', '\n') #return json.loads(f).get('text') class WechatService(object): """"""process request"""""" @staticmethod def processRequest(request): """"""process different message types. :param request: post request message :return: None """""" requestMap = MessageUtil.parseXml(request) fromUserName = requestMap.get(u'FromUserName') toUserName = requestMap.get(u'ToUserName') createTime = requestMap.get(u'CreateTime') msgType = requestMap.get(u'MsgType') msgId = requestMap.get(u'MsgId') textReply = TextReply() textReply.setToUserName(fromUserName) textReply.setFromUserName(toUserName) textReply.setCreateTime(time.time()) textReply.setMsgType(MessageUtil.RESP_MESSAGE_TYPE_TEXT) if msgType == MessageUtil.REQ_MESSAGE_TYPE_TEXT: content = requestMap.get('Content').decode('utf-8') # note: decode first #respContent = u'您发送的是文本消息:' + content respContent = RobotService.auto_reply(content) elif msgType == MessageUtil.REQ_MESSAGE_TYPE_IMAGE: respContent = u'您发送的是图片消息！' elif msgType == MessageUtil.REQ_MESSAGE_TYPE_VOICE: respContent = u'您发送的是语音消息！' elif msgType == MessageUtil.REQ_MESSAGE_TYPE_VIDEO: respContent = u'您发送的是视频消息！' elif msgType == MessageUtil.REQ_MESSAGE_TYPE_LOCATION: respContent = u'您发送的是地理位置消息！' elif msgType == MessageUtil.REQ_MESSAGE_TYPE_LINK: respContent = u'您发送的是链接消息！' elif msgType == MessageUtil.REQ_MESSAGE_TYPE_EVENT: eventType = requestMap.get(u'Event') if eventType == MessageUtil.EVENT_TYPE_SUBSCRIBE: respContent = u'^_^谢谢您的关注，本公众号由王宁宁开发(python2.7+django1.4),如果你有兴趣继续开发，' \ u'可以联系我，就当打发时间了.' elif eventType == MessageUtil.EVENT_TYPE_UNSUBSCRIBE: pass elif eventType == MessageUtil.EVENT_TYPE_SCAN: # TODO pass elif eventType == MessageUtil.EVENT_TYPE_LOCATION: # TODO pass elif eventType == MessageUtil.EVENT_TYPE_CLICK: # TODO pass textReply.setContent(respContent) respXml = MessageUtil.class2xml(textReply) return respXml """""" if msgType == 'text': content = requestMap.get('Content') # TODO elif msgType == 'image': picUrl = requestMap.get('PicUrl') # TODO elif msgType == 'voice': mediaId = requestMap.get('MediaId') format = requestMap.get('Format') # TODO elif msgType == 'video': mediaId = requestMap.get('MediaId') thumbMediaId = requestMap.get('ThumbMediaId') # TODO elif msgType == 'location': lat = requestMap.get('Location_X') lng = requestMap.get('Location_Y') label = requestMap.get('Label') scale = requestMap.get('Scale') # TODO elif msgType == 'link': title = requestMap.get('Title') description = requestMap.get('Description') url = requestMap.get('Url') """""" ",1 "contador da posição do numero, se é o primeiro, segundo etc; v = 5#representaria o len da lista; while(cont1 < v): x = int(input(""Informe o %dº numero inteiro para colocar em sua lista:\n""%cont2))#x e a variavel que recebe #o numero do usuario lista.append(x)#o numero informado para x e colocado dentro da lista; cont1+=1#Os contadores estao cont2+=1#sendo incrementados; print(""A lista de informada foi:\n%s""%lista) ",1 "from test import get_collector_config from test import unittest from mock import Mock from mock import patch try: from cStringIO import StringIO StringIO # workaround for pyflakes issue #13 except ImportError: from StringIO import StringIO from diamond.collector import Collector from filestat import FilestatCollector ################################################################################ class TestFilestatCollector(CollectorTestCase): def setUp(self): config = get_collector_config('FilestatCollector', { 'interval': 10 }) self.collector = FilestatCollector(config, None) def test_import(self): self.assertTrue(FilestatCollector) @patch('__builtin__.open') @patch('os.access', Mock(return_value=True)) @patch.object(Collector, 'publish') def test_should_open_proc_sys_fs_file_nr(self, publish_mock, open_mock): open_mock.return_value = StringIO('') self.collector.collect() open_mock.assert_called_once_with('/proc/sys/fs/file-nr') @patch.object(Collector, 'publish') def test_should_work_with_real_data(self, publish_mock): FilestatCollector.PROC = self.getFixturePath('proc_sys_fs_file-nr') self.collector.collect() metrics = { 'assigned': 576, 'unused': 0, 'max': 4835852 } self.setDocExample(collector=self.collector.__class__.__name__, metrics=metrics, defaultpath=self.collector.config['path']) self.assertPublishedMany(publish_mock, metrics) ################################################################################ if __name__ == ""__main__"": unittest.main() ",1 "rg/licenses/gpl-3.0.txt) # This is a virtual module that is entirely implemented as an action plugin and runs on the controller from __future__ import absolute_import, division, print_function __metaclass__ = type DOCUMENTATION = r''' --- module: fetch short_description: Fetch files from remote nodes description: - This module works like M(copy), but in reverse. - It is used for fetching files from remote machines and storing them locally in a file tree, organized by hostname. - Files that already exist at I(dest) will be overwritten if they are different than the I(src). - This module is also supported for Windows targets. version_added: '0.2' options: src: description: - The file on the remote system to fetch. - This I(must) be a file, not a directory. - Recursive fetching may be supported in a later release. required: yes dest: description: - A directory to save the file into. - For example, if the I(dest) directory is C(/backup) a I(src) file named C(/etc/profile) on host C(host.example.com), would be saved into C(/backup/host.example.com/etc/profile). The host name is based on the inventory name. required: yes fail_on_missing: version_added: '1.1' description: - When set to C(yes), the task will fail if the remote file cannot be read for any reason. - Prior to Ansible 2.5, setting this would only fail if the source file was missing. - The default was changed to C(yes) in Ansible 2.5. type: bool default: yes validate_checksum: version_added: '1.4' description: - Verify that the source and destination checksums match after the files are fetched. type: bool default: yes flat: version_added: '1.2' description: - Allows you to override the default behavior of appending hostname/path/to/file to the destination. - If C(dest) ends with '/', it will use the basename of the source file, similar to the copy module. - This can be useful if working with a single host, or if retrieving files that are uniquely named per host. - If using multiple hosts with the same filename, the file will be overwritten for each host. type: bool default: no notes: - When running fetch with C(become), the M(slurp) module will also be used to fetch the contents of the file for determining the remote checksum. This effectively doubles the transfer size, and depending on the file size can consume all available memory on the remote or local hosts causing a C(MemoryError). Due to this it is advisable to run this module without C(become) whenever possible. - Prior to Ansible 2.5 this module would not fail if reading the remote file was impossible unless C(fail_on_missing) was set. - In Ansible 2.5 or later, playbook authors are encouraged to use C(fail_when) or C(ignore_errors) to get this ability. They may also explicitly set C(fail_on_missing) to C(no) to get the non-failing behaviour. - This module is also supported for Windows targets. seealso: - module: copy - module: slurp author: - Ansible Core Team - Michael DeHaan ''' EXAMPLES = r''' - name: Store file into /tmp/fetched/host.example.com/tmp/somefile fetch: src: /tmp/somefile dest: /tmp/fetched - name: Specifying a path directly fetch: src: /tmp/somefile dest: /tmp/prefix-{{ inventory_hostname }} flat: yes - name: Specifying a destination path fetch: src: /tmp/uniquefile dest: /tmp/special/ flat: yes - name: Storing in a path relative to the playbook fetch: src: /tmp/uniquefile dest: special/prefix-{{ inventory_hostname }} flat: yes ''' ",1 "import AdminSite from django.http import HttpRequest import mock from course_creators.admin import CourseCreatorAdmin from course_creators.models import CourseCreator from django.core import mail from student.roles import CourseCreatorRole from student import auth def mock_render_to_string(template_name, context): """"""Return a string that encodes template_name and context"""""" return str((template_name, context)) class CourseCreatorAdminTest(TestCase): """""" Tests for course creator admin. """""" def setUp(self): """""" Test case setup """""" super(CourseCreatorAdminTest, self).setUp() self.user = User.objects.create_user('test_user', 'test_user+courses@edx.org', 'foo') self.table_entry = CourseCreator(user=self.user) self.table_entry.save() self.admin = User.objects.create_user('Mark', 'admin+courses@edx.org', 'foo') self.admin.is_staff = True self.request = HttpRequest() self.request.user = self.admin self.creator_admin = CourseCreatorAdmin(self.table_entry, AdminSite()) self.studio_request_email = 'mark@marky.mark' self.enable_creator_group_patch = { ""ENABLE_CREATOR_GROUP"": True, ""STUDIO_REQUEST_EMAIL"": self.studio_request_email } @mock.patch('course_creators.admin.render_to_string', mock.Mock(side_effect=mock_render_to_string, autospec=True)) @mock.patch('django.contrib.auth.models.User.email_user') def test_change_status(self, email_user): """""" Tests that updates to state impact the creator group maintained in authz.py and that e-mails are sent. """""" def change_state_and_verify_email(state, is_creator): """""" Changes user state, verifies creator status, and verifies e-mail is sent based on transition """""" self._change_state(state) self.assertEqual(is_creator, auth.user_has_role(self.user, CourseCreatorRole())) context = {'studio_request_email': self.studio_request_email} if state == CourseCreator.GRANTED: template = 'emails/course_creator_granted.txt' elif state == CourseCreator.DENIED: template = 'emails/course_creator_denied.txt' else: template = 'emails/course_creator_revoked.txt' email_user.assert_called_with( mock_render_to_string('emails/course_creator_subject.txt', context), mock_render_to_string(template, context), self.studio_request_email ) with mock.patch.dict('django.conf.settings.FEATURES', self.enable_creator_group_patch): # User is initially unrequested. self.assertFalse(auth.user_has_role(self.user, CourseCreatorRole())) change_state_and_verify_email(CourseCreator.GRANTED, True) change_state_and_verify_email(CourseCreator.DENIED, False) change_state_and_verify_email(CourseCreator.GRANTED, True) change_state_and_verify_email(CourseCreator.PENDING, False) change_state_and_verify_email(CourseCreator.GRANTED, True) change_state_and_verify_email(CourseCreator.UNREQUESTED, False) change_state_and_verify_email(CourseCreator.DENIED, False) @mock.patch('course_creators.admin.render_to_string', mock.Mock(side_effect=mock_render_to_string, autospec=True)) def test_mail_admin_on_pending(self): """""" Tests that the admin account is notified when a user is in the 'pending' state. """""" def check_admin_message_state(state, expect_sent_to_admin, expect_sent_to_user): """""" Changes user state and verifies e-mail sent to admin address only when pending. """""" mail.outbox = [] self._change_state(state) # If a message is sent to the user about course creator status change, it will be the first # message sent. Admin message will follow. base_num_emails = 1 if expect_sent_to_user else 0 if expect_sent_to_admin: context = {'user_name': ""test_user"", 'user_email': u'test_user+courses@edx.org'} self.assertEquals(base_num_emails + 1, len(mail.outbox), 'Expected admin message to be sent') sent_mail = mail.outbox[base_num_emails] self.assertEquals( mock_render_to_string('emails/course_creator_admin_subject.txt', context), sent_mail.subject ) self.assertEquals( mock_render_to_string('emails/course_creator_admin_user_pending.txt', context), sent_mail.body ) self.assertEquals(self.studio_request_email, sent_mail.from_email) self.assertEqual([self.studio_request_email], sent_mail.to) else: self.assertEquals(base_num_emails, len(mail.outbox)) with mock.patch.dict('django.conf.settings.FEATURES', self.enable_creator_group_patch): # E-mail message should be sent to admin only when new state is PENDING, regardless of what # previous state was (unless previous state was already PENDING). # E-mail message sent to user only on transition into and out of GRANTED state. check_admin_message_state(CourseCreator.UNREQUESTED, expect_sent_to_admin=False, expect_sent_to_user=False) check_admin_message_state(CourseCreator.PENDING, expect_sent_to_admin=True, expect_sent_to_user=False) check_admin_message_state(CourseCreator.GRANTED, expect_sent_to_admin=False, expect_sent_to_user=True) check_admin_message_state(CourseCreator.DENIED, expect_sent_to_admin=False, expect_sent_to_user=True) check_admin_message_state(CourseCreator.GRANTED, expect_sent_to_admin=False, expect_sent_to_user=True) check_admin_message_state(CourseCreator.PENDING, expect_sent_to_admin=True, expect_sent_to_user=True) check_admin_message_state(CourseCreator.PENDING, expect_sent_to_admin=False, expect_sent_to_user=False) check_admin_message_state(CourseCreator.DENIED, expect_sent_to_admin=False, expect_sent_to_user=True) def _change_state(self, state): """""" Helper method for changing state """""" self.table_entry.state = state self.creator_admin.save_model(self.request, self.table_entry, None, True) def test_add_permission(self): """""" Tests that staff cannot add entries """""" self.assertFalse(self.creator_admin.has_add_permission(self.request)) def test_delete_permission(self): """""" Tests that staff cannot delete entries """""" self.assertFalse(self.creator_admin.has_delete_permission(self.request)) def test_change_permission(self): """""" Tests that only staff can change entries """""" self.assertTrue(self.creator_admin.has_change_permission(self.request)) self.request.user = self.user self.assertFalse(self.creator_admin.has_change_permission(self.request)) ",1 "odification, 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. # 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. import unittest from webkitpy.common import lru_cache class LRUCacheTest(unittest.TestCase): def setUp(self): self.lru = lru_cache.LRUCache(3) self.lru['key_1'] = 'item_1' self.lru['key_2'] = 'item_2' self.lru['key_3'] = 'item_3' self.lru2 = lru_cache.LRUCache(1) self.lru2['key_1'] = 'item_1' def test_items(self): self.assertEqual(set(self.lru.items()), set([('key_1', 'item_1'), ('key_3', 'item_3'), ('key_2', 'item_2')])) def test_put(self): self.lru['key_4'] = 'item_4' self.assertEqual(set(self.lru.items()), set([('key_4', 'item_4'), ('key_3', 'item_3'), ('key_2', 'item_2')])) def test_update(self): self.lru['key_1'] self.lru['key_5'] = 'item_5' self.assertEqual(set(self.lru.items()), set([('key_1', 'item_1'), ('key_3', 'item_3'), ('key_5', 'item_5')])) def test_keys(self): self.assertEqual(set(self.lru.keys()), set(['key_1', 'key_2', 'key_3'])) def test_delete(self): del self.lru['key_1'] self.assertFalse('key_1' in self.lru) def test_contain(self): self.assertTrue('key_1' in self.lru) self.assertFalse('key_4' in self.lru) def test_values(self): self.assertEqual(set(self.lru.values()), set(['item_1', 'item_2', 'item_3'])) def test_len(self): self.assertEqual(len(self.lru), 3) def test_size_one_pop(self): self.lru2['key_2'] = 'item_2' self.assertEqual(self.lru2.keys(), ['key_2']) def test_size_one_delete(self): del self.lru2['key_1'] self.assertFalse('key_1' in self.lru2) def test_pop_error(self): self.assertRaises(KeyError, self.lru2.__getitem__, 'key_2') del self.lru2['key_1'] self.assertRaises(KeyError, self.lru2.__getitem__, 'key_2') def test_get_middle_item(self): self.lru['key_2'] self.lru['key_4'] = 'item_4' self.lru['key_5'] = 'item_5' self.assertEqual(set(self.lru.keys()), set(['key_2', 'key_4', 'key_5'])) def test_set_again(self): self.lru['key_1'] = 'item_4' self.assertEqual(set(self.lru.items()), set([('key_1', 'item_4'), ('key_3', 'item_3'), ('key_2', 'item_2')])) if __name__ == ""__main__"": unittest.main() ",1 "ics.message as message APP_ID = 'SbrApiServices' PROCESSING_ID = 'RbAppConversationApi' # 会話メッセージ # class ConversationMessage(message.CRFXMessage): def __init__(self, visitor, visitor_id, talkByMe, type): super(ConversationMessage, self).__init__() self.header['RoutingType'] = message.ROUTING_TYPE_CALL self.header['AppProcessingId'] = PROCESSING_ID self.header['MessageId'] = type self.body = { 'visitor': visitor, 'visitor_id': visitor_id, 'talkByMe': talkByMe } ",1 "cgi/public/reportlab/trunk/reportlab/lib/formatters.py __all__=('Formatter','DecimalFormatter') __version__=''' $Id: formatters.py 3959 2012-09-27 14:39:39Z robin $ ''' __doc__="""""" These help format numbers and dates in a user friendly way. Used by the graphics framework. """""" import string, sys, os, re class Formatter: ""Base formatter - simply applies python format strings"" def __init__(self, pattern): self.pattern = pattern def format(self, obj): return self.pattern % obj def __repr__(self): return ""%s('%s')"" % (self.__class__.__name__, self.pattern) def __call__(self, x): return self.format(x) _ld_re=re.compile(r'^\d*\.') _tz_re=re.compile('0+$') class DecimalFormatter(Formatter): """"""lets you specify how to build a decimal. A future NumberFormatter class will take Microsoft-style patterns instead - ""$#,##0.00"" is WAY easier than this."""""" def __init__(self, places=2, decimalSep='.', thousandSep=None, prefix=None, suffix=None): if places=='auto': self.calcPlaces = self._calcPlaces else: self.places = places self.dot = decimalSep self.comma = thousandSep self.prefix = prefix self.suffix = suffix def _calcPlaces(self,V): '''called with the full set of values to be formatted so we can calculate places''' self.places = max([len(_tz_re.sub('',_ld_re.sub('',str(v)))) for v in V]) def format(self, num): # positivize the numbers sign=num<0 if sign: num = -num places, sep = self.places, self.dot strip = places<=0 if places and strip: places = -places strInt = ('%.' + str(places) + 'f') % num if places: strInt, strFrac = strInt.split('.') strFrac = sep + strFrac if strip: while strFrac and strFrac[-1] in ['0',sep]: strFrac = strFrac[:-1] else: strFrac = '' if self.comma is not None: strNew = '' while strInt: left, right = strInt[0:-3], strInt[-3:] if left == '': #strNew = self.comma + right + strNew strNew = right + strNew else: strNew = self.comma + right + strNew strInt = left strInt = strNew strBody = strInt + strFrac if sign: strBody = '-' + strBody if self.prefix: strBody = self.prefix + strBody if self.suffix: strBody = strBody + self.suffix return strBody def __repr__(self): return ""%s(places=%d, decimalSep=%s, thousandSep=%s, prefix=%s, suffix=%s)"" % ( self.__class__.__name__, self.places, repr(self.dot), repr(self.comma), repr(self.prefix), repr(self.suffix) ) if __name__=='__main__': def t(n, s, places=2, decimalSep='.', thousandSep=None, prefix=None, suffix=None): f=DecimalFormatter(places,decimalSep,thousandSep,prefix,suffix) r = f(n) print(""places=%2d dot=%-4s comma=%-4s prefix=%-4s suffix=%-4s result=%10s %s"" %(f.places, f.dot, f.comma, f.prefix, f.suffix,r, r==s and 'OK' or 'BAD')) t(1000.9,'1,000.9',1,thousandSep=',') t(1000.95,'1,001.0',1,thousandSep=',') t(1000.95,'1,001',-1,thousandSep=',') t(1000.9,'1,001',0,thousandSep=',') t(1000.9,'1000.9',1) t(1000.95,'1001.0',1) t(1000.95,'1001',-1) t(1000.9,'1001',0) t(1000.1,'1000.1',1) t(1000.55,'1000.6',1) t(1000.449,'1000.4',-1) t(1000.45,'1000',0) ",1 "can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either # version 2.1 of the License, or (at your option) any later version. # This library 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 # Lesser General Public License for more details. # # You should have received a copy of the GNU Lesser General Public # License along with this library; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA from JoeAgent import job, event import db_interface import os, os.path import logging import log_parser LINEINCR = 30 log = logging.getLogger(""agent.LogReader"") class ReadLogCompleteEvent(event.Event): """"""Event to indicate the file is completely read. This event will be caught by the FindLogJob that is watching it. The file will continue to be checked for modifications"""""" pass class ReadLogContinueEvent(event.Event): """"""Event to indicate we should continue reading the file. Log file processing will be done in chunks so as not to block the agent for too long."""""" pass class ReadLogJob(job.Job): def __init__(self, agent_obj, logfile): job.Job.__init__(self, agent_obj) assert os.path.isfile(logfile), ""Not a file: %s"" % str(logfile) self._log_size = os.stat(logfile).st_size log.debug(""Log size is %d"" % self._log_size) self._logfile_path = logfile self._logfile_hndl = open(logfile, 'r') self._progress = 0 # Data read from file self._db = db_interface.getDB() def getFilePath(self): return self._logfile_path def getBytesRead(self): return self._progress def getBytesTotal(self): return self._log_size def run(self): evt = ReadLogContinueEvent(self) self.getAgent().addEvent(evt) def notify(self, evt): job.Job.notify(self, evt) if isinstance(evt, ReadLogContinueEvent) and evt.getSource() == self: log.debug(""Continuing read of file"") # Continue to read the log try: self._progress += log_parser.read_log( self._logfile_hndl, self._db, LINEINCR) log.debug(""Read %d %% of file (%d / %d)"" % (self.getProgress(), self._progress, self._log_size)) except log_parser.EndOfLogException, e: self._progress = self._log_size # Log file is complete, updated the db entry self._mark_complete() # Add an event to notify that the file is complete self._logfile_hndl.close() new_evt = ReadLogCompleteEvent(self) self.getAgent().addEvent(new_evt) except log_parser.InvalidLogException, e: log.warning(""Invalid log file: %s"" % str(e)) self._logfile_hndl.close() new_evt = ReadLogCompleteEvent(self) self.getAgent().addEvent(new_evt) else: # Add an event to continue reading new_evt = ReadLogContinueEvent(self) self.getAgent().addEvent(new_evt) def _update_db(self): """"""Update the entry in the database for this logfile"""""" log.debug(""Updating file %s"" % self._logfile_path) pass def _mark_invalid(self): """"""Update the database to indicate that this is not a valid log file"""""" log.debug(""Marking file %s invalid"" % self._logfile_path) pass def _mark_complete(self): log.debug(""Marking file %s complete"" % self._logfile_path) pass def getProgress(self): """"""Return a percentage complete value"""""" if self._log_size == 0: return 0 return int((float(self._progress) / self._log_size) * 100) ",1 "t SplashScreen, SPLASH_CENTRE_ON_SCREEN, SPLASH_TIMEOUT import os import sys import warnings from . import zpickle from .utils import * from .dialogs.waxy import * from .dialogs import * from .run_sim import * import threading import pylab gray=pylab.cm.gray from matplotlib.backends.backend_wxagg import FigureCanvasWx as FigureCanvas from matplotlib.backends.backend_wx import FigureManager from matplotlib.figure import Figure from matplotlib.axes import Subplot class SimThread(threading.Thread): def __init__(self,params,parent): self.params=params self.parent=parent threading.Thread.__init__(self); def run(self): run_sim(self.params,self.parent) def subplot(*args): import pylab if len(args)==1: return pylab.subplot(args[0]) elif len(args)==3: return pylab.subplot(args[0],args[1],args[2]) elif len(args)==4: r=args[2] c=args[3] return pylab.subplot(args[0],args[1],c+(r-1)*args[1]); else: raise ValueError(""invalid number of arguments"") class MainFrame(Frame): def __init__(self,parent=None,title='',direction='H', size=(750,750),lfname=None,params=None): self.fig=None # turn off security warning on tmpnam. why is it here? warnings.filterwarnings('ignore') fname=os.tempnam() warnings.resetwarnings() self.base_dir=os.path.dirname(__file__) if not self.base_dir: self.base_dir='.' self.tmpfile=fname+""_plasticity.dat"" self.modified=False self.running=False self.stopping=False self.quitting=False self.plot_first=False if not params: self.params=default_params() else: self.params=params for p in self.params['pattern_input']: if not os.path.exists(p['filename']): p['filename']=self.base_dir+""/""+p['filename'] if lfname: if not self.__load_sim__(lfname): self.plot_first=True Frame.__init__(self,parent,title,direction,size) def Body(self): self.CreateMenu() self.CenterOnScreen() self.ResetTitle() fname=self.base_dir+""/images/plasticity_small_icon.ico"" self.SetIcon(fname) self.fig = Figure(figsize=(7,5),dpi=100) self.canvas = FigureCanvas(self, -1, self.fig) self.figmgr = FigureManager(self.canvas, 1, self) self.axes = [self.fig.add_subplot(221), self.fig.add_subplot(222), self.fig.add_subplot(223), self.fig.add_subplot(224)] if self.plot_first: sim=zpickle.load(self.tmpfile) sim['params']['display']=True self.Plot(sim) def Stopping(self): return self.stopping def Yield(self): wx.Yield() def ResetTitle(self): (root,sfname)=os.path.split(self.params['save_sim_file']) if self.modified: s=' (*)' else: s='' title='Plasticity: %s%s' % (sfname,s) self.SetTitle(title) def Plot(self,sim): if not sim['params']['display']: return if sim['params']['display_module']: try: module=__import__(sim['params']['display_module'],fromlist=['UserPlot']) except ImportError: sim['params']['display']=False dlg = MessageDialog(self, ""Error"",""Error in Import: %s. Turning display off"" % sim['params']['display_module'], icon='error') dlg.ShowModal() dlg.Destroy() return try: module.UserPlot(self,sim) return except ValueError: sim['params']['display']=False dlg = MessageDialog(self, ""Error"",""Error in display. Turning display off"", icon='error') dlg.ShowModal() dlg.Destroy() return try: im=weights2image(sim['params'],sim['weights']) self.axes[0].hold(False) self.axes[0].set_axis_bgcolor('k') self.axes[0].pcolor(im,cmap=gray,edgecolors='k') self.axes[0].set_aspect('equal') num_moments=sim['moments_mat'].shape[0] self.axes[1].hold(False) num_neurons=sim['moments_mat'].shape[1] for k in range(num_neurons): for i in range(num_moments): self.axes[1].plot(sim['moments_mat'][i,k,:],'-o') self.axes[1].hold(True) self.axes[2].hold(False) response_mat=sim['response_mat'] response_var_list=sim['response_var_list'] styles=['b-o','g-o'] for i,r in enumerate(response_var_list[-1]): x=r[1] y=r[2] self.axes[2].plot(x,y,styles[i]) self.axes[2].hold(True) self.axes[3].hold(False) styles=['b-o','g-o'] for i,r in enumerate(response_mat): self.axes[3].plot(r,styles[i]) self.axes[3].hold(True) self.canvas.draw() self.canvas.gui_repaint() except ValueError: sim['params']['display']=False dlg = MessageDialog(self, ""Error"",""Error in display. Turning display off"", icon='error') dlg.ShowModal() dlg.Destroy() def Run_Pause(self,event): if not self.running: # pylab.close() self.params['tmpfile']=self.tmpfile if os.path.exists(self.tmpfile): self.params['continue']=1 self.modified=True self.ResetTitle() self.running=True ## d={} ## d['params']=self.params ## zpickle.save(d,'plasticity_tmpparams.dat') ## cmd='./run_sim.py --paramfile plasticity_tmpparams.dat --from_gui 1' ## os.system(cmd) self.stopping=False run_sim(self.params,self) self.params['load_sim_file']=self.tmpfile self.running=False if self.quitting: self.Quit() else: self.stopping=True def __load_sim__(self,lfname): sim=zpickle.load(lfname) params=sim['params'] params['save_sim_file']=self.params['save_sim_file'] params['load_sim_file']='' params['continue']=False try: params['initial_weights']=sim['weights'] params['initial_moments']=sim['moments'] except KeyError: self.params=params return 1 params['load_sim_file']=self.tmpfile params['continue']=True sim['params']=params self.params=params zpickle.save(sim,self.tmpfile) return 0 def Reset_Simulation(self,event=None): if not os.path.exists(self.tmpfile): return self.canvas.Show(False) if self.modified: (root,sfname)=os.path.split(self.params['save_sim_file']) dlg=MessageDialog(self, text=""Do you want to save the changes you made to %s?"" % sfname, title=""Reset"", ok=0, yes_no=1,cancel=1) result=dlg.ShowModal() dlg.Destroy() if result == 'cancel': self.canvas.Show(True) return elif result == 'yes': filename=self.Save_Simulation() if not filename: # cancelled the save self.canvas.Show(True) return self.params['continue']=False self.params['load_sim_file']='' self.params['initial_weights']=[] self.params['initial_moments']=[] for a in self.axes: a.cla() self.canvas.draw() self.canvas.Show(True) def Restart(self,event=None): if not os.path.exists(self.tmpfile): return self.canvas.Show(False) if self.modified: (root,sfname)=os.path.split(self.params['save_sim_file']) dlg=MessageDialog(self, text=""Do you want to save the changes you made to %s?"" % sfname, title=""Restart"", ok=0, yes_no=1,cancel=1) result=dlg.ShowModal() dlg.Destroy() if result == 'cancel': self.canvas.Show(True) return elif result == 'yes': filename=self.Save_Simulation() if not filename: # cancelled the save self.canvas.Show(True) return self.__load_sim__(self.tmpfile) self.params['continue']=False self.canvas.Show(True) def Load_Simulation(self,event=None): self.canvas.Show(False) if self.modified: (root,sfname)=os.path.split(self.params['save_sim_file']) dlg=MessageDialog(self, text=""Do you want to save the changes you made to %s?"" % sfname, title=""Load Simulation"", ok=0, yes_no=1,cancel=1) result=dlg.ShowModal() dlg.Destroy() if result == 'cancel': pass elif result == 'yes': self.Save_Simulation() lfname='' dlg = FileDialog(self, ""Load Simulation"",default_dir=os.getcwd()+""/sims"", wildcard='DAT Files|*.dat|All Files|*.*') result = dlg.ShowModal() if result == 'ok': lfname = dlg.GetPaths()[0] dlg.Destroy() if not lfname: self.canvas.Show(True) return self.__load_sim__(lfname) sim=zpickle.load(self.tmpfile) self.Plot(sim) self.canvas.Show(True) def Save_Simulation(self,event=None): if not self.modified: return sfname=self.params['save_sim_file'] def_sfname=default_params()['save_sim_file'] if sfname==def_sfname: filename=self.Save_Simulation_As() else: filename=sfname d=zpickle.load(self.tmpfile) d['params']=self.params zpickle.save(d,sfname) self.modified=False self.ResetTitle() return filename def Save_Simulation_As(self,event=None): self.canvas.Show(False) dlg = FileDialog(self, ""Save Simulation As..."",default_dir=os.getcwd()+""/sims/"", wildcard='DAT Files|*.dat|All Files|*.*',save=1) result = dlg.ShowModal() if result == 'ok': filename = dlg.GetPaths()[0] else: filename=None dlg.Destroy() if filename: d=zpickle.load(self.tmpfile) self.params['save_sim_file']=filename d['params']=self.params zpickle.save(d,filename) self.modified=False self.ResetTitle() self.canvas.Show(True) return filename def Set_Simulation_Parameters(self,event): self.canvas.Show(False) set_simulation_parameters(self.params,self) self.canvas.Show(True) def Set_Input_Parameters(self,event): self.canvas.Show(False) set_input_parameters(self.params,self) self.canvas.Show(True) def Set_Output_Parameters(self,event): self.canvas.Show(False) set_output_parameters(self.params,self) self.canvas.Show(True) def Set_Weight_Parameters(self,event): self.canvas.Show(False) set_weight_parameters(self.params,self) self.canvas.Show(True) def Save_Parameters_As(self,event): save_parameters_as(self.params,self) def Set_Parameter_Structure(self,event): set_parameter_structure(self.params,self) def Load_Parameters(self,event): p=load_parameters(None,self) if p: self.params=p def CreateMenu(self): menubar = MenuBar() menu = Menu(self) menu.Append(""L&oad State"", self.Load_Simulation, ""Load a Complete Simulation"",hotkey=""Ctrl+O"") menu.Append(""Load &Parameters"", self.Load_Parameters, ""Load Simulation Parameters"") menu.AppendSeparator() menu.Append(""Save Parameters As..."", self.Save_Parameters_As, ""Save Simulation Parameters"") menu.Append(""Save State As..."", self.Save_Simulation_As, ""Save a Complete Simulation"") menu.Append(""Save State"", self.Save_Simulation, ""Save a Complete Simulation"",hotkey=""Ctrl+S"") menu.AppendSeparator() menu.Append(""&Run/Pause"", self.Run_Pause, ""Run a Simulation"",hotkey=""Ctrl+P"") menu.Append(""Restart from Current State"", self.Restart) menu.Append(""Reset Simulation"", self.Reset_Simulation,hotkey=""Ctrl+R"") menu.AppendSeparator() menu.Append(""Export Figure..."", self.Export, ""Export the Screen"") menu.Append(""&Quit"", self.Quit, ""Quit"",hotkey=""Ctrl+Q"") menubar.Append(menu, ""&File"") menu = Menu(self) menu.Append(""&Simulation Parameters"", self.Set_Simulation_Parameters) menu.Append(""&Input Parameters"", self.Set_Input_Parameters) menu.Append(""&Output Neuron Parameters"", self.Set_Output_Parameters) menu.Append(""&Weight Parameters"", self.Set_Weight_Parameters) menu.AppendSeparator() menu.Append(""&Display"", self.Display) menu.Append(""Make &New Input Files"", self.Nop) menu.Append(""Parameter Structure"", self.Set_Parameter_Structure) menubar.Append(menu, ""&Edit"") menu=Menu(self) menu.Append(""&Help"", self.Nop) menu.Append(""&About"", self.About) menubar.Append(menu, ""&Help"") self.SetMenuBar(menubar) self.CreateStatusBar() def Display(self,event=None): self.canvas.Show(False) dlg = FileDialog(self, ""Choose Display Module"",default_dir=os.getcwd()+""/"", wildcard='Python Plot Files|plot*.py|All Files|*.*') result = dlg.ShowModal() dlg.Destroy() if result == 'ok': lfname = dlg.GetPaths()[0] modulename=os.path.splitext(os.path.split(lfname)[-1])[0] self.params['display_module']=modulename if os.path.exists(self.tmpfile): sim=zpickle.load(self.tmpfile) self.Plot(sim) self.canvas.Show(True) def About(self,event): win=AboutWindow() win.Show() def Nop(self,event): self.canvas.Show(False) dlg = MessageDialog(self, ""Error"",""Function Not Implemented"",icon='error') dlg.ShowModal() dlg.Destroy() self.canvas.Show(True) def Export(self,event=None): export_fig(self) def Quit(self,event=None): if self.running: self.quitting=True self.stopping=True return self.canvas.Show(False) if self.modified: (root,sfname)=os.path.split(self.params['save_sim_file']) dlg=MessageDialog(self, text=""Do you want to save the changes you made to %s?"" % sfname, title=""Quit"", ok=0, yes_no=1,cancel=1) result=dlg.ShowModal() dlg.Destroy() if result == 'cancel': self.canvas.Show(True) return elif result == 'yes': self.Save_Simulation() self.Close() if os.path.exists(self.tmpfile): os.remove(self.tmpfile) def run(lfname=None,params=None,use_splash=True): if use_splash: app1=Application(splash.SplashFrame) app1.Run() app = Application(MainFrame, title=""Plasticity"",lfname=lfname, params=params) app.Run() if __name__ == '__main__': from optparse import OptionParser parser = OptionParser() parser.add_option( ""--nosplash"", action=""store_false"", dest=""splash"", default=True, help=""don't show the splash screen"") (options, args) = parser.parse_args() if options.splash: app1=Application(splash.SplashFrame) app1.Run() if len(args)>=1: lfname=args[0] else: lfname=None run(lfname) ",1 " to send emails - Use MEMCACHIER on Heroku ''' from configurations import values # See: http://django-storages.readthedocs.org/en/latest/backends/amazon-S3.html#settings try: from S3 import CallingFormat AWS_CALLING_FORMAT = CallingFormat.SUBDOMAIN except ImportError: # TODO: Fix this where even if in Dev this class is called. pass from .common import Common class Production(Common): # This ensures that Django will be able to detect a secure connection # properly on Heroku. SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTO', 'https') # INSTALLED_APPS INSTALLED_APPS = Common.INSTALLED_APPS # END INSTALLED_APPS # SECRET KEY SECRET_KEY = values.SecretValue() # END SECRET KEY # django-secure INSTALLED_APPS += (""djangosecure"", ) # set this to 60 seconds and then to 518400 when you can prove it works SECURE_HSTS_SECONDS = 60 SECURE_HSTS_INCLUDE_SUBDOMAINS = values.BooleanValue(True) SECURE_FRAME_DENY = values.BooleanValue(True) SECURE_CONTENT_TYPE_NOSNIFF = values.BooleanValue(True) SECURE_BROWSER_XSS_FILTER = values.BooleanValue(True) SESSION_COOKIE_SECURE = values.BooleanValue(False) SESSION_COOKIE_HTTPONLY = values.BooleanValue(True) SECURE_SSL_REDIRECT = values.BooleanValue(True) # end django-secure # SITE CONFIGURATION # Hosts/domain names that are valid for this site # See https://docs.djangoproject.com/en/1.6/ref/settings/#allowed-hosts ALLOWED_HOSTS = [""*""] # END SITE CONFIGURATION INSTALLED_APPS += (""gunicorn"", ) # STORAGE CONFIGURATION # See: http://django-storages.readthedocs.org/en/latest/index.html INSTALLED_APPS += ( 'storages', ) # See: http://django-storages.readthedocs.org/en/latest/backends/amazon-S3.html#settings STATICFILES_STORAGE = DEFAULT_FILE_STORAGE = 'storages.backends.s3boto.S3BotoStorage' # See: http://django-storages.readthedocs.org/en/latest/backends/amazon-S3.html#settings AWS_ACCESS_KEY_ID = values.SecretValue() AWS_SECRET_ACCESS_KEY = values.SecretValue() AWS_STORAGE_BUCKET_NAME = values.SecretValue() AWS_AUTO_CREATE_BUCKET = True AWS_QUERYSTRING_AUTH = False # see: https://github.com/antonagestam/collectfast AWS_PRELOAD_METADATA = True INSTALLED_APPS += ('collectfast', ) # AWS cache settings, don't change unless you know what you're doing: AWS_EXPIRY = 60 * 60 * 24 * 7 AWS_HEADERS = { 'Cache-Control': 'max-age=%d, s-maxage=%d, must-revalidate' % ( AWS_EXPIRY, AWS_EXPIRY) } # See: https://docs.djangoproject.com/en/dev/ref/settings/#static-url STATIC_URL = 'https://s3.amazonaws.com/%s/' % AWS_STORAGE_BUCKET_NAME # END STORAGE CONFIGURATION # EMAIL DEFAULT_FROM_EMAIL = values.Value('tco2
%s
''' % (style, content)
return file
class HistoryOtherFile(OtherFile):
def __init__(self, path, environ, item):
super(HistoryOtherFile, self).__init__(path, environ, item)
self.content = self.design(self.item.item_content)
def __repr__(self):
return ""File history: %s-%s"" % (self.item.item_name, self.item.id)
def getDisplayName(self):
return str(self.item.id) + '-' + self.item.item_name
def beginWrite(self, contentType=None):
raise DAVError(HTTP_FORBIDDEN)
def delete(self):
raise DAVError(HTTP_FORBIDDEN)
def handleDelete(self):
return True
def handleCopy(self, destPath, depthInfinity):
return True
def handleMove(self, destPath):
return True
def copyMoveSingle(self, destpath, ismove):
raise DAVError(HTTP_FORBIDDEN)
",1
"_future__ import unicode_literals
import frappe
from frappe import _
from frappe.utils import flt, add_months, cint, nowdate, getdate
from frappe.model.document import Document
from erpnext.accounts.doctype.purchase_invoice.purchase_invoice import get_fixed_asset_account
from erpnext.accounts.doctype.asset.depreciation \
import get_disposal_account_and_cost_center, get_depreciation_accounts
class Asset(Document):
def validate(self):
self.status = self.get_status()
self.validate_item()
self.set_missing_values()
self.validate_asset_values()
self.make_depreciation_schedule()
self.set_accumulated_depreciation()
if self.get(""schedules""):
self.validate_expected_value_after_useful_life()
# Validate depreciation related accounts
get_depreciation_accounts(self)
def on_submit(self):
self.set_status()
def on_cancel(self):
self.validate_cancellation()
self.delete_depreciation_entries()
self.set_status()
def validate_item(self):
item = frappe.db.get_value(""Item"", self.item_code,
[""is_fixed_asset"", ""is_stock_item"", ""disabled""], as_dict=1)
if not item:
frappe.throw(_(""Item {0} does not exist"").format(self.item_code))
elif item.disabled:
frappe.throw(_(""Item {0} has been disabled"").format(self.item_code))
elif not item.is_fixed_asset:
frappe.throw(_(""Item {0} must be a Fixed Asset Item"").format(self.item_code))
elif item.is_stock_item:
frappe.throw(_(""Item {0} must be a non-stock item"").format(self.item_code))
def set_missing_values(self):
if self.item_code:
item_details = get_item_details(self.item_code)
for field, value in item_details.items():
if not self.get(field):
self.set(field, value)
self.value_after_depreciation = (flt(self.gross_purchase_amount) -
flt(self.opening_accumulated_depreciation))
def validate_asset_values(self):
if flt(self.expected_value_after_useful_life) >= flt(self.gross_purchase_amount):
frappe.throw(_(""Expected Value After Useful Life must be less than Gross Purchase Amount""))
if not flt(self.gross_purchase_amount):
frappe.throw(_(""Gross Purchase Amount is mandatory""), frappe.MandatoryError)
if not self.is_existing_asset:
self.opening_accumulated_depreciation = 0
self.number_of_depreciations_booked = 0
if not self.next_depreciation_date:
frappe.throw(_(""Next Depreciation Date is mandatory for new asset""))
else:
depreciable_amount = flt(self.gross_purchase_amount) - flt(self.expected_value_after_useful_life)
if flt(self.opening_accumulated_depreciation) > depreciable_amount:
frappe.throw(_(""Opening Accumulated Depreciation must be less than equal to {0}"")
.format(depreciable_amount))
if self.opening_accumulated_depreciation:
if not self.number_of_depreciations_booked:
frappe.throw(_(""Please set Number of Depreciations Booked""))
else:
self.number_of_depreciations_booked = 0
if cint(self.number_of_depreciations_booked) > cint(self.total_number_of_depreciations):
frappe.throw(_(""Number of Depreciations Booked cannot be greater than Total Number of Depreciations""))
if self.next_depreciation_date and getdate(self.next_depreciation_date) < getdate(nowdate()):
frappe.msgprint(_(""Next Depreciation Date is entered as past date""), title=_('Warning'), indicator='red')
if self.next_depreciation_date and getdate(self.next_depreciation_date) < getdate(self.purchase_date):
frappe.throw(_(""Next Depreciation Date cannot be before Purchase Date""))
if (flt(self.value_after_depreciation) > flt(self.expected_value_after_useful_life)
and not self.next_depreciation_date):
frappe.throw(_(""Please set Next Depreciation Date""))
def make_depreciation_schedule(self):
if self.depreciation_method != 'Manual':
self.schedules = []
if not self.get(""schedules"") and self.next_depreciation_date:
value_after_depreciation = flt(self.value_after_depreciation)
number_of_pending_depreciations = cint(self.total_number_of_depreciations) - \
cint(self.number_of_depreciations_booked)
if number_of_pending_depreciations:
for n in xrange(number_of_pending_depreciations):
schedule_date = add_months(self.next_depreciation_date,
n * cint(self.frequency_of_depreciation))
depreciation_amount = self.get_depreciation_amount(value_after_depreciation)
value_after_depreciation -= flt(depreciation_amount)
self.append(""schedules"", {
""schedule_date"": schedule_date,
""depreciation_amount"": depreciation_amount
})
def set_accumulated_depreciation(self):
accumulated_depreciation = flt(self.opening_accumulated_depreciation)
value_after_depreciation = flt(self.value_after_depreciation)
for i, d in enumerate(self.get(""schedules"")):
depreciation_amount = flt(d.depreciation_amount, d.precision(""depreciation_amount""))
value_after_depreciation -= flt(depreciation_amount)
if i==len(self.get(""schedules""))-1 and self.depreciation_method == ""Straight Line"":
depreciation_amount += flt(value_after_depreciation - flt(self.expected_value_after_useful_life),
d.precision(""depreciation_amount""))
d.depreciation_amount = depreciation_amount
accumulated_depreciation += d.depreciation_amount
d.accumulated_depreciation_amount = flt(accumulated_depreciation, d.precision(""accumulated_depreciation_amount""))
def get_depreciation_amount(self, depreciable_value):
if self.depreciation_method in (""Straight Line"", ""Manual""):
depreciation_amount = (flt(self.value_after_depreciation) -
flt(self.expected_value_after_useful_life)) / (cint(self.total_number_of_depreciations) -
cint(self.number_of_depreciations_booked))
else:
factor = 200.0 / self.total_number_of_depreciations
depreciation_amount = flt(depreciable_value * factor / 100, 0)
value_after_depreciation = flt(depreciable_value) - depreciation_amount
if value_after_depreciation < flt(self.expected_value_after_useful_life):
depreciation_amount = flt(depreciable_value) - flt(self.expected_value_after_useful_life)
return depreciation_amount
def validate_expected_value_after_useful_life(self):
accumulated_depreciation_after_full_schedule = \
max([d.accumulated_depreciation_amount for d in self.get(""schedules"")])
asset_value_after_full_schedule = (flt(self.gross_purchase_amount) -
flt(accumulated_depreciation_after_full_schedule))
if self.expected_value_after_useful_life < asset_value_after_full_schedule:
frappe.throw(_(""Expected value after useful life must be greater than or equal to {0}"")
.format(asset_value_after_full_schedule))
def validate_cancellation(self):
if self.status not in (""Submitted"", ""Partially Depreciated"", ""Fully Depreciated""):
frappe.throw(_(""Asset cannot be cancelled, as it is already {0}"").format(self.status))
if self.purchase_invoice:
frappe.throw(_(""Please cancel Purchase Invoice {0} first"").format(self.purchase_invoice))
def delete_depreciation_entries(self):
for d in self.get(""schedules""):
if d.journal_entry:
frappe.get_doc(""Journal Entry"", d.journal_entry).cancel()
d.db_set(""journal_entry"", None)
self.db_set(""value_after_depreciation"",
(flt(self.gross_purchase_amount) - flt(self.opening_accumulated_depreciation)))
def set_status(self, status=None):
'''Get and update status'''
if not status:
status = self.get_status()
self.db_set(""status"", status)
def get_status(self):
'''Returns status based on whether it is draft, submitted, scrapped or depreciated'''
if self.docstatus == 0:
status = ""Draft""
elif self.docstatus == 1:
status = ""Submitted""
if self.journal_entry_for_scrap:
status = ""Scrapped""
elif flt(self.value_after_depreciation) <= flt(self.expected_value_after_useful_life):
status = ""Fully Depreciated""
elif flt(self.value_after_depreciation) < flt(self.gross_purchase_amount):
status = 'Partially Depreciated'
elif self.docstatus == 2:
status = ""Cancelled""
return status
@frappe.whitelist()
def make_purchase_invoice(asset, item_code, gross_purchase_amount, company, posting_date):
pi = frappe.new_doc(""Purchase Invoice"")
pi.company = company
pi.currency = frappe.db.get_value(""Company"", company, ""default_currency"")
pi.set_posting_time = 1
pi.posting_date = posting_date
pi.append(""items"", {
""item_code"": item_code,
""is_fixed_asset"": 1,
""asset"": asset,
""expense_account"": get_fixed_asset_account(asset),
""qty"": 1,
""price_list_rate"": gross_purchase_amount,
""rate"": gross_purchase_amount
})
pi.set_missing_values()
return pi
@frappe.whitelist()
def make_sales_invoice(asset, item_code, company):
si = frappe.new_doc(""Sales Invoice"")
si.company = company
si.currency = frappe.db.get_value(""Company"", company, ""default_currency"")
disposal_account, depreciation_cost_center = get_disposal_account_and_cost_center(company)
si.append(""items"", {
""item_code"": item_code,
""is_fixed_asset"": 1,
""asset"": asset,
""income_account"": disposal_account,
""cost_center"": depreciation_cost_center,
""qty"": 1
})
si.set_missing_values()
return si
@frappe.whitelist()
def transfer_asset(args):
import json
args = json.loads(args)
movement_entry = frappe.new_doc(""Asset Movement"")
movement_entry.update(args)
movement_entry.insert()
movement_entry.submit()
frappe.db.commit()
frappe.msgprint(_(""Asset Movement record {0} created"").format(""{0}"".format(movement_entry.name)))
@frappe.whitelist()
def get_item_details(item_code):
asset_category = frappe.db.get_value(""Item"", item_code, ""asset_category"")
if not asset_category:
frappe.throw(_(""Please enter Asset Category in Item {0}"").format(item_code))
ret = frappe.db.get_value(""Asset Category"", asset_category,
[""depreciation_method"", ""total_number_of_depreciations"", ""frequency_of_depreciation""], as_dict=1)
ret.update({
""asset_category"": asset_category
})
return ret
",1
"tto package.
# Pycornetto 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.
# Pycornetto 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 loading ...
"""""" % {'div_id': url.replace(""/"", """"), 'url': url}
return """"
register.tag('view', ViewNode)
",1
"mport SampleGroup
class RunInfoTest(TestCase):
def test_get_all_samples(self):
expected_fastq_paths = ['1a_R1_001.fastq',
'1b_R1_001.fastq',
'2_R1_001.fastq']
run_info = RunInfo(
sample_groups=[SampleGroup(Sample(fastq1='1a_R1_001.fastq'),
Sample(fastq1='1b_R1_001.fastq')),
SampleGroup(Sample(fastq1='2_R1_001.fastq'))])
fastq_paths = [sample.fastq1 for sample in run_info.get_all_samples()]
self.assertEqual(expected_fastq_paths, fastq_paths)
",1
"ensource.org/licenses/BSD-3-Clause>
""""""
from selenium import webdriver
import os
import time
import logging
import re
import random
from cameo.utility import Utility
from cameo.localdb import LocalDbForTECHORANGE
""""""
抓取 科技報橘 html 存放到 source_html
""""""
class SpiderForTECHORANGE:
#建構子
def __init__(self):
self.SOURCE_HTML_BASE_FOLDER_PATH = u""cameo_res\\source_html""
self.PARSED_RESULT_BASE_FOLDER_PATH = u""cameo_res\\parsed_result""
self.strWebsiteDomain = u""http://buzzorange.com/techorange""
self.dicSubCommandHandler = {
""index"":self.downloadIndexPage,
""tag"":self.downloadTagPag,
""news"":self.downloadNewsPage
}
self.utility = Utility()
self.db = LocalDbForTECHORANGE()
self.driver = None
#取得 spider 使用資訊
def getUseageMessage(self):
return (""- TECHORANGE -\n""
""useage:\n""
""index - download entry page of TECHORANGE \n""
""tag - download not obtained tag page \n""
""news [tag] - download not obtained news [of given tag] \n"")
#取得 selenium driver 物件
def getDriver(self):
chromeDriverExeFilePath = ""cameo_res\\chromedriver.exe""
driver = webdriver.Chrome(chromeDriverExeFilePath)
return driver
#初始化 selenium driver 物件
def initDriver(self):
if self.driver is None:
self.driver = self.getDriver()
#終止 selenium driver 物件
def quitDriver(self):
self.driver.quit()
self.driver = None
#執行 spider
def runSpider(self, lstSubcommand=None):
strSubcommand = lstSubcommand[0]
strArg1 = None
if len(lstSubcommand) == 2:
strArg1 = lstSubcommand[1]
self.initDriver() #init selenium driver
self.dicSubCommandHandler[strSubcommand](strArg1)
self.quitDriver() #quit selenium driver
#下載 index 頁面
def downloadIndexPage(self, uselessArg1=None):
logging.info(""download index page"")
strIndexHtmlFolderPath = self.SOURCE_HTML_BASE_FOLDER_PATH + u""\\TECHORANGE""
if not os.path.exists(strIndexHtmlFolderPath):
os.mkdir(strIndexHtmlFolderPath) #mkdir source_html/TECHORANGE/
#科技報橘首頁
self.driver.get(""https://buzzorange.com/techorange/"")
#儲存 html
strIndexHtmlFilePath = strIndexHtmlFolderPath + u""\\index.html""
self.utility.overwriteSaveAs(strFilePath=strIndexHtmlFilePath, unicodeData=self.driver.page_source)
#下載 tag 頁面
def downloadTagPag(self, uselessArg1=None):
logging.info(""download tag page"")
strTagHtmlFolderPath = self.SOURCE_HTML_BASE_FOLDER_PATH + u""\\TECHORANGE\\tag""
if not os.path.exists(strTagHtmlFolderPath):
os.mkdir(strTagHtmlFolderPath) #mkdir source_html/TECHORANGE/tag/
strTagWebsiteDomain = self.strWebsiteDomain + u""/tag""
#取得 Db 中尚未下載的 Tag 名稱
lstStrNotObtainedTagName = self.db.fetchallNotObtainedTagName()
for strNotObtainedTagName in lstStrNotObtainedTagName:
#略過名稱太長的 tag
if len(strNotObtainedTagName) > 60:
continue
strTagUrl = strTagWebsiteDomain + u""/"" + strNotObtainedTagName
#tag 第0頁
intPageNum = 0
time.sleep(random.randint(2,5)) #sleep random time
self.driver.get(strTagUrl)
#儲存 html
strTagHtmlFilePath = strTagHtmlFolderPath + u""\\%d_%s_tag.html""%(intPageNum, strNotObtainedTagName)
self.utility.overwriteSaveAs(strFilePath=strTagHtmlFilePath, unicodeData=self.driver.page_source)
#tag 下一頁
elesNextPageA = self.driver.find_elements_by_css_selector(""div.nav-links a.next.page-numbers"")
while len(elesNextPageA) != 0:
time.sleep(random.randint(2,5)) #sleep random time
intPageNum = intPageNum+1
strTagUrl = elesNextPageA[0].get_attribute(""href"")
self.driver.get(strTagUrl)
#儲存 html
strTagHtmlFilePath = strTagHtmlFolderPath + u""\\%d_%s_tag.html""%(intPageNum, strNotObtainedTagName)
self.utility.overwriteSaveAs(strFilePath=strTagHtmlFilePath, unicodeData=self.driver.page_source)
#tag 再下一頁
elesNextPageA = self.driver.find_elements_by_css_selector(""div.nav-links a.next.page-numbers"")
#更新tag DB 為已抓取 (isGot = 1)
self.db.updateTagStatusIsGot(strTagName=strNotObtainedTagName)
logging.info(""got tag %s""%strNotObtainedTagName)
#限縮 字串長度低於 128 字元
def limitStrLessThen128Char(self, strStr=None):
if len(strStr) > 128:
logging.info(""limit str less then 128 char"")
return strStr[:127] + u""_""
else:
return strStr
#下載 news 頁面 (strTagName == None 會自動找尋已下載完成之 tag，但若未先執行 parser tag 即使 tag 已下載完成亦無法下載 news)
def downloadNewsPage(self, strTagName=None):
if strTagName is None:
#未指定 tag
lstStrObtainedTagName = self.db.fetchallCompletedObtainedTagName()
for strObtainedTagName in lstStrObtainedTagName:
self.downloadNewsPageWithGivenTagName(strTagName=strObtainedTagName)
else:
#有指定 tag 名稱
self.downloadNewsPageWithGivenTagName(strTagName=strTagName)
#下載 news 頁面 (指定 tag 名稱)
def downloadNewsPageWithGivenTagName(self, strTagName=None):
logging.info(""download news page with tag %s""%strTagName)
strNewsHtmlFolderPath = self.SOURCE_HTML_BASE_FOLDER_PATH + u""\\TECHORANGE\\news""
if not os.path.exists(strNewsHtmlFolderPath):
os.mkdir(strNewsHtmlFolderPath) #mkdir source_html/TECHORANGE/news/
#取得 DB 紀錄中，指定 strTagName tag 的 news url
lstStrNewsUrl = self.db.fetchallNewsUrlByTagName(strTagName=strTagName)
intDownloadedNewsCount = 0#紀錄下載 news 頁面數量
timeStart = time.time() #計時開始時間點
timeEnd = None #計時結束時間點
for strNewsUrl in lstStrNewsUrl:
#檢查是否已下載
if not self.db.checkNewsIsGot(strNewsUrl=strNewsUrl):
if intDownloadedNewsCount%10 == 0: #計算下載10筆news所需時間
timeEnd = time.time()
timeCost = timeEnd - timeStart
logging.info(""download 10 news cost %f sec""%timeCost)
timeStart = timeEnd
intDownloadedNewsCount = intDownloadedNewsCount+1
time.sleep(random.randint(2,5)) #sleep random time
self.driver.get(strNewsUrl)
#儲存 html
strNewsName = re.match(""^https://buzzorange.com/techorange/[\d]{4}/[\d]{2}/[\d]{2}/(.*)/$"", strNewsUrl).group(1)
strNewsName = self.limitStrLessThen128Char(strStr=strNewsName) #將名稱縮短小於128字完
strNewsHtmlFilePath = strNewsHtmlFolderPath + u""\\%s_news.html""%strNewsName
self.utility.overwriteSaveAs(strFilePath=strNewsHtmlFilePath, unicodeData=self.driver.page_source)
#更新news DB 為已抓取 (isGot = 1)
self.db.updateNewsStatusIsGot(strNewsUrl=strNewsUrl)
",1
"s free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero 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 Affero General Public License for more details.
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see You have been invited to follow %s.
') % document_name
result['message'] = message
elif 'message' in fields:
result['message'] = _('You have been invited to follow a new document.
')
return result
_columns = {
'res_model': fields.char('Related Document Model', size=128,
required=True, select=1,
help='Model of the followed resource'),
'res_id': fields.integer('Related Document ID', select=1,
help='Id of the followed resource'),
'partner_ids': fields.many2many('res.partner', string='Partners'),
'message': fields.html('Message'),
}
def add_followers(self, cr, uid, ids, context=None):
for wizard in self.browse(cr, uid, ids, context=context):
model_obj = self.pool.get(wizard.res_model)
document = model_obj.browse(cr, uid, wizard.res_id, context=context)
# filter partner_ids to get the new followers, to avoid sending email to already following partners
new_follower_ids = [p.id for p in wizard.partner_ids if p.id not in document.message_follower_ids]
model_obj.message_subscribe(cr, uid, [wizard.res_id], new_follower_ids, context=context)
# send an email only if a personal message exists
if wizard.message and not wizard.message == '': # when deleting the message, cleditor keeps a
# add signature user_id = self.pool.get(""res.users"").read(cr, uid, [uid], fields=[""signature""], context=context)[0] signature = user_id and user_id[""signature""] or '' if signature: wizard.message = tools.append_content_to_html(wizard.message, signature, plaintext=True, container_tag='div') # FIXME 8.0: use notification_email_send, send a wall message and let mail handle email notification + message box for follower_id in new_follower_ids: mail_mail = self.pool.get('mail.mail') # the invite wizard should create a private message not related to any object -> no model, no res_id mail_id = mail_mail.create(cr, uid, { 'model': wizard.res_model, 'res_id': wizard.res_id, 'subject': _('Invitation to follow %s') % document.name_get()[0][1], 'body_html': '%s' % wizard.message, 'auto_delete': True, }, context=context) mail_mail.send(cr, uid, [mail_id], recipient_ids=[follower_id], context=context) return {'type': 'ir.actions.act_window_close'} ",1 "0, 1, 0, -1], [1, 0, -1, 0] x, y, c = 0, -1, 1 l=0 for i in range(13+13-1): if i%2==0: for j in range((25+25-i)//2): x += dx[i % 4] y += dy[i % 4] #print(x,y,l) a[x][y] = s[l] l=l+1 c += 1 else: for j in range((13+13-i)//2): x += dx[i % 4] y += dy[i % 4] #print(x,y,l) a[x][y] = s[l] l=l+1 c += 1 for i in a: for k in i: k=re.sub(r""¦"",""█"",k) k=re.sub(r""¯"",""▀"",k) k=re.sub(r""_"",""▄"",k) print(k,end="""") print() ",1 "get_tags from add import add_tags from bmarklet import get_bmarklet from account import get_account from edit_tags import get_edit_tags from importbm import get_import_bm from edit import do_edit from login import do_login from register import do_register @route('/') def myroot(): return_data = get_index() return return_data @route('/account', method=['GET', 'POST']) def bmarks(): return_data = get_bmarklet() return return_data @route('/add', method=['GET', 'POST']) def bmarks(): return_data = add_tags() return return_data @route('/bmarklet') def bmarks(): return_data = get_bmarklet() return return_data @route('/bmarks') def bmarks(): return_data = get_bmarks() return return_data @route('/edit', method=['GET', 'POST']) def bmarks(): return_data = do_edit() return return_data @route('/edit_tags', method=['GET', 'POST']) def bmarks(): return_data = get_edit_tags() return return_data @route('/import', method=['GET', 'POST']) def bmarks(): return_data = get_import_bm() return return_data @route('/login', method=['GET', 'POST']) def bmarks(): return_data = do_login() return return_data @route('/register', method=['GET', 'POST']) def bmarks(): return_data = do_register() return return_data @route('/tags') def bmarks(): return_data = get_tags() return return_data # serve css @get('/
Ooops, its not here
'
@error(500)
def handle500(error):
return 'Oops, its broken: {}
'.format(error)
",1
"oder
from deepy.trainers import SGDTrainer, LearningRateAnnealer
from util import get_data, VECTOR_SIZE
model_path = os.path.join(os.path.dirname(__file__), ""models"", ""rae1.gz"")
if __name__ == '__main__':
model = RecursiveAutoEncoder(input_dim=VECTOR_SIZE, rep_dim=10)
trainer = SGDTrainer(model)
annealer = LearningRateAnnealer()
trainer.run(get_data(), epoch_controllers=[annealer])
model.save_params(model_path)
",1
"he prior for U and V we take value 1 for all entries (so exp 1).
As a result, each value in R has a value of around 20, and a variance of 100-120.
For contrast, the Sanger dataset of 705 by 140 shifted to nonnegative has mean
31.522999753779082 and variance 243.2427345740027.
We add Gaussian noise of precision tau = 1 (prior for gamma: alpha=1,beta=1).
(Simply using the expectation of our Gamma distribution over tau)
""""""
import sys, os
project_location = os.path.dirname(__file__)+""/../../../""
sys.path.append(project_location)
from BNMTF.code.models.distributions.exponential import exponential_draw
from BNMTF.code.models.distributions.normal import normal_draw
from BNMTF.code.cross_validation.mask import generate_M
import numpy, itertools, matplotlib.pyplot as plt
def generate_dataset(I,J,K,lambdaU,lambdaV,tau):
# Generate U, V
U = numpy.zeros((I,K))
for i,k in itertools.product(xrange(0,I),xrange(0,K)):
U[i,k] = exponential_draw(lambdaU[i,k])
V = numpy.zeros((J,K))
for j,k in itertools.product(xrange(0,J),xrange(0,K)):
V[j,k] = exponential_draw(lambdaV[j,k])
# Generate R
true_R = numpy.dot(U,V.T)
R = add_noise(true_R,tau)
return (U,V,tau,true_R,R)
def add_noise(true_R,tau):
if numpy.isinf(tau):
return numpy.copy(true_R)
(I,J) = true_R.shape
R = numpy.zeros((I,J))
for i,j in itertools.product(xrange(0,I),xrange(0,J)):
R[i,j] = normal_draw(true_R[i,j],tau)
return R
def try_generate_M(I,J,fraction_unknown,attempts):
for attempt in range(1,attempts+1):
try:
M = generate_M(I,J,fraction_unknown)
sums_columns = M.sum(axis=0)
sums_rows = M.sum(axis=1)
for i,c in enumerate(sums_rows):
assert c != 0, ""Fully unobserved row in M, row %s. Fraction %s."" % (i,fraction_unknown)
for j,c in enumerate(sums_columns):
assert c != 0, ""Fully unobserved column in M, column %s. Fraction %s."" % (j,fraction_unknown)
print ""Took %s attempts to generate M."" % attempt
return M
except AssertionError:
pass
raise Exception(""Tried to generate M %s times, with I=%s, J=%s, fraction=%s, but failed."" % (attempts,I,J,fraction_unknown))
##########
if __name__ == ""__main__"":
output_folder = project_location+""BNMTF/data_toy/bnmf/""
I,J,K = 100, 80, 10 #20, 10, 5 #
fraction_unknown = 0.1
alpha, beta = 1., 1.
lambdaU = numpy.ones((I,K))
lambdaV = numpy.ones((I,K))
tau = alpha / beta
(U,V,tau,true_R,R) = generate_dataset(I,J,K,lambdaU,lambdaV,tau)
# Try to generate M
M = try_generate_M(I,J,fraction_unknown,attempts=1000)
# Store all matrices in text files
numpy.savetxt(open(output_folder+""U.txt"",'w'),U)
numpy.savetxt(open(output_folder+""V.txt"",'w'),V)
numpy.savetxt(open(output_folder+""R_true.txt"",'w'),true_R)
numpy.savetxt(open(output_folder+""R.txt"",'w'),R)
numpy.savetxt(open(output_folder+""M.txt"",'w'),M)
print ""Mean R: %s. Variance R: %s. Min R: %s. Max R: %s."" % (numpy.mean(R),numpy.var(R),R.min(),R.max())
fig = plt.figure()
plt.hist(R.flatten(),bins=range(0,int(R.max())+1))
plt.show()",1
"er Research & Fraunhofer SCAI
#
# This file is part of ESPResSo++.
#
# ESPResSo++ 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.
#
# ESPResSo++ 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
""""""
def wrapper(*args, **kwargs):
""""""Decorator wrapper.""""""
if args[0].is_coordinator:
from soco.exceptions import SoCoUPnPException
try:
func(*args, **kwargs)
except SoCoUPnPException:
_LOGGER.error('command ""%s"" for Sonos device ""%s"" '
'not available in this mode',
func.__name__, args[0].name)
else:
_LOGGER.debug('Ignore command ""%s"" for Sonos device ""%s"" (%s)',
func.__name__, args[0].name, 'not coordinator')
return wrapper
# pylint: disable=too-many-instance-attributes, too-many-public-methods
# pylint: disable=abstract-method
class SonosDevice(MediaPlayerDevice):
""""""Representation of a Sonos device.""""""
# pylint: disable=too-many-arguments
def __init__(self, hass, player):
""""""Initialize the Sonos device.""""""
from soco.snapshot import Snapshot
self.hass = hass
self.volume_increment = 5
self._player = player
self._speaker_info = None
self._name = None
self._coordinator = None
self._media_content_id = None
self._media_duration = None
self._media_image_url = None
self._media_artist = None
self._media_album_name = None
self._media_title = None
self.update()
self.soco_snapshot = Snapshot(self._player)
@property
def should_poll(self):
""""""Polling needed.""""""
return True
def update_sonos(self, now):
""""""Update state, called by track_utc_time_change.""""""
self.update_ha_state(True)
@property
def unique_id(self):
""""""Return an unique ID.""""""
return self._player.uid
@property
def name(self):
""""""Return the name of the device.""""""
return self._name
@property
def state(self):
""""""Return the state of the device.""""""
if self._status == 'PAUSED_PLAYBACK':
return STATE_PAUSED
if self._status == 'PLAYING':
return STATE_PLAYING
if self._status == 'STOPPED':
return STATE_IDLE
if self._status == 'OFF':
return STATE_OFF
return STATE_UNKNOWN
@property
def is_coordinator(self):
""""""Return true if player is a coordinator.""""""
return self._player.is_coordinator
def update(self):
""""""Retrieve latest state.""""""
self._speaker_info = self._player.get_speaker_info()
self._name = self._speaker_info['zone_name'].replace(
' (R)', '').replace(' (L)', '')
if self.available:
self._status = self._player.get_current_transport_info().get(
'current_transport_state')
trackinfo = self._player.get_current_track_info()
if trackinfo['uri'].startswith('x-rincon:'):
# this speaker is a slave, find the coordinator
# the uri of the track is 'x-rincon:{coordinator-id}'
coordinator_id = trackinfo['uri'][9:]
coordinators = [device for device in DEVICES
if device.unique_id == coordinator_id]
self._coordinator = coordinators[0] if coordinators else None
else:
self._coordinator = None
if not self._coordinator:
mediainfo = self._player.avTransport.GetMediaInfo([
('InstanceID', 0)
])
duration = trackinfo.get('duration', '0:00')
# if the speaker is playing from the ""line-in"" source, getting
# track metadata can return NOT_IMPLEMENTED, which breaks the
# volume logic below
if duration == 'NOT_IMPLEMENTED':
duration = None
else:
duration = sum(60 ** x[0] * int(x[1]) for x in enumerate(
reversed(duration.split(':'))))
media_image_url = trackinfo.get('album_art', None)
media_artist = trackinfo.get('artist', None)
media_album_name = trackinfo.get('album', None)
media_title = trackinfo.get('title', None)
if media_image_url in ('', 'NOT_IMPLEMENTED', None):
# fallback to asking the speaker directly
media_image_url = \
'http://{host}:{port}/getaa?s=1&u={uri}'.format(
host=self._player.ip_address,
port=1400,
uri=urllib.parse.quote(mediainfo['CurrentURI'])
)
if media_artist in ('', 'NOT_IMPLEMENTED', None):
# if listening to a radio stream the media_artist field
# will be empty and the title field will contain the
# filename that is being streamed
current_uri_metadata = mediainfo[""CurrentURIMetaData""]
if current_uri_metadata not in \
('', 'NOT_IMPLEMENTED', None):
# currently soco does not have an API for this
import soco
current_uri_metadata = soco.xml.XML.fromstring(
soco.utils.really_utf8(current_uri_metadata))
md_title = current_uri_metadata.findtext(
'.//{http://purl.org/dc/elements/1.1/}title')
if md_title not in ('', 'NOT_IMPLEMENTED', None):
media_artist = ''
media_title = md_title
self._media_content_id = trackinfo.get('title', None)
self._media_duration = duration
self._media_image_url = media_image_url
self._media_artist = media_artist
self._media_album_name = media_album_name
self._media_title = media_title
else:
self._status = 'OFF'
self._coordinator = None
self._media_content_id = None
self._media_duration = None
self._media_image_url = None
self._media_artist = None
self._media_album_name = None
self._media_title = None
@property
def volume_level(self):
""""""Volume level of the media player (0..1).""""""
return self._player.volume / 100.0
@property
def is_volume_muted(self):
""""""Return true if volume is muted.""""""
return self._player.mute
@property
def media_content_id(self):
""""""Content ID of current playing media.""""""
if self._coordinator:
return self._coordinator.media_content_id
else:
return self._media_content_id
@property
def media_content_type(self):
""""""Content type of current playing media.""""""
return MEDIA_TYPE_MUSIC
@property
def media_duration(self):
""""""Duration of current playing media in seconds.""""""
if self._coordinator:
return self._coordinator.media_duration
else:
return self._media_duration
@property
def media_image_url(self):
""""""Image url of current playing media.""""""
if self._coordinator:
return self._coordinator.media_image_url
else:
return self._media_image_url
@property
def media_artist(self):
""""""Artist of current playing media, music track only.""""""
if self._coordinator:
return self._coordinator.media_artist
else:
return self._media_artist
@property
def media_album_name(self):
""""""Album name of current playing media, music track only.""""""
if self._coordinator:
return self._coordinator.media_album_name
else:
return self._media_album_name
@property
def media_title(self):
""""""Title of current playing media.""""""
if self._player.is_playing_line_in:
return SUPPORT_SOURCE_LINEIN
if self._player.is_playing_tv:
return SUPPORT_SOURCE_TV
if self._coordinator:
return self._coordinator.media_title
else:
return self._media_title
@property
def supported_media_commands(self):
""""""Flag of media commands that are supported.""""""
if not self.source_list:
# some devices do not allow source selection
return SUPPORT_SONOS ^ SUPPORT_SELECT_SOURCE
return SUPPORT_SONOS
def volume_up(self):
""""""Volume up media player.""""""
self._player.volume += self.volume_increment
def volume_down(self):
""""""Volume down media player.""""""
self._player.volume -= self.volume_increment
def set_volume_level(self, volume):
""""""Set volume level, range 0..1.""""""
self._player.volume = str(int(volume * 100))
def mute_volume(self, mute):
""""""Mute (true) or unmute (false) media player.""""""
self._player.mute = mute
def select_source(self, source):
""""""Select input source.""""""
if source == SUPPORT_SOURCE_LINEIN:
self._player.switch_to_line_in()
elif source == SUPPORT_SOURCE_TV:
self._player.switch_to_tv()
@property
def source_list(self):
""""""List of available input sources.""""""
model_name = self._speaker_info['model_name']
if 'PLAY:5' in model_name:
return [SUPPORT_SOURCE_LINEIN]
elif 'PLAYBAR' in model_name:
return [SUPPORT_SOURCE_LINEIN, SUPPORT_SOURCE_TV]
@property
def source(self):
""""""Name of the current input source.""""""
if self._player.is_playing_line_in:
return SUPPORT_SOURCE_LINEIN
if self._player.is_playing_tv:
return SUPPORT_SOURCE_TV
return None
@only_if_coordinator
def turn_off(self):
""""""Turn off media player.""""""
self._player.pause()
def media_play(self):
""""""Send play command.""""""
if self._coordinator:
self._coordinator.media_play()
else:
self._player.play()
def media_pause(self):
""""""Send pause command.""""""
if self._coordinator:
self._coordinator.media_pause()
else:
self._player.pause()
def media_next_track(self):
""""""Send next track command.""""""
if self._coordinator:
self._coordinator.media_next_track()
else:
self._player.next()
def media_previous_track(self):
""""""Send next track command.""""""
if self._coordinator:
self._coordinator.media_previous_track()
else:
self._player.previous()
def media_seek(self, position):
""""""Send seek command.""""""
if self._coordinator:
self._coordinator.media_seek(position)
else:
self._player.seek(str(datetime.timedelta(seconds=int(position))))
def clear_playlist(self):
""""""Clear players playlist.""""""
if self._coordinator:
self._coordinator.clear_playlist()
else:
self._player.clear_queue()
@only_if_coordinator
def turn_on(self):
""""""Turn the media player on.""""""
self._player.play()
def play_media(self, media_type, media_id, **kwargs):
""""""
Send the play_media command to the media player.
If ATTR_MEDIA_ENQUEUE is True, add `media_id` to the queue.
""""""
if self._coordinator:
self._coordinator.play_media(media_type, media_id, **kwargs)
else:
if kwargs.get(ATTR_MEDIA_ENQUEUE):
from soco.exceptions import SoCoUPnPException
try:
self._player.add_uri_to_queue(media_id)
except SoCoUPnPException:
_LOGGER.error('Error parsing media uri ""%s"", '
""please check it's a valid media resource ""
'supported by Sonos', media_id)
else:
self._player.play_uri(media_id)
def group_players(self):
""""""Group all players under this coordinator.""""""
if self._coordinator:
self._coordinator.group_players()
else:
self._player.partymode()
@only_if_coordinator
def unjoin(self):
""""""Unjoin the player from a group.""""""
self._player.unjoin()
@only_if_coordinator
def snapshot(self):
""""""Snapshot the player.""""""
self.soco_snapshot.snapshot()
@only_if_coordinator
def restore(self):
""""""Restore snapshot for the player.""""""
self.soco_snapshot.restore(True)
@only_if_coordinator
def set_sleep_timer(self, sleep_time):
""""""Set the timer on the player.""""""
self._player.set_sleep_timer(sleep_time)
@only_if_coordinator
def clear_sleep_timer(self):
""""""Clear the timer on the player.""""""
self._player.set_sleep_timer(None)
@property
def available(self):
""""""Return True if player is reachable, False otherwise.""""""
try:
sock = socket.create_connection(
address=(self._player.ip_address, 1443),
timeout=3)
sock.close()
return True
except socket.error:
return False
",1
"trations.models import Registration
from registrations import handlers
from registrations import tasks
class Command(BaseCommand):
def log(self, message):
f = open(settings.TASK_LOG_PATH, 'a')
now = datetime.datetime.utcnow().replace(tzinfo=pytz.utc)
log_message = ""%s\t%s\n"" % (now, message)
self.stdout.write(log_message)
f.write(log_message)
f.close()
def handle(self, *args, **options):
context = zmq.Context()
pull_socket = context.socket(zmq.PULL)
pull_socket.bind('tcp://*:7002')
self.log(""Registration Worker ZMQ Socket Bound to 7002"")
while True:
try:
data = pull_socket.recv_json()
task_name = data.pop('task')
task_kwargs = data.pop('kwargs')
self.log(""Got task '%s' with kwargs: %s"" % (task_name, task_kwargs))
if hasattr(tasks, task_name):
result = getattr(tasks, task_name)(**task_kwargs)
self.log(""Task '%s' result: %s"" % (task_name, result))
else:
self.log(""Received unknown task: %s"", task_name)
except Exception, e:
self.log(""Error: %s"" % e)
pull_socket.close()
context.term()
",1
"9 22:26:36 2013.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys
import os
from unittest.mock import MagicMock
class Mock(MagicMock):
@classmethod
def __getattr__(cls, name):
return MagicMock()
MOCK_MODULES = ['face_recognition_models', 'Click', 'dlib', 'numpy', 'PIL']
sys.modules.update((mod_name, Mock()) for mod_name in MOCK_MODULES)
# If extensions (or modules to document with autodoc) are in another
# directory, add these directories to sys.path here. If the directory is
# relative to the documentation root, use os.path.abspath to make it
# absolute, like shown here.
#sys.path.insert(0, os.path.abspath('.'))
# Get the project root dir, which is the parent dir of this
cwd = os.getcwd()
project_root = os.path.dirname(cwd)
# Insert the project root dir as the first element in the PYTHONPATH.
# This lets us ensure that the source package is imported, and that its
# version is used.
sys.path.insert(0, project_root)
import face_recognition
# -- General configuration ---------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = ['sphinx.ext.autodoc', 'sphinx.ext.viewcode']
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix of source filenames.
source_suffix = '.rst'
# The encoding of source files.
#source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u'Face Recognition'
copyright = u""2017, Adam Geitgey""
# The version info for the project you're documenting, acts as replacement
# for |version| and |release|, also used in various other places throughout
# the built documents.
#
# The short X.Y version.
version = face_recognition.__version__
# The full version, including alpha/beta/rc tags.
release = face_recognition.__version__
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#language = None
# There are two options for replacing |today|: either, you set today to
# some non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build']
# The reST default role (used for this markup: `text`) to use for all
# documents.
#default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []
# If true, keep warnings as ""system message"" paragraphs in the built
# documents.
#keep_warnings = False
# -- Options for HTML output -------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme = 'default'
# Theme options are theme-specific and customize the look and feel of a
# theme further. For a list of options available for each theme, see the
# documentation.
#html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = []
# The name for this set of Sphinx documents. If None, it defaults to
# "" v documentation"".
#html_title = None
# A shorter title for the navigation bar. Default is the same as
# html_title.
#html_short_title = None
# The name of an image file (relative to this directory) to place at the
# top of the sidebar.
#html_logo = None
# The name of an image file (within the static path) to use as favicon
# of the docs. This file should be a Windows icon file (.ico) being
# 16x16 or 32x32 pixels large.
#html_favicon = None
# Add any paths that contain custom static files (such as style sheets)
# here, relative to this directory. They are copied after the builtin
# static files, so a file named ""default.css"" will overwrite the builtin
# ""default.css"".
html_static_path = ['_static']
# If not '', a 'Last updated on:' timestamp is inserted at every page
# bottom, using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names
# to template names.
#html_additional_pages = {}
# If false, no module index is generated.
#html_domain_indices = True
# If false, no index is generated.
#html_use_index = True
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True
# If true, ""Created using Sphinx"" is shown in the HTML footer.
# Default is True.
#html_show_sphinx = True
# If true, ""(C) Copyright ..."" is shown in the HTML footer.
# Default is True.
#html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages
# will contain a tag referring to it. The value of this option
# must be the base URL from which the finished HTML is served.
#html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. "".xhtml"").
#html_file_suffix = None
# Output file base name for HTML help builder.
htmlhelp_basename = 'face_recognitiondoc'
# -- Options for LaTeX output ------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#'preamble': '',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, documentclass
# [howto/manual]).
latex_documents = [
('index', 'face_recognition.tex',
u'Face Recognition Documentation',
u'Adam Geitgey', 'manual'),
]
# The name of an image file (relative to this directory) to place at
# the top of the title page.
#latex_logo = None
# For ""manual"" documents, if this is true, then toplevel headings
# are parts, not chapters.
#latex_use_parts = False
# If true, show page references after internal links.
#latex_show_pagerefs = False
# If true, show URL addresses after external links.
#latex_show_urls = False
# Documents to append as an appendix to all manuals.
#latex_appendices = []
# If false, no module index is generated.
#latex_domain_indices = True
# -- Options for manual page output ------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
('index', 'face_recognition',
u'Face Recognition Documentation',
[u'Adam Geitgey'], 1)
]
# If true, show URL addresses after external links.
#man_show_urls = False
# -- Options for Texinfo output ----------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
('index', 'face_recognition',
u'Face Recognition Documentation',
u'Adam Geitgey',
'face_recognition',
'One line description of project.',
'Miscellaneous'),
]
# Documents to append as an appendix to all manuals.
#texinfo_appendices = []
# If false, no module index is generated.
#texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#texinfo_show_urls = 'footnote'
# If true, do not generate a @detailmenu in the ""Top"" node's menu.
#texinfo_no_detailmenu = False
",1
"is 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.
# ==============================================================================
""""""Generate some standard test data for debugging TensorBoard.
""""""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import bisect
import math
import os
import os.path
import random
import shutil
import numpy as np
from six.moves import xrange # pylint: disable=redefined-builtin
import tensorflow as tf
tf.flags.DEFINE_string(""target"", None, """"""The directoy where serialized data
will be written"""""")
tf.flags.DEFINE_boolean(""overwrite"", False, """"""Whether to remove and overwrite
TARGET if it already exists."""""")
FLAGS = tf.flags.FLAGS
# Hardcode a start time and reseed so script always generates the same data.
_start_time = 0
random.seed(0)
def _MakeHistogramBuckets():
v = 1E-12
buckets = []
neg_buckets = []
while v < 1E20:
buckets.append(v)
neg_buckets.append(-v)
v *= 1.1
# Should include DBL_MAX, but won't bother for test data.
return neg_buckets[::-1] + [0] + buckets
def _MakeHistogram(values):
""""""Convert values into a histogram proto using logic from histogram.cc.""""""
limits = _MakeHistogramBuckets()
counts = [0] * len(limits)
for v in values:
idx = bisect.bisect_left(limits, v)
counts[idx] += 1
limit_counts = [(limits[i], counts[i]) for i in xrange(len(limits))
if counts[i]]
bucket_limit = [lc[0] for lc in limit_counts]
bucket = [lc[1] for lc in limit_counts]
sum_sq = sum(v * v for v in values)
return tf.HistogramProto(min=min(values),
max=max(values),
num=len(values),
sum=sum(values),
sum_squares=sum_sq,
bucket_limit=bucket_limit,
bucket=bucket)
def WriteScalarSeries(writer, tag, f, n=5):
""""""Write a series of scalar events to writer, using f to create values.""""""
step = 0
wall_time = _start_time
for i in xrange(n):
v = f(i)
value = tf.Summary.Value(tag=tag, simple_value=v)
summary = tf.Summary(value=[value])
event = tf.Event(wall_time=wall_time, step=step, summary=summary)
writer.add_event(event)
step += 1
wall_time += 10
def WriteHistogramSeries(writer, tag, mu_sigma_tuples, n=20):
""""""Write a sequence of normally distributed histograms to writer.""""""
step = 0
wall_time = _start_time
for [mean, stddev] in mu_sigma_tuples:
data = [random.normalvariate(mean, stddev) for _ in xrange(n)]
histo = _MakeHistogram(data)
summary = tf.Summary(value=[tf.Summary.Value(tag=tag, histo=histo)])
event = tf.Event(wall_time=wall_time, step=step, summary=summary)
writer.add_event(event)
step += 10
wall_time += 100
def WriteImageSeries(writer, tag, n_images=1):
""""""Write a few dummy images to writer.""""""
step = 0
session = tf.Session()
p = tf.placeholder(""uint8"", (1, 4, 4, 3))
s = tf.image_summary(tag, p)
for _ in xrange(n_images):
im = np.random.random_integers(0, 255, (1, 4, 4, 3))
summ = session.run(s, feed_dict={p: im})
writer.add_summary(summ, step)
step += 20
session.close()
def WriteAudioSeries(writer, tag, n_audio=1):
""""""Write a few dummy audio clips to writer.""""""
step = 0
session = tf.Session()
min_frequency_hz = 440
max_frequency_hz = 880
sample_rate = 4000
duration_frames = sample_rate * 0.5 # 0.5 seconds.
frequencies_per_run = 1
num_channels = 2
p = tf.placeholder(""float32"", (frequencies_per_run, duration_frames,
num_channels))
s = tf.audio_summary(tag, p, sample_rate)
for _ in xrange(n_audio):
# Generate a different frequency for each channel to show stereo works.
frequencies = np.random.random_integers(
min_frequency_hz, max_frequency_hz,
size=(frequencies_per_run, num_channels))
tiled_frequencies = np.tile(frequencies, (1, duration_frames))
tiled_increments = np.tile(
np.arange(0, duration_frames), (num_channels, 1)).T.reshape(
1, duration_frames * num_channels)
tones = np.sin(2.0 * np.pi * tiled_frequencies * tiled_increments /
sample_rate)
tones = tones.reshape(frequencies_per_run, duration_frames, num_channels)
summ = session.run(s, feed_dict={p: tones})
writer.add_summary(summ, step)
step += 20
session.close()
def GenerateTestData(path):
""""""Generates the test data directory.""""""
run1_path = os.path.join(path, ""run1"")
os.makedirs(run1_path)
writer1 = tf.train.SummaryWriter(run1_path)
WriteScalarSeries(writer1, ""foo/square"", lambda x: x * x)
WriteScalarSeries(writer1, ""bar/square"", lambda x: x * x)
WriteScalarSeries(writer1, ""foo/sin"", math.sin)
WriteScalarSeries(writer1, ""foo/cos"", math.cos)
WriteHistogramSeries(writer1, ""histo1"", [[0, 1], [0.3, 1], [0.5, 1], [0.7, 1],
[1, 1]])
WriteImageSeries(writer1, ""im1"")
WriteImageSeries(writer1, ""im2"")
WriteAudioSeries(writer1, ""au1"")
run2_path = os.path.join(path, ""run2"")
os.makedirs(run2_path)
writer2 = tf.train.SummaryWriter(run2_path)
WriteScalarSeries(writer2, ""foo/square"", lambda x: x * x * 2)
WriteScalarSeries(writer2, ""bar/square"", lambda x: x * x * 3)
WriteScalarSeries(writer2, ""foo/cos"", lambda x: math.cos(x) * 2)
WriteHistogramSeries(writer2, ""histo1"", [[0, 2], [0.3, 2], [0.5, 2], [0.7, 2],
[1, 2]])
WriteHistogramSeries(writer2, ""histo2"", [[0, 1], [0.3, 1], [0.5, 1], [0.7, 1],
[1, 1]])
WriteImageSeries(writer2, ""im1"")
WriteAudioSeries(writer2, ""au2"")
graph_def = tf.GraphDef()
node1 = graph_def.node.add()
node1.name = ""a""
node1.op = ""matmul""
node2 = graph_def.node.add()
node2.name = ""b""
node2.op = ""matmul""
node2.input.extend([""a:0""])
writer1.add_graph(graph_def)
node3 = graph_def.node.add()
node3.name = ""c""
node3.op = ""matmul""
node3.input.extend([""a:0"", ""b:0""])
writer2.add_graph(graph_def)
writer1.close()
writer2.close()
def main(unused_argv=None):
target = FLAGS.target
if not target:
print(""The --target flag is required."")
return -1
if os.path.exists(target):
if FLAGS.overwrite:
if os.path.isdir(target):
shutil.rmtree(target)
else:
os.remove(target)
else:
print(""Refusing to overwrite target %s without --overwrite"" % target)
return -2
GenerateTestData(target)
if __name__ == ""__main__"":
tf.app.run()
",1
"ool
def default_reactor(reactor):
""""""
Return the specified reactor or the default.
""""""
if reactor is None:
from twisted.internet import reactor
return reactor
_global_pool = [None]
def get_global_pool():
return _global_pool[0]
def set_global_pool(pool):
_global_pool[0] = pool
def default_pool(reactor, pool, persistent):
""""""
Return the specified pool or a a pool with the specified reactor and
persistence.
""""""
reactor = default_reactor(reactor)
if pool is not None:
return pool
if persistent is False:
return HTTPConnectionPool(reactor, persistent=persistent)
if get_global_pool() is None:
set_global_pool(HTTPConnectionPool(reactor, persistent=True))
return get_global_pool()
",1
"on 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.
# 操作失败。
FAILEDOPERATION = 'FailedOperation'
# API网关触发器创建失败。
FAILEDOPERATION_APIGATEWAY = 'FailedOperation.ApiGateway'
# 创建触发器失败。
FAILEDOPERATION_APIGW = 'FailedOperation.Apigw'
# 获取Apm InstanceId失败。
FAILEDOPERATION_APMCONFIGINSTANCEID = 'FailedOperation.ApmConfigInstanceId'
# 当前异步事件状态不支持此操作，请稍后重试。
FAILEDOPERATION_ASYNCEVENTSTATUS = 'FailedOperation.AsyncEventStatus'
# 复制函数失败。
FAILEDOPERATION_COPYFAILED = 'FailedOperation.CopyFailed'
# 不支持复制到该地域。
FAILEDOPERATION_COPYFUNCTION = 'FailedOperation.CopyFunction'
# 操作COS资源失败。
FAILEDOPERATION_COS = 'FailedOperation.Cos'
# 创建别名失败。
FAILEDOPERATION_CREATEALIAS = 'FailedOperation.CreateAlias'
# 操作失败。
FAILEDOPERATION_CREATEFUNCTION = 'FailedOperation.CreateFunction'
# 创建命名空间失败。
FAILEDOPERATION_CREATENAMESPACE = 'FailedOperation.CreateNamespace'
# 当前函数状态无法进行此操作。
FAILEDOPERATION_CREATETRIGGER = 'FailedOperation.CreateTrigger'
# 当前调试状态无法执行此操作。
FAILEDOPERATION_DEBUGMODESTATUS = 'FailedOperation.DebugModeStatus'
# 调试状态下无法更新执行超时时间。
FAILEDOPERATION_DEBUGMODEUPDATETIMEOUTFAIL = 'FailedOperation.DebugModeUpdateTimeOutFail'
# 删除别名失败。
FAILEDOPERATION_DELETEALIAS = 'FailedOperation.DeleteAlias'
# 当前函数状态无法进行此操作，请在函数状态正常时重试。
FAILEDOPERATION_DELETEFUNCTION = 'FailedOperation.DeleteFunction'
# 删除layer版本失败。
FAILEDOPERATION_DELETELAYERVERSION = 'FailedOperation.DeleteLayerVersion'
# 无法删除默认Namespace。
FAILEDOPERATION_DELETENAMESPACE = 'FailedOperation.DeleteNamespace'
# 删除触发器失败。
FAILEDOPERATION_DELETETRIGGER = 'FailedOperation.DeleteTrigger'
# 当前函数状态无法更新代码，请在状态为正常时更新。
FAILEDOPERATION_FUNCTIONNAMESTATUSERROR = 'FailedOperation.FunctionNameStatusError'
# 函数在部署中,无法做此操作。
FAILEDOPERATION_FUNCTIONSTATUSERROR = 'FailedOperation.FunctionStatusError'
# 当前函数版本状态无法进行此操作，请在版本状态为正常时重试。
FAILEDOPERATION_FUNCTIONVERSIONSTATUSNOTACTIVE = 'FailedOperation.FunctionVersionStatusNotActive'
# 获取别名信息失败。
FAILEDOPERATION_GETALIAS = 'FailedOperation.GetAlias'
# 获取函数代码地址失败。
FAILEDOPERATION_GETFUNCTIONADDRESS = 'FailedOperation.GetFunctionAddress'
# 当前账号或命名空间处于欠费状态，请在可用时重试。
FAILEDOPERATION_INSUFFICIENTBALANCE = 'FailedOperation.InsufficientBalance'
# 调用函数失败。
FAILEDOPERATION_INVOKEFUNCTION = 'FailedOperation.InvokeFunction'
# 命名空间已存在，请勿重复创建。
FAILEDOPERATION_NAMESPACE = 'FailedOperation.Namespace'
# 服务开通失败。
FAILEDOPERATION_OPENSERVICE = 'FailedOperation.OpenService'
# 操作冲突。
FAILEDOPERATION_OPERATIONCONFLICT = 'FailedOperation.OperationConflict'
# 创建定时预置任务失败。
FAILEDOPERATION_PROVISIONCREATETIMER = 'FailedOperation.ProvisionCreateTimer'
# 删除定时预置任务失败。
FAILEDOPERATION_PROVISIONDELETETIMER = 'FailedOperation.ProvisionDeleteTimer'
# 当前函数版本已有预置任务处于进行中，请稍后重试。
FAILEDOPERATION_PROVISIONEDINPROGRESS = 'FailedOperation.ProvisionedInProgress'
# 发布layer版本失败。
FAILEDOPERATION_PUBLISHLAYERVERSION = 'FailedOperation.PublishLayerVersion'
# 当前函数状态无法发布版本，请在状态为正常时发布。
FAILEDOPERATION_PUBLISHVERSION = 'FailedOperation.PublishVersion'
# 角色不存在。
FAILEDOPERATION_QCSROLENOTFOUND = 'FailedOperation.QcsRoleNotFound'
# 当前函数已有保留并发设置任务处于进行中，请稍后重试。
FAILEDOPERATION_RESERVEDINPROGRESS = 'FailedOperation.ReservedInProgress'
# Topic不存在。
FAILEDOPERATION_TOPICNOTEXIST = 'FailedOperation.TopicNotExist'
# 用户并发内存配额设置任务处于进行中，请稍后重试。
FAILEDOPERATION_TOTALCONCURRENCYMEMORYINPROGRESS = 'FailedOperation.TotalConcurrencyMemoryInProgress'
# 指定的服务未开通，可以提交工单申请开通服务。
FAILEDOPERATION_UNOPENEDSERVICE = 'FailedOperation.UnOpenedService'
# 更新别名失败。
FAILEDOPERATION_UPDATEALIAS = 'FailedOperation.UpdateAlias'
# 当前函数状态无法更新代码，请在状态为正常时更新。
FAILEDOPERATION_UPDATEFUNCTIONCODE = 'FailedOperation.UpdateFunctionCode'
# UpdateFunctionConfiguration操作失败。
FAILEDOPERATION_UPDATEFUNCTIONCONFIGURATION = 'FailedOperation.UpdateFunctionConfiguration'
# 内部错误。
INTERNALERROR = 'InternalError'
# 创建apigw触发器内部错误。
INTERNALERROR_APIGATEWAY = 'InternalError.ApiGateway'
# ckafka接口失败。
INTERNALERROR_CKAFKA = 'InternalError.Ckafka'
# 删除cmq触发器失败。
INTERNALERROR_CMQ = 'InternalError.Cmq'
# 更新触发器失败。
INTERNALERROR_COS = 'InternalError.Cos'
# ES错误。
INTERNALERROR_ES = 'InternalError.ES'
# 内部服务异常。
INTERNALERROR_EXCEPTION = 'InternalError.Exception'
# 内部服务错误。
INTERNALERROR_GETROLEERROR = 'InternalError.GetRoleError'
# 内部系统错误。
INTERNALERROR_SYSTEM = 'InternalError.System'
# 内部服务错误。
INTERNALERROR_SYSTEMERROR = 'InternalError.SystemError'
# FunctionName取值与规范不符，请修正后再试。可参考：https://tencentcs.com/5jXKFnBW。
INVALIDPARAMETER_FUNCTIONNAME = 'InvalidParameter.FunctionName'
# 请求参数不合法。
INVALIDPARAMETER_PAYLOAD = 'InvalidParameter.Payload'
# RoutingConfig参数传入错误。
INVALIDPARAMETER_ROUTINGCONFIG = 'InvalidParameter.RoutingConfig'
# 参数取值错误。
INVALIDPARAMETERVALUE = 'InvalidParameterValue'
# Action取值与规范不符，请修正后再试。可参考：https://tencentcs.com/5jXKFnBW。
INVALIDPARAMETERVALUE_ACTION = 'InvalidParameterValue.Action'
# AdditionalVersionWeights参数传入错误。
INVALIDPARAMETERVALUE_ADDITIONALVERSIONWEIGHTS = 'InvalidParameterValue.AdditionalVersionWeights'
# 不支持删除默认别名，请修正后重试。
INVALIDPARAMETERVALUE_ALIAS = 'InvalidParameterValue.Alias'
# ApiGateway参数错误。
INVALIDPARAMETERVALUE_APIGATEWAY = 'InvalidParameterValue.ApiGateway'
# ApmConfig参数传入错误。
INVALIDPARAMETERVALUE_APMCONFIG = 'InvalidParameterValue.ApmConfig'
# ApmConfigInstanceId参数传入错误。
INVALIDPARAMETERVALUE_APMCONFIGINSTANCEID = 'InvalidParameterValue.ApmConfigInstanceId'
# ApmConfigRegion参数传入错误。
INVALIDPARAMETERVALUE_APMCONFIGREGION = 'InvalidParameterValue.ApmConfigRegion'
# Args 参数值有误。
INVALIDPARAMETERVALUE_ARGS = 'InvalidParameterValue.Args'
# 函数异步重试配置参数无效。
INVALIDPARAMETERVALUE_ASYNCTRIGGERCONFIG = 'InvalidParameterValue.AsyncTriggerConfig'
# Cdn传入错误。
INVALIDPARAMETERVALUE_CDN = 'InvalidParameterValue.Cdn'
# cfs配置项重复。
INVALIDPARAMETERVALUE_CFSPARAMETERDUPLICATE = 'InvalidParameterValue.CfsParameterDuplicate'
# cfs配置项取值与规范不符。
INVALIDPARAMETERVALUE_CFSPARAMETERERROR = 'InvalidParameterValue.CfsParameterError'
# cfs参数格式与规范不符。
INVALIDPARAMETERVALUE_CFSSTRUCTIONERROR = 'InvalidParameterValue.CfsStructionError'
# Ckafka传入错误。
INVALIDPARAMETERVALUE_CKAFKA = 'InvalidParameterValue.Ckafka'
# 运行函数时的参数传入有误。
INVALIDPARAMETERVALUE_CLIENTCONTEXT = 'InvalidParameterValue.ClientContext'
# Cls传入错误。
INVALIDPARAMETERVALUE_CLS = 'InvalidParameterValue.Cls'
# 修改Cls配置需要传入Role参数，请修正后重试。
INVALIDPARAMETERVALUE_CLSROLE = 'InvalidParameterValue.ClsRole'
# Cmq传入错误。
INVALIDPARAMETERVALUE_CMQ = 'InvalidParameterValue.Cmq'
# Code传入错误。
INVALIDPARAMETERVALUE_CODE = 'InvalidParameterValue.Code'
# CodeSecret传入错误。
INVALIDPARAMETERVALUE_CODESECRET = 'InvalidParameterValue.CodeSecret'
# CodeSource传入错误。
INVALIDPARAMETERVALUE_CODESOURCE = 'InvalidParameterValue.CodeSource'
# Command[Entrypoint] 参数值有误。
INVALIDPARAMETERVALUE_COMMAND = 'InvalidParameterValue.Command'
# CompatibleRuntimes参数传入错误。
INVALIDPARAMETERVALUE_COMPATIBLERUNTIMES = 'InvalidParameterValue.CompatibleRuntimes'
# Content参数传入错误。
INVALIDPARAMETERVALUE_CONTENT = 'InvalidParameterValue.Content'
# Cos传入错误。
INVALIDPARAMETERVALUE_COS = 'InvalidParameterValue.Cos'
# CosBucketName不符合规范。
INVALIDPARAMETERVALUE_COSBUCKETNAME = 'InvalidParameterValue.CosBucketName'
# CosBucketRegion取值与规范不符，请修正后再试。可参考：https://tencentcs.com/5jXKFnBW。
INVALIDPARAMETERVALUE_COSBUCKETREGION = 'InvalidParameterValue.CosBucketRegion'
# CosObjectName不符合规范。
INVALIDPARAMETERVALUE_COSOBJECTNAME = 'InvalidParameterValue.CosObjectName'
# CustomArgument参数长度超限。
INVALIDPARAMETERVALUE_CUSTOMARGUMENT = 'InvalidParameterValue.CustomArgument'
# DateTime传入错误。
INVALIDPARAMETERVALUE_DATETIME = 'InvalidParameterValue.DateTime'
# DeadLetterConfig取值与规范不符，请修正后再试。可参考：https://tencentcs.com/5jXKFnBW。
INVALIDPARAMETERVALUE_DEADLETTERCONFIG = 'InvalidParameterValue.DeadLetterConfig'
# 默认Namespace无法创建。
INVALIDPARAMETERVALUE_DEFAULTNAMESPACE = 'InvalidParameterValue.DefaultNamespace'
# Description传入错误。
INVALIDPARAMETERVALUE_DESCRIPTION = 'InvalidParameterValue.Description'
# 环境变量DNS[OS_NAMESERVER]配置有误。
INVALIDPARAMETERVALUE_DNSINFO = 'InvalidParameterValue.DnsInfo'
# EipConfig参数错误。
INVALIDPARAMETERVALUE_EIPCONFIG = 'InvalidParameterValue.EipConfig'
# Enable取值与规范不符，请修正后再试。可参考：https://tencentcs.com/5jXKFnBW。
INVALIDPARAMETERVALUE_ENABLE = 'InvalidParameterValue.Enable'
# Environment传入错误。
INVALIDPARAMETERVALUE_ENVIRONMENT = 'InvalidParameterValue.Environment'
# 环境变量大小超限，请保持在 4KB 以内。
INVALIDPARAMETERVALUE_ENVIRONMENTEXCEEDEDLIMIT = 'InvalidParameterValue.EnvironmentExceededLimit'
# 不支持修改函数系统环境变量和运行环境变量。
INVALIDPARAMETERVALUE_ENVIRONMENTSYSTEMPROTECT = 'InvalidParameterValue.EnvironmentSystemProtect'
# Filters参数错误。
INVALIDPARAMETERVALUE_FILTERS = 'InvalidParameterValue.Filters'
# Function取值与规范不符，请修正后再试。可参考：https://tencentcs.com/5jXKFnBW。
INVALIDPARAMETERVALUE_FUNCTION = 'InvalidParameterValue.Function'
# 函数不存在。
INVALIDPARAMETERVALUE_FUNCTIONNAME = 'InvalidParameterValue.FunctionName'
# GitBranch不符合规范。
INVALIDPARAMETERVALUE_GITBRANCH = 'InvalidParameterValue.GitBranch'
# GitCommitId取值与规范不符，请修正后再试。可参考：https://tencentcs.com/5jXKFnBW。
INVALIDPARAMETERVALUE_GITCOMMITID = 'InvalidParameterValue.GitCommitId'
# GitDirectory不符合规范。
INVALIDPARAMETERVALUE_GITDIRECTORY = 'InvalidParameterValue.GitDirectory'
# GitPassword不符合规范。
INVALIDPARAMETERVALUE_GITPASSWORD = 'InvalidParameterValue.GitPassword'
# GitUrl不符合规范。
INVALIDPARAMETERVALUE_GITURL = 'InvalidParameterValue.GitUrl'
# GitUserName不符合规范。
INVALIDPARAMETERVALUE_GITUSERNAME = 'InvalidParameterValue.GitUserName'
# Handler传入错误。
INVALIDPARAMETERVALUE_HANDLER = 'InvalidParameterValue.Handler'
# IdleTimeOut参数传入错误。
INVALIDPARAMETERVALUE_IDLETIMEOUT = 'InvalidParameterValue.IdleTimeOut'
# imageUri 传入有误。
INVALIDPARAMETERVALUE_IMAGEURI = 'InvalidParameterValue.ImageUri'
# InlineZipFile非法。
INVALIDPARAMETERVALUE_INLINEZIPFILE = 'InvalidParameterValue.InlineZipFile'
# InvokeType取值与规范不符，请修正后再试。
INVALIDPARAMETERVALUE_INVOKETYPE = 'InvalidParameterValue.InvokeType'
# L5Enable取值与规范不符，请修正后再试。
INVALIDPARAMETERVALUE_L5ENABLE = 'InvalidParameterValue.L5Enable'
# LayerName参数传入错误。
INVALIDPARAMETERVALUE_LAYERNAME = 'InvalidParameterValue.LayerName'
# Layers参数传入错误。
INVALIDPARAMETERVALUE_LAYERS = 'InvalidParameterValue.Layers'
# Limit传入错误。
INVALIDPARAMETERVALUE_LIMIT = 'InvalidParameterValue.Limit'
# 参数超出长度限制。
INVALIDPARAMETERVALUE_LIMITEXCEEDED = 'InvalidParameterValue.LimitExceeded'
# Memory取值与规范不符，请修正后再试。可参考：https://tencentcs.com/5jXKFnBW。
INVALIDPARAMETERVALUE_MEMORY = 'InvalidParameterValue.Memory'
# MemorySize错误。
INVALIDPARAMETERVALUE_MEMORYSIZE = 'InvalidParameterValue.MemorySize'
# MinCapacity 参数传入错误。
INVALIDPARAMETERVALUE_MINCAPACITY = 'InvalidParameterValue.MinCapacity'
# Name参数传入错误。
INVALIDPARAMETERVALUE_NAME = 'InvalidParameterValue.Name'
# Namespace参数传入错误。
INVALIDPARAMETERVALUE_NAMESPACE = 'InvalidParameterValue.Namespace'
# 规则不正确，Namespace为英文字母、数字、-_ 符号组成，长度30。
INVALIDPARAMETERVALUE_NAMESPACEINVALID = 'InvalidParameterValue.NamespaceInvalid'
# NodeSpec 参数传入错误。
INVALIDPARAMETERVALUE_NODESPEC = 'InvalidParameterValue.NodeSpec'
# NodeType 参数传入错误。
INVALIDPARAMETERVALUE_NODETYPE = 'InvalidParameterValue.NodeType'
# 偏移量不合法。
INVALIDPARAMETERVALUE_OFFSET = 'InvalidParameterValue.Offset'
# Order传入错误。
INVALIDPARAMETERVALUE_ORDER = 'InvalidParameterValue.Order'
# OrderBy取值与规范不符，请修正后再试。可参考：https://tencentcs.com/5jXKFnBW。
INVALIDPARAMETERVALUE_ORDERBY = 'InvalidParameterValue.OrderBy'
# 入参不是标准的json。
INVALIDPARAMETERVALUE_PARAM = 'InvalidParameterValue.Param'
# ProtocolType参数传入错误。
INVALIDPARAMETERVALUE_PROTOCOLTYPE = 'InvalidParameterValue.ProtocolType'
# 定时预置的cron配置重复。
INVALIDPARAMETERVALUE_PROVISIONTRIGGERCRONCONFIGDUPLICATE = 'InvalidParameterValue.ProvisionTriggerCronConfigDuplicate'
# TriggerName参数传入错误。
INVALIDPARAMETERVALUE_PROVISIONTRIGGERNAME = 'InvalidParameterValue.ProvisionTriggerName'
# TriggerName重复。
INVALIDPARAMETERVALUE_PROVISIONTRIGGERNAMEDUPLICATE = 'InvalidParameterValue.ProvisionTriggerNameDuplicate'
# ProvisionType 参数传入错误。
INVALIDPARAMETERVALUE_PROVISIONTYPE = 'InvalidParameterValue.ProvisionType'
# PublicNetConfig参数错误。
INVALIDPARAMETERVALUE_PUBLICNETCONFIG = 'InvalidParameterValue.PublicNetConfig'
# 不支持的函数版本。
INVALIDPARAMETERVALUE_QUALIFIER = 'InvalidParameterValue.Qualifier'
# 企业版镜像实例ID[RegistryId]传值错误。
INVALIDPARAMETERVALUE_REGISTRYID = 'InvalidParameterValue.RegistryId'
# RetCode不合法。
INVALIDPARAMETERVALUE_RETCODE = 'InvalidParameterValue.RetCode'
# RoutingConfig取值与规范不符，请修正后再试。可参考：https://tencentcs.com/5jXKFnBW。
INVALIDPARAMETERVALUE_ROUTINGCONFIG = 'InvalidParameterValue.RoutingConfig'
# Runtime传入错误。
INVALIDPARAMETERVALUE_RUNTIME = 'InvalidParameterValue.Runtime'
# searchkey 不是 Keyword,Tag 或者 Runtime。
INVALIDPARAMETERVALUE_SEARCHKEY = 'InvalidParameterValue.SearchKey'
# SecretInfo错误。
INVALIDPARAMETERVALUE_SECRETINFO = 'InvalidParameterValue.SecretInfo'
# ServiceName命名不规范。
INVALIDPARAMETERVALUE_SERVICENAME = 'InvalidParameterValue.ServiceName'
# Stamp取值与规范不符，请修正后再试。
INVALIDPARAMETERVALUE_STAMP = 'InvalidParameterValue.Stamp'
# 起始时间传入错误。
INVALIDPARAMETERVALUE_STARTTIME = 'InvalidParameterValue.StartTime'
# 需要同时指定开始日期与结束日期。
INVALIDPARAMETERVALUE_STARTTIMEORENDTIME = 'InvalidParameterValue.StartTimeOrEndTime'
# Status取值与规范不符，请修正后再试。
INVALIDPARAMETERVALUE_STATUS = 'InvalidParameterValue.Status'
# 系统环境变量错误。
INVALIDPARAMETERVALUE_SYSTEMENVIRONMENT = 'InvalidParameterValue.SystemEnvironment'
# 非法的TempCosObjectName。
INVALIDPARAMETERVALUE_TEMPCOSOBJECTNAME = 'InvalidParameterValue.TempCosObjectName'
# TraceEnable取值与规范不符，请修正后再试。
INVALIDPARAMETERVALUE_TRACEENABLE = 'InvalidParameterValue.TraceEnable'
# TrackingTarget 参数输入错误。
INVALIDPARAMETERVALUE_TRACKINGTARGET = 'InvalidParameterValue.TrackingTarget'
# TriggerCronConfig参数传入错误。
INVALIDPARAMETERVALUE_TRIGGERCRONCONFIG = 'InvalidParameterValue.TriggerCronConfig'
# TriggerCronConfig参数定时触发间隔小于指定值。
INVALIDPARAMETERVALUE_TRIGGERCRONCONFIGTIMEINTERVAL = 'InvalidParameterValue.TriggerCronConfigTimeInterval'
# TriggerDesc传入参数错误。
INVALIDPARAMETERVALUE_TRIGGERDESC = 'InvalidParameterValue.TriggerDesc'
# TriggerName传入错误。
INVALIDPARAMETERVALUE_TRIGGERNAME = 'InvalidParameterValue.TriggerName'
# TriggerProvisionedConcurrencyNum参数传入错误。
INVALIDPARAMETERVALUE_TRIGGERPROVISIONEDCONCURRENCYNUM = 'InvalidParameterValue.TriggerProvisionedConcurrencyNum'
# Type传入错误。
INVALIDPARAMETERVALUE_TYPE = 'InvalidParameterValue.Type'
# 开启cfs配置的同时必须开启vpc。
INVALIDPARAMETERVALUE_VPCNOTSETWHENOPENCFS = 'InvalidParameterValue.VpcNotSetWhenOpenCfs'
# WebSocketsParams参数传入错误。
INVALIDPARAMETERVALUE_WEBSOCKETSPARAMS = 'InvalidParameterValue.WebSocketsParams'
# 检测到不是标准的zip文件，请重新压缩后再试。
INVALIDPARAMETERVALUE_ZIPFILE = 'InvalidParameterValue.ZipFile'
# 压缩文件base64解码失败: `Incorrect padding`，请修正后再试。
INVALIDPARAMETERVALUE_ZIPFILEBASE64BINASCIIERROR = 'InvalidParameterValue.ZipFileBase64BinasciiError'
# 别名个数超过最大限制。
LIMITEXCEEDED_ALIAS = 'LimitExceeded.Alias'
# Cdn使用超过最大限制。
LIMITEXCEEDED_CDN = 'LimitExceeded.Cdn'
# eip资源超限。
LIMITEXCEEDED_EIP = 'LimitExceeded.Eip'
# 函数数量超出最大限制 ，可通过[提交工单](https://cloud.tencent.com/act/event/Online_service?from=scf%7Cindex)申请提升限制。
LIMITEXCEEDED_FUNCTION = 'LimitExceeded.Function'
# 同一个主题下的函数超过最大限制。
LIMITEXCEEDED_FUNCTIONONTOPIC = 'LimitExceeded.FunctionOnTopic'
# FunctionProvisionedConcurrencyMemory数量达到限制，可提交工单申请提升限制：https://tencentcs.com/7Fixwt63。
LIMITEXCEEDED_FUNCTIONPROVISIONEDCONCURRENCYMEMORY = 'LimitExceeded.FunctionProvisionedConcurrencyMemory'
# 函数保留并发内存超限。
LIMITEXCEEDED_FUNCTIONRESERVEDCONCURRENCYMEMORY = 'LimitExceeded.FunctionReservedConcurrencyMemory'
# FunctionTotalProvisionedConcurrencyMemory达到限制，可提交工单申请提升限制：https://tencentcs.com/7Fixwt63。
LIMITEXCEEDED_FUNCTIONTOTALPROVISIONEDCONCURRENCYMEMORY = 'LimitExceeded.FunctionTotalProvisionedConcurrencyMemory'
# 函数预置并发总数达到限制。
LIMITEXCEEDED_FUNCTIONTOTALPROVISIONEDCONCURRENCYNUM = 'LimitExceeded.FunctionTotalProvisionedConcurrencyNum'
# InitTimeout达到限制，可提交工单申请提升限制：https://tencentcs.com/7Fixwt63。
LIMITEXCEEDED_INITTIMEOUT = 'LimitExceeded.InitTimeout'
# layer版本数量超出最大限制。
LIMITEXCEEDED_LAYERVERSIONS = 'LimitExceeded.LayerVersions'
# layer数量超出最大限制。
LIMITEXCEEDED_LAYERS = 'LimitExceeded.Layers'
# 内存超出最大限制。
LIMITEXCEEDED_MEMORY = 'LimitExceeded.Memory'
# 函数异步重试配置消息保留时间超过限制。
LIMITEXCEEDED_MSGTTL = 'LimitExceeded.MsgTTL'
# 命名空间数量超过最大限制，可通过[提交工单](https://cloud.tencent.com/act/event/Online_service?from=scf%7Cindex)申请提升限制。
LIMITEXCEEDED_NAMESPACE = 'LimitExceeded.Namespace'
# Offset超出限制。
LIMITEXCEEDED_OFFSET = 'LimitExceeded.Offset'
# 定时预置数量超过最大限制。
LIMITEXCEEDED_PROVISIONTRIGGERACTION = 'LimitExceeded.ProvisionTriggerAction'
# 定时触发间隔小于最大限制。
LIMITEXCEEDED_PROVISIONTRIGGERINTERVAL = 'LimitExceeded.ProvisionTriggerInterval'
# 配额超限。
LIMITEXCEEDED_QUOTA = 'LimitExceeded.Quota'
# 函数异步重试配置异步重试次数超过限制。
LIMITEXCEEDED_RETRYNUM = 'LimitExceeded.RetryNum'
# Timeout超出最大限制。
LIMITEXCEEDED_TIMEOUT = 'LimitExceeded.Timeout'
# 用户并发内存配额超限。
LIMITEXCEEDED_TOTALCONCURRENCYMEMORY = 'LimitExceeded.TotalConcurrencyMemory'
# 触发器数量超出最大限制，可通过[提交工单](https://cloud.tencent.com/act/event/Online_service?from=scf%7Cindex)申请提升限制。
LIMITEXCEEDED_TRIGGER = 'LimitExceeded.Trigger'
# UserTotalConcurrencyMemory达到限制，可提交工单申请提升限制：https://tencentcs.com/7Fixwt63。
LIMITEXCEEDED_USERTOTALCONCURRENCYMEMORY = 'LimitExceeded.UserTotalConcurrencyMemory'
# 缺少参数错误。
MISSINGPARAMETER = 'MissingParameter'
# Code没有传入。
MISSINGPARAMETER_CODE = 'MissingParameter.Code'
# 缺失 Runtime 字段。
MISSINGPARAMETER_RUNTIME = 'MissingParameter.Runtime'
# 资源被占用。
RESOURCEINUSE = 'ResourceInUse'
# Alias已被占用。
RESOURCEINUSE_ALIAS = 'ResourceInUse.Alias'
# Cdn已被占用。
RESOURCEINUSE_CDN = 'ResourceInUse.Cdn'
# Cmq已被占用。
RESOURCEINUSE_CMQ = 'ResourceInUse.Cmq'
# Cos已被占用。
RESOURCEINUSE_COS = 'ResourceInUse.Cos'
# 函数已存在。
RESOURCEINUSE_FUNCTION = 'ResourceInUse.Function'
# FunctionName已存在。
RESOURCEINUSE_FUNCTIONNAME = 'ResourceInUse.FunctionName'
# Layer版本正在使用中。
RESOURCEINUSE_LAYERVERSION = 'ResourceInUse.LayerVersion'
# Namespace已存在。
RESOURCEINUSE_NAMESPACE = 'ResourceInUse.Namespace'
# TriggerName已存在。
RESOURCEINUSE_TRIGGER = 'ResourceInUse.Trigger'
# TriggerName已存在。
RESOURCEINUSE_TRIGGERNAME = 'ResourceInUse.TriggerName'
# COS资源不足。
RESOURCEINSUFFICIENT_COS = 'ResourceInsufficient.COS'
# 资源不存在。
RESOURCENOTFOUND = 'ResourceNotFound'
# 别名不存在。
RESOURCENOTFOUND_ALIAS = 'ResourceNotFound.Alias'
# 未找到指定的AsyncEvent，请创建后再试。
RESOURCENOTFOUND_ASYNCEVENT = 'ResourceNotFound.AsyncEvent'
# Cdn不存在。
RESOURCENOTFOUND_CDN = 'ResourceNotFound.Cdn'
# 指定的cfs下未找到您所指定的挂载点。
RESOURCENOTFOUND_CFSMOUNTINSNOTMATCH = 'ResourceNotFound.CfsMountInsNotMatch'
# 检测cfs状态为不可用。
RESOURCENOTFOUND_CFSSTATUSERROR = 'ResourceNotFound.CfsStatusError'
# cfs与云函数所处vpc不一致。
RESOURCENOTFOUND_CFSVPCNOTMATCH = 'ResourceNotFound.CfsVpcNotMatch'
# Ckafka不存在。
RESOURCENOTFOUND_CKAFKA = 'ResourceNotFound.Ckafka'
# Cmq不存在。
RESOURCENOTFOUND_CMQ = 'ResourceNotFound.Cmq'
# Cos不存在。
RESOURCENOTFOUND_COS = 'ResourceNotFound.Cos'
# 不存在的Demo。
RESOURCENOTFOUND_DEMO = 'ResourceNotFound.Demo'
# 函数不存在。
RESOURCENOTFOUND_FUNCTION = 'ResourceNotFound.Function'
# 函数不存在。
RESOURCENOTFOUND_FUNCTIONNAME = 'ResourceNotFound.FunctionName'
# 函数版本不存在。
RESOURCENOTFOUND_FUNCTIONVERSION = 'ResourceNotFound.FunctionVersion'
# 获取cfs挂载点信息错误。
RESOURCENOTFOUND_GETCFSMOUNTINSERROR = 'ResourceNotFound.GetCfsMountInsError'
# 获取cfs信息错误。
RESOURCENOTFOUND_GETCFSNOTMATCH = 'ResourceNotFound.GetCfsNotMatch'
# 未找到指定的ImageConfig，请创建后再试。
RESOURCENOTFOUND_IMAGECONFIG = 'ResourceNotFound.ImageConfig'
# layer不存在。
RESOURCENOTFOUND_LAYER = 'ResourceNotFound.Layer'
# Layer版本不存在。
RESOURCENOTFOUND_LAYERVERSION = 'ResourceNotFound.LayerVersion'
# Namespace不存在。
RESOURCENOTFOUND_NAMESPACE = 'ResourceNotFound.Namespace'
# 版本不存在。
RESOURCENOTFOUND_QUALIFIER = 'ResourceNotFound.Qualifier'
# 角色不存在。
RESOURCENOTFOUND_ROLE = 'ResourceNotFound.Role'
# Role不存在。
RESOURCENOTFOUND_ROLECHECK = 'ResourceNotFound.RoleCheck'
# Timer不存在。
RESOURCENOTFOUND_TIMER = 'ResourceNotFound.Timer'
# 并发内存配额资源未找到。
RESOURCENOTFOUND_TOTALCONCURRENCYMEMORY = 'ResourceNotFound.TotalConcurrencyMemory'
# 触发器不存在。
RESOURCENOTFOUND_TRIGGER = 'ResourceNotFound.Trigger'
# 版本不存在。
RESOURCENOTFOUND_VERSION = 'ResourceNotFound.Version'
# VPC或子网不存在。
RESOURCENOTFOUND_VPC = 'ResourceNotFound.Vpc'
# 余额不足，请先充值。
RESOURCEUNAVAILABLE_INSUFFICIENTBALANCE = 'ResourceUnavailable.InsufficientBalance'
# Namespace不可用。
RESOURCEUNAVAILABLE_NAMESPACE = 'ResourceUnavailable.Namespace'
# 未授权操作。
UNAUTHORIZEDOPERATION = 'UnauthorizedOperation'
# CAM鉴权失败。
UNAUTHORIZEDOPERATION_CAM = 'UnauthorizedOperation.CAM'
# 无访问代码权限。
UNAUTHORIZEDOPERATION_CODESECRET = 'UnauthorizedOperation.CodeSecret'
# 没有权限。
UNAUTHORIZEDOPERATION_CREATETRIGGER = 'UnauthorizedOperation.CreateTrigger'
# 没有权限的操作。
UNAUTHORIZEDOPERATION_DELETEFUNCTION = 'UnauthorizedOperation.DeleteFunction'
# 没有权限。
UNAUTHORIZEDOPERATION_DELETETRIGGER = 'UnauthorizedOperation.DeleteTrigger'
# 不是从控制台调用的该接口。
UNAUTHORIZEDOPERATION_NOTMC = 'UnauthorizedOperation.NotMC'
# Region错误。
UNAUTHORIZEDOPERATION_REGION = 'UnauthorizedOperation.Region'
# 没有权限访问您的Cos资源。
UNAUTHORIZEDOPERATION_ROLE = 'UnauthorizedOperation.Role'
# TempCos的Appid和请求账户的APPID不一致。
UNAUTHORIZEDOPERATION_TEMPCOSAPPID = 'UnauthorizedOperation.TempCosAppid'
# 无法进行此操作。
UNAUTHORIZEDOPERATION_UPDATEFUNCTIONCODE = 'UnauthorizedOperation.UpdateFunctionCode'
# 操作不支持。
UNSUPPORTEDOPERATION = 'UnsupportedOperation'
# 资源还有别名绑定，不支持当前操作，请解绑别名后重试。
UNSUPPORTEDOPERATION_ALIASBIND = 'UnsupportedOperation.AliasBind'
# 指定的配置AsyncRunEnable暂不支持，请修正后再试。
UNSUPPORTEDOPERATION_ASYNCRUNENABLE = 'UnsupportedOperation.AsyncRunEnable'
# Cdn不支持。
UNSUPPORTEDOPERATION_CDN = 'UnsupportedOperation.Cdn'
# Cos操作不支持。
UNSUPPORTEDOPERATION_COS = 'UnsupportedOperation.Cos'
# 指定的配置EipFixed暂不支持。
UNSUPPORTEDOPERATION_EIPFIXED = 'UnsupportedOperation.EipFixed'
# 不支持此地域。
UNSUPPORTEDOPERATION_REGION = 'UnsupportedOperation.Region'
# Trigger操作不支持。
UNSUPPORTEDOPERATION_TRIGGER = 'UnsupportedOperation.Trigger'
# 指定的配置暂不支持，请修正后再试。
UNSUPPORTEDOPERATION_UPDATEFUNCTIONEVENTINVOKECONFIG = 'UnsupportedOperation.UpdateFunctionEventInvokeConfig'
# 指定的配置VpcConfig暂不支持。
UNSUPPORTEDOPERATION_VPCCONFIG = 'UnsupportedOperation.VpcConfig'
",1
"istributions import MultivariateNormal
from gpytorch.kernels import InducingPointKernel, RBFKernel, ScaleKernel
from gpytorch.likelihoods import GaussianLikelihood
from gpytorch.means import ConstantMean
from gpytorch.priors import SmoothedBoxPrior
from gpytorch.test.utils import least_used_cuda_device
from gpytorch.utils.warnings import NumericalWarning
from torch import optim
# Simple training data: let's try to learn a sine function,
# but with SGPR
# let's use 100 training examples.
def make_data(cuda=False):
train_x = torch.linspace(0, 1, 100)
train_y = torch.sin(train_x * (2 * pi))
train_y.add_(torch.randn_like(train_y), alpha=1e-2)
test_x = torch.rand(51)
test_y = torch.sin(test_x * (2 * pi))
if cuda:
train_x = train_x.cuda()
train_y = train_y.cuda()
test_x = test_x.cuda()
test_y = test_y.cuda()
return train_x, train_y, test_x, test_y
class GPRegressionModel(gpytorch.models.ExactGP):
def __init__(self, train_x, train_y, likelihood):
super(GPRegressionModel, self).__init__(train_x, train_y, likelihood)
self.mean_module = ConstantMean(prior=SmoothedBoxPrior(-1e-5, 1e-5))
self.base_covar_module = ScaleKernel(RBFKernel(lengthscale_prior=SmoothedBoxPrior(exp(-5), exp(6), sigma=0.1)))
self.covar_module = InducingPointKernel(
self.base_covar_module, inducing_points=torch.linspace(0, 1, 32), likelihood=likelihood
)
def forward(self, x):
mean_x = self.mean_module(x)
covar_x = self.covar_module(x)
return MultivariateNormal(mean_x, covar_x)
class TestSGPRRegression(unittest.TestCase):
def setUp(self):
if os.getenv(""UNLOCK_SEED"") is None or os.getenv(""UNLOCK_SEED"").lower() == ""false"":
self.rng_state = torch.get_rng_state()
torch.manual_seed(0)
if torch.cuda.is_available():
torch.cuda.manual_seed_all(0)
random.seed(0)
def tearDown(self):
if hasattr(self, ""rng_state""):
torch.set_rng_state(self.rng_state)
def test_sgpr_mean_abs_error(self):
# Suppress numerical warnings
warnings.simplefilter(""ignore"", NumericalWarning)
train_x, train_y, test_x, test_y = make_data()
likelihood = GaussianLikelihood()
gp_model = GPRegressionModel(train_x, train_y, likelihood)
mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, gp_model)
# Optimize the model
gp_model.train()
likelihood.train()
optimizer = optim.Adam(gp_model.parameters(), lr=0.1)
for _ in range(30):
optimizer.zero_grad()
output = gp_model(train_x)
loss = -mll(output, train_y)
loss.backward()
optimizer.step()
for param in gp_model.parameters():
self.assertTrue(param.grad is not None)
self.assertGreater(param.grad.norm().item(), 0)
# Test the model
gp_model.eval()
likelihood.eval()
test_preds = likelihood(gp_model(test_x)).mean
mean_abs_error = torch.mean(torch.abs(test_y - test_preds))
self.assertLess(mean_abs_error.squeeze().item(), 0.05)
def test_sgpr_fast_pred_var(self):
# Suppress numerical warnings
warnings.simplefilter(""ignore"", NumericalWarning)
train_x, train_y, test_x, test_y = make_data()
likelihood = GaussianLikelihood()
gp_model = GPRegressionModel(train_x, train_y, likelihood)
mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, gp_model)
# Optimize the model
gp_model.train()
likelihood.train()
optimizer = optim.Adam(gp_model.parameters(), lr=0.1)
for _ in range(50):
optimizer.zero_grad()
output = gp_model(train_x)
loss = -mll(output, train_y)
loss.backward()
optimizer.step()
for param in gp_model.parameters():
self.assertTrue(param.grad is not None)
self.assertGreater(param.grad.norm().item(), 0)
# Test the model
gp_model.eval()
likelihood.eval()
with gpytorch.settings.max_preconditioner_size(5), gpytorch.settings.max_cg_iterations(50):
with gpytorch.settings.fast_pred_var(True):
fast_var = gp_model(test_x).variance
fast_var_cache = gp_model(test_x).variance
self.assertLess(torch.max((fast_var_cache - fast_var).abs()), 1e-3)
with gpytorch.settings.fast_pred_var(False):
slow_var = gp_model(test_x).variance
self.assertLess(torch.max((fast_var_cache - slow_var).abs()), 1e-3)
def test_sgpr_mean_abs_error_cuda(self):
# Suppress numerical warnings
warnings.simplefilter(""ignore"", NumericalWarning)
if not torch.cuda.is_available():
return
with least_used_cuda_device():
train_x, train_y, test_x, test_y = make_data(cuda=True)
likelihood = GaussianLikelihood().cuda()
gp_model = GPRegressionModel(train_x, train_y, likelihood).cuda()
mll = gpytorch.mlls.ExactMarginalLogLikelihood(likelihood, gp_model)
# Optimize the model
gp_model.train()
likelihood.train()
optimizer = optim.Adam(gp_model.parameters(), lr=0.1)
optimizer.n_iter = 0
for _ in range(25):
optimizer.zero_grad()
output = gp_model(train_x)
loss = -mll(output, train_y)
loss.backward()
optimizer.n_iter += 1
optimizer.step()
for param in gp_model.parameters():
self.assertTrue(param.grad is not None)
self.assertGreater(param.grad.norm().item(), 0)
# Test the model
gp_model.eval()
likelihood.eval()
test_preds = likelihood(gp_model(test_x)).mean
mean_abs_error = torch.mean(torch.abs(test_y - test_preds))
self.assertLess(mean_abs_error.squeeze().item(), 0.02)
if __name__ == ""__main__"":
unittest.main()
",1
" = ""insert""
KEY_HOME = ""home""
KEY_END = ""end""
KEY_PAGEUP = ""pageup""
KEY_PAGEDOWN = ""pagedown""
KEY_BACKSPACE = ""backspace""
KEY_DELETE = ""delete""
KEY_TAB = ""tab""
KEY_ENTER = ""enter""
KEY_PAUSE = ""pause""
KEY_ESCAPE = ""escape""
KEY_SPACE = ""space""
KEY_KEYPAD0 = ""keypad0""
KEY_KEYPAD1 = ""keypad1""
KEY_KEYPAD2 = ""keypad2""
KEY_KEYPAD3 = ""keypad3""
KEY_KEYPAD4 = ""keypad4""
KEY_KEYPAD5 = ""keypad5""
KEY_KEYPAD6 = ""keypad6""
KEY_KEYPAD7 = ""keypad7""
KEY_KEYPAD8 = ""keypad8""
KEY_KEYPAD9 = ""keypad9""
KEY_KEYPAD_PERIOD = ""keypad_period""
KEY_KEYPAD_DIVIDE = ""keypad_divide""
KEY_KEYPAD_MULTIPLY = ""keypad_multiply""
KEY_KEYPAD_MINUS = ""keypad_minus""
KEY_KEYPAD_PLUS = ""keypad_plus""
KEY_KEYPAD_ENTER = ""keypad_enter""
KEY_CLEAR = ""clear""
KEY_F1 = ""f1""
KEY_F2 = ""f2""
KEY_F3 = ""f3""
KEY_F4 = ""f4""
KEY_F5 = ""f5""
KEY_F6 = ""f6""
KEY_F7 = ""f7""
KEY_F8 = ""f8""
KEY_F9 = ""f9""
KEY_F10 = ""f10""
KEY_F11 = ""f11""
KEY_F12 = ""f12""
KEY_F13 = ""f13""
KEY_F14 = ""f14""
KEY_F15 = ""f15""
KEY_F16 = ""f16""
KEY_F17 = ""f17""
KEY_F18 = ""f18""
KEY_F19 = ""f19""
KEY_F20 = ""f20""
KEY_SYSREQ = ""sysreq""
KEY_BREAK = ""break""
KEY_CONTEXT_MENU = ""context_menu""
KEY_BROWSER_BACK = ""browser_back""
KEY_BROWSER_FORWARD = ""browser_forward""
KEY_BROWSER_REFRESH = ""browser_refresh""
KEY_BROWSER_STOP = ""browser_stop""
KEY_BROWSER_SEARCH = ""browser_search""
KEY_BROWSER_FAVORITES = ""browser_favorites""
KEY_BROWSER_HOME = ""browser_home""
",1
"port Parallel
#-------------------------------------------------------------------------
#
# conftools.py is a simple module to manage .xml configuration files
#
#-------------------------------------------------------------------------
if __name__ == '__main__':
""""""
VARIABLES
""""""
args = sys.argv
config_file_name = args[1]
""""""
CODE
""""""
parallel = Parallel()
parallel.create_config_files(config_file_name)
",1
"# 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.
#
# Ansible 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 Ansible. If not, see [^/]+)$',
MethodDispatcher({ 'DELETE' : carenet_account_delete })),
# Manage apps
(r'^/apps/$',
MethodDispatcher({ 'GET' : carenet_apps_list})),
(r'^/apps/(?P[^/]+)$',
MethodDispatcher({ 'PUT' : carenet_apps_create,
'DELETE': carenet_apps_delete})),
# Permissions Calls
(r'^/accounts/(?P[^/]+)/permissions$',
MethodDispatcher({ 'GET' : carenet_account_permissions })),
(r'^/apps/(?P[^/]+)/permissions$',
MethodDispatcher({ 'GET' : carenet_app_permissions })),
# Reporting Calls
(r'^/reports/minimal/procedures/$',
MethodDispatcher({'GET':carenet_procedure_list})),
(r'^/reports/minimal/simple-clinical-notes/$',
MethodDispatcher({'GET':carenet_simple_clinical_notes_list})),
(r'^/reports/minimal/equipment/$',
MethodDispatcher({'GET':carenet_equipment_list})),
(r'^/reports/minimal/measurements/(?P[^/]+)/$',
MethodDispatcher({'GET':carenet_measurement_list})),
(r'^/reports/(?P[^/]+)/$',
MethodDispatcher({'GET':carenet_generic_list})),
# Demographics
(r'^/demographics$', MethodDispatcher({'GET': read_demographics_carenet})),
)
",1
"shutil
from gnupg import GPG
def setup_keyring(keyring_name):
'''Setup the keyring'''
keyring_path = os.path.join(""test"", ""outputdata"", keyring_name)
# Delete the entire keyring
shutil.rmtree(keyring_path, ignore_errors=True)
os.makedirs(keyring_path)
gpg = GPG(gnupghome=keyring_path, gpgbinary=""gpg"")
for key_name in [""key1_private"", ""key1_public""]:
with open(os.path.join(""test"", ""inputdata"", key_name + "".txt""), ""r"") as keyfile:
key_str = """".join(keyfile.readlines())
import_result = gpg.import_keys(key_str)
print(""Import result:"", type(import_result))
print(import_result.__dict__)
if import_result.count == 1 and len(set(import_result.fingerprints)) == 1:
print(""Got one import result"")
return gpg
CRYPTO = setup_keyring(""keyringtest"")
if CRYPTO:
print(""Ready"", CRYPTO)
KEY_LIST = CRYPTO.list_keys(False)
NUM_KEYS = len(KEY_LIST) if KEY_LIST else 0
print(""Number of public keys:"", NUM_KEYS)
if NUM_KEYS < 1:
print(""ERROR: Number of keys should be 1, not"", NUM_KEYS)
KEY_LIST = CRYPTO.list_keys(True)
NUM_KEYS = len(KEY_LIST) if KEY_LIST else 0
print(""Number of private keys:"", NUM_KEYS)
if NUM_KEYS < 1:
print(""ERROR: Number of keys should be 1, not"", NUM_KEYS)
",1
".
# Licensed under the MIT License. See License.txt in the project root for
# license information.
#
# Code generated by Microsoft (R) AutoRest Code Generator.
# Changes may cause incorrect behavior and will be lost if the code is
# regenerated.
# --------------------------------------------------------------------------
from msrest.serialization import Model
class Destination(Model):
""""""Capture storage details for capture description.
:param name: Name for capture destination
:type name: str
:param storage_account_resource_id: Resource id of the storage account to
be used to create the blobs
:type storage_account_resource_id: str
:param blob_container: Blob container Name
:type blob_container: str
:param archive_name_format: Blob naming convention for archive, e.g.
{Namespace}/{EventHub}/{PartitionId}/{Year}/{Month}/{Day}/{Hour}/{Minute}/{Second}.
Here all the parameters (Namespace,EventHub .. etc) are mandatory
irrespective of order
:type archive_name_format: str
""""""
_attribute_map = {
'name': {'key': 'name', 'type': 'str'},
'storage_account_resource_id': {'key': 'properties.storageAccountResourceId', 'type': 'str'},
'blob_container': {'key': 'properties.blobContainer', 'type': 'str'},
'archive_name_format': {'key': 'properties.archiveNameFormat', 'type': 'str'},
}
def __init__(self, name=None, storage_account_resource_id=None, blob_container=None, archive_name_format=None):
self.name = name
self.storage_account_resource_id = storage_account_resource_id
self.blob_container = blob_container
self.archive_name_format = archive_name_format
",1
"oftware 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 TYPE_CHECKING, Any, Dict, Union
from ansiblelint.rules import AnsibleLintRule
if TYPE_CHECKING:
from typing import Optional
from ansiblelint.file_utils import Lintable
class MercurialHasRevisionRule(AnsibleLintRule):
id = 'hg-latest'
shortdesc = 'Mercurial checkouts must contain explicit revision'
description = (
'All version control checkouts must point to '
'an explicit commit or tag, not just ``latest``'
)
severity = 'MEDIUM'
tags = ['idempotency']
version_added = 'historic'
def matchtask(
self, task: Dict[str, Any], file: 'Optional[Lintable]' = None
) -> Union[bool, str]:
return bool(
task['action']['__ansible_module__'] == 'hg'
and task['action'].get('revision', 'default') == 'default'
)
",1
"
def x(self):
pass
def fun(obj):
pass
class Class2(object):
def __call__(self, obj):
pass
class SaferefTests(Case):
def setUp(self):
ts = []
ss = []
for x in xrange(5000):
t = Class1()
ts.append(t)
s = safe_ref(t.x, self._closure)
ss.append(s)
ts.append(fun)
ss.append(safe_ref(fun, self._closure))
for x in xrange(30):
t = Class2()
ts.append(t)
s = safe_ref(t, self._closure)
ss.append(s)
self.ts = ts
self.ss = ss
self.closureCount = 0
def tearDown(self):
del self.ts
del self.ss
def testIn(self):
""""""Test the ""in"" operator for safe references (cmp)""""""
for t in self.ts[:50]:
self.assertTrue(safe_ref(t.x) in self.ss)
def testValid(self):
""""""Test that the references are valid (return instance methods)""""""
for s in self.ss:
self.assertTrue(s())
def testShortCircuit(self):
""""""Test that creation short-circuits to reuse existing references""""""
sd = {}
for s in self.ss:
sd[s] = 1
for t in self.ts:
if hasattr(t, 'x'):
self.assertIn(safe_ref(t.x), sd)
else:
self.assertIn(safe_ref(t), sd)
def testRepresentation(self):
""""""Test that the reference object's representation works
XXX Doesn't currently check the results, just that no error
is raised
""""""
repr(self.ss[-1])
def _closure(self, ref):
""""""Dumb utility mechanism to increment deletion counter""""""
self.closureCount += 1
",1
"t and/or modify
# it under the terms of the GNU Affero 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see "")
if not prop_parent:
pg.Append(prop_group)
else:
pg.AppendIn(prev_group, prop_group)
prop_parent = prop_group
self.groups[group] = prop_parent
pg.SetPropertyReadOnly(group)
pg.AppendIn(spec.group, prop)
pg.Collapse(spec.group)
name = spec.group + ""."" + name
if spec.type == ""boolean"":
pg.SetPropertyAttribute(name, ""UseCheckbox"", True)
doc = spec.__doc__
if doc:
pg.SetPropertyHelpString(name, doc)
def edit(self, name=""""):
""Programatically select a (default) property to start editing it""
# for more info see DoSelectAndEdit in propgrid.cpp
for name in (name, ""label"", ""value"", ""text"", ""title"", ""filename"",
""name""):
prop = self.pg.GetPropertyByName(name)
if prop is not None:
break
self.Parent.SetFocus()
self.Parent.Raise()
self.pg.SetFocus()
# give time to the ui to show the prop grid and set focus:
wx.CallLater(250, self.select, prop.GetName())
def select(self, name, flags=0):
""Select a property (and start the editor)""
# do not call this directly from another window, use edit() instead
# // wxPropertyGrid::DoSelectProperty flags (selFlags) -see propgrid.h-
wxPG_SEL_FOCUS=0x0001 # Focuses to created editor
wxPG_SEL_FORCE=0x0002 # Forces deletion and recreation of editor
flags |= wxPG_SEL_FOCUS # | wxPG_SEL_FORCE
prop = self.pg.GetPropertyByName(name)
self.pg.SelectProperty(prop, flags)
if DEBUG: print ""selected!"", prop
def OnPropGridChange(self, event):
p = event.GetProperty()
if DEBUG: print ""change!"", p
if p:
name = p.GetName()
spec = p.GetPyClientData()
if spec and 'enum' in spec.type:
value = p.GetValueAsString()
else:
value = p.GetValue()
#self.log.write(u'%s changed to ""%s""\n' % (p,p.GetValueAsString()))
# if it a property child (parent.child), extract its name
if ""."" in name:
name = name[name.rindex(""."") + 1:]
if spec and not name in self.groups:
if name == 'font': # TODO: detect property type
# create a gui font from the wx.Font
font = Font()
font.set_wx_font(value)
value = font
# expressions must be evaluated to store the python object
if spec.type == ""expr"":
value = eval(value)
# re-create the wx_object with the new property value
# (this is required at least to apply new styles and init specs)
if DEBUG: print ""changed"", self.obj.name
kwargs = {str(name): value}
wx.CallAfter(self.obj.rebuild, **kwargs)
if name == 'name':
wx.CallAfter(self.callback, **dict(name=self.obj.name))
def OnPropGridSelect(self, event):
p = event.GetProperty()
if p:
self.log.write(u'%s selected\n' % (event.GetProperty().GetName()))
else:
self.log.write(u'Nothing selected\n')
def OnDeleteProperty(self, event):
p = self.pg.GetSelectedProperty()
if p:
self.pg.DeleteProperty(p)
else:
wx.MessageBox(""First select a property to delete"")
def OnReserved(self, event):
pass
def OnPropGridRightClick(self, event):
p = event.GetProperty()
if p:
self.log.write(u'%s right clicked\n' % (event.GetProperty().GetName()))
else:
self.log.write(u'Nothing right clicked\n')
#self.obj.get_parent().Refresh()
def OnPropGridPageChange(self, event):
index = self.pg.GetSelectedPage()
self.log.write('Page Changed to \'%s\'\n' % (self.pg.GetPageName(index)))
if __name__ == '__main__':
import sys,os
app = wx.App()
f = wx.Frame(None)
from gui.controls import Button, Label, TextBox, CheckBox, ListBox, ComboBox
frame = wx.Frame(None)
#o = Button(frame, name=""btnTest"", label=""click me!"", default=True)
#o = Label(frame, name=""lblTest"", alignment=""right"", size=(-1, 500), text=""hello!"")
o = TextBox(frame, name=""txtTest"", border=False, text=""hello world!"")
#o = CheckBox(frame, name=""chkTest"", border='none', label=""Check me!"")
#o = ListBox(frame, name=""lstTest"", border='none',
# items={'datum1': 'a', 'datum2':'b', 'datum3':'c'},
# multiselect=""--multiselect"" in sys.argv)
#o = ComboBox(frame, name=""cboTest"",
# items={'datum1': 'a', 'datum2':'b', 'datum3':'c'},
# readonly='--readonly' in sys.argv,
# )
frame.Show()
log = sys.stdout
w = PropertyEditorPanel(f, log)
w.load_object(o)
f.Show()
app.MainLoop()
",1
"nning as root.
Derived from ping.c distributed in Linux's netkit. That code is
copyright (c) 1989 by The Regents of the University of California.
That code is in turn derived from code written by Mike Muuss of the
US Army Ballistic Research Laboratory in December, 1983 and
placed in the public domain. They have my thanks.
Bugs are naturally mine. I'd be glad to hear about them. There are
certainly word - size dependenceies here.
Copyright (c) Matthew Dixon Cowles, > 16) + (sum & 0xffff)
sum = sum + (sum >> 16)
answer = ~sum
answer = answer & 0xffff
# Swap bytes. Bugger me if I know why.
answer = answer >> 8 | (answer << 8 & 0xff00)
return answer
def receive_one_ping(my_socket, ID, timeout):
""""""
receive the ping from the socket.
""""""
timeLeft = timeout
while True:
startedSelect = time.time()
whatReady = select.select([my_socket], [], [], timeLeft)
howLongInSelect = (time.time() - startedSelect)
if whatReady[0] == []: # Timeout
return
timeReceived = time.time()
recPacket, addr = my_socket.recvfrom(1024)
icmpHeader = recPacket[20:28]
type, code, checksum, packetID, sequence = struct.unpack(
""bbHHh"", icmpHeader
)
if packetID == ID:
bytesInDouble = struct.calcsize(""d"")
timeSent = struct.unpack(""d"", recPacket[28:28 + bytesInDouble])[0]
return timeReceived - timeSent
timeLeft = timeLeft - howLongInSelect
if timeLeft <= 0:
return
def send_one_ping(my_socket, dest_addr, ID):
""""""
Send one ping to the given >dest_addr<.
""""""
dest_addr = socket.gethostbyname(dest_addr)
# Header is type (8), code (8), checksum (16), id (16), sequence (16)
my_checksum = 0
# Make a dummy heder with a 0 checksum.
header = struct.pack(""bbHHh"", ICMP_ECHO_REQUEST, 0, my_checksum, ID, 1)
bytesInDouble = struct.calcsize(""d"")
data = (192 - bytesInDouble) * ""Q""
data = struct.pack(""d"", time.time()) + data
# Calculate the checksum on the data and the dummy header.
my_checksum = checksum(header + data)
# Now that we have the right checksum, we put that in. It's just easier
# to make up a new header than to stuff it into the dummy.
header = struct.pack(
""bbHHh"", ICMP_ECHO_REQUEST, 0, socket.htons(my_checksum), ID, 1
)
packet = header + data
my_socket.sendto(packet, (dest_addr, 1)) # Don't know about the 1
def do_one(dest_addr, timeout):
""""""
Returns either the delay (in seconds) or none on timeout.
""""""
icmp = socket.getprotobyname(""icmp"")
try:
my_socket = socket.socket(socket.AF_INET, socket.SOCK_RAW, icmp)
except socket.error, (errno, msg):
if errno == 1:
# Operation not permitted
msg = msg + (
"" - Note that ICMP messages can only be sent from processes""
"" running as root.""
)
raise socket.error(msg)
raise # raise the original error
my_ID = os.getpid() & 0xFFFF
send_one_ping(my_socket, dest_addr, my_ID)
delay = receive_one_ping(my_socket, my_ID, timeout)
my_socket.close()
return delay
def verbose_ping(dest_addr, timeout = 2, count = 4):
""""""
Send >count< ping to >dest_addr< with the given >timeout< and display
the result.
""""""
for i in xrange(count):
print ""ping %s..."" % dest_addr,
try:
delay = do_one(dest_addr, timeout)
except socket.gaierror, e:
print ""failed. (socket error: '%s')"" % e[1]
break
if delay == None:
print ""failed. (timeout within %ssec.)"" % timeout
else:
delay = delay * 1000
print ""get ping in %0.4fms"" % delay
print
if __name__ == '__main__':
#verbose_ping(""192.168.0.4"",timeout=0.1,count=1)
result=do_one(""192.168.0.4"", 0.1)
print result
",1
" 'uri_binding': 'cpe:/a:string_value_with\:double_points:internet_explorer:4.0:beta:~~~android_marshmallow~~'},
{'wfn': {'version': '1.0.1.2', 'target_sw': 'android_marshmallow'},
'uri_binding': 'cpe:/a:string_value_with\:double_points:internet_explorer:1.0.1.2:beta'},
{'wfn': {'version': '4.1.2', 'target_sw': 'ANY'},
'uri_binding': 'cpe:/a:string_value_with\:double_points:internet_explorer:4.1.2:beta'},
{'wfn': {'version': '4.6.3', 'target_sw': 'windows'},
'uri_binding': 'cpe:/a:string_value_with\:double_points:internet_explorer:4.6.3:beta:~~~windows~~'},
{'wfn': {'version': '4.7.1', 'target_sw': 'android'},
'uri_binding': 'cpe:/a:string_value_with\:double_points:internet_explorer:4.7.1:beta:~~~android~~'},
{'wfn': {'version': '4.7.2', 'target_sw': 'ANY'},
'uri_binding':'cpe:/a:string_value_with\:double_points:internet_explorer:4.7.2:beta'},
{'wfn': {'version': '4.3.2', 'target_sw': 'linux'},
'uri_binding': 'cpe:/a:string_value_with\:double_points:internet_explorer:4.3.2:beta:~~~linux~~'},
{'wfn': {'version': '2.3.1', 'target_sw': 'linux'},
'uri_binding': 'cpe:/a:string_value_with\:double_points:internet_explorer:2.3.1:beta'},
{'wfn': {'version': '4.7.3', 'target_sw': 'mac_os_x'},
'uri_binding': 'cpe:/a:string_value_with\:double_points:internet_explorer:4.7.3:beta:~~~mac_os_x~~'}
]
unsorted_cpes_year = [{'wfn': {'version': '2000', 'target_sw': 'android_marshmallow'},
'uri_binding': 'cpe:/a:string_value_with\:double_points:internet_explorer:2000:beta:~~~android_marshmallow~~'},
{'wfn': {'version': '2007', 'target_sw': 'android_marshmallow'},
'uri_binding': 'cpe:/a:string_value_with\:double_points:internet_explorer:2007:beta'},
{'wfn': {'version': '4.1.2', 'target_sw': 'ANY'},
'uri_binding': 'cpe:/a:string_value_with\:double_points:internet_explorer:4.1.2:beta'},
{'wfn': {'version': '2010', 'target_sw': 'windows'},
'uri_binding': 'cpe:/a:string_value_with\:double_points:internet_explorer:2010:beta:~~~windows~~'},
{'wfn': {'version': '4.7.1', 'target_sw': 'android'},
'uri_binding': 'cpe:/a:string_value_with\:double_points:internet_explorer:4.7.1:beta:~~~android~~'},
{'wfn': {'version': '2001', 'target_sw': 'ANY'},
'uri_binding':'cpe:/a:string_value_with\:double_points:internet_explorer:2001:beta'},
{'wfn': {'version': '4.3.2', 'target_sw': 'linux'},
'uri_binding': 'cpe:/a:string_value_with\:double_points:internet_explorer:4.3.2:beta:~~~linux~~'},
{'wfn': {'version': '2010', 'target_sw': 'linux'},
'uri_binding': 'cpe:/a:string_value_with\:double_points:internet_explorer:2010:beta'},
{'wfn': {'version': '4.7.3', 'target_sw': 'mac_os_x'},
'uri_binding': 'cpe:/a:string_value_with\:double_points:internet_explorer:4.7.3:beta:~~~mac_os_x~~'},
{'wfn': {'version': '2010', 'target_sw': 'mac_os_x'},
'uri_binding': 'cpe:/a:string_value_with\:double_points:internet_explorer:2010:beta:~~~mac_os_x~~'}]
version = '4.7.2'
version_without_points = '4_7-2'
version_year = '2010'
os_windows = 'windows_7'
os_linux = 'linux_ubuntu'
os_android = 'android'
os_mac = 'mac_os_x_10.11'
class TestCPESorter(unittest.TestCase):
def test_sort_cpes_by_software_version(self):
sorted_cpes = sort_cpes_by_version(unsorted_cpes, version)
self.assertEqual(len(unsorted_cpes), len(sorted_cpes))
self.assertEqual(unsorted_cpes[5], sorted_cpes[0]) # 4.7.2
self.assertEqual(unsorted_cpes[4], sorted_cpes[1]) # 4.7.1
self.assertEqual(unsorted_cpes[8], sorted_cpes[2]) # 4.7.3
self.assertEqual(unsorted_cpes[0], sorted_cpes[3]) # 4.0
self.assertEqual(unsorted_cpes[2], sorted_cpes[4]) # 4.1.2
self.assertEqual(unsorted_cpes[3], sorted_cpes[5]) # 4.6.3
self.assertEqual(unsorted_cpes[6], sorted_cpes[6]) # 4.3.2
def test_cpes_and_sorted_cpes_are_equal_when_software_version_not_splitted_by_points(self):
sorted_cpes = sort_cpes_by_version(unsorted_cpes, version_without_points)
self.assertListEqual(unsorted_cpes, sorted_cpes)
def test_sort_cpes_by_version_with_year(self):
sorted_cpes = sort_cpes_by_version(unsorted_cpes_year, version_year)
self.assertEqual(len(unsorted_cpes_year), len(sorted_cpes))
self.assertEqual(unsorted_cpes_year[3], sorted_cpes[0]) # 2010
self.assertEqual(unsorted_cpes_year[7], sorted_cpes[1]) # 2010
self.assertEqual(unsorted_cpes_year[9], sorted_cpes[2]) # 2010
self.assertEqual(unsorted_cpes_year[0], sorted_cpes[3]) # 2000
self.assertEqual(unsorted_cpes_year[1], sorted_cpes[4]) # 2007
self.assertEqual(unsorted_cpes_year[5], sorted_cpes[5]) # 2001
def test_sort_cpes_by_operating_system_windows(self):
sorted_cpes = sort_cpes_by_operating_system(unsorted_cpes, os_windows)
self.assertEqual(len(unsorted_cpes), len(sorted_cpes))
self.assertEqual(unsorted_cpes[3], sorted_cpes[0])
def test_sort_cpes_by_operating_system_linux(self):
sorted_cpes = sort_cpes_by_operating_system(unsorted_cpes, os_linux)
self.assertEqual(len(unsorted_cpes), len(sorted_cpes))
self.assertEqual(unsorted_cpes[6], sorted_cpes[0])
def test_sort_cpes_by_operating_system_android(self):
sorted_cpes = sort_cpes_by_operating_system(unsorted_cpes, os_android)
self.assertEqual(len(unsorted_cpes), len(sorted_cpes))
self.assertEqual(unsorted_cpes[4], sorted_cpes[0])
self.assertEqual(unsorted_cpes[0], sorted_cpes[1])
if __name__ == '__main__':
unittest.main()
",1
"ecific offset you want to do things from, use pack_into and unack_into from the docs '''
#Integer to string
i1= 1234
print ""Int to string as 8 byte little endian"", repr(struct.pack(""Q"",i1))
#String to integer. Make sure size of destination matches the length of the string
s1= '1234'
print ""String to 4 byte integer little endian"", struct.unpack(""i"", s1)
''' Whenever you want to convert to and from binary, think of binascii '''
import binascii
h1= binascii.b2a_hex(s1)
print ""String to hex"", h1
uh1= binascii.a2b_hex(h1)
print ""Hex to string, even a binary string"", uh1
",1
"org/licenses/gpl-3.0.txt)
from __future__ import absolute_import, division, print_function
__metaclass__ = type
DOCUMENTATION = r'''
---
module: bigiq_regkey_license_assignment
short_description: Manage regkey license assignment on BIG-IPs from a BIG-IQ
description:
- Manages the assignment of regkey licenses on a BIG-IQ. Assignment means
the license is assigned to a BIG-IP, or it needs to be assigned to a BIG-IP.
Additionally, this module supports revoking the assignments from BIG-IP devices.
version_added: ""1.0.0""
options:
pool:
description:
- The registration key pool to use.
type: str
required: True
key:
description:
- The registration key you want to assign from the pool.
type: str
required: True
device:
description:
- When C(managed) is C(no), specifies the address, or hostname, where the BIG-IQ
can reach the remote device to register.
- When C(managed) is C(yes), specifies the managed device, or device UUID, that
you want to register.
- If C(managed) is C(yes), it is very important you do not have more than
one device with the same name. BIG-IQ internally recognizes devices by their ID,
and therefore, this module cannot guarantee the correct device will be
registered. The device returned is the device that is used.
type: str
required: True
managed:
description:
- Whether the specified device is a managed or un-managed device.
- When C(state) is C(present), this parameter is required.
type: bool
device_port:
description:
- Specifies the port of the remote device to connect to.
- If this parameter is not specified, the default is C(443).
type: int
default: 443
device_username:
description:
- The username used to connect to the remote device.
- This username should be one that has sufficient privileges on the remote device
to do licensing. Usually this is the C(Administrator) role.
- When C(managed) is C(no), this parameter is required.
type: str
device_password:
description:
- The password of the C(device_username).
- When C(managed) is C(no), this parameter is required.
type: str
state:
description:
- When C(present), ensures the device is assigned the specified license.
- When C(absent), ensures the license is revoked from the remote device and freed
on the BIG-IQ.
type: str
choices:
- present
- absent
default: present
extends_documentation_fragment: f5networks.f5_modules.f5
author:
- Tim Rupp (@caphrim007)
'''
EXAMPLES = r'''
- name: Register an unmanaged device
bigiq_regkey_license_assignment:
pool: my-regkey-pool
key: XXXX-XXXX-XXXX-XXXX-XXXX
device: 1.1.1.1
managed: no
device_username: admin
device_password: secret
state: present
provider:
user: admin
password: secret
server: lb.mydomain.com
delegate_to: localhost
- name: Register a managed device, by name
bigiq_regkey_license_assignment:
pool: my-regkey-pool
key: XXXX-XXXX-XXXX-XXXX-XXXX
device: bigi1.foo.com
managed: yes
state: present
provider:
user: admin
password: secret
server: lb.mydomain.com
delegate_to: localhost
- name: Register a managed device, by UUID
bigiq_regkey_license_assignment:
pool: my-regkey-pool
key: XXXX-XXXX-XXXX-XXXX-XXXX
device: 7141a063-7cf8-423f-9829-9d40599fa3e0
managed: yes
state: present
provider:
user: admin
password: secret
server: lb.mydomain.com
delegate_to: localhost
'''
RETURN = r'''
# only common fields returned
'''
import re
import time
from datetime import datetime
from ansible.module_utils.basic import AnsibleModule
from ..module_utils.bigip import F5RestClient
from ..module_utils.common import (
F5ModuleError, AnsibleF5Parameters, f5_argument_spec
)
from ..module_utils.icontrol import bigiq_version
from ..module_utils.ipaddress import is_valid_ip
from ..module_utils.teem import send_teem
class Parameters(AnsibleF5Parameters):
api_map = {
'deviceReference': 'device_reference',
'deviceAddress': 'device_address',
'httpsPort': 'device_port'
}
api_attributes = [
'deviceReference', 'deviceAddress', 'httpsPort', 'managed'
]
returnables = [
'device_address', 'device_reference', 'device_username', 'device_password',
'device_port', 'managed'
]
updatables = [
'device_reference', 'device_address', 'device_username', 'device_password',
'device_port', 'managed'
]
def to_return(self):
result = {}
try:
for returnable in self.returnables:
result[returnable] = getattr(self, returnable)
result = self._filter_params(result)
except Exception:
raise
return result
class ApiParameters(Parameters):
pass
class ModuleParameters(Parameters):
@property
def device_password(self):
if self._values['device_password'] is None:
return None
return self._values['device_password']
@property
def device_username(self):
if self._values['device_username'] is None:
return None
return self._values['device_username']
@property
def device_address(self):
if self.device_is_address:
return self._values['device']
@property
def device_port(self):
if self._values['device_port'] is None:
return None
return int(self._values['device_port'])
@property
def device_is_address(self):
if is_valid_ip(self.device):
return True
return False
@property
def device_is_id(self):
pattern = r'[A-Za-z0-9]{8}-[A-Za-z0-9]{4}-[A-Za-z0-9]{4}-[A-Za-z0-9]{4}-[A-Za-z0-9]{12}'
if re.match(pattern, self.device):
return True
return False
@property
def device_is_name(self):
if not self.device_is_address and not self.device_is_id:
return True
return False
@property
def device_reference(self):
if not self.managed:
return None
if self.device_is_address:
# This range lookup is how you do lookups for single IP addresses. Weird.
filter = ""address+eq+'{0}...{0}'"".format(self.device)
elif self.device_is_name:
filter = ""hostname+eq+'{0}'"".format(self.device)
elif self.device_is_id:
filter = ""uuid+eq+'{0}'"".format(self.device)
else:
raise F5ModuleError(
""Unknown device format '{0}'"".format(self.device)
)
uri = ""https://{0}:{1}/mgmt/shared/resolver/device-groups/cm-bigip-allBigIpDevices/devices/"" \
""?$filter={2}&$top=1"".format(self.client.provider['server'],
self.client.provider['server_port'], filter)
resp = self.client.api.get(uri)
try:
response = resp.json()
except ValueError as ex:
raise F5ModuleError(str(ex))
if resp.status == 200 and response['totalItems'] == 0:
raise F5ModuleError(
""No device with the specified address was found.""
)
elif 'code' in response and response['code'] == 400:
if 'message' in response:
raise F5ModuleError(response['message'])
else:
raise F5ModuleError(resp._content)
id = response['items'][0]['uuid']
result = dict(
link='https://localhost/mgmt/shared/resolver/device-groups/cm-bigip-allBigIpDevices/devices/{0}'.format(id)
)
return result
@property
def pool_id(self):
filter = ""(name%20eq%20'{0}')"".format(self.pool)
uri = 'https://{0}:{1}/mgmt/cm/device/licensing/pool/regkey/licenses?$filter={2}&$top=1'.format(
self.client.provider['server'],
self.client.provider['server_port'],
filter
)
resp = self.client.api.get(uri)
try:
response = resp.json()
except ValueError as ex:
raise F5ModuleError(str(ex))
if resp.status == 200 and response['totalItems'] == 0:
raise F5ModuleError(
""No pool with the specified name was found.""
)
elif 'code' in response and response['code'] == 400:
if 'message' in response:
raise F5ModuleError(response['message'])
else:
raise F5ModuleError(resp._content)
return response['items'][0]['id']
@property
def member_id(self):
if self.device_is_address:
# This range lookup is how you do lookups for single IP addresses. Weird.
filter = ""deviceAddress+eq+'{0}...{0}'"".format(self.device)
elif self.device_is_name:
filter = ""deviceName+eq+'{0}'"".format(self.device)
elif self.device_is_id:
filter = ""deviceMachineId+eq+'{0}'"".format(self.device)
else:
raise F5ModuleError(
""Unknown device format '{0}'"".format(self.device)
)
uri = 'https://{0}:{1}/mgmt/cm/device/licensing/pool/regkey/licenses/{2}/offerings/{3}/members/' \
'?$filter={4}'.format(self.client.provider['server'], self.client.provider['server_port'],
self.pool_id, self.key, filter)
resp = self.client.api.get(uri)
try:
response = resp.json()
except ValueError as ex:
raise F5ModuleError(str(ex))
if resp.status == 200 and response['totalItems'] == 0:
return None
elif 'code' in response and response['code'] == 400:
if 'message' in response:
raise F5ModuleError(response['message'])
else:
raise F5ModuleError(resp._content)
result = response['items'][0]['id']
return result
class Changes(Parameters):
pass
class UsableChanges(Changes):
@property
def device_port(self):
if self._values['managed']:
return None
return self._values['device_port']
@property
def device_username(self):
if self._values['managed']:
return None
return self._values['device_username']
@property
def device_password(self):
if self._values['managed']:
return None
return self._values['device_password']
@property
def device_reference(self):
if not self._values['managed']:
return None
return self._values['device_reference']
@property
def device_address(self):
if self._values['managed']:
return None
return self._values['device_address']
@property
def managed(self):
return None
class ReportableChanges(Changes):
pass
class Difference(object):
def __init__(self, want, have=None):
self.want = want
self.have = have
def compare(self, param):
try:
result = getattr(self, param)
return result
except AttributeError:
return self.__default(param)
def __default(self, param):
attr1 = getattr(self.want, param)
try:
attr2 = getattr(self.have, param)
if attr1 != attr2:
return attr1
except AttributeError:
return attr1
class ModuleManager(object):
def __init__(self, *args, **kwargs):
self.module = kwargs.get('module', None)
self.client = F5RestClient(**self.module.params)
self.want = ModuleParameters(params=self.module.params, client=self.client)
self.have = ApiParameters()
self.changes = UsableChanges()
def _set_changed_options(self):
changed = {}
for key in Parameters.returnables:
if getattr(self.want, key) is not None:
changed[key] = getattr(self.want, key)
if changed:
self.changes = UsableChanges(params=changed)
def _update_changed_options(self):
diff = Difference(self.want, self.have)
updatables = Parameters.updatables
changed = dict()
for k in updatables:
change = diff.compare(k)
if change is None:
continue
else:
if isinstance(change, dict):
changed.update(change)
else:
changed[k] = change
if changed:
self.changes = UsableChanges(params=changed)
return True
return False
def should_update(self):
result = self._update_changed_options()
if result:
return True
return False
def exec_module(self):
start = datetime.now().isoformat()
version = bigiq_version(self.client)
changed = False
result = dict()
state = self.want.state
if state == ""present"":
changed = self.present()
elif state == ""absent"":
changed = self.absent()
reportable = ReportableChanges(params=self.changes.to_return())
changes = reportable.to_return()
result.update(**changes)
result.update(dict(changed=changed))
self._announce_deprecations(result)
send_teem(start, self.module, version)
return result
def _announce_deprecations(self, result):
warnings = result.pop('__warnings', [])
for warning in warnings:
self.module.deprecate(
msg=warning['msg'],
version=warning['version']
)
def present(self):
if self.exists():
return False
return self.create()
def exists(self):
if self.want.member_id is None:
return False
uri = 'https://{0}:{1}/mgmt/cm/device/licensing/pool/regkey/licenses/{2}/offerings/{3}/members/{4}'.format(
self.client.provider['server'],
self.client.provider['server_port'],
self.want.pool_id,
self.want.key,
self.want.member_id
)
resp = self.client.api.get(uri)
if resp.status == 200:
return True
return False
def remove(self):
self._set_changed_options()
if self.module.check_mode:
return True
self.remove_from_device()
if self.exists():
raise F5ModuleError(""Failed to delete the resource."")
# Artificial sleeping to wait for remote licensing (on BIG-IP) to complete
#
# This should be something that BIG-IQ can do natively in 6.1-ish time.
time.sleep(60)
return True
def create(self):
self._set_changed_options()
if not self.want.managed:
if self.want.device_username is None:
raise F5ModuleError(
""You must specify a 'device_username' when working with unmanaged devices.""
)
if self.want.device_password is None:
raise F5ModuleError(
""You must specify a 'device_password' when working with unmanaged devices.""
)
if self.module.check_mode:
return True
self.create_on_device()
if not self.exists():
raise F5ModuleError(
""Failed to license the remote device.""
)
self.wait_for_device_to_be_licensed()
# Artificial sleeping to wait for remote licensing (on BIG-IP) to complete
#
# This should be something that BIG-IQ can do natively in 6.1-ish time.
time.sleep(60)
return True
def create_on_device(self):
params = self.changes.api_params()
uri = 'https://{0}:{1}/mgmt/cm/device/licensing/pool/regkey/licenses/{2}/offerings/{3}/members/'.format(
self.client.provider['server'],
self.client.provider['server_port'],
self.want.pool_id,
self.want.key
)
if not self.want.managed:
params['username'] = self.want.device_username
params['password'] = self.want.device_password
resp = self.client.api.post(uri, json=params)
try:
response = resp.json()
except ValueError as ex:
raise F5ModuleError(str(ex))
if 'code' in response and response['code'] == 400:
if 'message' in response:
raise F5ModuleError(response['message'])
else:
raise F5ModuleError(resp.content)
def wait_for_device_to_be_licensed(self):
count = 0
uri = 'https://{0}:{1}/mgmt/cm/device/licensing/pool/regkey/licenses/{2}/offerings/{3}/members/{4}'.format(
self.client.provider['server'],
self.client.provider['server_port'],
self.want.pool_id,
self.want.key,
self.want.member_id
)
while count < 3:
resp = self.client.api.get(uri)
try:
response = resp.json()
except ValueError as ex:
raise F5ModuleError(str(ex))
if 'code' in response and response['code'] == 400:
if 'message' in response:
raise F5ModuleError(response['message'])
else:
raise F5ModuleError(resp.content)
if response['status'] == 'LICENSED':
count += 1
else:
count = 0
def absent(self):
if self.exists():
return self.remove()
return False
def remove_from_device(self):
uri = 'https://{0}:{1}/mgmt/cm/device/licensing/pool/regkey/licenses/{2}/offerings/{3}/members/{4}'.format(
self.client.provider['server'],
self.client.provider['server_port'],
self.want.pool_id,
self.want.key,
self.want.member_id
)
params = {}
if not self.want.managed:
params.update(self.changes.api_params())
params['id'] = self.want.member_id
params['username'] = self.want.device_username
params['password'] = self.want.device_password
self.client.api.delete(uri, json=params)
class ArgumentSpec(object):
def __init__(self):
self.supports_check_mode = True
argument_spec = dict(
pool=dict(required=True),
key=dict(required=True, no_log=True),
device=dict(required=True),
managed=dict(type='bool'),
device_port=dict(type='int', default=443),
device_username=dict(no_log=True),
device_password=dict(no_log=True),
state=dict(default='present', choices=['absent', 'present'])
)
self.argument_spec = {}
self.argument_spec.update(f5_argument_spec)
self.argument_spec.update(argument_spec)
self.required_if = [
['state', 'present', ['key', 'managed']],
['managed', False, ['device', 'device_username', 'device_password']],
['managed', True, ['device']]
]
def main():
spec = ArgumentSpec()
module = AnsibleModule(
argument_spec=spec.argument_spec,
supports_check_mode=spec.supports_check_mode,
required_if=spec.required_if
)
try:
mm = ModuleManager(module=module)
results = mm.exec_module()
module.exit_json(**results)
except F5ModuleError as ex:
module.fail_json(msg=str(ex))
if __name__ == '__main__':
main()
",1
"erval, fpu
class FpuTestCase(unittest.TestCase):
def test_third(self):
""Nearest rounding of 1/3 is downwards.""
self.assertEqual(1/3.0, fpu.down(lambda: 1.0 / 3.0))
self.assertTrue(1/3.0 < fpu.up(lambda: 1.0 / 3.0))
self.assertEqual(-1/3.0, fpu.up(lambda: 1.0 / -3.0))
self.assertTrue(-1/3.0 > fpu.down(lambda: 1.0 / -3.0))
def test_fourth(self):
"" 1/4 is exact.""
self.assertEqual(1/4.0, fpu.down(lambda: 1.0 / 4.0))
self.assertEqual(1/4.0, fpu.up(lambda: 1.0 / 4.0))
self.assertEqual(-1/4.0, fpu.up(lambda: 1.0 / -4.0))
self.assertEqual(-1/4.0, fpu.down(lambda: 1.0 / -4.0))
def test_fifth(self):
""Nearest rounding of 1/5 is upwards.""
self.assertEqual(1/5.0, fpu.up(lambda: 1.0 / 5.0))
self.assertTrue(1/5.0 > fpu.down(lambda: 1.0 / 5.0))
self.assertEqual(-1/5.0, fpu.down(lambda: 1.0 / -5.0))
self.assertTrue(-1/5.0 < fpu.up(lambda: 1.0 / -5.0))
def test_ieee754(self):
""fpu.float respect ieee754 semantics.""
self.assertEqual(fpu.infinity + fpu.infinity, fpu.infinity)
self.assertTrue(fpu.isnan(fpu.nan))
self.assertTrue(fpu.isnan(0.0 * fpu.infinity))
self.assertTrue(fpu.isnan(fpu.infinity - fpu.infinity))
def test_float_coercion(self):
""Only real-number scalars should be able to coerce as fpu.float""
self.assertRaises(Exception, lambda: float(1,2))
self.assertRaises(Exception, lambda: float((1,2)))
self.assertRaises(Exception, lambda: float([1,2]))
self.assertRaises(Exception, lambda: float('a'))
self.assertRaises(Exception, lambda: float(1+1j))
def test_min(self):
""Verify corner cases with nan, -inf, +inf""
self.assertEqual(fpu.min((1.0, 2.0)), 1.0)
self.assertEqual(fpu.min((1.0, fpu.infinity)), 1.0)
self.assertEqual(fpu.min((1.0, -fpu.infinity)), -fpu.infinity)
self.assertTrue(fpu.isnan(fpu.min((1.0, -fpu.nan))))
def test_max(self):
""Verify corner cases with nan, -inf, +inf""
self.assertEqual(fpu.max((1.0, 2.0)), 2.0)
self.assertEqual(fpu.max((1.0, fpu.infinity)), fpu.infinity)
self.assertEqual(fpu.max((1.0, -fpu.infinity)), 1.0)
self.assertTrue(fpu.isnan(fpu.max((1.0, fpu.nan))))
def test_power(self):
x = 1/3.0
# The cube of one third should depend on the rounding mode
self.assertTrue(fpu.down(lambda: x*x*x) < fpu.up(lambda: x*x*x))
# But using the built-in power operator, it doesn't necessarily do it
# print fpu.down(lambda: x**3) < fpu.up(lambda: x**3))
# So we define an integer power methods that does
self.assertTrue(fpu.power_rd(x, 3) < fpu.power_ru(x, 3))
self.assertTrue(fpu.power_rd(-x, 3) < fpu.power_ru(-x, 3))
self.assertTrue(fpu.power_rd(x, 4) < fpu.power_ru(x, 4))
self.assertTrue(fpu.power_rd(-x, 4) < fpu.power_ru(-x, 4))
self.assertEqual(
(fpu.down(lambda: x*x*x), fpu.up(lambda: x*x*x)),
(fpu.power_rd(x, 3), fpu.power_ru(x, 3)))
class ModuleTestCase(unittest.TestCase):
def test_namespace(self):
import interval
self.assertEqual(
dir(interval),
['__builtins__', '__doc__', '__file__', '__name__', '__path__', 'fpu', 'imath', 'inf', 'interval'])
class IntervalTestCase(unittest.TestCase):
def test_trivial_constructor(self):
self.assertEqual(interval[1], ((1, 1),))
self.assertEqual(interval(1), ((1, 1),))
self.assertEqual(interval[1, 2], ((1, 2),))
self.assertEqual(interval(1, 2), ((1, 1), (2, 2)))
self.assertEqual(interval([1, 2], [3, 4]), ((1, 2), (3, 4)))
self.assertEqual(interval([1,2]), interval(interval([1, 2])))
def test_nan_constructor(self):
self.assertEqual(interval[2, fpu.nan], ((-fpu.infinity, fpu.infinity),))
self.assertEqual(interval[2, fpu.nan], ((-fpu.infinity, fpu.infinity),))
self.assertEqual(interval(2, fpu.nan, 9), ((-fpu.infinity, fpu.infinity),))
def test_failing_constructor(self):
self.assertRaises(interval.ComponentError, lambda: interval[1, [2, 3]])
self.assertRaises(interval.ComponentError, lambda: interval[1, 2, 3])
self.assertRaises(interval.ComponentError, lambda: interval(0, [1, 2, 3]))
self.assertRaises(interval.ComponentError, lambda: interval(0, [1, [2, 3]]))
self.assertRaises(interval.ComponentError, lambda: interval['a', 1])
def test_canonical_constructor(self):
self.assertEqual(interval([1, 3], [4, 6], [2, 5], 9), ((1, 6), (9, 9)))
self.assertEqual(interval[2 ** (52 + 1) - 1], interval[9007199254740991.0])
self.assertEqual(interval[2 ** (52 + 1) + 1], interval[4503599627370496 * 2.0, 4503599627370497 * 2.0])
self.assertEqual(interval[-2 ** (52 + 1) + 1], interval[-9007199254740991.0])
self.assertEqual(interval[-2 ** (52 + 1) - 1], interval[-4503599627370497 * 2.0, -4503599627370496 * 2.0])
self.assertEqual(interval[2 ** (52 + 2) + 1], interval[4503599627370496 * 4.0, 4503599627370497 * 4.0])
self.assertEqual(interval[2 ** (52 + 2) + 2], interval[4503599627370496 * 4.0, 4503599627370497 * 4.0])
self.assertEqual(interval[2 ** (52 + 2) + 3], interval[4503599627370496 * 4.0, 4503599627370497 * 4.0])
self.assertEqual(interval[-2 ** (52 + 2) - 1], interval[-4503599627370497 * 4.0, -4503599627370496 * 4.0])
self.assertEqual(interval[-2 ** (52 + 2) - 2], interval[-4503599627370497 * 4.0, -4503599627370496 * 4.0])
self.assertEqual(interval[-2 ** (52 + 2) - 3], interval[-4503599627370497 * 4.0, -4503599627370496 * 4.0])
def test_unary(self):
self.assertEqual(interval[1, 2], +interval[1, 2])
self.assertEqual(interval[-2, -1], -interval[1, 2])
def test_sum(self):
self.assertEqual(interval[-fpu.infinity, +fpu.infinity], interval[-fpu.infinity] + interval[fpu.infinity])
self.assertEqual(interval[4, 6], interval[1, 2] + interval[3, 4])
self.assertEqual(interval[3, fpu.infinity], interval[1, fpu.infinity] + interval[2])
self.assertEqual(interval[-fpu.infinity, +fpu.infinity], interval[-fpu.infinity, -1] + interval[2, +fpu.infinity])
self.assertEqual(interval[-fpu.infinity, +fpu.infinity], interval[-fpu.infinity] + interval[8, +fpu.infinity])
self.assertEqual(interval([1, 2], [10, fpu.infinity]) + interval([1,9],[-2,-1]), interval([-1, 1], [2, fpu.infinity]))
self.assertEqual(interval[1, 9] + interval([1, 2], [10, fpu.infinity]), interval[2, fpu.infinity])
def test_sum_coercion(self):
self.assertEqual(interval[1,2] + 2, interval[3, 4])
self.assertRaises(TypeError, lambda: interval[1,2] + 1j)
self.assertEqual(1 + interval[4, 5], interval[5, 6])
self.assertRaises(TypeError, lambda: (1, 2) + interval[1,2])
self.assertEqual(fpu.infinity + interval[4, 5], interval[fpu.infinity])
def test_sub(self):
self.assertEqual(interval[1, 2] - interval[3, 4], interval[-3.0, -1.0])
self.assertEqual(interval[1, 2] - 0.5, interval[0.5, 1.5])
self.assertEqual(1.5 - interval[1, 2], interval[-0.5, 0.5])
def test_mul(self):
self.assertEqual(interval[-fpu.infinity, +fpu.infinity], fpu.infinity * interval[0])
self.assertEqual(interval[+fpu.infinity], interval[+fpu.infinity] * interval[3])
self.assertEqual(interval[-8, +10], interval[1, 2] * interval[-4, 5])
self.assertEqual(interval[3, 8], interval[1, 2] * interval[3, 4])
self.assertEqual(interval[-fpu.infinity, +fpu.infinity], interval[0,1 ] * interval[2, +fpu.infinity])
self.assertEqual(interval[2, fpu.infinity], interval[-fpu.infinity,-2] * interval[-fpu.infinity,-1])
self.assertEqual(interval([1, 2], [3, 4]) * interval[0.5, 2], interval[0.5, 8])
self.assertEqual(interval[1, 2] * 2, interval[2, 4])
def test_inverse(self):
self.assertEqual(interval[0.5, 1], interval[1, 2].inverse())
self.assertEqual(interval[-1, -0.5],(-interval[1, 2]).inverse())
self.assertEqual(interval([-fpu.infinity, -1], [0.5, +fpu.infinity]), interval[-1,2].inverse())
self.assertEqual(interval(-fpu.infinity, [1, +fpu.infinity]), interval[0,1].inverse())
self.assertEqual(interval([-fpu.infinity, -2.0], [0.0, fpu.infinity]),
interval([-0.5, 0.5], [0.2, fpu.infinity]).inverse())
def test_division(self):
self.assertEqual(interval[-fpu.infinity, fpu.infinity], interval[0,1] / interval[0,1])
self.assertEqual(interval[0.5], interval[1] / 2)
self.assertEqual(interval[0.5], 1 / interval[2])
def test_power(self):
self.assertRaises(TypeError, lambda: interval[1, 2] ** (1.3))
self.assertEqual((-interval[1, 2]).inverse(), (-interval[1, 2]) ** -1)
self.assertEqual(interval[0, 4], interval[-1, 2] ** 2)
self.assertEqual(interval[-27, 8], interval[-3, 2] ** 3)
self.assertEqual(interval[-1, 2], (interval[-1,2]**-1)**-1)
self.assertEqual(interval([-0.38712442133802405]) ** 3, interval([-0.058016524353106828, -0.058016524353106808]))
self.assertEqual(
interval[fpu.down(lambda: (1/3.0)*(1/3.0)), fpu.up(lambda: (1/3.0)*(1/3.0))],
(interval[1]/3.0) ** 2)
self.assertEqual(
interval[fpu.down(lambda: (1/3.0)*(1/3.0)*(1/3.0)), fpu.up(lambda: (1/3.0)*(1/3.0)*(1/3.0))],
(interval[1]/3.0) ** 3)
def test_format(self):
for x in interval[1], interval[1,2], interval([1,2], [3,4]):
self.assertEqual(x, eval(repr(x)))
def test_intersection(self):
self.assertEqual(interval[1, 2] & interval[0, 3], interval[1, 2])
self.assertEqual(interval[1.1, 1.9] & interval[1.3, 2.5], interval[1.3, 1.9])
self.assertEqual(interval[1.1, 1.9] & interval[0.3, 0.7], interval())
self.assertEqual(interval([1, 3], [4, 5]) & interval[2], interval[2])
self.assertEqual(interval([1, 3], [4, 5]) & interval(2,4.5), interval(2, 4.5))
self.assertEqual(interval[1, 2] & 1.2, interval(1.2))
self.assertEqual(2.1 & interval[1, 2], interval())
def test_union(self):
self.assertEqual(interval([1, 6], 9), interval([1, 3], [4, 6]) | interval([2, 5], 9))
self.assertEqual(interval[1, 2] | 2.1, interval([1, 2], 2.1))
self.assertEqual(2.1 | interval[1, 2], interval([1, 2], 2.1))
def test_hull(self):
self.assertEqual(interval([1, 9]), interval.hull((interval([1, 3], [4, 6]), interval([2, 5], 9))))
def test_inclusion(self):
def verify_in(x, y):
self.assertTrue(x in y)
self.assertEqual(x & y, interval(x))
verify_in(1.5, interval[1, 2])
verify_in(1, interval[1, 2])
verify_in(2, interval[1, 2])
verify_in(interval[1, 2], interval[1, 2])
verify_in(interval[1.1, 2], interval[1, 2])
verify_in(interval[1, 1.8], interval[1, 2])
verify_in(interval([1.1, 2.2], [3.3, 4.4]), interval(-1, [0, 2.5], [3, 5], [7, 9]))
def verify_out(x, y):
self.assertFalse(x in y)
self.assertNotEqual(x & y, x)
verify_out(0, interval[1, 2])
verify_out(4, interval[1, 2])
verify_out(interval[1, 3], interval[2, 4])
verify_out(interval(1, 3), interval(2, 4))
def test_extrema(self):
self.assertEqual(interval(1, [2, 3], 4).extrema, interval(1, 2, 3, 4))
def test_midpoint(self):
self.assertEqual(interval[0, 4].midpoint, interval[2])
self.assertEqual(interval(-1, 1, 4), interval(-1, [0, 2], [3, 5]).midpoint)
class NewtonTestCase(unittest.TestCase):
def test_opts(self):
self.assertRaises(TypeError, lambda: interval(0,1).newton(None, None, nonexisting=True))
def test_cubic(self):
self.assertEqual(
interval[-2, 2].newton(lambda x: x**3 - x, lambda x: 3*x**2-1),
interval(-1, 0, 1))
self.assertEqual(
interval[-5, 5].newton(lambda x: x**3 + x - 10, lambda x: 3*x**2 + 1),
interval[2])
self.assertEqual(
interval[-5, 5].newton(lambda x: x**3 + x - 15, lambda x: 3*x**2 + 1),
interval[5249383869325653 * 2.0 ** -51, 5249383869325655 * 2.0 ** -51])
# The sharpest result would be with 5249383869325654 * 2.0 ** -51 as sup.
def test_sqrt2(self):
import math
f, p = lambda x: x**2 - 2, lambda x: 2 * x
u, v = 6369051672525772 * 2.0 **-52, 6369051672525773 * 2.0 **-52
self.assertEqual(v, math.sqrt(2))
s = interval[u, v]
self.assertEqual(s, interval[0.1, 5].newton(f, p))
self.assertEqual(s, interval[0, 2].newton(f, p))
self.assertEqual(s, interval[-1, 10].newton(f, p))
self.assertEqual(interval(), interval[2, 5].newton(f, p))
self.assertEqual(-s, interval[-5, 0].newton(f, p))
self.assertEqual(-s|s, interval[-5, +5].newton(f, p))
if __name__ == '__main__':
unittest.main()
",1
"eckedIps = 0
onlineIps = 0
unreachable = 0
timedOut = 0
upIpsAddress = []
computerName = []
completeMacAddress = []
executionTime = 0
def __init__(self,fromIp,toIp):
startTime = time.time()
self.fromIp = fromIp # from 192.168.1.x
self.toIp = toIp # to 192.168.x.x
self.__checkIfIpIsValid(fromIp)
self.__checkIfIpIsValid(toIp)
self.__getRange(fromIp,toIp)
self.__shellToQueue()
#self.__checkIfUp() # run by the shellToQueue queue organizer
self.__computerInfoInQueue()
endTime = time.time()
self.executionTime = round(endTime - startTime,3)
def __checkIfIpIsValid(self,ip):
def validateRange(val):
# valid range => 1 <-> 255
try:
val = int(val)
if val < 0 or val > 255:
print ""Invalid IP Range (""+str(val)+"")""
sys.exit(0)
except:
print ""Invalid IP""
sys.exit(0)
ip = ip.split(""."")
firstVal = validateRange(ip[0])
secondVal = validateRange(ip[1])
thirdVal = validateRange(ip[2])
fourthVal = validateRange(ip[3])
return True
def __getRange(self,fromIp,toIp):
fromIp = fromIp.split(""."")
toIp = toIp.split(""."")
# toIp must be > fromIp
def ip3chars(ipBlock):
# input 1; output 001
ipBlock = str(ipBlock)
while len(ipBlock) != 3:
ipBlock = ""0""+ipBlock
return ipBlock
fromIpRaw = ip3chars(fromIp[0])+ip3chars(fromIp[1])+ip3chars(fromIp[2])+ip3chars(fromIp[3])
toIpRaw = ip3chars(toIp[0])+ip3chars(toIp[1])+ip3chars(toIp[2])+ip3chars(toIp[3])
if fromIpRaw > toIpRaw:
# if from is bigger switch the order
temp = fromIp
fromIp = toIp
toIp = temp
currentIp = [0,0,0,0]
# all to integers
currentIp0 = int(fromIp[0])
currentIp1 = int(fromIp[1])
currentIp2 = int(fromIp[2])
currentIp3 = int(fromIp[3])
toIp0 = int(toIp[0])
toIp1 = int(toIp[1])
toIp2 = int(toIp[2])
toIp3 = int(toIp[3])
firstIp = str(currentIp0)+"".""+str(currentIp1)+"".""+str(currentIp2)+"".""+str(currentIp3)
self.__ipsToCheck = [firstIp]
while currentIp3 != toIp3 or currentIp2 != toIp2 or currentIp1 != toIp1 or currentIp0 != toIp0:
currentIp3 += 1
if currentIp3 > 255:
currentIp3 = 0
currentIp2 += 1
if currentIp2 > 255:
currentIp2 = 0
currentIp1 += 1
if currentIp1 > 255:
currentIp1 = 0
currentIp0 += 1
addIp = str(currentIp0)+"".""+str(currentIp1)+"".""+str(currentIp2)+"".""+str(currentIp3)
self.__ipsToCheck.append(addIp)
def __shellToQueue(self):
# write them in the shell queue
maxPingsAtOnce = 200
currentQueuedPings = 0
for pingIp in self.__ipsToCheck:
proc = subprocess.Popen(['ping','-n','1',pingIp],stdout=subprocess.PIPE,shell=True)
self.__shellPings.append(proc)
currentQueuedPings += 1
if currentQueuedPings >= maxPingsAtOnce:
#execute shells
self.__checkIfUp()
currentQueuedPings = 0
self.__shellPings = []
self.__checkIfUp() # execute last queue
def __checkIfUp(self):
# execute the shells & determine whether the host is up or not
for shellInQueue in self.__shellPings:
pingResult = """"
shellInQueue.wait()
while True:
line = shellInQueue.stdout.readline()
if line != """":
pingResult += line
else:
break;
self.checkedIps += 1
if 'unreachable' in pingResult:
self.unreachable += 1
elif 'timed out' in pingResult:
self.timedOut += 1
else:
self.onlineIps += 1
currentIp = self.__ipsToCheck[self.checkedIps-1]
self.upIpsAddress.append(currentIp)
def __computerInfoInQueue(self):
# shell queue for online hosts
maxShellsAtOnce = 255
currentQueuedNbst = 0
for onlineIp in self.upIpsAddress:
proc = subprocess.Popen(['\\Windows\\sysnative\\nbtstat.exe','-a',onlineIp],stdout=subprocess.PIPE,shell=True)
self.__shell2Nbst.append(proc)
currentQueuedNbst += 1
if currentQueuedNbst >= maxShellsAtOnce:
# execute shells
self.__gatherComputerInfo()
currentQueuedNbst = 0
self.__shell2Nbst = []
self.__gatherComputerInfo() # execute last queue
def __gatherComputerInfo(self):
# execute the shells and find host Name and MAC
for shellInQueue in self.__shell2Nbst:
nbstResult = """"
shellInQueue.wait()
computerNameLine = """"
macAddressLine = """"
computerName = """"
macAddress = """"
while True:
line = shellInQueue.stdout.readline()
if line != """":
if '<00>' in line and 'UNIQUE' in line:
computerNameLine = line
if 'MAC Address' in line:
macAddressLine = line
else:
break;
computerName = re.findall('([ ]+)(.*?)([ ]+)<00>', computerNameLine)
macAddress = re.findall('([A-Z0-9]+)-([A-Z0-9]+)-([A-Z0-9]+)-([A-Z0-9]+)-([A-Z0-9]+)-([A-Z0-9]+)',macAddressLine)
try:
self.computerName.append(computerName[0][1])
except:
self.computerName.append("""")
completeMacAddress = """"
firstMacElement = 0
try:
for macEach in macAddress[0]:
if firstMacElement == 0:
firstMacElement += 1
else:
completeMacAddress += "":""
completeMacAddress += macEach
firstMacElement = 0
except:
completeMacAddress = """"
self.completeMacAddress.append(completeMacAddress)
def readValue(self):
# debugging use only
ips = []
for ip in self.completeMacAddress:
ips.append(ip)
return ips
print ""\t\t---LANScanner v1.0---\n""
# brief tutorial
print ""Sample input data:""
print ""FromIP: 192.168.1.50""
print ""ToIP: 192.168.1.20""
print ""---""
# input
fromIp = raw_input(""From: "")
toIp = raw_input(""To: "")
# enter values to class
userRange = checkIfUp(fromIp,toIp)
# read class values
print """"
#print userRange.readValue() # debugging use only
print ""Checked"",userRange.checkedIps,""IPs""
print """"
print ""Online:"",str(userRange.onlineIps)+""/""+str(userRange.checkedIps)
print ""Unreachable:"",userRange.unreachable,""Timed out:"",userRange.timedOut
print """" # newline
print ""Online IPs:""
print ""IP\t\tNAME\t\tMAC""
counter = 0
for onlineIp in userRange.upIpsAddress:
print onlineIp+""\t""+userRange.computerName[counter]+""\t""+userRange.completeMacAddress[counter]
counter += 1
print """"
print ""Took"",userRange.executionTime,""seconds""",1
", flatten_nested_dicts, get_level_keys, flatten, sort_fields
from databot.exporters import jsonl
from databot.exporters import pandas
@pytest.fixture
def data():
return {
'a': 1,
'b': 2,
'c': {
'x': 1,
'y': 2,
'z': ['foo', 'bar', 'baz'],
}
}
def test_flatten_rows_update(data):
rows = [
Row(key=1, value={'text': 'abc'}),
Row(key=1, value={'text': 'abcde'}),
]
update = {'size': databot.this.value.text.apply(len)}
assert list(flatten(rows, include=['key', 'size'], update=update)) == [
('key', 'size'),
(1, 3),
(1, 5),
]
def test_flattenjson():
rows = [
{'key': 1, 'value': {'foo': 'bar', 'events': [
{'name': 'Event 1', 'date': '2017-01-01', 'people': ['a', 'b']},
{'name': 'Event 2', 'date': '2017-01-02', 'people': ['a']},
]}},
{'key': 2, 'value': {'foo': 'baz', 'events': [
{'name': 'Event 3', 'date': '2017-01-03', 'people': ['x', 'y']},
{'name': 'Event 4', 'date': '2017-01-04', 'people': ['z']},
]}},
]
assert list(map(dict, flatten_nested_lists(rows, include={('key',), ('value', 'events', 'date')}))) == [
{('key',): 1, ('value', 'events', 'date'): '2017-01-01'},
{('key',): 1, ('value', 'events', 'date'): '2017-01-02'},
{('key',): 2, ('value', 'events', 'date'): '2017-01-03'},
{('key',): 2, ('value', 'events', 'date'): '2017-01-04'},
]
assert list(map(dict, flatten_nested_lists(rows, include={('key',), ('value', 'events', 'people')}))) == [
{('key',): 1, ('value', 'events', 'people'): 'a'},
{('key',): 1, ('value', 'events', 'people'): 'b'},
{('key',): 1, ('value', 'events', 'people'): 'a'},
{('key',): 2, ('value', 'events', 'people'): 'x'},
{('key',): 2, ('value', 'events', 'people'): 'y'},
{('key',): 2, ('value', 'events', 'people'): 'z'},
]
assert [{v for k, v in x} for x in flatten_nested_lists(rows, include=[('key',), ('value',)])] == [
{1, 'bar', '2017-01-01', 'Event 1', 'a'},
{1, 'bar', '2017-01-01', 'Event 1', 'b'},
{1, 'bar', '2017-01-02', 'Event 2', 'a'},
{2, 'baz', '2017-01-03', 'Event 3', 'x'},
{2, 'baz', '2017-01-03', 'Event 3', 'y'},
{2, 'baz', '2017-01-04', 'Event 4', 'z'},
]
assert [{v for k, v in x} for x in flatten_nested_lists(rows)] == [
{1, 'bar', '2017-01-01', 'Event 1', 'a'},
{1, 'bar', '2017-01-01', 'Event 1', 'b'},
{1, 'bar', '2017-01-02', 'Event 2', 'a'},
{2, 'baz', '2017-01-03', 'Event 3', 'x'},
{2, 'baz', '2017-01-03', 'Event 3', 'y'},
{2, 'baz', '2017-01-04', 'Event 4', 'z'},
]
def test_flatten_nested_dicts():
assert set(flatten_nested_dicts({'a': 1, 'b': 2, 'c': 3})) == {
(('a',), 1),
(('b',), 2),
(('c',), 3),
}
def test_flatten_nested_dicts_include():
assert set(flatten_nested_dicts({'a': 1, 'b': 2, 'c': 3}, include=[('b',), ('a',), ('c',)])) == {
(('b',), 2),
(('a',), 1),
(('c',), 3),
}
def test_get_level_keys():
assert list(get_level_keys(keys=['c', 'b', 'a'], field=(), include=())) == ['a', 'b', 'c']
assert list(get_level_keys(keys=['c', 'b', 'a'], field=(), include=[('b',), ('a',), ('c',)])) == ['b', 'a', 'c']
assert list(get_level_keys(keys=['c', 'b', 'a'], field=('x',), include=())) == ['a', 'b', 'c']
assert list(get_level_keys(keys=['c', 'b', 'a'], field=('x',), include=[('x', 'b',), ('x', 'c',)])) == ['b', 'c']
assert list(get_level_keys(keys=['c', 'b', 'a'], field=(), include=[('b',), ('x',)])) == ['b']
assert list(get_level_keys(keys=['c', 'b', 'a'], field=('x', 'y'), include=[('x',)])) == ['a', 'b', 'c']
def test_flatten():
rows = [
Row(key=1, value={'foo': 'bar', 'events': [
{'name': 'Event 1', 'date': '2017-01-01', 'people': ['a', 'b']},
{'name': 'Event 2', 'date': '2017-01-02', 'people': ['a']},
]}),
Row(key=2, value={'foo': 'baz', 'events': [
{'name': 'Event 3', 'date': '2017-01-03', 'people': ['x', 'y']},
{'name': 'Event 4', 'date': '2017-01-04', 'people': ['z']},
]}),
]
assert list(flatten(rows)) == [
('events.date', 'events.name', 'events.people', 'foo', 'key'),
('2017-01-01', 'Event 1', 'a', 'bar', 1),
('2017-01-01', 'Event 1', 'b', 'bar', 1),
('2017-01-02', 'Event 2', 'a', 'bar', 1),
('2017-01-03', 'Event 3', 'x', 'baz', 2),
('2017-01-03', 'Event 3', 'y', 'baz', 2),
('2017-01-04', 'Event 4', 'z', 'baz', 2),
]
assert list(flatten(rows, include=('key', 'foo', 'events.people'))) == [
('key', 'foo', 'events.people'),
(1, 'bar', 'a'),
(1, 'bar', 'b'),
(1, 'bar', 'a'),
(2, 'baz', 'x'),
(2, 'baz', 'y'),
(2, 'baz', 'z'),
]
assert list(flatten(rows, include=('key', 'foo'))) == [
('key', 'foo'),
(1, 'bar'),
(2, 'baz'),
]
def test_sort_fields():
def _(fields, include):
fields = [tuple(x.split('.')) for x in fields]
include = [tuple(x.split('.')) for x in include]
return ['.'.join(x) for x in sort_fields(fields, include)]
assert _(['c', 'b', 'a'], []) == ['a', 'b', 'c']
assert _(['c', 'b', 'a'], ['a', 'c']) == ['a', 'c']
assert _(['x.c', 'x.b', 'x.a'], ['x']) == ['x.a', 'x.b', 'x.c']
assert _(['z', 'x.b', 'x.a'], ['x', 'z']) == ['x.a', 'x.b', 'z']
def test_flatten_rows_update_without_include(data):
rows = [
Row(key=1, value={'text': 'abc'}),
Row(key=1, value={'text': 'abcde'}),
]
update = {'size': databot.this.value.text.apply(len)}
assert list(flatten(rows, update=update)) == [
('key', 'size', 'text'),
(1, 3, 'abc'),
(1, 5, 'abcde'),
]
def test_flatten_rows_callable_update(data):
rows = [
Row(key=1, value={'text': 'abc'}),
Row(key=1, value={'text': 'abcde'}),
]
def update(row):
return {'size': len(row.value['text'])}
assert list(flatten(rows, update=update)) == [
('size',),
(3,),
(5,),
]
def test_flatten_rows_include(data):
rows = [
Row(key=1, value={'a': 1}),
Row(key=2, value={'b': 2}),
]
assert list(flatten(rows, include=['a', 'b'])) == [
('a', 'b'),
(1, None),
(None, 2),
]
def test_flatten_rows_include_value(data):
rows = [
Row(key=1, value='a'),
Row(key=2, value='b'),
]
assert list(flatten(rows, include=['key', 'value'])) == [
('key', 'value'),
(1, 'a'),
(2, 'b'),
]
def test_flatten_rows_value(data):
rows = [
Row(key=1, value='a'),
Row(key=2, value='b'),
]
assert list(flatten(rows)) == [
('key', 'value'),
(1, 'a'),
(2, 'b'),
]
def test_flatten_int_key(data):
rows = [
Row(key=1, value={'year': {2000: 1, 2001: 2}}),
Row(key=2, value={'year': {2000: 3, 2001: 4}}),
]
assert list(flatten(rows)) == [
('key', 'year.2000', 'year.2001'),
(1, 1, 2),
(2, 3, 4),
]
def test_flatten_list(data):
rows = [
Row(key=1, value={'events': [
{'name': 'Event 1', 'date': '2017-01-01'},
{'name': 'Event 2', 'date': '2017-02-01'},
]}),
Row(key=2, value={'events': [
{'name': 'Event 3', 'date': '2017-03-01'},
{'name': 'Event 4', 'date': '2017-04-01'},
]}),
]
assert list(flatten(rows)) == [
('events.date', 'events.name', 'key'),
('2017-01-01', 'Event 1', 1),
('2017-02-01', 'Event 2', 1),
('2017-03-01', 'Event 3', 2),
('2017-04-01', 'Event 4', 2),
]
def test_jsonl(bot):
pipe = bot.define('p1').append([('1', 'a'), ('2', 'b')])
stream = io.StringIO()
jsonl.export(stream, pipe.rows())
assert stream.getvalue().splitlines() == [
'{""key"": ""1"", ""value"": ""a""}',
'{""key"": ""2"", ""value"": ""b""}',
]
def test_jsonl_dict(bot):
pipe = bot.define('p1').append([('1', {'a': 2}), ('2', {'b': 3})])
stream = io.StringIO()
jsonl.export(stream, pipe.rows())
assert stream.getvalue().splitlines() == [
'{""key"": ""1"", ""a"": 2}',
'{""key"": ""2"", ""b"": 3}',
]
def test_pandas_rows_to_dataframe_items():
rows = [
[1, 'a', 'x'],
[2, 'b', 'y'],
]
assert list(pandas.rows_to_dataframe_items(rows, 0)) == [
(1, ['a', 'x']),
(2, ['b', 'y'])
]
assert list(pandas.rows_to_dataframe_items(rows, 2)) == [
('x', [1, 'a']),
('y', [2, 'b'])
]
def test_pandas(bot):
pipe = bot.define('p1').append([
(1, {'a': 10}),
(2, {'a': 20}),
])
assert [dict(x._asdict()) for x in pipe.export(pd).itertuples()] == [
{'Index': 1, 'a': 10.0},
{'Index': 2, 'a': 20.0},
]
",1
""""""" Custom exception handler that returns errors object as an array """"""
# Import inside method to avoid errors when the OSF is loaded without Django
from rest_framework.views import exception_handler
response = exception_handler(exc, context)
# Error objects may have the following members. Title removed to avoid clash with node ""title"" errors.
top_level_error_keys = ['id', 'links', 'status', 'code', 'detail', 'source', 'meta']
errors = []
if response:
message = response.data
if isinstance(message, dict):
for error_key, error_description in message.iteritems():
if error_key in top_level_error_keys:
errors.append({error_key: error_description})
else:
if isinstance(error_description, basestring):
error_description = [error_description]
errors.extend([{'source': {'pointer': '/data/attributes/' + error_key}, 'detail': reason}
for reason in error_description])
else:
if isinstance(message, basestring):
message = [message]
errors.extend([{'detail': error} for error in message])
response.data = {'errors': errors}
return response
# Custom Exceptions the Django Rest Framework does not support
class Gone(APIException):
status_code = status.HTTP_410_GONE
default_detail = ('The requested resource is no longer available.')
class InvalidFilterError(ParseError):
""""""Raised when client passes an invalid filter in the querystring.""""""
default_detail = 'Querystring contains an invalid filter.'
",1
" #
# #
# Copyright (C) 2007, 2008 Paul Pogonyshev. #
# #
# This library is free software; you can redistribute it and/or #
# modify it under the terms of the GNU Lesser General Public License #
# as published by the Free Software Foundation; either version 2.1 #
# of the License, or (at your option) any later version. #
# #
# This library 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 #
# Lesser General Public License for more details. #
# #
# You should have received a copy of the GNU Lesser General Public #
# License along with this library; if not, write to the Free #
# Software Foundation, Inc., 51 Franklin Street, Fifth Floor, #
# Boston, MA 02110-1301 USA #
#--------------------------------------------------------------------#
""""""
cNotify package provides three main concepts: I{L{signals }}, I{L{conditions
}} and I{L{variables }}. Signals are basically lists of callables
that can be I{emitted} and then will call all contained callables (I{handler} of a signal)
in turn. Conditions are boolean values complemented with a signal that is emitted when
condition’s I{state} changes. Variables are akin to conditions but can hold arbitrary
I{values}, not just booleans. Conditions, unlike variables, can also be combined using
standard logic operators, like negation, conjunction and so on.
All three concepts provide separation between providers (writers, setters) and listeners
(readers, getters) of some entity. Conditions and variables make the entity explicit—it
is a boolean state for the former and arbitrary Python object for the latter (though
derived variable classes can restrict the set of allowed values.)
Here is a quick example:
>>> from cnotify.variable import *
... name = Variable ()
...
... import sys
... name.changed.connect (
... lambda string: sys.stdout.write ('Hello there, %s!\\n' % string))
...
... name.value = 'Chuk'
Note that when setting the C{name} variable, you don’t need to know who, if anyone,
listens to changes to it. Interested parties take care to express their interest
themselves and are informed upon a change automatically.
Here is a little more elaborate example with the same functionality (it requires U{PyGTK
}} code creates a condition that is true depending on
C{pilots} value (true for non-empty sequences in our case.) It is just a convenience
wrapper over C{L{AbstractVariable.predicate }}
method. Now, the latter is also used directly in this line of code. It creates a
condition that is true as long as variable’s value conforms to the passed in predicate.
In particular, C{fuel.predicate (lambda amount: amount > 0)} creates a condition that is
true if C{fuel}’s value is greater than zero. Predicate conditions will recompute their
state each time variable’s value changes and that’s the point in using them.
Finally, two just constructed conditions are combined into a third condition using ‘and’
operator (C{&}). This third condition will be true if and only if I{both} its term
conditions are true. Conditions support four logic operations: negation, conjunction,
disjunction and xoring (with these operators: C{~}, C{&}, C{|} and C{^}.) In addition,
each condition has C{L{if_else }} method, which is
much like Python’s C{if} operator.
The next line introduces one more new method: C{L{store
}}. It is really just like connecting its only argument
to the ‘changed’ signal, except that it is also called once with the current state of the
condition (or value of a variable.)
The example should produce this output::
Missing pilots or fuel
Pilots are Jen and Jim
Got 500 litres of fuel
Ready to get off!
Got 0 litres of fuel
Missing pilots or fuel
Notable here is the output from C{ready_state_changed} function. It is called once at the
beginning from the C{store} method with the state of C{ready} condition (then C{False}.)
Both later calls correspond to changes in C{ready}’s state. When both C{pilots} and
C{fuel} variables are set, corresponding predicate conditions become true and so does the
C{ready} condition. However, when one of the predicate conditions becomes false (as the
result of C{fuel} being set to zero), C{ready} turns false again. Note that
C{ready_state_changed} is not called in between of setting C{pilots} and C{fuel} variable.
C{ready} state is recomputed, but since it remains the same, ‘changed’ signal is not
emitted.
G{packagetree}
""""""
__docformat__ = 'epytext en'
# CONFIGURATION
__version__ = '0.3.2.1'
""""""
Version of Py-cnotify, as a string.
""""""
version_tuple = (0, 3, 2, 1)
""""""
Version of Py-cnotify, as a tuple of integers. It is guaranteed that version tuples of
later versions will compare greater that those of earlier versions.
""""""
# /CONFIGURATION
# Local variables:
# mode: python
# python-indent: 4
# indent-tabs-mode: nil
# fill-column: 90
# End:
",1
"go.template.defaultfilters import slugify
from django.utils.encoding import smart_text
from unidecode import unidecode
from django.forms.widgets import FILE_INPUT_CONTRADICTION, CheckboxInput, ClearableFileInput
class ImagePreviewWidget(AdminFileWidget):
template_name = 'admin/attachment/widgets/preview_image_input.html'
def render(self, name, value, attrs=None, renderer=None):
output = []
output.append(super(AdminFileWidget, self).render(name, value, attrs)) # really for AdminFileWidget
instance = getattr(value, 'instance', None)
if instance is not None and value:
output = ['![]()
' % \
(instance.image.url, instance.thumb.url, instance.image)] + output
return mark_safe(u''.join(output))
def value_from_datadict(self, data, files, name):
for key, file in files.items():
filename = file._get_name()
ext = u""""
if '.' in filename:
ext = u""."" + filename.rpartition('.')[2]
filename = filename.rpartition('.')[0]
filename = re.sub(r'[_.,:;@#$%^&?*|()\[\]]', '-', filename)
filename = slugify(unidecode(smart_text(filename))) + ext
files[key]._set_name(filename)
upload = super(ImagePreviewWidget, self).value_from_datadict(data, files, name)
if not self.is_required and CheckboxInput().value_from_datadict(
data, files, self.clear_checkbox_name(name)):
if upload:
# If the user contradicts themselves (uploads a new file AND
# checks the ""clear"" checkbox), we return a unique marker
# object that FileField will turn into a ValidationError.
return FILE_INPUT_CONTRADICTION
# False signals to clear any existing value, as opposed to just None
return False
return upload
class ImagePreviewWidgetHorizontal(ImagePreviewWidget):
template_name = 'admin/attachment/widgets/preview_image_input_horizontal.html'
class ImagePreviewWidgetVertical(ImagePreviewWidget):
template_name = 'admin/attachment/widgets/preview_image_input_vertical.html'
class FileWidget(ClearableFileInput):
def value_from_datadict(self, data, files, name):
for key, file in files.items():
filename = file._get_name()
ext = u""""
if '.' in filename:
ext = u""."" + filename.rpartition('.')[2]
filename = filename.rpartition('.')[0]
filename = re.sub(r'[_.,:;@#$%^&?*|()\[\]]', '-', filename)
filename = slugify(unidecode(smart_text(filename))) + ext
files[key]._set_name(filename)
return files.get(name, None)
",1
"add this to the top of your setup.py::
from ez_setup import use_setuptools
use_setuptools()
To require a specific version of setuptools, set a download
mirror, or use an alternate download directory, simply supply
the appropriate options to ``use_setuptools()``.
This file can also be run as a script to install or upgrade setuptools.
""""""
import os
import shutil
import sys
import tempfile
import zipfile
import optparse
import subprocess
import platform
import textwrap
import contextlib
from distutils import log
try:
# noinspection PyCompatibility
from urllib.request import urlopen
except ImportError:
# noinspection PyCompatibility
from urllib2 import urlopen
try:
from site import USER_SITE
except ImportError:
USER_SITE = None
DEFAULT_VERSION = ""7.0""
DEFAULT_URL = ""https://pypi.python.org/packages/source/s/setuptools/""
def _python_cmd(*args):
""""""
Return True if the command succeeded.
""""""
args = (sys.executable,) + args
return subprocess.call(args) == 0
def _install(archive_filename, install_args=()):
with archive_context(archive_filename):
# installing
log.warn('Installing Setuptools')
if not _python_cmd('setup.py', 'install', *install_args):
log.warn('Something went wrong during the installation.')
log.warn('See the error message above.')
# exitcode will be 2
return 2
def _build_egg(egg, archive_filename, to_dir):
with archive_context(archive_filename):
# building an egg
log.warn('Building a Setuptools egg in %s', to_dir)
_python_cmd('setup.py', '-q', 'bdist_egg', '--dist-dir', to_dir)
# returning the result
log.warn(egg)
if not os.path.exists(egg):
raise IOError('Could not build the egg.')
class ContextualZipFile(zipfile.ZipFile):
""""""
Supplement ZipFile class to support context manager for Python 2.6
""""""
def __enter__(self):
return self
def __exit__(self, type, value, traceback):
self.close()
def __new__(cls, *args, **kwargs):
""""""
Construct a ZipFile or ContextualZipFile as appropriate
""""""
if hasattr(zipfile.ZipFile, '__exit__'):
return zipfile.ZipFile(*args, **kwargs)
return super(ContextualZipFile, cls).__new__(cls)
@contextlib.contextmanager
def archive_context(filename):
# extracting the archive
tmpdir = tempfile.mkdtemp()
log.warn('Extracting in %s', tmpdir)
old_wd = os.getcwd()
try:
os.chdir(tmpdir)
with ContextualZipFile(filename) as archive:
archive.extractall()
# going in the directory
subdir = os.path.join(tmpdir, os.listdir(tmpdir)[0])
os.chdir(subdir)
log.warn('Now working in %s', subdir)
yield
finally:
os.chdir(old_wd)
shutil.rmtree(tmpdir)
def _do_download(version, download_base, to_dir, download_delay):
egg = os.path.join(to_dir, 'setuptools-%s-py%d.%d.egg'
% (version, sys.version_info[0], sys.version_info[1]))
if not os.path.exists(egg):
archive = download_setuptools(version, download_base,
to_dir, download_delay)
_build_egg(egg, archive, to_dir)
sys.path.insert(0, egg)
# Remove previously-imported pkg_resources if present (see
# https://bitbucket.org/pypa/setuptools/pull-request/7/ for details).
if 'pkg_resources' in sys.modules:
del sys.modules['pkg_resources']
import setuptools
setuptools.bootstrap_install_from = egg
def use_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,
to_dir=os.curdir, download_delay=15):
to_dir = os.path.abspath(to_dir)
rep_modules = 'pkg_resources', 'setuptools'
imported = set(sys.modules).intersection(rep_modules)
try:
import pkg_resources
except ImportError:
return _do_download(version, download_base, to_dir, download_delay)
try:
pkg_resources.require(""setuptools>="" + version)
return
except pkg_resources.DistributionNotFound:
return _do_download(version, download_base, to_dir, download_delay)
except pkg_resources.VersionConflict as VC_err:
if imported:
msg = textwrap.dedent(""""""
The required version of setuptools (>={version}) is not available,
and can't be installed while this script is running. Please
install a more recent version first, using
'easy_install -U setuptools'.
(Currently using {VC_err.args[0]!r})
"""""").format(VC_err=VC_err, version=version)
sys.stderr.write(msg)
sys.exit(2)
# otherwise, reload ok
del pkg_resources, sys.modules['pkg_resources']
return _do_download(version, download_base, to_dir, download_delay)
def _clean_check(cmd, target):
""""""
Run the command to download target. If the command fails, clean up before
re-raising the error.
""""""
try:
subprocess.check_call(cmd)
except subprocess.CalledProcessError:
if os.access(target, os.F_OK):
os.unlink(target)
raise
def download_file_powershell(url, target):
""""""
Download the file at url to target using Powershell (which will validate
trust). Raise an exception if the command cannot complete.
""""""
target = os.path.abspath(target)
ps_cmd = (
""[System.Net.WebRequest]::DefaultWebProxy.Credentials = ""
""[System.Net.CredentialCache]::DefaultCredentials; ""
""(new-object System.Net.WebClient).DownloadFile(%(url)r, %(target)r)""
% vars()
)
cmd = [
'powershell',
'-Command',
ps_cmd,
]
_clean_check(cmd, target)
def has_powershell():
if platform.system() != 'Windows':
return False
cmd = ['powershell', '-Command', 'echo test']
with open(os.path.devnull, 'wb') as devnull:
try:
subprocess.check_call(cmd, stdout=devnull, stderr=devnull)
except Exception:
return False
return True
download_file_powershell.viable = has_powershell
def download_file_curl(url, target):
cmd = ['curl', url, '--silent', '--output', target]
_clean_check(cmd, target)
def has_curl():
cmd = ['curl', '--version']
with open(os.path.devnull, 'wb') as devnull:
try:
subprocess.check_call(cmd, stdout=devnull, stderr=devnull)
except Exception:
return False
return True
download_file_curl.viable = has_curl
def download_file_wget(url, target):
cmd = ['wget', url, '--quiet', '--output-document', target]
_clean_check(cmd, target)
def has_wget():
cmd = ['wget', '--version']
with open(os.path.devnull, 'wb') as devnull:
try:
subprocess.check_call(cmd, stdout=devnull, stderr=devnull)
except Exception:
return False
return True
download_file_wget.viable = has_wget
def download_file_insecure(url, target):
""""""
Use Python to download the file, even though it cannot authenticate the
connection.
""""""
src = urlopen(url)
try:
# Read all the data in one block.
data = src.read()
finally:
src.close()
# Write all the data in one block to avoid creating a partial file.
with open(target, ""wb"") as dst:
dst.write(data)
download_file_insecure.viable = lambda: True
def get_best_downloader():
downloaders = (
download_file_powershell,
download_file_curl,
download_file_wget,
download_file_insecure,
)
viable_downloaders = (dl for dl in downloaders if dl.viable())
return next(viable_downloaders, None)
def download_setuptools(version=DEFAULT_VERSION, download_base=DEFAULT_URL,
to_dir=os.curdir, delay=15, downloader_factory=get_best_downloader):
""""""
Download setuptools from a specified location and return its filename
`version` should be a valid setuptools version number that is available
as an sdist for download under the `download_base` URL (which should end
with a '/'). `to_dir` is the directory where the egg will be downloaded.
`delay` is the number of seconds to pause before an actual download
attempt.
``downloader_factory`` should be a function taking no arguments and
returning a function for downloading a URL to a target.
""""""
# making sure we use the absolute path
to_dir = os.path.abspath(to_dir)
zip_name = ""setuptools-%s.zip"" % version
url = download_base + zip_name
saveto = os.path.join(to_dir, zip_name)
if not os.path.exists(saveto): # Avoid repeated downloads
log.warn(""Downloading %s"", url)
downloader = downloader_factory()
downloader(url, saveto)
return os.path.realpath(saveto)
def _build_install_args(options):
""""""
Build the arguments to 'python setup.py install' on the setuptools package
""""""
return ['--user'] if options.user_install else []
def _parse_args():
""""""
Parse the command line for options
""""""
parser = optparse.OptionParser()
parser.add_option(
'--user', dest='user_install', action='store_true', default=False,
help='install in user site package (requires Python 2.6 or later)')
parser.add_option(
'--download-base', dest='download_base', metavar=""URL"",
default=DEFAULT_URL,
help='alternative URL from where to download the setuptools package')
parser.add_option(
'--insecure', dest='downloader_factory', action='store_const',
const=lambda: download_file_insecure, default=get_best_downloader,
help='Use internal, non-validating downloader'
)
parser.add_option(
'--version', help=""Specify which version to download"",
default=DEFAULT_VERSION,
)
options, args = parser.parse_args()
# positional arguments are ignored
return options
def main():
""""""Install or upgrade setuptools and EasyInstall""""""
options = _parse_args()
archive = download_setuptools(
version=options.version,
download_base=options.download_base,
downloader_factory=options.downloader_factory,
)
return _install(archive, _build_install_args(options))
if __name__ == '__main__':
sys.exit(main())
",1
"
#
# 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 Indiana University 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.
from corepy.spre.spe import Instruction, DispatchInstruction, Register
from spu_insts import *
__doc__=""""""
ISA for the Cell Broadband Engine's SPU.
""""""
class lqx(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':452}
cycles = (1, 6, 0)
class stqx(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':324}
cycles = (1, 6, 0)
class cbx(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':468}
cycles = (1, 4, 0)
class chx(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':469}
cycles = (1, 4, 0)
class cwx(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':470}
cycles = (1, 4, 0)
class cdx(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':471}
cycles = (1, 4, 0)
class ah(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':200}
cycles = (0, 2, 0)
class a(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':192}
cycles = (0, 2, 0)
class sfh(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':72}
cycles = (0, 2, 0)
class sf(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':64}
cycles = (0, 2, 0)
class addx(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':832}
cycles = (0, 2, 0)
class cg(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':194}
cycles = (0, 2, 0)
class cgx(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':834}
cycles = (0, 2, 0)
class sfx(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':833}
cycles = (0, 2, 0)
class bg(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':66}
cycles = (0, 2, 0)
class bgx(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':835}
cycles = (0, 2, 0)
class mpy(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':964}
cycles = (0, 7, 0)
class mpyu(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':972}
cycles = (0, 7, 0)
class mpyh(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':965}
cycles = (0, 7, 0)
class mpys(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':967}
cycles = (0, 7, 0)
class mpyhh(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':966}
cycles = (0, 7, 0)
class mpyhha(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':838}
cycles = (0, 7, 0)
class mpyhhu(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':974}
cycles = (0, 7, 0)
class mpyhhau(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':846}
cycles = (0, 7, 0)
class clz(Instruction):
machine_inst = OPCD_A_T
params = {'OPCD':677}
cycles = (0, 2, 0)
class cntb(Instruction):
machine_inst = OPCD_A_T
params = {'OPCD':692}
cycles = (0, 4, 0)
class fsmb(Instruction):
machine_inst = OPCD_A_T
params = {'OPCD':438}
cycles = (1, 4, 0)
class fsmh(Instruction):
machine_inst = OPCD_A_T
params = {'OPCD':437}
cycles = (1, 4, 0)
class fsm(Instruction):
machine_inst = OPCD_A_T
params = {'OPCD':436}
cycles = (1, 4, 0)
class gbb(Instruction):
machine_inst = OPCD_A_T
params = {'OPCD':434}
cycles = (1, 4, 0)
class gbh(Instruction):
machine_inst = OPCD_A_T
params = {'OPCD':433}
cycles = (1, 4, 0)
class gb(Instruction):
machine_inst = OPCD_A_T
params = {'OPCD':432}
cycles = (1, 4, 0)
class avgb(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':211}
cycles = (0, 4, 0)
class absdb(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':83}
cycles = (0, 4, 0)
class sumb(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':595}
cycles = (0, 4, 0)
class xsbh(Instruction):
machine_inst = OPCD_A_T
params = {'OPCD':694}
cycles = (0, 2, 0)
class xshw(Instruction):
machine_inst = OPCD_A_T
params = {'OPCD':686}
cycles = (0, 2, 0)
class xswd(Instruction):
machine_inst = OPCD_A_T
params = {'OPCD':678}
cycles = (0, 2, 0)
class and_(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':193}
cycles = (0, 2, 0)
class andc(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':705}
cycles = (0, 2, 0)
class or_(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':65}
cycles = (0, 2, 0)
class orc(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':713}
cycles = (0, 2, 0)
class orx(Instruction):
machine_inst = OPCD_A_T
params = {'OPCD':496}
cycles = (1, 4, 0)
class xor(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':577}
cycles = (0, 2, 0)
class nand(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':201}
cycles = (0, 2, 0)
class nor(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':73}
cycles = (0, 2, 0)
class eqv(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':585}
cycles = (0, 2, 0)
class shlh(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':95}
cycles = (0, 4, 0)
class shl(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':91}
cycles = (0, 4, 0)
class shlqbi(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':475}
cycles = (1, 4, 0)
class shlqby(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':479}
cycles = (1, 4, 0)
class shlqbybi(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':463}
cycles = (1, 4, 0)
class roth(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':92}
cycles = (0, 4, 0)
class rot(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':88}
cycles = (0, 4, 0)
class rotqby(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':476}
cycles = (1, 4, 0)
class rotqbybi(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':460}
cycles = (1, 4, 0)
class rotqbi(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':472}
cycles = (1, 4, 0)
class rothm(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':93}
cycles = (0, 4, 0)
class rotm(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':89}
cycles = (0, 4, 0)
class rotqmby(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':477}
cycles = (1, 4, 0)
class rotqmbybi(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':461}
cycles = (1, 4, 0)
class rotqmbi(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':473}
cycles = (1, 4, 0)
class rotmah(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':94}
cycles = (0, 4, 0)
class rotma(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':90}
cycles = (0, 4, 0)
class heq(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':984}
cycles = (0, 2, 0)
class hgt(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':600}
cycles = (0, 2, 0)
class hlgt(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':728}
cycles = (0, 2, 0)
class ceqb(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':976}
cycles = (0, 2, 0)
class ceqh(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':968}
cycles = (0, 2, 0)
class ceq(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':960}
cycles = (0, 2, 0)
class cgtb(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':592}
cycles = (0, 2, 0)
class cgth(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':584}
cycles = (0, 2, 0)
class cgt(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':576}
cycles = (0, 2, 0)
class clgtb(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':720}
cycles = (0, 2, 0)
class clgth(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':712}
cycles = (0, 2, 0)
class clgt(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':704}
cycles = (0, 2, 0)
class bi(Instruction):
machine_inst = OPCD_A_D_E
params = {'OPCD':424}
cycles = (1, 4, 0)
class iret(Instruction):
machine_inst = OPCD_A_D_E
params = {'OPCD':426}
cycles = (1, 4, 0)
class bisled(Instruction):
machine_inst = OPCD_A_T_D_E
params = {'OPCD':427}
cycles = (1, 4, 0)
class bisl(Instruction):
machine_inst = OPCD_A_T_D_E
params = {'OPCD':425}
cycles = (1, 4, 0)
class biz(Instruction):
machine_inst = OPCD_A_T_D_E
params = {'OPCD':296}
cycles = (1, 4, 0)
class binz(Instruction):
machine_inst = OPCD_A_T_D_E
params = {'OPCD':297}
cycles = (1, 4, 0)
class bihz(Instruction):
machine_inst = OPCD_A_T_D_E
params = {'OPCD':294}
cycles = (1, 4, 0)
class bihnz(Instruction):
machine_inst = OPCD_A_T_D_E
params = {'OPCD':299}
cycles = (1, 4, 0)
# TODO - can we check that if P is set then RO is zero as required?
class hbr(DispatchInstruction):
cycles = (1, 15, 0)
dispatch = (
(OPCD_RO_A_P, {'OPCD':428}),
(OPCD_LBL9_A_P, {'OPCD':428}))
class fa(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':708}
cycles = (0, 6, 0)
class dfa(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':716}
cycles = (0, 13, 6)
class fs(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':709}
cycles = (0, 6, 0)
class dfs(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':717}
cycles = (0, 13, 6)
class fm(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':710}
cycles = (0, 6, 0)
class dfm(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':718}
cycles = (0, 13, 6)
class dfma(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':860}
cycles = (0, 13, 6)
class dfnms(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':862}
cycles = (0, 13, 6)
class dfms(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':861}
cycles = (0, 13, 6)
class dfnma(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':863}
cycles = (0, 13, 6)
class frest(Instruction):
machine_inst = OPCD_A_T
params = {'OPCD':440}
cycles = (1, 4, 0)
class frsqest(Instruction):
machine_inst = OPCD_A_T
params = {'OPCD':441}
cycles = (1, 4, 0)
class fi(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':980}
cycles = (0, 7, 0)
class frds(Instruction):
machine_inst = OPCD_A_T
params = {'OPCD':953}
cycles = (0, 13, 6)
class fesd(Instruction):
machine_inst = OPCD_A_T
params = {'OPCD':952}
cycles = (0, 13, 6)
class fceq(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':962}
cycles = (0, 2, 0)
class fcmeq(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':970}
cycles = (0, 2, 0)
class fcgt(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':706}
cycles = (0, 2, 0)
class fcmgt(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':714}
cycles = (0, 2, 0)
class fscrwr(Instruction):
machine_inst = OPCD_A_T
params = {'OPCD':954}
cycles = (0, 7, 0)
class fscrrd(Instruction):
machine_inst = OPCD_T
params = {'OPCD':920}
cycles = (0, 13, 6)
class stop(Instruction):
machine_inst = OPCD_STOP_SIG
params = {'OPCD':0}
cycles = (1, 4, 0)
class stopd(Instruction):
machine_inst = OPCD_B_A_T
params = {'OPCD':320}
cycles = (1, 4, 0)
class lnop(Instruction):
machine_inst = OPCD
params = {'OPCD':1}
cycles = (1, 0, 0)
class nop(Instruction):
machine_inst = OPCD_T
params = {'OPCD':513}
cycles = (0, 0, 0)
class sync(Instruction):
machine_inst = OPCD_CF
params = {'OPCD':2}
cycles = (1, 4, 0)
class dsync(Instruction):
machine_inst = OPCD
params = {'OPCD':3}
cycles = (1, 4, 0)
class mfspr(Instruction):
machine_inst = OPCD_SA_T
params = {'OPCD':12}
cycles = (1, 6, 0)
class mtspr(Instruction):
machine_inst = OPCD_SA_T
params = {'OPCD':268}
cycles = (1, 6, 0)
class rdch(Instruction):
machine_inst = OPCD_A_T
params = {'OPCD':13}
cycles = (1, 6, 0)
class rchcnt(Instruction):
machine_inst = OPCD_A_T
params = {'OPCD':15}
cycles = (1, 6, 0)
class wrch(Instruction):
machine_inst = OPCD_A_T
params = {'OPCD':269}
cycles = (1, 6, 0)
class mpya(Instruction):
machine_inst = OPCD_T_B_A_C
params = {'OPCD':12}
cycles = (0, 7, 0)
class selb(Instruction):
machine_inst = OPCD_T_B_A_C
params = {'OPCD':8}
cycles = (0, 2, 0)
class shufb(Instruction):
machine_inst = OPCD_T_B_A_C
params = {'OPCD':11}
cycles = (1, 4, 0)
class fma(Instruction):
machine_inst = OPCD_T_B_A_C
params = {'OPCD':14}
cycles = (0, 6, 0)
class fnms(Instruction):
machine_inst = OPCD_T_B_A_C
params = {'OPCD':13}
cycles = (0, 6, 0)
class fms(Instruction):
machine_inst = OPCD_T_B_A_C
params = {'OPCD':15}
cycles = (0, 6, 0)
class cbd(Instruction):
machine_inst = OPCD_I7_A_T
params = {'OPCD':500}
cycles = (1, 4, 0)
class chd(Instruction):
machine_inst = OPCD_I7_A_T
params = {'OPCD':501}
cycles = (1, 4, 0)
class cwd(Instruction):
machine_inst = OPCD_I7_A_T
params = {'OPCD':502}
cycles = (1, 4, 0)
class cdd(Instruction):
machine_inst = OPCD_I7_A_T
params = {'OPCD':503}
cycles = (1, 4, 0)
class shlhi(Instruction):
machine_inst = OPCD_I7_A_T
params = {'OPCD':127}
cycles = (0, 4, 0)
class shli(Instruction):
machine_inst = OPCD_I7_A_T
params = {'OPCD':123}
cycles = (0, 4, 0)
class shlqbii(Instruction):
machine_inst = OPCD_I7_A_T
params = {'OPCD':507}
cycles = (1, 4, 0)
class shlqbyi(Instruction):
machine_inst = OPCD_I7_A_T
params = {'OPCD':511}
cycles = (1, 4, 0)
class rothi(Instruction):
machine_inst = OPCD_I7_A_T
params = {'OPCD':124}
cycles = (0, 4, 0)
class roti(Instruction):
machine_inst = OPCD_I7_A_T
params = {'OPCD':120}
cycles = (0, 4, 0)
class rotqbyi(Instruction):
machine_inst = OPCD_I7_A_T
params = {'OPCD':508}
cycles = (1, 4, 0)
class rotqbii(Instruction):
machine_inst = OPCD_I7_A_T
params = {'OPCD':504}
cycles = (1, 4, 0)
class rothmi(Instruction):
machine_inst = OPCD_I7_A_T
params = {'OPCD':125}
cycles = (0, 4, 0)
class rotmi(Instruction):
machine_inst = OPCD_I7_A_T
params = {'OPCD':121}
cycles = (0, 4, 0)
class rotqmbyi(Instruction):
machine_inst = OPCD_I7_A_T
params = {'OPCD':509}
cycles = (1, 4, 0)
class rotqmbii(Instruction):
machine_inst = OPCD_I7_A_T
params = {'OPCD':505}
cycles = (1, 4, 0)
class rotmahi(Instruction):
machine_inst = OPCD_I7_A_T
params = {'OPCD':126}
cycles = (0, 4, 0)
class rotmai(Instruction):
machine_inst = OPCD_I7_A_T
params = {'OPCD':122}
cycles = (0, 4, 0)
class csflt(Instruction):
machine_inst = OPCD_I8_A_T
params = {'OPCD':474}
cycles = (0, 7, 0)
class cflts(Instruction):
machine_inst = OPCD_I8_A_T
params = {'OPCD':472}
cycles = (0, 7, 0)
class cuflt(Instruction):
machine_inst = OPCD_I8_A_T
params = {'OPCD':475}
cycles = (0, 7, 0)
class cfltu(Instruction):
machine_inst = OPCD_I8_A_T
params = {'OPCD':473}
cycles = (0, 7, 0)
class lqd(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':52}
cycles = (1, 6, 0)
class stqd(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':36}
cycles = (1, 6, 0)
class ahi(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':29}
cycles = (0, 2, 0)
class ai(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':28}
cycles = (0, 2, 0)
class sfhi(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':13}
cycles = (0, 2, 0)
class sfi(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':12}
cycles = (0, 2, 0)
class mpyi(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':116}
cycles = (0, 7, 0)
class mpyui(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':117}
cycles = (0, 7, 0)
class andbi(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':22}
cycles = (0, 2, 0)
class andhi(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':21}
cycles = (0, 2, 0)
class andi(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':20}
cycles = (0, 2, 0)
class orbi(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':6}
cycles = (0, 2, 0)
class orhi(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':5}
cycles = (0, 2, 0)
class ori(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':4}
cycles = (0, 2, 0)
class xorbi(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':70}
cycles = (0, 2, 0)
class xorhi(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':69}
cycles = (0, 2, 0)
class xori(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':68}
cycles = (0, 2, 0)
class heqi(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':127}
cycles = (0, 2, 0)
class hgti(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':79}
cycles = (0, 2, 0)
class hlgti(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':95}
cycles = (0, 2, 0)
class ceqbi(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':126}
cycles = (0, 2, 0)
class ceqhi(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':125}
cycles = (0, 2, 0)
class ceqi(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':124}
cycles = (0, 2, 0)
class cgtbi(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':78}
cycles = (0, 2, 0)
class cgthi(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':77}
cycles = (0, 2, 0)
class cgti(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':76}
cycles = (0, 2, 0)
class clgtbi(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':94}
cycles = (0, 2, 0)
class clgthi(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':93}
cycles = (0, 2, 0)
class clgti(Instruction):
machine_inst = OPCD_I10_A_T
params = {'OPCD':92}
cycles = (0, 2, 0)
class lqa(Instruction):
machine_inst = OPCD_I16_T
params = {'OPCD':97}
cycles = (1, 6, 0)
class lqr(Instruction):
machine_inst = OPCD_I16_T
params = {'OPCD':103}
cycles = (1, 6, 0)
class stqa(Instruction):
machine_inst = OPCD_I16_T
params = {'OPCD':65}
cycles = (1, 6, 0)
class stqr(Instruction):
machine_inst = OPCD_I16_T
params = {'OPCD':71}
cycles = (1, 6, 0)
class ilh(Instruction):
machine_inst = OPCD_I16_T
params = {'OPCD':131}
cycles = (0, 2, 0)
class ilhu(Instruction):
machine_inst = OPCD_I16_T
params = {'OPCD':130}
cycles = (0, 2, 0)
class il(Instruction):
machine_inst = OPCD_I16_T
params = {'OPCD':129}
cycles = (0, 2, 0)
class iohl(Instruction):
machine_inst = OPCD_I16_T
params = {'OPCD':193}
cycles = (0, 2, 0)
class fsmbi(Instruction):
machine_inst = OPCD_I16_T
params = {'OPCD':101}
cycles = (1, 4, 0)
class br(DispatchInstruction):
cycles = (1, 4, 0)
dispatch = (
(OPCD_I16, {'OPCD':100}),
(OPCD_LBL16, {'OPCD':100}))
# TODO - how can I do absolute branches?
class bra(Instruction):
machine_inst = OPCD_I16
params = {'OPCD':96}
cycles = (1, 4, 0)
# TODO - I16 has two zero bits appended, do I handle this correctly?
# What is the correct way, anyway?
class brsl(DispatchInstruction):
cycles = (1, 4, 0)
dispatch = (
(OPCD_I16_T, {'OPCD':102}),
(OPCD_LBL16_T, {'OPCD':102}))
class brasl(Instruction):
machine_inst = OPCD_I16_T
params = {'OPCD':98}
cycles = (1, 4, 0)
class brnz(DispatchInstruction):
cycles = (1, 4, 0)
dispatch = (
(OPCD_I16_T, {'OPCD':66}),
(OPCD_LBL16_T, {'OPCD':66}))
class brz(DispatchInstruction):
cycles = (1, 4, 0)
dispatch = (
(OPCD_I16_T, {'OPCD':64}),
(OPCD_LBL16_T, {'OPCD':64}))
class brhnz(DispatchInstruction):
cycles = (1, 4, 0)
dispatch = (
(OPCD_I16, {'OPCD':70}),
(OPCD_LBL16, {'OPCD':70}))
class brhz(DispatchInstruction):
cycles = (1, 4, 0)
dispatch = (
(OPCD_I16, {'OPCD':68}),
(OPCD_LBL16, {'OPCD':68}))
class hbra(Instruction):
machine_inst = OPCD_LBL9_I16
params = {'OPCD':8}
cycles = (1, 15, 0)
class hbrr(DispatchInstruction):
cycles = (1, 15, 0)
dispatch = (
(OPCD_ROA_I16, {'OPCD':9}),
(OPCD_LBL9_LBL16, {'OPCD':9}))
class ila(Instruction):
machine_inst = OPCD_I18_T
params = {'OPCD':33}
cycles = (0, 2, 0)
",1
" 2018 Alan Hamlett.
:license: BSD, see LICENSE for more details.
""""""
from . import TokenParser
class HaxeParser(TokenParser):
exclude = [
r'^haxe$',
]
state = None
def parse(self):
for index, token, content in self.tokens:
self._process_token(token, content)
return self.dependencies
def _process_token(self, token, content):
if self.partial(token) == 'Namespace':
self._process_namespace(token, content)
elif self.partial(token) == 'Text':
self._process_text(token, content)
else:
self._process_other(token, content)
def _process_namespace(self, token, content):
if self.state == 'import':
self.append(self._format(content))
self.state = None
else:
self.state = content
def _process_text(self, token, content):
pass
def _process_other(self, token, content):
self.state = None
def _format(self, content):
return content.strip()
",1
"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 "", ""dirs"", 1)
try:
names = os.listdir(dir)
except os.error, err:
sys.stderr.write(""Can't list %s: %s\n"" % (file, err))
self.addstats(ext, ""unlistable"", 1)
return
names.sort()
for name in names:
if name.startswith("".#""):
continue # Skip CVS temp files
if name.endswith(""~""):
continue# Skip Emacs backup files
full = os.path.join(dir, name)
if os.path.islink(full):
self.addstats("""", ""links"", 1)
elif os.path.isdir(full):
self.statdir(full)
else:
self.statfile(full)
def statfile(self, file):
head, ext = os.path.splitext(file)
head, base = os.path.split(file)
if ext == base:
ext = """" # E.g. .cvsignore is deemed not to have an extension
ext = os.path.normcase(ext)
if not ext:
ext = """"
self.addstats(ext, ""files"", 1)
try:
f = open(file, ""rb"")
except IOError, err:
sys.stderr.write(""Can't open %s: %s\n"" % (file, err))
self.addstats(ext, ""unopenable"", 1)
return
data = f.read()
f.close()
self.addstats(ext, ""bytes"", len(data))
if '\0' in data:
self.addstats(ext, ""binary"", 1)
return
if not data:
self.addstats(ext, ""empty"", 1)
#self.addstats(ext, ""chars"", len(data))
lines = data.splitlines()
self.addstats(ext, ""lines"", len(lines))
del lines
words = data.split()
self.addstats(ext, ""words"", len(words))
def addstats(self, ext, key, n):
d = self.stats.setdefault(ext, {})
d[key] = d.get(key, 0) + n
def report(self):
exts = self.stats.keys()
exts.sort()
# Get the column keys
columns = {}
for ext in exts:
columns.update(self.stats[ext])
cols = columns.keys()
cols.sort()
colwidth = {}
colwidth[""ext""] = max([len(ext) for ext in exts])
minwidth = 6
self.stats[""TOTAL""] = {}
for col in cols:
total = 0
cw = max(minwidth, len(col))
for ext in exts:
value = self.stats[ext].get(col)
if value is None:
w = 0
else:
w = len(""%d"" % value)
total += value
cw = max(cw, w)
cw = max(cw, len(str(total)))
colwidth[col] = cw
self.stats[""TOTAL""][col] = total
exts.append(""TOTAL"")
for ext in exts:
self.stats[ext][""ext""] = ext
cols.insert(0, ""ext"")
def printheader():
for col in cols:
print ""%*s"" % (colwidth[col], col),
print
printheader()
for ext in exts:
for col in cols:
value = self.stats[ext].get(col, """")
print ""%*s"" % (colwidth[col], value),
print
printheader() # Another header at the bottom
def main():
args = sys.argv[1:]
if not args:
args = [os.curdir]
s = Stats()
s.statargs(args)
s.report()
if __name__ == ""__main__"":
main()
",1
"t ""Read in prostate data.""
hdf = h2o.upload_file(h2o.locate(""smalldata/prostate/prostate_complete.csv.zip""))
print ""Testing for family: TWEEDIE""
print ""Set variables for h2o.""
y = ""CAPSULE""
x = [""AGE"",""RACE"",""DCAPS"",""PSA"",""VOL"",""DPROS"",""GLEASON""]
print ""Create models with canonical link: TWEEDIE""
model_h2o_tweedie = h2o.glm(x=hdf[x], y=hdf[y], family=""tweedie"", link=""tweedie"", alpha=[0.5], Lambda = [0])
print ""Compare model deviances for link function tweedie (using precomputed values from R)""
deviance_h2o_tweedie = model_h2o_tweedie.residual_deviance() / model_h2o_tweedie.null_deviance()
assert 0.721452 - deviance_h2o_tweedie <= 0.01, ""h2o's residual/null deviance is more than 0.01 lower than R's. h2o: "" \
""{0}, r: {1}"".format(deviance_h2o_tweedie, 0.721452)
if __name__ == ""__main__"":
h2o.run_test(sys.argv, link_functions_tweedie_basic)
",1
" get token data
username = userToken.username
# Read packet data
packetData = clientPackets.setAwayMessage(packetData)
# Set token away message
userToken.awayMessage = packetData[""awayMessage""]
# Send private message from fokabot
if packetData[""awayMessage""] == """":
fokaMessage = ""Your away message has been reset""
else:
fokaMessage = ""Your away message is now: {}"".format(packetData[""awayMessage""])
userToken.enqueue(serverPackets.sendMessage(""FokaBot"", username, fokaMessage))
log.info(""{} has changed their away message to: {}"".format(username, packetData[""awayMessage""]))
",1
" 888ooo888
# `88bod8P' d8( 888 .d8P' .P 888 .o 888 .o
# `8oooooo. `Y888""""8o d8888888P `Y8bod8P' `Y8bod8P'
# d"" YD
# ""Y88888P'
#
# config class - btx
#
import sys
import os
import configparser
import logging
log = logging.getLogger(__name__)
class gcfg(object):
datapath = None
cfgpath = None
defaults = {'bind_address': '127.0.0.1',
'port': '4242',
'data_dir': '~/.gazee',
'temp_dir': '',
'comic_path': '',
'comic_scan_interval': '60',
'comics_per_page': '15',
'thumb_maxwidth': '300',
'thumb_maxheight': '400',
'image_script': '0',
'mylar_db': '',
'ssl_key': '',
'ssl_cert': '',
'web_text_color': 'ffffff',
'main_color': '757575',
'accent_color': 'bdbdbd'}
def __init__(self, data_override=None):
self.cfg = configparser.ConfigParser()
self.datapath = data_override
self.logpath = None
self.dbpath = None
self.sessionspath = None
print(""Created a new gcfg..."")
if self.datapath is not None:
self.datapath = os.path.realpath(os.path.expanduser(self.datapath))
if self.datapath is None and data_override is not None:
log.error(""Somehow the datapath is now None."")
self.configRead()
log.debug(""Initialized configation... in %s"", __name__)
def create_init_dirs(self, data_dir):
''' Sets up the data_dir plus the two paths that aren't
configurable, and are relative to the data_dir - the
log_dir and db_dir
'''
if self.datapath is not None and data_dir is None:
log.error(""data_dir is None while datapath is not."")
self.datapath = data_dir
self.logpath = os.path.join(self.datapath, ""logs"")
self.dbpath = os.path.join(self.datapath, ""db"")
self.sessionspath = os.path.join(self.datapath, ""sessions"")
if not os.path.exists(self.logpath):
os.makedirs(self.logpath, 0o700)
if not os.path.exists(self.dbpath):
os.makedirs(self.dbpath, 0o700)
if not os.path.exists(self.sessionspath):
os.makedirs(self.sessionspath, 0o700)
def find_config(self):
''' Looks for where the data dir is located.
Once it finds the dir, it calls create_
'''
dirfound = None
firstdir = None
cfgfound = None
# print(""Looking for config in find_config() - datapath: %s"" % (self.datapath))
if self.datapath is not None:
if not os.path.exists(self.datapath):
msg = 'Path %s does not exist.\n\nDo you wish to create it? [y/n]: ' % self.datapath
if self.get_yn(msg):
try:
os.makedirs(self.datapath)
except PermissionError:
print(""You don't have the permissions to create that path.\nExiting."")
sys.exit(1)
else:
print(""Exiting."")
sys.exit(1)
firstdir = dirfound = self.datapath
cfile = os.path.join(dirfound, ""app.ini"")
if os.path.exists(cfile):
cfgfound = cfile
else:
cfgfound = None
else:
dirs = ['data', '~/.gazee', '../data']
for d in dirs:
ddir = os.path.realpath(os.path.expanduser(d))
cfile = os.path.join(ddir, ""app.ini"")
if os.path.exists(ddir) and os.path.isdir(ddir):
if firstdir is None:
firstdir = ddir
dirfound = ddir
if os.path.exists(cfile):
cfgfound = cfile
break
if dirfound is None:
log.error(""Data directory not found!"")
return False
dirfound = firstdir
self.datapath = dirfound
self.create_init_dirs(dirfound)
if cfgfound is not None:
log.debug('cfgfound=%s', cfgfound)
self.cfgpath = cfgfound
else:
cfile = os.path.join(self.datapath, 'app.ini')
self.cfg['GLOBAL'] = {}
self.cfg['DEFAULT'] = self.defaults
self.cfg.set('DEFAULT', 'data_dir', self.datapath)
self.cfg.set('DEFAULT', 'image_script', self.defaults['image_script'])
cfgfound = cfile
self.cfgpath = cfgfound
self.configWrite()
self.cfg.set('GLOBAL', 'data_dir', self.datapath)
self.cfg.set('GLOBAL', 'log_dir', self.logpath)
self.cfg.set('GLOBAL', 'db_dir', self.dbpath)
self.cfg.set('GLOBAL', 'sessions_dir', self.sessionspath)
return True
def configWrite(self):
''' Write self.cfg to disk
'''
with open(self.cfgpath, 'w') as configfile:
self.cfg.write(configfile)
return True
def globalize(self):
''' Place the cfg variables into the self.config
scope
'''
mod = sys.modules[__name__]
for vn in self.cfg['GLOBAL']:
vn = vn.upper()
v = self.cfg.get('GLOBAL', vn)
if vn in ['PORT', 'COMIC_SCAN_INTERVAL', 'IMAGE_SCRIPT',
'COMICS_PER_PAGE', 'THUMB_MAXWIDTH', 'THUMB_MAXHEIGHT']:
if v == '':
v = self.cfg.get('DEFAULT', vn)
v = int(v, 10)
setattr(mod, vn, v)
def get_yn(self, msg):
while True:
v = input(msg)
if v.lower() in ['y', 'n']:
break
print(""\nInvalid response. Enter 'y' or 'n'."")
return v.lower() == 'y'
def get_path(self, name):
p = None
while True:
prompt = 'Please enter %s: ' % name
p = input(prompt)
if not os.path.exists(p):
msg = 'Path %s does not exist.\n\nDo you wish to create it? [y/n]: ' % p
if self.get_yn(msg):
try:
os.makedirs(p)
except PermissionError:
print(""You don't have the permissions to create that path.\n"")
continue
else:
print(""Not creating directory: %s"" % p)
continue
break
return p
def configRead(self):
''' Read the app.ini config file.
'''
print(""configRead() being called..."")
dp = self.find_config()
if dp is None or self.datapath is None:
log.error(""Failed to find_config()"")
sys.exit(1)
self.cfgpath = os.path.join(self.datapath, 'app.ini')
self.cfg.read(self.cfgpath)
for k in self.defaults.keys():
if k not in self.cfg['DEFAULT']:
v = self.defaults[k]
log.info(""Setting default[%s] = %s"", k, v)
self.cfg['DEFAULT'][k] = v
if 'GLOBAL' not in self.cfg:
log.info(""Resetting GLOBAL cfg..."")
self.cfg['GLOBAL'] = {}
self.cfg.set('GLOBAL', 'data_dir', self.datapath)
if 'comic_path' not in self.cfg['GLOBAL'] or self.cfg.get('GLOBAL', 'comic_path') in [None, '']:
cpath = self.get_path(""your comic share's path"")
if cpath is not None:
self.cfg.set('GLOBAL', 'comic_path', cpath)
if 'temp_dir' not in self.cfg['GLOBAL'] or self.cfg.get('GLOBAL', 'temp_dir') in [None, '']:
tdir = self.get_path('a directory for temporary (large) file storage')
if tdir is not None:
self.cfg.set('GLOBAL', 'temp_dir', tdir)
self.configWrite()
self.cfg.set('GLOBAL', 'log_dir', self.logpath)
self.cfg.set('GLOBAL', 'db_dir', self.dbpath)
self.cfg.set('GLOBAL', 'sessions_dir', self.sessionspath)
self.globalize()
return True
def updateCfg(self, newvals):
''' Update the self.cfg with newvals, which should be
a dict in the form {'GLOBAL': {'varname': 'varval'}}
'''
log.debug(newvals)
for k in newvals['GLOBAL'].keys():
if not isinstance(newvals['GLOBAL'][k], str):
if newvals['GLOBAL'][k] is None:
newvals['GLOBAL'][k] = ''
else:
log.debug(""newvals['GLOBAL'][%s] is type %s"",
k, str(type(newvals['GLOBAL'][k])))
self.cfg.set('GLOBAL', k, newvals['GLOBAL'][k])
self.configWrite()
self.globalize()
return True
",1
")"",
400: ""Bad request sent to search API ({0})"",
401: ""Incorrect API Key ({0})"",
403: ""Correct API but request refused ({0})"",
404: ""Bad request sent to search API ({0})""}
class SearchException(Exception):
""""""
Abstract class representing an ifind search exception.
""""""
def __init__(self, module, message):
""""""
SearchException constructor.
Args:
module (str): name of module/class that's raising exception
message (str): exception message to be displayed
Usage:
raise SearchException(""Test"", ""this is an error"")
""""""
message = ""{0} - {1}"".format(module, message)
Exception.__init__(self, message)
class EngineConnectionException(SearchException):
""""""
Thrown when an Engine connectivity error occurs.
Returns specific response message if status code specified.
""""""
def __init__(self, engine, message, code=None):
""""""
EngineException constructor.
Args:
engine (str): name of engine that's raising exception
message (str): exception message to be displayed (ignored usually here)
Kwargs:
code (int): response status code of issued request
Usage:
raise EngineException(""Bing"", """", code=200)
""""""
self.message = message
self.code = code
if code:
self.message = ERROR.get(code, ERROR['default']).format(self.code)
SearchException.__init__(self, engine, self.message)
class EngineLoadException(SearchException):
""""""
Thrown when an Engine can't be dynamically loaded.
""""""
pass
class EngineAPIKeyException(SearchException):
""""""
Thrown when an Engine's API key hasn't been provided.
""""""
pass
class QueryParamException(SearchException):
""""""
Thrown when a query parameters incompatible or missing.
""""""
pass
class CacheConnectionException(SearchException):
""""""
Thrown when cache connectivity error occurs.
""""""
pass
class InvalidQueryException(SearchException):
""""""
Thrown when an invalid query is passed to engine's search method.
""""""
pass
class RateLimitException(SearchException):
""""""
Thrown when an engine's request rate limit has been exceeded.
""""""
pass",1
"ee software: you can redistribute it and/or modify
# it under the terms of the GNU Affero 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see ,""
""Odoo Community Association (OCA)"",
'website': 'http://miketelahun.wordpress.com',
'license': 'AGPL-3',
'depends': [
'hr',
'web',
'trip'
],
'js': [
'static/src/js/jquery.webcam.js',
'static/src/js/tapplicant_webcam.js',
],
'css': [
'static/src/css/tapplicant_webcam.css',
],
'qweb': [
'static/src/xml/tapplicant_webcam.xml',
],
'data': [
'tapplicant_webcam_data.xml',
'tapplicant_webcam_view.xml',
],
'installable': True,
'active': False,
}
",1
"to files
run the command as another user
limit the process's running time
control the process window (location, size, window state, desktop)
Works on Windows NT, 2000 & XP. Requires Mark Hammond's win32
extensions.
This code is free for any purpose, with no warranty of any kind.
-- John B. Dell'Aquila
""""""
import win32api, win32process, win32security
import win32event, win32con, msvcrt, win32gui
def logonUser(loginString):
""""""
Login as specified user and return handle.
loginString: 'Domain\nUser\nPassword'; for local
login use . or empty string as domain
e.g. '.\nadministrator\nsecret_password'
""""""
domain, user, passwd = loginString.split('\n')
return win32security.LogonUser(
user,
domain,
passwd,
win32con.LOGON32_LOGON_INTERACTIVE,
win32con.LOGON32_PROVIDER_DEFAULT
)
class Process:
""""""
A Windows process.
""""""
def __init__(self, cmd, login=None,
hStdin=None, hStdout=None, hStderr=None,
show=1, xy=None, xySize=None,
desktop=None):
""""""
Create a Windows process.
cmd: command to run
login: run as user 'Domain\nUser\nPassword'
hStdin, hStdout, hStderr:
handles for process I/O; default is caller's stdin,
stdout & stderr
show: wShowWindow (0=SW_HIDE, 1=SW_NORMAL, ...)
xy: window offset (x, y) of upper left corner in pixels
xySize: window size (width, height) in pixels
desktop: lpDesktop - name of desktop e.g. 'winsta0\\default'
None = inherit current desktop
'' = create new desktop if necessary
User calling login requires additional privileges:
Act as part of the operating system [not needed on Windows XP]
Increase quotas
Replace a process level token
Login string must EITHER be an administrator's account
(ordinary user can't access current desktop - see Microsoft
Q165194) OR use desktop='' to run another desktop invisibly
(may be very slow to startup & finalize).
""""""
si = win32process.STARTUPINFO()
si.dwFlags = (win32con.STARTF_USESTDHANDLES ^
win32con.STARTF_USESHOWWINDOW)
if hStdin is None:
si.hStdInput = win32api.GetStdHandle(win32api.STD_INPUT_HANDLE)
else:
si.hStdInput = hStdin
if hStdout is None:
si.hStdOutput = win32api.GetStdHandle(win32api.STD_OUTPUT_HANDLE)
else:
si.hStdOutput = hStdout
if hStderr is None:
si.hStdError = win32api.GetStdHandle(win32api.STD_ERROR_HANDLE)
else:
si.hStdError = hStderr
si.wShowWindow = show
if xy is not None:
si.dwX, si.dwY = xy
si.dwFlags ^= win32con.STARTF_USEPOSITION
if xySize is not None:
si.dwXSize, si.dwYSize = xySize
si.dwFlags ^= win32con.STARTF_USESIZE
if desktop is not None:
si.lpDesktop = desktop
procArgs = (None, # appName
cmd, # commandLine
None, # processAttributes
None, # threadAttributes
1, # bInheritHandles
win32process.CREATE_NEW_CONSOLE, # dwCreationFlags
None, # newEnvironment
None, # currentDirectory
si) # startupinfo
if login is not None:
hUser = logonUser(login)
win32security.ImpersonateLoggedOnUser(hUser)
procHandles = win32process.CreateProcessAsUser(hUser, *procArgs)
win32security.RevertToSelf()
else:
procHandles = win32process.CreateProcess(*procArgs)
self.hProcess, self.hThread, self.PId, self.TId = procHandles
def wait(self, mSec=None):
""""""
Wait for process to finish or for specified number of
milliseconds to elapse.
""""""
if mSec is None:
mSec = win32event.INFINITE
return win32event.WaitForSingleObject(self.hProcess, mSec)
def kill(self, gracePeriod=5000):
""""""
Kill process. Try for an orderly shutdown via WM_CLOSE. If
still running after gracePeriod (5 sec. default), terminate.
""""""
win32gui.EnumWindows(self.__close__, 0)
if self.wait(gracePeriod) != win32event.WAIT_OBJECT_0:
win32process.TerminateProcess(self.hProcess, 0)
win32api.Sleep(100) # wait for resources to be released
def __close__(self, hwnd, dummy):
""""""
EnumWindows callback - sends WM_CLOSE to any window
owned by this process.
""""""
TId, PId = win32process.GetWindowThreadProcessId(hwnd)
if PId == self.PId:
win32gui.PostMessage(hwnd, win32con.WM_CLOSE, 0, 0)
def exitCode(self):
""""""
Return process exit code.
""""""
return win32process.GetExitCodeProcess(self.hProcess)
def run(cmd, mSec=None, stdin=None, stdout=None, stderr=None, **kw):
""""""
Run cmd as a child process and return exit code.
mSec: terminate cmd after specified number of milliseconds
stdin, stdout, stderr:
file objects for child I/O (use hStdin etc. to attach
handles instead of files); default is caller's stdin,
stdout & stderr;
kw: see Process.__init__ for more keyword options
""""""
if stdin is not None:
kw['hStdin'] = msvcrt.get_osfhandle(stdin.fileno())
if stdout is not None:
kw['hStdout'] = msvcrt.get_osfhandle(stdout.fileno())
if stderr is not None:
kw['hStderr'] = msvcrt.get_osfhandle(stderr.fileno())
child = Process(cmd, **kw)
if child.wait(mSec) != win32event.WAIT_OBJECT_0:
child.kill()
raise WindowsError, 'process timeout exceeded'
return child.exitCode()
if __name__ == '__main__':
# Pipe commands to a shell and display the output in notepad
print 'Testing winprocess.py...'
import tempfile
timeoutSeconds = 15
cmdString = """"""\
REM Test of winprocess.py piping commands to a shell.\r
REM This window will close in %d seconds.\r
vol\r
net user\r
_this_is_a_test_of_stderr_\r
"""""" % timeoutSeconds
cmd, out = tempfile.TemporaryFile(), tempfile.TemporaryFile()
cmd.write(cmdString)
cmd.seek(0)
print 'CMD.EXE exit code:', run('cmd.exe', show=0, stdin=cmd,
stdout=out, stderr=out)
cmd.close()
print 'NOTEPAD exit code:', run('notepad.exe %s' % out.file.name,
show=win32con.SW_MAXIMIZE,
mSec=timeoutSeconds*1000)
out.close()
",1
"t
def make_vecs_vals(shape):
return randn(*(shape)), randn(*(shape[:-2] + shape[-1:]))
try:
np.einsum
except AttributeError:
with_einsum = dec.skipif(True, ""Need einsum for benchmark"")
else:
def with_einsum(f): return f
@with_einsum
def test_vec_val_vect():
for shape0 in ((10,), (100,), (10, 12), (12, 10, 5)):
for shape1 in ((3, 3), (4, 3), (3, 4)):
shape = shape0 + shape1
evecs, evals = make_vecs_vals(shape)
res1 = np.einsum('...ij,...j,...kj->...ik', evecs, evals, evecs)
assert_almost_equal(res1, vec_val_vect(evecs, evals))
def dumb_sum(vecs, vals):
N, rows, cols = vecs.shape
res2 = np.zeros((N, rows, rows))
for i in range(N):
Q = vecs[i]
L = vals[i]
res2[i] = np.dot(Q, np.dot(np.diag(L), Q.T))
return res2
def test_vec_val_vect_dumber():
for shape0 in ((10,), (100,)):
for shape1 in ((3, 3), (4, 3), (3, 4)):
shape = shape0 + shape1
evecs, evals = make_vecs_vals(shape)
res1 = dumb_sum(evecs, evals)
assert_almost_equal(res1, vec_val_vect(evecs, evals))
",1
" :copyright: Copyright 2006-2010 by the Pygments team, see AUTHORS.
:license: BSD, see LICENSE for details.
""""""
from pygments.style import Style
from pygments.token import Keyword, Name, Comment, String, Error, \
Number, Operator, Generic, Whitespace
class BorlandStyle(Style):
""""""
Style similar to the style used in the borland IDEs.
""""""
default_style = ''
styles = {
Whitespace: '#bbbbbb',
Comment: 'italic #008800',
Comment.Preproc: 'noitalic #008080',
Comment.Special: 'noitalic bold',
String: '#0000FF',
String.Char: '#800080',
Number: '#0000FF',
Keyword: 'bold #000080',
Operator.Word: 'bold',
Name.Tag: 'bold #000080',
Name.Attribute: '#FF0000',
Generic.Heading: '#999999',
Generic.Subheading: '#aaaaaa',
Generic.Deleted: 'bg:#ffdddd #000000',
Generic.Inserted: 'bg:#ddffdd #000000',
Generic.Error: '#aa0000',
Generic.Emph: 'italic',
Generic.Strong: 'bold',
Generic.Prompt: '#555555',
Generic.Output: '#888888',
Generic.Traceback: '#aa0000',
Error: 'bg:#e3d2d2 #a61717'
}
",1
"# SPDX-License-Identifier: (Apache-2.0 OR MIT)
from spack import *
class PyIlmbase(AutotoolsPackage):
""""""The PyIlmBase libraries provides python bindings for the IlmBase libraries.""""""
homepage = ""https://github.com/AcademySoftwareFoundation/openexr/tree/v2.3.0/PyIlmBase""
url = ""https://github.com/AcademySoftwareFoundation/openexr/releases/download/v2.3.0/pyilmbase-2.3.0.tar.gz""
version('2.3.0', sha256='9c898bb16e7bc916c82bebdf32c343c0f2878fc3eacbafa49937e78f2079a425')
depends_on('ilmbase')
depends_on('boost+python')
# https://github.com/AcademySoftwareFoundation/openexr/issues/336
parallel = False
def configure_args(self):
spec = self.spec
args = [
'--with-boost-python-libname=boost_python{0}'.format(
spec['python'].version.up_to(2).joined)
]
return args
",1
"png"" alt=""projecteuler.net"" style=""border:none;"" />
Number letter counts
Problem 17
Published on Friday, 17th May 2002, 06:00 pm; Solved by 88413; Difficulty rating: 5%
If the numbers 1 to 5 are written out in words: one, two, three, four, five, then there are 3 + 3 + 5 + 4 + 4 = 19 letters used in total.
If all the numbers from 1 to 1000 (one thousand) inclusive were written out in words, how many letters would be used?
NOTE: Do not count spaces or hyphens. For example, 342 (three hundred and forty-two) contains 23 letters and 115 (one hundred and fifteen) contains 20 letters. The use of ""and"" when writing out numbers is in compliance with British usage.
""""""
s={0:"""",1:""one"",2:""two"",3:""three"",4:""four"",5:""five"",6:""six"",7:""seven"",8:""eight"",9:""nine"",10:""ten"",11:""eleven"",12:""twelve"",13:""thirteen"",14:""fourteen"",15:""fifteen"",16:""sixteen"",17:""seventeen"",18:""eighteen"",19:""nineteen"",20:""twenty"",30:""thirty"",40:""forty"",50:""fifty"",60:""sixty"",70:""seventy"",80:""eighty"",90:""ninety""}
for i in range(1,1000):
if(not i in s.keys()):
if(i<100):
s[i]=s[i/10*10]+s[i%10]
else:
s[i]=s[i/100]+""hundred""
if(i%100):
s[i]+=""and""+s[i%100]
s[1000]=""onethousand""
total=0;
for i in s.values():
total+=len(i)
print total
",1
"https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import absolute_import, division, print_function
__metaclass__ = type
DOCUMENTATION = '''
---
module: group
version_added: ""0.0.2""
short_description: Add or remove groups
requirements:
- groupadd
- groupdel
- groupmod
description:
- Manage presence of groups on a host.
- For Windows targets, use the M(win_group) module instead.
options:
name:
description:
- Name of the group to manage.
type: str
required: true
gid:
description:
- Optional I(GID) to set for the group.
type: int
state:
description:
- Whether the group should be present or not on the remote host.
type: str
choices: [ absent, present ]
default: present
system:
description:
- If I(yes), indicates that the group created is a system group.
type: bool
default: no
local:
description:
- Forces the use of ""local"" command alternatives on platforms that implement it.
- This is useful in environments that use centralized authentication when you want to manipulate the local groups.
(e.g. it uses C(lgroupadd) instead of C(groupadd)).
- This requires that these commands exist on the targeted host, otherwise it will be a fatal error.
type: bool
default: no
version_added: ""2.6""
non_unique:
description:
- This option allows to change the group ID to a non-unique value. Requires C(gid).
- Not supported on macOS or BusyBox distributions.
type: bool
default: no
version_added: ""2.8""
seealso:
- module: user
- module: win_group
author:
- Stephen Fromm (@sfromm)
'''
EXAMPLES = '''
- name: Ensure group ""somegroup"" exists
group:
name: somegroup
state: present
- name: Ensure group ""docker"" exists with correct gid
group:
name: docker
state: present
gid: 1750
'''
RETURN = r'''
gid:
description: Group ID of the group.
returned: When C(state) is 'present'
type: int
sample: 1001
name:
description: Group name
returned: always
type: str
sample: users
state:
description: Whether the group is present or not
returned: always
type: str
sample: 'absent'
system:
description: Whether the group is a system group or not
returned: When C(state) is 'present'
type: bool
sample: False
'''
import grp
import os
from ansible.module_utils._text import to_bytes
from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils.common.sys_info import get_platform_subclass
class Group(object):
""""""
This is a generic Group manipulation class that is subclassed
based on platform.
A subclass may wish to override the following action methods:-
- group_del()
- group_add()
- group_mod()
All subclasses MUST define platform and distribution (which may be None).
""""""
platform = 'Generic'
distribution = None
GROUPFILE = '/etc/group'
def __new__(cls, *args, **kwargs):
new_cls = get_platform_subclass(Group)
return super(cls, new_cls).__new__(new_cls)
def __init__(self, module):
self.module = module
self.state = module.params['state']
self.name = module.params['name']
self.gid = module.params['gid']
self.system = module.params['system']
self.local = module.params['local']
self.non_unique = module.params['non_unique']
def execute_command(self, cmd):
return self.module.run_command(cmd)
def group_del(self):
if self.local:
command_name = 'lgroupdel'
else:
command_name = 'groupdel'
cmd = [self.module.get_bin_path(command_name, True), self.name]
return self.execute_command(cmd)
def _local_check_gid_exists(self):
if self.gid:
for gr in grp.getgrall():
if self.gid == gr.gr_gid and self.name != gr.gr_name:
self.module.fail_json(msg=""GID '{0}' already exists with group '{1}'"".format(self.gid, gr.gr_name))
def group_add(self, **kwargs):
if self.local:
command_name = 'lgroupadd'
self._local_check_gid_exists()
else:
command_name = 'groupadd'
cmd = [self.module.get_bin_path(command_name, True)]
for key in kwargs:
if key == 'gid' and kwargs[key] is not None:
cmd.append('-g')
cmd.append(str(kwargs[key]))
if self.non_unique:
cmd.append('-o')
elif key == 'system' and kwargs[key] is True:
cmd.append('-r')
cmd.append(self.name)
return self.execute_command(cmd)
def group_mod(self, **kwargs):
if self.local:
command_name = 'lgroupmod'
self._local_check_gid_exists()
else:
command_name = 'groupmod'
cmd = [self.module.get_bin_path(command_name, True)]
info = self.group_info()
for key in kwargs:
if key == 'gid':
if kwargs[key] is not None and info[2] != int(kwargs[key]):
cmd.append('-g')
cmd.append(str(kwargs[key]))
if self.non_unique:
cmd.append('-o')
if len(cmd) == 1:
return (None, '', '')
if self.module.check_mode:
return (0, '', '')
cmd.append(self.name)
return self.execute_command(cmd)
def group_exists(self):
# The grp module does not distinguish between local and directory accounts.
# It's output cannot be used to determine whether or not a group exists locally.
# It returns True if the group exists locally or in the directory, so instead
# look in the local GROUP file for an existing account.
if self.local:
if not os.path.exists(self.GROUPFILE):
self.module.fail_json(msg=""'local: true' specified but unable to find local group file {0} to parse."".format(self.GROUPFILE))
exists = False
name_test = '{0}:'.format(self.name)
with open(self.GROUPFILE, 'rb') as f:
reversed_lines = f.readlines()[::-1]
for line in reversed_lines:
if line.startswith(to_bytes(name_test)):
exists = True
break
if not exists:
self.module.warn(
""'local: true' specified and group was not found in {file}. ""
""The local group may already exist if the local group database exists somewhere other than {file}."".format(file=self.GROUPFILE))
return exists
else:
try:
if grp.getgrnam(self.name):
return True
except KeyError:
return False
def group_info(self):
if not self.group_exists():
return False
try:
info = list(grp.getgrnam(self.name))
except KeyError:
return False
return info
# ===========================================
class SunOS(Group):
""""""
This is a SunOS Group manipulation class. Solaris doesn't have
the 'system' group concept.
This overrides the following methods from the generic class:-
- group_add()
""""""
platform = 'SunOS'
distribution = None
GROUPFILE = '/etc/group'
def group_add(self, **kwargs):
cmd = [self.module.get_bin_path('groupadd', True)]
for key in kwargs:
if key == 'gid' and kwargs[key] is not None:
cmd.append('-g')
cmd.append(str(kwargs[key]))
if self.non_unique:
cmd.append('-o')
cmd.append(self.name)
return self.execute_command(cmd)
# ===========================================
class AIX(Group):
""""""
This is a AIX Group manipulation class.
This overrides the following methods from the generic class:-
- group_del()
- group_add()
- group_mod()
""""""
platform = 'AIX'
distribution = None
GROUPFILE = '/etc/group'
def group_del(self):
cmd = [self.module.get_bin_path('rmgroup', True), self.name]
return self.execute_command(cmd)
def group_add(self, **kwargs):
cmd = [self.module.get_bin_path('mkgroup', True)]
for key in kwargs:
if key == 'gid' and kwargs[key] is not None:
cmd.append('id=' + str(kwargs[key]))
elif key == 'system' and kwargs[key] is True:
cmd.append('-a')
cmd.append(self.name)
return self.execute_command(cmd)
def group_mod(self, **kwargs):
cmd = [self.module.get_bin_path('chgroup', True)]
info = self.group_info()
for key in kwargs:
if key == 'gid':
if kwargs[key] is not None and info[2] != int(kwargs[key]):
cmd.append('id=' + str(kwargs[key]))
if len(cmd) == 1:
return (None, '', '')
if self.module.check_mode:
return (0, '', '')
cmd.append(self.name)
return self.execute_command(cmd)
# ===========================================
class FreeBsdGroup(Group):
""""""
This is a FreeBSD Group manipulation class.
This overrides the following methods from the generic class:-
- group_del()
- group_add()
- group_mod()
""""""
platform = 'FreeBSD'
distribution = None
GROUPFILE = '/etc/group'
def group_del(self):
cmd = [self.module.get_bin_path('pw', True), 'groupdel', self.name]
return self.execute_command(cmd)
def group_add(self, **kwargs):
cmd = [self.module.get_bin_path('pw', True), 'groupadd', self.name]
if self.gid is not None:
cmd.append('-g')
cmd.append(str(self.gid))
if self.non_unique:
cmd.append('-o')
return self.execute_command(cmd)
def group_mod(self, **kwargs):
cmd = [self.module.get_bin_path('pw', True), 'groupmod', self.name]
info = self.group_info()
cmd_len = len(cmd)
if self.gid is not None and int(self.gid) != info[2]:
cmd.append('-g')
cmd.append(str(self.gid))
if self.non_unique:
cmd.append('-o')
# modify the group if cmd will do anything
if cmd_len != len(cmd):
if self.module.check_mode:
return (0, '', '')
return self.execute_command(cmd)
return (None, '', '')
class DragonFlyBsdGroup(FreeBsdGroup):
""""""
This is a DragonFlyBSD Group manipulation class.
It inherits all behaviors from FreeBsdGroup class.
""""""
platform = 'DragonFly'
# ===========================================
class DarwinGroup(Group):
""""""
This is a Mac macOS Darwin Group manipulation class.
This overrides the following methods from the generic class:-
- group_del()
- group_add()
- group_mod()
group manipulation are done using dseditgroup(1).
""""""
platform = 'Darwin'
distribution = None
def group_add(self, **kwargs):
cmd = [self.module.get_bin_path('dseditgroup', True)]
cmd += ['-o', 'create']
if self.gid is not None:
cmd += ['-i', str(self.gid)]
elif 'system' in kwargs and kwargs['system'] is True:
gid = self.get_lowest_available_system_gid()
if gid is not False:
self.gid = str(gid)
cmd += ['-i', str(self.gid)]
cmd += ['-L', self.name]
(rc, out, err) = self.execute_command(cmd)
return (rc, out, err)
def group_del(self):
cmd = [self.module.get_bin_path('dseditgroup', True)]
cmd += ['-o', 'delete']
cmd += ['-L', self.name]
(rc, out, err) = self.execute_command(cmd)
return (rc, out, err)
def group_mod(self, gid=None):
info = self.group_info()
if self.gid is not None and int(self.gid) != info[2]:
cmd = [self.module.get_bin_path('dseditgroup', True)]
cmd += ['-o', 'edit']
if gid is not None:
cmd += ['-i', str(gid)]
cmd += ['-L', self.name]
(rc, out, err) = self.execute_command(cmd)
return (rc, out, err)
return (None, '', '')
def get_lowest_available_system_gid(self):
# check for lowest available system gid (< 500)
try:
cmd = [self.module.get_bin_path('dscl', True)]
cmd += ['/Local/Default', '-list', '/Groups', 'PrimaryGroupID']
(rc, out, err) = self.execute_command(cmd)
lines = out.splitlines()
highest = 0
for group_info in lines:
parts = group_info.split(' ')
if len(parts) > 1:
gid = int(parts[-1])
if gid > highest and gid < 500:
highest = gid
if highest == 0 or highest == 499:
return False
return (highest + 1)
except Exception:
return False
class OpenBsdGroup(Group):
""""""
This is a OpenBSD Group manipulation class.
This overrides the following methods from the generic class:-
- group_del()
- group_add()
- group_mod()
""""""
platform = 'OpenBSD'
distribution = None
GROUPFILE = '/etc/group'
def group_del(self):
cmd = [self.module.get_bin_path('groupdel', True), self.name]
return self.execute_command(cmd)
def group_add(self, **kwargs):
cmd = [self.module.get_bin_path('groupadd', True)]
if self.gid is not None:
cmd.append('-g')
cmd.append(str(self.gid))
if self.non_unique:
cmd.append('-o')
cmd.append(self.name)
return self.execute_command(cmd)
def group_mod(self, **kwargs):
cmd = [self.module.get_bin_path('groupmod', True)]
info = self.group_info()
if self.gid is not None and int(self.gid) != info[2]:
cmd.append('-g')
cmd.append(str(self.gid))
if self.non_unique:
cmd.append('-o')
if len(cmd) == 1:
return (None, '', '')
if self.module.check_mode:
return (0, '', '')
cmd.append(self.name)
return self.execute_command(cmd)
# ===========================================
class NetBsdGroup(Group):
""""""
This is a NetBSD Group manipulation class.
This overrides the following methods from the generic class:-
- group_del()
- group_add()
- group_mod()
""""""
platform = 'NetBSD'
distribution = None
GROUPFILE = '/etc/group'
def group_del(self):
cmd = [self.module.get_bin_path('groupdel', True), self.name]
return self.execute_command(cmd)
def group_add(self, **kwargs):
cmd = [self.module.get_bin_path('groupadd', True)]
if self.gid is not None:
cmd.append('-g')
cmd.append(str(self.gid))
if self.non_unique:
cmd.append('-o')
cmd.append(self.name)
return self.execute_command(cmd)
def group_mod(self, **kwargs):
cmd = [self.module.get_bin_path('groupmod', True)]
info = self.group_info()
if self.gid is not None and int(self.gid) != info[2]:
cmd.append('-g')
cmd.append(str(self.gid))
if self.non_unique:
cmd.append('-o')
if len(cmd) == 1:
return (None, '', '')
if self.module.check_mode:
return (0, '', '')
cmd.append(self.name)
return self.execute_command(cmd)
# ===========================================
class BusyBoxGroup(Group):
""""""
BusyBox group manipulation class for systems that have addgroup and delgroup.
It overrides the following methods:
- group_add()
- group_del()
- group_mod()
""""""
def group_add(self, **kwargs):
cmd = [self.module.get_bin_path('addgroup', True)]
if self.gid is not None:
cmd.extend(['-g', str(self.gid)])
if self.system:
cmd.append('-S')
cmd.append(self.name)
return self.execute_command(cmd)
def group_del(self):
cmd = [self.module.get_bin_path('delgroup', True), self.name]
return self.execute_command(cmd)
def group_mod(self, **kwargs):
# Since there is no groupmod command, modify /etc/group directly
info = self.group_info()
if self.gid is not None and self.gid != info[2]:
with open('/etc/group', 'rb') as f:
b_groups = f.read()
b_name = to_bytes(self.name)
b_current_group_string = b'%s:x:%d:' % (b_name, info[2])
b_new_group_string = b'%s:x:%d:' % (b_name, self.gid)
if b':%d:' % self.gid in b_groups:
self.module.fail_json(msg=""gid '{gid}' in use"".format(gid=self.gid))
if self.module.check_mode:
return 0, '', ''
b_new_groups = b_groups.replace(b_current_group_string, b_new_group_string)
with open('/etc/group', 'wb') as f:
f.write(b_new_groups)
return 0, '', ''
return None, '', ''
class AlpineGroup(BusyBoxGroup):
platform = 'Linux'
distribution = 'Alpine'
def main():
module = AnsibleModule(
argument_spec=dict(
state=dict(type='str', default='present', choices=['absent', 'present']),
name=dict(type='str', required=True),
gid=dict(type='int'),
system=dict(type='bool', default=False),
local=dict(type='bool', default=False),
non_unique=dict(type='bool', default=False),
),
supports_check_mode=True,
required_if=[
['non_unique', True, ['gid']],
],
)
group = Group(module)
module.debug('Group instantiated - platform %s' % group.platform)
if group.distribution:
module.debug('Group instantiated - distribution %s' % group.distribution)
rc = None
out = ''
err = ''
result = {}
result['name'] = group.name
result['state'] = group.state
if group.state == 'absent':
if group.group_exists():
if module.check_mode:
module.exit_json(changed=True)
(rc, out, err) = group.group_del()
if rc != 0:
module.fail_json(name=group.name, msg=err)
elif group.state == 'present':
if not group.group_exists():
if module.check_mode:
module.exit_json(changed=True)
(rc, out, err) = group.group_add(gid=group.gid, system=group.system)
else:
(rc, out, err) = group.group_mod(gid=group.gid)
if rc is not None and rc != 0:
module.fail_json(name=group.name, msg=err)
if rc is None:
result['changed'] = False
else:
result['changed'] = True
if out:
result['stdout'] = out
if err:
result['stderr'] = err
if group.group_exists():
info = group.group_info()
result['system'] = group.system
result['gid'] = info[2]
module.exit_json(**result)
if __name__ == '__main__':
main()
",1
"fy
# 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 Register
\n"", response.data)
def test_user_registration(self):
# Ensure registration behaves correctlys.
with self.client:
response = self.client.post(
""/register"",
data=dict(
email=""test@tester.com"",
password=""testing"",
confirm=""testing"",
),
follow_redirects=True,
)
self.assertIn(b""Welcome"", response.data)
self.assertTrue(current_user.email == ""test@tester.com"")
self.assertTrue(current_user.is_active())
self.assertEqual(response.status_code, 200)
if __name__ == ""__main__"":
unittest.main()
",1
"
""Make a class named %%% that is-a %%%."",
""class %%%(object):\n\tdef __init__(self, ***)"" :
""class %%% has-a __init__ hat takes self and *** parameter."",
""class %%%(object):\n\tdef ***(self, @@@)"":
""class %%% has-a function named *** that takes self and @@@ parameter."",
""*** = %%%()"":
""Set *** to an instance of class %%%."",
""***.***(@@@)"":
""From *** get the *** function, and call it with parameters self, @@@."",
""***.*** = '***'"":
""From *** get the *** attribute and set it to '***'.""
}
# do they want to drill phrases first
if len(sys.argv) == 2 and sys.argv[1] == ""english"":
PHRASE_FIRST = True
else:
PHRASE_FIRST = False
# load up the word from the website
for word in urlopen(WORD_URL).readlines():
WORDS.append(word.strip())
def convert(snippet, phrase):
class_names = [w.capitalize() for w in
random.sample(WORDS, snippet.count(""%%%""))]
other_names = random.sample(WORDS, snippet.count(""***""))
results = []
param_names = []
for i in range(0, snippet.count(""@@@"")):
param_count = random.randint(1,3)
param_names.append(', '.join(random.sample(WORDS, param_count)))
for sentence in snippet, phrase:
result = sentence[:]
# fake class names
for word in class_names:
result = result.replace(""%%%"", word, 1)
# fake other names
for word in other_names:
result = result.replace(""***"", word, 1)
# fake parameter lists
for word in param_names:
result = result.replace(""@@@"", word, 1)
results.append(result)
return results
# keep going until they hit CTRL-D
try:
while True:
snippets = PHRASES.keys()
random.shuffle(snippets)
for snippet in snippets:
phrase = PHRASES[snippet]
question, answer = convert(snippet, phrase)
if PHRASE_FIRST:
question, answer = answer, question
print question
raw_input(""> "")
print ""ANSWER: %s\n\n"" % answer
except EOFError:
print ""\nBye""
",1
"olivre.org>
#
# 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 requests
from unittest import skip
from sure import expect
from httpretty import HTTPretty
@skip
def test_http_passthrough():
url = 'http://httpbin.org/status/200'
response1 = requests.get(url)
response1 = requests.get(url, stream=True)
HTTPretty.enable()
HTTPretty.register_uri(HTTPretty.GET, 'http://google.com/', body=""Not Google"")
response2 = requests.get('http://google.com/')
expect(response2.content).to.equal(b'Not Google')
response3 = requests.get(url, stream=True)
(response3.content).should.equal(response1.content)
HTTPretty.disable()
response4 = requests.get(url, stream=True)
(response4.content).should.equal(response1.content)
@skip
def test_https_passthrough():
url = 'https://raw.githubusercontent.com/gabrielfalcao/HTTPretty/master/COPYING'
response1 = requests.get(url, stream=True)
HTTPretty.enable()
HTTPretty.register_uri(HTTPretty.GET, 'https://google.com/', body=""Not Google"")
response2 = requests.get('https://google.com/')
expect(response2.content).to.equal(b'Not Google')
response3 = requests.get(url, stream=True)
(response3.content).should.equal(response1.content)
HTTPretty.disable()
response4 = requests.get(url, stream=True)
(response4.content).should.equal(response1.content)
",1
"ation
self.use_horizontal_flips = True
self.use_vertical_flips = True
self.rot_90 = True
# anchor box scales
self.anchor_box_scales = [1, 2, 4, 8, 16, 32, 64, 124, 256, 512]
# anchor box ratios
self.anchor_box_ratios = [[1, 1], [1, 2], [2, 1],[1,3],[3,1],[4,1],[1,4],[1,5],[5,1],[1,6],[6,1],[1,7],[7,1],[1,8],[8,1],[1,9],[9,1]]
# size to resize the smallest side of the image
self.im_size = 600
# image channel-wise mean to subtract
self.img_channel_mean = [103.939, 116.779, 123.68]
self.img_scaling_factor = 1.0
# number of ROIs at once
self.num_rois = 8
# stride at the RPN (this depends on the network configuration)
self.rpn_stride = 16
self.balanced_classes = False
# scaling the stdev
self.std_scaling = 4.0
self.classifier_regr_std = [8.0, 8.0, 4.0, 4.0]
# overlaps for RPN
self.rpn_min_overlap = 0.3
self.rpn_max_overlap = 0.7
# overlaps for classifier ROIs
self.classifier_min_overlap = 0.1
self.classifier_max_overlap = 0.5
# placeholder for the class mapping, automatically generated by the parser
self.class_mapping = None
#location of pretrained weights for the base network
# weight files can be found at:
# https://github.com/fchollet/deep-learning-models/releases/download/v0.2/resnet50_weights_th_dim_ordering_th_kernels_notop.h5
# https://github.com/fchollet/deep-learning-models/releases/download/v0.2/resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5
self.model_path = 'model_frcnn.vgg.hdf5'
",1
"CENSE file.
import shutil
import tempfile
from telemetry import decorators
from telemetry.testing import options_for_unittests
from telemetry.testing import page_test_test_case
from measurements import skpicture_printer
class SkpicturePrinterUnitTest(page_test_test_case.PageTestTestCase):
def setUp(self):
self._options = options_for_unittests.GetCopy()
self._skp_outdir = tempfile.mkdtemp('_skp_test')
def tearDown(self):
shutil.rmtree(self._skp_outdir)
@decorators.Disabled('android')
def testSkpicturePrinter(self):
ps = self.CreateStorySetFromFileInUnittestDataDir('blank.html')
measurement = skpicture_printer.SkpicturePrinter(self._skp_outdir)
results = self.RunMeasurement(measurement, ps, options=self._options)
# Picture printing is not supported on all platforms.
if results.failures:
assert 'not supported' in results.failures[0].exc_info[1].message
return
saved_picture_count = results.FindAllPageSpecificValuesNamed(
'saved_picture_count')
self.assertEquals(len(saved_picture_count), 1)
self.assertGreater(saved_picture_count[0].GetRepresentativeNumber(), 0)
",1
"al, LengthGreaterEqual
c = hyperdex.client.Client(sys.argv[1], int(sys.argv[2]))
def to_objectset(xs):
return set([frozenset(x.items()) for x in xs])
assert c.put('kv', 'k', {}) == True
assert c.get('kv', 'k') == {'v': {}}
assert c.put('kv', 'k', {'v': {1: 3.14, 2: 0.25, 3: 1.0}}) == True
assert c.get('kv', 'k') == {'v': {1: 3.14, 2: 0.25, 3: 1.0}}
assert c.put('kv', 'k', {'v': {}}) == True
assert c.get('kv', 'k') == {'v': {}}
",1
"if setuptools isn't installed but they just
return nothing.
lexer plugins::
[pygments.lexers]
yourlexer = yourmodule:YourLexer
formatter plugins::
[pygments.formatters]
yourformatter = yourformatter:YourFormatter
/.ext = yourformatter:YourFormatter
As you can see, you can define extensions for the formatter
with a leading slash.
syntax plugins::
[pygments.styles]
yourstyle = yourstyle:YourStyle
filter plugin::
[pygments.filter]
yourfilter = yourfilter:YourFilter
:copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS.
:license: BSD, see LICENSE for details.
""""""
from __future__ import unicode_literals
try:
import pkg_resources
except ImportError:
pkg_resources = None
LEXER_ENTRY_POINT = 'pygments.lexers'
FORMATTER_ENTRY_POINT = 'pygments.formatters'
STYLE_ENTRY_POINT = 'pygments.styles'
FILTER_ENTRY_POINT = 'pygments.filters'
def find_plugin_lexers():
if pkg_resources is None:
return
for entrypoint in pkg_resources.iter_entry_points(LEXER_ENTRY_POINT):
yield entrypoint.load()
def find_plugin_formatters():
if pkg_resources is None:
return
for entrypoint in pkg_resources.iter_entry_points(FORMATTER_ENTRY_POINT):
yield entrypoint.name, entrypoint.load()
def find_plugin_styles():
if pkg_resources is None:
return
for entrypoint in pkg_resources.iter_entry_points(STYLE_ENTRY_POINT):
yield entrypoint.name, entrypoint.load()
def find_plugin_filters():
if pkg_resources is None:
return
for entrypoint in pkg_resources.iter_entry_points(FILTER_ENTRY_POINT):
yield entrypoint.name, entrypoint.load()
",1
"le_parser
__author__ = ""Andrey Konovalov""
__copyright__ = ""Copyright (C) 2014 Andrey Konovalov""
__license__ = ""MIT""
__version__ = ""0.1""
this_dir, this_filename = os.path.split(__file__)
SCHEDULE_PATH = os.path.join(this_dir, "".."", ""data"", ""2013_fall"", ""4kurs.xls"")
class WeekdayRangeTest(unittest.TestCase):
def setUp(self):
self.schedule = schedule_parser.Schedule()
self.schedule.Parse(SCHEDULE_PATH)
def runTest(self):
self.assertEqual(self.schedule.GetWeekdayRange(0), (4, 11))
self.assertEqual(self.schedule.GetWeekdayRange(1), (12, 19))
self.assertEqual(self.schedule.GetWeekdayRange(2), (20, 27))
self.assertEqual(self.schedule.GetWeekdayRange(3), (28, 37))
self.assertEqual(self.schedule.GetWeekdayRange(4), (38, 47))
self.assertEqual(self.schedule.GetWeekdayRange(5), (48, 57))
class DepartmentCountTest(unittest.TestCase):
def setUp(self):
self.schedule = schedule_parser.Schedule()
self.schedule.Parse(SCHEDULE_PATH)
def runTest(self):
self.assertEqual(self.schedule.GetDepartmentCount(), 9)
class DepartmentRangeTest(unittest.TestCase):
def setUp(self):
self.schedule = schedule_parser.Schedule()
self.schedule.Parse(SCHEDULE_PATH)
def runTest(self):
self.assertEqual(self.schedule.GetDepartmentRange(0), (2, 11))
self.assertEqual(self.schedule.GetDepartmentRange(1), (13, 20))
self.assertEqual(self.schedule.GetDepartmentRange(2), (22, 32))
self.assertEqual(self.schedule.GetDepartmentRange(3), (34, 36))
self.assertEqual(self.schedule.GetDepartmentRange(4), (38, 43))
self.assertEqual(self.schedule.GetDepartmentRange(5), (45, 53))
self.assertEqual(self.schedule.GetDepartmentRange(6), (55, 62))
self.assertEqual(self.schedule.GetDepartmentRange(7), (64, 71))
self.assertEqual(self.schedule.GetDepartmentRange(8), (73, 77))
class DepartmentsRowTest(unittest.TestCase):
def setUp(self):
self.schedule = schedule_parser.Schedule()
self.schedule.Parse(SCHEDULE_PATH)
def runTest(self):
self.assertEqual(self.schedule.GetDepartmentsRow(), 3)
class HoursColumnTest(unittest.TestCase):
def setUp(self):
self.schedule = schedule_parser.Schedule()
self.schedule.Parse(SCHEDULE_PATH)
def runTest(self):
self.assertEqual(self.schedule.GetHoursColumn(), 1)
class HoursRangesTest(unittest.TestCase):
def setUp(self):
self.schedule = schedule_parser.Schedule()
self.schedule.Parse(SCHEDULE_PATH)
def runTest(self):
self.assertEqual(self.schedule.GetHoursRanges(0), [(4, 5), (5, 6), (6, 7), (7, 8), (8, 9), (9, 10), (10, 11)])
self.assertEqual(self.schedule.GetHoursRanges(3), [(28, 30), (30, 31), (31, 32), (32, 34), (34, 35), (35, 36), (36, 37)])
self.assertEqual(self.schedule.GetHoursRanges(5), [(48, 49), (49, 50), (50, 52), (52, 53), (53, 54), (54, 56), (56, 57)])
class GroupCountTest(unittest.TestCase):
def setUp(self):
self.schedule = schedule_parser.Schedule()
self.schedule.Parse(SCHEDULE_PATH)
def runTest(self):
self.assertEqual(self.schedule.GetGroupCount(0), 9)
self.assertEqual(self.schedule.GetGroupCount(1), 7)
self.assertEqual(self.schedule.GetGroupCount(2), 8)
self.assertEqual(self.schedule.GetGroupCount(3), 2)
self.assertEqual(self.schedule.GetGroupCount(4), 5)
self.assertEqual(self.schedule.GetGroupCount(5), 8)
self.assertEqual(self.schedule.GetGroupCount(6), 7)
self.assertEqual(self.schedule.GetGroupCount(7), 7)
self.assertEqual(self.schedule.GetGroupCount(8), 4)
class GroupListTest(unittest.TestCase):
def setUp(self):
self.schedule = schedule_parser.Schedule()
self.schedule.Parse(SCHEDULE_PATH)
def runTest(self):
self.assertEqual(self.schedule.GetGroupList(0), ['011', '012', '013', '014', '015', '016', '017', '018', '019'])
self.assertEqual(self.schedule.GetGroupList(1), ['021', '022', '023', '024', '025', '026', '028'])
self.assertEqual(self.schedule.GetGroupList(3), ['041', '042'])
self.assertEqual(self.schedule.GetGroupList(8), ['0111', '0112', '0113', '0114'])
class GroupRangeTest(unittest.TestCase):
def setUp(self):
self.schedule = schedule_parser.Schedule()
self.schedule.Parse(SCHEDULE_PATH)
def runTest(self):
self.assertEqual(self.schedule.GetGroupRange(0, 0), (2, 3))
self.assertEqual(self.schedule.GetGroupRange(0, 1), (3, 4))
self.assertEqual(self.schedule.GetGroupRange(2, 1), (23, 25))
self.assertEqual(self.schedule.GetGroupRange(2, 2), (25, 26))
self.assertEqual(self.schedule.GetGroupRange(2, 3), (26, 28))
self.assertEqual(self.schedule.GetGroupRange(5, 3), (48, 49))
self.assertEqual(self.schedule.GetGroupRange(8, 0), (73, 74))
self.assertEqual(self.schedule.GetGroupRange(8, 3), (76, 77))
class WeekdayByRowTest(unittest.TestCase):
def setUp(self):
self.schedule = schedule_parser.Schedule()
self.schedule.Parse(SCHEDULE_PATH)
def runTest(self):
self.assertEqual(self.schedule.GetWeekdayByRow(4), 0)
self.assertEqual(self.schedule.GetWeekdayByRow(5), 0)
self.assertEqual(self.schedule.GetWeekdayByRow(10), 0)
self.assertEqual(self.schedule.GetWeekdayByRow(13), 1)
self.assertEqual(self.schedule.GetWeekdayByRow(25), 2)
self.assertEqual(self.schedule.GetWeekdayByRow(26), 2)
self.assertEqual(self.schedule.GetWeekdayByRow(28), 3)
self.assertEqual(self.schedule.GetWeekdayByRow(44), 4)
self.assertEqual(self.schedule.GetWeekdayByRow(48), 5)
self.assertEqual(self.schedule.GetWeekdayByRow(56), 5)
class PairByRowTest(unittest.TestCase):
def setUp(self):
self.schedule = schedule_parser.Schedule()
self.schedule.Parse(SCHEDULE_PATH)
def runTest(self):
self.assertEqual(self.schedule.GetPairByRow(4), (0, 0))
self.assertEqual(self.schedule.GetPairByRow(5), (1, 0))
self.assertEqual(self.schedule.GetPairByRow(10), (6, 0))
self.assertEqual(self.schedule.GetPairByRow(12), (0, 0))
self.assertEqual(self.schedule.GetPairByRow(28), (0, 0))
self.assertEqual(self.schedule.GetPairByRow(29), (0, 1))
self.assertEqual(self.schedule.GetPairByRow(30), (1, 0))
self.assertEqual(self.schedule.GetPairByRow(33), (3, 1))
self.assertEqual(self.schedule.GetPairByRow(56), (6, 0))
class DepartmentByColumnTest(unittest.TestCase):
def setUp(self):
self.schedule = schedule_parser.Schedule()
self.schedule.Parse(SCHEDULE_PATH)
def runTest(self):
self.assertEqual(self.schedule.GetDepartmentIndexByColumn(2), 0)
self.assertEqual(self.schedule.GetDepartmentIndexByColumn(3), 0)
self.assertEqual(self.schedule.GetDepartmentIndexByColumn(10), 0)
self.assertEqual(self.schedule.GetDepartmentIndexByColumn(13), 1)
self.assertEqual(self.schedule.GetDepartmentIndexByColumn(18), 1)
self.assertEqual(self.schedule.GetDepartmentIndexByColumn(19), 1)
self.assertEqual(self.schedule.GetDepartmentIndexByColumn(22), 2)
self.assertEqual(self.schedule.GetDepartmentIndexByColumn(24), 2)
self.assertEqual(self.schedule.GetDepartmentIndexByColumn(31), 2)
self.assertEqual(self.schedule.GetDepartmentIndexByColumn(39), 4)
self.assertEqual(self.schedule.GetDepartmentIndexByColumn(64), 7)
self.assertEqual(self.schedule.GetDepartmentIndexByColumn(70), 7)
self.assertEqual(self.schedule.GetDepartmentIndexByColumn(73), 8)
self.assertEqual(self.schedule.GetDepartmentIndexByColumn(76), 8)
class GroupByColumnTest(unittest.TestCase):
def setUp(self):
self.schedule = schedule_parser.Schedule()
self.schedule.Parse(SCHEDULE_PATH)
def runTest(self):
self.assertEqual(self.schedule.GetGroupIndexByColumn(2), (0, 0))
self.assertEqual(self.schedule.GetGroupIndexByColumn(3), (1, 0))
self.assertEqual(self.schedule.GetGroupIndexByColumn(10), (8, 0))
self.assertEqual(self.schedule.GetGroupIndexByColumn(23), (1, 0))
self.assertEqual(self.schedule.GetGroupIndexByColumn(24), (1, 1))
self.assertEqual(self.schedule.GetGroupIndexByColumn(25), (2, 0))
self.assertEqual(self.schedule.GetGroupIndexByColumn(26), (3, 0))
self.assertEqual(self.schedule.GetGroupIndexByColumn(27), (3, 1))
self.assertEqual(self.schedule.GetGroupIndexByColumn(76), (3, 0))
def suite():
loader = unittest.TestLoader()
suite = unittest.TestSuite()
suite.addTest(WeekdayRangeTest())
suite.addTest(DepartmentCountTest())
suite.addTest(DepartmentRangeTest())
suite.addTest(DepartmentsRowTest())
suite.addTest(HoursColumnTest())
suite.addTest(HoursRangesTest())
suite.addTest(GroupCountTest())
suite.addTest(GroupListTest())
suite.addTest(GroupRangeTest())
suite.addTest(WeekdayByRowTest())
suite.addTest(PairByRowTest())
suite.addTest(DepartmentByColumnTest())
suite.addTest(GroupByColumnTest())
return suite
if __name__ == '__main__':
unittest.TextTestRunner(verbosity=2).run(suite())
",1
"s'
id = Column(Integer, Sequence('data_stage01_rnasequencing_analysis_id_seq'), primary_key=True)
analysis_id = Column(String(500))
experiment_id = Column(String(50))
sample_name_abbreviation = Column(String(500)) # equivalent to sample_name_abbreviation
sample_name = Column(String(500)) # equivalent to sample_name_abbreviation
time_point = Column(String(10)) # converted to intermediate in lineage analysis
analysis_type = Column(String(100)); # time-course (i.e., multiple time points), paired (i.e., control compared to multiple replicates), group (i.e., single grouping of samples).
used_ = Column(Boolean);
comment_ = Column(Text);
__table_args__ = (
UniqueConstraint('experiment_id','sample_name_abbreviation','sample_name','time_point','analysis_type','analysis_id'),
)
def __init__(self,
row_dict_I,
):
self.analysis_id=row_dict_I['analysis_id'];
self.experiment_id=row_dict_I['experiment_id'];
self.sample_name_abbreviation=row_dict_I['sample_name_abbreviation'];
self.sample_name=row_dict_I['sample_name'];
self.time_point=row_dict_I['time_point'];
self.analysis_type=row_dict_I['analysis_type'];
self.used_=row_dict_I['used_'];
self.comment_=row_dict_I['comment_'];
def __set__row__(self,analysis_id_I,
experiment_id_I,
sample_name_abbreviation_I,
sample_name_I,
time_point_I,
analysis_type_I,
used__I,
comment__I):
self.analysis_id=analysis_id_I
self.experiment_id=experiment_id_I
self.sample_name_abbreviation=sample_name_abbreviation_I
self.sample_name=sample_name_I
self.time_point=time_point_I
self.analysis_type=analysis_type_I
self.used_=used__I
self.comment_=comment__I
def __repr__dict__(self):
return {'id':self.id,
'analysis_id':self.analysis_id,
'experiment_id':self.experiment_id,
'sample_name_abbreviation':self.sample_name_abbreviation,
'sample_name':self.sample_name,
'time_point':self.time_point,
'analysis_type':self.analysis_type,
'used_':self.used_,
'comment_':self.comment_}
def __repr__json__(self):
return json.dumps(self.__repr__dict__())",1
"2 2015 -0400
#
# Copyright (C) 2015 Tipsy Bear Studios
# For license information, see LICENSE.txt
#
# ID: version.py [] benjamin@bengfort.com $
""""""
Helper module for ORMBad version information.
""""""
##########################################################################
## Versioning
##########################################################################
__version_info__ = {
'major': 0,
'minor': 1,
'micro': 0,
'releaselevel': 'final',
'serial': 0,
}
def get_version(short=False):
""""""
Returns the version from the version info.
""""""
assert __version_info__['releaselevel'] in ('alpha', 'beta', 'final')
vers = [""%(major)i.%(minor)i"" % __version_info__, ]
if __version_info__['micro']:
vers.append("".%(micro)i"" % __version_info__)
if __version_info__['releaselevel'] != 'final' and not short:
vers.append('%s%i' % (__version_info__['releaselevel'][0],
__version_info__['serial']))
return ''.join(vers)
",1
"aemon import runner
from os.path import dirname, abspath
# add the shared settings file to namespace
sys.path.insert(0, dirname(dirname(abspath(__file__))))
import settings
REDIS_CONN = redis.StrictRedis(unix_socket_path=settings.REDIS_SOCKET_PATH)
app = Flask(__name__)
app.config['PROPAGATE_EXCEPTIONS'] = True
@app.route(""/"")
def index():
return render_template('index.html'), 200
@app.route(""/app_settings"")
def app_settings():
app_settings = {'GRAPHITE_HOST': settings.GRAPHITE_HOST,
'OCULUS_HOST': settings.OCULUS_HOST,
'FULL_NAMESPACE': settings.FULL_NAMESPACE,
}
resp = json.dumps(app_settings)
return resp, 200
@app.route(""/api"", methods=['GET'])
def data():
metric = request.args.get('metric', None)
try:
raw_series = REDIS_CONN.get(metric)
if not raw_series:
resp = json.dumps({'results': 'Error: No metric by that name'})
return resp, 404
else:
unpacker = Unpacker(use_list = False)
unpacker.feed(raw_series)
timeseries = [item[:2] for item in unpacker]
resp = json.dumps({'results': timeseries})
return resp, 200
except Exception as e:
error = ""Error: "" + e
resp = json.dumps({'results': error})
return resp, 500
class App():
def __init__(self):
self.stdin_path = '/dev/null'
self.stdout_path = settings.LOG_PATH + '/webapp.log'
self.stderr_path = settings.LOG_PATH + '/webapp.log'
self.pidfile_path = settings.PID_PATH + '/webapp.pid'
self.pidfile_timeout = 5
def run(self):
logger.info('starting webapp')
logger.info('hosted at %s' % settings.WEBAPP_IP)
logger.info('running on port %d' % settings.WEBAPP_PORT)
app.run(settings.WEBAPP_IP, settings.WEBAPP_PORT)
if __name__ == ""__main__"":
""""""
Start the server
""""""
webapp = App()
logger = logging.getLogger(""AppLog"")
logger.setLevel(logging.DEBUG)
formatter = logging.Formatter(""%(asctime)s :: %(message)s"", datefmt=""%Y-%m-%d %H:%M:%S"")
handler = logging.FileHandler(settings.LOG_PATH + '/webapp.log')
handler.setFormatter(formatter)
logger.addHandler(handler)
if len(sys.argv) > 1 and sys.argv[1] == 'run':
webapp.run()
else:
daemon_runner = runner.DaemonRunner(webapp)
daemon_runner.daemon_context.files_preserve = [handler.stream]
daemon_runner.do_action()
",1
"_folder_iterfile
from pyquickhelper.ipythonhelper import upgrade_notebook, remove_execution_number
class TestConvertNotebooks(unittest.TestCase):
""""""Converts notebooks from v3 to v4. Should not be needed anymore.""""""
def test_convert_notebooks(self):
fLOG(
__file__,
self._testMethodName,
OutputPrint=__name__ == ""__main__"")
fold = os.path.abspath(os.path.dirname(__file__))
fold2 = os.path.normpath(
os.path.join(fold, "".."", "".."", ""_doc"", ""notebooks""))
for nbf in explore_folder_iterfile(fold2, pattern="".*[.]ipynb""):
t = upgrade_notebook(nbf)
if t:
fLOG(""modified"", nbf)
# remove numbers
remove_execution_number(nbf, nbf)
fold2 = os.path.normpath(os.path.join(fold, "".."", "".."", ""_unittests""))
for nbf in explore_folder_iterfile(fold2, pattern="".*[.]ipynb""):
t = upgrade_notebook(nbf)
if t:
fLOG(""modified"", nbf)
if __name__ == ""__main__"":
unittest.main()
",1
"turns True or False. The algorithm is called
# the ""Ray Casting Method"".
# the point_in_poly algorithm was found here:
# http://geospatialpython.com/2011/01/point-in-polygon.html
def point_in_poly(x,y,poly):
n = len(poly)
inside = False
p1x,p1y = poly[0]
for i in range(n+1):
p2x,p2y = poly[i % n]
if y > min(p1y,p2y):
if y <= max(p1y,p2y):
if x <= max(p1x,p2x):
if p1y != p2y:
xints = (y-p1y)*(p2x-p1x)/(p2y-p1y)+p1x
if p1x == p2x or x <= xints:
inside = not inside
p1x,p1y = p2x,p2y
return inside
# This one is my own version of the ray-trace algorithm which utilises the numpy arrays so that a list of x and y coordinates can be processed in one call and only points inside polygon are returned alongside the indices in case required for future referencing. This saves a fair bit of looping.
def points_in_poly(x,y,poly):
n = len(poly)
inside=np.zeros(x.size,dtype=bool)
xints=np.zeros(x.size)
p1x,p1y = poly[0]
for i in range(n+1):
p2x,p2y=poly[i % n]
if p1y!=p2y:
xints[np.all([y>min(p1y,p2y), y<=max(p1y,p2y), x<=max(p1x,p2x)],axis=0)] = (y[np.all([y>min(p1y,p2y), y<=max(p1y,p2y), x<=max(p1x,p2x)],axis=0)]-p1y)*(p2x-p1x)/(p2y-p1y)+p1x
if p1x==p2x:
inside[np.all([y>min(p1y,p2y), y<=max(p1y,p2y), x<=max(p1x,p2x)],axis=0)] = np.invert(inside[np.all([y>min(p1y,p2y), y<=max(p1y,p2y), x<=max(p1x,p2x)],axis=0)])
else:
inside[np.all([y>min(p1y,p2y), y<=max(p1y,p2y), x<=max(p1x,p2x),x<=xints],axis=0)] = np.invert(inside[np.all([y>min(p1y,p2y), y<=max(p1y,p2y), x<=max(p1x,p2x),x<=xints],axis=0)])
p1x,p1y = p2x,p2y
return x[inside],y[inside], inside
# This retrieves all points within circular neighbourhood, Terget point is the location around which the neighbourhood search is conducted, for a specified search radius. x and y are vectors with the x and y coordinates of the test points
def points_in_radius(x,y,target_x, target_y,radius):
inside=np.zeros(x.size,dtype=bool)
d2=(x-target_x)**2+(y-target_y)**2
inside = d2<=radius**2
return x[inside],y[inside], inside
# filter lidar wth polygon
# This function has been updated to include an option to filter by first return location.
# The reason for this is so full collections of returns associated with each LiDAR pulse
# can be retrieved, which can be an issue at edges in multi-return analyses
def filter_lidar_data_by_polygon(in_pts,polygon,filter_by_first_return_location = False):
pts = np.zeros((0,in_pts.shape[1]))
if in_pts.shape[0]>0:
if filter_by_first_return_location:
# find first returns
mask = in_pts[:,3]==1
x_temp, y_temp, inside_temp = points_in_poly(in_pts[mask,0],in_pts[mask,1],polygon)
shots = np.unique(in_pts[mask,6][inside_temp]) # index 6 refers to GPS time
inside = np.in1d(in_pts[:,6],shots) # this function retrieves all points corresponding to this GPS time
x = in_pts[inside,0]
y = in_pts[inside,1]
x_temp=None
y_temp=None
inside_temp=None
else:
x,y,inside = points_in_poly(in_pts[:,0],in_pts[:,1],polygon)
pts = in_pts[inside,:]
else:
print(""\t\t\t no points in polygon"")
return pts
# filter lidar by circular neighbourhood
def filter_lidar_data_by_neighbourhood(in_pts,target_xy,radius):
pts = np.zeros((0,in_pts.shape[1]))
if in_pts.shape[0]>0:
x,y,inside = points_in_radius(in_pts[:,0],in_pts[:,1],target_xy[0],target_xy[1],radius)
pts = in_pts[inside,:]
else:
print( ""\t\t\t no points in neighbourhood"")
return pts
",1
"ontrib.syndication.views import feed as feed_view
from django.views.generic import date_based, list_detail
from django.views.generic.simple import direct_to_template
from django.contrib import admin
import django.contrib.auth.views as auth_views
from django.conf import settings
from django.core.urlresolvers import reverse
from django.http import HttpResponseRedirect, HttpResponsePermanentRedirect
from django.contrib import admin
admin.autodiscover()
# Need to move this somewhere more useful and try to make it less hacky but
# seems to be the easiest way unfortunately.
from django.contrib.auth.models import User
User._meta.ordering = ['username']
from frontend.feeds import LatestCodeObjects, LatestCodeObjectsBySearchTerm, LatestCodeObjectsByTag, LatestViewObjects, LatestScraperObjects
feeds = {
'all_code_objects': LatestCodeObjects,
'all_scrapers': LatestScraperObjects,
'all_views': LatestViewObjects,
'latest_code_objects_by_search_term': LatestCodeObjectsBySearchTerm,
'latest_code_objects_by_tag': LatestCodeObjectsByTag,
}
urlpatterns = patterns('',
url(r'^$', frontend_views.frontpage, name=""frontpage""),
# redirects from old version (would clashes if you happen to have a scraper whose name is list!)
(r'^scrapers/list/$', lambda request: HttpResponseRedirect(reverse('scraper_list_wiki_type', args=['scraper']))),
url(r'^', include('codewiki.urls')),
url(r'^logout/$', auth_views.logout, {'next_page': '/'}, name=""logout""),
url(r'^accounts/', include('registration.urls')),
url(r'^accounts/resend_activation_email/', frontend_views.resend_activation_email, name=""resend_activation_email""),
url(r'^captcha/', include('captcha.urls')),
url(r'^attachauth', codewiki.views.attachauth),
# allows direct viewing of the django tables
url(r'^admin/', include(admin.site.urls)),
# favicon
(r'^favicon\.ico$', 'django.views.generic.simple.redirect_to', {'url': '/media/images/favicon.ico'}),
# RSS feeds
url(r'^feeds/(?P.*)/$', 'django.contrib.syndication.views.feed', {'feed_dict': feeds}, name='feeds'),
# API
(r'^api/', include('api.urls', namespace='foo', app_name='api')),
# Status
url(r'^status/$', codewiki.viewsuml.status, name='status'),
# Documentation
(r'^docs/', include('documentation.urls')),
# Robots.txt
(r'^robots.txt$', direct_to_template, {'template': 'robots.txt', 'mimetype': 'text/plain'}),
# pdf cropper technology
(r'^cropper/', include('cropper.urls')),
# froth
(r'^froth/', include('froth.urls')),
# static media server for the dev sites / local dev
url(r'^media/(?P.*)$', 'django.views.static.serve', {'document_root': settings.MEDIA_DIR, 'show_indexes':True}),
url(r'^media-admin/(?P.*)$', 'django.views.static.serve', {'document_root': settings.MEDIA_ADMIN_DIR, 'show_indexes':True}),
#Rest of the site
url(r'^', include('frontend.urls')),
# redirects from old version
(r'^editor/$', lambda request: HttpResponseRedirect('/scrapers/new/python?template=tutorial_python_trivial')),
(r'^scrapers/show/(?P[\w_\-]+)/(?:data/|map-only/)?$',
lambda request, short_name: HttpResponseRedirect(reverse('code_overview', args=['scraper', short_name]))),
)
",1
"ndle atlas `_.
""""""
import os.path as op
import plotly
from AFQ.api.group import GroupAFQ
import AFQ.data.fetch as afd
##########################################################################
# Get some example data
# ---------------------
#
# Retrieves `Stanford HARDI dataset `_.
#
afd.organize_stanford_data(clear_previous_afq=True)
##########################################################################
# Set tractography parameters (optional)
# ---------------------
# We make this tracking_params which we will pass to the AFQ object
# which specifies that we want 50,000 seeds randomly distributed
# in the white matter.
#
# We only do this to make this example faster and consume less space.
tracking_params = dict(n_seeds=50000,
random_seeds=True,
rng_seed=42)
##########################################################################
# Initialize an AFQ object:
# -------------------------
#
# We specify seg_algo as reco80 in segmentation_params. This tells the AFQ
# object to perform RecoBundles using the 80 bundles atlas in the
# segmentation step.
myafq = GroupAFQ(bids_path=op.join(afd.afq_home,
'stanford_hardi'),
preproc_pipeline='vistasoft',
segmentation_params={""seg_algo"": ""reco80""},
tracking_params=tracking_params)
##########################################################################
# Visualizing bundles and tract profiles:
# ---------------------------------------
# This would run the script and visualize the bundles using the plotly
# interactive visualization, which should automatically open in a
# new browser window.
bundle_html = myafq.all_bundles_figure
plotly.io.show(bundle_html[""01""])
",1
"ount = 0
endOfLine = len(userInput) - 1
for i in range(len(userInput)):
if (re.search('[\s*a-z\s*A-Z]+', userInput[i])):
charCount = charCount + 1
print operandCount, "" 1""
elif (re.search('[\s*0-9]+', userInput[i])):
numCount = numCount + 1
print operandCount, "" 2""
elif (re.search('[\*]', userInput[i])):
print 'TRUE'
# operandCount = operandCount + 1
# print operandCount, "" 3.5""
# elif (re.search('[\s*\+|\s*\-|\s*\/]+', userInput[i])):
elif (re.search('[+-/*]+', userInput[i])):
operandCount = operandCount + 1
print operandCount, "" 3""
# if(re.search('[\s*\+|\s*\-|\s*\/]+', userInput[endOfLine])):
if(re.search('[+-/*]+', userInput[endOfLine])):
print ""invalid expression""
print ""1""
exit(0)
else:
if((re.search('[\s*a-zA-Z]+', userInput[i - 1])) or (re.search('[\s*\d]+', userInput[i - 1]))):
continue
else:
print 'invalid expression'
print '2'
exit(0)
if(re.search('[\s*\d]+', userInput[i - 1])):
continue
else:
print 'invalid expression'
print '3'
exit(0)
if(re.search('[\s*a-zA-Z]+', userInput[i + 1])):
continue
elif(re.search('[\s*\d]+', userInput[i + 1])):
continue
elif (re.search('[\(]+', userInput[i + 1])):
continue
elif (re.search('[\)]+', userInput[i + 1])):
continue
else:
print 'invalid expression'
print '4'
exit(0)
elif (re.search('[\(]+', userInput[i])):
entryBracketCount = entryBracketCount + 1
print operandCount, "" 4""
elif (re.search('[\)]+', userInput[i])):
exitBracketCount = exitBracketCount + 1
print operandCount, "" 5""
if(re.search('[\)]+', userInput[endOfLine])):
continue
else:
if(re.search('[\(]+', userInput[i + 1])):
print 'invalid expression'
print '5'
exit(0)
print operandCount, "" 6""
if (entryBracketCount != exitBracketCount):
print ""invalid expression""
print '6'
exit(0)
elif operandCount == 0:
print operandCount
print ""invalid expression""
print '7'
exit(0)
elif ((numCount == 0) and (charCount == 0)):
print ""invalid expression""
print '8'
exit(0)
else:
print ""valid expression""
",1
"C) 2008 Imran M Yousuf (imran@smartitengineering.com)
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# 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, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
import poplib, email, re, sys, xmlConfigs, utils;
class ReferenceNode :
def __init__(self, node, emailMessage, references=list(), children=dict(), slotted=bool(""false"")):
self.node = node
self.children = dict(children)
self.references = references[:]
self.slotted = slotted
self.emailMessage = emailMessage
def get_node(self):
return self.node
def get_children(self):
return self.children
def set_node(self, node):
self.node = node
def set_children(self, children):
self.children = children
def get_references(self):
return self.references
def is_slotted(self):
return self.slotted
def set_slotted(self, slotted):
self.slotted = slotted
def get_message(self):
return self.emailMessage
def __repr__(self):
return self.node + ""\nREF: "" + str(self.references) + ""\nChildren: "" + str(self.children.keys()) + ""\n""
def handleNode(currentNodeInAction, referenceNodeNow, referencesToCheck, patchMessageReferenceNode):
for reference in referencesToCheck[:] :
if reference in referenceNodeNow.get_children() :
referencesToCheck.remove(reference)
return patchMessageReferenceNode[reference]
if len(referencesToCheck) == 0 :
referenceNodeNow.get_children()[currentNodeInAction.get_node()] = currentNodeInAction
def makeChildren(patchMessageReferenceNode) :
ref_keys = patchMessageReferenceNode.keys()
ref_keys.sort()
for messageId in ref_keys:
referenceNode = patchMessageReferenceNode[messageId]
utils.verboseOutput(verbose, ""Managing Message Id:"", referenceNode.get_node())
referenceIds = referenceNode.get_references()
referenceIdsClone = referenceIds[:]
utils.verboseOutput(verbose, ""Cloned References: "", referenceIdsClone)
if len(referenceIds) > 0 :
nextNode = patchMessageReferenceNode[referenceIdsClone[0]]
referenceIdsClone.remove(referenceIdsClone[0])
while nextNode != None :
utils.verboseOutput(verbose, ""Next Node: "", nextNode.get_node())
utils.verboseOutput(verbose, ""Curent Node: "", referenceNode.get_node())
utils.verboseOutput(verbose, ""REF: "", referenceIdsClone)
nextNode = handleNode(referenceNode, nextNode, referenceIdsClone, patchMessageReferenceNode)
if __name__ == ""__main__"":
arguments = sys.argv
verbose = ""false""
pseudoArgs = arguments[:]
while len(pseudoArgs) > 1 :
argument = pseudoArgs[1]
if argument == ""-v"" or argument == ""--verbose"" :
verbose = ""true""
pseudoArgs.remove(argument)
utils.verboseOutput(verbose, ""Checking POP3 for gmail"")
try:
emailConfig = xmlConfigs.initializePopConfig(""./email-configuration.xml"")
myPop = emailConfig.get_pop3_connection()
numMessages = len(myPop.list()[1])
patchMessages = dict()
for i in range(numMessages):
utils.verboseOutput(verbose, ""Index: "", i)
totalContent = """"
for content in myPop.retr(i+1)[1]:
totalContent += content + '\n'
msg = email.message_from_string(totalContent)
if 'subject' in msg :
subject = msg['subject']
subjectPattern = ""^\[.*PATCH.*\].+""
subjectMatch = re.match(subjectPattern, subject)
utils.verboseOutput(verbose, ""Checking subject: "", subject)
if subjectMatch == None :
continue
else :
continue
messageId = """"
if 'message-id' in msg:
messageId = re.search(""<(.*)>"", msg['message-id']).group(1)
utils.verboseOutput(verbose, 'Message-ID:', messageId)
referenceIds = []
if 'references' in msg:
references = msg['references']
referenceIds = re.findall(""<(.*)>"", references)
utils.verboseOutput(verbose, ""References: "", referenceIds)
currentNode = ReferenceNode(messageId, msg, referenceIds)
patchMessages[messageId] = currentNode
currentNode.set_slotted(bool(""false""))
utils.verboseOutput(verbose, ""**************Make Children**************"")
makeChildren(patchMessages)
utils.verboseOutput(verbose, ""--------------RESULT--------------"")
utils.verboseOutput(verbose, patchMessages)
except:
utils.verboseOutput(verbose, ""Error: "", sys.exc_info())
",1
"import odict, py3
@pytest.fixture
def empty_ops(request):
return Filter()
@pytest.fixture
def single_ops(request):
return Filter({'roll': 27})
def test_ops_iteration(single_ops):
assert list(iter(single_ops)) == ['roll']
class TestOpsMapping(object):
def test_getitem(self, empty_ops, single_ops):
with pytest.raises(KeyError):
empty_ops['roll']
assert single_ops['roll'] == 27
def test_setitem(self, empty_ops):
assert repr(empty_ops) == ""Filter([])""
empty_ops['meaning'] = 42
if py3:
assert repr(empty_ops) == ""Filter([('meaning', 42)])""
else:
assert repr(empty_ops) == ""Filter([(u'meaning', 42)])""
def test_delitem(self, empty_ops, single_ops):
with pytest.raises(KeyError):
del empty_ops['roll']
if py3:
assert repr(single_ops) == ""Filter([('roll', 27)])""
else:
assert repr(single_ops) == ""Filter([(u'roll', 27)])""
del single_ops['roll']
assert repr(single_ops) == ""Filter([])""
def test_length(self, empty_ops, single_ops):
assert len(empty_ops) == 0
assert len(single_ops) == 1
def test_keys(self, empty_ops, single_ops):
assert list(empty_ops.keys()) == []
assert list(single_ops.keys()) == ['roll']
def test_items(self, empty_ops, single_ops):
assert list(empty_ops.items()) == []
assert list(single_ops.items()) == [('roll', 27)]
def test_values(self, empty_ops, single_ops):
assert list(empty_ops.values()) == []
assert list(single_ops.values()) == [27]
def test_contains(self, single_ops):
assert 'foo' not in single_ops
assert 'roll' in single_ops
def test_equality_inequality(self, empty_ops, single_ops):
assert empty_ops == {}
assert empty_ops != {'roll': 27}
assert single_ops != {}
assert single_ops == {'roll': 27}
def test_get(self, single_ops):
assert single_ops.get('foo') is None
assert single_ops.get('foo', 42) == 42
assert single_ops.get('roll') == 27
def test_clear(self, single_ops):
assert len(single_ops.operations) == 1
single_ops.clear()
assert len(single_ops.operations) == 0
def test_pop(self, single_ops):
assert len(single_ops.operations) == 1
with pytest.raises(KeyError):
single_ops.pop('foo')
assert single_ops.pop('foo', 42) == 42
assert len(single_ops.operations) == 1
assert single_ops.pop('roll') == 27
assert len(single_ops.operations) == 0
def test_popitem(self, single_ops):
assert len(single_ops.operations) == 1
assert single_ops.popitem() == ('roll', 27)
assert len(single_ops.operations) == 0
with pytest.raises(KeyError):
single_ops.popitem()
def test_update(self, empty_ops, single_ops):
assert len(empty_ops.operations) == 0
empty_ops.update(name=""Bob Dole"")
assert len(empty_ops.operations) == 1
if py3:
assert repr(empty_ops) == ""Filter([('name', 'Bob Dole')])""
else:
assert repr(empty_ops) == ""Filter([('name', u'Bob Dole')])""
assert len(single_ops.operations) == 1
if py3:
assert repr(single_ops) == ""Filter([('roll', 27)])""
else:
assert repr(single_ops) == ""Filter([(u'roll', 27)])""
single_ops.update([('name', ""Bob Dole"")])
assert len(single_ops.operations) == 2
if py3:
assert repr(single_ops) in (""Filter([('roll', 27), ('name', 'Bob Dole')])"", ""Filter([('name', 'Bob Dole'), ('roll', 27)])"")
else:
assert repr(single_ops) in (""Filter([(u'roll', 27), (u'name', u'Bob Dole')])"", ""Filter([(u'name', u'Bob Dole'), (u'roll', 27)])"")
def test_setdefault(self, empty_ops):
assert len(empty_ops.operations) == 0
empty_ops.setdefault('fnord', 42)
assert len(empty_ops.operations) == 1
assert empty_ops.operations['fnord'] == 42
empty_ops.setdefault('fnord', 27)
assert len(empty_ops.operations) == 1
assert empty_ops.operations['fnord'] == 42
def test_ops_shallow_copy(self, single_ops):
assert single_ops.operations == single_ops.copy().operations
class TestOperationsCombination(object):
def test_operations_and_clean_merge(self):
comb = Filter({'roll': 27}) & Filter({'foo': 42})
assert comb.as_query == {'roll': 27, 'foo': 42}
def test_operations_and_operator_overlap(self):
comb = Filter({'roll': {'$gte': 27}}) & Filter({'roll': {'$lte': 42}})
assert comb.as_query == {'roll': {'$gte': 27, '$lte': 42}}
def test_paradoxical_condition(self):
comb = Filter({'roll': 27}) & Filter({'roll': {'$lte': 42}})
assert comb.as_query == {'roll': {'$eq': 27, '$lte': 42}}
comb = Filter({'roll': {'$gte': 27}}) & Filter({'roll': 42})
assert list(comb.as_query['roll'].items()) in ([('$gte', 27), ('$eq', 42)], [('$eq', 42), ('$gte', 27)])
def test_operations_or_clean_merge(self):
comb = Filter({'roll': 27}) | Filter({'foo': 42})
assert comb.as_query == {'$or': [{'roll': 27}, {'foo': 42}]}
comb = comb | Filter({'bar': 'baz'})
assert comb.as_query == {'$or': [{'roll': 27}, {'foo': 42}, {'bar': 'baz'}]}
def test_operations_hard_and(self):
comb = Filter({'$and': [{'a': 1}, {'b': 2}]}) & Filter({'$and': [{'c': 3}]})
assert comb.as_query == {'$and': [{'a': 1}, {'b': 2}, {'c': 3}]}
def test_operations_soft_and(self):
comb = Filter({'$and': [{'a': 1}, {'b': 2}]}) & Filter({'c': 3})
assert comb.as_query == {'$and': [{'a': 1}, {'b': 2}], 'c': 3}
",1
"rf_exempt
import django.shortcuts
from wlokalu.api import presence
#-----------------------------------------------------------------------------
from wlokalu.logging import getLogger, message as log
logger = getLogger(__name__)
#-----------------------------------------------------------------------------
@csrf_exempt
def list(request, nick = None):
template = loader.get_template(""list.html"")
from django.core.urlresolvers import reverse
from forms import PresenceForm
form = PresenceForm()
if nick is not None:
form.initial['nick'] = nick
form_target = reverse(list, kwargs = {'nick': nick})
else:
form_target = reverse(list)
if request.POST.get('nick', '') != '':
context = {
'address': request.META['REMOTE_ADDR'],
'uri': request.META['REQUEST_URI'],
}
if 'enter' in request.POST:
presence.person_entered(request.POST['nick'], context)
else: # 'leave' in request.POST
presence.person_left(request.POST['nick'], context)
# tell the browser to reload the page, but with GET request
return django.shortcuts.redirect(request.path)
context = RequestContext(request, {
'form_target': form_target,
'form': form,
'present': presence.list_people(),
'sensors': presence.list_simple_sensors(),
'complex_sensors': presence.list_complex_sensors(),
})
return HttpResponse(template.render(context))
#-----------------------------------------------------------------------------
# vim:ft=python:foldmethod=marker
",1
"ining 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.
""""""
TODO...
""""""
__all__ = ['GreedyPlayer']
import random
from jdhp.tictactoe.player.abstract import Player
class GreedyPlayer(Player):
""""""
TODO...
""""""
def play(self, game, state):
""""""
TODO...
""""""
action_list = game.getSetOfValidActions(state)
choosen_action = None
# Choose actions that lead to immediate victory...
for action in action_list:
next_state = game.nextState(state, action, self)
if game.hasWon(self, next_state):
choosen_action = action
break
# ... otherwise choose randomly
if choosen_action is None:
#print(""randomly choose action"") # debug
choosen_action = random.choice(action_list)
return choosen_action
",1
" def __init__(self):
Base.__init__(self)
def fondo(self):
pilas.fondos.Fondo(""data/img/fondos/aplicacion.jpg"")
def general(self):
self.sonido_boton.reproducir()
pilas.almacenar_escena(General())
def individual(self):
self.sonido_boton.reproducir()
pilas.almacenar_escena(Individual())
def volver(self):
self.sonido_boton.reproducir()
pilas.recuperar_escena()
def iniciar(self):
self.fondo()
self.sonido_boton = pilas.sonidos.cargar(""data/audio/boton.ogg"")
self.interfaz()
self.mostrar()
def interfaz(self):
opcion= [(""General"",self.general),(""Individual"",self.individual),(""Volver"",self.volver)]
menu = pilas.actores.Menu(opcion, y=50, fuente=""data/fonts/American Captain.ttf"")
menu.escala = 1.3
enunciado = pilas.actores.Actor(""data/img/enunciados/estadisticas.png"",y=250)
enunciado.escala = 0.3",1
"h 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.
""""""Libraries of Keras metrics.""""""
import tensorflow as tf
def _apply_mask(y_true, sample_weight, masked_tokens, dtype):
if sample_weight is None:
sample_weight = tf.ones_like(y_true, dtype)
else:
sample_weight = tf.cast(sample_weight, dtype)
for token in masked_tokens:
mask = tf.cast(tf.not_equal(y_true, token), dtype)
sample_weight = sample_weight * mask
return sample_weight
class NumTokensCounter(tf.keras.metrics.Sum):
""""""A `tf.keras.metrics.Metric` that counts tokens seen after masking.""""""
def __init__(self, masked_tokens=None, name='num_tokens', dtype=tf.int64):
self._masked_tokens = masked_tokens or []
super().__init__(name, dtype)
def update_state(self, y_true, y_pred, sample_weight=None):
sample_weight = _apply_mask(y_true, sample_weight, self._masked_tokens,
self._dtype)
sample_weight = tf.reshape(sample_weight, [-1])
super().update_state(sample_weight)
def get_config(self):
config = super().get_config()
config['masked_tokens'] = tuple(self._masked_tokens)
return config
class MaskedCategoricalAccuracy(tf.keras.metrics.SparseCategoricalAccuracy):
""""""An accuracy metric that masks some tokens.""""""
def __init__(self, masked_tokens=None, name='accuracy', dtype=None):
self._masked_tokens = masked_tokens or []
super().__init__(name, dtype=dtype)
def update_state(self, y_true, y_pred, sample_weight=None):
sample_weight = _apply_mask(y_true, sample_weight, self._masked_tokens,
self._dtype)
num_classes = tf.shape(y_pred)[-1]
y_true = tf.reshape(y_true, [-1])
y_pred = tf.reshape(y_pred, [-1, num_classes])
sample_weight = tf.reshape(sample_weight, [-1])
super().update_state(y_true, y_pred, sample_weight)
def get_config(self):
config = super().get_config()
config['masked_tokens'] = tuple(self._masked_tokens)
return config
",1
": Import / Create / Update / Delete preference
#
from django.conf import settings
from django.contrib.auth import get_user_model
from django.core.management.base import BaseCommand, CommandError
from django.db import transaction
from django.db.models import Q
from pathlib import Path
from webframe.functions import TRUE_VALUES, LogMessage as lm, getTime
from webframe.models import Preference, AbstractPreference
from uuid import UUID
import logging, os, glob, sys, re
logger=logging.getLogger('webframe.commands.prefs')
class Command(BaseCommand):
help = '''Mainpulate the preference in database. Including insert/update/delete/view/import/gensecret/gendoc; Importing support csv|xlsx file.'''
def __getIndent__(self, indent=0, ch=' '):
return ch*indent
def create_parser(self, cmdName, subcommand, **kwargs):
parser=super().create_parser(cmdName, subcommand, **kwargs)
parser.epilog='''Example:\r\n
\tpref import path_to_prefs #Import a folder or a csv/xlsx file\r\n
\tpref set ABC --value=""def"" #Set the preference ""ABC"" to value ""def""\r\n
\tpref gensecret #Generate the encryption secret; PLEASE backup in secure way.\r\n
\tpref gendoc prefsDoc.html #Generate the documentation and save as as output.html
'''
return parser
def add_arguments(self, parser):
#Default Value
pattern='Pref({pref.id}:{pref.name}): {pref.value}'
action='show'
max=256
wildcard='*'
tmpl='webframe/prefsDoc.html'
#Adding arguments
parser.add_argument('action', type=str, help='The action to be taken. One of import/export/show/set/delete/gensecret/gendoc; Default is {0}'.format(action), default=action)
parser.add_argument('name', type=str, nargs='?', help='[import/export/show/set/delete/gendoc]; The name of the preference or path of importing/exporting file (csv|xlsx);')
parser.add_argument('--file', dest='file', type=str, help='[import/export/gendoc]; The file path for import/export/output.')
parser.add_argument('--value', dest='value', type=str, help='[set/delete]; The value of the preference;', default=None)
parser.add_argument('--owner', dest='owner', type=str, help='[set/delete]; The owner of the preference; Optional;', default=None)
parser.add_argument('--noowner', dest='noowner', action='store_true', help='[show/set/delete]; The target preference has no owner; Optional; Default False')
parser.add_argument('--parent', dest='parent', type=str, help='[show/set/delete]; The parent\'s name of the preference. Optional;', default=None)
parser.add_argument('--noparent', dest='noparent', action='store_true', help='[show/set/delete]; The target preference has no parent; Optional; Default False')
parser.add_argument('--pattern', dest='pattern', type=str, help='[show]; The output pattern. {0}'.format(pattern), default=pattern)
parser.add_argument('--max', dest='max', type=int, help='[show]; The maximum number of preference to show. Default is {0}'.format(max), default=max)
parser.add_argument('--wildcard', dest='wildcard', type=str, help='[show]; Specify the wildcard; Default is {0}'.format(wildcard), default=wildcard)
#Importing
parser.add_argument('--sep', dest='separator', type=str, default=',', help='[import]; The separator when CSV importing; Default \"",\""')
parser.add_argument('--encoding', dest='encoding', type=str, default='utf-8', help='[import]; The encoding when CSV importing; Default \""utf-8\""')
parser.add_argument('--quotechar', dest='quotechar', type=str, default='\""', help='[import]; The quote-char when CSV importing; Default double quote: \""')
parser.add_argument('--filepath', dest='filepath', action='store_true', help='[import]; Import the file-path in preferences; Default False')
parser.add_argument('--force', '-f ', dest='force', action='store_true', help='[import]; Force the import', default=False)
#Generate Doc
parser.add_argument('--tmpl', dest='tmpl', type=str, help=""[gendoc]; The template name when generating document; Default: {0}"".format(tmpl), default=tmpl)
def __get_owner__(self, owner=None):
if not owner: return None
logger.debug('Getting owner by: ""%s""', owner)
owner=owner if owner else self.kwargs['owner']
return get_user_model().objects.get(username=owner) if owner else None
def __get_parent__(self, parent=None):
parent=parent if parent else self.kwargs['parent']
if parent:
try:
#Get parent by uuid
return Preference.objects.get(id=parent)
except:
try:
#Get parent by name
return Preference.objects.get(name=parent)
except:
pass
return None
def __get_pref__(self, **kwargs):
owner=kwargs['owner'] if 'owner' in kwargs else self.__get_owner__()
parent=kwargs['parent'] if 'parent' in kwargs else self.__get_parent__()
name=kwargs['name'] if 'name' in kwargs else self.kwargs['name']
lang=kwargs['lang'] if 'lang' in kwargs else None
if self.kwargs['filepath']: name=os.path.basename(name)
if self.kwargs['parent'] and parent==None:
raise Preference.DoesNotExist('Parent Preference not found: {0}'.format(self.kwargs['parent']))
rst=Preference.objects.all()
if name and name!='*':
rst=rst.filter(name=name)
if owner:
rst=rst.filter(owner=owner)
elif self.kwargs['noowner']:
rst=rst.filter(owner__isnull=True)
if parent:
rst=rst.filter(parent=parent)
elif self.kwargs['noparent']:
rst=rst.filter(parent__isnull=True)
if self.kwargs['filepath']:
rst=rst.filter(tipe=AbstractPreference.TYPE_FILEPATH)
rst=rst.order_by('owner', 'parent', 'sequence', 'name')
return rst
def __get_name__( self, name ):
'''
Get the name and sequence according to the name.
@param name The string including the sequence and name. For example, '01.Target' will return a tuple (1, 'Target')
@return A tuple including the sequence and the name
'''
p=re.search(r'^\d+\.', name)
if p:
s=p.group(0)
return name[len(s):].strip(), int(name[0:len(s)-1])
return (name, sys.maxsize if hasattr(sys, 'maxsize') else sys.maxint) #Default append
def output( self, pref, pattern=None ):
pattern=pattern if pattern else self.kwargs['pattern']
print(pattern.format(pref=pref))
pattern=' {0}'.format(pattern)
for ch in pref.childs:
self.output(ch, pattern)
def handle(self, *args, **kwargs):
verbosity=int(kwargs['verbosity'])
if verbosity==3:
logger.setLevel(logging.DEBUG)
elif verbosity==2:
logger.setLevel(logging.INFO)
elif verbosity==1:
logger.setLevel(logging.WARNING)
else:
logger.setLevel(logging.ERROR)
self.kwargs=kwargs
action=kwargs['action']
if action=='import':
self.imp()
elif action=='create': #for backward compatibility
self.set()
elif action=='update': #for backward compatibility
self.set()
elif action=='set':
self.set()
elif action=='delete':
self.delete()
elif action=='show':
self.show()
elif action=='gensecret':
self.gensecret()
elif action=='gendoc':
self.gendoc()
elif action=='export':
self.expCsv()
else:
logger.warning('Unknown action: {0}'.format(action))
logger.warn('DONE!')
def show(self):
logger.info('Showing the preference ...')
q=Preference.objects.all()
if self.kwargs['name']:
logger.info(' with the name filter: {0}'.format(self.kwargs['name']))
if self.kwargs['wildcard'] in self.kwargs['name']:
q=q.filter(name__icontains=self.kwargs['name'].replace(self.kwargs['wildcard'], ''))
else:
q=q.filter(name=self.kwargs['name'])
if self.kwargs['value']:
logger.info(' with the value filter: {0}'.format(self.kwargs['value']))
q=q.filter(value__icontains=self.kwargs['value'])
if self.kwargs['owner']:
logger.info(' which belongs to user: {0}'.format(self.kwargs['owner']))
q=q.filter(owner__username=self.kwargs['owner'])
if self.kwargs['parent']:
logger.info(' which belongs to preference: {0}'.format(self.kwargs['parent']))
q=q.filter(parent__name__iexact=self.kwargs['parent'])
else:
q=q.filter(parent__isnull=True)
for p in q:
self.output(p)
logger.warning('There have {0} preference(s) has been shown'.format(len(q)))
def set(self):
with transaction.atomic():
try:
pref=self.__get_pref__()
if pref.count()<1: raise Preference.DoesNotExist
cnt=pref.update(value=self.kwargs['value'])
logger.info('{0} of Preference(s) has been updated'.format(cnt))
except Preference.DoesNotExist:
p=Preference(name=self.kwargs['name'], value=self.kwargs['value'], owner=owner, parent=parent)
p.save()
logger.info('The preference<{0}> has been created with value: {1}'.format(p.name, p.value))
def delete(self):
pref=self.__get_pref__()
cnt=pref.count()
pref.delete()
logger.warning('{0} of Preference(s) has been deleted'.format(cnt))
def expRow( self, wr, pref, indent=0 ):
'''
Import the specified preference to csv.
'''
cnt=0
tab=self.__getIndent__(indent)
logger.debug(lm('{0}Exporting preference: {1}::{2}...', tab, pref.id, pref.name))
wr.writerow([
pref.name # [0]
, pref.realValue # [1]
, pref.parent.id if pref.parent else '' # [2]
, pref.owner.username if pref.owner else '' # [3]
, pref.helptext # [4]
, Preference.TYPES[pref.tipe][1] # [5]
, pref.encrypted # [6]
, pref.regex # [7]
])
cnt+=1
for p in pref.childs:
cnt+=self.expRow(wr, p, indent+3)
return cnt
def expCsv( self ):
'''
Import the specified list of preferences to csv.
'''
import csv
f=self.kwargs['file']
with open(f, 'w', encoding=self.kwargs['encoding']) as fp:
wr=csv.writer(fp, delimiter=self.kwargs['separator'], quotechar=self.kwargs['quotechar'], quoting=csv.QUOTE_MINIMAL, skipinitialspace=True)
cnt=0
for p in self.__get_pref__():
cnt+=self.expRow(wr, p, 0)
logger.info(lm('Exported {0} records', cnt))
def improw( self, cols, idx=0 ):
try:
name=cols[0]
val=cols[1]
parent=self.__get_parent__(cols[2])
owner=self.__get_owner__(cols[3])
helptext=cols[4]
tipe=cols[5]
encrypted=cols[6] in TRUE_VALUES
regex=cols[7]
lang=cols[8] if len(cols)>8 else None
logger.debug(' Importing row: {0}: {1} [{2}]'.format(idx, name, 'encrypted' if encrypted else 'clear-text'))
self.kwargs['name']=name
pref=self.__get_pref__(name=name, owner=owner, parent=parent, lang=lang)
if pref.count()<1: raise Preference.DoesNotExist
for p in pref:
p.encrypted=encrypted
p.helptext=helptext
p.tipe=tipe
p.regex=regex
#The value must be the last steps to set due to validation. Otherwise, once importing/assign a new value into this field, the last validation rule may be applied incorrectly
p.value=val
p.save()
except Preference.DoesNotExist:
Preference(name=name, _value=val, owner=owner, parent=parent, encrypted=encrypted, helptext=helptext, regex=regex, lang=lang).save()
except:
logger.debug(cols)
logger.exception('Error when handling the column')
raise
def impXlsx( self, f ):
'''
Import xlsx file.
'''
from openpyxl import load_workbook
wb=load_workbook(filename=f)
ws=wb.active
logger.info(' Importing worksheet: {0}!{1}'.format(f, ws.title))
cnt=0
with transaction.atomic():
for r in range(1, ws.max_row+1):
cols=list()
name=ws.cell(row=r, column=1).value
if isinstance(name, str): name=name.strip()
if not name: continue #Skip the row when it has no pref.name
if r==1 and (name.upper()=='ID' or name.upper()=='NAME' or name.upper()=='ID/Name'): continue #Skip the first row if header row
cols.append(name) #Name/ID
cols.append(ws.cell(row=r, column=2).value) #Value
cols.append(ws.cell(row=r, column=3).value) #Parent
cols.append(ws.cell(row=r, column=4).value) #Owner
cols.append(ws.cell(row=r, column=5).value) #Reserved
cols.append(ws.cell(row=r, column=6).value) #Tipe
cols.append(ws.cell(row=r, column=7).value) #encrypted
self.improw( cols, r )
cnt+=1
logger.info(' Imported {0} row(s)'.format(cnt))
def impCsv( self, f ):
'''
Import the csv file.
'''
import csv
with transaction.atomic():
logger.info(' Importing csv: {0}'.format(f))
cnt=0
with open(f, 'r', encoding=self.kwargs['encoding']) as fp:
if self.kwargs['quotechar']:
rows=csv.reader(fp, delimiter=self.kwargs['separator'], quotechar=self.kwargs['quotechar'], quoting=csv.QUOTE_MINIMAL, skipinitialspace=True)
else:
rows=csv.reader(fp, delimiter=self.kwargs['separator'], quoting=csv.QUOTE_NONE, skipinitialspace=True)
for row in rows:
if len(row)<1: continue #Skip the empty row
name=row[0].strip()
if not name: continue #Skip the row when it has no name
if cnt==0 and (name.upper()=='ID' or name.upper()=='NAME' or name.upper()=='ID/NAME'): continue #Skip the first row if header row
self.improw( row, cnt )
cnt+=1
logger.info(' Imported {0} row(s)'.format(cnt))
def impdir( self, d ):
if os.path.isdir(d):
logger.info('Importing directory: {0}'.format(d))
else:
logger.warning('This is not the directory: {0}'.format(d))
return
cnt=0
with transaction.atomic():
p=Preference.objects.pref('IMPORTED_PREFERENCES', returnValue=False)
p.helptext='Sysetm use only! DO NOT MODIFY youself unless you understand the risk.
'
p.save()
for f in os.listdir(d):
if not (f.upper().endswith('.XLSX') or f.upper().endswith('.CSV')): continue #only support *.xlsx and *.csv
f=os.path.join(d, f)
try:
Preference.objects.get(name=f, parent=p)
if self.kwargs['force']: raise Preference.DoesNotExist
except Preference.DoesNotExist:
self.impfile( f )
cnt+=1
Preference(name=f, parent=p).save()
logger.debug('Imported {0} file(s)'.format(cnt))
def impfile( self, f ):
if not (os.path.isfile(f) and os.access(f, os.R_OK)):
logger.warning('The file is not readable: {0}'.format(f))
return
fn=f.lower()
if fn.endswith('.xlsx'):
self.impXlsx(f)
elif fn.endswith('.csv'):
self.impCsv(f)
else:
logger.info('Unsupported file: {0}'.format(f))
def imppath( self, p, parent=None):
name, seq=self.__get_name__(os.path.basename(p))
if os.path.isdir(p):
try:
pref=self.__get_pref__(name=name)
if pref.count()<1: raise Preference.DoesNotExist
pref=pref[0]
except Preference.DoesNotExist:
pref=Preference(name=name, parent=parent)
pref.tipe=AbstractPreference.TYPE_FILEPATH
pref.sequence=seq
pref.save()
for f in os.listdir(p):
path=os.path.join(p, f)
self.imppath(path, pref)
#Handling the ordering after import all the childs
ord=1
for c in pref.childs:
c.sequence=ord
c.save()
ord+=1
else:
try:
pref=self.__get_pref__(name=name)
if pref.count()<1: raise Preference.DoesNotExist
pref=pref[0]
except Preference.DoesNotExist:
pref=Preference(name=name, parent=parent)
pref.pathValue=p if os.path.isabs(p) else os.path.abspath(p)
pref.tipe=AbstractPreference.TYPE_FILEPATH
pref.sequence=seq
pref.save()
def imp(self):
disableOrder=getattr(settings, 'DISABLE_REORDER', False)
setattr(settings, 'DISABLE_REORDER', True) #Disable the re-ordering features during importing
try:
f=self.kwargs['file']
if self.kwargs['filepath']:
self.imppath(f)
elif os.path.isdir(f):
self.impdir(f)
elif os.path.isfile(f):
self.impfile(f)
finally:
setattr(settings, 'DISABLE_REORDER', disableOrder) #Resume the re-ordering features after importing
def gensecret(self):
from webframe.models import AbstractPreference
key=AbstractPreference.__getSecret__()
logger.warning(lm('Your secret is: {0}', key))
def gendoc(self):
from django.shortcuts import render
from django.template import loader, Template, Context
from webframe.providers import template_injection, fmt_injection
tmpl=getattr(self.kwargs, 'tmpl', 'webframe/prefDoc.html')
logger.warning(lm('Generating the documents according template: {0}', tmpl))
tmpl=loader.get_template(tmpl)
params=dict()
params.update(template_injection(None))
params.update(fmt_injection(None))
#params['target']=Preference.objects.filter(parent__isnull=True)
params['target']=self.__get_pref__()
params['TYPES']=Preference.TYPES
params['now']=getTime('now')
txt=tmpl.render(params)
output=self.kwargs.get('file')
if not output: output='prefsDoc.html'
logger.warning(lm('Generated! Outputing into: {0}', output))
with open(output, 'w') as f:
f.write(txt)
",1
"file__)
lFile, eError =vhdlFile.utils.read_vhdlfile(os.path.join(sTestDir,'rule_300_test_input.vhd'))
dIndentMap = utils.read_indent_file()
lExpected = []
lExpected.append('')
utils.read_file(os.path.join(sTestDir, 'rule_300_test_input.fixed.vhd'), lExpected)
class test_iteration_scheme_rule(unittest.TestCase):
def setUp(self):
self.oFile = vhdlFile.vhdlFile(lFile)
self.assertIsNone(eError)
self.oFile.set_indent_map(dIndentMap)
def test_rule_300(self):
oRule = iteration_scheme.rule_300()
self.assertTrue(oRule)
self.assertEqual(oRule.name, 'iteration_scheme')
self.assertEqual(oRule.identifier, '300')
lExpected = [13, 17]
oRule.analyze(self.oFile)
self.assertEqual(lExpected, utils.extract_violation_lines_from_violation_object(oRule.violations))
def test_fix_rule_300(self):
oRule = iteration_scheme.rule_300()
oRule.fix(self.oFile)
lActual = self.oFile.get_lines()
self.assertEqual(lExpected, lActual)
oRule.analyze(self.oFile)
self.assertEqual(oRule.violations, [])
",1
"lified BSD""
import sys
from recursely._compat import IS_PY3
from recursely.importer import RecursiveImporter
from recursely.utils import SentinelList
__all__ = ['install']
def install(retroactive=True):
""""""Install the recursive import hook in ``sys.meta_path``,
enabling the use of ``__recursive__`` directive.
:param retroactive: Whether the hook should be retroactively applied
to module's that have been imported before
it was installed.
""""""
if RecursiveImporter.is_installed():
return
importer = RecursiveImporter()
# because the hook is a catch-all one, we ensure that it's always
# at the very end of ``sys.meta_path``, so that it's tried only if
# no other (more specific) hook has been chosen by Python
if IS_PY3:
for i in reversed(range(len(sys.meta_path))):
ih_module = getattr(sys.meta_path[i], '__module__', '')
is_builtin = ih_module == '_frozen_importlib'
if not is_builtin:
break
sys.meta_path = SentinelList(
sys.meta_path[:i],
sentinels=[importer] + sys.meta_path[i:])
else:
sys.meta_path = SentinelList(sys.meta_path, sentinel=importer)
# look through already imported packages and recursively import
# their submodules, if they contain the ``__recursive__`` directive
if retroactive:
for module in list(sys.modules.values()):
importer.recurse(module)
",1
"""""""
Filter query list from treatment database table
""""""
class Meta:
model = Treatment
fields = {'id': ['exact', 'in'],
'no_replicate': ['exact', 'in', 'gte', 'lte'],
'nitrogen_treatment': ['iexact', 'in', 'icontains'],
'phosphate_treatment': ['iexact', 'in', 'icontains'],
'tillage_practice': ['iexact', 'in', 'icontains'],
'cropping_system': ['iexact', 'in', 'icontains'],
'crops_grown': ['iexact', 'in', 'icontains'],
'farm_yard_manure': ['iexact', 'in', 'icontains'],
'farm_residue': ['iexact', 'in', 'icontains'],
}
order_by = ['tillage_practice', 'cropping_system', 'crops_grown']
",1
"rved.
#
# 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 pyglet 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.
# ----------------------------------------------------------------------------
# Based on pygxinput originally by Andrew D. Straw
# http://code.astraw.com/projects/motmot/wiki/pygxinput
import ctypes
import pyglet
from pyglet.window.xlib import xlib
import lib_xinput as xi
class XInputDevice:
def __init__(self, display, device_info):
self._x_display = display._display
self._device_id = device_info.id
self.name = device_info.name
self._open_device = None
# TODO: retrieve inputclassinfo from device_info and expose / save
# for valuator axes etc.
def open(self):
if self._open_device:
return
self._open_device = xi.XOpenDevice(self._x_display, self._device_id)
if not self._open_device:
raise Exception('Cannot open device')
def close(self):
if not self._open_device:
return
xi.XCloseDevice(self._x_display, self._open_device)
def attach(self, window):
assert window._x_display == self._x_display
return XInputDeviceInstance(self, window)
class XInputDeviceInstance(pyglet.event.EventDispatcher):
def __init__(self, device, window):
""""""Create an opened instance of a device on the given window.
:Parameters:
`device` : XInputDevice
Device to open
`window` : Window
Window to open device on
""""""
assert device._x_display == window._x_display
assert device._open_device
self.device = device
self.window = window
self._events = list()
try:
dispatcher = window.__xinput_window_event_dispatcher
except AttributeError:
dispatcher = window.__xinput_window_event_dispatcher = \
XInputWindowEventDispatcher()
dispatcher.add_instance(self)
device = device._open_device.contents
if not device.num_classes:
return
# Bind matching extended window events to bound instance methods
# on this object.
#
# This is inspired by test.c of xinput package by Frederic
# Lepied available at x.org.
#
# In C, this stuff is normally handled by the macro DeviceKeyPress and
# friends. Since we don't have access to those macros here, we do it
# this way.
for i in range(device.num_classes):
class_info = device.classes[i]
if class_info.input_class == xi.KeyClass:
self._add(class_info, xi._deviceKeyPress,
dispatcher._event_xinput_key_press)
self._add(class_info, xi._deviceKeyRelease,
dispatcher._event_xinput_key_release)
elif class_info.input_class == xi.ButtonClass:
self._add(class_info, xi._deviceButtonPress,
dispatcher._event_xinput_button_press)
self._add(class_info, xi._deviceButtonRelease,
dispatcher._event_xinput_button_release)
elif class_info.input_class == xi.ValuatorClass:
self._add(class_info, xi._deviceMotionNotify,
dispatcher._event_xinput_motion)
elif class_info.input_class == xi.ProximityClass:
self._add(class_info, xi._proximityIn,
dispatcher._event_xinput_proximity_in)
self._add(class_info, xi._proximityOut,
dispatcher._event_xinput_proximity_out)
elif class_info.input_class == xi.FeedbackClass:
pass
elif class_info.input_class == xi.FocusClass:
pass
elif class_info.input_class == xi.OtherClass:
pass
array = (xi.XEventClass * len(self._events))(*self._events)
xi.XSelectExtensionEvent(window._x_display,
window._window,
array,
len(array))
def _add(self, class_info, event, handler):
_type = class_info.event_type_base + event
_class = self.device._device_id << 8 | _type
self._events.append(_class)
self.window._event_handlers[_type] = handler
XInputDeviceInstance.register_event_type('on_button_press')
XInputDeviceInstance.register_event_type('on_button_release')
XInputDeviceInstance.register_event_type('on_motion')
XInputDeviceInstance.register_event_type('on_proximity_in')
XInputDeviceInstance.register_event_type('on_proximity_out')
class XInputWindowEventDispatcher:
def __init__(self):
self._instances = dict()
def add_instance(self, instance):
self._instances[instance.device._device_id] = instance
def remove_instance(self, instance):
del self._instances[instance.device._device_id]
def dispatch_instance_event(self, e, *args):
try:
instance = self._instances[e.deviceid]
except KeyError:
return
instance.dispatch_event(*args)
@pyglet.window.xlib.XlibEventHandler(0)
def _event_xinput_key_press(self, ev):
raise NotImplementedError('TODO')
@pyglet.window.xlib.XlibEventHandler(0)
def _event_xinput_key_release(self, ev):
raise NotImplementedError('TODO')
@pyglet.window.xlib.XlibEventHandler(0)
def _event_xinput_button_press(self, ev):
e = ctypes.cast(ctypes.byref(ev),
ctypes.POINTER(xi.XDeviceButtonEvent)).contents
self.dispatch_instance_event(e, 'on_button_press', e.button)
@pyglet.window.xlib.XlibEventHandler(0)
def _event_xinput_button_release(self, ev):
e = ctypes.cast(ctypes.byref(ev),
ctypes.POINTER(xi.XDeviceButtonEvent)).contents
self.dispatch_instance_event(e, 'on_button_release', e.button)
@pyglet.window.xlib.XlibEventHandler(0)
def _event_xinput_motion(self, ev):
e = ctypes.cast(ctypes.byref(ev),
ctypes.POINTER(xi.XDeviceMotionEvent)).contents
axis_data = list()
for i in range(e.axes_count):
axis_data.append(e.axis_data[i])
self.dispatch_instance_event(e, 'on_motion', axis_data, e.x, e.y)
@pyglet.window.xlib.XlibEventHandler(0)
def _event_xinput_proximity_in(self, ev):
e = ctypes.cast(ctypes.byref(ev),
ctypes.POINTER(xi.XProximityNotifyEvent)).contents
self.dispatch_instance_event(e, 'on_proximity_in')
@pyglet.window.xlib.XlibEventHandler(-1)
def _event_xinput_proximity_out(self, ev):
e = ctypes.cast(ctypes.byref(ev),
ctypes.POINTER(xi.XProximityNotifyEvent)).contents
self.dispatch_instance_event(e, 'on_proximity_out')
def _check_extension(display):
major_opcode = ctypes.c_int()
first_event = ctypes.c_int()
first_error = ctypes.c_int()
xlib.XQueryExtension(display._display, 'XInputExtension',
ctypes.byref(major_opcode),
ctypes.byref(first_event),
ctypes.byref(first_error))
if not major_opcode.value:
raise Exception('XInput extension not available')
def get_devices(display):
_check_extension(display)
devices = list()
count = ctypes.c_int(0)
device_list = xi.XListInputDevices(display._display, count)
for i in range(count.value):
device_info = device_list[i]
devices.append(XInputDevice(display, device_info))
return devices
",1
"la.utils import timezone
class PositionOptions(admin.ModelAdmin):
def show_title(self, obj):
if not obj.target:
return '-- %s --' % ugettext('empty position')
else:
return u'%s [%s]' % (obj.target.title, ugettext(obj.target_ct.name),)
show_title.short_description = _('Title')
def is_filled(self, obj):
if obj.target:
return True
else:
return False
is_filled.short_description = _('Filled')
is_filled.boolean = True
def is_active(self, obj):
if obj.disabled:
return False
now = timezone.now()
active_from = not obj.active_from or obj.active_from <= now
active_till = not obj.active_till or obj.active_till > now
return active_from and active_till
is_active.short_description = _('Active')
is_active.boolean = True
list_display = ('name', 'category', 'box_type', 'is_active', 'is_filled', 'show_title', 'disabled',)
list_filter = ('category', 'name', 'disabled', 'active_from', 'active_till',)
search_fields = ('box_type', 'text',)
# suggest_fields = {'category': ('tree_path', 'title', 'slug',),}
admin.site.register(Position, PositionOptions)
",1
"PyQt4 UI code generator 4.9.3
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
try:
_fromUtf8 = QtCore.QString.fromUtf8
except AttributeError:
_fromUtf8 = lambda s: s
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName(_fromUtf8(""MainWindow""))
MainWindow.resize(1024, 768)
self.centralwidget = QtGui.QWidget(MainWindow)
self.centralwidget.setEnabled(True)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.centralwidget.sizePolicy().hasHeightForWidth())
self.centralwidget.setSizePolicy(sizePolicy)
self.centralwidget.setObjectName(_fromUtf8(""centralwidget""))
self.verticalLayout = QtGui.QVBoxLayout(self.centralwidget)
self.verticalLayout.setObjectName(_fromUtf8(""verticalLayout""))
self.horizontalLayout_2 = QtGui.QHBoxLayout()
self.horizontalLayout_2.setObjectName(_fromUtf8(""horizontalLayout_2""))
self.label_3 = QtGui.QLabel(self.centralwidget)
self.label_3.setMaximumSize(QtCore.QSize(200, 200))
self.label_3.setText(_fromUtf8(""""))
self.label_3.setPixmap(QtGui.QPixmap(_fromUtf8("":/logo/pixmaps/logo.jpg"")))
self.label_3.setScaledContents(True)
self.label_3.setObjectName(_fromUtf8(""label_3""))
self.horizontalLayout_2.addWidget(self.label_3)
self.verticalLayout_2 = QtGui.QVBoxLayout()
self.verticalLayout_2.setObjectName(_fromUtf8(""verticalLayout_2""))
self.label_2 = QtGui.QLabel(self.centralwidget)
font = QtGui.QFont()
font.setPointSize(20)
self.label_2.setFont(font)
self.label_2.setAlignment(QtCore.Qt.AlignCenter)
self.label_2.setObjectName(_fromUtf8(""label_2""))
self.verticalLayout_2.addWidget(self.label_2)
self.labelServerId = QtGui.QLabel(self.centralwidget)
palette = QtGui.QPalette()
brush = QtGui.QBrush(QtGui.QColor(0, 0, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Text, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Text, brush)
brush = QtGui.QBrush(QtGui.QColor(118, 116, 113))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText, brush)
brush = QtGui.QBrush(QtGui.QColor(118, 116, 113))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Text, brush)
self.labelServerId.setPalette(palette)
font = QtGui.QFont()
font.setPointSize(16)
font.setBold(True)
font.setWeight(75)
self.labelServerId.setFont(font)
self.labelServerId.setAlignment(QtCore.Qt.AlignCenter)
self.labelServerId.setObjectName(_fromUtf8(""labelServerId""))
self.verticalLayout_2.addWidget(self.labelServerId)
self.labelYear = QtGui.QLabel(self.centralwidget)
palette = QtGui.QPalette()
brush = QtGui.QBrush(QtGui.QColor(0, 0, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText, brush)
brush = QtGui.QBrush(QtGui.QColor(0, 0, 255))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText, brush)
brush = QtGui.QBrush(QtGui.QColor(118, 116, 113))
brush.setStyle(QtCore.Qt.SolidPattern)
palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText, brush)
self.labelYear.setPalette(palette)
font = QtGui.QFont()
font.setPointSize(37)
font.setBold(True)
font.setWeight(75)
self.labelYear.setFont(font)
self.labelYear.setTextFormat(QtCore.Qt.PlainText)
self.labelYear.setAlignment(QtCore.Qt.AlignCenter)
self.labelYear.setObjectName(_fromUtf8(""labelYear""))
self.verticalLayout_2.addWidget(self.labelYear)
self.horizontalLayout_2.addLayout(self.verticalLayout_2)
self.label = QtGui.QLabel(self.centralwidget)
self.label.setMaximumSize(QtCore.QSize(200, 200))
self.label.setText(_fromUtf8(""""))
self.label.setPixmap(QtGui.QPixmap(_fromUtf8("":/logo/pixmaps/Stampa-silicone-tondo-fi55.png"")))
self.label.setScaledContents(True)
self.label.setObjectName(_fromUtf8(""label""))
self.horizontalLayout_2.addWidget(self.label)
self.verticalLayout.addLayout(self.horizontalLayout_2)
self.line = QtGui.QFrame(self.centralwidget)
self.line.setFrameShadow(QtGui.QFrame.Raised)
self.line.setLineWidth(4)
self.line.setFrameShape(QtGui.QFrame.HLine)
self.line.setFrameShadow(QtGui.QFrame.Sunken)
self.line.setObjectName(_fromUtf8(""line""))
self.verticalLayout.addWidget(self.line)
spacerItem = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
self.verticalLayout.addItem(spacerItem)
self.horizontalLayout = QtGui.QHBoxLayout()
self.horizontalLayout.setObjectName(_fromUtf8(""horizontalLayout""))
self.btnNewYear = QtGui.QToolButton(self.centralwidget)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Maximum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(11)
sizePolicy.setHeightForWidth(self.btnNewYear.sizePolicy().hasHeightForWidth())
self.btnNewYear.setSizePolicy(sizePolicy)
self.btnNewYear.setMinimumSize(QtCore.QSize(0, 200))
font = QtGui.QFont()
font.setBold(True)
font.setWeight(75)
self.btnNewYear.setFont(font)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(_fromUtf8("":/img/pixmaps/planner.png"")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.btnNewYear.setIcon(icon)
self.btnNewYear.setIconSize(QtCore.QSize(128, 128))
self.btnNewYear.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
self.btnNewYear.setAutoRaise(False)
self.btnNewYear.setArrowType(QtCore.Qt.NoArrow)
self.btnNewYear.setObjectName(_fromUtf8(""btnNewYear""))
self.horizontalLayout.addWidget(self.btnNewYear)
self.btnCloseYear = QtGui.QToolButton(self.centralwidget)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(11)
sizePolicy.setHeightForWidth(self.btnCloseYear.sizePolicy().hasHeightForWidth())
self.btnCloseYear.setSizePolicy(sizePolicy)
self.btnCloseYear.setMinimumSize(QtCore.QSize(0, 200))
font = QtGui.QFont()
font.setBold(True)
font.setWeight(75)
self.btnCloseYear.setFont(font)
self.btnCloseYear.setAutoFillBackground(False)
icon1 = QtGui.QIcon()
icon1.addPixmap(QtGui.QPixmap(_fromUtf8("":/img/pixmaps/save.png"")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.btnCloseYear.setIcon(icon1)
self.btnCloseYear.setIconSize(QtCore.QSize(128, 128))
self.btnCloseYear.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
self.btnCloseYear.setObjectName(_fromUtf8(""btnCloseYear""))
self.horizontalLayout.addWidget(self.btnCloseYear)
self.btnTeachers = QtGui.QToolButton(self.centralwidget)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Maximum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(11)
sizePolicy.setHeightForWidth(self.btnTeachers.sizePolicy().hasHeightForWidth())
self.btnTeachers.setSizePolicy(sizePolicy)
self.btnTeachers.setMinimumSize(QtCore.QSize(0, 200))
font = QtGui.QFont()
font.setBold(True)
font.setWeight(75)
self.btnTeachers.setFont(font)
icon2 = QtGui.QIcon()
icon2.addPixmap(QtGui.QPixmap(_fromUtf8("":/img/pixmaps/education.png"")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.btnTeachers.setIcon(icon2)
self.btnTeachers.setIconSize(QtCore.QSize(128, 128))
self.btnTeachers.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
self.btnTeachers.setObjectName(_fromUtf8(""btnTeachers""))
self.horizontalLayout.addWidget(self.btnTeachers)
self.btnStudents = QtGui.QToolButton(self.centralwidget)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Maximum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(11)
sizePolicy.setHeightForWidth(self.btnStudents.sizePolicy().hasHeightForWidth())
self.btnStudents.setSizePolicy(sizePolicy)
self.btnStudents.setMinimumSize(QtCore.QSize(0, 200))
font = QtGui.QFont()
font.setBold(True)
font.setWeight(75)
self.btnStudents.setFont(font)
self.btnStudents.setStyleSheet(_fromUtf8(""""))
icon3 = QtGui.QIcon()
icon3.addPixmap(QtGui.QPixmap(_fromUtf8("":/img/pixmaps/System-users.png"")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.btnStudents.setIcon(icon3)
self.btnStudents.setIconSize(QtCore.QSize(128, 128))
self.btnStudents.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
self.btnStudents.setObjectName(_fromUtf8(""btnStudents""))
self.horizontalLayout.addWidget(self.btnStudents)
self.btnAdvanced = QtGui.QToolButton(self.centralwidget)
sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Maximum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(11)
sizePolicy.setHeightForWidth(self.btnAdvanced.sizePolicy().hasHeightForWidth())
self.btnAdvanced.setSizePolicy(sizePolicy)
self.btnAdvanced.setMinimumSize(QtCore.QSize(0, 200))
font = QtGui.QFont()
font.setBold(True)
font.setWeight(75)
self.btnAdvanced.setFont(font)
icon4 = QtGui.QIcon()
icon4.addPixmap(QtGui.QPixmap(_fromUtf8("":/img/pixmaps/advanced_options.png"")), QtGui.QIcon.Normal, QtGui.QIcon.Off)
self.btnAdvanced.setIcon(icon4)
self.btnAdvanced.setIconSize(QtCore.QSize(128, 128))
self.btnAdvanced.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon)
self.btnAdvanced.setObjectName(_fromUtf8(""btnAdvanced""))
self.horizontalLayout.addWidget(self.btnAdvanced)
self.verticalLayout.addLayout(self.horizontalLayout)
spacerItem1 = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding)
self.verticalLayout.addItem(spacerItem1)
MainWindow.setCentralWidget(self.centralwidget)
self.statusbar = QtGui.QStatusBar(MainWindow)
self.statusbar.setObjectName(_fromUtf8(""statusbar""))
MainWindow.setStatusBar(self.statusbar)
self.menubar = QtGui.QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 1024, 29))
self.menubar.setObjectName(_fromUtf8(""menubar""))
self.menuImpostazioni = QtGui.QMenu(self.menubar)
self.menuImpostazioni.setEnabled(False)
self.menuImpostazioni.setObjectName(_fromUtf8(""menuImpostazioni""))
self.menuHelp = QtGui.QMenu(self.menubar)
self.menuHelp.setEnabled(False)
self.menuHelp.setObjectName(_fromUtf8(""menuHelp""))
self.menuArchivi = QtGui.QMenu(self.menubar)
self.menuArchivi.setObjectName(_fromUtf8(""menuArchivi""))
MainWindow.setMenuBar(self.menubar)
self.actionAbout = QtGui.QAction(MainWindow)
self.actionAbout.setObjectName(_fromUtf8(""actionAbout""))
self.actionPreferenze = QtGui.QAction(MainWindow)
self.actionPreferenze.setObjectName(_fromUtf8(""actionPreferenze""))
self.actionArchivioAnniPrec = QtGui.QAction(MainWindow)
self.actionArchivioAnniPrec.setObjectName(_fromUtf8(""actionArchivioAnniPrec""))
self.menuImpostazioni.addAction(self.actionPreferenze)
self.menuHelp.addAction(self.actionAbout)
self.menuArchivi.addAction(self.actionArchivioAnniPrec)
self.menubar.addAction(self.menuArchivi.menuAction())
self.menubar.addAction(self.menuImpostazioni.menuAction())
self.menubar.addAction(self.menuHelp.menuAction())
self.retranslateUi(MainWindow)
QtCore.QObject.connect(self.btnAdvanced, QtCore.SIGNAL(_fromUtf8(""clicked()"")), MainWindow.execAdvancedUserManager)
QtCore.QObject.connect(self.btnCloseYear, QtCore.SIGNAL(_fromUtf8(""clicked()"")), MainWindow.execYearEnd)
QtCore.QObject.connect(self.btnNewYear, QtCore.SIGNAL(_fromUtf8(""clicked()"")), MainWindow.execYearNew)
QtCore.QObject.connect(self.actionArchivioAnniPrec, QtCore.SIGNAL(_fromUtf8(""triggered()"")), MainWindow.showArchBackup)
QtCore.QObject.connect(self.btnStudents, QtCore.SIGNAL(_fromUtf8(""clicked()"")), MainWindow.showStudentsManager)
QtCore.QObject.connect(self.btnTeachers, QtCore.SIGNAL(_fromUtf8(""clicked()"")), MainWindow.showTeachersManager)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def retranslateUi(self, MainWindow):
MainWindow.setWindowTitle(QtGui.QApplication.translate(""MainWindow"", ""MainWindow"", None, QtGui.QApplication.UnicodeUTF8))
self.label_2.setText(QtGui.QApplication.translate(""MainWindow"", ""Pannello di Amministrazione del Server"", None, QtGui.QApplication.UnicodeUTF8))
self.labelServerId.setText(QtGui.QApplication.translate(""MainWindow"", ""TextLabel"", None, QtGui.QApplication.UnicodeUTF8))
self.labelYear.setText(QtGui.QApplication.translate(""MainWindow"", ""Anno -"", None, QtGui.QApplication.UnicodeUTF8))
self.btnNewYear.setText(QtGui.QApplication.translate(""MainWindow"", ""Nuovo Anno"", None, QtGui.QApplication.UnicodeUTF8))
self.btnCloseYear.setText(QtGui.QApplication.translate(""MainWindow"", ""Chiusura Anno"", None, QtGui.QApplication.UnicodeUTF8))
self.btnTeachers.setText(QtGui.QApplication.translate(""MainWindow"", ""Gestione Insegnanti"", None, QtGui.QApplication.UnicodeUTF8))
self.btnStudents.setText(QtGui.QApplication.translate(""MainWindow"", ""Gestione Alunni"", None, QtGui.QApplication.UnicodeUTF8))
self.btnAdvanced.setText(QtGui.QApplication.translate(""MainWindow"", ""Gestione Avanzata"", None, QtGui.QApplication.UnicodeUTF8))
self.menuImpostazioni.setTitle(QtGui.QApplication.translate(""MainWindow"", ""Impostazioni"", None, QtGui.QApplication.UnicodeUTF8))
self.menuHelp.setTitle(QtGui.QApplication.translate(""MainWindow"", ""Help"", None, QtGui.QApplication.UnicodeUTF8))
self.menuArchivi.setTitle(QtGui.QApplication.translate(""MainWindow"", ""Archivi"", None, QtGui.QApplication.UnicodeUTF8))
self.actionAbout.setText(QtGui.QApplication.translate(""MainWindow"", ""About"", None, QtGui.QApplication.UnicodeUTF8))
self.actionPreferenze.setText(QtGui.QApplication.translate(""MainWindow"", ""Preferenze"", None, QtGui.QApplication.UnicodeUTF8))
self.actionArchivioAnniPrec.setText(QtGui.QApplication.translate(""MainWindow"", ""Archivio anni precedenti"", None, QtGui.QApplication.UnicodeUTF8))
import classerman_rc
",1
"= rig.get_default_rig()
g = r.groups['all']
def all_red():
""""""
Create an all-red frame.
""""""
g.setColor('#ff0000')
g.setIntensity(255)
return g.getFrame()
def all_blue():
""""""
Create an all-blue frame.
""""""
g.setColor('#0000ff')
g.setIntensity(255)
return g.getFrame()
def main(config, controller=None):
log.info(""Running script %s"" % __name__)
# global g
# g = get_default_fixture_group(config)
q = controller or dmx.Controller(config.get('base', 'address'), bpm=60, nodaemon=True, runout=True)
q.add(fades.create_multifade([
all_red(),
all_blue(),
] * 3, secs=5.0))
if not controller:
q.start()
",1
"
""""""
import os
import sys
import sqlalchemy
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
import legendary_waffle
# Database setup
db_engine = sqlalchemy.create_engine(""sqlite://"")
legendary_waffle.models.MODELBASE.metadata.create_all(db_engine)
legendary_waffle.models.MODELBASE.metadata.bind = db_engine
db_session = sqlalchemy.orm.sessionmaker(bind=db_engine)
db = db_session()
# Create the user
legendary_waffle.model_create(db, legendary_waffle.models.User, name='sk4ly')
print ""Users: {}"".format(legendary_waffle.model_read(db, legendary_waffle.models.User))
# Create the universe
universe_config = {
""name"": 'poopiverse',
""map_size"": 1000,
""max_planets"": 1000,
""max_players"": 10
}
legendary_waffle.model_create(db, legendary_waffle.models.Universe, **universe_config)
print ""Universe: {}"".format(legendary_waffle.model_read(db, legendary_waffle.models.Universe))
# Create the planet
planet_config = {
""universe"": 1, # The pkid of the universe 'poopiverse'
""coordinate_x"": 1,
""coordinate_y"": 1,
""name"": 'bloth',
""habitable"": True,
""player_control"": 1, # The pkid of user 'sk4ly'
""default_condition"": 1000,
""default_resources"": 1000,
""current_condition"": 1000,
""current_resources"": 1000
}
legendary_waffle.model_create(db, legendary_waffle.models.Planet, **planet_config)
print ""Planet: {}"".format(legendary_waffle.model_read(db, legendary_waffle.models.Planet))
# Create building type name
legendary_waffle.model_create(db, legendary_waffle.models.BuildingTypeName, name=""Control Center"")
print ""Building Type Name: {}"".format(legendary_waffle.model_read(db, legendary_waffle.models.BuildingTypeName))
# Create building type
building_type_config = {
""typename"": 1, # The pkid of the building type name 'Control Center'
""description"": ""This is the control center"",
""default_condition"": 100,
""default_firepower"": 0,
""default_storage"": 100,
""rhr_passive"": 0,
""rhr_active"": 0,
""rhr_destructive"": 0,
""build_resource_reqs"": 500,
}
legendary_waffle.model_create(db, legendary_waffle.models.BuildingType, **building_type_config)
print ""Building Type: {}"".format(legendary_waffle.model_read(db, legendary_waffle.models.BuildingType))
# Now create our new building
building_config = {
""building_type"": 1, # The pkid of the building type with the name 'Control Center'
""universe"": 1, # The pkid of the universe 'poopiverse'
""planet"": 1, # The pkid of the planet 'bloth'
""player_control"": 1, # The pkid of the user 'sk4ly'
}
legendary_waffle.model_create(db, legendary_waffle.models.Building, **building_config)
print ""Building: {}"".format(legendary_waffle.model_read(db, legendary_waffle.models.Building))
",1
"?', hasattr(mod, '__all__')
print 'Has __doc__?', hasattr(mod, '__doc__')
print 'doc: ', getdoc(mod)
if __name__=='__main__':
attribs('cairo')
attribs('zope')
attribs('A.B.C')
import hacked
class Object(object):
pass
opt = Object()
opt.ignore_errors = False
a, d = hacked.get_all_attr_has_docstr('/home/ali/ws-pydev/apidocfilter/A/B',
'/home/ali/ws-pydev/apidocfilter/A/B/C',
opt)
print(a)
print(d)",1
"rk 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 tvm
from tvm import te
def test_stmt_simplify():
ib = tvm.tir.ir_builder.create()
A = ib.pointer(""float32"", name=""A"")
C = ib.pointer(""float32"", name=""C"")
n = te.size_var(""n"")
with ib.for_range(0, n, name=""i"") as i:
with ib.if_scope(i < 12):
A[i] = C[i]
body = tvm.tir.LetStmt(n, 10, ib.get())
mod = tvm.IRModule.from_expr(tvm.tir.PrimFunc([A, C, n], body))
body = tvm.tir.transform.Simplify()(mod)[""main""].body
assert isinstance(body.body, tvm.tir.Store)
def test_thread_extent_simplify():
ib = tvm.tir.ir_builder.create()
A = ib.pointer(""float32"", name=""A"")
C = ib.pointer(""float32"", name=""C"")
n = te.size_var(""n"")
tx = te.thread_axis(""threadIdx.x"")
ty = te.thread_axis(""threadIdx.y"")
ib.scope_attr(tx, ""thread_extent"", n)
ib.scope_attr(tx, ""thread_extent"", n)
ib.scope_attr(ty, ""thread_extent"", 1)
with ib.if_scope(tx + ty < 12):
A[tx] = C[tx + ty]
body = tvm.tir.LetStmt(n, 10, ib.get())
mod = tvm.IRModule.from_expr(tvm.tir.PrimFunc([A, C, n], body))
body = tvm.tir.transform.Simplify()(mod)[""main""].body
assert isinstance(body.body.body.body, tvm.tir.Store)
def test_if_likely():
ib = tvm.tir.ir_builder.create()
A = ib.pointer(""float32"", name=""A"")
C = ib.pointer(""float32"", name=""C"")
n = te.size_var(""n"")
tx = te.thread_axis(""threadIdx.x"")
ty = te.thread_axis(""threadIdx.y"")
ib.scope_attr(tx, ""thread_extent"", 32)
ib.scope_attr(ty, ""thread_extent"", 32)
with ib.if_scope(ib.likely(tx * 32 + ty < n)):
with ib.if_scope(ib.likely(tx * 32 + ty < n)):
A[tx] = C[tx * 32 + ty]
body = ib.get()
mod = tvm.IRModule.from_expr(tvm.tir.PrimFunc([A, C, n], body))
body = tvm.tir.transform.Simplify()(mod)[""main""].body
assert isinstance(body.body.body, tvm.tir.IfThenElse)
assert not isinstance(body.body.body.then_case, tvm.tir.IfThenElse)
def test_basic_likely_elimination():
n = te.size_var(""n"")
X = te.placeholder(shape=(n,), name=""x"")
W = te.placeholder(shape=(n + 1,), dtype=""int32"", name=""w"")
def f(i):
start = W[i]
extent = W[i + 1] - W[i]
rv = te.reduce_axis((0, extent))
return te.sum(X[rv + start], axis=rv)
Y = te.compute(X.shape, f, name=""y"")
s = te.create_schedule([Y.op])
stmt = tvm.lower(s, [X, W, Y], simple_mode=True)
assert ""if"" not in str(stmt)
def test_complex_likely_elimination():
def cumsum(X):
""""""
Y[i] = sum(X[:i])
""""""
(m,) = X.shape
s_state = te.placeholder((m + 1,), dtype=""int32"", name=""state"")
s_init = te.compute((1,), lambda _: tvm.tir.const(0, ""int32""))
s_update = te.compute((m + 1,), lambda l: s_state[l - 1] + X[l - 1])
return tvm.te.scan(s_init, s_update, s_state, inputs=[X], name=""cumsum"")
def sparse_lengths_sum(data, indices, lengths):
oshape = list(data.shape)
oshape[0] = lengths.shape[0]
length_offsets = cumsum(lengths)
def sls(n, d):
gg = te.reduce_axis((0, lengths[n]))
indices_idx = length_offsets[n] + gg
data_idx = indices[indices_idx]
data_val = data[data_idx, d]
return te.sum(data_val, axis=gg)
return te.compute(oshape, sls)
m, n, d, i, l = (
te.size_var(""m""),
te.size_var(""n""),
te.size_var(""d""),
te.size_var(""i""),
te.size_var(""l""),
)
data_ph = te.placeholder((m, d * 32), name=""data"")
indices_ph = te.placeholder((i,), name=""indices"", dtype=""int32"")
lengths_ph = te.placeholder((n,), name=""lengths"", dtype=""int32"")
Y = sparse_lengths_sum(data_ph, indices_ph, lengths_ph)
s = te.create_schedule([Y.op])
(n, d) = s[Y].op.axis
(do, di) = s[Y].split(d, factor=32)
(gg,) = s[Y].op.reduce_axis
s[Y].reorder(n, do, gg, di)
s[Y].vectorize(di)
stmt = tvm.lower(s, [data_ph, indices_ph, lengths_ph, Y], simple_mode=True)
assert ""if"" not in str(stmt)
if __name__ == ""__main__"":
test_stmt_simplify()
test_thread_extent_simplify()
test_if_likely()
test_basic_likely_elimination()
test_complex_likely_elimination()
",1
"imiter.extension import C, Limiter
from flask_limiter.util import get_remote_address
def test_reset(extension_factory):
app, limiter = extension_factory({C.DEFAULT_LIMITS: ""1 per day""})
@app.route(""/"")
def null():
return ""Hello Reset""
with app.test_client() as cli:
cli.get(""/"")
assert ""1 per 1 day"" in cli.get(""/"").data.decode()
limiter.reset()
assert ""Hello Reset"" == cli.get(""/"").data.decode()
assert ""1 per 1 day"" in cli.get(""/"").data.decode()
def test_reset_unsupported(extension_factory, memcached_connection):
app, limiter = extension_factory(
{C.DEFAULT_LIMITS: ""1 per day"", C.STORAGE_URI: ""memcached://localhost:31211""}
)
@app.route(""/"")
def null():
return ""Hello Reset""
with app.test_client() as cli:
cli.get(""/"")
assert ""1 per 1 day"" in cli.get(""/"").data.decode()
# no op with memcached but no error raised
limiter.reset()
assert ""1 per 1 day"" in cli.get(""/"").data.decode()
def test_combined_rate_limits(extension_factory):
app, limiter = extension_factory({C.DEFAULT_LIMITS: ""1 per hour; 10 per day""})
@app.route(""/t1"")
@limiter.limit(""100 per hour;10/minute"")
def t1():
return ""t1""
@app.route(""/t2"")
def t2():
return ""t2""
with hiro.Timeline().freeze():
with app.test_client() as cli:
assert 200 == cli.get(""/t1"").status_code
assert 200 == cli.get(""/t2"").status_code
assert 429 == cli.get(""/t2"").status_code
def test_defaults_per_method(extension_factory):
app, limiter = extension_factory(
{C.DEFAULT_LIMITS: ""1 per hour"", C.DEFAULT_LIMITS_PER_METHOD: True}
)
@app.route(""/t1"", methods=[""GET"", ""POST""])
def t1():
return ""t1""
with hiro.Timeline().freeze():
with app.test_client() as cli:
assert 200 == cli.get(""/t1"").status_code
assert 429 == cli.get(""/t1"").status_code
assert 200 == cli.post(""/t1"").status_code
assert 429 == cli.post(""/t1"").status_code
def test_default_limit_with_exemption(extension_factory):
def is_backdoor():
return request.headers.get(""backdoor"") == ""true""
app, limiter = extension_factory(
{C.DEFAULT_LIMITS: ""1 per hour"", C.DEFAULT_LIMITS_EXEMPT_WHEN: is_backdoor}
)
@app.route(""/t1"")
def t1():
return ""test""
with hiro.Timeline() as timeline:
with app.test_client() as cli:
assert cli.get(""/t1"", headers={""backdoor"": ""true""}).status_code == 200
assert cli.get(""/t1"", headers={""backdoor"": ""true""}).status_code == 200
assert cli.get(""/t1"").status_code == 200
assert cli.get(""/t1"").status_code == 429
timeline.forward(3600)
assert cli.get(""/t1"").status_code == 200
def test_default_limit_with_conditional_deduction(extension_factory):
def failed_request(response):
return response.status_code != 200
app, limiter = extension_factory(
{C.DEFAULT_LIMITS: ""1 per hour"", C.DEFAULT_LIMITS_DEDUCT_WHEN: failed_request}
)
@app.route(""/t1/"")
def t1(path):
if path != ""1"":
raise BadRequest()
return path
with hiro.Timeline() as timeline:
with app.test_client() as cli:
assert cli.get(""/t1/1"").status_code == 200
assert cli.get(""/t1/1"").status_code == 200
assert cli.get(""/t1/2"").status_code == 400
assert cli.get(""/t1/1"").status_code == 429
assert cli.get(""/t1/2"").status_code == 429
timeline.forward(3600)
assert cli.get(""/t1/1"").status_code == 200
assert cli.get(""/t1/2"").status_code == 400
def test_key_func(extension_factory):
app, limiter = extension_factory()
@app.route(""/t1"")
@limiter.limit(""100 per minute"", lambda: ""test"")
def t1():
return ""test""
with hiro.Timeline().freeze():
with app.test_client() as cli:
for i in range(0, 100):
assert (
200
== cli.get(
""/t1"", headers={""X_FORWARDED_FOR"": ""127.0.0.2""}
).status_code
)
assert 429 == cli.get(""/t1"").status_code
def test_logging(caplog):
app = Flask(__name__)
limiter = Limiter(app, key_func=get_remote_address)
@app.route(""/t1"")
@limiter.limit(""1/minute"")
def t1():
return ""test""
with app.test_client() as cli:
assert 200 == cli.get(""/t1"").status_code
assert 429 == cli.get(""/t1"").status_code
assert len(caplog.records) == 1
assert caplog.records[0].levelname == ""WARNING""
def test_reuse_logging():
app = Flask(__name__)
app_handler = mock.Mock()
app_handler.level = logging.INFO
app.logger.addHandler(app_handler)
limiter = Limiter(app, key_func=get_remote_address)
for handler in app.logger.handlers:
limiter.logger.addHandler(handler)
@app.route(""/t1"")
@limiter.limit(""1/minute"")
def t1():
return ""42""
with app.test_client() as cli:
cli.get(""/t1"")
cli.get(""/t1"")
assert app_handler.handle.call_count == 1
def test_disabled_flag(extension_factory):
app, limiter = extension_factory(
config={C.ENABLED: False}, default_limits=[""1/minute""]
)
@app.route(""/t1"")
def t1():
return ""test""
@app.route(""/t2"")
@limiter.limit(""10 per minute"")
def t2():
return ""test""
with app.test_client() as cli:
assert cli.get(""/t1"").status_code == 200
assert cli.get(""/t1"").status_code == 200
for i in range(0, 10):
assert cli.get(""/t2"").status_code == 200
assert cli.get(""/t2"").status_code == 200
def test_multiple_apps():
app1 = Flask(__name__)
app2 = Flask(__name__)
limiter = Limiter(default_limits=[""1/second""], key_func=get_remote_address)
limiter.init_app(app1)
limiter.init_app(app2)
@app1.route(""/ping"")
def ping():
return ""PONG""
@app1.route(""/slowping"")
@limiter.limit(""1/minute"")
def slow_ping():
return ""PONG""
@app2.route(""/ping"")
@limiter.limit(""2/second"")
def ping_2():
return ""PONG""
@app2.route(""/slowping"")
@limiter.limit(""2/minute"")
def slow_ping_2():
return ""PONG""
with hiro.Timeline().freeze() as timeline:
with app1.test_client() as cli:
assert cli.get(""/ping"").status_code == 200
assert cli.get(""/ping"").status_code == 429
timeline.forward(1)
assert cli.get(""/ping"").status_code == 200
assert cli.get(""/slowping"").status_code == 200
timeline.forward(59)
assert cli.get(""/slowping"").status_code == 429
timeline.forward(1)
assert cli.get(""/slowping"").status_code == 200
with app2.test_client() as cli:
assert cli.get(""/ping"").status_code == 200
assert cli.get(""/ping"").status_code == 200
assert cli.get(""/ping"").status_code == 429
timeline.forward(1)
assert cli.get(""/ping"").status_code == 200
assert cli.get(""/slowping"").status_code == 200
timeline.forward(59)
assert cli.get(""/slowping"").status_code == 200
assert cli.get(""/slowping"").status_code == 429
timeline.forward(1)
assert cli.get(""/slowping"").status_code == 200
def test_headers_no_breach():
app = Flask(__name__)
limiter = Limiter(
app,
default_limits=[""10/minute""],
headers_enabled=True,
key_func=get_remote_address,
)
@app.route(""/t1"")
def t1():
return ""test""
@app.route(""/t2"")
@limiter.limit(""2/second; 5 per minute; 10/hour"")
def t2():
return ""test""
with hiro.Timeline().freeze():
with app.test_client() as cli:
resp = cli.get(""/t1"")
assert resp.headers.get(""X-RateLimit-Limit"") == ""10""
assert resp.headers.get(""X-RateLimit-Remaining"") == ""9""
assert resp.headers.get(""X-RateLimit-Reset"") == str(int(time.time() + 61))
assert resp.headers.get(""Retry-After"") == str(60)
resp = cli.get(""/t2"")
assert resp.headers.get(""X-RateLimit-Limit"") == ""2""
assert resp.headers.get(""X-RateLimit-Remaining"") == ""1""
assert resp.headers.get(""X-RateLimit-Reset"") == str(int(time.time() + 2))
assert resp.headers.get(""Retry-After"") == str(1)
assert limiter.current_limit.remaining == 1
assert limiter.current_limit.reset_at == int(time.time() + 2)
assert not limiter.current_limit.breached
def test_headers_breach():
app = Flask(__name__)
limiter = Limiter(
app,
default_limits=[""10/minute""],
headers_enabled=True,
key_func=get_remote_address,
)
@app.route(""/t1"")
@limiter.limit(""2/second; 10 per minute; 20/hour"")
def t():
return ""test""
with hiro.Timeline().freeze() as timeline:
with app.test_client() as cli:
for i in range(10):
resp = cli.get(""/t1"")
timeline.forward(1)
assert len(limiter.current_limits) == 3
assert all(not limit.breached for limit in limiter.current_limits)
resp = cli.get(""/t1"")
timeline.forward(1)
assert resp.headers.get(""X-RateLimit-Limit"") == ""10""
assert resp.headers.get(""X-RateLimit-Remaining"") == ""0""
assert resp.headers.get(""X-RateLimit-Reset"") == str(int(time.time() + 50))
assert resp.headers.get(""Retry-After"") == str(int(50))
assert limiter.current_limit.remaining == 0
assert limiter.current_limit.reset_at == int(time.time() + 50)
assert limiter.current_limit.breached
def test_retry_after():
app = Flask(__name__)
_ = Limiter(
app,
default_limits=[""1/minute""],
headers_enabled=True,
key_func=get_remote_address,
)
@app.route(""/t1"")
def t():
return ""test""
with hiro.Timeline().freeze() as timeline:
with app.test_client() as cli:
resp = cli.get(""/t1"")
retry_after = int(resp.headers.get(""Retry-After""))
assert retry_after > 0
timeline.forward(retry_after)
resp = cli.get(""/t1"")
assert resp.status_code == 200
def test_retry_after_exists_seconds():
app = Flask(__name__)
_ = Limiter(
app,
default_limits=[""1/minute""],
headers_enabled=True,
key_func=get_remote_address,
)
@app.route(""/t1"")
def t():
return """", 200, {""Retry-After"": ""1000000""}
with app.test_client() as cli:
resp = cli.get(""/t1"")
retry_after = int(resp.headers.get(""Retry-After""))
assert retry_after > 1000
def test_retry_after_exists_rfc1123():
app = Flask(__name__)
_ = Limiter(
app,
default_limits=[""1/minute""],
headers_enabled=True,
key_func=get_remote_address,
)
@app.route(""/t1"")
def t():
return """", 200, {""Retry-After"": ""Sun, 06 Nov 2032 01:01:01 GMT""}
with app.test_client() as cli:
resp = cli.get(""/t1"")
retry_after = int(resp.headers.get(""Retry-After""))
assert retry_after > 1000
def test_custom_headers_from_config():
app = Flask(__name__)
app.config.setdefault(C.HEADER_LIMIT, ""X-Limit"")
app.config.setdefault(C.HEADER_REMAINING, ""X-Remaining"")
app.config.setdefault(C.HEADER_RESET, ""X-Reset"")
limiter = Limiter(
app,
default_limits=[""10/minute""],
headers_enabled=True,
key_func=get_remote_address,
)
@app.route(""/t1"")
@limiter.limit(""2/second; 10 per minute; 20/hour"")
def t():
return ""test""
with hiro.Timeline().freeze() as timeline:
with app.test_client() as cli:
for i in range(11):
resp = cli.get(""/t1"")
timeline.forward(1)
assert resp.headers.get(""X-Limit"") == ""10""
assert resp.headers.get(""X-Remaining"") == ""0""
assert resp.headers.get(""X-Reset"") == str(int(time.time() + 50))
def test_application_shared_limit(extension_factory):
app, limiter = extension_factory(application_limits=[""2/minute""])
@app.route(""/t1"")
def t1():
return ""route1""
@app.route(""/t2"")
def t2():
return ""route2""
with hiro.Timeline().freeze():
with app.test_client() as cli:
assert 200 == cli.get(""/t1"").status_code
assert 200 == cli.get(""/t2"").status_code
assert 429 == cli.get(""/t1"").status_code
def test_callable_default_limit(extension_factory):
app, limiter = extension_factory(default_limits=[lambda: ""1/minute""])
@app.route(""/t1"")
def t1():
return ""t1""
@app.route(""/t2"")
def t2():
return ""t2""
with hiro.Timeline().freeze():
with app.test_client() as cli:
assert cli.get(""/t1"").status_code == 200
assert cli.get(""/t2"").status_code == 200
assert cli.get(""/t1"").status_code == 429
assert cli.get(""/t2"").status_code == 429
def test_callable_application_limit(extension_factory):
app, limiter = extension_factory(application_limits=[lambda: ""1/minute""])
@app.route(""/t1"")
def t1():
return ""t1""
@app.route(""/t2"")
def t2():
return ""t2""
with hiro.Timeline().freeze():
with app.test_client() as cli:
assert cli.get(""/t1"").status_code == 200
assert cli.get(""/t2"").status_code == 429
def test_no_auto_check(extension_factory):
app, limiter = extension_factory(auto_check=False)
@app.route(""/"", methods=[""GET"", ""POST""])
@limiter.limit(""1/second"", per_method=True)
def root():
return ""root""
with hiro.Timeline().freeze():
with app.test_client() as cli:
assert 200 == cli.get(""/"").status_code
assert 200 == cli.get(""/"").status_code
# attach before_request to perform check
@app.before_request
def _():
limiter.check()
with hiro.Timeline().freeze():
with app.test_client() as cli:
assert 200 == cli.get(""/"").status_code
assert 429 == cli.get(""/"").status_code
def test_fail_on_first_breach(extension_factory):
app, limiter = extension_factory(fail_on_first_breach=True)
@app.route(""/"", methods=[""GET"", ""POST""])
@limiter.limit(""1/second"", per_method=True)
@limiter.limit(""2/minute"", per_method=True)
def root():
return ""root""
with hiro.Timeline().freeze() as timeline:
with app.test_client() as cli:
assert 200 == cli.get(""/"").status_code
assert 429 == cli.get(""/"").status_code
assert [True] == [k.breached for k in limiter.current_limits]
timeline.forward(1)
assert 200 == cli.get(""/"").status_code
assert [False, False] == [k.breached for k in limiter.current_limits]
timeline.forward(1)
assert 429 == cli.get(""/"").status_code
assert [False, True] == [k.breached for k in limiter.current_limits]
def test_no_fail_on_first_breach(extension_factory):
app, limiter = extension_factory(fail_on_first_breach=False)
@app.route(""/"", methods=[""GET"", ""POST""])
@limiter.limit(""1/second"", per_method=True)
@limiter.limit(""2/minute"", per_method=True)
def root():
return ""root""
with hiro.Timeline().freeze() as timeline:
with app.test_client() as cli:
assert 200 == cli.get(""/"").status_code
assert 429 == cli.get(""/"").status_code
assert [True, False] == [k.breached for k in limiter.current_limits]
timeline.forward(1)
assert 429 == cli.get(""/"").status_code
assert [False, True] == [k.breached for k in limiter.current_limits]
def test_custom_key_prefix(redis_connection, extension_factory):
app1, limiter1 = extension_factory(
key_prefix=""moo"", storage_uri=""redis://localhost:46379""
)
app2, limiter2 = extension_factory(
{C.KEY_PREFIX: ""cow""}, storage_uri=""redis://localhost:46379""
)
app3, limiter3 = extension_factory(storage_uri=""redis://localhost:46379"")
@app1.route(""/test"")
@limiter1.limit(""1/day"")
def app1_test():
return ""app1 test""
@app2.route(""/test"")
@limiter2.limit(""1/day"")
def app2_test():
return ""app1 test""
@app3.route(""/test"")
@limiter3.limit(""1/day"")
def app3_test():
return ""app1 test""
with app1.test_client() as cli:
resp = cli.get(""/test"")
assert 200 == resp.status_code
resp = cli.get(""/test"")
assert 429 == resp.status_code
with app2.test_client() as cli:
resp = cli.get(""/test"")
assert 200 == resp.status_code
resp = cli.get(""/test"")
assert 429 == resp.status_code
with app3.test_client() as cli:
resp = cli.get(""/test"")
assert 200 == resp.status_code
resp = cli.get(""/test"")
assert 429 == resp.status_code
def test_second_instance_bypassed_by_shared_g():
app = Flask(__name__)
limiter1 = Limiter(app, key_func=get_remote_address)
limiter2 = Limiter(app, key_func=get_remote_address)
@app.route(""/test1"")
@limiter2.limit(""1/second"")
def app_test1():
return ""app test1""
@app.route(""/test2"")
@limiter1.limit(""10/minute"")
@limiter2.limit(""1/second"")
def app_test2():
return ""app test2""
with hiro.Timeline().freeze() as timeline:
with app.test_client() as cli:
assert cli.get(""/test1"").status_code == 200
assert cli.get(""/test2"").status_code == 200
assert cli.get(""/test1"").status_code == 429
assert cli.get(""/test2"").status_code == 200
for i in range(8):
assert cli.get(""/test1"").status_code == 429
assert cli.get(""/test2"").status_code == 200
assert cli.get(""/test2"").status_code == 429
timeline.forward(1)
assert cli.get(""/test1"").status_code == 200
assert cli.get(""/test2"").status_code == 429
timeline.forward(59)
assert cli.get(""/test1"").status_code == 200
assert cli.get(""/test2"").status_code == 200
def test_independent_instances_by_key_prefix():
app = Flask(__name__)
limiter1 = Limiter(app, key_prefix=""lmt1"", key_func=get_remote_address)
limiter2 = Limiter(app, key_prefix=""lmt2"", key_func=get_remote_address)
@app.route(""/test1"")
@limiter2.limit(""1/second"")
def app_test1():
return ""app test1""
@app.route(""/test2"")
@limiter1.limit(""10/minute"")
@limiter2.limit(""1/second"")
def app_test2():
return ""app test2""
with hiro.Timeline().freeze() as timeline:
with app.test_client() as cli:
assert cli.get(""/test1"").status_code == 200
assert cli.get(""/test2"").status_code == 200
resp = cli.get(""/test1"")
assert resp.status_code == 429
assert ""1 per 1 second"" in resp.data.decode()
resp = cli.get(""/test2"")
assert resp.status_code == 429
assert ""1 per 1 second"" in resp.data.decode()
for i in range(8):
assert cli.get(""/test1"").status_code == 429
assert cli.get(""/test2"").status_code == 429
assert cli.get(""/test2"").status_code == 429
timeline.forward(1)
assert cli.get(""/test1"").status_code == 200
assert cli.get(""/test2"").status_code == 429
timeline.forward(59)
assert cli.get(""/test1"").status_code == 200
assert cli.get(""/test2"").status_code == 200
",1
"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 [^/]+) # initial letter, wordchars + hyphen
/logs/ # static midfix
(?P[^/]+) # initial letter, wordchars + allowed punc
"""""", re.VERBOSE)
def logger_name_from_path(path):
""""""Validate a logger URI path and get the logger name.
:type path: str
:param path: URI path for a logger API request.
:rtype: str
:returns: Logger name parsed from ``path``.
:raises: :class:`ValueError` if the ``path`` is ill-formed or if
the project from the ``path`` does not agree with the
``project`` passed in.
""""""
return _name_from_project_path(path, None, _LOGGER_TEMPLATE)
def _int_or_none(value):
""""""Helper: return an integer or ``None``.""""""
if value is not None:
value = int(value)
return value
_LOG_ENTRY_FIELDS = ( # (name, default)
('log_name', None),
('labels', None),
('insert_id', None),
('severity', None),
('http_request', None),
('timestamp', None),
('resource', _GLOBAL_RESOURCE),
('trace', None),
('span_id', None),
('trace_sampled', None),
('source_location', None),
('operation', None),
('logger', None),
('payload', None),
)
_LogEntryTuple = collections.namedtuple(
'LogEntry', (field for field, _ in _LOG_ENTRY_FIELDS))
_LogEntryTuple.__new__.__defaults__ = tuple(
default for _, default in _LOG_ENTRY_FIELDS)
_LOG_ENTRY_PARAM_DOCSTRING = """"""\
:type log_name: str
:param log_name: the name of the logger used to post the entry.
:type labels: dict
:param labels: (optional) mapping of labels for the entry
:type insert_id: text
:param insert_id: (optional) the ID used to identify an entry uniquely.
:type severity: str
:param severity: (optional) severity of event being logged.
:type http_request: dict
:param http_request: (optional) info about HTTP request associated with
the entry.
:type timestamp: :class:`datetime.datetime`
:param timestamp: (optional) timestamp for the entry
:type resource: :class:`~google.cloud.logging.resource.Resource`
:param resource: (Optional) Monitored resource of the entry
:type trace: str
:param trace: (optional) traceid to apply to the entry.
:type span_id: str
:param span_id: (optional) span_id within the trace for the log entry.
Specify the trace parameter if span_id is set.
:type trace_sampled: bool
:param trace_sampled: (optional) the sampling decision of the trace
associated with the log entry.
:type source_location: dict
:param source_location: (optional) location in source code from which
the entry was emitted.
:type operation: dict
:param operation: (optional) additional information about a potentially
long-running operation associated with the log entry.
:type logger: :class:`google.cloud.logging.logger.Logger`
:param logger: the logger used to write the entry.
""""""
_LOG_ENTRY_SEE_ALSO_DOCSTRING = """"""\
See:
https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry
""""""
class LogEntry(_LogEntryTuple):
__doc__ = """"""
Log entry.
"""""" + _LOG_ENTRY_PARAM_DOCSTRING + _LOG_ENTRY_SEE_ALSO_DOCSTRING
received_timestamp = None
@classmethod
def _extract_payload(cls, resource):
""""""Helper for :meth:`from_api_repr`""""""
return None
@classmethod
def from_api_repr(cls, resource, client, loggers=None):
""""""Factory: construct an entry given its API representation
:type resource: dict
:param resource: text entry resource representation returned from
the API
:type client: :class:`google.cloud.logging.client.Client`
:param client: Client which holds credentials and project
configuration.
:type loggers: dict
:param loggers:
(Optional) A mapping of logger fullnames -> loggers. If not
passed, the entry will have a newly-created logger.
:rtype: :class:`google.cloud.logging.entries.LogEntry`
:returns: Log entry parsed from ``resource``.
""""""
if loggers is None:
loggers = {}
logger_fullname = resource['logName']
logger = loggers.get(logger_fullname)
if logger is None:
logger_name = logger_name_from_path(logger_fullname)
logger = loggers[logger_fullname] = client.logger(logger_name)
payload = cls._extract_payload(resource)
insert_id = resource.get('insertId')
timestamp = resource.get('timestamp')
if timestamp is not None:
timestamp = _rfc3339_nanos_to_datetime(timestamp)
labels = resource.get('labels')
severity = resource.get('severity')
http_request = resource.get('httpRequest')
trace = resource.get('trace')
span_id = resource.get('spanId')
trace_sampled = resource.get('traceSampled')
source_location = resource.get('sourceLocation')
if source_location is not None:
line = source_location.pop('line', None)
source_location['line'] = _int_or_none(line)
operation = resource.get('operation')
monitored_resource_dict = resource.get('resource')
monitored_resource = None
if monitored_resource_dict is not None:
monitored_resource = Resource._from_dict(monitored_resource_dict)
inst = cls(
log_name=logger_fullname,
insert_id=insert_id,
timestamp=timestamp,
labels=labels,
severity=severity,
http_request=http_request,
resource=monitored_resource,
trace=trace,
span_id=span_id,
trace_sampled=trace_sampled,
source_location=source_location,
operation=operation,
logger=logger,
payload=payload,
)
received = resource.get('receiveTimestamp')
if received is not None:
inst.received_timestamp = _rfc3339_nanos_to_datetime(received)
return inst
def to_api_repr(self):
""""""API repr (JSON format) for entry.
""""""
info = {}
if self.log_name is not None:
info['logName'] = self.log_name
if self.resource is not None:
info['resource'] = self.resource._to_dict()
if self.labels is not None:
info['labels'] = self.labels
if self.insert_id is not None:
info['insertId'] = self.insert_id
if self.severity is not None:
info['severity'] = self.severity
if self.http_request is not None:
info['httpRequest'] = self.http_request
if self.timestamp is not None:
info['timestamp'] = _datetime_to_rfc3339(self.timestamp)
if self.trace is not None:
info['trace'] = self.trace
if self.span_id is not None:
info['spanId'] = self.span_id
if self.trace_sampled is not None:
info['traceSampled'] = self.trace_sampled
if self.source_location is not None:
source_location = self.source_location.copy()
source_location['line'] = str(source_location.pop('line', 0))
info['sourceLocation'] = source_location
if self.operation is not None:
info['operation'] = self.operation
return info
class TextEntry(LogEntry):
__doc__ = """"""
Log entry with text payload.
"""""" + _LOG_ENTRY_PARAM_DOCSTRING + """"""
:type payload: str | unicode
:param payload: payload for the log entry.
"""""" + _LOG_ENTRY_SEE_ALSO_DOCSTRING
@classmethod
def _extract_payload(cls, resource):
""""""Helper for :meth:`from_api_repr`""""""
return resource['textPayload']
def to_api_repr(self):
""""""API repr (JSON format) for entry.
""""""
info = super(TextEntry, self).to_api_repr()
info['textPayload'] = self.payload
return info
class StructEntry(LogEntry):
__doc__ = """"""
Log entry with JSON payload.
"""""" + _LOG_ENTRY_PARAM_DOCSTRING + """"""
:type payload: dict
:param payload: payload for the log entry.
"""""" + _LOG_ENTRY_SEE_ALSO_DOCSTRING
@classmethod
def _extract_payload(cls, resource):
""""""Helper for :meth:`from_api_repr`""""""
return resource['jsonPayload']
def to_api_repr(self):
""""""API repr (JSON format) for entry.
""""""
info = super(StructEntry, self).to_api_repr()
info['jsonPayload'] = self.payload
return info
class ProtobufEntry(LogEntry):
__doc__ = """"""
Log entry with protobuf message payload.
"""""" + _LOG_ENTRY_PARAM_DOCSTRING + """"""
:type payload: protobuf message
:param payload: payload for the log entry.
"""""" + _LOG_ENTRY_SEE_ALSO_DOCSTRING
@classmethod
def _extract_payload(cls, resource):
""""""Helper for :meth:`from_api_repr`""""""
return resource['protoPayload']
@property
def payload_pb(self):
if isinstance(self.payload, Any):
return self.payload
@property
def payload_json(self):
if not isinstance(self.payload, Any):
return self.payload
def to_api_repr(self):
""""""API repr (JSON format) for entry.
""""""
info = super(ProtobufEntry, self).to_api_repr()
info['protoPayload'] = MessageToDict(self.payload)
return info
def parse_message(self, message):
""""""Parse payload into a protobuf message.
Mutates the passed-in ``message`` in place.
:type message: Protobuf message
:param message: the message to be logged
""""""
# NOTE: This assumes that ``payload`` is already a deserialized
# ``Any`` field and ``message`` has come from an imported
# ``pb2`` module with the relevant protobuf message type.
Parse(json.dumps(self.payload), message)
",1
"pt 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 for spanner databases create.""""""
from googlecloudsdk.api_lib.spanner import database_operations
from googlecloudsdk.api_lib.spanner import databases
from googlecloudsdk.calliope import base
from googlecloudsdk.command_lib.spanner import flags
class Create(base.CreateCommand):
""""""Cloud Spanner databases create command.""""""
@staticmethod
def Args(parser):
""""""Args is called by calliope to gather arguments for this command.
Please add arguments in alphabetical order except for no- or a clear-
pair for that argument which can follow the argument itself.
Args:
parser: An argparse parser that you can use to add arguments that go
on the command line after this command. Positional arguments are
allowed.
""""""
flags.Instance(positional=False).AddToParser(parser)
flags.Database().AddToParser(parser)
flags.Ddl(help_text='Semi-colon separated DDL (data definition language) '
'statements to run inside the '
'newly created database. If there is an error in any statement, '
'the database is not created. Full DDL specification is at '
'https://cloud.google.com/spanner/docs/data-definition-language'
).AddToParser(parser)
base.ASYNC_FLAG.AddToParser(parser)
def Run(self, args):
""""""This is what gets called when the user runs this command.
Args:
args: an argparse namespace. All the arguments that were provided to this
command invocation.
Returns:
Some value that we want to have printed later.
""""""
op = databases.Create(
args.instance, args.database, flags.FixDdl(args.ddl or []))
if args.async:
return op
return database_operations.Await(op, 'Creating database')
",1
"s import face_lookup
from ...geometry.sheet_geometry import SheetGeometry
from ...topology.sheet_topology import cell_division
from .actions import (
exchange,
remove,
merge_vertices,
detach_vertices,
increase,
decrease,
increase_linear_tension,
)
def reconnect(sheet, manager, **kwargs):
""""""Performs reconnections (vertex merging / splitting) following Finegan et al. 2019
kwargs overwrite their corresponding `sheet.settings` entries
Keyword Arguments
-----------------
threshold_length : the threshold length at which vertex merging is performed
p_4 : the probability per unit time to perform a detachement from a rank 4 vertex
p_5p : the probability per unit time to perform a detachement from a rank 5 or more vertex
See Also
--------
**The tricellular vertex-specific adhesion molecule Sidekick
facilitates polarised cell intercalation during Drosophila axis
extension** _Tara M Finegan, Nathan Hervieux, Alexander
Nestor-Bergmann, Alexander G. Fletcher, Guy B Blanchard, Benedicte
Sanson_ bioRxiv 704932; doi: https://doi.org/10.1101/704932
""""""
sheet.settings.update(kwargs)
nv = sheet.Nv
merge_vertices(sheet)
if nv != sheet.Nv:
logger.info(f""Merged {nv - sheet.Nv+1} vertices"")
nv = sheet.Nv
retval = detach_vertices(sheet)
if retval:
logger.info(""Failed to detach, skipping"")
if nv != sheet.Nv:
logger.info(f""Detached {sheet.Nv - nv} vertices"")
manager.append(reconnect, **kwargs)
default_division_spec = {
""face_id"": -1,
""face"": -1,
""growth_rate"": 0.1,
""critical_vol"": 2.0,
""geom"": SheetGeometry,
}
@face_lookup
def division(sheet, manager, **kwargs):
""""""Cell division happens through cell growth up to a critical volume,
followed by actual division of the face.
Parameters
----------
sheet : a `Sheet` object
manager : an `EventManager` instance
face_id : int,
index of the mother face
growth_rate : float, default 0.1
rate of increase of the prefered volume
critical_vol : float, default 2.
volume at which the cells stops to grow and devides
""""""
division_spec = default_division_spec
division_spec.update(**kwargs)
face = division_spec[""face""]
division_spec[""critical_vol""] *= sheet.specs[""face""][""prefered_vol""]
print(sheet.face_df.loc[face, ""vol""], division_spec[""critical_vol""])
if sheet.face_df.loc[face, ""vol""] < division_spec[""critical_vol""]:
increase(
sheet, ""face"", face, division_spec[""growth_rate""], ""prefered_vol"", True
)
manager.append(division, **division_spec)
else:
daughter = cell_division(sheet, face, division_spec[""geom""])
sheet.face_df.loc[daughter, ""id""] = sheet.face_df.id.max() + 1
default_contraction_spec = {
""face_id"": -1,
""face"": -1,
""contractile_increase"": 1.0,
""critical_area"": 1e-2,
""max_contractility"": 10,
""multiply"": False,
""contraction_column"": ""contractility"",
""unique"": True,
}
@face_lookup
def contraction(sheet, manager, **kwargs):
""""""Single step contraction event.""""""
contraction_spec = default_contraction_spec
contraction_spec.update(**kwargs)
face = contraction_spec[""face""]
if (sheet.face_df.loc[face, ""area""] < contraction_spec[""critical_area""]) or (
sheet.face_df.loc[face, contraction_spec[""contraction_column""]]
> contraction_spec[""max_contractility""]
):
return
increase(
sheet,
""face"",
face,
contraction_spec[""contractile_increase""],
contraction_spec[""contraction_column""],
contraction_spec[""multiply""],
)
default_type1_transition_spec = {
""face_id"": -1,
""face"": -1,
""critical_length"": 0.1,
""geom"": SheetGeometry,
}
@face_lookup
def type1_transition(sheet, manager, **kwargs):
""""""Custom type 1 transition event that tests if
the the shorter edge of the face is smaller than
the critical length.
""""""
type1_transition_spec = default_type1_transition_spec
type1_transition_spec.update(**kwargs)
face = type1_transition_spec[""face""]
edges = sheet.edge_df[sheet.edge_df[""face""] == face]
if min(edges[""length""]) < type1_transition_spec[""critical_length""]:
exchange(sheet, face, type1_transition_spec[""geom""])
default_face_elimination_spec = {""face_id"": -1, ""face"": -1, ""geom"": SheetGeometry}
@face_lookup
def face_elimination(sheet, manager, **kwargs):
""""""Removes the face with if face_id from the sheet.""""""
face_elimination_spec = default_face_elimination_spec
face_elimination_spec.update(**kwargs)
remove(sheet, face_elimination_spec[""face""], face_elimination_spec[""geom""])
default_check_tri_face_spec = {""geom"": SheetGeometry}
def check_tri_faces(sheet, manager, **kwargs):
""""""Three neighbourghs cell elimination
Add all cells with three neighbourghs in the manager
to be eliminated at the next time step.
Parameters
----------
sheet : a :class:`tyssue.sheet` object
manager : a :class:`tyssue.events.EventManager` object
""""""
check_tri_faces_spec = default_check_tri_face_spec
check_tri_faces_spec.update(**kwargs)
tri_faces = sheet.face_df[(sheet.face_df[""num_sides""] < 4)].id
manager.extend(
[
(face_elimination, {""face_id"": f, ""geom"": check_tri_faces_spec[""geom""]})
for f in tri_faces
]
)
default_contraction_line_tension_spec = {
""face_id"": -1,
""face"": -1,
""shrink_rate"": 1.05,
""contractile_increase"": 1.0,
""critical_area"": 1e-2,
""max_contractility"": 10,
""multiply"": True,
""contraction_column"": ""line_tension"",
""unique"": True,
}
@face_lookup
def contraction_line_tension(sheet, manager, **kwargs):
""""""
Single step contraction event
""""""
contraction_spec = default_contraction_line_tension_spec
contraction_spec.update(**kwargs)
face = contraction_spec[""face""]
if sheet.face_df.loc[face, ""area""] < contraction_spec[""critical_area""]:
return
# reduce prefered_area
decrease(
sheet,
""face"",
face,
contraction_spec[""shrink_rate""],
col=""prefered_area"",
divide=True,
bound=contraction_spec[""critical_area""] / 2,
)
increase_linear_tension(
sheet,
face,
contraction_spec[""contractile_increase""],
multiply=contraction_spec[""multiply""],
isotropic=True,
limit=100,
)
",1
"t_mongo_collection():
""Open a connection to MongoDB and return the collection to use.""
if settings.RIGHT_MONGODB_HOST:
connection = Connection.paired(
left=(settings.MONGODB_HOST, settings.MONGODB_PORT),
right=(settings.RIGHT_MONGODB_HOST, settings.RIGHT_MONGODB_PORT)
)
else:
connection = Connection(host=settings.MONGODB_HOST, port=settings.MONGODB_PORT)
return connection[settings.MONGODB_DB][settings.MONGODB_COLLECTION]
def save_event(collection, event, timestamp, params):
""Save the event in MongoDB collection""
collection.insert({
'event': event,
'timestamp': datetime.fromtimestamp(timestamp),
'params': params
})
class Event(models.Model):
""Dummy model for development.""
timestamp = models.DateTimeField(auto_now_add=True)
event = models.SlugField()
params = models.TextField()
",1
"_license__ = 'GPL 2.0/LGPL 2.1'
__all__ = ('ensure_autodiscover', 'list_checkers', 'get_public_ip')
from pif.base import registry
from pif.discover import autodiscover
def ensure_autodiscover():
""""""
Ensures the IP checkers are discovered.
""""""
if not registry._registry:
autodiscover()
def list_checkers():
""""""
Lists available checkers.
:return list:
""""""
return registry._registry.keys()
def get_public_ip(preferred_checker=None, verbose=False):
""""""
Gets IP using one of the services.
:param str preffered checker: Checker UID. If given, the preferred checker is used.
:param bool verbose: If set to True, debug info is printed.
:return str:
""""""
ensure_autodiscover()
# If use preferred checker.
if preferred_checker:
ip_checker_cls = registry.get(preferred_checker)
if not ip_checker_cls:
return False
ip_checker = ip_checker_cls(verbose=verbose)
ip = ip_checker.get_public_ip()
if verbose:
print('provider: ', ip_checker_cls)
return ip
# Using all checkers.
for ip_checker_name, ip_checker_cls in registry._registry.items():
ip_checker = ip_checker_cls(verbose=verbose)
try:
ip = ip_checker.get_public_ip()
if ip:
if verbose:
print('provider: ', ip_checker_cls)
return ip
except Exception as e:
if verbose:
print(e)
return False
",1
"subprocess import Popen, PIPE, STDOUT
from numpy.distutils.fcompiler import FCompiler
from numpy.distutils.exec_command import exec_command
from numpy.distutils.misc_util import msvc_runtime_library
from numpy.distutils.compat import get_exception
compilers = ['GnuFCompiler', 'Gnu95FCompiler']
TARGET_R = re.compile(""Target: ([a-zA-Z0-9_\-]*)"")
# XXX: handle cross compilation
def is_win64():
return sys.platform == ""win32"" and platform.architecture()[0] == ""64bit""
if is_win64():
#_EXTRAFLAGS = [""-fno-leading-underscore""]
_EXTRAFLAGS = []
else:
_EXTRAFLAGS = []
class GnuFCompiler(FCompiler):
compiler_type = 'gnu'
compiler_aliases = ('g77',)
description = 'GNU Fortran 77 compiler'
def gnu_version_match(self, version_string):
""""""Handle the different versions of GNU fortran compilers""""""
# Strip warning(s) that may be emitted by gfortran
while version_string.startswith('gfortran: warning'):
version_string = version_string[version_string.find('\n')+1:]
# Gfortran versions from after 2010 will output a simple string
# (usually ""x.y"", ""x.y.z"" or ""x.y.z-q"") for ``-dumpversion``; older
# gfortrans may still return long version strings (``-dumpversion`` was
# an alias for ``--version``)
if len(version_string) <= 20:
# Try to find a valid version string
m = re.search(r'([0-9.]+)', version_string)
if m:
# g77 provides a longer version string that starts with GNU
# Fortran
if version_string.startswith('GNU Fortran'):
return ('g77', m.group(1))
# gfortran only outputs a version string such as #.#.#, so check
# if the match is at the start of the string
elif m.start() == 0:
return ('gfortran', m.group(1))
else:
# Output probably from --version, try harder:
m = re.search(r'GNU Fortran\s+95.*?([0-9-.]+)', version_string)
if m:
return ('gfortran', m.group(1))
m = re.search(r'GNU Fortran.*?\-?([0-9-.]+)', version_string)
if m:
v = m.group(1)
if v.startswith('0') or v.startswith('2') or v.startswith('3'):
# the '0' is for early g77's
return ('g77', v)
else:
# at some point in the 4.x series, the ' 95' was dropped
# from the version string
return ('gfortran', v)
# If still nothing, raise an error to make the problem easy to find.
err = 'A valid Fortran version was not found in this string:\n'
raise ValueError(err + version_string)
def version_match(self, version_string):
v = self.gnu_version_match(version_string)
if not v or v[0] != 'g77':
return None
return v[1]
possible_executables = ['g77', 'f77']
executables = {
'version_cmd' : [None, ""-dumpversion""],
'compiler_f77' : [None, ""-g"", ""-Wall"", ""-fno-second-underscore""],
'compiler_f90' : None, # Use --fcompiler=gnu95 for f90 codes
'compiler_fix' : None,
'linker_so' : [None, ""-g"", ""-Wall""],
'archiver' : [""ar"", ""-cr""],
'ranlib' : [""ranlib""],
'linker_exe' : [None, ""-g"", ""-Wall""]
}
module_dir_switch = None
module_include_switch = None
# Cygwin: f771: warning: -fPIC ignored for target (all code is
# position independent)
if os.name != 'nt' and sys.platform != 'cygwin':
pic_flags = ['-fPIC']
# use -mno-cygwin for g77 when Python is not Cygwin-Python
if sys.platform == 'win32':
for key in ['version_cmd', 'compiler_f77', 'linker_so', 'linker_exe']:
executables[key].append('-mno-cygwin')
g2c = 'g2c'
suggested_f90_compiler = 'gnu95'
def get_flags_linker_so(self):
opt = self.linker_so[1:]
if sys.platform == 'darwin':
target = os.environ.get('MACOSX_DEPLOYMENT_TARGET', None)
# If MACOSX_DEPLOYMENT_TARGET is set, we simply trust the value
# and leave it alone. But, distutils will complain if the
# environment's value is different from the one in the Python
# Makefile used to build Python. We let disutils handle this
# error checking.
if not target:
# If MACOSX_DEPLOYMENT_TARGET is not set in the environment,
# we try to get it first from the Python Makefile and then we
# fall back to setting it to 10.3 to maximize the set of
# versions we can work with. This is a reasonable default
# even when using the official Python dist and those derived
# from it.
import distutils.sysconfig as sc
g = {}
try:
get_makefile_filename = sc.get_makefile_filename
except AttributeError:
pass # i.e. PyPy
else:
filename = get_makefile_filename()
sc.parse_makefile(filename, g)
target = g.get('MACOSX_DEPLOYMENT_TARGET', '10.3')
os.environ['MACOSX_DEPLOYMENT_TARGET'] = target
if target == '10.3':
s = 'Env. variable MACOSX_DEPLOYMENT_TARGET set to 10.3'
warnings.warn(s, stacklevel=2)
opt.extend(['-undefined', 'dynamic_lookup', '-bundle'])
else:
opt.append(""-shared"")
if sys.platform.startswith('sunos'):
# SunOS often has dynamically loaded symbols defined in the
# static library libg2c.a The linker doesn't like this. To
# ignore the problem, use the -mimpure-text flag. It isn't
# the safest thing, but seems to work. 'man gcc' says:
# "".. Instead of using -mimpure-text, you should compile all
# source code with -fpic or -fPIC.""
opt.append('-mimpure-text')
return opt
def get_libgcc_dir(self):
status, output = exec_command(self.compiler_f77 +
['-print-libgcc-file-name'],
use_tee=0)
if not status:
return os.path.dirname(output)
return None
def get_library_dirs(self):
opt = []
if sys.platform[:5] != 'linux':
d = self.get_libgcc_dir()
if d:
# if windows and not cygwin, libg2c lies in a different folder
if sys.platform == 'win32' and not d.startswith('/usr/lib'):
d = os.path.normpath(d)
path = os.path.join(d, ""lib%s.a"" % self.g2c)
if not os.path.exists(path):
root = os.path.join(d, *((os.pardir,)*4))
d2 = os.path.abspath(os.path.join(root, 'lib'))
path = os.path.join(d2, ""lib%s.a"" % self.g2c)
if os.path.exists(path):
opt.append(d2)
opt.append(d)
return opt
def get_libraries(self):
opt = []
d = self.get_libgcc_dir()
if d is not None:
g2c = self.g2c + '-pic'
f = self.static_lib_format % (g2c, self.static_lib_extension)
if not os.path.isfile(os.path.join(d, f)):
g2c = self.g2c
else:
g2c = self.g2c
if g2c is not None:
opt.append(g2c)
c_compiler = self.c_compiler
if sys.platform == 'win32' and c_compiler and \
c_compiler.compiler_type == 'msvc':
# the following code is not needed (read: breaks) when using MinGW
# in case want to link F77 compiled code with MSVC
opt.append('gcc')
runtime_lib = msvc_runtime_library()
if runtime_lib:
opt.append(runtime_lib)
if sys.platform == 'darwin':
opt.append('cc_dynamic')
return opt
def get_flags_debug(self):
return ['-g']
def get_flags_opt(self):
v = self.get_version()
if v and v <= '3.3.3':
# With this compiler version building Fortran BLAS/LAPACK
# with -O3 caused failures in lib.lapack heevr,syevr tests.
opt = ['-O2']
else:
opt = ['-O3']
opt.append('-funroll-loops')
return opt
def _c_arch_flags(self):
"""""" Return detected arch flags from CFLAGS """"""
from distutils import sysconfig
try:
cflags = sysconfig.get_config_vars()['CFLAGS']
except KeyError:
return []
arch_re = re.compile(r""-arch\s+(\w+)"")
arch_flags = []
for arch in arch_re.findall(cflags):
arch_flags += ['-arch', arch]
return arch_flags
def get_flags_arch(self):
return []
def runtime_library_dir_option(self, dir):
sep = ',' if sys.platform == 'darwin' else '='
return '-Wl,-rpath%s""%s""' % (sep, dir)
class Gnu95FCompiler(GnuFCompiler):
compiler_type = 'gnu95'
compiler_aliases = ('gfortran',)
description = 'GNU Fortran 95 compiler'
def version_match(self, version_string):
v = self.gnu_version_match(version_string)
if not v or v[0] != 'gfortran':
return None
v = v[1]
if v >= '4.':
# gcc-4 series releases do not support -mno-cygwin option
pass
else:
# use -mno-cygwin flag for gfortran when Python is not
# Cygwin-Python
if sys.platform == 'win32':
for key in ['version_cmd', 'compiler_f77', 'compiler_f90',
'compiler_fix', 'linker_so', 'linker_exe']:
self.executables[key].append('-mno-cygwin')
return v
possible_executables = ['gfortran', 'f95']
executables = {
'version_cmd' : ["""", ""-dumpversion""],
'compiler_f77' : [None, ""-Wall"", ""-g"", ""-ffixed-form"",
""-fno-second-underscore""] + _EXTRAFLAGS,
'compiler_f90' : [None, ""-Wall"", ""-g"",
""-fno-second-underscore""] + _EXTRAFLAGS,
'compiler_fix' : [None, ""-Wall"", ""-g"",""-ffixed-form"",
""-fno-second-underscore""] + _EXTRAFLAGS,
'linker_so' : ["""", ""-Wall"", ""-g""],
'archiver' : [""ar"", ""-cr""],
'ranlib' : [""ranlib""],
'linker_exe' : [None, ""-Wall""]
}
module_dir_switch = '-J'
module_include_switch = '-I'
g2c = 'gfortran'
def _universal_flags(self, cmd):
""""""Return a list of -arch flags for every supported architecture.""""""
if not sys.platform == 'darwin':
return []
arch_flags = []
# get arches the C compiler gets.
c_archs = self._c_arch_flags()
if ""i386"" in c_archs:
c_archs[c_archs.index(""i386"")] = ""i686""
# check the arches the Fortran compiler supports, and compare with
# arch flags from C compiler
for arch in [""ppc"", ""i686"", ""x86_64"", ""ppc64""]:
if _can_target(cmd, arch) and arch in c_archs:
arch_flags.extend([""-arch"", arch])
return arch_flags
def get_flags(self):
flags = GnuFCompiler.get_flags(self)
arch_flags = self._universal_flags(self.compiler_f90)
if arch_flags:
flags[:0] = arch_flags
return flags
def get_flags_linker_so(self):
flags = GnuFCompiler.get_flags_linker_so(self)
arch_flags = self._universal_flags(self.linker_so)
if arch_flags:
flags[:0] = arch_flags
return flags
def get_library_dirs(self):
opt = GnuFCompiler.get_library_dirs(self)
if sys.platform == 'win32':
c_compiler = self.c_compiler
if c_compiler and c_compiler.compiler_type == ""msvc"":
target = self.get_target()
if target:
d = os.path.normpath(self.get_libgcc_dir())
root = os.path.join(d, *((os.pardir,)*4))
path = os.path.join(root, ""lib"")
mingwdir = os.path.normpath(path)
if os.path.exists(os.path.join(mingwdir, ""libmingwex.a"")):
opt.append(mingwdir)
return opt
def get_libraries(self):
opt = GnuFCompiler.get_libraries(self)
if sys.platform == 'darwin':
opt.remove('cc_dynamic')
if sys.platform == 'win32':
c_compiler = self.c_compiler
if c_compiler and c_compiler.compiler_type == ""msvc"":
if ""gcc"" in opt:
i = opt.index(""gcc"")
opt.insert(i+1, ""mingwex"")
opt.insert(i+1, ""mingw32"")
# XXX: fix this mess, does not work for mingw
if is_win64():
c_compiler = self.c_compiler
if c_compiler and c_compiler.compiler_type == ""msvc"":
return []
else:
pass
return opt
def get_target(self):
status, output = exec_command(self.compiler_f77 +
['-v'],
use_tee=0)
if not status:
m = TARGET_R.search(output)
if m:
return m.group(1)
return """"
def get_flags_opt(self):
if is_win64():
return ['-O0']
else:
return GnuFCompiler.get_flags_opt(self)
def _can_target(cmd, arch):
""""""Return true if the architecture supports the -arch flag""""""
newcmd = cmd[:]
fid, filename = tempfile.mkstemp(suffix="".f"")
os.close(fid)
try:
d = os.path.dirname(filename)
output = os.path.splitext(filename)[0] + "".o""
try:
newcmd.extend([""-arch"", arch, ""-c"", filename])
p = Popen(newcmd, stderr=STDOUT, stdout=PIPE, cwd=d)
p.communicate()
return p.returncode == 0
finally:
if os.path.exists(output):
os.remove(output)
finally:
os.remove(filename)
return False
if __name__ == '__main__':
from distutils import log
log.set_verbosity(2)
compiler = GnuFCompiler()
compiler.customize()
print(compiler.get_version())
try:
compiler = Gnu95FCompiler()
compiler.customize()
print(compiler.get_version())
except Exception:
msg = get_exception()
print(msg)
",1
"code_vars = lambda v: { 'req_url': 'http://%(domain)s.se/%(req_url)s' % v } )
hls = { 'title': 'UR-play', 'url': 'http://urplay.se/', 'feed_url': 'http://urplay.se/rss',
'items': [init_req,
TemplateRequest(
re = r'file_html5"":\s?""(?P[^""]+)"".*?""subtitles"":\s?""(?P[^"",]*)',
encode_vars = lambda v: { 'final_url': ('http://130.242.59.75/%(final_url)s/playlist.m3u8' % v).replace('\\', ''),
'suffix-hint': 'mp4',
'subtitles': v.get('subtitles', '').replace('\\', '') % v } )] }
rtmp = { 'items': [init_req,
TemplateRequest(
re = r'file_flash"":\s?""(?P[^""]+\.(?Pmp[34]))"".*?""subtitles"":\s?""(?P[^"",]*)',
encode_vars = lambda v: { 'final_url': ('rtmp://130.242.59.75/ondemand playpath=%(ext)s:/%(final_url)s app=ondemand' % v).replace('\\', ''),
'suffix-hint': 'flv',
'rtmpdump-realtime': True,
'subtitles': v.get('subtitles', '').replace('\\', '') % v } )] }
services = [hls, rtmp]",1
".getLogger(__name__)
class NoSensorsFoundException(RuntimeError):
pass
class Controller(metaclass=ABCMeta):
@abstractmethod
def run(self):
raise NotImplementedError
@abstractmethod
def enable(self):
raise NotImplementedError
@abstractmethod
def disable(self):
raise NotImplementedError
@abstractmethod
def valid(self) -> bool:
raise NotImplementedError
class InputDevice(metaclass=ABCMeta):
""""""
Abstract class for input devices.
""""""
def __init__(self, name):
self.name = name
self.values = ValueBuffer(name, 128)
@abstractmethod
def get_value(self) -> float:
raise NotImplementedError
class OutputDevice(metaclass=ABCMeta):
""""""
Abstract class for output devices.
""""""
def __init__(self, name):
self.name = name
self.values = ValueBuffer(name, 128)
def set_value(self, value: Union[int, float]):
self.values.update(value)
@abstractmethod
def apply(self):
raise NotImplementedError
@abstractmethod
def enable(self):
raise NotImplementedError
@abstractmethod
def disable(self):
raise NotImplementedError
class PassthroughController(Controller):
def __init__(self, inputs=Sequence[InputDevice], outputs=Sequence[OutputDevice], speeds=None):
self.inputs = list(inputs)
self.outputs = list(outputs)
def run(self):
for idx, input_reader in enumerate(self.inputs):
output = self.outputs[idx]
output.name = input_reader.name
output.values.name = input_reader.name
output.set_value(input_reader.get_value())
output.apply()
log.debug('ran loop')
def apply_candidates(self):
return self.outputs
def enable(self):
for output_dev in self.outputs:
output_dev.enable()
def disable(self):
for output_dev in self.outputs:
output_dev.disable()
def valid(self) -> bool:
return bool(self.inputs and self.outputs) and len(self.inputs) == len(self.outputs)
class DummyInput(InputDevice):
def __init__(self):
super().__init__('dummy')
self.temp = 0
def get_value(self):
return self.temp
def set_value(self, value):
self.temp = value
class DummyOutput(OutputDevice):
def __init__(self):
super().__init__('dummy')
self.speed = None
self.enabled = False
def apply(self):
if self.enabled:
self.speed = round(self.values.mean())
def enable(self):
self.enabled = True
def disable(self):
self.enabled = False
def mean(seq: Iterable) -> float:
if not isinstance(seq, Iterable):
raise ValueError('provided sequence MUST be iterable')
if not isinstance(seq, Sequence):
seq = list(seq)
if len(seq) == 1:
return float(seq[0])
if len(seq) == 0:
raise ValueError('sequence must have at least one value.')
return sum(seq) / len(seq)
def lerp(value: Union[float, int], input_min: Union[float, int], input_max: Union[float, int], output_min: Union[float, int], output_max: Union[float, int]) -> float:
if value <= input_min:
return float(output_min)
if value >= input_max:
return float(output_max)
return (output_min * (input_max - value) + output_max * (value - input_min)) / (input_max - input_min)
def lerp_range(seq: Iterable[Union[float, int]], input_min, input_max, output_min, output_max) -> List[float]:
return [lerp(val, input_min, input_max, output_min, output_max) for val in seq]
class ValueBuffer:
def __init__(self, name, default_value=0.0):
self.name = name
self.buffer = deque(maxlen=32)
self._default_value = default_value
def update(self, value: float):
self.buffer.append(value)
def mean(self) -> float:
try:
return mean(self.buffer)
except (ValueError, ZeroDivisionError):
return self._default_value
",1
"s.has_module(module):
raise HTTP(404, body=""Module disabled: %s"" % module)
# -----------------------------------------------------------------------------
def index():
"""""" Module's Home Page """"""
return s3db.cms_index(module, alt_function=""index_alt"")
# -----------------------------------------------------------------------------
def index_alt():
""""""
Module homepage for non-Admin users when no CMS content found
""""""
# @ToDo: Move this to the Template (separate deployment_setting or else a customise for non-REST controllers)
template = settings.get_template()
if template == ""SandyRelief"":
# Just redirect to the Facilities
redirect(URL(f=""facility""))
else:
# Just redirect to the list of Organisations
redirect(URL(f=""organisation""))
# -----------------------------------------------------------------------------
def group():
"""""" RESTful CRUD controller """"""
return s3_rest_controller(rheader = s3db.org_rheader)
# -----------------------------------------------------------------------------
def region():
"""""" RESTful CRUD controller """"""
return s3_rest_controller()
# -----------------------------------------------------------------------------
def sector():
"""""" RESTful CRUD controller """"""
# Pre-processor
def prep(r):
# Location Filter
s3db.gis_location_filter(r)
return True
s3.prep = prep
return s3_rest_controller()
# -----------------------------------------------------------------------------
def subsector():
"""""" RESTful CRUD controller """"""
return s3_rest_controller()
# -----------------------------------------------------------------------------
def site():
""""""
RESTful CRUD controller
- used by S3SiteAutocompleteWidget
which doesn't yet support filtering to just updateable sites
- used by site_contact_person()
- used by S3OptionsFilter (e.g. Asset Log)
""""""
# Pre-processor
def prep(r):
if r.representation != ""json"" and \
r.method not in (""search_ac"", ""search_address_ac"", ""site_contact_person""):
return False
# Location Filter
s3db.gis_location_filter(r)
return True
s3.prep = prep
return s3_rest_controller()
# -----------------------------------------------------------------------------
def sites_for_org():
""""""
Used to provide the list of Sites for an Organisation
- used in User Registration
""""""
try:
org = request.args[0]
except:
result = current.xml.json_message(False, 400, ""No Org provided!"")
else:
stable = s3db.org_site
if settings.get_org_branches():
# Find all branches for this Organisation
btable = s3db.org_organisation_branch
query = (btable.organisation_id == org) & \
(btable.deleted != True)
rows = db(query).select(btable.branch_id)
org_ids = [row.branch_id for row in rows] + [org]
query = (stable.organisation_id.belongs(org_ids)) & \
(stable.deleted != True)
else:
query = (stable.organisation_id == org) & \
(stable.deleted != True)
rows = db(query).select(stable.site_id,
stable.name,
orderby=stable.name)
result = rows.json()
finally:
response.headers[""Content-Type""] = ""application/json""
return result
# -----------------------------------------------------------------------------
def facility():
"""""" RESTful CRUD controller """"""
return s3db.org_facility_controller()
# -----------------------------------------------------------------------------
def facility_type():
"""""" RESTful CRUD controller """"""
return s3_rest_controller()
# -----------------------------------------------------------------------------
def office_type():
"""""" RESTful CRUD controller """"""
return s3_rest_controller()
# -----------------------------------------------------------------------------
def organisation_type():
"""""" RESTful CRUD controller """"""
return s3_rest_controller()
# -----------------------------------------------------------------------------
def organisation():
"""""" RESTful CRUD controller """"""
# Defined in the Model for use from Multiple Controllers for unified menus
return s3db.org_organisation_controller()
# -----------------------------------------------------------------------------
def org_search():
""""""
Organisation REST controller
- limited to just search_ac for use in Autocompletes
- allows differential access permissions
""""""
s3.prep = lambda r: r.method == ""search_ac""
return s3_rest_controller(module, ""organisation"")
# -----------------------------------------------------------------------------
def organisation_list_represent(l):
organisation_represent = s3db.org_organisation_represent
if l:
max_length = 4
if len(l) > max_length:
return ""%s, etc"" % \
organisation_represent.multiple(l[:max_length])
else:
return organisation_represent.multiple(l)
else:
return NONE
# -----------------------------------------------------------------------------
def office():
"""""" RESTful CRUD controller """"""
# Defined in the Model for use from Multiple Controllers for unified menus
return s3db.org_office_controller()
# -----------------------------------------------------------------------------
def person():
"""""" Person controller for AddPersonWidget """"""
def prep(r):
if r.representation != ""s3json"":
# Do not serve other representations here
return False
else:
current.xml.show_ids = True
return True
s3.prep = prep
return s3_rest_controller(""pr"", ""person"")
# -----------------------------------------------------------------------------
def room():
"""""" RESTful CRUD controller """"""
return s3_rest_controller()
# -----------------------------------------------------------------------------
def mailing_list():
"""""" RESTful CRUD controller """"""
tablename = ""pr_group""
table = s3db[tablename]
# Only groups with a group_type of 5
s3.filter = (table.group_type == 5)
table.group_type.writable = False
table.group_type.readable = False
table.name.label = T(""Mailing List Name"")
s3.crud_strings[tablename] = s3.pr_mailing_list_crud_strings
# define the list_fields
list_fields = s3db.configure(tablename,
list_fields = [""id"",
""name"",
""description"",
])
# Components
_rheader = s3db.pr_rheader
_tabs = [(T(""Organization""), ""organisation/""),
(T(""Mailing List Details""), None),
]
if len(request.args) > 0:
_tabs.append((T(""Members""), ""group_membership""))
if ""viewing"" in request.vars:
tablename, record_id = request.vars.viewing.rsplit(""."", 1)
if tablename == ""org_organisation"":
table = s3db[tablename]
_rheader = s3db.org_rheader
_tabs = []
s3db.add_components(""pr_group"", pr_group_membership=""group_id"")
rheader = lambda r: _rheader(r, tabs = _tabs)
return s3_rest_controller(""pr"",
""group"",
rheader=rheader)
# -----------------------------------------------------------------------------
def donor():
"""""" RESTful CRUD controller """"""
tablename = ""org_donor""
table = s3db[tablename]
tablename = ""org_donor""
s3.crud_strings[tablename] = Storage(
label_create = ADD_DONOR,
title_display = T(""Donor Details""),
title_list = T(""Donors Report""),
title_update = T(""Edit Donor""),
label_list_button = T(""List Donors""),
label_delete_button = T(""Delete Donor""),
msg_record_created = T(""Donor added""),
msg_record_modified = T(""Donor updated""),
msg_record_deleted = T(""Donor deleted""),
msg_list_empty = T(""No Donors currently registered""))
s3db.configure(tablename, listadd=False)
output = s3_rest_controller()
return output
# -----------------------------------------------------------------------------
def resource():
"""""" RESTful CRUD controller """"""
def prep(r):
if r.interactive:
if r.method in (""create"", ""update""):
# Context from a Profile page?""
table = r.table
location_id = request.get_vars.get(""(location)"", None)
if location_id:
field = table.location_id
field.default = location_id
field.readable = field.writable = False
organisation_id = request.get_vars.get(""(organisation)"", None)
if organisation_id:
field = table.organisation_id
field.default = organisation_id
field.readable = field.writable = False
return True
s3.prep = prep
return s3_rest_controller()
# -----------------------------------------------------------------------------
def resource_type():
"""""" RESTful CRUD controller """"""
return s3_rest_controller()
# -----------------------------------------------------------------------------
def service():
"""""" RESTful CRUD controller """"""
return s3_rest_controller()
# -----------------------------------------------------------------------------
def req_match():
"""""" Match Requests for Sites """"""
return s3db.req_match()
# -----------------------------------------------------------------------------
def incoming():
""""""
Incoming Shipments for Sites
@unused
""""""
return inv_incoming()
# -----------------------------------------------------------------------------
def facility_geojson():
""""""
Create GeoJSON[P] of Facilities for use by a high-traffic website
- controller just for testing
- function normally run on a schedule
""""""
s3db.org_facility_geojson()
# END =========================================================================
",1
"e.ConfigFile(""test.cfg"")
cfg.setCfgValue(""name1"", ""value1"")
cfg.setCfgValue(""name2"", ""value2"")
cfg.selectSection(""user"")
cfg.setCfgValue(""username"", ""janis"")
cfg.setCfgValue(""acceptable_names"", [""john"", ""janis""])
cfg.load()
print cfg.cfg.options(""main"")
print cfg.cfg.options(""user"")
print cfg.getCfgValue(""username"")
print type(cfg.getCfgValue(""username""))
print cfg.getCfgValueAsList(""acceptable_names"")
print cfg.getCfgValueAsList(""list_in_list"")
cfg.selectSection(""main"")
print cfg.getCfgValueAsInt(""a_number"")
print type(cfg.getCfgValueAsInt(""a_number""))
print cfg.getCfgValueAsBool(""a_bool"")
print type(cfg.getCfgValueAsBool(""a_bool""))
cfg.filename = ""test-mod.cfg""
cfg.selectSection(""main"")
cfg.setCfgValue(""name1"", ""value1mod2"")
cfg.setCfgValue(""a_number"", 14)
cfg.selectSection(""user"")
cfg.setCfgValue(""acceptable_names"", [""john"", ""janis"", ""ivan""])
cfg.setCfgValue(""list_in_list2"", [""[baz]"", ""[foo, bar]""])
cfg.setCfgValue(""list_in_list3"", [""first"", ""[second-one, second-third]""])
cfg.save()
",1
" mode=""rt"", encoding=""utf-8"") as f:
s = f.read()
# go to beginning
f.seek(0)
return s
@staticmethod
def read_beginning(path, lines):
with io.open(path, mode=""rt"", encoding=""utf-8"") as f:
s = f.read(lines)
# go to beginning
f.seek(0)
return s
@staticmethod
def read_lines(path):
with io.open(path, mode=""rt"", encoding=""utf-8"") as f:
content = f.readlines()
return content
@staticmethod
def write(contents, path):
if isPython3:
with open(path, mode=""wt"", encoding=""utf-8"") as f:
# truncate previous contents
f.truncate()
f.write(contents)
else:
with io.open(path, mode=""wt"", encoding=""utf-8"") as f:
# truncate previous contents
f.truncate()
f.write(contents.decode(""utf8""))
@staticmethod
def write_lines(lines, path):
if isPython3:
with open(path, mode=""wt"", encoding=""utf-8"") as f:
f.writelines([l + ""\n"" for l in lines])
else:
with io.open(path, mode=""wt"") as f:
for line in lines:
f.writelines(line.decode(""utf8"") + ""\n"")
@staticmethod
def add_content(contents, path):
if isPython3:
with open(path, mode=""a"", encoding=""utf-8"") as f:
f.writelines(contents)
else:
with io.open(path, mode=""a"") as f:
f.writelines(contents.decode(""utf8""))
",1
"m['title'])
if not (chp or vol) or ""preview"" in item['title'].lower():
return None
tagmap = [
('FW', 'Fortunate Wife', 'translated'),
('PRC', 'PRC', 'translated'),
('Loiterous', 'Loiterous', 'oel'),
]
for tagname, name, tl_type in tagmap:
if tagname in item['tags']:
return buildReleaseMessageWithType(item, name, vol, chp, frag=frag, postfix=postfix, tl_type=tl_type)
return False",1
"earFunction(function.Function):
def check_type_forward(self, in_types):
n_in = type_check.eval(in_types.size())
if n_in != 3 and n_in != 6:
raise type_check.InvalidType(
'%s or %s' % (in_types.size() == 3, in_types.size() == 6),
'%s == %s' % (in_types.size(), n_in))
e1_type, e2_type, W_type = in_types[:3]
type_check_prod = type_check.make_variable(numpy.prod, 'prod')
type_check.expect(
e1_type.dtype == numpy.float32,
e1_type.ndim >= 2,
e2_type.dtype == numpy.float32,
e2_type.ndim >= 2,
e1_type.shape[0] == e2_type.shape[0],
W_type.dtype == numpy.float32,
W_type.ndim == 3,
type_check_prod(e1_type.shape[1:]) == W_type.shape[0],
type_check_prod(e2_type.shape[1:]) == W_type.shape[1],
)
if n_in == 6:
out_size = W_type.shape[2]
V1_type, V2_type, b_type = in_types[3:]
type_check.expect(
V1_type.dtype == numpy.float32,
V1_type.ndim == 2,
V1_type.shape[0] == W_type.shape[0],
V1_type.shape[1] == out_size,
V2_type.dtype == numpy.float32,
V2_type.ndim == 2,
V2_type.shape[0] == W_type.shape[1],
V2_type.shape[1] == out_size,
b_type.dtype == numpy.float32,
b_type.ndim == 1,
b_type.shape[0] == out_size,
)
def forward(self, inputs):
e1 = array.as_mat(inputs[0])
e2 = array.as_mat(inputs[1])
W = inputs[2]
if not type_check.same_types(*inputs):
raise ValueError('numpy and cupy must not be used together\n'
'type(W): {0}, type(e1): {1}, type(e2): {2}'
.format(type(W), type(e1), type(e2)))
xp = cuda.get_array_module(*inputs)
if xp is numpy:
y = numpy.einsum('ij,ik,jkl->il', e1, e2, W)
else:
i_len, j_len = e1.shape
k_len = e2.shape[1]
# 'ij,ik->ijk'
e1e2 = e1[:, :, None] * e2[:, None, :]
# ijk->i[jk]
e1e2 = e1e2.reshape(i_len, j_len * k_len)
# jkl->[jk]l
W_mat = W.reshape(-1, W.shape[2])
# 'i[jk],[jk]l->il'
y = e1e2.dot(W_mat)
if len(inputs) == 6:
V1, V2, b = inputs[3:]
y += e1.dot(V1)
y += e2.dot(V2)
y += b
return y,
def backward(self, inputs, grad_outputs):
e1 = array.as_mat(inputs[0])
e2 = array.as_mat(inputs[1])
W = inputs[2]
gy = grad_outputs[0]
xp = cuda.get_array_module(*inputs)
if xp is numpy:
gW = numpy.einsum('ij,ik,il->jkl', e1, e2, gy)
ge1 = numpy.einsum('ik,jkl,il->ij', e2, W, gy)
ge2 = numpy.einsum('ij,jkl,il->ik', e1, W, gy)
else:
kern = cuda.reduce('T in0, T in1, T in2', 'T out',
'in0 * in1 * in2', 'a + b', 'out = a', 0,
'bilinear_product')
e1_b = e1[:, :, None, None] # ij
e2_b = e2[:, None, :, None] # ik
gy_b = gy[:, None, None, :] # il
W_b = W[None, :, :, :] # jkl
gW = kern(e1_b, e2_b, gy_b, axis=0) # 'ij,ik,il->jkl'
ge1 = kern(e2_b, W_b, gy_b, axis=(2, 3)) # 'ik,jkl,il->ij'
ge2 = kern(e1_b, W_b, gy_b, axis=(1, 3)) # 'ij,jkl,il->ik'
ret = ge1.reshape(inputs[0].shape), ge2.reshape(inputs[1].shape), gW
if len(inputs) == 6:
V1, V2, b = inputs[3:]
gV1 = e1.T.dot(gy)
gV2 = e2.T.dot(gy)
gb = gy.sum(0)
ge1 += gy.dot(V1.T)
ge2 += gy.dot(V2.T)
ret += gV1, gV2, gb
return ret
def bilinear(e1, e2, W, V1=None, V2=None, b=None):
""""""Applies a bilinear function based on given parameters.
This is a building block of Neural Tensor Network (see the reference paper
below). It takes two input variables and one or four parameters, and
outputs one variable.
To be precise, denote six input arrays mathematically by
:math:`e^1\\in \\mathbb{R}^{I\\cdot J}`,
:math:`e^2\\in \\mathbb{R}^{I\\cdot K}`,
:math:`W\\in \\mathbb{R}^{J \\cdot K \\cdot L}`,
:math:`V^1\\in \\mathbb{R}^{J \\cdot L}`,
:math:`V^2\\in \\mathbb{R}^{K \\cdot L}`, and
:math:`b\\in \\mathbb{R}^{L}`,
where :math:`I` is mini-batch size.
In this document, we call :math:`V^1`, :math:`V^2`, and :math:`b` linear
parameters.
The output of forward propagation is calculated as
.. math::
y_{il} = \\sum_{jk} e^1_{ij} e^2_{ik} W_{jkl} + \\
\\sum_{j} e^1_{ij} V^1_{jl} + \\sum_{k} e^2_{ik} V^2_{kl} + b_{l}.
Note that V1, V2, b are optional. If these are not given, then this
function omits the last three terms in the above equation.
.. note::
This function accepts an input variable ``e1`` or ``e2`` of a non-matrix
array. In this case, the leading dimension is treated as the batch
dimension, and the other dimensions are reduced to one dimension.
.. note::
In the original paper, :math:`J` and :math:`K`
must be equal and the author denotes :math:`[V^1 V^2]`
(concatenation of matrices) by :math:`V`.
Args:
e1 (~chainer.Variable): Left input variable.
e2 (~chainer.Variable): Right input variable.
W (~chainer.Variable): Quadratic weight variable.
V1 (~chainer.Variable): Left coefficient variable.
V2 (~chainer.Variable): Right coefficient variable.
b (~chainer.Variable): Bias variable.
Returns:
~chainer.Variable: Output variable.
See:
`Reasoning With Neural Tensor Networks for Knowledge Base Completion
`_ [Socher+, NIPS2013].
""""""
flags = [V1 is None, V2 is None, b is None]
if any(flags):
if not all(flags):
raise ValueError('All coefficients and bias for bilinear() must '
'be None, if at least one of them is None.')
return BilinearFunction()(e1, e2, W)
else:
return BilinearFunction()(e1, e2, W, V1, V2, b)
",1
"= (a*a)%MOD
b /= 2
return res
fn = [1 for _ in xrange(100001)]
ifn = [1 for _ in xrange(100001)]
for i in range(1,100000):
fn[i] = fn[i-1] * i
fn[i] %= MOD
ifn[i] = modexp(fn[i],MOD-2)
def nCr(n,k):
return fn[n] * ifn[k] * ifn[n-k]
for ti in range(t):
n = int(raw_input())
a = map(int,raw_input().split())
ans = 0
for i in range(n):
if i%2==0:
ans += nCr(n-1,i)%MOD * a[i]%MOD
else:
ans -= nCr(n-1,i)%MOD * a[i]%MOD
ans %= MOD
print ans",1
"clude queueing time inside BitFunnel nor does it include head-of-line blocking queue waiting time on the queue into BitFunnel.
import csv
filename = ""/tmp/QueryPipelineStatistics.csv""
times = []
with open(filename) as f:
reader = csv.reader(f)
header = next(reader)
assert header == ['query',
'rows',
'matches',
'quadwords',
'cachelines',
'parse',
'plan',
'match']
for row in reader:
total_time = float(row[-1]) + float(row[-2]) + float(row[-3])
times.append(total_time)
times.sort(reverse=True)
idx_max = len(times) - 1
idx = [round(idx_max / 2),
round(idx_max / 10),
round(idx_max / 100),
round(idx_max / 1000),
0]
tails = [times[x] for x in idx]
print(tails)
",1
"re two nodes of the binary tree
and A is ancestor of B. Expected time complexity is O(n).
""""""
class Node:
def __init__(self, data, left=None, right=None):
self.data = data
self.left = left
self.right = right
def add_left_child(self, data):
self.left = Node(data)
return self.left
def add_right_child(self, data):
self.right = Node(data)
return self.right
class BinaryTree:
def __init__(self, root):
self.root = root
self.max_difference = -float('inf')
def max_difference_node_and_ancestor(self):
self.max_min_in_subtree(self.root)
return self.max_difference
def max_min_in_subtree(self, node):
if node is None:
return float('inf'), -float('inf')
left_min, left_max = self.max_min_in_subtree(node.left)
right_min, right_max = self.max_min_in_subtree(node.right)
if node.left:
self.max_difference = max(self.max_difference, node.data - left_min, node.data - left_max)
if node.right:
self.max_difference = max(self.max_difference, node.data - right_min, node.data - right_max)
return min(node.data, left_min, right_min), max(node.data, left_max, right_max)
class TestBinaryTree(unittest.TestCase):
def test_max_difference(self):
root = Node(8)
root.left = Node(3)
root.left.left = Node(1)
root.left.right = Node(6)
root.left.right.left = Node(4)
root.left.right.right = Node(7)
root.right = Node(10)
root.right.right = Node(14)
root.right.right.left = Node(13)
binary_tree = BinaryTree(root)
self.assertEqual(binary_tree.max_difference_node_and_ancestor(), 7)
",1
"from queue import Queue
from threading import Thread
import time
class SetQueue(Queue):
def _init(self, maxsize):
Queue._init(self, maxsize)
self.all_items = set()
def _put(self, item):
if item not in self.all_items:
Queue._put(self, item)
self.all_items.add(item)
def signal_handler(signal, frame):
print('You pressed Ctrl+C!')
sys.exit(0)
def usage():
""""""usage de la ligne de commande""""""
print (""usage : "" + sys.argv[0] + ""-h --help -s --server someurl.com -u --user login -p --password password"")
def getAtomFeed(url, login, pwd):
# var
MAX_TRY = 10
essai = 0
# get atom document
while essai < MAX_TRY:
try:
r = requests.get('http://' + url, auth=(login,pwd), timeout=10)
except:
essai += 1
continue
break
else:
raise ('Erreur lors de la requête')
# parse atom document
try:
dom = xml.dom.minidom.parseString(r.text)
except:
raise ('Erreur lors du parsing du document Atom')
return dom
def getManagerInfo(atomFeed):
try:
entries = atomFeed.getElementsByTagName('entry')[1]
except:
return None
try:
managerId = entries.getElementsByTagName('snx:userid')[0]
return managerId.firstChild.data
except:
return None
def buildUrlSearchList(server, login, pwd, q):
# var
alphabet = ['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
#alphabet = ['a']
for i in alphabet:
url = server + '/profiles/atom/search.do?search=' + i + '*&ps=250'
dom = getAtomFeed(url, login, pwd)
totalResult = dom.getElementsByTagName('opensearch:totalResults')[0]
totalResult = int(totalResult.firstChild.data)
if totalResult > 250:
nbPage = int(float(totalResult) / 250) + 1
for n in range(1,nbPage,1):
item = url + ""&page="" + str(n)
q.put(item)
else:
nbPage = 1
q.put(url)
def getUserIdsWorker(login, pwd, qin, qout):
while True:
url = qin.get()
if url == None:
break
qin.task_done()
try:
dom = getAtomFeed(url, login, pwd)
except:
continue
userIds = dom.getElementsByTagName('snx:userid')
for index, item, in enumerate(userIds):
qout.put(item.firstChild.data)
def getRelationsWorker(server, login, pwd, qin, qout, getManager, qmgmt):
while True:
userid = qin.get()
if userid == None:
break
qin.task_done()
url = server + '/profiles/atom/connections.do?userid=' + userid + '&connectionType=colleague&ps=250'
try:
dom = getAtomFeed(url, login, pwd)
except:
continue
feed = dom.firstChild
entries = feed.getElementsByTagName('entry')
for entry in entries:
# get date
dateRelation = entry.getElementsByTagName('updated')[0]
dateRelation = dateRelation.firstChild.data
dateRelation = dateRelation[:10]
# get author user id
author = entry.getElementsByTagName('author')[0]
try:
authorName = author.getElementsByTagName('name')[0]
authorName = authorName.firstChild.data
except:
authorName = """"
try:
authorEMail = author.getElementsByTagName('email')[0]
authorEMail = authorEMail.firstChild.data
except:
authorEMail = """"
authorUserId = author.getElementsByTagName('snx:userid')[0]
authorUserId = authorUserId.firstChild.data
# get contributor user id
contributor = entry.getElementsByTagName('contributor')[0]
try:
contribName = contributor.getElementsByTagName('name')[0]
contribName = contribName.firstChild.data
except:
contribName = """"
try:
contribEMail = contributor.getElementsByTagName('email')[0]
contribEMail = contribEMail.firstChild.data
except:
contribEMail = """"
contribUserId = contributor.getElementsByTagName('snx:userid')[0]
contribUserId = contribUserId.firstChild.data
# build dict
authorInfo = { ""userid"" : authorUserId, ""name"" : authorName, ""email"" : authorEMail }
contribInfo = { ""userid"" : contribUserId, ""name"" : contribName, ""email"" : contribEMail }
relation = ""\"""" + authorUserId + ""\"",\"""" + contribUserId + ""\"",\""<("" + str(dateRelation) + "",Infinity)>\""""
qout.put(authorInfo)
qout.put(contribInfo)
qout.put(relation)
# get manager
if getManager == True:
url = server + ""/profiles/atom/reportingChain.do?userid="" + userid
rc = getAtomFeed(url, login, pwd)
managerId = getManagerInfo(rc)
if managerId is not None:
reportingChain = str(userid) + "","" + str(managerId)
qmgmt.put(reportingChain)
def printStatusThread(q0, q1, q2, q3):
strtime = time.time()
while True:
sys.stdout.write('\r\x1b[K')
sys.stdout.write(""urls:"" + str(q0.qsize()) + "" | "")
sys.stdout.write(""userids:"" + str(q1.qsize()) + "" | "")
sys.stdout.write(""user infos:"" + str(q2.qsize()) + "" | "")
sys.stdout.write(""manager infos:"" + str(q3.qsize()))
sys.stdout.flush()
time.sleep(1)
def writeFileThread(usersFilename, relationsFilename, qin):
# file for user details
u = open(usersFilename + "".csv"", ""w"")
u.write(""Id,Label,eMail\n"")
# file for relations
r = open(relationsFilename + "".csv"", ""w"")
r.write(""Source,Target,Time Interval\n"")
doneUsers = []
while True:
data = qin.get()
if data == None:
u.flush()
r.flush()
u.close()
r.close()
break
# write data
if type(data) is dict:
string = str(data[""userid""]) + ',' + str(data[""name""]) + ',' + str(data[""email""])
if string not in doneUsers:
u.write(string + ""\n"")
doneUsers.append(string)
elif type(data) is str:
r.write(str(data) + ""\n"")
qin.task_done()
def writeManagerFileThread(managerFilename, qin):
m = open(managerFilename + "".csv"", ""w"")
m.write(""Source,Target\n"")
while True:
data = qin.get()
if data == None:
break
m.write(str(data) + ""\n"")
qin.task_done()
def main(argv):
# global
serverUrl = """"
login = """"
pwd = """"
getManager = False
urlQueue = SetQueue(maxsize=5000)
userIdsQueue = SetQueue(maxsize=5000)
userInfosQueue = Queue(maxsize=5000)
userManagerQueue = Queue(maxsize=5000)
# signal handler
signal.signal(signal.SIGINT, signal_handler)
# retrive arguments
try:
opts, args = getopt.getopt(argv, ""hs:u:p:m"", [""help"", ""server="", ""user="", ""password="", ""manager""])
for opt, arg in opts:
if opt in (""-h"", ""--help""):
usage()
sys.exit()
elif opt in (""-s"", ""--server""):
serverUrl = arg
elif opt in (""-u"", ""--user""):
login = arg
elif opt in (""-p"", ""--password""):
pwd = arg
elif opt in (""-m"", ""--manager""):
getManager = True
except:
usage()
sys.exit()
# threading get userinfo worker
userIdWorker = []
for i in range(10):
w1 = Thread(target=getUserIdsWorker, args=(login, pwd, urlQueue, userIdsQueue,))
w1.setDaemon(True)
w1.start()
userIdWorker.append(w1)
# threading get relations worker
userInfoWorker = []
for i in range(20):
w2 = Thread(target=getRelationsWorker, args=(serverUrl, login, pwd, userIdsQueue, userInfosQueue, getManager, userManagerQueue,))
w2.setDaemon(True)
w2.start()
userInfoWorker.append(w2)
# thread to print size of queue
w3 = Thread(target=printStatusThread, args=(urlQueue, userIdsQueue, userInfosQueue, userManagerQueue,))
w3.setDaemon(True)
w3.start()
# thread to write files
w4 = Thread(target=writeFileThread, args=(""users"", ""relations"", userInfosQueue,))
w4.setDaemon(True)
w4.start()
if getManager == True:
w5 = Thread(target=writeManagerFileThread, args=(""manager"", userManagerQueue,))
w5.setDaemon(True)
w5.start()
# build Queue url list
MAX_TRY = 10
essai = 0
while essai < MAX_TRY:
try:
buildUrlSearchList(serverUrl, login, pwd, urlQueue)
except KeyboardInterrupt:
break
except:
essai += 1
continue
break
while not (urlQueue.empty() and userIdsQueue.empty() and userInfosQueue.empty()):
pass
print (""end threads"")
urlQueue.put(None)
userIdsQueue.put(None)
userInfosQueue.put(None)
# end of workers
for i in userIdWorker:
i.join()
for i in userInfoWorker:
i.join()
time.sleep(5)
sys.exit(0)
if __name__ == '__main__':
main(sys.argv[1:])
",1
"and raise the ErrorResponse instance if an error is encountered.
:param f:
:return:
""""""
def inner(*args, **kwargs):
warn('`raise_for_error` is deprecated and will not process any response content.')
return f(*args, **kwargs)
# e = ErrorResponse.load(content)
# e.raise_for_error()
# return content
return inner
def raise_response_for_error(f):
""""""
Wrapper method to parse a response object and raise the ErrorResponse
instance if an error is encountered in the response body.
:param f:
:return:
""""""
def inner(*args, **kwargs):
warn('`raise_response_for_error` is deprecated and will not process any response content.')
return f(*args, **kwargs)
return inner
",1
"ptional expression like ""field1=\'newvalue\'"". You cannot update or delete the results of a JOIN',
'%Y-%m-%d': '%Y.%m.%d.',
'%Y-%m-%d %H:%M:%S': '%Y.%m.%d. %H:%M:%S',
'%s rows deleted': '%s sorok t\xc3\xb6rl\xc5\x91dtek',
'%s rows updated': '%s sorok friss\xc3\xadt\xc5\x91dtek',
'Available databases and tables': 'El\xc3\xa9rhet\xc5\x91 adatb\xc3\xa1zisok \xc3\xa9s t\xc3\xa1bl\xc3\xa1k',
'Cannot be empty': 'Nem lehet \xc3\xbcres',
'Check to delete': 'T\xc3\xb6rl\xc3\xa9shez v\xc3\xa1laszd ki',
'Client IP': 'Client IP',
'Controller': 'Controller',
'Copyright': 'Copyright',
'Current request': 'Jelenlegi lek\xc3\xa9rdez\xc3\xa9s',
'Current response': 'Jelenlegi v\xc3\xa1lasz',
'Current session': 'Jelenlegi folyamat',
'DB Model': 'DB Model',
'Database': 'Adatb\xc3\xa1zis',
'Delete:': 'T\xc3\xb6r\xc3\xb6l:',
'Description': 'Description',
'E-mail': 'E-mail',
'Edit': 'Szerkeszt',
'Edit This App': 'Alkalmaz\xc3\xa1st szerkeszt',
'Edit current record': 'Aktu\xc3\xa1lis bejegyz\xc3\xa9s szerkeszt\xc3\xa9se',
'First name': 'First name',
'Group ID': 'Group ID',
'Hello World': 'Hello Vil\xc3\xa1g',
'Import/Export': 'Import/Export',
'Index': 'Index',
'Internal State': 'Internal State',
'Invalid Query': 'Hib\xc3\xa1s lek\xc3\xa9rdez\xc3\xa9s',
'Invalid email': 'Invalid email',
'Last name': 'Last name',
'Layout': 'Szerkezet',
'Main Menu': 'F\xc5\x91men\xc3\xbc',
'Menu Model': 'Men\xc3\xbc model',
'Name': 'Name',
'New Record': '\xc3\x9aj bejegyz\xc3\xa9s',
'No databases in this application': 'Nincs adatb\xc3\xa1zis ebben az alkalmaz\xc3\xa1sban',
'Origin': 'Origin',
'Password': 'Password',
'Powered by': 'Powered by',
'Query:': 'Lek\xc3\xa9rdez\xc3\xa9s:',
'Record ID': 'Record ID',
'Registration key': 'Registration key',
'Reset Password key': 'Reset Password key',
'Role': 'Role',
'Rows in table': 'Sorok a t\xc3\xa1bl\xc3\xa1ban',
'Rows selected': 'Kiv\xc3\xa1lasztott sorok',
'Stylesheet': 'Stylesheet',
'Sure you want to delete this object?': 'Biztos t\xc3\xb6rli ezt az objektumot?',
'Table name': 'Table name',
'The ""query"" is a condition like ""db.table1.field1==\'value\'"". Something like ""db.table1.field1==db.table2.field2"" results in a SQL JOIN.': 'The ""query"" is a condition like ""db.table1.field1==\'value\'"". Something like ""db.table1.field1==db.table2.field2"" results in a SQL JOIN.',
'Timestamp': 'Timestamp',
'Update:': 'Friss\xc3\xadt:',
'Use (...)&(...) for AND, (...)|(...) for OR, and ~(...) for NOT to build more complex queries.': 'Use (...)&(...) for AND, (...)|(...) for OR, and ~(...) for NOT to build more complex queries.',
'User ID': 'User ID',
'View': 'N\xc3\xa9zet',
'Welcome to web2py': 'Isten hozott a web2py-ban',
'appadmin is disabled because insecure channel': 'az appadmin a biztons\xc3\xa1gtalan csatorna miatt letiltva',
'cache': 'gyors\xc3\xadt\xc3\xb3t\xc3\xa1r',
'change password': 'jelsz\xc3\xb3 megv\xc3\xa1ltoztat\xc3\xa1sa',
'click here for online examples': 'online p\xc3\xa9ld\xc3\xa1k\xc3\xa9rt kattints ide',
'click here for the administrative interface': 'az adminisztr\xc3\xa1ci\xc3\xb3s fel\xc3\xbclet\xc3\xa9rt kattints ide',
'customize me!': 'v\xc3\xa1ltoztass meg!',
'data uploaded': 'adat felt\xc3\xb6ltve',
'database': 'adatb\xc3\xa1zis',
'database %s select': 'adatb\xc3\xa1zis %s kiv\xc3\xa1laszt\xc3\xa1s',
'db': 'db',
'design': 'design',
'done!': 'k\xc3\xa9sz!',
'edit profile': 'profil szerkeszt\xc3\xa9se',
'export as csv file': 'export\xc3\xa1l csv f\xc3\xa1jlba',
'insert new': '\xc3\xbaj beilleszt\xc3\xa9se',
'insert new %s': '\xc3\xbaj beilleszt\xc3\xa9se %s',
'invalid request': 'hib\xc3\xa1s k\xc3\xa9r\xc3\xa9s',
'login': 'bel\xc3\xa9p',
'logout': 'kil\xc3\xa9p',
'lost password': 'elveszett jelsz\xc3\xb3',
'new record inserted': '\xc3\xbaj bejegyz\xc3\xa9s felv\xc3\xa9ve',
'next 100 rows': 'k\xc3\xb6vetkez\xc5\x91 100 sor',
'or import from csv file': 'vagy bet\xc3\xb6lt\xc3\xa9s csv f\xc3\xa1jlb\xc3\xb3l',
'previous 100 rows': 'el\xc5\x91z\xc5\x91 100 sor',
'record': 'bejegyz\xc3\xa9s',
'record does not exist': 'bejegyz\xc3\xa9s nem l\xc3\xa9tezik',
'record id': 'bejegyz\xc3\xa9s id',
'register': 'regisztr\xc3\xa1ci\xc3\xb3',
'selected': 'kiv\xc3\xa1lasztott',
'state': '\xc3\xa1llapot',
'table': 't\xc3\xa1bla',
'unable to parse csv file': 'nem lehet a csv f\xc3\xa1jlt beolvasni',
}
",1
"np
import datetime
# from numpy import linalg
import os.path as osp
import sys
cur_dir = osp.dirname(osp.abspath(__file__))
sys.path.insert(1, osp.join(cur_dir, '.'))
from sklearn.datasets import load_svmlight_file
from scipy.sparse import csr_matrix
# from scipy.sparse import linalg
import matplotlib
matplotlib.use(""Agg"")
import matplotlib.pyplot as plt
import tensorflow as tf
from tf_utils import pinv_naive, pinv
path_train = osp.join(cur_dir, ""../a9a/a9a"")
path_test = osp.join(cur_dir, ""../a9a/a9a.t"")
MAX_ITER = 100
np_dtype = np.float32
tf_dtype = tf.float32
# manual seed
manualSeed = random.randint(1, 10000) # fix seed
print(""Random Seed: "", manualSeed)
random.seed(manualSeed)
np.random.seed(manualSeed)
# load all data
X_train, y_train = load_svmlight_file(path_train, n_features=123, dtype=np_dtype)
X_test, y_test = load_svmlight_file(path_test, n_features=123, dtype=np_dtype)
# X: scipy.sparse.csr.csr_matrix
# X_train: (32561, 123), y_train: (32561,)
# X_test: (16281, 123), y_test:(16281,)
# stack a dimension of ones to X to simplify computation
N_train = X_train.shape[0]
N_test = X_test.shape[0]
X_train = np.hstack((np.ones((N_train, 1)), X_train.toarray())).astype(np_dtype)
X_test = np.hstack((np.ones((N_test, 1)), X_test.toarray())).astype(np_dtype)
# print(X_train.shape, X_test.shape)
y_train = y_train.reshape((N_train, 1))
y_test = y_test.reshape((N_test, 1))
# label: -1, +1 ==> 0, 1
y_train = np.where(y_train == -1, 0, 1)
y_test = np.where(y_test == -1, 0, 1)
# NB: here X's shape is (N,d), which differs to the derivation
def neg_log_likelihood(w, X, y, L2_param=None):
""""""
w: dx1
X: Nxd
y: Nx1
L2_param: \lambda>0, will introduce -\lambda/2 ||w||_2^2
""""""
# print(type(X), X.dtype)
res = tf.matmul(tf.matmul(tf.transpose(w), tf.transpose(X)), y.astype(np_dtype)) - \
tf.reduce_sum(tf.math.log(1 + tf.exp(tf.matmul(X, w))))
if L2_param != None and L2_param > 0:
res += -0.5 * L2_param * tf.matmul(tf.transpose(w), w)
return -res[0][0]
def prob(X, w):
""""""
X: Nxd
w: dx1
---
prob: N x num_classes(2)""""""
y = tf.constant(np.array([0.0, 1.0]), dtype=tf.float32)
prob = tf.exp(tf.matmul(X, w) * y) / (1 + tf.exp(tf.matmul(X, w)))
return prob
def compute_acc(X, y, w):
p = prob(X, w)
y_pred = tf.cast(tf.argmax(p, axis=1), tf.float32)
y = tf.cast(tf.squeeze(y), tf.float32)
acc = tf.reduce_mean(tf.cast(tf.equal(y, y_pred), tf.float32))
return acc
def update(w_old, X, y, L2_param=0):
""""""
w_new = w_old - w_update
w_update = (X'RX+lambda*I)^(-1) (X'(mu-y) + lambda*w_old)
lambda is L2_param
w_old: dx1
X: Nxd
y: Nx1
---
w_update: dx1
""""""
d = X.shape[1]
mu = tf.sigmoid(tf.matmul(X, w_old)) # Nx1
R_flat = mu * (1 - mu) # element-wise, Nx1
L2_reg_term = L2_param * tf.eye(d)
XRX = tf.matmul(tf.transpose(X), R_flat * X) + L2_reg_term # dxd
# np.save('XRX_tf.npy', XRX.numpy())
# calculate pseudo inverse via SVD
# method 1
# slightly better than tfp.math.pinv when L2_param=0
XRX_pinv = pinv_naive(XRX)
# method 2
# XRX_pinv = pinv(XRX)
# w = w - (X^T R X)^(-1) X^T (mu-y)
# w_new = tf.assign(w_old, w_old - tf.matmul(tf.matmul(XRX_pinv, tf.transpose(X)), mu - y))
y = tf.cast(y, tf_dtype)
w_update = tf.matmul(XRX_pinv, tf.matmul(tf.transpose(X), mu - y) + L2_param * w_old)
return w_update
def optimize(w_old, w_update):
""""""custom update op, instead of using SGD variants""""""
return w_old.assign(w_old - w_update)
def train_IRLS(X_train, y_train, X_test=None, y_test=None, L2_param=0, max_iter=MAX_ITER):
""""""train Logistic Regression via IRLS algorithm
X: Nxd
y: Nx1
---
""""""
N, d = X_train.shape
w = tf.Variable(0.01 * tf.ones((d, 1), dtype=tf.float32), name=""w"")
current_time = datetime.datetime.now().strftime(""%Y%m%d_%H%M%S"")
summary_writer = tf.summary.create_file_writer(f""./logs/{current_time}"")
print(""start training..."")
print(""L2 param(lambda): {}"".format(L2_param))
i = 0
# iteration
while i <= max_iter:
print(""iter: {}"".format(i))
# print('\t neg log likelihood: {}'.format(sess.run(neg_L, feed_dict=train_feed_dict)))
neg_L = neg_log_likelihood(w, X_train, y_train, L2_param)
print(""\t neg log likelihood: {}"".format(neg_L))
train_acc = compute_acc(X_train, y_train, w)
with summary_writer.as_default():
tf.summary.scalar(""train_acc"", train_acc, step=i)
tf.summary.scalar(""train_neg_L"", neg_L, step=i)
test_acc = compute_acc(X_test, y_test, w)
with summary_writer.as_default():
tf.summary.scalar(""test_acc"", test_acc, step=i)
print(""\t train acc: {}, test acc: {}"".format(train_acc, test_acc))
L2_norm_w = np.linalg.norm(w.numpy())
print(""\t L2 norm of w: {}"".format(L2_norm_w))
if i > 0:
diff_w = np.linalg.norm(w_update.numpy())
print(""\t diff of w_old and w: {}"".format(diff_w))
if diff_w < 1e-2:
break
w_update = update(w, X_train, y_train, L2_param)
w = optimize(w, w_update)
i += 1
print(""training done."")
if __name__ == ""__main__"":
# test_acc should be about 0.85
lambda_ = 20 # 0
train_IRLS(X_train, y_train, X_test, y_test, L2_param=lambda_, max_iter=100)
from sklearn.linear_model import LogisticRegression
classifier = LogisticRegression()
classifier.fit(X_train, y_train.reshape(N_train,))
y_pred_train = classifier.predict(X_train)
train_acc = np.sum(y_train.reshape(N_train,) == y_pred_train)/N_train
print('train_acc: {}'.format(train_acc))
y_pred_test = classifier.predict(X_test)
test_acc = np.sum(y_test.reshape(N_test,) == y_pred_test)/N_test
print('test acc: {}'.format(test_acc))
",1
"p
from . import check_tag
def test_init():
doc = Document()
check_tag(doc.doc, ['document', 'body'])
check_tag(doc.body, ['body'])
def test_save():
doc = Document()
tmp = BytesIO()
doc.save(tmp)
with ZipFile(tmp) as zippy:
assert(zippy.testzip() is None)
assert(set(zippy.namelist()) == set([
'[Content_Types].xml', '_rels/.rels', 'docProps/app.xml',
'word/fontTable.xml', 'word/numbering.xml', 'word/settings.xml',
'word/styles.xml', 'word/stylesWithEffects.xml',
'word/webSettings.xml', 'word/theme/theme1.xml',
'word/_rels/document.xml.rels', 'word/document.xml',
'docProps/core.xml'
]))
zxf = zippy.open('word/document.xml')
root = etree.parse(zxf)
check_tag(root, 'document body'.split())
def test_load():
# assume save works
d = Document()
tmp = BytesIO()
d.save(tmp)
doc = Document.load(tmp)
check_tag(doc.doc, 'document body'.split())
check_tag(doc.body, 'body'.split())
def test_dumps():
doc = Document()
assert doc.dumps()
def test_core_props():
doc = Document()
attrs = dict(lastModifiedBy='Joe Smith',
keywords=['egg', 'spam'],
title='Testing Doc',
subject='A boilerplate document',
creator='Jill Smith',
description='Core properties test.',
created=datetime.now()
)
doc.update(attrs)
core = doc.get_core_props()
for key in ('title', 'subject', 'creator', 'description'):
attr = core.find('.//dc:%s' % key, namespaces=nsmap)
assert attr is not None
assert attr.text == attrs[key]
attr = core.find('.//cp:keywords', namespaces=nsmap)
assert attr is not None
assert attr.text == ','.join(attrs['keywords'])
attr = core.find('.//dcterms:created', namespaces=nsmap)
assert attr is not None
assert datetime.strptime(attr.text, '%Y-%m-%dT%H:%M:%SZ') == datetime(*attrs['created'].timetuple()[:6])
",1
"om xlsxwriter.utility import xl_rowcol_to_cell
def format_excel(writer, df_size):
"""""" Add Excel specific formatting to the workbook
df_size is a tuple representing the size of the dataframe - typically called
by df.shape -> (20,3)
""""""
# Get the workbook and the summary sheet so we can add the formatting
workbook = writer.book
worksheet = writer.sheets['summary']
# Add currency formatting and apply it
money_fmt = workbook.add_format({'num_format': 42, 'align': 'center'})
worksheet.set_column('A:A', 20)
worksheet.set_column('B:C', 15, money_fmt)
# Add 1 to row so we can include a total
# subtract 1 from the column to handle because we don't care about index
table_end = xl_rowcol_to_cell(df_size[0] + 1, df_size[1] - 1)
# This assumes we start in the left hand corner
table_range = 'A1:{}'.format(table_end)
worksheet.add_table(table_range, {'columns': [{'header': 'account',
'total_string': 'Total'},
{'header': 'Total Sales',
'total_function': 'sum'},
{'header': 'Average Sales',
'total_function': 'average'}],
'autofilter': False,
'total_row': True,
'style': 'Table Style Medium 20'})
if __name__ == ""__main__"":
sales_df = pd.read_excel('https://github.com/chris1610/pbpython/blob/master/data/sample-salesv3.xlsx?raw=true')
sales_summary = sales_df.groupby(['name'])['ext price'].agg(['sum', 'mean'])
# Reset the index for consistency when saving in Excel
sales_summary.reset_index(inplace=True)
writer = pd.ExcelWriter('sales_summary.xlsx', engine='xlsxwriter')
sales_summary.to_excel(writer, 'summary', index=False)
format_excel(writer, sales_summary.shape)
writer.save()
",1
"Administrator of the National Aeronautics and Space Administration. All
# rights reserved.
#
# The Crisis Mapping Toolkit (CMT) v1 platform is 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 ee
import math
from cmt.mapclient_qt import addToMap
from cmt.util.miscUtilities import safe_get_info
import modis_utilities
'''
Contains implementations of several simple MODIS-based flood detection algorithms.
'''
#==============================================================
def dem_threshold(domain, b):
'''Just use a height threshold on the DEM!'''
heightLevel = float(domain.algorithm_params['dem_threshold'])
dem = domain.get_dem().image
return dem.lt(heightLevel).select(['elevation'], ['b1'])
#==============================================================
def evi(domain, b):
'''Simple EVI based classifier'''
#no_clouds = b['b3'].lte(2100).select(['sur_refl_b03'], ['b1'])
criteria1 = b['EVI'].lte(0.3).And(b['LSWI'].subtract(b['EVI']).gte(0.05)).select(['sur_refl_b02'], ['b1'])
criteria2 = b['EVI'].lte(0.05).And(b['LSWI'].lte(0.0)).select(['sur_refl_b02'], ['b1'])
#return no_clouds.And(criteria1.Or(criteria2))
return criteria1.Or(criteria2)
def xiao(domain, b):
'''Method from paper: Xiao, Boles, Frolking, et. al. Mapping paddy rice agriculture in South and Southeast Asia using
multi-temporal MODIS images, Remote Sensing of Environment, 2006.
This method implements a very simple decision tree from several standard MODIS data products.
The default constants were tuned for (wet) rice paddy detection.
'''
return b['LSWI'].subtract(b['NDVI']).gte(0.05).Or(b['LSWI'].subtract(b['EVI']).gte(0.05)).select(['sur_refl_b02'], ['b1']);
#==============================================================
def get_diff(b):
'''Just the internals of the difference method'''
return b['b2'].subtract(b['b1']).select(['sur_refl_b02'], ['b1'])
def diff_learned(domain, b):
'''modis_diff but with the threshold calculation included (training image required)'''
if domain.unflooded_domain == None:
print('No unflooded training domain provided.')
return None
unflooded_b = modis_utilities.compute_modis_indices(domain.unflooded_domain)
water_mask = modis_utilities.get_permanent_water_mask()
threshold = modis_utilities.compute_binary_threshold(get_diff(unflooded_b), water_mask, domain.bounds)
return modis_diff(domain, b, threshold)
def modis_diff(domain, b, threshold=None):
'''Compute (b2-b1) < threshold, a simple water detection index.
This method may be all that is needed in cases where the threshold can be hand tuned.
'''
if threshold == None: # If no threshold value passed in, load it based on the data set.
threshold = float(domain.algorithm_params['modis_diff_threshold'])
return get_diff(b).lte(threshold)
#==============================================================
def get_dartmouth(b):
A = 500
B = 2500
return b['b2'].add(A).divide(b['b1'].add(B)).select(['sur_refl_b02'], ['b1'])
def dart_learned(domain, b):
'''The dartmouth method but with threshold calculation included (training image required)'''
if domain.unflooded_domain == None:
print('No unflooded training domain provided.')
return None
unflooded_b = modis_utilities.compute_modis_indices(domain.unflooded_domain)
water_mask = modis_utilities.get_permanent_water_mask()
threshold = modis_utilities.compute_binary_threshold(get_dartmouth(unflooded_b), water_mask, domain.bounds)
return dartmouth(domain, b, threshold)
def dartmouth(domain, b, threshold=None):
'''A flood detection method from the Dartmouth Flood Observatory.
This method is a refinement of the simple b2-b1 detection method.
'''
if threshold == None:
threshold = float(domain.algorithm_params['dartmouth_threshold'])
return get_dartmouth(b).lte(threshold)
#==============================================================
def get_mod_ndwi(b):
return b['b6'].subtract(b['b4']).divide(b['b4'].add(b['b6'])).select(['sur_refl_b06'], ['b1'])
def mod_ndwi_learned(domain, b):
if domain.unflooded_domain == None:
print('No unflooded training domain provided.')
return None
unflooded_b = modis_utilities.compute_modis_indices(domain.unflooded_domain)
water_mask = modis_utilities.get_permanent_water_mask()
threshold = modis_utilities.compute_binary_threshold(get_mod_ndwi(unflooded_b), water_mask, domain.bounds)
return mod_ndwi(domain, b, threshold)
def mod_ndwi(domain, b, threshold=None):
if threshold == None:
threshold = float(domain.algorithm_params['mod_ndwi_threshold'])
return get_mod_ndwi(b).lte(threshold)
#==============================================================
def get_fai(b):
'''Just the internals of the FAI method'''
return b['b2'].subtract(b['b1'].add(b['b5'].subtract(b['b1']).multiply((859.0 - 645) / (1240 - 645)))).select(['sur_refl_b02'], ['b1'])
def fai_learned(domain, b):
if domain.unflooded_domain == None:
print('No unflooded training domain provided.')
return None
unflooded_b = modis_utilities.compute_modis_indices(domain.unflooded_domain)
water_mask = modis_utilities.get_permanent_water_mask()
threshold = modis_utilities.compute_binary_threshold(get_fai(unflooded_b), water_mask, domain.bounds)
return fai(domain, b, threshold)
def fai(domain, b, threshold=None):
''' Floating Algae Index. Method from paper: Feng, Hu, Chen, Cai, Tian, Gan,
Assessment of inundation changes of Poyang Lake using MODIS observations
between 2000 and 2010. Remote Sensing of Environment, 2012.
'''
if threshold == None:
threshold = float(domain.algorithm_params['fai_threshold'])
return get_fai(b).lte(threshold)
",1
" http://longman.me
# @license The MIT License (MIT)
import os
import sys
import sublime
import sublime_plugin
st_version = 2
if sublime.version() == '' or int(sublime.version()) > 3000:
st_version = 3
reloader_name = 'codeformatter.reloader'
# ST3 loads each package as a module, so it needs an extra prefix
if st_version == 3:
reloader_name = 'CodeFormatter.' + reloader_name
from imp import reload
if reloader_name in sys.modules:
reload(sys.modules[reloader_name])
try:
# Python 3
from .codeformatter.formatter import Formatter
except (ValueError):
# Python 2
from codeformatter.formatter import Formatter
# fix for ST2
cprint = globals()['__builtins__']['print']
debug_mode = False
def plugin_loaded():
cprint('CodeFormatter: Plugin Initialized')
# settings = sublime.load_settings('CodeFormatter.sublime-settings')
# debug_mode = settings.get('codeformatter_debug', False)
# if debug_mode:
# from pprint import pprint
# pprint(settings)
# debug_write('Debug mode enabled')
# debug_write('Platform ' + sublime.platform() + ' ' + sublime.arch())
# debug_write('Sublime Version ' + sublime.version())
# debug_write('Settings ' + pprint(settings))
if (sublime.platform() != 'windows'):
import stat
path = (
sublime.packages_path() +
'/CodeFormatter/codeformatter/lib/phpbeautifier/fmt.phar'
)
st = os.stat(path)
os.chmod(path, st.st_mode | stat.S_IEXEC)
if st_version == 2:
plugin_loaded()
class CodeFormatterCommand(sublime_plugin.TextCommand):
def run(self, edit, syntax=None, saving=None):
run_formatter(self.view, edit, syntax=syntax, saving=saving)
class CodeFormatterOpenTabsCommand(sublime_plugin.TextCommand):
def run(self, edit, syntax=None):
window = sublime.active_window()
for view in window.views():
run_formatter(view, edit, quiet=True)
class CodeFormatterEventListener(sublime_plugin.EventListener):
def on_pre_save(self, view):
view.run_command('code_formatter', {'saving': True})
class CodeFormatterShowPhpTransformationsCommand(sublime_plugin.TextCommand):
def run(self, edit, syntax=False):
import subprocess
import re
platform = sublime.platform()
settings = sublime.load_settings('CodeFormatter.sublime-settings')
opts = settings.get('codeformatter_php_options')
php_path = 'php'
if ('php_path' in opts and opts['php_path']):
php_path = opts['php_path']
php55_compat = False
if ('php55_compat' in opts and opts['php55_compat']):
php55_compat = opts['php55_compat']
cmd = []
cmd.append(str(php_path))
if php55_compat:
cmd.append(
'{}/CodeFormatter/codeformatter/lib/phpbeautifier/fmt.phar'.format(
sublime.packages_path()))
else:
cmd.append(
'{}/CodeFormatter/codeformatter/lib/phpbeautifier/phpf.phar'.format(
sublime.packages_path()))
cmd.append('--list')
#print(cmd)
stderr = ''
stdout = ''
try:
if (platform == 'windows'):
startupinfo = subprocess.STARTUPINFO()
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
startupinfo.wShowWindow = subprocess.SW_HIDE
p = subprocess.Popen(
cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.PIPE, startupinfo=startupinfo,
shell=False, creationflags=subprocess.SW_HIDE)
else:
p = subprocess.Popen(
cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
stdout, stderr = p.communicate()
except Exception as e:
stderr = str(e)
if (not stderr and not stdout):
stderr = 'Error while gethering list of php transformations'
if len(stderr) == 0 and len(stdout) > 0:
text = stdout.decode('utf-8')
text = re.sub(
'Usage:.*?PASSNAME', 'Available PHP Tranformations:', text)
window = self.view.window()
pt = window.get_output_panel('paneltranformations')
pt.set_read_only(False)
pt.insert(edit, pt.size(), text)
window.run_command(
'show_panel', {'panel': 'output.paneltranformations'})
else:
show_error('Formatter error:\n' + stderr)
def run_formatter(view, edit, *args, **kwargs):
if view.is_scratch():
show_error('File is scratch')
return
# default parameters
syntax = kwargs.get('syntax')
saving = kwargs.get('saving', False)
quiet = kwargs.get('quiet', False)
formatter = Formatter(view, syntax)
if not formatter.exists():
if not quiet and not saving:
show_error('Formatter for this file type ({}) not found.'.format(
formatter.syntax))
return
if (saving and not formatter.format_on_save_enabled()):
return
file_text = sublime.Region(0, view.size())
file_text_utf = view.substr(file_text).encode('utf-8')
if (len(file_text_utf) == 0):
return
stdout, stderr = formatter.format(file_text_utf)
if len(stderr) == 0 and len(stdout) > 0:
view.replace(edit, file_text, stdout)
elif not quiet:
show_error('Format error:\n' + stderr)
def console_write(text, prefix=False):
if prefix:
sys.stdout.write('CodeFormatter: ')
sys.stdout.write(text + '\n')
def debug_write(text, prefix=False):
console_write(text, True)
def show_error(text):
sublime.error_message(u'CodeFormatter\n\n%s' % text)
",1
"ated 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 setting the $P4COMSTR variable.
""""""
import os.path
import TestSCons
_python_ = TestSCons._python_
test = TestSCons.TestSCons()
test.subdir('Perforce', ['Perforce', 'sub'], 'sub')
sub_Perforce = os.path.join('sub', 'Perforce')
sub_SConscript = os.path.join('sub', 'SConscript')
sub_all = os.path.join('sub', 'all')
sub_ddd_in = os.path.join('sub', 'ddd.in')
sub_ddd_out = os.path.join('sub', 'ddd.out')
sub_eee_in = os.path.join('sub', 'eee.in')
sub_eee_out = os.path.join('sub', 'eee.out')
sub_fff_in = os.path.join('sub', 'fff.in')
sub_fff_out = os.path.join('sub', 'fff.out')
test.write('my-p4.py', """"""
import shutil
import sys
for f in sys.argv[1:]:
shutil.copy('Perforce/'+f, f)
"""""")
test.write('SConstruct', """"""
def cat(env, source, target):
target = str(target[0])
source = map(str, source)
f = open(target, ""wb"")
for src in source:
f.write(open(src, ""rb"").read())
f.close()
env = Environment(TOOLS = ['default', 'Perforce'],
BUILDERS={'Cat':Builder(action=cat)},
P4COM='%(_python_)s my-p4.py $TARGET',
P4COMSTR='Checking out $TARGET from our fake Perforce')
env.Cat('aaa.out', 'aaa.in')
env.Cat('bbb.out', 'bbb.in')
env.Cat('ccc.out', 'ccc.in')
env.Cat('all', ['aaa.out', 'bbb.out', 'ccc.out'])
env.SourceCode('.', env.Perforce())
SConscript('sub/SConscript', ""env"")
"""""" % locals())
test.write(['Perforce', 'sub', 'SConscript'], """"""\
Import(""env"")
env.Cat('ddd.out', 'ddd.in')
env.Cat('eee.out', 'eee.in')
env.Cat('fff.out', 'fff.in')
env.Cat('all', ['ddd.out', 'eee.out', 'fff.out'])
"""""")
test.write(['Perforce', 'aaa.in'], ""Perforce/aaa.in\n"")
test.write('bbb.in', ""checked-out bbb.in\n"")
test.write(['Perforce', 'ccc.in'], ""Perforce/ccc.in\n"")
test.write(['Perforce', 'sub', 'ddd.in'], ""Perforce/sub/ddd.in\n"")
test.write(['sub', 'eee.in'], ""checked-out sub/eee.in\n"")
test.write(['Perforce', 'sub', 'fff.in'], ""Perforce/sub/fff.in\n"")
test.run(arguments = '.',
stdout = test.wrap_stdout(read_str = """"""\
Checking out %(sub_SConscript)s from our fake Perforce
"""""" % locals(),
build_str = """"""\
Checking out aaa.in from our fake Perforce
cat([""aaa.out""], [""aaa.in""])
cat([""bbb.out""], [""bbb.in""])
Checking out ccc.in from our fake Perforce
cat([""ccc.out""], [""ccc.in""])
cat([""all""], [""aaa.out"", ""bbb.out"", ""ccc.out""])
Checking out %(sub_ddd_in)s from our fake Perforce
cat([""%(sub_ddd_out)s""], [""%(sub_ddd_in)s""])
cat([""%(sub_eee_out)s""], [""%(sub_eee_in)s""])
Checking out %(sub_fff_in)s from our fake Perforce
cat([""%(sub_fff_out)s""], [""%(sub_fff_in)s""])
cat([""%(sub_all)s""], [""%(sub_ddd_out)s"", ""%(sub_eee_out)s"", ""%(sub_fff_out)s""])
"""""" % locals()))
test.must_match('all',
""Perforce/aaa.in\nchecked-out bbb.in\nPerforce/ccc.in\n"")
test.must_match(['sub', 'all'],
""Perforce/sub/ddd.in\nchecked-out sub/eee.in\nPerforce/sub/fff.in\n"")
#
test.pass_test()
",1
"from flask_api import exceptions, renderers, status, FlaskAPI
import json
import unittest
app = FlaskAPI(__name__)
app.config['TESTING'] = True
class JSONVersion1(renderers.JSONRenderer):
media_type = 'application/json; api-version=""1.0""'
class JSONVersion2(renderers.JSONRenderer):
media_type = 'application/json; api-version=""2.0""'
@app.route('/set_status_and_headers/')
def set_status_and_headers():
headers = {'Location': 'http://example.com/456'}
return {'example': 'content'}, status.HTTP_201_CREATED, headers
@app.route('/set_headers/')
def set_headers():
headers = {'Location': 'http://example.com/456'}
return {'example': 'content'}, headers
@app.route('/make_response_view/')
def make_response_view():
response = make_response({'example': 'content'})
response.headers['Location'] = 'http://example.com/456'
return response
@app.route('/api_exception/')
def api_exception():
raise exceptions.PermissionDenied()
@app.route('/abort_view/')
def abort_view():
abort(status.HTTP_403_FORBIDDEN)
@app.route('/options/')
def options_view():
return {}
@app.route('/accepted_media_type/')
@set_renderers([JSONVersion2, JSONVersion1])
def accepted_media_type():
return {'accepted_media_type': str(request.accepted_media_type)}
class AppTests(unittest.TestCase):
def test_set_status_and_headers(self):
with app.test_client() as client:
response = client.get('/set_status_and_headers/')
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.headers['Location'], 'http://example.com/456')
self.assertEqual(response.content_type, 'application/json')
expected = '{""example"": ""content""}'
self.assertEqual(response.get_data().decode('utf8'), expected)
def test_set_headers(self):
with app.test_client() as client:
response = client.get('/set_headers/')
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.headers['Location'], 'http://example.com/456')
self.assertEqual(response.content_type, 'application/json')
expected = '{""example"": ""content""}'
self.assertEqual(response.get_data().decode('utf8'), expected)
def test_make_response(self):
with app.test_client() as client:
response = client.get('/make_response_view/')
self.assertEqual(response.content_type, 'application/json')
self.assertEqual(response.headers['Location'], 'http://example.com/456')
self.assertEqual(response.content_type, 'application/json')
expected = '{""example"": ""content""}'
self.assertEqual(response.get_data().decode('utf8'), expected)
def test_api_exception(self):
with app.test_client() as client:
response = client.get('/api_exception/')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
self.assertEqual(response.content_type, 'application/json')
expected = '{""message"": ""You do not have permission to perform this action.""}'
self.assertEqual(response.get_data().decode('utf8'), expected)
def test_abort_view(self):
with app.test_client() as client:
response = client.get('/abort_view/')
self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
def test_options_view(self):
with app.test_client() as client:
response = client.options('/options/')
# Errors if `response.response` is `None`
response.get_data()
def test_accepted_media_type_property(self):
with app.test_client() as client:
# Explicitly request the ""api-version 1.0"" renderer.
headers = {'Accept': 'application/json; api-version=""1.0""'}
response = client.get('/accepted_media_type/', headers=headers)
data = json.loads(response.get_data().decode('utf8'))
expected = {'accepted_media_type': 'application/json; api-version=""1.0""'}
self.assertEqual(data, expected)
# Request the default renderer, which is ""api-version 2.0"".
headers = {'Accept': '*/*'}
response = client.get('/accepted_media_type/', headers=headers)
data = json.loads(response.get_data().decode('utf8'))
expected = {'accepted_media_type': 'application/json; api-version=""2.0""'}
self.assertEqual(data, expected)
",1
"ntable, txt))
return txt
def traverse(t, outfile):
print>>outfile, sanitize(t.code+'\t'+t.description)
for c in t.children:
traverse(c, outfile)
def getEdges(t, outfile):
for c in t.children:
print >>outfile, sanitize(t.code+'\t'+c.code)
getEdges(c, outfile)
print 'cloning github repository sirrice/icd9.git'
subprocess.call('git clone https://github.com/sirrice/icd9.git', shell=1)
sys.path.append('icd9')
from icd9 import ICD9
tree = ICD9('icd9/codes.json')
toplevelnodes = tree.children
print 'creating name file'
outfile = file('code.names', 'w')
traverse(tree, outfile)
outfile.close()
print 'creating edges file'
outfile = file('code.edges', 'w')
getEdges(tree, outfile)
outfile.close()
print 'cleaning up'
#os.chdir('..')
#subprocess.call('rm -rf icd9', shell=1)
",1
"edistribute it and/or modify
# it under the terms of the GNU Lesser General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This weboob module 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with this weboob module. If not, see \d{2})/?(?P\d{2})(/?(?P\d{2}))? (?P.*)'),
FrenchTransaction.TYPE_WITHDRAWAL),
(re.compile(r'CARTE (?P\d{2})/(?P\d{2}) (?P.*)'),
FrenchTransaction.TYPE_CARD),
(re.compile(r'^(?PVIR(EMEN)?T? (SEPA)?(RECU|FAVEUR)?)( /FRM)?(?P.*)'),
FrenchTransaction.TYPE_TRANSFER),
(re.compile(r'^PRLV (?P.*)( \d+)?$'), FrenchTransaction.TYPE_ORDER),
(re.compile(r'^(CHQ|CHEQUE) .*$'), FrenchTransaction.TYPE_CHECK),
(re.compile(r'^(AGIOS /|FRAIS) (?P.*)'), FrenchTransaction.TYPE_BANK),
(re.compile(r'^(CONVENTION \d+ |F )?COTIS(ATION)? (?P.*)'),
FrenchTransaction.TYPE_BANK),
(re.compile(r'^REMISE (?P.*)'), FrenchTransaction.TYPE_DEPOSIT),
(re.compile(r'^(?P.*)( \d+)? QUITTANCE .*'),
FrenchTransaction.TYPE_ORDER),
(re.compile(r'^.* LE (?P\d{2})/(?P\d{2})/(?P\d{2})$'),
FrenchTransaction.TYPE_UNKNOWN),
(re.compile(r'^.* PAIEMENT (?P\d{2})/(?P\d{2}) (?P.*)'),
FrenchTransaction.TYPE_UNKNOWN),
]
class CmsoTransactionElement(ItemElement):
klass = Transaction
def condition(self):
return len(self.el) >= 5 and not self.el.get('id', '').startswith('libelleLong')
class HistoryPage(CMSOPage):
def get_date_range_list(self):
return [d for d in self.doc.xpath('//select[@name=""date""]/option/@value') if d]
@pagination
@method
class iter_history(ListElement):
item_xpath = '//div[contains(@class, ""master-table"")]//ul/li'
def next_page(self):
pager = self.page.doc.xpath('//div[@class=""pager""]')
if pager: # more than one page if only enough transactions
assert len(pager) == 1
next_links = pager[0].xpath('./span/following-sibling::a[@class=""page""]')
if next_links:
url_next_page = Link('.')(next_links[0])
url_next_page = urljoin(self.page.url, url_next_page)
return self.page.browser.build_request(url_next_page)
class item(CmsoTransactionElement):
def date(selector):
return DateGuesser(Regexp(CleanText(selector), r'\w+ (\d{2}/\d{2})'), Env('date_guesser')) | Transaction.Date(selector)
# CAUTION: this website write a 'Date valeur' inside a div with a class == 'c-ope'
# and a 'Date opération' inside a div with a class == 'c-val'
# so actually i assume 'c-val' class is the real operation date and 'c-ope' is value date
obj_date = date('./div[contains(@class, ""c-val"")]')
obj_vdate = date('./div[contains(@class, ""c-ope"")]')
obj_raw = Transaction.Raw(Regexp(CleanText('./div[contains(@class, ""c-libelle-long"")]'), r'Libellé étendu (.+)'))
obj_amount = Transaction.Amount('./div[contains(@class, ""c-credit"")]', './div[contains(@class, ""c-debit"")]')
class UpdateTokenMixin(object):
def on_load(self):
if 'Authentication' in self.response.headers:
self.browser.token = self.response.headers['Authentication'].split(' ')[-1]
class SSODomiPage(JsonPage, UpdateTokenMixin):
def get_sso_url(self):
return self.doc['urlSSO']
class AuthCheckUser(HTMLPage):
pass
",1
"qa: E501
OpenAPI spec version: Latest
Generated by: https://github.com/swagger-api/swagger-codegen.git
""""""
import pprint
import re # noqa: F401
import six
from orcid_api_v3.models.subtitle_v30_rc2 import SubtitleV30Rc2 # noqa: F401,E501
from orcid_api_v3.models.title_v30_rc2 import TitleV30Rc2 # noqa: F401,E501
from orcid_api_v3.models.translated_title_v30_rc2 import TranslatedTitleV30Rc2 # noqa: F401,E501
class WorkTitleV30Rc2(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 = {
'title': 'TitleV30Rc2',
'subtitle': 'SubtitleV30Rc2',
'translated_title': 'TranslatedTitleV30Rc2'
}
attribute_map = {
'title': 'title',
'subtitle': 'subtitle',
'translated_title': 'translated-title'
}
def __init__(self, title=None, subtitle=None, translated_title=None): # noqa: E501
""""""WorkTitleV30Rc2 - a model defined in Swagger"""""" # noqa: E501
self._title = None
self._subtitle = None
self._translated_title = None
self.discriminator = None
if title is not None:
self.title = title
if subtitle is not None:
self.subtitle = subtitle
if translated_title is not None:
self.translated_title = translated_title
@property
def title(self):
""""""Gets the title of this WorkTitleV30Rc2. # noqa: E501
:return: The title of this WorkTitleV30Rc2. # noqa: E501
:rtype: TitleV30Rc2
""""""
return self._title
@title.setter
def title(self, title):
""""""Sets the title of this WorkTitleV30Rc2.
:param title: The title of this WorkTitleV30Rc2. # noqa: E501
:type: TitleV30Rc2
""""""
self._title = title
@property
def subtitle(self):
""""""Gets the subtitle of this WorkTitleV30Rc2. # noqa: E501
:return: The subtitle of this WorkTitleV30Rc2. # noqa: E501
:rtype: SubtitleV30Rc2
""""""
return self._subtitle
@subtitle.setter
def subtitle(self, subtitle):
""""""Sets the subtitle of this WorkTitleV30Rc2.
:param subtitle: The subtitle of this WorkTitleV30Rc2. # noqa: E501
:type: SubtitleV30Rc2
""""""
self._subtitle = subtitle
@property
def translated_title(self):
""""""Gets the translated_title of this WorkTitleV30Rc2. # noqa: E501
:return: The translated_title of this WorkTitleV30Rc2. # noqa: E501
:rtype: TranslatedTitleV30Rc2
""""""
return self._translated_title
@translated_title.setter
def translated_title(self, translated_title):
""""""Sets the translated_title of this WorkTitleV30Rc2.
:param translated_title: The translated_title of this WorkTitleV30Rc2. # noqa: E501
:type: TranslatedTitleV30Rc2
""""""
self._translated_title = translated_title
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(WorkTitleV30Rc2, 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, WorkTitleV30Rc2):
return False
return self.__dict__ == other.__dict__
def __ne__(self, other):
""""""Returns true if both objects are not equal""""""
return not self == other
",1
"meters following the first STAR in the list.
from lib2to3 import fixer_base
from lib2to3.fixer_util import token, String, Newline, Comma, Name
from libfuturize.fixer_util import indentation, suitify, DoubleStar
_assign_template = u""%(name)s = %(kwargs)s['%(name)s']; del %(kwargs)s['%(name)s']""
_if_template = u""if '%(name)s' in %(kwargs)s: %(assign)s""
_else_template = u""else: %(name)s = %(default)s""
_kwargs_default_name = u""_3to2kwargs""
def gen_params(raw_params):
u""""""
Generator that yields tuples of (name, default_value) for each parameter in the list
If no default is given, then it is default_value is None (not Leaf(token.NAME, 'None'))
""""""
assert raw_params[0].type == token.STAR and len(raw_params) > 2
curr_idx = 2 # the first place a keyword-only parameter name can be is index 2
max_idx = len(raw_params)
while curr_idx < max_idx:
curr_item = raw_params[curr_idx]
prev_item = curr_item.prev_sibling
if curr_item.type != token.NAME:
curr_idx += 1
continue
if prev_item is not None and prev_item.type == token.DOUBLESTAR:
break
name = curr_item.value
nxt = curr_item.next_sibling
if nxt is not None and nxt.type == token.EQUAL:
default_value = nxt.next_sibling
curr_idx += 2
else:
default_value = None
yield (name, default_value)
curr_idx += 1
def remove_params(raw_params, kwargs_default=_kwargs_default_name):
u""""""
Removes all keyword-only args from the params list and a bare star, if any.
Does not add the kwargs dict if needed.
Returns True if more action is needed, False if not
(more action is needed if no kwargs dict exists)
""""""
assert raw_params[0].type == token.STAR
if raw_params[1].type == token.COMMA:
raw_params[0].remove()
raw_params[1].remove()
kw_params = raw_params[2:]
else:
kw_params = raw_params[3:]
for param in kw_params:
if param.type != token.DOUBLESTAR:
param.remove()
else:
return False
else:
return True
def needs_fixing(raw_params, kwargs_default=_kwargs_default_name):
u""""""
Returns string with the name of the kwargs dict if the params after the first star need fixing
Otherwise returns empty string
""""""
found_kwargs = False
needs_fix = False
for t in raw_params[2:]:
if t.type == token.COMMA:
# Commas are irrelevant at this stage.
continue
elif t.type == token.NAME and not found_kwargs:
# Keyword-only argument: definitely need to fix.
needs_fix = True
elif t.type == token.NAME and found_kwargs:
# Return 'foobar' of **foobar, if needed.
return t.value if needs_fix else u''
elif t.type == token.DOUBLESTAR:
# Found either '*' from **foobar.
found_kwargs = True
else:
# Never found **foobar. Return a synthetic name, if needed.
return kwargs_default if needs_fix else u''
class FixKwargs(fixer_base.BaseFix):
run_order = 7 # Run after function annotations are removed
PATTERN = u""funcdef< 'def' NAME parameters< '(' arglist=typedargslist< params=any* > ')' > ':' suite=any >""
def transform(self, node, results):
params_rawlist = results[u""params""]
for i, item in enumerate(params_rawlist):
if item.type == token.STAR:
params_rawlist = params_rawlist[i:]
break
else:
return
# params is guaranteed to be a list starting with *.
# if fixing is needed, there will be at least 3 items in this list:
# [STAR, COMMA, NAME] is the minimum that we need to worry about.
new_kwargs = needs_fixing(params_rawlist)
# new_kwargs is the name of the kwargs dictionary.
if not new_kwargs:
return
suitify(node)
# At this point, params_rawlist is guaranteed to be a list
# beginning with a star that includes at least one keyword-only param
# e.g., [STAR, NAME, COMMA, NAME, COMMA, DOUBLESTAR, NAME] or
# [STAR, COMMA, NAME], or [STAR, COMMA, NAME, COMMA, DOUBLESTAR, NAME]
# Anatomy of a funcdef: ['def', 'name', parameters, ':', suite]
# Anatomy of that suite: [NEWLINE, INDENT, first_stmt, all_other_stmts]
# We need to insert our new stuff before the first_stmt and change the
# first_stmt's prefix.
suite = node.children[4]
first_stmt = suite.children[2]
ident = indentation(first_stmt)
for name, default_value in gen_params(params_rawlist):
if default_value is None:
suite.insert_child(2, Newline())
suite.insert_child(2, String(_assign_template % {u'name': name, u'kwargs': new_kwargs}, prefix=ident))
else:
suite.insert_child(2, Newline())
suite.insert_child(2, String(_else_template % {u'name': name, u'default': default_value}, prefix=ident))
suite.insert_child(2, Newline())
suite.insert_child(2, String(
_if_template % {u'assign': _assign_template % {u'name': name, u'kwargs': new_kwargs}, u'name': name,
u'kwargs': new_kwargs}, prefix=ident))
first_stmt.prefix = ident
suite.children[2].prefix = u""""
# Now, we need to fix up the list of params.
must_add_kwargs = remove_params(params_rawlist)
if must_add_kwargs:
arglist = results[u'arglist']
if len(arglist.children) > 0 and arglist.children[-1].type != token.COMMA:
arglist.append_child(Comma())
arglist.append_child(DoubleStar(prefix=u"" ""))
arglist.append_child(Name(new_kwargs))
",1
"ification, 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.
""""""Test for environment_tools. These are SMALL and MEDIUM tests.""""""
import os
import unittest
import TestFramework
class EnvToolsTests(unittest.TestCase):
""""""Tests for environment_tools module.""""""
def setUp(self):
""""""Per-test setup.""""""
self.env = self.root_env.Clone()
def testFilterOut(self):
""""""Test FilterOut().""""""
env = self.env
env.Replace(
TEST1=['ant', 'bear', 'cat'],
TEST2=[1, 2, 3, 4],
)
# Simple filter
env.FilterOut(TEST1=['bear'])
self.assertEqual(env['TEST1'], ['ant', 'cat'])
# Filter multiple
env.FilterOut(TEST1=['ant'], TEST2=[1, 3])
self.assertEqual(env['TEST1'], ['cat'])
self.assertEqual(env['TEST2'], [2, 4])
# Filter doesn't care if the variable or value doesn't exist
env.FilterOut(TEST1=['dog'], TEST3=[2])
self.assertEqual(env['TEST1'], ['cat'])
self.assertEqual(env['TEST2'], [2, 4])
def testFilterOutRepeated(self):
""""""Test FilterOut() filters all matches.""""""
env = self.env
env['TEST3'] = ['A', 'B', 'B', 'C']
env.FilterOut(TEST3=['B'])
self.assertEqual(env['TEST3'], ['A', 'C'])
def testFilterOutNested(self):
""""""Test FilterOut on nested lists.""""""
env = self.env
# FilterOut does not currently flatten lists, nor remove values from
# sub-lists. This is related to not evaluating environment variables (see
# below).
env['TEST4'] = ['A', ['B', 'C'], 'D']
env.FilterOut(TEST4=['B'])
self.assertEqual(env['TEST4'], ['A', ['B', 'C'], 'D'])
# If you specify the entire sub-list, it will be filtered
env.FilterOut(TEST4=[['B', 'C']])
self.assertEqual(env['TEST4'], ['A', 'D'])
def testFilterOutNoEval(self):
""""""Test FilterOut does not evaluate variables in the list.""""""
env = self.env
# FilterOut does not evaluate variables in the list. (Doing so would
# defeat much of the purpose of variables.) Note that this means it does
# not filter variables which evaluate partially or wholly to the filtered
# string. On the plus side, this means you CAN filter out variables.
env.Replace(
TEST5=['$V1', '$V2', '$V3', '$V4'],
V1='A',
# (V2 intentionally undefined at this point)
V3=['A', 'B'],
V4='C',
)
env.FilterOut(TEST5=['A', '$V4'])
self.assertEqual(env['TEST5'], ['$V1', '$V2', '$V3'])
def testOverlap(self):
""""""Test Overlap().""""""
env = self.env
env.Replace(
OLVAR='baz',
OLLIST=['2', '3', '4'],
)
# Simple string compares
self.assertEqual(env.Overlap('foo', 'foo'), ['foo'])
self.assertEqual(env.Overlap('foo', 'food'), [])
# String compare with variable substitution
self.assertEqual(env.Overlap('foobaz', 'foo$OLVAR'), ['foobaz'])
# Simple list overlap
# Need to use set() for comparison, since the order of entries in the
# output list is indeterminate
self.assertEqual(set(env.Overlap(['1', '2', '3'], ['2', '3', '4'])),
set(['2', '3']))
# Overlap removes duplicates
self.assertEqual(env.Overlap(['1', '2', '2'], ['2', '3', '2']), ['2'])
# List and string
self.assertEqual(env.Overlap('3', ['1', '2', '3']), ['3'])
self.assertEqual(env.Overlap('4', ['1', '2', '3']), [])
self.assertEqual(env.Overlap(['1', '$OLVAR', '3'], '$OLVAR'), ['baz'])
# Variable substitition will replace and flatten lists
self.assertEqual(set(env.Overlap(['1', '2', '3'], '$OLLIST')),
set(['2', '3']))
# Substitution flattens lists
self.assertEqual(set(env.Overlap([['1', '2'], '3'], ['2', ['3', '4']])),
set(['2', '3']))
def testSubstList2(self):
""""""Test SubstList2().""""""
env = self.env
# Empty args should return empty list
self.assertEqual(env.SubstList2(), [])
# Undefined variable also returns empty list
self.assertEqual(env.SubstList2('$NO_SUCH_VAR'), [])
# Simple substitution (recursively evaluates variables)
env['STR1'] = 'FOO$STR2'
env['STR2'] = 'BAR'
self.assertEqual(env.SubstList2('$STR1'), ['FOOBAR'])
# Simple list substitution
env['LIST1'] = ['A', 'B']
self.assertEqual(env.SubstList2('$LIST1'), ['A', 'B'])
# Nested lists
env['LIST2'] = ['C', '$LIST1']
self.assertEqual(env.SubstList2('$LIST2'), ['C', 'A', 'B'])
# Multiple variables in a single entry stay a single entry
self.assertEqual(env.SubstList2('$STR1 $STR2'), ['FOOBAR BAR'])
# Multiple args to command
self.assertEqual(env.SubstList2('$LIST2', '$STR2'), ['C', 'A', 'B', 'BAR'])
# Items in list are actually strings, not some subclass
self.assert_(type(env.SubstList2('$STR1')[0]) is str)
def testRelativePath(self):
""""""Test RelativePath().""""""
env = self.env
# Trivial cases - directory or file relative to itself
self.assertEqual(env.RelativePath('a', 'a'), '.')
self.assertEqual(env.RelativePath('a/b/c', 'a/b/c'), '.')
self.assertEqual(env.RelativePath('a', 'a', source_is_file=True), 'a')
self.assertEqual(env.RelativePath('a/b/c', 'a/b/c', source_is_file=True),
'c')
# Can pass in directory or file nodes
self.assertEqual(env.RelativePath(env.Dir('a'), env.File('b/c'), sep='/'),
'../b/c')
# Separator argument is respected
self.assertEqual(env.RelativePath('.', 'a/b/c', sep='BOOGA'),
'aBOOGAbBOOGAc')
# Default separator is os.sep
self.assertEqual(env.RelativePath('.', 'a/b'),
'a' + os.sep + 'b')
# No common dirs
self.assertEqual(env.RelativePath('a/b/c', 'd/e/f', sep='/'),
'../../../d/e/f')
self.assertEqual(
env.RelativePath('a/b/c', 'd/e/f', sep='/', source_is_file=True),
'../../d/e/f')
# Common dirs
self.assertEqual(env.RelativePath('a/b/c/d', 'a/b/e/f', sep='/'),
'../../e/f')
# Source or destination path is different length
self.assertEqual(env.RelativePath('a/b/c/d', 'a/b', sep='/'), '../..')
self.assertEqual(env.RelativePath('a/b', 'a/b/c/d', sep='/'), 'c/d')
# Current directory on either side
self.assertEqual(env.RelativePath('a/b/c', '.', sep='/'), '../../..')
self.assertEqual(env.RelativePath('.', 'a/b/c', sep='/'), 'a/b/c')
# Variables are evaluated
env.Replace(
DIR1='foo',
DIR2='bar',
)
self.assertEqual(env.RelativePath('foo/$DIR2/a', '$DIR1/bar/b', sep='/'),
'../b')
def testApplyBuildSConscript(self):
""""""Test ApplySConscript() and BuildSConscript() (MEDIUM test).""""""
env = self.env
env['SUB1'] = 'nougat'
# ApplySConscript() affects the calling environment
env.ApplySConscript('SConscript1')
self.assertEqual(env.get('SUB2'), 'orange')
# BuildSConscript() does not affect the calling environment
env.BuildSConscript('SConscript2')
self.assertEqual(env.get('SUB2'), 'orange')
# BuildSConscript finds build.scons in preference to SConscript
env.BuildSConscript('abs1')
# But does look for SConscript if there isn't build.scons
env.BuildSConscript('abs2')
def TestSConstruct(scons_globals):
""""""Test SConstruct file.
Args:
scons_globals: Global variables dict from the SConscript file.
""""""
# Get globals from SCons
Environment = scons_globals['Environment']
env = Environment(tools=['environment_tools'])
# Run unit tests
TestFramework.RunUnitTests(EnvToolsTests, root_env=env)
sconscript1_contents = """"""
Import('env')
if env.get('SUB1') != 'nougat':
raise ValueError('ApplySConscript() failure in sconscript1')
env['SUB2'] = 'orange'
""""""
sconscript2_contents = """"""
Import('env')
if env.get('SUB1') != 'nougat':
raise ValueError('BuildSConscript() failure in sconscript2')
env['SUB2'] = 'pizza'
""""""
sconscript3_contents = """"""
Import('env')
filename = '%s'
env.Execute(Touch(filename))
""""""
def main():
test = TestFramework.TestFramework()
test.subdir('environment_tools')
base = 'environment_tools/'
test.WriteSConscript(base + 'SConstruct', TestSConstruct)
test.write(base + 'SConscript1', sconscript1_contents)
test.write(base + 'SConscript2', sconscript2_contents)
test.subdir(base + 'abs1')
test.write(base + 'abs1/build.scons', sconscript3_contents % 'yes1')
test.write(base + 'abs1/SConscript', sconscript3_contents % 'no')
test.subdir(base + 'abs2')
test.write(base + 'abs2/SConscript', sconscript3_contents % 'yes2')
# Ignore stderr since unittest prints its output there
test.run(chdir=base, stderr=None)
test.must_exist(base + 'abs1/yes1')
test.must_not_exist(base + 'abs1/no')
test.must_exist(base + 'abs2/yes2')
test.pass_test()
if __name__ == '__main__':
main()
",1
"s free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# 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, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301, USA.
import gtk, time
import threading
import thread
import gobject
#Iniciando el hilo sin usarlo
gtk.gdk.threads_init()
#La clase App hereda threading.Thread
class App(threading.Thread):
def __init__(self):
#Método constructor, asociando los widgets
self.glade_file = ""progreso.glade""
self.glade = gtk.Builder()
self.glade.add_from_file(self.glade_file)
self.window1 = self.glade.get_object('window1')
self.togglebutton1 = self.glade.get_object('togglebutton1')
self.button1 = self.glade.get_object('button1')
self.progressbar1 = self.glade.get_object('progressbar1')
self.new_val = 0.0
self.rango =60
#Definiendo el valor inicial de la barra de proceso, definiendo los saltos en 0.1
self.progressbar1.set_fraction(self.new_val)
self.progressbar1.set_pulse_step(0.1)
self.window1.connect(""destroy"",self.on_window1_destroy)
self.button1.connect('clicked', self.on_button1_clicked)
self.togglebutton1.connect('toggled',self.on_togglebutton1_toggled)
#Iniciando el hilo en el constructor
threading.Thread.__init__(self)
self.window1.show_all()
def __iteracion__(self):
#Iteración en segundos cambiando el valor en la barra de progreso.
for i in range(self.rango):
if self.togglebutton1.get_active() == True:
self.new_val = self.progressbar1.get_fraction() + 0.01
if self.new_val > 1.0:
self.new_val = 0.0
self.togglebutton1.set_active(False)
break
else:
time.sleep(1)
self.x = self.new_val*100
self.progressbar1.set_text(""%s"" %self.x)
self.progressbar1.set_fraction(self.new_val)
else:
return
def on_togglebutton1_toggled(self,*args):
#Si cambia el evento en el boton biestado se inicia la iteración entre
los hilos.
variable = self.togglebutton1.get_active()
self.rango = 100
if variable == True:
lock = thread.allocate_lock()
lock.acquire()
thread.start_new_thread( self.__iteracion__, ())
lock.release()
else:
#Se detiene la barra de progreso
self.progressbar1.set_fraction(self.new_val)
self.progressbar1.set_text(""%s"" %self.x)
",1
"ee 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
'
'You will need to restart hass after fixing.'
''.format(err_msg),
title=NOTIFICATION_TITLE,
notification_id=NOTIFICATION_ID)
add_entities(cams, True)
return True
class RingCam(Camera):
""""""An implementation of a Ring Door Bell camera.""""""
def __init__(self, hass, camera, device_info):
""""""Initialize a Ring Door Bell camera.""""""
super(RingCam, self).__init__()
self._camera = camera
self._hass = hass
self._name = self._camera.name
self._ffmpeg = hass.data[DATA_FFMPEG]
self._ffmpeg_arguments = device_info.get(CONF_FFMPEG_ARGUMENTS)
self._last_video_id = self._camera.last_recording_id
self._video_url = self._camera.recording_url(self._last_video_id)
self._utcnow = dt_util.utcnow()
self._expires_at = FORCE_REFRESH_INTERVAL + self._utcnow
@property
def name(self):
""""""Return the name of this camera.""""""
return self._name
@property
def unique_id(self):
""""""Return a unique ID.""""""
return self._camera.id
@property
def device_state_attributes(self):
""""""Return the state attributes.""""""
return {
ATTR_ATTRIBUTION: ATTRIBUTION,
'device_id': self._camera.id,
'firmware': self._camera.firmware,
'kind': self._camera.kind,
'timezone': self._camera.timezone,
'type': self._camera.family,
'video_url': self._video_url,
}
async def async_camera_image(self):
""""""Return a still image response from the camera.""""""
from haffmpeg.tools import ImageFrame, IMAGE_JPEG
ffmpeg = ImageFrame(self._ffmpeg.binary, loop=self.hass.loop)
if self._video_url is None:
return
image = await asyncio.shield(ffmpeg.get_image(
self._video_url, output_format=IMAGE_JPEG,
extra_cmd=self._ffmpeg_arguments))
return image
async def handle_async_mjpeg_stream(self, request):
""""""Generate an HTTP MJPEG stream from the camera.""""""
from haffmpeg.camera import CameraMjpeg
if self._video_url is None:
return
stream = CameraMjpeg(self._ffmpeg.binary, loop=self.hass.loop)
await stream.open_camera(
self._video_url, extra_cmd=self._ffmpeg_arguments)
try:
stream_reader = await stream.get_reader()
return await async_aiohttp_proxy_stream(
self.hass, request, stream_reader,
self._ffmpeg.ffmpeg_stream_content_type)
finally:
await stream.close()
@property
def should_poll(self):
""""""Update the image periodically.""""""
return True
def update(self):
""""""Update camera entity and refresh attributes.""""""
_LOGGER.debug(""Checking if Ring DoorBell needs to refresh video_url"")
self._camera.update()
self._utcnow = dt_util.utcnow()
try:
last_event = self._camera.history(limit=1)[0]
except (IndexError, TypeError):
return
last_recording_id = last_event['id']
video_status = last_event['recording']['status']
if video_status == 'ready' and \
(self._last_video_id != last_recording_id or
self._utcnow >= self._expires_at):
video_url = self._camera.recording_url(last_recording_id)
if video_url:
_LOGGER.info(""Ring DoorBell properties refreshed"")
# update attributes if new video or if URL has expired
self._last_video_id = last_recording_id
self._video_url = video_url
self._expires_at = FORCE_REFRESH_INTERVAL + self._utcnow
",1
" self.events_count_by_type = dict()
def increment_counting(self, event):
""""""Counts an event
Args:
event (:obj:`baroque.entities.event.Event`): the event to be counted
""""""
assert isinstance(event, Event)
self.events_count += 1
t = type(event.type)
if t in self.events_count_by_type:
self.events_count_by_type[t] += 1
else:
self.events_count_by_type[t] = 1
def count_all(self):
""""""Tells how many events have been counted globally
Returns:
int
""""""
return self.events_count
def count(self, eventtype):
""""""Tells how many events have been counted of the specified type
Args:
eventtype (:obj:`baroque.entities.eventtype.EventType`): the type of events to be counted
Returns:
int
""""""
return self.events_count_by_type.get(type(eventtype), 0)
",1
"
@classmethod
def setup_class(cls):
cls.K = nx.krackhardt_kite_graph()
cls.P3 = nx.path_graph(3)
cls.P4 = nx.path_graph(4)
cls.K5 = nx.complete_graph(5)
cls.C4 = nx.cycle_graph(4)
cls.T = nx.balanced_tree(r=2, h=2)
cls.Gb = nx.Graph()
cls.Gb.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (4, 5), (3, 5)])
F = nx.florentine_families_graph()
cls.F = F
cls.LM = nx.les_miserables_graph()
# Create random undirected, unweighted graph for testing incremental version
cls.undirected_G = nx.fast_gnp_random_graph(n=100, p=0.6, seed=123)
cls.undirected_G_cc = nx.closeness_centrality(cls.undirected_G)
def test_wf_improved(self):
G = nx.union(self.P4, nx.path_graph([4, 5, 6]))
c = nx.closeness_centrality(G)
cwf = nx.closeness_centrality(G, wf_improved=False)
res = {0: 0.25, 1: 0.375, 2: 0.375, 3: 0.25, 4: 0.222, 5: 0.333, 6: 0.222}
wf_res = {0: 0.5, 1: 0.75, 2: 0.75, 3: 0.5, 4: 0.667, 5: 1.0, 6: 0.667}
for n in G:
assert almost_equal(c[n], res[n], places=3)
assert almost_equal(cwf[n], wf_res[n], places=3)
def test_digraph(self):
G = nx.path_graph(3, create_using=nx.DiGraph())
c = nx.closeness_centrality(G)
cr = nx.closeness_centrality(G.reverse())
d = {0: 0.0, 1: 0.500, 2: 0.667}
dr = {0: 0.667, 1: 0.500, 2: 0.0}
for n in sorted(self.P3):
assert almost_equal(c[n], d[n], places=3)
assert almost_equal(cr[n], dr[n], places=3)
def test_k5_closeness(self):
c = nx.closeness_centrality(self.K5)
d = {0: 1.000, 1: 1.000, 2: 1.000, 3: 1.000, 4: 1.000}
for n in sorted(self.K5):
assert almost_equal(c[n], d[n], places=3)
def test_p3_closeness(self):
c = nx.closeness_centrality(self.P3)
d = {0: 0.667, 1: 1.000, 2: 0.667}
for n in sorted(self.P3):
assert almost_equal(c[n], d[n], places=3)
def test_krackhardt_closeness(self):
c = nx.closeness_centrality(self.K)
d = {
0: 0.529,
1: 0.529,
2: 0.500,
3: 0.600,
4: 0.500,
5: 0.643,
6: 0.643,
7: 0.600,
8: 0.429,
9: 0.310,
}
for n in sorted(self.K):
assert almost_equal(c[n], d[n], places=3)
def test_florentine_families_closeness(self):
c = nx.closeness_centrality(self.F)
d = {
""Acciaiuoli"": 0.368,
""Albizzi"": 0.483,
""Barbadori"": 0.4375,
""Bischeri"": 0.400,
""Castellani"": 0.389,
""Ginori"": 0.333,
""Guadagni"": 0.467,
""Lamberteschi"": 0.326,
""Medici"": 0.560,
""Pazzi"": 0.286,
""Peruzzi"": 0.368,
""Ridolfi"": 0.500,
""Salviati"": 0.389,
""Strozzi"": 0.4375,
""Tornabuoni"": 0.483,
}
for n in sorted(self.F):
assert almost_equal(c[n], d[n], places=3)
def test_les_miserables_closeness(self):
c = nx.closeness_centrality(self.LM)
d = {
""Napoleon"": 0.302,
""Myriel"": 0.429,
""MlleBaptistine"": 0.413,
""MmeMagloire"": 0.413,
""CountessDeLo"": 0.302,
""Geborand"": 0.302,
""Champtercier"": 0.302,
""Cravatte"": 0.302,
""Count"": 0.302,
""OldMan"": 0.302,
""Valjean"": 0.644,
""Labarre"": 0.394,
""Marguerite"": 0.413,
""MmeDeR"": 0.394,
""Isabeau"": 0.394,
""Gervais"": 0.394,
""Listolier"": 0.341,
""Tholomyes"": 0.392,
""Fameuil"": 0.341,
""Blacheville"": 0.341,
""Favourite"": 0.341,
""Dahlia"": 0.341,
""Zephine"": 0.341,
""Fantine"": 0.461,
""MmeThenardier"": 0.461,
""Thenardier"": 0.517,
""Cosette"": 0.478,
""Javert"": 0.517,
""Fauchelevent"": 0.402,
""Bamatabois"": 0.427,
""Perpetue"": 0.318,
""Simplice"": 0.418,
""Scaufflaire"": 0.394,
""Woman1"": 0.396,
""Judge"": 0.404,
""Champmathieu"": 0.404,
""Brevet"": 0.404,
""Chenildieu"": 0.404,
""Cochepaille"": 0.404,
""Pontmercy"": 0.373,
""Boulatruelle"": 0.342,
""Eponine"": 0.396,
""Anzelma"": 0.352,
""Woman2"": 0.402,
""MotherInnocent"": 0.398,
""Gribier"": 0.288,
""MmeBurgon"": 0.344,
""Jondrette"": 0.257,
""Gavroche"": 0.514,
""Gillenormand"": 0.442,
""Magnon"": 0.335,
""MlleGillenormand"": 0.442,
""MmePontmercy"": 0.315,
""MlleVaubois"": 0.308,
""LtGillenormand"": 0.365,
""Marius"": 0.531,
""BaronessT"": 0.352,
""Mabeuf"": 0.396,
""Enjolras"": 0.481,
""Combeferre"": 0.392,
""Prouvaire"": 0.357,
""Feuilly"": 0.392,
""Courfeyrac"": 0.400,
""Bahorel"": 0.394,
""Bossuet"": 0.475,
""Joly"": 0.394,
""Grantaire"": 0.358,
""MotherPlutarch"": 0.285,
""Gueulemer"": 0.463,
""Babet"": 0.463,
""Claquesous"": 0.452,
""Montparnasse"": 0.458,
""Toussaint"": 0.402,
""Child1"": 0.342,
""Child2"": 0.342,
""Brujon"": 0.380,
""MmeHucheloup"": 0.353,
}
for n in sorted(self.LM):
assert almost_equal(c[n], d[n], places=3)
def test_weighted_closeness(self):
edges = [
(""s"", ""u"", 10),
(""s"", ""x"", 5),
(""u"", ""v"", 1),
(""u"", ""x"", 2),
(""v"", ""y"", 1),
(""x"", ""u"", 3),
(""x"", ""v"", 5),
(""x"", ""y"", 2),
(""y"", ""s"", 7),
(""y"", ""v"", 6),
]
XG = nx.Graph()
XG.add_weighted_edges_from(edges)
c = nx.closeness_centrality(XG, distance=""weight"")
d = {""y"": 0.200, ""x"": 0.286, ""s"": 0.138, ""u"": 0.235, ""v"": 0.200}
for n in sorted(XG):
assert almost_equal(c[n], d[n], places=3)
#
# Tests for incremental closeness centrality.
#
@staticmethod
def pick_add_edge(g):
u = nx.utils.arbitrary_element(g)
possible_nodes = set(g.nodes())
neighbors = list(g.neighbors(u)) + [u]
possible_nodes.difference_update(neighbors)
v = nx.utils.arbitrary_element(possible_nodes)
return (u, v)
@staticmethod
def pick_remove_edge(g):
u = nx.utils.arbitrary_element(g)
possible_nodes = list(g.neighbors(u))
v = nx.utils.arbitrary_element(possible_nodes)
return (u, v)
def test_directed_raises(self):
with pytest.raises(nx.NetworkXNotImplemented):
dir_G = nx.gn_graph(n=5)
prev_cc = None
edge = self.pick_add_edge(dir_G)
insert = True
nx.incremental_closeness_centrality(dir_G, edge, prev_cc, insert)
def test_wrong_size_prev_cc_raises(self):
with pytest.raises(nx.NetworkXError):
G = self.undirected_G.copy()
edge = self.pick_add_edge(G)
insert = True
prev_cc = self.undirected_G_cc.copy()
prev_cc.pop(0)
nx.incremental_closeness_centrality(G, edge, prev_cc, insert)
def test_wrong_nodes_prev_cc_raises(self):
with pytest.raises(nx.NetworkXError):
G = self.undirected_G.copy()
edge = self.pick_add_edge(G)
insert = True
prev_cc = self.undirected_G_cc.copy()
num_nodes = len(prev_cc)
prev_cc.pop(0)
prev_cc[num_nodes] = 0.5
nx.incremental_closeness_centrality(G, edge, prev_cc, insert)
def test_zero_centrality(self):
G = nx.path_graph(3)
prev_cc = nx.closeness_centrality(G)
edge = self.pick_remove_edge(G)
test_cc = nx.incremental_closeness_centrality(G, edge, prev_cc, insertion=False)
G.remove_edges_from([edge])
real_cc = nx.closeness_centrality(G)
shared_items = set(test_cc.items()) & set(real_cc.items())
assert len(shared_items) == len(real_cc)
assert 0 in test_cc.values()
def test_incremental(self):
# Check that incremental and regular give same output
G = self.undirected_G.copy()
prev_cc = None
for i in range(5):
if i % 2 == 0:
# Remove an edge
insert = False
edge = self.pick_remove_edge(G)
else:
# Add an edge
insert = True
edge = self.pick_add_edge(G)
# start = timeit.default_timer()
test_cc = nx.incremental_closeness_centrality(G, edge, prev_cc, insert)
# inc_elapsed = (timeit.default_timer() - start)
# print(f""incremental time: {inc_elapsed}"")
if insert:
G.add_edges_from([edge])
else:
G.remove_edges_from([edge])
# start = timeit.default_timer()
real_cc = nx.closeness_centrality(G)
# reg_elapsed = (timeit.default_timer() - start)
# print(f""regular time: {reg_elapsed}"")
# Example output:
# incremental time: 0.208
# regular time: 0.276
# incremental time: 0.00683
# regular time: 0.260
# incremental time: 0.0224
# regular time: 0.278
# incremental time: 0.00804
# regular time: 0.208
# incremental time: 0.00947
# regular time: 0.188
assert set(test_cc.items()) == set(real_cc.items())
prev_cc = test_cc
",1
"oLismero 2.0 - The web knife - Copyright (C) 2011-2014
Golismero project site: https://github.com/golismero
Golismero project mail: contact@golismero-project.com
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
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, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
""""""
__all__ = [""RPCManager""]
from ..common import pickle
from ..messaging.codes import MessageCode, MSG_RPC_CODES
from ..messaging.manager import MessageManager
from functools import partial
from threading import Thread
import sys
import traceback
#------------------------------------------------------------------------------
# Decorators to automatically register RPC implementors at import time.
# Global map of RPC codes to implementors.
# dict( int -> tuple(callable, bool) )
rpcMap = {}
def implementor(rpc_code, blocking=False):
""""""
RPC implementation function.
""""""
return partial(_add_implementor, rpc_code, blocking)
def _add_implementor(rpc_code, blocking, fn):
# Validate the argument types.
if type(rpc_code) is not int:
raise TypeError(""Expected int, got %r instead"" % type(rpc_code))
if type(blocking) is not bool:
raise TypeError(""Expected bool, got %r instead"" % type(blocking))
if not callable(fn):
raise TypeError(""Expected callable, got %r instead"" % type(fn))
# Validate the RPC code.
if rpc_code in rpcMap:
try:
msg = ""Duplicated RPC implementors for code %d: %s and %s""
msg %= (rpc_code, rpcMap[rpc_code][0].__name__, fn.__name__)
except Exception:
msg = ""Duplicated RPC implementors for code: %d"" % rpc_code
raise SyntaxError(msg)
# TODO: use introspection to validate the function signature
# Register the implementor.
rpcMap[rpc_code] = (fn, blocking)
# Return the implementor. No wrapping is needed! :)
return fn
#------------------------------------------------------------------------------
# Implementor for the special MSG_RPC_BULK code for bulk RPC calls.
@implementor(MessageCode.MSG_RPC_BULK)
def rpc_bulk(orchestrator, audit_name, rpc_code, *arguments):
# Get the implementor for the RPC code.
# Raise NotImplementedError if it's not defined.
try:
method, blocking = rpcMap[rpc_code]
except KeyError:
raise NotImplementedError(""RPC code not implemented: %r"" % rpc_code)
# This can't be done with blocking implementors!
if blocking:
raise NotImplementedError(
""Cannot run blocking RPC calls in bulk. Code: %r"" % rpc_code)
# Prepare a partial function call to the implementor.
caller = partial(method, orchestrator, audit_name)
# Use the built-in map() function to issue all the calls.
# This ensures we support the exact same interface and functionality.
return map(caller, *arguments)
#------------------------------------------------------------------------------
# Ensures the message is received by the Orchestrator.
@implementor(MessageCode.MSG_RPC_SEND_MESSAGE)
def rpc_send_message(orchestrator, audit_name, message):
# Enqueue the ACK message.
orchestrator.enqueue_msg(message)
#------------------------------------------------------------------------------
class RPCManager (object):
""""""
Executes remote procedure calls from plugins.
""""""
#--------------------------------------------------------------------------
def __init__(self, orchestrator):
""""""
:param orchestrator: Orchestrator instance.
:type orchestrator: Orchestrator
""""""
# Keep a reference to the Orchestrator.
self.__orchestrator = orchestrator
# Keep a reference to the global RPC map (it's faster this way).
self.__rpcMap = rpcMap
# Check all RPC messages have been mapped at this point.
missing = MSG_RPC_CODES.difference(self.__rpcMap.keys())
if missing:
msg = ""Missing RPC implementors for codes: %s""
msg %= "", "".join(str(x) for x in sorted(missing))
raise SyntaxError(msg)
#--------------------------------------------------------------------------
@property
def orchestrator(self):
""""""
:returns: Orchestrator instance.
:rtype: Orchestrator
""""""
return self.__orchestrator
#--------------------------------------------------------------------------
def execute_rpc(self, audit_name, rpc_code, response_queue, args, kwargs):
""""""
Honor a remote procedure call request from a plugin.
:param audit_name: Name of the audit requesting the call.
:type audit_name: str
:param rpc_code: RPC code.
:type rpc_code: int
:param response_queue: Response queue identity.
:type response_queue: str
:param args: Positional arguments to the call.
:type args: tuple
:param kwargs: Keyword arguments to the call.
:type kwargs: dict
""""""
try:
# Get the implementor for the RPC code.
# Raise NotImplementedError if it's not defined.
try:
target, blocking = self.__rpcMap[rpc_code]
except KeyError:
raise NotImplementedError(
""RPC code not implemented: %r"" % rpc_code)
# If it's a blocking call...
if blocking:
# Run the implementor in a new thread.
thread = Thread(
target = self._execute_rpc_implementor_background,
args = (
Config._context,
audit_name,
target,
response_queue,
args, kwargs),
)
thread.daemon = True
thread.start()
# If it's a non-blocking call...
else:
# Call the implementor directly.
self.execute_rpc_implementor(
audit_name, target, response_queue, args, kwargs)
# Catch exceptions and send them back.
except Exception:
if response_queue:
error = self.prepare_exception(*sys.exc_info())
try:
self.orchestrator.messageManager.send(
response_queue, (False, error))
except IOError:
import warnings
warnings.warn(""RPC caller died!"")
pass
#--------------------------------------------------------------------------
def _execute_rpc_implementor_background(self, context, audit_name, target,
response_queue, args, kwargs):
""""""
Honor a remote procedure call request from a plugin,
from a background thread. Must only be used as the entry
point for said background thread!
:param context: Plugin execution context.
:type context: PluginContext
:param audit_name: Name of the audit requesting the call.
:type audit_name: str
:param target: RPC implementor function.
:type target: callable
:param response_queue: Response queue identity.
:type response_queue: str
:param args: Positional arguments to the call.
:type args: tuple
:param kwargs: Keyword arguments to the call.
:type kwargs: dict
""""""
Config._context = context
self.execute_rpc_implementor(
audit_name, target, response_queue, args, kwargs)
#--------------------------------------------------------------------------
def execute_rpc_implementor(self, audit_name, target, response_queue,
args, kwargs):
""""""
Honor a remote procedure call request from a plugin.
:param audit_name: Name of the audit requesting the call.
:type audit_name: str
:param target: RPC implementor function.
:type target: callable
:param response_queue: Response queue identity.
:type response_queue: str
:param args: Positional arguments to the call.
:type args: tuple
:param kwargs: Keyword arguments to the call.
:type kwargs: dict
""""""
try:
# Call the implementor and get the response.
response = target(self.orchestrator, audit_name, *args, **kwargs)
success = True
# Catch exceptions and prepare them for sending.
except Exception:
if response_queue:
response = self.prepare_exception(*sys.exc_info())
success = False
# If the call was synchronous,
# send the response/error back to the plugin.
if response_queue:
self.orchestrator.messageManager.send(
response_queue, (success, response))
#--------------------------------------------------------------------------
@staticmethod
def prepare_exception(exc_type, exc_value, exc_traceback):
""""""
Prepare an exception for sending back to the plugins.
:param exc_type: Exception type.
:type exc_type: class
:param exc_value: Exception value.
:type exc_value:
:returns: Exception type, exception value
and formatted traceback. The exception value may be formatted too
and the exception type replaced by Exception if it's not possible
to serialize it for sending.
:rtype: tuple(class, object, str)
""""""
exc_type, exc_value, exc_traceback = sys.exc_info()
try:
pickle.dumps(exc_value, -1)
except Exception:
exc_value = traceback.format_exception_only(exc_type, exc_value)
try:
pickle.dumps(exc_type, -1)
except Exception:
exc_type = Exception
exc_traceback = traceback.extract_tb(exc_traceback)
return exc_type, exc_value, exc_traceback
",1
"RANCH = ""develop""
def run_git(*args, dry_run=False, quiet=False):
""""""Run a git command, print it before executing and capture the output.""""""
command = git[split("" "".join(args))]
if not quiet:
print(""{}{}"".format(""[DRY-RUN] "" if dry_run else """", command))
if dry_run:
return """"
rv = command()
if not quiet and rv:
print(rv)
return rv
def branch_exists(branch):
""""""Return True if the branch exists.""""""
try:
run_git(""rev-parse --verify {}"".format(branch), quiet=True)
return True
except ProcessExecutionError:
return False
def get_current_branch():
""""""Get the current branch name.""""""
return run_git(""rev-parse --abbrev-ref HEAD"", quiet=True).strip()
",1
"msg):
print(msg)
sys.exit(1)
def isPathDisabled(path):
for part in path.parts:
if part.lower().startswith(""_disabled""):
return True
return False
depsFolder = Path(""_deps_split"")
prodFolder = Path(""_prods_split"")
merged_deps = Path(""merged_deps.py"" )
merged_prods = Path(""merged_prods.py"")
if not os.path.isfile(merged_deps):
errorExit(""Merged depends file does not exist"")
if not os.path.isfile(merged_prods):
errorExit(""Merged products file does not exist"")
if not os.path.isdir(depsFolder):
os.makedirs(depsFolder)
else:
print(""Clearing old split folder:"" + str(depsFolder))
shutil.rmtree(depsFolder)
os.makedirs(depsFolder)
if not os.path.isdir(prodFolder):
os.makedirs(prodFolder)
else:
print(""Clearing old split folder:"" + str(prodFolder))
shutil.rmtree(prodFolder)
os.makedirs(prodFolder)
things = { ""merged_deps.py"" : depsFolder, ""merged_prods.py"" : prodFolder, }
for mergefile_name in things:
mergedFile = None
enableWrite = False
curFile = None
print(""Splitting "" +mergefile_name+ "" into seperate files in "" + str(things[mergefile_name]))
with open(mergefile_name, ""r"", encoding=""utf-8"") as f:
mergedFile = f.read().split(""\n"")
fileBuffer = """"
for line in mergedFile:
startR = re.search(""^########START:\[(.+)\]$"",line)
endR = re.search(""^########END:\[(.+)\]$"",line)
if endR != None:
enableWrite = False
curFile.write(fileBuffer.rstrip(""\n""))
curFile.close()
if enableWrite:
fileBuffer+=line+""\n""
if startR != None:
enableWrite = True
fileBuffer = """"
curFile = open(os.path.join(things[mergefile_name],startR.groups()[0]) ,""w"",encoding=""utf-8"")
print(""Done"")",1
" import S_OK, S_ERROR, gLogger
from DIRAC.Core.Base.Client import Client
from DIRAC.Core.Utilities.List import breakListIntoChunks
from DIRAC.Resources.Catalog.FileCatalogueBase import FileCatalogueBase
from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations
rpc = None
url = None
class TransformationClient( Client, FileCatalogueBase ):
"""""" Exposes the functionality available in the DIRAC/TransformationHandler
This inherits the DIRAC base Client for direct execution of server functionality.
The following methods are available (although not visible here).
Transformation (table) manipulation
deleteTransformation(transName)
getTransformationParameters(transName,paramNames)
getTransformationWithStatus(status)
setTransformationParameter(transName,paramName,paramValue)
deleteTransformationParameter(transName,paramName)
TransformationFiles table manipulation
addFilesToTransformation(transName,lfns)
addTaskForTransformation(transName,lfns=[],se='Unknown')
getTransformationStats(transName)
TransformationTasks table manipulation
setTaskStatus(transName, taskID, status)
setTaskStatusAndWmsID(transName, taskID, status, taskWmsID)
getTransformationTaskStats(transName)
deleteTasks(transName, taskMin, taskMax)
extendTransformation( transName, nTasks)
getTasksToSubmit(transName,numTasks,site='')
TransformationLogging table manipulation
getTransformationLogging(transName)
File/directory manipulation methods (the remainder of the interface can be found below)
getFileSummary(lfns)
exists(lfns)
Web monitoring tools
getDistinctAttributeValues(attribute, selectDict)
getTransformationStatusCounters()
getTransformationSummary()
getTransformationSummaryWeb(selectDict, sortList, startItem, maxItems)
""""""
def __init__( self, **kwargs ):
Client.__init__( self, **kwargs )
opsH = Operations()
self.maxResetCounter = opsH.getValue( 'Productions/ProductionFilesMaxResetCounter', 10 )
self.setServer( 'Transformation/TransformationManager' )
def setServer( self, url ):
self.serverURL = url
def getCounters( self, table, attrList, condDict, older = None, newer = None, timeStamp = None,
rpc = '', url = '' ):
rpcClient = self._getRPC( rpc = rpc, url = url )
return rpcClient. getCounters( table, attrList, condDict, older, newer, timeStamp )
def addTransformation( self, transName, description, longDescription, transType, plugin, agentType, fileMask,
transformationGroup = 'General',
groupSize = 1,
inheritedFrom = 0,
body = '',
maxTasks = 0,
eventsPerTask = 0,
addFiles = True,
rpc = '', url = '', timeout = 1800 ):
"""""" add a new transformation
""""""
rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout )
return rpcClient.addTransformation( transName, description, longDescription, transType, plugin,
agentType, fileMask, transformationGroup, groupSize, inheritedFrom,
body, maxTasks, eventsPerTask, addFiles )
def getTransformations( self, condDict = {}, older = None, newer = None, timeStamp = 'CreationDate',
orderAttribute = None, limit = 100, extraParams = False, rpc = '', url = '', timeout = None ):
"""""" gets all the transformations in the system, incrementally. ""limit"" here is just used to determine the offset.
""""""
rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout )
transformations = []
# getting transformations - incrementally
offsetToApply = 0
while True:
res = rpcClient.getTransformations( condDict, older, newer, timeStamp, orderAttribute, limit,
extraParams, offsetToApply )
if not res['OK']:
return res
else:
gLogger.verbose( ""Result for limit %d, offset %d: %d"" % ( limit, offsetToApply, len( res['Value'] ) ) )
if res['Value']:
transformations = transformations + res['Value']
offsetToApply += limit
if len( res['Value'] ) < limit:
break
return S_OK( transformations )
def getTransformation( self, transName, extraParams = False, rpc = '', url = '', timeout = None ):
rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout )
return rpcClient.getTransformation( transName, extraParams )
def getTransformationFiles( self, condDict = {}, older = None, newer = None, timeStamp = 'LastUpdate',
orderAttribute = None, limit = 10000, rpc = '', url = '', timeout = 1800 ):
"""""" gets all the transformation files for a transformation, incrementally.
""limit"" here is just used to determine the offset.
""""""
rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout )
transformationFiles = []
# getting transformationFiles - incrementally
offsetToApply = 0
while True:
res = rpcClient.getTransformationFiles( condDict, older, newer, timeStamp, orderAttribute, limit, offsetToApply )
if not res['OK']:
return res
else:
gLogger.verbose( ""Result for limit %d, offset %d: %d"" % ( limit, offsetToApply, len( res['Value'] ) ) )
if res['Value']:
transformationFiles = transformationFiles + res['Value']
offsetToApply += limit
if len( res['Value'] ) < limit:
break
return S_OK( transformationFiles )
def getTransformationTasks( self, condDict = {}, older = None, newer = None, timeStamp = 'CreationTime',
orderAttribute = None, limit = 10000, inputVector = False, rpc = '',
url = '', timeout = None ):
"""""" gets all the transformation tasks for a transformation, incrementally.
""limit"" here is just used to determine the offset.
""""""
rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout )
transformationTasks = []
# getting transformationFiles - incrementally
offsetToApply = 0
while True:
res = rpcClient.getTransformationTasks( condDict, older, newer, timeStamp, orderAttribute, limit,
inputVector, offsetToApply )
if not res['OK']:
return res
else:
gLogger.verbose( ""Result for limit %d, offset %d: %d"" % ( limit, offsetToApply, len( res['Value'] ) ) )
if res['Value']:
transformationTasks = transformationTasks + res['Value']
offsetToApply += limit
if len( res['Value'] ) < limit:
break
return S_OK( transformationTasks )
def cleanTransformation( self, transID, rpc = '', url = '', timeout = None ):
"""""" Clean the transformation, and set the status parameter (doing it here, for easier extensibility)
""""""
# Cleaning
rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout )
res = rpcClient.cleanTransformation( transID )
if not res['OK']:
return res
# Setting the status
return self.setTransformationParameter( transID, 'Status', 'TransformationCleaned' )
def moveFilesToDerivedTransformation( self, transDict, resetUnused = True ):
"""""" move files input to a transformation, to the derived one
""""""
prod = transDict['TransformationID']
parentProd = int( transDict.get( 'InheritedFrom', 0 ) )
movedFiles = {}
if not parentProd:
gLogger.warn( ""[None] [%d] .moveFilesToDerivedTransformation: Transformation was not derived..."" % prod )
return S_OK( ( parentProd, movedFiles ) )
# get the lfns in status Unused/MaxReset of the parent production
res = self.getTransformationFiles( condDict = {'TransformationID': parentProd, 'Status': [ 'Unused', 'MaxReset' ]} )
if not res['OK']:
gLogger.error( ""[None] [%d] .moveFilesToDerivedTransformation: Error getting Unused files from transformation %s:"" % ( prod, parentProd ), res['Message'] )
return res
parentFiles = res['Value']
lfns = [lfnDict['LFN'] for lfnDict in parentFiles]
if not lfns:
gLogger.info( ""[None] [%d] .moveFilesToDerivedTransformation: No files found to be moved from transformation %d"" % ( prod, parentProd ) )
return S_OK( ( parentProd, movedFiles ) )
# get the lfns of the derived production that were Unused/MaxReset in the parent one
res = self.getTransformationFiles( condDict = { 'TransformationID': prod, 'LFN': lfns} )
if not res['OK']:
gLogger.error( ""[None] [%d] .moveFilesToDerivedTransformation: Error getting files from derived transformation"" % prod, res['Message'] )
return res
derivedFiles = res['Value']
suffix = '-%d' % parentProd
derivedStatusDict = dict( [( derivedDict['LFN'], derivedDict['Status'] ) for derivedDict in derivedFiles] )
newStatusFiles = {}
parentStatusFiles = {}
force = False
for parentDict in parentFiles:
lfn = parentDict['LFN']
derivedStatus = derivedStatusDict.get( lfn )
if derivedStatus:
parentStatus = parentDict['Status']
if resetUnused and parentStatus == 'MaxReset':
status = 'Unused'
moveStatus = 'Unused from MaxReset'
force = True
else:
status = parentStatus
moveStatus = parentStatus
if derivedStatus.endswith( suffix ):
# This file is Unused or MaxReset while it was most likely Assigned at the time of derivation
parentStatusFiles.setdefault( 'Moved-%s' % str( prod ), [] ).append( lfn )
newStatusFiles.setdefault( ( status, parentStatus ), [] ).append( lfn )
movedFiles[moveStatus] = movedFiles.setdefault( moveStatus, 0 ) + 1
elif parentDict['Status'] == 'Unused':
# If the file was Unused already at derivation time, set it NotProcessed
parentStatusFiles.setdefault( 'NotProcessed', [] ).append( lfn )
# Set the status in the parent transformation first
for status, lfnList in parentStatusFiles.items():
for lfnChunk in breakListIntoChunks( lfnList, 5000 ):
res = self.setFileStatusForTransformation( parentProd, status, lfnChunk )
if not res['OK']:
gLogger.error( ""[None] [%d] .moveFilesToDerivedTransformation: Error setting status %s for %d files in transformation %d ""
% ( prod, status, len( lfnList ), parentProd ),
res['Message'] )
# Set the status in the new transformation
for ( status, oldStatus ), lfnList in newStatusFiles.items():
for lfnChunk in breakListIntoChunks( lfnList, 5000 ):
res = self.setFileStatusForTransformation( prod, status, lfnChunk, force = force )
if not res['OK']:
gLogger.error( ""[None] [%d] .moveFilesToDerivedTransformation: Error setting status %s for %d files; resetting them %s in transformation %d""
% ( prod, status, len( lfnChunk ), oldStatus, parentProd ),
res['Message'] )
res = self.setFileStatusForTransformation( parentProd, oldStatus, lfnChunk )
if not res['OK']:
gLogger.error( ""[None] [%d] .moveFilesToDerivedTransformation: Error setting status %s for %d files in transformation %d""
% ( prod, oldStatus, len( lfnChunk ), parentProd ),
res['Message'] )
return S_OK( ( parentProd, movedFiles ) )
def setFileStatusForTransformation( self, transName, newLFNsStatus = {}, lfns = [], force = False,
rpc = '', url = '', timeout = 120 ):
"""""" sets the file status for LFNs of a transformation
For backward compatibility purposes, the status and LFNs can be passed in 2 ways:
- newLFNsStatus is a dictionary with the form:
{'/this/is/an/lfn1.txt': 'StatusA', '/this/is/an/lfn2.txt': 'StatusB', ... }
and at this point lfns is not considered
- newLFNStatus is a string, that applies to all the LFNs in lfns
""""""
rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout )
# create dictionary in case newLFNsStatus is a string
if type( newLFNsStatus ) == type( '' ):
newLFNsStatus = dict( [( lfn, newLFNsStatus ) for lfn in lfns ] )
# gets status as of today
tsFiles = self.getTransformationFiles( {'TransformationID':transName, 'LFN': newLFNsStatus.keys()} )
if not tsFiles['OK']:
return tsFiles
tsFiles = tsFiles['Value']
if tsFiles:
# for convenience, makes a small dictionary out of the tsFiles, with the lfn as key
tsFilesAsDict = {}
for tsFile in tsFiles:
tsFilesAsDict[tsFile['LFN']] = [tsFile['Status'], tsFile['ErrorCount'], tsFile['FileID']]
# applying the state machine to the proposed status
newStatuses = self._applyTransformationFilesStateMachine( tsFilesAsDict, newLFNsStatus, force )
if newStatuses: # if there's something to update
# must do it for the file IDs...
newStatusForFileIDs = dict( [( tsFilesAsDict[lfn][2], newStatuses[lfn] ) for lfn in newStatuses.keys()] )
res = rpcClient.setFileStatusForTransformation( transName, newStatusForFileIDs )
if not res['OK']:
return res
return S_OK( newStatuses )
def _applyTransformationFilesStateMachine( self, tsFilesAsDict, dictOfProposedLFNsStatus, force ):
"""""" For easier extension, here we apply the state machine of the production files.
VOs might want to replace the standard here with something they prefer.
tsFiles is a dictionary with the lfn as key and as value a list of [Status, ErrorCount, FileID]
dictOfNewLFNsStatus is a dictionary with the proposed status
force is a boolean
It returns a dictionary with the status updates
""""""
newStatuses = {}
for lfn in dictOfProposedLFNsStatus.keys():
if lfn not in tsFilesAsDict.keys():
continue
else:
newStatus = dictOfProposedLFNsStatus[lfn]
# Apply optional corrections
if tsFilesAsDict[lfn][0].lower() == 'processed' and dictOfProposedLFNsStatus[lfn].lower() != 'processed':
if not force:
newStatus = 'Processed'
elif tsFilesAsDict[lfn][0].lower() == 'maxreset':
if not force:
newStatus = 'MaxReset'
elif dictOfProposedLFNsStatus[lfn].lower() == 'unused':
errorCount = tsFilesAsDict[lfn][1]
# every 10 retries (by default)
if errorCount and ( ( errorCount % self.maxResetCounter ) == 0 ):
if not force:
newStatus = 'MaxReset'
if tsFilesAsDict[lfn][0].lower() != newStatus:
newStatuses[lfn] = newStatus
return newStatuses
def setTransformationParameter( self, transID, paramName, paramValue, force = False,
rpc = '', url = '', timeout = 120 ):
"""""" Sets a transformation parameter. There's a special case when coming to setting the status of a transformation.
""""""
rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout )
if paramName.lower() == 'status':
# get transformation Type
transformation = self.getTransformation( transID )
if not transformation['OK']:
return transformation
transformationType = transformation['Value']['Type']
# get status as of today
originalStatus = self.getTransformationParameters( transID, 'Status' )
if not originalStatus['OK']:
return originalStatus
originalStatus = originalStatus['Value']
transIDAsDict = {transID: [originalStatus, transformationType]}
dictOfProposedstatus = {transID: paramValue}
# applying the state machine to the proposed status
value = self._applyTransformationStatusStateMachine( transIDAsDict, dictOfProposedstatus, force )
else:
value = paramValue
return rpcClient.setTransformationParameter( transID, paramName, value )
def _applyTransformationStatusStateMachine( self, transIDAsDict, dictOfProposedstatus, force ):
"""""" For easier extension, here we apply the state machine of the transformation status.
VOs might want to replace the standard here with something they prefer.
transIDAsDict is a dictionary with the transID as key and as value a list with [Status, Type]
dictOfProposedstatus is a dictionary with the proposed status
force is a boolean
It returns the new status (the standard is just doing nothing: everything is possible)
""""""
return dictOfProposedstatus.values()[0]
#####################################################################
#
# These are the file catalog interface methods
#
def isOK( self ):
return self.valid
def getName( self, DN = '' ):
"""""" Get the file catalog type name
""""""
return self.name
def addDirectory( self, path, force = False, rpc = '', url = '', timeout = None ):
rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout )
return rpcClient.addDirectory( path, force )
def getReplicas( self, lfn, rpc = '', url = '', timeout = None ):
res = self.__checkArgumentFormat( lfn )
if not res['OK']:
return res
lfns = res['Value'].keys()
rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout )
return rpcClient.getReplicas( lfns )
def addFile( self, lfn, force = False, rpc = '', url = '', timeout = None ):
res = self.__checkArgumentFormat( lfn )
if not res['OK']:
return res
lfndicts = res['Value']
rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout )
return rpcClient.addFile( lfndicts, force )
def addReplica( self, lfn, force = False, rpc = '', url = '', timeout = None ):
res = self.__checkArgumentFormat( lfn )
if not res['OK']:
return res
lfndicts = res['Value']
rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout )
return rpcClient.addReplica( lfndicts, force )
def removeFile( self, lfn, rpc = '', url = '', timeout = None ):
res = self.__checkArgumentFormat( lfn )
if not res['OK']:
return res
lfns = res['Value'].keys()
rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout )
successful = {}
failed = {}
listOfLists = breakListIntoChunks( lfns, 100 )
for fList in listOfLists:
res = rpcClient.removeFile( fList )
if not res['OK']:
return res
successful.update( res['Value']['Successful'] )
failed.update( res['Value']['Failed'] )
resDict = {'Successful': successful, 'Failed':failed}
return S_OK( resDict )
def removeReplica( self, lfn, rpc = '', url = '', timeout = None ):
res = self.__checkArgumentFormat( lfn )
if not res['OK']:
return res
lfndicts = res['Value']
rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout )
successful = {}
failed = {}
# as lfndicts is a dict, the breakListIntoChunks will fail. Fake it!
listOfDicts = []
localdicts = {}
for lfn, info in lfndicts.items():
localdicts.update( { lfn : info } )
if len( localdicts.keys() ) % 100 == 0:
listOfDicts.append( localdicts )
localdicts = {}
for fDict in listOfDicts:
res = rpcClient.removeReplica( fDict )
if not res['OK']:
return res
successful.update( res['Value']['Successful'] )
failed.update( res['Value']['Failed'] )
resDict = {'Successful': successful, 'Failed':failed}
return S_OK( resDict )
def getReplicaStatus( self, lfn, rpc = '', url = '', timeout = None ):
res = self.__checkArgumentFormat( lfn )
if not res['OK']:
return res
lfndict = res['Value']
rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout )
return rpcClient.getReplicaStatus( lfndict )
def setReplicaStatus( self, lfn, rpc = '', url = '', timeout = None ):
res = self.__checkArgumentFormat( lfn )
if not res['OK']:
return res
lfndict = res['Value']
rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout )
return rpcClient.setReplicaStatus( lfndict )
def setReplicaHost( self, lfn, rpc = '', url = '', timeout = None ):
res = self.__checkArgumentFormat( lfn )
if not res['OK']:
return res
lfndict = res['Value']
rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout )
return rpcClient.setReplicaHost( lfndict )
def removeDirectory( self, lfn, rpc = '', url = '', timeout = None ):
return self.__returnOK( lfn )
def createDirectory( self, lfn, rpc = '', url = '', timeout = None ):
return self.__returnOK( lfn )
def createLink( self, lfn, rpc = '', url = '', timeout = None ):
return self.__returnOK( lfn )
def removeLink( self, lfn, rpc = '', url = '', timeout = None ):
return self.__returnOK( lfn )
def __returnOK( self, lfn ):
res = self.__checkArgumentFormat( lfn )
if not res['OK']:
return res
successful = {}
for lfn in res['Value'].keys():
successful[lfn] = True
resDict = {'Successful':successful, 'Failed':{}}
return S_OK( resDict )
def __checkArgumentFormat( self, path ):
if type( path ) in types.StringTypes:
urls = {path:False}
elif type( path ) == types.ListType:
urls = {}
for url in path:
urls[url] = False
elif type( path ) == types.DictType:
urls = path
else:
return S_ERROR( ""TransformationClient.__checkArgumentFormat: Supplied path is not of the correct format."" )
return S_OK( urls )
",1
"et_gdb_executable = Architecture.resolve(GDB_X86)
get_oocd_executable = Architecture.resolve(OPENOCD)
qemu_name = 'i386'
gdb_name = 'i386'
registers = {'eax': 0,
'ecx': 1,
'edx': 2,
'ebx': 3,
'esp': 4,
'ebp': 5,
'esi': 6,
'edi': 7,
'eip': 8,
'pc': 8,
'eflags': 9,
'cs': 10,
'ss': 11,
'ds': 12,
'es': 13,
'fs': 14,
'gs': 15, }
special_registers = {
#SSE
'xmm0': {'format': '{{{:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$xmm0.v4_int32',
},
'xmm1': {'format': '{{{:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$xmm1.v4_int32',
},
'xmm2': {'format': '{{{:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$xmm2.v4_int32',
},
'xmm3': {'format': '{{{:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$xmm3.v4_int32',
},
'xmm4': {'format': '{{{:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$xmm4.v4_int32',
},
'xmm5': {'format': '{{{:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$xmm5.v4_int32',
},
'xmm6': {'format': '{{{:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$xmm6.v4_int32',
},
'xmm7': {'format': '{{{:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$xmm7.v4_int32',
},
'xmm8': {'format': '{{{:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$xmm8.v4_int32',
},
'xmm9': {'format': '{{{:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$xmm9.v4_int32',
},
'xmm10': {'format': '{{{:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$xmm10.v4_int32',
},
'xmm11': {'format': '{{{:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$xmm11.v4_int32',
},
'xmm12': {'format': '{{{:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$xmm12.v4_int32',
},
'xmm13': {'format': '{{{:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$xmm13.v4_int32',
},
'xmm14': {'format': '{{{:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$xmm14.v4_int32',
},
'xmm15': {'format': '{{{:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$xmm15.v4_int32',
},
#AVX
'ymm0': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$ymm0.v8_int32',
},
'ymm1': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$ymm1.v8_int32',
},
'ymm2': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$ymm2.v8_int32',
},
'ymm3': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$ymm3.v8_int32',
},
'ymm4': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$ymm4.v8_int32',
},
'ymm5': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$ymm5.v8_int32',
},
'ymm6': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$ymm6.v8_int32',
},
'ymm7': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$ymm7.v8_int32',
},
'ymm8': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$ymm8.v8_int32',
},
'ymm9': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$ymm9.v8_int32',
},
'ymm10': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$ymm10.v8_int32',
},
'ymm11': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$ymm11.v8_int32',
},
'ymm12': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$ymm12.v8_int32',
},
'ymm13': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$ymm13.v8_int32',
},
'ymm14': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$ymm14.v8_int32',
},
'ymm15': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}',
'gdb_expression': '$ymm15.v8_int32',
},
}
sr_name = 'eflags'
unemulated_instructions = []
capstone_arch = CS_ARCH_X86
capstone_mode = CS_MODE_32
word_size = 32
class X86_64(X86):
qemu_name = 'x86_64'
gdb_name = 'i386:x86-64'
registers = {'rax': 0,
'rbx': 1,
'rcx': 2,
'rdx': 3,
'rsi': 4,
'rdi': 5,
'rbp': 6,
'rsp': 7,
'r8': 8,
'r9': 9,
'r10': 10,
'r11': 11,
'r12': 12,
'r13': 13,
'r14': 14,
'r15': 15,
'rip': 16,
'pc': 16,
'eflags': 17,
'cs': 18,
'ss': 19,
'ds': 20,
'es': 21,
'fs': 22,
'gs': 23,
}
capstone_mode = CS_MODE_64
unemulated_instructions = []
capstone_mode = CS_MODE_64
word_size = 64
",1
"ef __init__(self):
c_ptr = SummaryKeyMatcher.cNamespace().alloc()
super(SummaryKeyMatcher, self).__init__(c_ptr)
def addSummaryKey(self, key):
assert isinstance(key, str)
return SummaryKeyMatcher.cNamespace().add_key(self, key)
def __len__(self):
return SummaryKeyMatcher.cNamespace().size(self)
def __contains__(self, key):
return SummaryKeyMatcher.cNamespace().match_key(self, key)
def isRequired(self, key):
"""""" @rtype: bool """"""
return SummaryKeyMatcher.cNamespace().is_required(self, key)
def keys(self):
"""""" @rtype: StringList """"""
return SummaryKeyMatcher.cNamespace().keys(self)
def free(self):
SummaryKeyMatcher.cNamespace().free(self)
cwrapper = CWrapper(ENKF_LIB)
cwrapper.registerObjectType(""summary_key_matcher"", SummaryKeyMatcher)
SummaryKeyMatcher.cNamespace().alloc = cwrapper.prototype(""c_void_p summary_key_matcher_alloc()"")
SummaryKeyMatcher.cNamespace().free = cwrapper.prototype(""void summary_key_matcher_free(summary_key_matcher)"")
SummaryKeyMatcher.cNamespace().size = cwrapper.prototype(""int summary_key_matcher_get_size(summary_key_matcher)"")
SummaryKeyMatcher.cNamespace().add_key = cwrapper.prototype(""void summary_key_matcher_add_summary_key(summary_key_matcher, char*)"")
SummaryKeyMatcher.cNamespace().match_key = cwrapper.prototype(""bool summary_key_matcher_match_summary_key(summary_key_matcher, char*)"")
SummaryKeyMatcher.cNamespace().keys = cwrapper.prototype(""stringlist_obj summary_key_matcher_get_keys(summary_key_matcher)"")
SummaryKeyMatcher.cNamespace().is_required = cwrapper.prototype(""bool summary_key_matcher_summary_key_is_required(summary_key_matcher, char*)"")
",1
"iven('a valid user with values {username}, {password}, {email}, {first_name}, {last_name}')
def step_impl(context, username, password, email, first_name, last_name):
context.base_user = User(username=username, email=email, password=password, first_name=first_name,
last_name=last_name)
@when('I add the user to the collection')
def step_impl(context):
context.user_service.save(context.base_user)
@then('I check {user_name} exists')
def step_impl(context, user_name):
user_exists = context.user_service.exists(user_name)
assert context.base_user.username == user_exists['username']
assert context.base_user.password == user_exists['password']
assert context.base_user.email == user_exists['email']
assert context.base_user.first_name == user_exists['first_name']
assert context.base_user.last_name == user_exists['last_name']
assert user_exists['_id'] is not None
@given('I update {username} {field} with {value}')
def step_impl(context, username, field, value):
user = context.user_service.exists(username)
if user is not None:
user[field] = value
context.user_service.update(user.to_json())
else:
raise UserNotFound(username, ""User was not found"")
@then('I check {username} {field} is {value}')
def step_impl(context, username, field, value):
user = context.user_service.exists(username)
if user is not None:
assert user[field] == value
else:
raise UserNotFound(username, ""User was not found"")
",1
"hemaMigration):
def forwards(self, orm):
# Adding field 'Question.order'
db.add_column(u'survey_question', 'order',
self.gf('django.db.models.fields.IntegerField')(default=0),
keep_default=False)
def backwards(self, orm):
# Deleting field 'Question.order'
db.delete_column(u'survey_question', 'order')
models = {
u'survey.option': {
'Meta': {'object_name': 'Option'},
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'label': ('django.db.models.fields.SlugField', [], {'max_length': '64'}),
'text': ('django.db.models.fields.CharField', [], {'max_length': '254'})
},
u'survey.page': {
'Meta': {'ordering': ""['order']"", 'unique_together': ""(('survey', 'order'),)"", 'object_name': 'Page'},
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'order': ('django.db.models.fields.IntegerField', [], {}),
'question': ('django.db.models.fields.related.ForeignKey', [], {'to': u""orm['survey.Question']""}),
'survey': ('django.db.models.fields.related.ForeignKey', [], {'to': u""orm['survey.Survey']""})
},
u'survey.question': {
'Meta': {'object_name': 'Question'},
'allow_other': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'info': ('django.db.models.fields.CharField', [], {'max_length': '254', 'null': 'True', 'blank': 'True'}),
'label': ('django.db.models.fields.CharField', [], {'max_length': '254'}),
'modalQuestion': ('django.db.models.fields.related.ForeignKey', [], {'to': u""orm['survey.Question']"", 'null': 'True', 'blank': 'True'}),
'options': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': u""orm['survey.Option']"", 'null': 'True', 'blank': 'True'}),
'options_from_previous_answer': ('django.db.models.fields.CharField', [], {'max_length': '254', 'null': 'True', 'blank': 'True'}),
'options_json': ('django.db.models.fields.CharField', [], {'max_length': '254', 'null': 'True', 'blank': 'True'}),
'order': ('django.db.models.fields.IntegerField', [], {}),
'randomize_groups': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
'slug': ('django.db.models.fields.SlugField', [], {'max_length': '64'}),
'title': ('django.db.models.fields.TextField', [], {}),
'type': ('django.db.models.fields.CharField', [], {'default': ""'text'"", 'max_length': '20'})
},
u'survey.respondant': {
'Meta': {'object_name': 'Respondant'},
'email': ('django.db.models.fields.EmailField', [], {'max_length': '254'}),
'responses': ('django.db.models.fields.related.ManyToManyField', [], {'related_name': ""'responses'"", 'symmetrical': 'False', 'to': u""orm['survey.Response']""}),
'survey': ('django.db.models.fields.related.ForeignKey', [], {'to': u""orm['survey.Survey']""}),
'ts': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2013, 4, 30, 0, 0)'}),
'uuid': ('django.db.models.fields.CharField', [], {'default': ""'bc967489-023c-46ce-b396-d209c8323fac'"", 'max_length': '36', 'primary_key': 'True'})
},
u'survey.response': {
'Meta': {'object_name': 'Response'},
'answer': ('django.db.models.fields.TextField', [], {}),
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'question': ('django.db.models.fields.related.ForeignKey', [], {'to': u""orm['survey.Question']""}),
'respondant': ('django.db.models.fields.related.ForeignKey', [], {'to': u""orm['survey.Respondant']""}),
'ts': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2013, 4, 30, 0, 0)'})
},
u'survey.survey': {
'Meta': {'object_name': 'Survey'},
u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
'name': ('django.db.models.fields.CharField', [], {'max_length': '254'}),
'questions': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': u""orm['survey.Question']"", 'null': 'True', 'through': u""orm['survey.Page']"", 'blank': 'True'}),
'slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '254'})
}
}
complete_apps = ['survey']",1
" .product import ProductImage
from .enum_values import EnumValues
from .related_values import RelatedValues
from .customer import Customer
from .expense import Expense
from .incoming import Incoming
from .shipping import Shipping, ShippingLine
from .receiving import Receiving, ReceivingLine
from .inventory_transaction import InventoryTransaction, InventoryTransactionLine
from .purchase_order import PurchaseOrder, PurchaseOrderLine
from .sales_order import SalesOrder, SalesOrderLine
from .user import User
from .role import Role, roles_users
from .organization import Organization
from .inventory_in_out_link import InventoryInOutLink
from .aspects import update_menemonic
from .product_inventory import ProductInventory
",1
"ttp://www.opensource.org/licenses/mit-license.php.
# CLI to solve an auxpow (or not) in regtest difficulty.
import binascii
import hashlib
import sys
def computeAuxpow (block, target, ok):
""""""
Build an auxpow object (serialised as hex string) that solves
(ok = True) or doesn't solve (ok = False) the block.
""""""
# Start by building the merge-mining coinbase. The merkle tree
# consists only of the block hash as root.
coinbase = ""fabe"" + binascii.hexlify (""m"" * 2)
coinbase += block
coinbase += ""01000000"" + (""00"" * 4)
# Construct ""vector"" of transaction inputs.
vin = ""01""
vin += (""00"" * 32) + (""ff"" * 4)
vin += (""%02x"" % (len (coinbase) / 2)) + coinbase
vin += (""ff"" * 4)
# Build up the full coinbase transaction. It consists only
# of the input and has no outputs.
tx = ""01000000"" + vin + ""00"" + (""00"" * 4)
txHash = doubleHashHex (tx)
# Construct the parent block header. It need not be valid, just good
# enough for auxpow purposes.
header = ""01000000""
header += ""00"" * 32
header += reverseHex (txHash)
header += ""00"" * 4
header += ""00"" * 4
header += ""00"" * 4
# Mine the block.
(header, blockhash) = mineBlock (header, target, ok)
# Build the MerkleTx part of the auxpow.
auxpow = tx
auxpow += blockhash
auxpow += ""00""
auxpow += ""00"" * 4
# Extend to full auxpow.
auxpow += ""00""
auxpow += ""00"" * 4
auxpow += header
return auxpow
def mineBlock (header, target, ok):
""""""
Given a block header, update the nonce until it is ok (or not)
for the given target.
""""""
data = bytearray (binascii.unhexlify (header))
while True:
assert data[79] < 255
data[79] += 1
hexData = binascii.hexlify (data)
blockhash = doubleHashHex (hexData)
if (ok and blockhash < target) or ((not ok) and blockhash > target):
break
return (hexData, blockhash)
def doubleHashHex (data):
""""""
Perform Crowncoin's Double-SHA256 hash on the given hex string.
""""""
hasher = hashlib.sha256 ()
hasher.update (binascii.unhexlify (data))
data = hasher.digest ()
hasher = hashlib.sha256 ()
hasher.update (data)
return reverseHex (hasher.hexdigest ())
def reverseHex (data):
""""""
Flip byte order in the given data (hex string).
""""""
b = bytearray (binascii.unhexlify (data))
b.reverse ()
return binascii.hexlify (b)
################################################################################
if len (sys.argv) != 4:
print ""Usage: solveauxpow.py HASH _TARGET OK""
sys.exit ()
blockHash = sys.argv[1]
revTarget = sys.argv[2]
ok = sys.argv[3]
if ok not in [""true"", ""false""]:
print ""expected 'true' or 'false' as OK value""
sys.exit ()
target = reverseHex (revTarget)
ok = (ok == ""true"")
res = computeAuxpow (blockHash, target, ok)
print res
",1
" def test__POINTER_c_char(self):
class X(Structure):
_fields_ = [(""str"", POINTER(c_char))]
x = X()
# NULL pointer access
self.assertRaises(ValueError, getattr, x.str, ""contents"")
b = c_buffer(b""Hello, World"")
from sys import getrefcount as grc
self.assertEqual(grc(b), 2)
x.str = b
self.assertEqual(grc(b), 3)
# POINTER(c_char) and Python string is NOT compatible
# POINTER(c_char) and c_buffer() is compatible
for i in range(len(b)):
self.assertEqual(b[i], x.str[i])
self.assertRaises(TypeError, setattr, x, ""str"", ""Hello, World"")
def test__c_char_p(self):
class X(Structure):
_fields_ = [(""str"", c_char_p)]
x = X()
# c_char_p and Python string is compatible
# c_char_p and c_buffer is NOT compatible
self.assertEqual(x.str, None)
x.str = b""Hello, World""
self.assertEqual(x.str, b""Hello, World"")
b = c_buffer(b""Hello, World"")
self.assertRaises(TypeError, setattr, x, b""str"", b)
def test_functions(self):
strchr = lib.my_strchr
strchr.restype = c_char_p
# c_char_p and Python string is compatible
# c_char_p and c_buffer are now compatible
strchr.argtypes = c_char_p, c_char
self.assertEqual(strchr(b""abcdef"", b""c""), b""cdef"")
self.assertEqual(strchr(c_buffer(b""abcdef""), b""c""), b""cdef"")
# POINTER(c_char) and Python string is NOT compatible
# POINTER(c_char) and c_buffer() is compatible
strchr.argtypes = POINTER(c_char), c_char
buf = c_buffer(b""abcdef"")
self.assertEqual(strchr(buf, b""c""), b""cdef"")
self.assertEqual(strchr(b""abcdef"", b""c""), b""cdef"")
# XXX These calls are dangerous, because the first argument
# to strchr is no longer valid after the function returns!
# So we must keep a reference to buf separately
strchr.restype = POINTER(c_char)
buf = c_buffer(b""abcdef"")
r = strchr(buf, b""c"")
x = r[0], r[1], r[2], r[3], r[4]
self.assertEqual(x, (b""c"", b""d"", b""e"", b""f"", b""\000""))
del buf
# x1 will NOT be the same as x, usually:
x1 = r[0], r[1], r[2], r[3], r[4]
if __name__ == '__main__':
unittest.main()
",1
"erty()
class Greeting(db.Model):
author = db.UserProperty()
content = db.StringProperty(multiline=True)
avatar = db.BlobProperty()
date = db.DateTimeProperty(auto_now_add=True)
class Placebo(db.Model):
developer = db.StringProperty()
OID = db.StringProperty()
concept = db.StringProperty()
category = db.StringProperty()
taxonomy = db.StringProperty()
taxonomy_version = db.StringProperty()
code = db.StringProperty()
descriptor = db.StringProperty()
",1
"t 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.
""""""All sorts of properties for every field.
Generated by ./generate-onetime-js-widget-data.py
AMD-style module definition.
Note: No leading, internal path before the [], since we'd have to hardwire it
to data/whatever-fns.js which is inflexible.
""""""
# TODO: Clean up the description fields that actually contain data
# extracted from the comments of dbroot_v2.proto.
# The META_INFO contains already vetted snippets.
META_INFO = r""""""
{
""end_snippet.bbs_server_info.base_url:value"": {
""abstract_fieldpath"": ""end_snippet.bbs_server_info.base_url:value"",
""default_value"": null,
""description"": ""URL of the server including protocol, domain and port. Can be translated if we use different servers for different languages."",
""empty_concrete_fieldpath"": ""end_snippet.bbs_server_info.base_url:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""base_url:value"",
""presence"": ""optional"",
""short_label"": ""base_url"",
""typ"": ""string""
},
""end_snippet.bbs_server_info.file_submit_path:value"": {
""abstract_fieldpath"": ""end_snippet.bbs_server_info.file_submit_path:value"",
""default_value"": null,
""description"": ""Path on server where files can be submitted."",
""empty_concrete_fieldpath"": ""end_snippet.bbs_server_info.file_submit_path:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""file_submit_path:value"",
""presence"": ""optional"",
""short_label"": ""file_submit_path"",
""typ"": ""string""
},
""end_snippet.bbs_server_info.name:value"": {
""abstract_fieldpath"": ""end_snippet.bbs_server_info.name:value"",
""default_value"": null,
""description"": ""Name that will be displayed in context menu to user. Must be translated."",
""empty_concrete_fieldpath"": ""end_snippet.bbs_server_info.name:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""name:value"",
""presence"": ""optional"",
""short_label"": ""name"",
""typ"": ""string""
},
""end_snippet.bbs_server_info.post_wizard_path:value"": {
""abstract_fieldpath"": ""end_snippet.bbs_server_info.post_wizard_path:value"",
""default_value"": null,
""description"": ""Path on server where wizard can be found."",
""empty_concrete_fieldpath"": ""end_snippet.bbs_server_info.post_wizard_path:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""post_wizard_path:value"",
""presence"": ""optional"",
""short_label"": ""post_wizard_path"",
""typ"": ""string""
},
""end_snippet.client_options.disable_disk_cache"": {
""abstract_fieldpath"": ""end_snippet.client_options.disable_disk_cache"",
""default_value"": null,
""description"": ""If true, no data will be cached on disk for this database. It will not be accessible offline."",
""empty_concrete_fieldpath"": ""end_snippet.client_options.disable_disk_cache"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": false
},
""name"": ""disable_disk_cache"",
""presence"": ""optional"",
""short_label"": ""disable_disk_cache"",
""typ"": ""bool""
},
""end_snippet.cobrand_info.logo_url"": {
""abstract_fieldpath"": ""end_snippet.cobrand_info.logo_url"",
""default_value"": null,
""description"": ""URL of image to use as logo. Can be remote or local. However, using local URLs depends on the installation of the client and should be used carefully."",
""empty_concrete_fieldpath"": ""end_snippet.cobrand_info.[].logo_url"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""logo_url"",
""presence"": ""required"",
""short_label"": ""logo_url"",
""typ"": ""string""
},
""end_snippet.cobrand_info.screen_size"": {
""abstract_fieldpath"": ""end_snippet.cobrand_info.screen_size"",
""default_value"": ""0.0"",
""description"": ""If specified and strictly positive but <= 1.0, makes logo scalable with screen by forcing its width to occupy a fixed fraction of the screeen. For instance, a value of .25 makes the given logo occupy 25% of the screen."",
""empty_concrete_fieldpath"": ""end_snippet.cobrand_info.[].screen_size"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""screen_size"",
""presence"": ""optional"",
""short_label"": ""screen_size"",
""typ"": ""double""
},
""end_snippet.cobrand_info.tie_point"": {
""abstract_fieldpath"": ""end_snippet.cobrand_info.tie_point"",
""default_value"": ""BOTTOM_LEFT"",
""description"": ""Controls reference point in overlay."",
""empty_concrete_fieldpath"": ""end_snippet.cobrand_info.[].tie_point"",
""enum_vals"": {
""BOTTOM_CENTER"": 7,
""BOTTOM_LEFT"": 6,
""BOTTOM_RIGHT"": 8,
""MID_CENTER"": 4,
""MID_LEFT"": 3,
""MID_RIGHT"": 5,
""TOP_CENTER"": 1,
""TOP_LEFT"": 0,
""TOP_RIGHT"": 2
},
""js_validation_rule"": {
""required"": true
},
""name"": ""tie_point"",
""presence"": ""optional"",
""short_label"": ""tie_point"",
""typ"": ""TiePoint""
},
""end_snippet.cobrand_info.x_coord.is_relative"": {
""abstract_fieldpath"": ""end_snippet.cobrand_info.x_coord.is_relative"",
""default_value"": ""false"",
""description"": ""If true, the coordinate is relative to the screen."",
""empty_concrete_fieldpath"": ""end_snippet.cobrand_info.[].x_coord.is_relative"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": false
},
""name"": ""is_relative"",
""presence"": ""optional"",
""short_label"": ""is_relative"",
""typ"": ""bool""
},
""end_snippet.cobrand_info.x_coord.value"": {
""abstract_fieldpath"": ""end_snippet.cobrand_info.x_coord.value"",
""default_value"": ""0.0"",
""description"": ""Coordinate value. Interpretation depends on is_relative (absolute or"",
""empty_concrete_fieldpath"": ""end_snippet.cobrand_info.[].x_coord.value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""value"",
""presence"": ""required"",
""short_label"": ""value"",
""typ"": ""double""
},
""end_snippet.cobrand_info.y_coord.is_relative"": {
""abstract_fieldpath"": ""end_snippet.cobrand_info.y_coord.is_relative"",
""default_value"": ""false"",
""description"": ""If true, the coordinate is relative to the screen."",
""empty_concrete_fieldpath"": ""end_snippet.cobrand_info.[].y_coord.is_relative"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": false
},
""name"": ""is_relative"",
""presence"": ""optional"",
""short_label"": ""is_relative"",
""typ"": ""bool""
},
""end_snippet.cobrand_info.y_coord.value"": {
""abstract_fieldpath"": ""end_snippet.cobrand_info.y_coord.value"",
""default_value"": ""0.0"",
""description"": ""Coordinate value. Interpretation depends on is_relative (absolute or"",
""empty_concrete_fieldpath"": ""end_snippet.cobrand_info.[].y_coord.value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""value"",
""presence"": ""required"",
""short_label"": ""value"",
""typ"": ""double""
},
""end_snippet.default_web_page_intl_url:value"": {
""abstract_fieldpath"": ""end_snippet.default_web_page_intl_url:value"",
""default_value"": null,
""description"": ""Default location of web page."",
""empty_concrete_fieldpath"": ""end_snippet.default_web_page_intl_url:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""default_web_page_intl_url:value"",
""presence"": ""optional"",
""short_label"": ""default_web_page_intl_url"",
""typ"": ""string""
},
""end_snippet.earth_intl_url:value"": {
""abstract_fieldpath"": ""end_snippet.earth_intl_url:value"",
""default_value"": null,
""description"": ""Location of international page for earth."",
""empty_concrete_fieldpath"": ""end_snippet.earth_intl_url:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""earth_intl_url:value"",
""presence"": ""optional"",
""short_label"": ""earth_intl_url"",
""typ"": ""string""
},
""end_snippet.elevation_service_base_url"": {
""abstract_fieldpath"": ""end_snippet.elevation_service_base_url"",
""default_value"": """",
""description"": ""Terrain elevation service URL. If empty, service will be unavailable."",
""empty_concrete_fieldpath"": ""end_snippet.elevation_service_base_url"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""elevation_service_base_url"",
""presence"": ""optional"",
""short_label"": ""elevation_service_base_url"",
""typ"": ""string""
},
""end_snippet.hide_user_data"": {
""abstract_fieldpath"": ""end_snippet.hide_user_data"",
""default_value"": ""false"",
""description"": ""If true, hides user license key in about dialog. Useful for Pro only, allows information to not be visible for shared license keys."",
""empty_concrete_fieldpath"": ""end_snippet.hide_user_data"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": false
},
""name"": ""hide_user_data"",
""presence"": ""optional"",
""short_label"": ""hide_user_data"",
""typ"": ""bool""
},
""end_snippet.keyboard_shortcuts_url:value"": {
""abstract_fieldpath"": ""end_snippet.keyboard_shortcuts_url:value"",
""default_value"": null,
""description"": ""URL for keyboard shortcuts page. If not specified, this URL is built from user_guide_intl_url as user_guide_intl_url + \""ug_keyboard.html\""."",
""empty_concrete_fieldpath"": ""end_snippet.keyboard_shortcuts_url:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""keyboard_shortcuts_url:value"",
""presence"": ""optional"",
""short_label"": ""keyboard_shortcuts_url"",
""typ"": ""string""
},
""end_snippet.model.compressed_negative_altitude_threshold"": {
""abstract_fieldpath"": ""end_snippet.model.compressed_negative_altitude_threshold"",
""default_value"": null,
""description"": ""Threshold below which negative altitudes are compressed"",
""empty_concrete_fieldpath"": ""end_snippet.model.compressed_negative_altitude_threshold"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""compressed_negative_altitude_threshold"",
""presence"": ""optional"",
""short_label"": ""compressed_negative_altitude_threshold"",
""typ"": ""double""
},
""end_snippet.model.elevation_bias"": {
""abstract_fieldpath"": ""end_snippet.model.elevation_bias"",
""default_value"": null,
""description"": ""Elevation bias"",
""empty_concrete_fieldpath"": ""end_snippet.model.elevation_bias"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""elevation_bias"",
""presence"": ""optional"",
""short_label"": ""elevation_bias"",
""typ"": ""double""
},
""end_snippet.model.flattening"": {
""abstract_fieldpath"": ""end_snippet.model.flattening"",
""default_value"": ""0.00335281066474748"",
""description"": ""Planet flattening. Default value is 1.0/298.257223563 (from WGS84)."",
""empty_concrete_fieldpath"": ""end_snippet.model.flattening"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""flattening"",
""presence"": ""optional"",
""short_label"": ""flattening"",
""typ"": ""double""
},
""end_snippet.model.negative_altitude_exponent_bias"": {
""abstract_fieldpath"": ""end_snippet.model.negative_altitude_exponent_bias"",
""default_value"": null,
""description"": ""Bias for negative altitude so that ocean tiles can be streamed to older clients"",
""empty_concrete_fieldpath"": ""end_snippet.model.negative_altitude_exponent_bias"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""negative_altitude_exponent_bias"",
""presence"": ""optional"",
""short_label"": ""negative_altitude_exponent_bias"",
""typ"": ""int32""
},
""end_snippet.model.radius"": {
""abstract_fieldpath"": ""end_snippet.model.radius"",
""default_value"": ""6378.13700"",
""description"": ""Mean planet radius. Default value is the WGS84 model for earth."",
""empty_concrete_fieldpath"": ""end_snippet.model.radius"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""radius"",
""presence"": ""optional"",
""short_label"": ""radius"",
""typ"": ""double""
},
""end_snippet.privacy_policy_url:value"": {
""abstract_fieldpath"": ""end_snippet.privacy_policy_url:value"",
""default_value"": null,
""description"": ""URL for the privacy policy."",
""empty_concrete_fieldpath"": ""end_snippet.privacy_policy_url:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""privacy_policy_url:value"",
""presence"": ""optional"",
""short_label"": ""privacy_policy_url"",
""typ"": ""string""
},
""end_snippet.release_notes_url:value"": {
""abstract_fieldpath"": ""end_snippet.release_notes_url:value"",
""default_value"": null,
""description"": ""URL for release notes page."",
""empty_concrete_fieldpath"": ""end_snippet.release_notes_url:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""release_notes_url:value"",
""presence"": ""optional"",
""short_label"": ""release_notes_url"",
""typ"": ""string""
},
""end_snippet.reverse_geocoder_protocol_version"": {
""abstract_fieldpath"": ""end_snippet.reverse_geocoder_protocol_version"",
""default_value"": ""3"",
""description"": ""Reverse geocoder protocol version. Default is 3 which is the protocol supported by newer clients."",
""empty_concrete_fieldpath"": ""end_snippet.reverse_geocoder_protocol_version"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""reverse_geocoder_protocol_version"",
""presence"": ""optional"",
""short_label"": ""reverse_geocoder_protocol_version"",
""typ"": ""int32""
},
""end_snippet.reverse_geocoder_url:value"": {
""abstract_fieldpath"": ""end_snippet.reverse_geocoder_url:value"",
""default_value"": null,
""description"": ""Reverse geocoder server URL"",
""empty_concrete_fieldpath"": ""end_snippet.reverse_geocoder_url:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""reverse_geocoder_url:value"",
""presence"": ""optional"",
""short_label"": ""reverse_geocoder_url"",
""typ"": ""string""
},
""end_snippet.show_signin_button"": {
""abstract_fieldpath"": ""end_snippet.show_signin_button"",
""default_value"": null,
""description"": ""If true, shows the signin button in the upper right corner."",
""empty_concrete_fieldpath"": ""end_snippet.show_signin_button"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": false
},
""name"": ""show_signin_button"",
""presence"": ""optional"",
""short_label"": ""show_signin_button"",
""typ"": ""bool""
},
""end_snippet.startup_tips_intl_url:value"": {
""abstract_fieldpath"": ""end_snippet.startup_tips_intl_url:value"",
""default_value"": null,
""description"": ""URL from which to load startup tips in Earth 7.0 and higher."",
""empty_concrete_fieldpath"": ""end_snippet.startup_tips_intl_url:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""startup_tips_intl_url:value"",
""presence"": ""optional"",
""short_label"": ""startup_tips_intl_url"",
""typ"": ""string""
},
""end_snippet.support_answer_intl_url:value"": {
""abstract_fieldpath"": ""end_snippet.support_answer_intl_url:value"",
""default_value"": null,
""description"": ""Url to support answer."",
""empty_concrete_fieldpath"": ""end_snippet.support_answer_intl_url:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""support_answer_intl_url:value"",
""presence"": ""optional"",
""short_label"": ""support_answer_intl_url"",
""typ"": ""string""
},
""end_snippet.support_center_intl_url:value"": {
""abstract_fieldpath"": ""end_snippet.support_center_intl_url:value"",
""default_value"": null,
""description"": ""Url to support center."",
""empty_concrete_fieldpath"": ""end_snippet.support_center_intl_url:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""support_center_intl_url:value"",
""presence"": ""optional"",
""short_label"": ""support_center_intl_url"",
""typ"": ""string""
},
""end_snippet.support_request_intl_url:value"": {
""abstract_fieldpath"": ""end_snippet.support_request_intl_url:value"",
""default_value"": null,
""description"": ""Url to support pages."",
""empty_concrete_fieldpath"": ""end_snippet.support_request_intl_url:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""support_request_intl_url:value"",
""presence"": ""optional"",
""short_label"": ""support_request_intl_url"",
""typ"": ""string""
},
""end_snippet.support_topic_intl_url:value"": {
""abstract_fieldpath"": ""end_snippet.support_topic_intl_url:value"",
""default_value"": null,
""description"": ""Url to support topics used by certain diagnostic messages."",
""empty_concrete_fieldpath"": ""end_snippet.support_topic_intl_url:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""support_topic_intl_url:value"",
""presence"": ""optional"",
""short_label"": ""support_topic_intl_url"",
""typ"": ""string""
},
""end_snippet.swoop_parameters.start_dist_in_meters"": {
""abstract_fieldpath"": ""end_snippet.swoop_parameters.start_dist_in_meters"",
""default_value"": null,
""description"": ""Controls how far from a target swooping should start."",
""empty_concrete_fieldpath"": ""end_snippet.swoop_parameters.start_dist_in_meters"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""start_dist_in_meters"",
""presence"": ""optional"",
""short_label"": ""start_dist_in_meters"",
""typ"": ""double""
},
""end_snippet.tutorial_url:value"": {
""abstract_fieldpath"": ""end_snippet.tutorial_url:value"",
""default_value"": null,
""description"": ""URL for tutorial page. If not specified, this URL is built from user_guide_intl_url as user_guide_intl_url + \""tutorials/index.html\""."",
""empty_concrete_fieldpath"": ""end_snippet.tutorial_url:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""tutorial_url:value"",
""presence"": ""optional"",
""short_label"": ""tutorial_url"",
""typ"": ""string""
},
""end_snippet.use_ge_logo"": {
""abstract_fieldpath"": ""end_snippet.use_ge_logo"",
""default_value"": ""true"",
""description"": ""If false, hides the Google logo."",
""empty_concrete_fieldpath"": ""end_snippet.use_ge_logo"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": false
},
""name"": ""use_ge_logo"",
""presence"": ""optional"",
""short_label"": ""use_ge_logo"",
""typ"": ""bool""
},
""end_snippet.user_guide_intl_url:value"": {
""abstract_fieldpath"": ""end_snippet.user_guide_intl_url:value"",
""default_value"": null,
""description"": ""Url to user guide."",
""empty_concrete_fieldpath"": ""end_snippet.user_guide_intl_url:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""user_guide_intl_url:value"",
""presence"": ""optional"",
""short_label"": ""user_guide_intl_url"",
""typ"": ""string""
},
""end_snippet.valid_database.database_name:value"": {
""abstract_fieldpath"": ""end_snippet.valid_database.database_name:value"",
""default_value"": null,
""description"": ""Human-readable name of database (such as \""Primary Database\"" or \""Digital Globe Database\"")"",
""empty_concrete_fieldpath"": ""end_snippet.valid_database.[].database_name:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""database_name:value"",
""presence"": ""optional"",
""short_label"": ""database_name"",
""typ"": ""string""
},
""end_snippet.valid_database.database_url"": {
""abstract_fieldpath"": ""end_snippet.valid_database.database_url"",
""default_value"": null,
""description"": ""URL of server. This can include a path and query, and must be a well-formed, absolute URL."",
""empty_concrete_fieldpath"": ""end_snippet.valid_database.[].database_url"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""database_url"",
""presence"": ""required"",
""short_label"": ""database_url"",
""typ"": ""string""
},
""end_snippet.search_config.error_page_url:value"": {
""abstract_fieldpath"": ""end_snippet.search_config.error_page_url:value"",
""default_value"": ""about:blank"",
""description"": ""URL of a page that will be displayed if a network error or other local error occurs while performing a search. This might be an error for a local geocode while in offline mode, a connection error while trying to connect to MFE, or some other error where we can't get an error message from the server. (Obviously this page should be cached locally, or it's not terribly useful.) The URL should be fully encoded, and can use $[hl] and friends if necessary."",
""empty_concrete_fieldpath"": ""end_snippet.search_config.error_page_url:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""error_page_url:value"",
""presence"": ""optional"",
""short_label"": ""error_page_url"",
""typ"": ""string""
},
""end_snippet.search_config.kml_render_url:value"": {
""abstract_fieldpath"": ""end_snippet.search_config.kml_render_url:value"",
""default_value"": ""/earth/client/kmlrender/index_$[hl].html"",
""description"": ""URL of a page that will be shown when KML is rendered in the search panel. This page should have JavaScript that reads the KML from the environment and renders it as HTML, but should NOT perform onebox or searchlet searches. The URL should be fully encoded, and can use $[hl] and friends if necessary."",
""empty_concrete_fieldpath"": ""end_snippet.search_config.kml_render_url:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""kml_render_url:value"",
""presence"": ""optional"",
""short_label"": ""kml_render_url"",
""typ"": ""string""
},
""end_snippet.search_config.kml_search_url:value"": {
""abstract_fieldpath"": ""end_snippet.search_config.kml_search_url:value"",
""default_value"": ""/earth/client/kmlrender/index_$[hl].html"",
""description"": ""URL of a page that will be shown when a KML search is performed. This page should have JavaScript that reads the KML from the environment and renders it as HTML, and also performs onebox and searchlet searches if applicable. The URL should be fully encoded, and can use $[hl] and friends if necessary."",
""empty_concrete_fieldpath"": ""end_snippet.search_config.kml_search_url:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""kml_search_url:value"",
""presence"": ""optional"",
""short_label"": ""kml_search_url"",
""typ"": ""string""
},
""end_snippet.search_config.search_history_url:value"": {
""abstract_fieldpath"": ""end_snippet.search_config.search_history_url:value"",
""default_value"": ""http://www.google.com/earth/client/search/history_$[hl].html"",
""description"": ""URL of a page that will be shown when the search history is requested. This page should have JavaScript that reads the search history from the client and renders it as HTML."",
""empty_concrete_fieldpath"": ""end_snippet.search_config.search_history_url:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""search_history_url:value"",
""presence"": ""optional"",
""short_label"": ""search_history_url"",
""typ"": ""string""
},
""end_snippet.google_maps_url:value"": {
""abstract_fieldpath"": ""end_snippet.google_maps_url:value"",
""default_value"": """",
""description"": ""URL for Google Maps, for features like 'View in Maps'."",
""empty_concrete_fieldpath"": ""end_snippet.google_maps_url:value"",
""enum_vals"": null,
""js_validation_rule"": {
""required"": true
},
""name"": ""google_maps_url:value"",
""presence"": ""optional"",
""short_label"": ""google_maps_url"",
""typ"": ""string""
}
}
""""""
",1
"mpliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an ""AS IS"" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
import pytest
import numpy as np
from test.zoo.pipeline.utils.test_utils import ZooTestCase
from zoo.chronos.detector.anomaly.ae_detector import AEDetector
class TestAEDetector(ZooTestCase):
def setup_method(self, method):
pass
def teardown_method(self, method):
pass
def create_data(self):
cycles = 10
time = np.arange(0, cycles * np.pi, 0.01)
data = np.sin(time)
data[600:800] = 10
return data
def test_ae_fit_score_rolled_keras(self):
y = self.create_data()
ad = AEDetector(roll_len=314)
ad.fit(y)
anomaly_scores = ad.score()
assert len(anomaly_scores) == len(y)
anomaly_indexes = ad.anomaly_indexes()
assert len(anomaly_indexes) == int(ad.ratio * len(y))
def test_ae_fit_score_rolled_pytorch(self):
y = self.create_data()
ad = AEDetector(roll_len=314, backend=""torch"")
ad.fit(y)
anomaly_scores = ad.score()
assert len(anomaly_scores) == len(y)
anomaly_indexes = ad.anomaly_indexes()
assert len(anomaly_indexes) == int(ad.ratio * len(y))
def test_ae_fit_score_unrolled(self):
y = self.create_data()
ad = AEDetector(roll_len=0)
ad.fit(y)
anomaly_scores = ad.score()
assert len(anomaly_scores) == len(y)
anomaly_indexes = ad.anomaly_indexes()
assert len(anomaly_indexes) == int(ad.ratio * len(y))
def test_corner_cases(self):
y = self.create_data()
ad = AEDetector(roll_len=314, backend=""dummy"")
with pytest.raises(ValueError):
ad.fit(y)
ad = AEDetector(roll_len=314)
with pytest.raises(RuntimeError):
ad.score()
y = np.array([1])
with pytest.raises(ValueError):
ad.fit(y)
y = self.create_data()
y = y.reshape(2, -1)
with pytest.raises(ValueError):
ad.fit(y)
",1
"State
from direct.fsm import State
from direct.task import Task
import random
from toontown.toonbase import ToontownGlobals
from toontown.toonbase import TTLocalizer
import CharStateDatasAI
class DistributedGoofySpeedwayAI(DistributedCCharBaseAI.DistributedCCharBaseAI):
notify = DirectNotifyGlobal.directNotify.newCategory('DistributedGoofySpeedwayAI')
def __init__(self, air):
DistributedCCharBaseAI.DistributedCCharBaseAI.__init__(self, air, TTLocalizer.Goofy)
self.fsm = ClassicFSM.ClassicFSM('DistributedGoofySpeedwayAI', [State.State('Off', self.enterOff, self.exitOff, ['Lonely', 'TransitionToCostume', 'Walk']),
State.State('Lonely', self.enterLonely, self.exitLonely, ['Chatty', 'Walk', 'TransitionToCostume']),
State.State('Chatty', self.enterChatty, self.exitChatty, ['Lonely', 'Walk', 'TransitionToCostume']),
State.State('Walk', self.enterWalk, self.exitWalk, ['Lonely', 'Chatty', 'TransitionToCostume']),
State.State('TransitionToCostume', self.enterTransitionToCostume, self.exitTransitionToCostume, ['Off'])], 'Off', 'Off')
self.fsm.enterInitialState()
self.handleHolidays()
def delete(self):
self.fsm.requestFinalState()
DistributedCCharBaseAI.DistributedCCharBaseAI.delete(self)
self.lonelyDoneEvent = None
self.lonely = None
self.chattyDoneEvent = None
self.chatty = None
self.walkDoneEvent = None
self.walk = None
return
def generate(self):
DistributedCCharBaseAI.DistributedCCharBaseAI.generate(self)
name = self.getName()
self.lonelyDoneEvent = self.taskName(name + '-lonely-done')
self.lonely = CharStateDatasAI.CharLonelyStateAI(self.lonelyDoneEvent, self)
self.chattyDoneEvent = self.taskName(name + '-chatty-done')
self.chatty = CharStateDatasAI.CharChattyStateAI(self.chattyDoneEvent, self)
self.walkDoneEvent = self.taskName(name + '-walk-done')
if self.diffPath == None:
self.walk = CharStateDatasAI.CharWalkStateAI(self.walkDoneEvent, self)
else:
self.walk = CharStateDatasAI.CharWalkStateAI(self.walkDoneEvent, self, self.diffPath)
return
def walkSpeed(self):
return ToontownGlobals.GoofySpeed
def start(self):
self.fsm.request('Lonely')
def __decideNextState(self, doneStatus):
if self.transitionToCostume == 1:
curWalkNode = self.walk.getDestNode()
if simbase.air.holidayManager:
if ToontownGlobals.HALLOWEEN_COSTUMES in simbase.air.holidayManager.currentHolidays and simbase.air.holidayManager.currentHolidays[ToontownGlobals.HALLOWEEN_COSTUMES]:
simbase.air.holidayManager.currentHolidays[ToontownGlobals.HALLOWEEN_COSTUMES].triggerSwitch(curWalkNode, self)
self.fsm.request('TransitionToCostume')
elif ToontownGlobals.APRIL_FOOLS_COSTUMES in simbase.air.holidayManager.currentHolidays and simbase.air.holidayManager.currentHolidays[ToontownGlobals.APRIL_FOOLS_COSTUMES]:
simbase.air.holidayManager.currentHolidays[ToontownGlobals.APRIL_FOOLS_COSTUMES].triggerSwitch(curWalkNode, self)
self.fsm.request('TransitionToCostume')
else:
self.notify.warning('transitionToCostume == 1 but no costume holiday')
else:
self.notify.warning('transitionToCostume == 1 but no holiday Manager')
if doneStatus['state'] == 'lonely' and doneStatus['status'] == 'done':
self.fsm.request('Walk')
elif doneStatus['state'] == 'chatty' and doneStatus['status'] == 'done':
self.fsm.request('Walk')
elif doneStatus['state'] == 'walk' and doneStatus['status'] == 'done':
if len(self.nearbyAvatars) > 0:
self.fsm.request('Chatty')
else:
self.fsm.request('Lonely')
def enterOff(self):
pass
def exitOff(self):
DistributedCCharBaseAI.DistributedCCharBaseAI.exitOff(self)
def enterLonely(self):
self.lonely.enter()
self.acceptOnce(self.lonelyDoneEvent, self.__decideNextState)
def exitLonely(self):
self.ignore(self.lonelyDoneEvent)
self.lonely.exit()
def __goForAWalk(self, task):
self.notify.debug('going for a walk')
self.fsm.request('Walk')
return Task.done
def enterChatty(self):
self.chatty.enter()
self.acceptOnce(self.chattyDoneEvent, self.__decideNextState)
def exitChatty(self):
self.ignore(self.chattyDoneEvent)
self.chatty.exit()
def enterWalk(self):
self.notify.debug('going for a walk')
self.walk.enter()
self.acceptOnce(self.walkDoneEvent, self.__decideNextState)
def exitWalk(self):
self.ignore(self.walkDoneEvent)
self.walk.exit()
def avatarEnterNextState(self):
if len(self.nearbyAvatars) == 1:
if self.fsm.getCurrentState().getName() != 'Walk':
self.fsm.request('Chatty')
else:
self.notify.debug('avatarEnterNextState: in walk state')
else:
self.notify.debug('avatarEnterNextState: num avatars: ' + str(len(self.nearbyAvatars)))
def avatarExitNextState(self):
if len(self.nearbyAvatars) == 0:
if self.fsm.getCurrentState().getName() != 'Walk':
self.fsm.request('Lonely')
def handleHolidays(self):
DistributedCCharBaseAI.DistributedCCharBaseAI.handleHolidays(self)
if hasattr(simbase.air, 'holidayManager'):
if ToontownGlobals.APRIL_FOOLS_COSTUMES in simbase.air.holidayManager.currentHolidays:
if simbase.air.holidayManager.currentHolidays[ToontownGlobals.APRIL_FOOLS_COSTUMES] != None and simbase.air.holidayManager.currentHolidays[ToontownGlobals.APRIL_FOOLS_COSTUMES].getRunningState():
self.diffPath = TTLocalizer.Donald
return
def getCCLocation(self):
if self.diffPath == None:
return 1
else:
return 0
return
def enterTransitionToCostume(self):
pass
def exitTransitionToCostume(self):
pass
",1
"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.
#
""""""add tenant_id to lcm_subscriptions and lcm_op_occs
Revision ID: d6ae359ab0d6
Revises: 3ff50553e9d3
Create Date: 2022-01-06 13:35:53.868106
""""""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = 'd6ae359ab0d6'
down_revision = '3ff50553e9d3'
def upgrade(active_plugins=None, options=None):
op.add_column('vnf_lcm_subscriptions',
sa.Column('tenant_id', sa.String(length=64),
nullable=False))
op.add_column('vnf_lcm_op_occs',
sa.Column('tenant_id', sa.String(length=64),
nullable=False))
",1
"pacal.distr import sqrt as distr_sqrt
class NoncentralTDistr(DivDistr):
def __init__(self, df = 2, mu = 0):
d1 = NormalDistr(mu, 1)
d2 = distr_sqrt(ChiSquareDistr(df) / df)
super(NoncentralTDistr, self).__init__(d1, d2)
self.df = df
self.mu = mu
def __str__(self):
return ""NoncentralTDistr(df={0},mu={1})#{2}"".format(self.df, self.mu, self.id())
def getName(self):
return ""NoncT({0},{1})"".format(self.df, self.mu)
class NoncentralChiSquareDistr(SumDistr):
def __new__(cls, df, lmbda = 0):
assert df >= 1
d1 = NormalDistr(sqrt(lmbda))**2
if df == 1:
return d1
d2 = ChiSquareDistr(df - 1)
ncc2 = super(NoncentralChiSquareDistr, cls).__new__(cls, d1, d2)
super(NoncentralChiSquareDistr, ncc2).__init__(d1, d2)
ncc2.df = df
ncc2.lmbda = lmbda
return ncc2
def __init__(self, df, lmbda = 0):
pass
def __str__(self):
return ""NoncentralChiSquare(df={0},lambda={1})#{2}"".format(self.df, self.lmbda, self.id())
def getName(self):
return ""NoncChi2({0},{1})"".format(self.df, self.lmbda)
class NoncentralBetaDistr(InvDistr):
def __init__(self, alpha = 1, beta = 1, lmbda = 0):
d = 1 + ChiSquareDistr(2.0 * beta) / NoncentralChiSquareDistr(2 * alpha, lmbda)
super(NoncentralBetaDistr, self).__init__(d)
self.alpha = alpha
self.beta = beta
self.lmbda = lmbda
def __str__(self):
return ""NoncentralBetaDistr(alpha={0},beta={1},lambda={2})#{3}"".format(self.alpha, self.beta, self.lmbda, self.id())
def getName(self):
return ""NoncBeta({0},{1},{2})"".format(self.alpha, self.beta, self.lmbda)
class NoncentralFDistr(DivDistr):
def __init__(self, df1 = 1, df2 = 1, lmbda = 0):
d1 = NoncentralChiSquareDistr(df1, lmbda) / df1
d2 = ChiSquareDistr(df2) / df2
super(NoncentralFDistr, self).__init__(d1, d2)
self.df1 = df1
self.df2 = df2
self.lmbda = lmbda
def __str__(self):
return ""NoncentralFDistr(df1={0},df2={1},lambda={2})#{3}"".format(self.df1, self.df2, self.lmbda, self.id())
def getName(self):
return ""NoncF({0},{1},{2})"".format(self.df1, self.df2, self.lmbda)
",1
"license__ = 'BSD'
import io, subprocess, wave, shutil
import math, audioop, collections
import json, urllib.request
#wip: filter out clicks and other too short parts
class AudioSource(object):
def __init__(self):
raise NotImplementedError(""this is an abstract class"")
def __enter__(self):
raise NotImplementedError(""this is an abstract class"")
def __exit__(self, exc_type, exc_value, traceback):
raise NotImplementedError(""this is an abstract class"")
try:
import pyaudio
class Microphone(AudioSource):
def __init__(self, device_index = None):
self.device_index = device_index
self.format = pyaudio.paInt16 # 16-bit int sampling
self.SAMPLE_WIDTH = pyaudio.get_sample_size(self.format)
self.RATE = 16000 # sampling rate in Hertz
self.CHANNELS = 1 # mono audio
self.CHUNK = 1024 # number of frames stored in each buffer
self.audio = None
self.stream = None
def __enter__(self):
self.audio = pyaudio.PyAudio()
self.stream = self.audio.open(
input_device_index = self.device_index,
format = self.format, rate = self.RATE, channels = self.CHANNELS, frames_per_buffer = self.CHUNK,
input = True, # stream is an input stream
)
return self
def __exit__(self, exc_type, exc_value, traceback):
self.stream.stop_stream()
self.stream.close()
self.stream = None
self.audio.terminate()
except ImportError:
pass
class WavFile(AudioSource):
def __init__(self, filename_or_fileobject):
if isinstance(filename_or_fileobject, str):
self.filename = filename_or_fileobject
else:
self.filename = None
self.wav_file = filename_or_fileobject
self.stream = None
def __enter__(self):
if self.filename: self.wav_file = open(self.filename, ""rb"")
self.wav_reader = wave.open(self.wav_file, ""rb"")
self.SAMPLE_WIDTH = self.wav_reader.getsampwidth()
self.RATE = self.wav_reader.getframerate()
self.CHANNELS = self.wav_reader.getnchannels()
assert self.CHANNELS == 1 # audio must be mono
self.CHUNK = 4096
self.stream = WavFile.WavStream(self.wav_reader)
return self
def __exit__(self, exc_type, exc_value, traceback):
if self.filename: self.wav_file.close()
self.stream = None
class WavStream(object):
def __init__(self, wav_reader):
self.wav_reader = wav_reader
def read(self, size = -1):
if size == -1:
return self.wav_reader.readframes(self.wav_reader.getnframes())
return self.wav_reader.readframes(size)
class AudioData(object):
def __init__(self, rate, data):
self.rate = rate
self.data = data
class Recognizer(AudioSource):
def __init__(self, language = ""fr-FR"", key = ""AIzaSyBOti4mM-6x9WDnZIjIeyEU21OpBXqWBgw""):
self.key = key
self.language = language
self.energy_threshold = 1500 # minimum audio energy to consider for recording
self.pause_threshold = 0.8 # seconds of quiet time before a phrase is considered complete
self.quiet_duration = 0.5 # amount of quiet time to keep on both sides of the recording
def samples_to_flac(self, source, frame_data):
import platform, os
with io.BytesIO() as wav_file:
with wave.open(wav_file, ""wb"") as wav_writer:
wav_writer.setsampwidth(source.SAMPLE_WIDTH)
wav_writer.setnchannels(source.CHANNELS)
wav_writer.setframerate(source.RATE)
wav_writer.writeframes(frame_data)
wav_data = wav_file.getvalue()
# determine which converter executable to use
system = platform.system()
path = os.path.dirname(os.path.abspath(__file__)) # directory of the current module file, where all the FLAC bundled binaries are stored
if shutil.which(""flac"") is not None: # check for installed version first
flac_converter = shutil.which(""flac"")
elif system == ""Windows"" and platform.machine() in {""i386"", ""x86"", ""x86_64"", ""AMD64""}: # Windows NT, use the bundled FLAC conversion utility
flac_converter = os.path.join(path, ""flac-win32.exe"")
elif system == ""Linux"" and platform.machine() in {""i386"", ""x86"", ""x86_64"", ""AMD64""}:
flac_converter = os.path.join(path, ""flac-linux-i386"")
else:
raise ChildProcessError(""FLAC conversion utility not available - consider installing the FLAC utility"")
process = subprocess.Popen(""\""%s\"" --stdout --totally-silent --best -"" % flac_converter, stdin=subprocess.PIPE, stdout=subprocess.PIPE, shell=True)
flac_data, stderr = process.communicate(wav_data)
return flac_data
def record(self, source, duration = None):
assert isinstance(source, AudioSource) and source.stream
frames = io.BytesIO()
seconds_per_buffer = source.CHUNK / source.RATE
elapsed_time = 0
while True: # loop for the total number of chunks needed
elapsed_time += seconds_per_buffer
if duration and elapsed_time > duration: break
buffer = source.stream.read(source.CHUNK)
if len(buffer) == 0: break
frames.write(buffer)
frame_data = frames.getvalue()
frames.close()
return AudioData(source.RATE, self.samples_to_flac(source, frame_data))
def listen(self, source, timeout = None):
assert isinstance(source, AudioSource) and source.stream
# record audio data as raw samples
frames = collections.deque()
assert self.pause_threshold >= self.quiet_duration >= 0
seconds_per_buffer = source.CHUNK / source.RATE
pause_buffer_count = math.ceil(self.pause_threshold / seconds_per_buffer) # number of buffers of quiet audio before the phrase is complete
quiet_buffer_count = math.ceil(self.quiet_duration / seconds_per_buffer) # maximum number of buffers of quiet audio to retain before and after
elapsed_time = 0
# store audio input until the phrase starts
while True:
# handle timeout if specified
elapsed_time += seconds_per_buffer
if timeout and elapsed_time > timeout:
raise TimeoutError(""listening timed out"")
buffer = source.stream.read(source.CHUNK)
if len(buffer) == 0: break # reached end of the stream
frames.append(buffer)
# check if the audio input has stopped being quiet
energy = audioop.rms(buffer, source.SAMPLE_WIDTH) # energy of the audio signal
if energy > self.energy_threshold:
break
if len(frames) > quiet_buffer_count: # ensure we only keep the needed amount of quiet buffers
frames.popleft()
# read audio input until the phrase ends
pause_count = 0
while True:
buffer = source.stream.read(source.CHUNK)
if len(buffer) == 0: break # reached end of the stream
frames.append(buffer)
# check if the audio input has gone quiet for longer than the pause threshold
energy = audioop.rms(buffer, source.SAMPLE_WIDTH) # energy of the audio signal
if energy > self.energy_threshold:
pause_count = 0
else:
pause_count += 1
if pause_count > pause_buffer_count: # end of the phrase
break
# obtain frame data
for i in range(quiet_buffer_count, pause_buffer_count): frames.pop() # remove extra quiet frames at the end
frame_data = b"""".join(list(frames))
return AudioData(source.RATE, self.samples_to_flac(source, frame_data))
def recognize(self, audio_data, show_all = False):
assert isinstance(audio_data, AudioData)
url = ""http://www.google.com/speech-api/v2/recognize?client=chromium&lang=%s&key=%s"" % (self.language, self.key)
self.request = urllib.request.Request(url, data = audio_data.data, headers = {""Content-Type"": ""audio/x-flac; rate=%s"" % audio_data.rate})
# check for invalid key response from the server
try:
response = urllib.request.urlopen(self.request)
except:
raise KeyError(""Server wouldn't respond (invalid key or quota has been maxed out)"")
response_text = response.read().decode(""utf-8"")
# ignore any blank blocks
actual_result = []
for line in response_text.split(""\n""):
if not line: continue
result = json.loads(line)[""result""]
if len(result) != 0:
actual_result = result[0]
# make sure we have a list of transcriptions
if ""alternative"" not in actual_result:
raise LookupError(""Speech is unintelligible"")
# return the best guess unless told to do otherwise
if not show_all:
for prediction in actual_result[""alternative""]:
if ""confidence"" in prediction:
return prediction[""transcript""]
raise LookupError(""Speech is unintelligible"")
spoken_text = []
# check to see if Google thinks it's 100% correct
default_confidence = 0
if len(actual_result[""alternative""])==1: default_confidence = 1
# return all the possibilities
for prediction in actual_result[""alternative""]:
if ""confidence"" in prediction:
spoken_text.append({""text"":prediction[""transcript""],""confidence"":prediction[""confidence""]})
else:
spoken_text.append({""text"":prediction[""transcript""],""confidence"":default_confidence})
return spoken_text
if __name__ == ""__main__"":
r = Recognizer()
m = Microphone()
while True:
print(""Say something!"")
with m as source:
audio = r.listen(source)
print(""Got it! Now to recognize it..."")
try:
print(""You said "" + r.recognize(audio))
except LookupError:
print(""Oops! Didn't catch that"")
",1
"__ import absolute_import, division, print_function
__metaclass__ = type
ANSIBLE_METADATA = {'metadata_version': '1.1',
'status': ['preview'],
'supported_by': 'community'}
DOCUMENTATION = r'''
---
module: aci_tenant_span_dst_group
short_description: Manage SPAN destination groups (span:DestGrp)
description:
- Manage SPAN destination groups on Cisco ACI fabrics.
notes:
- The C(tenant) used must exist before using this module in your playbook.
The M(aci_tenant) module can be used for this.
- More information about the internal APIC class B(span:DestGrp) from
L(the APIC Management Information Model reference,https://developer.cisco.com/docs/apic-mim-ref/).
author:
- Dag Wieers (@dagwieers)
version_added: '2.4'
options:
dst_group:
description:
- The name of the SPAN destination group.
required: yes
aliases: [ name ]
description:
description:
- The description of the SPAN destination group.
aliases: [ descr ]
tenant:
description:
- The name of the tenant.
required: yes
aliases: [ tenant_name ]
state:
description:
- Use C(present) or C(absent) for adding or removing.
- Use C(query) for listing an object or multiple objects.
choices: [ absent, present, query ]
default: present
extends_documentation_fragment: aci
'''
# FIXME: Add more, better examples
EXAMPLES = r'''
- aci_tenant_span_dst_group:
host: apic
username: admin
password: SomeSecretPassword
dst_group: '{{ dst_group }}'
description: '{{ descr }}'
tenant: '{{ tenant }}'
'''
RETURN = r'''
current:
description: The existing configuration from the APIC after the module has finished
returned: success
type: list
sample:
[
{
""fvTenant"": {
""attributes"": {
""descr"": ""Production environment"",
""dn"": ""uni/tn-production"",
""name"": ""production"",
""nameAlias"": """",
""ownerKey"": """",
""ownerTag"": """"
}
}
}
]
error:
description: The error information as returned from the APIC
returned: failure
type: dict
sample:
{
""code"": ""122"",
""text"": ""unknown managed object class foo""
}
raw:
description: The raw output returned by the APIC REST API (xml or json)
returned: parse error
type: string
sample: '\d+)/(?P(\w|-)+)?'
_NETRC_MACHINE = 'gdcvault'
_TESTS = [
{
'url': 'http://www.gdcvault.com/play/1019721/Doki-Doki-Universe-Sweet-Simple',
'md5': '7ce8388f544c88b7ac11c7ab1b593704',
'info_dict': {
'id': '1019721',
'display_id': 'Doki-Doki-Universe-Sweet-Simple',
'ext': 'mp4',
'title': 'Doki-Doki Universe: Sweet, Simple and Genuine (GDC Next 10)'
}
},
{
'url': 'http://www.gdcvault.com/play/1015683/Embracing-the-Dark-Art-of',
'info_dict': {
'id': '1015683',
'display_id': 'Embracing-the-Dark-Art-of',
'ext': 'flv',
'title': 'Embracing the Dark Art of Mathematical Modeling in AI'
},
'params': {
'skip_download': True, # Requires rtmpdump
}
},
{
'url': 'http://www.gdcvault.com/play/1015301/Thexder-Meets-Windows-95-or',
'md5': 'a5eb77996ef82118afbbe8e48731b98e',
'info_dict': {
'id': '1015301',
'display_id': 'Thexder-Meets-Windows-95-or',
'ext': 'flv',
'title': 'Thexder Meets Windows 95, or Writing Great Games in the Windows 95 Environment',
},
'skip': 'Requires login',
},
{
'url': 'http://gdcvault.com/play/1020791/',
'only_matching': True,
},
{
# Hard-coded hostname
'url': 'http://gdcvault.com/play/1023460/Tenacious-Design-and-The-Interface',
'md5': 'a8efb6c31ed06ca8739294960b2dbabd',
'info_dict': {
'id': '1023460',
'ext': 'mp4',
'display_id': 'Tenacious-Design-and-The-Interface',
'title': 'Tenacious Design and The Interface of \'Destiny\'',
},
},
{
# Multiple audios
'url': 'http://www.gdcvault.com/play/1014631/Classic-Game-Postmortem-PAC',
'info_dict': {
'id': '1014631',
'ext': 'flv',
'title': 'How to Create a Good Game - From My Experience of Designing Pac-Man',
},
'params': {
'skip_download': True, # Requires rtmpdump
'format': 'jp', # The japanese audio
}
},
{
# gdc-player.html
'url': 'http://www.gdcvault.com/play/1435/An-American-engine-in-Tokyo',
'info_dict': {
'id': '1435',
'display_id': 'An-American-engine-in-Tokyo',
'ext': 'flv',
'title': 'An American Engine in Tokyo:/nThe collaboration of Epic Games and Square Enix/nFor THE LAST REMINANT',
},
'params': {
'skip_download': True, # Requires rtmpdump
},
},
]
def _login(self, webpage_url, display_id):
username, password = self._get_login_info()
if username is None or password is None:
self.report_warning('It looks like ' + webpage_url + ' requires a login. Try specifying a username and password and try again.')
return None
mobj = re.match(r'(?Phttps?://.*?/).*', webpage_url)
login_url = mobj.group('root_url') + 'api/login.php'
logout_url = mobj.group('root_url') + 'logout'
login_form = {
'email': username,
'password': password,
}
request = sanitized_Request(login_url, urlencode_postdata(login_form))
request.add_header('Content-Type', 'application/x-www-form-urlencoded')
self._download_webpage(request, display_id, 'Logging in')
start_page = self._download_webpage(webpage_url, display_id, 'Getting authenticated video page')
self._download_webpage(logout_url, display_id, 'Logging out')
return start_page
def _real_extract(self, url):
mobj = re.match(self._VALID_URL, url)
video_id = mobj.group('id')
display_id = mobj.group('name') or video_id
webpage_url = 'http://www.gdcvault.com/play/' + video_id
start_page = self._download_webpage(webpage_url, display_id)
direct_url = self._search_regex(
r's1\.addVariable\(""file"",\s*encodeURIComponent\(""(/[^""]+)""\)\);',
start_page, 'url', default=None)
if direct_url:
title = self._html_search_regex(
r'Session Name \s*(.*?) ',
start_page, 'title')
video_url = 'http://www.gdcvault.com' + direct_url
# resolve the url so that we can detect the correct extension
head = self._request_webpage(HEADRequest(video_url), video_id)
video_url = head.geturl()
return {
'id': video_id,
'display_id': display_id,
'url': video_url,
'title': title,
}
PLAYER_REGEX = r''
xml_root = self._html_search_regex(
PLAYER_REGEX, start_page, 'xml root', default=None)
if xml_root is None:
# Probably need to authenticate
login_res = self._login(webpage_url, display_id)
if login_res is None:
self.report_warning('Could not login.')
else:
start_page = login_res
# Grab the url from the authenticated page
xml_root = self._html_search_regex(
PLAYER_REGEX, start_page, 'xml root')
xml_name = self._html_search_regex(
r'',
start_page, 'xml filename')
return {
'_type': 'url_transparent',
'id': video_id,
'display_id': display_id,
'url': '%s/xml/%s' % (xml_root, xml_name),
'ie_key': 'DigitallySpeaking',
}
",1
"dap.initialize')
def test_exists(self, mocked_initialize):
connection = mock.MagicMock()
mocked_initialize.return_value = connection
url = reverse('api:exists')
response = self.client.get(url)
self.assertEqual(response.status_code, 400)
# check that 400 Bad Request errors are proper JSON
self.assertEqual(response['Content-Type'], 'application/json')
self.assertEqual(
json.loads(response.content),
{'error': ""missing key 'mail'""}
)
response = self.client.get(url, {'mail': ''})
self.assertEqual(response.status_code, 400)
result = {
'abc123': {'uid': 'abc123', 'mail': 'peter@example.com'},
}
def search_s(base, scope, filterstr, *args, **kwargs):
if 'peter@example.com' in filterstr:
# if 'hgaccountenabled=TRUE' in filterstr:
# return []
return result.items()
return []
connection.search_s.side_effect = search_s
response = self.client.get(url, {'mail': 'peter@example.com'})
self.assertEqual(response.status_code, 200)
self.assertEqual(response['Content-Type'], 'application/json')
self.assertEqual(json.loads(response.content), True)
response = self.client.get(url, {'mail': 'never@heard.of.com'})
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content), False)
# response = self.client.get(url, {'mail': 'peter@example.com',
# 'hgaccountenabled': ''})
# self.assertEqual(response.status_code, 200)
# self.assertEqual(json.loads(response.content), False)
response = self.client.get(url, {'mail': 'peter@example.com',
'gender': 'male'})
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content), True)
@mock.patch('ldap.initialize')
def test_employee(self, mocked_initialize):
connection = mock.MagicMock()
mocked_initialize.return_value = connection
url = reverse('api:employee')
response = self.client.get(url)
self.assertEqual(response.status_code, 400)
response = self.client.get(url, {'mail': ''})
self.assertEqual(response.status_code, 400)
result = {
'abc123': {'uid': 'abc123',
'mail': 'peter@mozilla.com',
'sn': u'B\xe3ngtsson'},
}
def search_s(base, scope, filterstr, *args, **kwargs):
if 'peter@example.com' in filterstr:
return result.items()
return []
connection.search_s.side_effect = search_s
response = self.client.get(url, {'mail': 'peter@example.com'})
self.assertEqual(response.status_code, 200)
self.assertEqual(response['Content-Type'], 'application/json')
self.assertEqual(json.loads(response.content), True)
response = self.client.get(url, {'mail': 'never@heard.of.com'})
self.assertEqual(response.status_code, 200)
self.assertEqual(response['Content-Type'], 'application/json')
self.assertEqual(json.loads(response.content), False)
@mock.patch('ldap.initialize')
def test_ingroup(self, mocked_initialize):
connection = mock.MagicMock()
mocked_initialize.return_value = connection
url = reverse('api:in-group')
response = self.client.get(url)
self.assertEqual(response.status_code, 400)
response = self.client.get(url, {'mail': ''})
self.assertEqual(response.status_code, 400)
response = self.client.get(url, {'mail': 'peter@example.com'})
self.assertEqual(response.status_code, 400)
response = self.client.get(url, {'mail': 'peter@example.com',
'cn': ''})
self.assertEqual(response.status_code, 400)
result = {
'abc123': {'uid': 'abc123', 'mail': 'peter@example.com'},
}
def search_s(base, scope, filterstr, *args, **kwargs):
if 'ou=groups' in base:
if (
'peter@example.com' in filterstr and
'cn=CrashStats' in filterstr
):
return result.items()
else:
# basic lookup
if 'peter@example.com' in filterstr:
return result.items()
return []
connection.search_s.side_effect = search_s
response = self.client.get(url, {'mail': 'not@head.of.com',
'cn': 'CrashStats'})
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content), False)
response = self.client.get(url, {'mail': 'peter@example.com',
'cn': 'CrashStats'})
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content), True)
response = self.client.get(url, {'mail': 'peter@example.com',
'cn': 'NotInGroup'})
self.assertEqual(response.status_code, 200)
self.assertEqual(json.loads(response.content), False)
",1
"ject with a
white background, small black text and a centred title. Designed to better
mimic MATLAB style plots.
Unspecified arguments will be set to default values when mayaxes is called
(note that default settings are configured for a figure measuring 1024 x 768
pixels and may not display correctly on plots that are significantly larger
or smaller).
=== Inputs ===
'title' Figure title text (default = 'VOID')
'xlabel' X axis label text (default = 'X')
'ylabel' Y axis label text (default = 'Y')
'zlabel' Z axis label text (default = 'Z')
'handle' Graphics handle of object (if bounding box is to be plotted)
'title_size' Font size of the title text (default = 25)
'ticks' Number of divisions on each axis (default = 7)
'font_scaling' Font scaling factor for axis text (default = 0.7)
'background' Background colour (can be 'b' (black) or 'w' (white))
=== Notes ===
Disbaling figure title: specify title_string='void' OR title_string='Void' OR
title_string='VOID' to disable figure title.
Disabling bounding box: specify handle='void' OR handle='Void' OR handle='VOID'
to disable figure bounding box.
=== Usage ===
from mayaxes import mayaxes
mayaxes('Figure title','X axis label','Y axis label','Z axis label')
OR
mayaxes(title_string='TITLE',xlabel='X',ylabel='Y',zlabel='Z',title_size=25,ticks=7,font_scaling=0.7)
=== Example ===
from mayaxes import test_mayaxes
test_mayaxes()
@author: Nathan Donaldson
""""""
def mayaxes(title_string='VOID', xlabel='VOID', ylabel='VOID', zlabel='VOID', handle='VOID', \
title_size=25, ticks=7, font_scaling=0.7, background='w'):
if type(title_string) != str or type(xlabel) != str or type(ylabel) != str or type(zlabel) != str:
print('ERROR: label inputs must all be strings')
return
elif type(ticks) != int:
print('ERROR: number of ticks must be an integer')
return
elif type(font_scaling) != float and type(font_scaling) != int:
print('Error: font scaling factor must be an integer or a float')
return
from mayavi.mlab import axes,title,gcf,outline
# Create axes object
ax = axes()
# Font factor globally adjusts figure text size
ax.axes.font_factor = font_scaling
# Number of ticks along each axis
ax.axes.number_of_labels = ticks
# Set axis labels to input strings
# (spaces are included for padding so that labels do not intersect with axes)
if xlabel=='void' or xlabel=='Void' or xlabel=='VOID':
print 'X axis label title disabled'
else:
ax.axes.x_label = ' ' + xlabel
if ylabel=='void' or ylabel=='Void' or ylabel=='VOID':
print 'Y axis label disabled'
else:
ax.axes.y_label = ylabel + ' '
if zlabel=='void' or zlabel=='Void' or zlabel=='VOID':
print 'Z axis label disabled'
else:
ax.axes.z_label = zlabel + ' '
# Create figure title
if title_string=='void' or title_string=='Void' or title_string=='VOID':
print 'Figure title disabled'
else:
text_title = title(title_string)
text_title.x_position = 0.5
text_title.y_position = 0.9
text_title.property.color = (0.0, 0.0, 0.0)
text_title.actor.text_scale_mode = 'none'
text_title.property.font_size = title_size
text_title.property.justification = 'centered'
# Create bounding box
if handle=='void' or handle=='Void' or handle=='VOID':
print 'Bounding box disabled'
else:
if background == 'w':
bounding_box = outline(handle, color=(0.0, 0.0, 0.0), opacity=0.2)
elif background == 'b':
bounding_box = outline(handle, color=(1.0, 1.0, 1.0), opacity=0.2)
# Set axis, labels and titles to neat black text
#ax.property.color = (0.0, 0.0, 0.0)
#ax.title_text_property.color = (0.0, 0.0, 0.0)
#ax.label_text_property.color = (0.0, 0.0, 0.0)
ax.label_text_property.bold = False
ax.label_text_property.italic = False
ax.title_text_property.italic = False
ax.title_text_property.bold = False
# Reset axis range
ax.axes.use_ranges = True
# Set scene background, axis and text colours
fig = gcf()
if background == 'w':
fig.scene.background = (1.0, 1.0, 1.0)
ax.label_text_property.color = (0.0, 0.0, 0.0)
ax.property.color = (0.0, 0.0, 0.0)
ax.title_text_property.color = (0.0, 0.0, 0.0)
elif background == 'b':
fig.scene.background = (0.0, 0.0, 0.0)
ax.label_text_property.color = (1.0, 1.0, 1.0)
ax.property.color = (1.0, 1.0, 1.0)
ax.title_text_property.color = (1.0, 1.0, 1.0)
fig.scene.parallel_projection = True
def test_mayaxes():
from mayaxes import mayaxes
from scipy import sqrt,sin,meshgrid,linspace,pi
import mayavi.mlab as mlab
resolution = 200
lambda_var = 3
theta = linspace(-lambda_var*2*pi,lambda_var*2*pi,resolution)
x, y = meshgrid(theta, theta)
r = sqrt(x**2 + y**2)
z = sin(r)/r
fig = mlab.figure(size=(1024,768))
surf = mlab.surf(theta,theta,z,colormap='jet',opacity=1.0,warp_scale='auto')
mayaxes(title_string='Figure 1: Diminishing polar cosine series', \
xlabel='X data',ylabel='Y data',zlabel='Z data',handle=surf)
fig.scene.camera.position = [435.4093863309094, 434.1268937227623, 315.90311468125287]
fig.scene.camera.focal_point = [94.434632665253829, 93.152140057106593, -25.071638984402856]
fig.scene.camera.view_angle = 30.0
fig.scene.camera.view_up = [0.0, 0.0, 1.0]
fig.scene.camera.clipping_range = [287.45231734040635, 973.59247058049255]
fig.scene.camera.compute_view_plane_normal()
fig.scene.render()
mlab.show()
",1
"to create the downloadable Word 97 version
of the book (http://diveintopython.org/diveintopython.doc)
Looks for 2 arguments on the command line. The first argument is the input (HTML)
file; the second argument is the output (.doc) file.
Only runs on Windows. Requires Microsoft Word 2000.
Safe to run on the same file(s) more than once. The output file will be
silently overwritten if it already exists.
The script has been modified by xiaq (xiaqqaix@gmail.com) to fit Simplified Chinese version of Microsoft Word.
""""""
__author__ = ""Mark Pilgrim (mark@diveintopython.org)""
__version__ = ""$Revision: 1.2 $""
__date__ = ""$Date: 2004/05/05 21:57:19 $""
__copyright__ = ""Copyright (c) 2001 Mark Pilgrim""
__license__ = ""Python""
import sys, os
from win32com.client import gencache, constants
def makeRealWordDoc(infile, outfile):
word = gencache.EnsureDispatch(""Word.Application"")
try:
worddoc = word.Documents.Open(FileName=infile)
try:
worddoc.TablesOfContents.Add(Range=word.ActiveWindow.Selection.Range, \
RightAlignPageNumbers=1, \
UseHeadingStyles=1, \
UpperHeadingLevel=1, \
LowerHeadingLevel=2, \
IncludePageNumbers=1, \
AddedStyles='', \
UseHyperlinks=1, \
HidePageNumbersInWeb=1)
worddoc.TablesOfContents(1).TabLeader = constants.wdTabLeaderDots
worddoc.TablesOfContents.Format = constants.wdIndexIndent
word.ActiveWindow.ActivePane.View.SeekView = constants.wdSeekCurrentPageHeader
word.Selection.TypeText(Text=""Dive Into Python\t\thttp://diveintopython.org/"")
word.ActiveWindow.ActivePane.View.SeekView = constants.wdSeekCurrentPageFooter
word.NormalTemplate.AutoTextEntries(""- Ò³Âë -"").Insert(Where=word.ActiveWindow.Selection.Range)
word.ActiveWindow.View.Type = constants.wdPrintView
worddoc.TablesOfContents(1).Update()
worddoc.SaveAs(FileName=outfile, \
FileFormat=constants.wdFormatDocument)
finally:
worddoc.Close(0)
del worddoc
finally:
word.Quit()
del word
if __name__ == ""__main__"":
infile = os.path.normpath(os.path.join(os.getcwd(), sys.argv[1]))
outfile = os.path.normpath(os.path.join(os.getcwd(), sys.argv[2]))
makeRealWordDoc(infile, outfile)
",1
" without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice, this
# list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright notice,
# this list of conditions and the following disclaimer in the documentation
# and/or other materials provided with the distribution.
# * Neither the name of the copyright holder nor the names of its contributors
# may be used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS""
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 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.
""""""Package contenant la commande 'scripting alerte info'.""""""
from primaires.interpreteur.masque.parametre import Parametre
from primaires.format.fonctions import echapper_accolades
from primaires.format.date import get_date
class PrmInfo(Parametre):
""""""Commande 'scripting alerte info'""""""
def __init__(self):
""""""Constructeur du paramètre.""""""
Parametre.__init__(self, ""info"", ""info"")
self.schema = """"
self.aide_courte = ""affiche des informations sur l'alerte""
self.aide_longue = \
""Affiche des informations sur l'alerte permettant de la corriger.""
def interpreter(self, personnage, dic_masques):
""""""Méthode d'interprétation de commande""""""
nombre = dic_masques[""nombre""].nombre
try:
alerte = type(self).importeur.scripting.alertes[nombre]
except KeyError:
personnage << ""|err|Ce numéro d'alerte est invalide.|ff|""
else:
msg = ""Informations sur l'alerte {} :"".format(alerte.no)
msg += ""\n S'est produit sur {} {}"".format(alerte.type,
alerte.objet) + "" "" + get_date(alerte.date.timetuple())
msg += ""\n Evenement {}, test {}, ligne {}"".format(
alerte.evenement, echapper_accolades(alerte.test),
alerte.no_ligne)
msg += ""\n {}\n"".format(echapper_accolades(alerte.ligne))
msg += ""\n Message d'erreur : |err|{}|ff|"".format(
echapper_accolades(alerte.message))
if personnage.nom_groupe == ""administrateur"":
msg += ""\n Traceback Python :\n {}"".format(
echapper_accolades(alerte.traceback))
personnage << msg
",1
"out
# 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 Purdue University nor the names of its contributors
# may be used to endorse or promote products derived from this software without
# specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS""
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
""""""Test for Credential cache library.""""""
__copyright__ = 'Copyright (C) 2009, Purdue University'
__license__ = 'BSD'
__version__ = '#TRUNK#'
import unittest
import os
import roster_core
from roster_server import credentials
CONFIG_FILE = 'test_data/roster.conf' # Example in test_data
SCHEMA_FILE = '../roster-core/data/database_schema.sql'
DATA_FILE = 'test_data/test_data.sql'
class TestCredentialsLibrary(unittest.TestCase):
def setUp(self):
self.config_instance = roster_core.Config(file_name=CONFIG_FILE)
self.cred_instance = credentials.CredCache(self.config_instance,
u'sharrell')
db_instance = self.config_instance.GetDb()
db_instance.CreateRosterDatabase()
data = open(DATA_FILE, 'r').read()
db_instance.StartTransaction()
db_instance.cursor.execute(data)
db_instance.EndTransaction()
db_instance.close()
self.core_instance = roster_core.Core(u'sharrell', self.config_instance)
def is_valid_uuid (self, uuid):
""""""
TAKEN FROM THE BLUEZ MODULE
is_valid_uuid (uuid) -> bool
returns True if uuid is a valid 128-bit UUID.
valid UUIDs are always strings taking one of the following forms:
XXXX
XXXXXXXX
XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
where each X is a hexadecimal digit (case insensitive)
""""""
try:
if len (uuid) == 4:
if int (uuid, 16) < 0: return False
elif len (uuid) == 8:
if int (uuid, 16) < 0: return False
elif len (uuid) == 36:
pieces = uuid.split (""-"")
if len (pieces) != 5 or \
len (pieces[0]) != 8 or \
len (pieces[1]) != 4 or \
len (pieces[2]) != 4 or \
len (pieces[3]) != 4 or \
len (pieces[4]) != 12:
return False
[ int (p, 16) for p in pieces ]
else:
return False
except ValueError:
return False
except TypeError:
return False
return True
def testCredentials(self):
self.assertTrue(self.cred_instance.Authenticate(u'sharrell', 'test'))
cred_string = self.cred_instance.GetCredentials(u'sharrell', 'test',
self.core_instance)
self.assertEqual(self.cred_instance.CheckCredential(cred_string,
u'sharrell',
self.core_instance),
u'')
self.assertEqual(self.cred_instance.CheckCredential(u'test', u'sharrell',
self.core_instance),
None)
if( __name__ == '__main__' ):
unittest.main()
",1
"execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#
import os
import sys
# Set variable so that todos are shown in local build
on_rtd = os.environ.get(""READTHEDOCS"") == ""True""
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
sys.path.insert(0, os.path.abspath(""..""))
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
""sphinx.ext.autodoc"",
""sphinx.ext.doctest"",
""sphinx.ext.todo"",
""sphinx.ext.coverage"",
""sphinx.ext.mathjax"",
""sphinx.ext.ifconfig"",
""sphinx.ext.viewcode"",
""sphinxcontrib.bibtex"",
""sphinx.ext.imgconverter"",
]
bibtex_bibfiles = [""source/refs.bib""]
# Add any paths that contain templates here, relative to this directory.
templates_path = [""_templates""]
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
#
# source_suffix = ['.rst', '.md']
source_suffix = "".rst""
# The master toctree document.
master_doc = ""index""
# General information about the project.
project = ""grmpy""
copyright_ = ""2018, grmpy-dev team""
author = ""grmpy-dev team""
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = ""1.0""
# The full version, including alpha/beta/rc tags.
release = ""1.0""
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set ""language"" from the command line for these cases.
language = None
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This patterns also effect to html_static_path and html_extra_path
exclude_patterns = [""_build"", ""Thumbs.db"", "".DS_Store""]
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = ""sphinx""
# If true, `todo` and `todoList` produce output, else they produce nothing. We
# want to supress the output on readthedocs.
if on_rtd:
todo_include_todos = False
else:
todo_include_todos = True
# -- Options for HTML output ----------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#
html_theme = ""sphinx_rtd_theme""
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#
# html_theme_options = {}
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named ""default.css"" will overwrite the builtin ""default.css"".
html_static_path = []
# -- Options for HTMLHelp output ------------------------------------------
# Output file base name for HTML help builder.
htmlhelp_basename = ""grmpydoc""
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#
# 'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#
""pointsize"": ""12pt"",
# Additional stuff for the LaTeX preamble.
#
# 'preamble': '',
# Latex figure (float) alignment
#
""figure_align"": ""htbp"",
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, ""grmpy.tex"", ""grmpy Documentation"", ""Development Team"", ""manual"")
]
# -- Options for manual page output ---------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [(master_doc, ""grmpy"", ""grmpy Documentation"", [author], 1)]
# -- Options for Texinfo output -------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(
master_doc,
""grmpy"",
""grmpy Documentation"",
author,
""grmpy"",
""One line description of project."",
""Miscellaneous"",
)
]
# -- Options for Epub output ----------------------------------------------
# Bibliographic Dublin Core info.
epub_title = project
epub_author = author
epub_publisher = author
epub_copyright = copyright_
# The unique identifier of the text. This can be a ISBN number
# or the project homepage.
#
# epub_identifier = ''
# A unique identification for the text.
#
# epub_uid = ''
# A list of files that should not be packed into the epub file.
epub_exclude_files = [""search.html""]
",1
"iance 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 boundary import ApiCli
class SourceList(ApiCli):
def __init__(self):
ApiCli.__init__(self)
self.path = ""v1/account/sources/""
self.method = ""GET""
def getDescription(self):
return ""Lists the sources in a Boundary account""
",1
"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.
#
# Database Navigator 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 Database Navigator. If not, see
""""""
class ZenCodingPlugin(pluma.Plugin):
""""""A Pluma plugin to implement Zen Coding's HTML and CSS shorthand expander.""""""
def activate(self, window):
actions = [
('ZenCodingMenuAction', None, '_Zen Coding', None, ""Zen Coding tools"", None),
('ZenCodingExpandAction', None, '_Expand abbreviation', 'E', ""Expand abbreviation to raw HTML/CSS"", self.expand_abbreviation),
('ZenCodingExpandWAction', None, 'E_xpand dynamic abbreviation...', 'E', ""Dynamically expand abbreviation as you type"", self.expand_with_abbreviation),
('ZenCodingWrapAction', None, '_Wrap with abbreviation...', 'E', ""Wrap with code expanded from abbreviation"", self.wrap_with_abbreviation),
('ZenCodingInwardAction', None, 'Balance tag _inward', 'I', ""Select inner tag's content"", self.match_pair_inward),
('ZenCodingOutwardAction', None, 'Balance tag _outward', 'O', ""Select outer tag's content"", self.match_pair_outward),
('ZenCodingMergeAction', None, '_Merge lines', 'M', ""Merge all lines of the current selection"", self.merge_lines),
('ZenCodingPrevAction', None, '_Previous edit point', 'Left', ""Place the cursor at the previous edit point"", self.prev_edit_point),
('ZenCodingNextAction', None, '_Next edit point', 'Right', ""Place the cursor at the next edit point"", self.next_edit_point),
('ZenCodingRemoveAction', None, '_Remove tag', 'R', ""Remove a tag"", self.remove_tag),
('ZenCodingSplitAction', None, 'Split or _join tag', 'J', ""Toggle between single and double tag"", self.split_join_tag),
('ZenCodingCommentAction', None, 'Toggle _comment', 'C', ""Toggle an XML or HTML comment"", self.toggle_comment)
]
windowdata = dict()
window.set_data(""ZenCodingPluginDataKey"", windowdata)
windowdata[""action_group""] = gtk.ActionGroup(""PlumaZenCodingPluginActions"")
windowdata[""action_group""].add_actions(actions, window)
manager = window.get_ui_manager()
manager.insert_action_group(windowdata[""action_group""], -1)
windowdata[""ui_id""] = manager.add_ui_from_string(zencoding_ui_str)
window.set_data(""ZenCodingPluginInfo"", windowdata)
self.editor = ZenEditor()
error = self.editor.get_user_settings_error()
if error:
md = gtk.MessageDialog(window, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR,
gtk.BUTTONS_CLOSE, ""There is an error in user settings:"")
message = ""{0} on line {1} at character {2}\n\nUser settings will not be available.""
md.set_title(""Zen Coding error"")
md.format_secondary_text(message.format(error['msg'], error['lineno'], error['offset']))
md.run()
md.destroy()
def deactivate(self, window):
windowdata = window.get_data(""ZenCodingPluginDataKey"")
manager = window.get_ui_manager()
manager.remove_ui(windowdata[""ui_id""])
manager.remove_action_group(windowdata[""action_group""])
def update_ui(self, window):
view = window.get_active_view()
windowdata = window.get_data(""ZenCodingPluginDataKey"")
windowdata[""action_group""].set_sensitive(bool(view and view.get_editable()))
def expand_abbreviation(self, action, window):
self.editor.expand_abbreviation(window)
def expand_with_abbreviation(self, action, window):
self.editor.expand_with_abbreviation(window)
def wrap_with_abbreviation(self, action, window):
self.editor.wrap_with_abbreviation(window)
def match_pair_inward(self, action, window):
self.editor.match_pair_inward(window)
def match_pair_outward(self, action, window):
self.editor.match_pair_outward(window)
def merge_lines(self, action, window):
self.editor.merge_lines(window)
def prev_edit_point(self, action, window):
self.editor.prev_edit_point(window)
def next_edit_point(self, action, window):
self.editor.next_edit_point(window)
def remove_tag(self, action, window):
self.editor.remove_tag(window)
def split_join_tag(self, action, window):
self.editor.split_join_tag(window)
def toggle_comment(self, action, window):
self.editor.toggle_comment(window)
",1
"3 or later;
# http://www.gnu.org/licenses/agpl.html
import os
import re
import shutil
import zipfile
from . import Collection
from .hooks import runHook
from .lang import _
from .utils import ids2str, json, splitFields
class Exporter(object):
def __init__(self, col, did=None):
self.col = col
self.did = did
def exportInto(self, path):
self._escapeCount = 0
file = open(path, ""wb"")
self.doExport(file)
file.close()
def escapeText(self, text):
""Escape newlines, tabs, CSS and quotechar.""
text = text.replace(""\n"", ""
"")
text = text.replace(""\t"", "" "" * 8)
text = re.sub(""(?i)"", """", text)
if ""\"""" in text:
text = ""\"""" + text.replace(""\"""", ""\""\"""") + ""\""""
return text
def cardIds(self):
if not self.did:
cids = self.col.db.list(""select id from cards"")
else:
cids = self.col.decks.cids(self.did, children=True)
self.count = len(cids)
return cids
# Cards as TSV
######################################################################
class TextCardExporter(Exporter):
key = _(""Cards in Plain Text"")
ext = "".txt""
hideTags = True
def __init__(self, col):
Exporter.__init__(self, col)
def doExport(self, file):
ids = sorted(self.cardIds())
# strids = ids2str(ids)
def esc(s):
# strip off the repeated question in answer if exists
s = re.sub(""(?si)^.*
\n*"", """", s)
return self.escapeText(s)
out = """"
for cid in ids:
c = self.col.getCard(cid)
out += esc(c.q())
out += ""\t"" + esc(c.a()) + ""\n""
file.write(out.encode(""utf-8""))
# Notes as TSV
######################################################################
class TextNoteExporter(Exporter):
key = _(""Notes in Plain Text"")
ext = "".txt""
def __init__(self, col):
Exporter.__init__(self, col)
self.includeID = False
self.includeTags = True
def doExport(self, file):
cardIds = self.cardIds()
data = []
for id, flds, tags in self.col.db.execute(""""""
select guid, flds, tags from notes
where id in
(select nid from cards
where cards.id in %s)"""""" % ids2str(cardIds)):
row = []
# note id
if self.includeID:
row.append(str(id))
# fields
row.extend([self.escapeText(f) for f in splitFields(flds)])
# tags
if self.includeTags:
row.append(tags.strip())
data.append(""\t"".join(row))
self.count = len(data)
out = ""\n"".join(data)
file.write(out.encode(""utf-8""))
# Anki decks
######################################################################
# media files are stored in self.mediaFiles, but not exported.
class AnkiExporter(Exporter):
key = _(""Anki 2.0 Deck"")
ext = "".anki2""
def __init__(self, col):
Exporter.__init__(self, col)
self.includeSched = False
self.includeMedia = True
def exportInto(self, path):
# create a new collection at the target
try:
os.unlink(path)
except (IOError, OSError):
pass
self.dst = Collection(path)
self.src = self.col
# find cards
if not self.did:
cids = self.src.db.list(""select id from cards"")
else:
cids = self.src.decks.cids(self.did, children=True)
# copy cards, noting used nids
nids = {}
data = []
for row in self.src.db.execute(
""select * from cards where id in "" + ids2str(cids)):
nids[row[1]] = True
data.append(row)
self.dst.db.executemany(
""insert into cards values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"",
data)
# notes
strnids = ids2str(list(nids.keys()))
notedata = []
for row in self.src.db.all(
""select * from notes where id in ""+strnids):
# remove system tags if not exporting scheduling info
if not self.includeSched:
row = list(row)
row[5] = self.removeSystemTags(row[5])
notedata.append(row)
self.dst.db.executemany(
""insert into notes values (?,?,?,?,?,?,?,?,?,?,?)"",
notedata)
# models used by the notes
mids = self.dst.db.list(
""select distinct mid from notes where id in "" + strnids)
# card history and revlog
if self.includeSched:
data = self.src.db.all(
""select * from revlog where cid in "" + ids2str(cids))
self.dst.db.executemany(
""insert into revlog values (?,?,?,?,?,?,?,?,?)"",
data)
else:
# need to reset card state
self.dst.sched.resetCards(cids)
# models - start with zero
self.dst.models.models = {}
for m in self.src.models.all():
if int(m['id']) in mids:
self.dst.models.update(m)
# decks
if not self.did:
dids = []
else:
dids = [self.did] + [
x[1] for x in self.src.decks.children(self.did)]
dconfs = {}
for d in self.src.decks.all():
if str(d['id']) == ""1"":
continue
if dids and d['id'] not in dids:
continue
if not d['dyn'] and d['conf'] != 1:
if self.includeSched:
dconfs[d['conf']] = True
if not self.includeSched:
# scheduling not included, so reset deck settings to default
d = dict(d)
d['conf'] = 1
self.dst.decks.update(d)
# copy used deck confs
for dc in self.src.decks.allConf():
if dc['id'] in dconfs:
self.dst.decks.updateConf(dc)
# find used media
media = {}
self.mediaDir = self.src.media.dir()
if self.includeMedia:
for row in notedata:
flds = row[6]
mid = row[2]
for file in self.src.media.filesInStr(mid, flds):
media[file] = True
if self.mediaDir:
for fname in os.listdir(self.mediaDir):
if fname.startswith(""_""):
media[fname] = True
self.mediaFiles = list(media.keys())
self.dst.crt = self.src.crt
# todo: tags?
self.count = self.dst.cardCount()
self.dst.setMod()
self.postExport()
self.dst.close()
def postExport(self):
# overwrite to apply customizations to the deck before it's closed,
# such as update the deck description
pass
def removeSystemTags(self, tags):
return self.src.tags.remFromStr(""marked leech"", tags)
# Packaged Anki decks
######################################################################
class AnkiPackageExporter(AnkiExporter):
key = _(""Anki Deck Package"")
ext = "".apkg""
def __init__(self, col):
AnkiExporter.__init__(self, col)
def exportInto(self, path):
# open a zip file
z = zipfile.ZipFile(path, ""w"", zipfile.ZIP_DEFLATED)
# if all decks and scheduling included, full export
if self.includeSched and not self.did:
media = self.exportVerbatim(z)
else:
# otherwise, filter
media = self.exportFiltered(z, path)
# media map
z.writestr(""media"", json.dumps(media))
z.close()
def exportFiltered(self, z, path):
# export into the anki2 file
colfile = path.replace("".apkg"", "".anki2"")
AnkiExporter.exportInto(self, colfile)
z.write(colfile, ""collection.anki2"")
# and media
self.prepareMedia()
media = {}
for c, file in enumerate(self.mediaFiles):
c = str(c)
mpath = os.path.join(self.mediaDir, file)
if os.path.exists(mpath):
z.write(mpath, c)
media[c] = file
# tidy up intermediate files
os.unlink(colfile)
p = path.replace("".apkg"", "".media.db2"")
if os.path.exists(p):
os.unlink(p)
os.chdir(self.mediaDir)
shutil.rmtree(path.replace("".apkg"", "".media""))
return media
def exportVerbatim(self, z):
# close our deck & write it into the zip file, and reopen
self.count = self.col.cardCount()
self.col.close()
z.write(self.col.path, ""collection.anki2"")
self.col.reopen()
# copy all media
if not self.includeMedia:
return {}
media = {}
mdir = self.col.media.dir()
for c, file in enumerate(os.listdir(mdir)):
c = str(c)
mpath = os.path.join(mdir, file)
if os.path.exists(mpath):
z.write(mpath, c)
media[c] = file
return media
def prepareMedia(self):
# chance to move each file in self.mediaFiles into place before media
# is zipped up
pass
# Export modules
##########################################################################
def exporters():
def id(obj):
return (""%s (*%s)"" % (obj.key, obj.ext), obj)
exps = [
id(AnkiPackageExporter),
id(TextNoteExporter),
id(TextCardExporter),
]
runHook(""exportersList"", exps)
return exps
",1
"_num
from misc import is_number
# info
baseurl = 'http://phya.snu.ac.kr/xe/underbbs/'
url ='http://phya.snu.ac.kr/xe/index.php?mid=underbbs&category=372' # notices + general
f = open('srl_notices.txt','r')
num_notices = f.read().split(',')
f.close()
g = open('srl_general.txt','r')
num_general = g.read().split(',')
g.close()
g = open('srl_general.txt','a')
response = urllib.request.urlopen(url)
data = response.read()
text = data.decode('utf-8')
count_new = 0
srl_arr_general = []
text_splitted = text.split('document_srl=')
for i in range(1,len(text_splitted)):
srl = text_splitted[i].split('"">')[0].split('#comment')[0]
if(is_number(srl)):
if(srl not in num_notices and srl not in srl_arr_general): # second statement : to prevent duplication
srl_arr_general.append(srl)
if(srl not in num_general):
count_new += 1
g.write(',' + srl)
print('New post found : ' + srl)
g.close()
if(count_new != 0):
print('Started generating feed...')
# make FeedGenerator
fg = FeedGenerator()
fg.id('asdf')
fg.title('SNU Physics Board RSS feed - general')
fg.author({'name':'Seungwon Park','email':'yyyyy at snu dot ac dot kr'})
fg.link(href='asdf')
fg.subtitle('SNU Physics Board RSS - general')
fg.language('ko')
for srl in srl_arr_general:
print('Parsing post #' + srl + '...')
fe = fg.add_entry()
fe.id(baseurl + srl)
fe.title(post_title(srl))
fe.author({'name':post_author(srl),'email':'unknown'})
fe.link(href = baseurl + srl)
atomfeed = fg.atom_str(pretty=True)
fg.atom_file('general.xml')
print('Added ' + str(count_new) + ' posts to feed.')
else:
print('Posts are up-to-date.')",1
"u can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# 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, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
#
import os
import ConfigParser
import HnTool.modules.util
from HnTool.modules.rule import Rule as MasterRule
class Rule(MasterRule):
def __init__(self, options):
MasterRule.__init__(self, options)
self.short_name=""php""
self.long_name=""Checks security problems on php config file""
self.type=""config""
self.required_files = ['/etc/php5/apache2/php.ini', '/etc/php5/cli/php.ini', '/etc/php.ini']
def requires(self):
return self.required_files
def analyze(self, options):
check_results = self.check_results
conf_files = self.required_files
for php_conf in conf_files:
if os.path.isfile(php_conf):
config = ConfigParser.ConfigParser()
try:
config.read(php_conf)
except ConfigParser.ParsingError, (errno, strerror):
check_results['info'].append('Could not parse %s: %s' % (php_conf, strerror))
continue
if not config.has_section('PHP'):
check_results['info'].append('%s is not a PHP config file' % (php_conf))
continue
if config.has_option('PHP', 'register_globals'):
rg = config.get('PHP', 'register_globals').lower()
if rg == 'on':
check_results['medium'].append('Register globals is on (%s)' % (php_conf))
elif rg == 'off':
check_results['ok'].append('Register globals is off (%s)' % (php_conf))
else:
check_results['info'].append('Unknown value for register globals (%s)' % (php_conf))
else:
check_results['info'].append('Register globals not found (%s)' % (php_conf))
if config.has_option('PHP', 'safe_mode'):
sm = config.get('PHP', 'safe_mode').lower()
if sm == 'on':
check_results['low'].append('Safe mode is on (fake security) (%s)' % (php_conf))
elif sm == 'off':
check_results['info'].append('Safe mode is off (%s)' % (php_conf))
else:
check_results['info'].append('Unknown value for safe mode (%s)' % (php_conf))
else:
check_results['info'].append('Safe mode not found (%s)' % (php_conf))
if config.has_option('PHP', 'display_errors'):
de = config.get('PHP', 'display_errors').lower()
if de == 'on':
check_results['medium'].append('Display errors is on (stdout) (%s)' % (php_conf))
elif de == 'off':
check_results['ok'].append('Display errors is off (%s)' % (php_conf))
elif de == 'stderr':
check_results['info'].append('Display errors set to stderr (%s)' % (php_conf))
else:
check_results['info'].append('Unknown value for display errors (%s)' % (php_conf))
else:
check_results['info'].append('Display errors not found (%s)' % (php_conf))
if config.has_option('PHP', 'expose_php'):
ep = config.get('PHP', 'expose_php').lower()
if ep == 'on':
check_results['low'].append('Expose PHP is on (%s)' % (php_conf))
elif ep == 'off':
check_results['ok'].append('Expose PHP is off (%s)' % (php_conf))
else:
check_results['info'].append('Unknown value for expose PHP (%s)' % (php_conf))
else:
check_results['info'].append('Expose PHP not found (%s)' % (php_conf))
return check_results
",1
"cept 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 .inventory import (
GetInventoryRequest,
Inventory,
ListInventoriesRequest,
ListInventoriesResponse,
InventoryView,
)
from .os_policy import OSPolicy
from .os_policy_assignment_reports import (
GetOSPolicyAssignmentReportRequest,
ListOSPolicyAssignmentReportsRequest,
ListOSPolicyAssignmentReportsResponse,
OSPolicyAssignmentReport,
)
from .os_policy_assignments import (
CreateOSPolicyAssignmentRequest,
DeleteOSPolicyAssignmentRequest,
GetOSPolicyAssignmentRequest,
ListOSPolicyAssignmentRevisionsRequest,
ListOSPolicyAssignmentRevisionsResponse,
ListOSPolicyAssignmentsRequest,
ListOSPolicyAssignmentsResponse,
OSPolicyAssignment,
OSPolicyAssignmentOperationMetadata,
UpdateOSPolicyAssignmentRequest,
)
from .osconfig_common import FixedOrPercent
from .patch_deployments import (
CreatePatchDeploymentRequest,
DeletePatchDeploymentRequest,
GetPatchDeploymentRequest,
ListPatchDeploymentsRequest,
ListPatchDeploymentsResponse,
MonthlySchedule,
OneTimeSchedule,
PatchDeployment,
PausePatchDeploymentRequest,
RecurringSchedule,
ResumePatchDeploymentRequest,
UpdatePatchDeploymentRequest,
WeekDayOfMonth,
WeeklySchedule,
)
from .patch_jobs import (
AptSettings,
CancelPatchJobRequest,
ExecStep,
ExecStepConfig,
ExecutePatchJobRequest,
GcsObject,
GetPatchJobRequest,
GooSettings,
Instance,
ListPatchJobInstanceDetailsRequest,
ListPatchJobInstanceDetailsResponse,
ListPatchJobsRequest,
ListPatchJobsResponse,
PatchConfig,
PatchInstanceFilter,
PatchJob,
PatchJobInstanceDetails,
PatchRollout,
WindowsUpdateSettings,
YumSettings,
ZypperSettings,
)
from .vulnerability import (
CVSSv3,
GetVulnerabilityReportRequest,
ListVulnerabilityReportsRequest,
ListVulnerabilityReportsResponse,
VulnerabilityReport,
)
__all__ = (
""GetInventoryRequest"",
""Inventory"",
""ListInventoriesRequest"",
""ListInventoriesResponse"",
""InventoryView"",
""OSPolicy"",
""GetOSPolicyAssignmentReportRequest"",
""ListOSPolicyAssignmentReportsRequest"",
""ListOSPolicyAssignmentReportsResponse"",
""OSPolicyAssignmentReport"",
""CreateOSPolicyAssignmentRequest"",
""DeleteOSPolicyAssignmentRequest"",
""GetOSPolicyAssignmentRequest"",
""ListOSPolicyAssignmentRevisionsRequest"",
""ListOSPolicyAssignmentRevisionsResponse"",
""ListOSPolicyAssignmentsRequest"",
""ListOSPolicyAssignmentsResponse"",
""OSPolicyAssignment"",
""OSPolicyAssignmentOperationMetadata"",
""UpdateOSPolicyAssignmentRequest"",
""FixedOrPercent"",
""CreatePatchDeploymentRequest"",
""DeletePatchDeploymentRequest"",
""GetPatchDeploymentRequest"",
""ListPatchDeploymentsRequest"",
""ListPatchDeploymentsResponse"",
""MonthlySchedule"",
""OneTimeSchedule"",
""PatchDeployment"",
""PausePatchDeploymentRequest"",
""RecurringSchedule"",
""ResumePatchDeploymentRequest"",
""UpdatePatchDeploymentRequest"",
""WeekDayOfMonth"",
""WeeklySchedule"",
""AptSettings"",
""CancelPatchJobRequest"",
""ExecStep"",
""ExecStepConfig"",
""ExecutePatchJobRequest"",
""GcsObject"",
""GetPatchJobRequest"",
""GooSettings"",
""Instance"",
""ListPatchJobInstanceDetailsRequest"",
""ListPatchJobInstanceDetailsResponse"",
""ListPatchJobsRequest"",
""ListPatchJobsResponse"",
""PatchConfig"",
""PatchInstanceFilter"",
""PatchJob"",
""PatchJobInstanceDetails"",
""PatchRollout"",
""WindowsUpdateSettings"",
""YumSettings"",
""ZypperSettings"",
""CVSSv3"",
""GetVulnerabilityReportRequest"",
""ListVulnerabilityReportsRequest"",
""ListVulnerabilityReportsResponse"",
""VulnerabilityReport"",
)
",1
"ternatives
from django.template.loader import get_template
from django.utils import timezone
from invitations.models import Invitation
logger = logging.getLogger('email')
sentry = logging.getLogger('sentry')
def send_invite(message):
try:
invite = Invitation.objects.get(
id=message.get('id'),
status__in=[Invitation.PENDING, Invitation.ERROR],
)
except Invitation.DoesNotExist:
sentry.error(""Invitation to send not found"", exc_info=True, extra={'message': message})
return
invite.status = Invitation.PROCESSING
invite.save()
context = {
'invite': invite,
'domain': Site.objects.get_current().domain,
}
subject = ""[ContactOtter] Invitation to join ContactOtter from %s"" % (invite.sender)
if invite.book:
subject = ""[ContactOtter] Invitation to share %s's contact book"" % (invite.sender)
txt = get_template('email/invitation.txt').render(context)
html = get_template('email/invitation.html').render(context)
try:
message = EmailMultiAlternatives(
subject=subject,
body=txt,
from_email=""ContactOtter "",
to=[invite.email,],
)
message.attach_alternative(html, ""text/html"")
message.send()
invite.status = Invitation.SENT
invite.sent = timezone.now()
invite.save()
except:
sentry.exception('Problem sending invite', exc_info=True, extra={'invite_id': invite.id})
invite.status = Invitation.ERROR
invite.save()
",1
"):
class X(Structure):
_fields_ = [(""a"", c_int)]
class Y(X):
_fields_ = [(""b"", c_int)]
class Z(X):
pass
self.assertEqual(sizeof(X), sizeof(c_int))
self.assertEqual(sizeof(Y), sizeof(c_int)*2)
self.assertEqual(sizeof(Z), sizeof(c_int))
self.assertEqual(X._fields_, [(""a"", c_int)])
self.assertEqual(Y._fields_, [(""b"", c_int)])
self.assertEqual(Z._fields_, [(""a"", c_int)])
def test_subclass_delayed(self):
class X(Structure):
pass
self.assertEqual(sizeof(X), 0)
X._fields_ = [(""a"", c_int)]
class Y(X):
pass
self.assertEqual(sizeof(Y), sizeof(X))
Y._fields_ = [(""b"", c_int)]
class Z(X):
pass
self.assertEqual(sizeof(X), sizeof(c_int))
self.assertEqual(sizeof(Y), sizeof(c_int)*2)
self.assertEqual(sizeof(Z), sizeof(c_int))
self.assertEqual(X._fields_, [(""a"", c_int)])
self.assertEqual(Y._fields_, [(""b"", c_int)])
self.assertEqual(Z._fields_, [(""a"", c_int)])
class StructureTestCase(unittest.TestCase):
formats = {""c"": c_char,
""b"": c_byte,
""B"": c_ubyte,
""h"": c_short,
""H"": c_ushort,
""i"": c_int,
""I"": c_uint,
""l"": c_long,
""L"": c_ulong,
""q"": c_longlong,
""Q"": c_ulonglong,
""f"": c_float,
""d"": c_double,
}
def test_simple_structs(self):
for code, tp in self.formats.items():
class X(Structure):
_fields_ = [(""x"", c_char),
(""y"", tp)]
self.assertEqual((sizeof(X), code),
(calcsize(""c%c0%c"" % (code, code)), code))
def test_unions(self):
for code, tp in self.formats.items():
class X(Union):
_fields_ = [(""x"", c_char),
(""y"", tp)]
self.assertEqual((sizeof(X), code),
(calcsize(""%c"" % (code)), code))
def test_struct_alignment(self):
class X(Structure):
_fields_ = [(""x"", c_char * 3)]
self.assertEqual(alignment(X), calcsize(""s""))
self.assertEqual(sizeof(X), calcsize(""3s""))
class Y(Structure):
_fields_ = [(""x"", c_char * 3),
(""y"", c_int)]
self.assertEqual(alignment(Y), calcsize(""i""))
self.assertEqual(sizeof(Y), calcsize(""3si""))
class SI(Structure):
_fields_ = [(""a"", X),
(""b"", Y)]
self.assertEqual(alignment(SI), max(alignment(Y), alignment(X)))
self.assertEqual(sizeof(SI), calcsize(""3s0i 3si 0i""))
class IS(Structure):
_fields_ = [(""b"", Y),
(""a"", X)]
self.assertEqual(alignment(SI), max(alignment(X), alignment(Y)))
self.assertEqual(sizeof(IS), calcsize(""3si 3s 0i""))
class XX(Structure):
_fields_ = [(""a"", X),
(""b"", X)]
self.assertEqual(alignment(XX), alignment(X))
self.assertEqual(sizeof(XX), calcsize(""3s 3s 0s""))
def test_emtpy(self):
# I had problems with these
#
# Although these are patological cases: Empty Structures!
class X(Structure):
_fields_ = []
class Y(Union):
_fields_ = []
# Is this really the correct alignment, or should it be 0?
self.assertTrue(alignment(X) == alignment(Y) == 1)
self.assertTrue(sizeof(X) == sizeof(Y) == 0)
class XX(Structure):
_fields_ = [(""a"", X),
(""b"", X)]
self.assertEqual(alignment(XX), 1)
self.assertEqual(sizeof(XX), 0)
def test_fields(self):
# test the offset and size attributes of Structure/Unoin fields.
class X(Structure):
_fields_ = [(""x"", c_int),
(""y"", c_char)]
self.assertEqual(X.x.offset, 0)
self.assertEqual(X.x.size, sizeof(c_int))
self.assertEqual(X.y.offset, sizeof(c_int))
self.assertEqual(X.y.size, sizeof(c_char))
# readonly
self.assertRaises((TypeError, AttributeError), setattr, X.x, ""offset"", 92)
self.assertRaises((TypeError, AttributeError), setattr, X.x, ""size"", 92)
class X(Union):
_fields_ = [(""x"", c_int),
(""y"", c_char)]
self.assertEqual(X.x.offset, 0)
self.assertEqual(X.x.size, sizeof(c_int))
self.assertEqual(X.y.offset, 0)
self.assertEqual(X.y.size, sizeof(c_char))
# readonly
self.assertRaises((TypeError, AttributeError), setattr, X.x, ""offset"", 92)
self.assertRaises((TypeError, AttributeError), setattr, X.x, ""size"", 92)
# XXX Should we check nested data types also?
# offset is always relative to the class...
def test_packed(self):
class X(Structure):
_fields_ = [(""a"", c_byte),
(""b"", c_longlong)]
_pack_ = 1
self.assertEqual(sizeof(X), 9)
self.assertEqual(X.b.offset, 1)
class X(Structure):
_fields_ = [(""a"", c_byte),
(""b"", c_longlong)]
_pack_ = 2
self.assertEqual(sizeof(X), 10)
self.assertEqual(X.b.offset, 2)
class X(Structure):
_fields_ = [(""a"", c_byte),
(""b"", c_longlong)]
_pack_ = 4
self.assertEqual(sizeof(X), 12)
self.assertEqual(X.b.offset, 4)
import struct
longlong_size = struct.calcsize(""q"")
longlong_align = struct.calcsize(""bq"") - longlong_size
class X(Structure):
_fields_ = [(""a"", c_byte),
(""b"", c_longlong)]
_pack_ = 8
self.assertEqual(sizeof(X), longlong_align + longlong_size)
self.assertEqual(X.b.offset, min(8, longlong_align))
d = {""_fields_"": [(""a"", ""b""),
(""b"", ""q"")],
""_pack_"": -1}
self.assertRaises(ValueError, type(Structure), ""X"", (Structure,), d)
# Issue 15989
d = {""_fields_"": [(""a"", c_byte)],
""_pack_"": _testcapi.INT_MAX + 1}
self.assertRaises(ValueError, type(Structure), ""X"", (Structure,), d)
d = {""_fields_"": [(""a"", c_byte)],
""_pack_"": _testcapi.UINT_MAX + 2}
self.assertRaises(ValueError, type(Structure), ""X"", (Structure,), d)
def test_initializers(self):
class Person(Structure):
_fields_ = [(""name"", c_char*6),
(""age"", c_int)]
self.assertRaises(TypeError, Person, 42)
self.assertRaises(ValueError, Person, b""asldkjaslkdjaslkdj"")
self.assertRaises(TypeError, Person, ""Name"", ""HI"")
# short enough
self.assertEqual(Person(b""12345"", 5).name, b""12345"")
# exact fit
self.assertEqual(Person(b""123456"", 5).name, b""123456"")
# too long
self.assertRaises(ValueError, Person, b""1234567"", 5)
def test_conflicting_initializers(self):
class POINT(Structure):
_fields_ = [(""x"", c_int), (""y"", c_int)]
# conflicting positional and keyword args
self.assertRaises(TypeError, POINT, 2, 3, x=4)
self.assertRaises(TypeError, POINT, 2, 3, y=4)
# too many initializers
self.assertRaises(TypeError, POINT, 2, 3, 4)
def test_keyword_initializers(self):
class POINT(Structure):
_fields_ = [(""x"", c_int), (""y"", c_int)]
pt = POINT(1, 2)
self.assertEqual((pt.x, pt.y), (1, 2))
pt = POINT(y=2, x=1)
self.assertEqual((pt.x, pt.y), (1, 2))
def test_invalid_field_types(self):
class POINT(Structure):
pass
self.assertRaises(TypeError, setattr, POINT, ""_fields_"", [(""x"", 1), (""y"", 2)])
def test_invalid_name(self):
# field name must be string
def declare_with_name(name):
class S(Structure):
_fields_ = [(name, c_int)]
self.assertRaises(TypeError, declare_with_name, b""x"")
def test_intarray_fields(self):
class SomeInts(Structure):
_fields_ = [(""a"", c_int * 4)]
# can use tuple to initialize array (but not list!)
self.assertEqual(SomeInts((1, 2)).a[:], [1, 2, 0, 0])
self.assertEqual(SomeInts((1, 2)).a[::], [1, 2, 0, 0])
self.assertEqual(SomeInts((1, 2)).a[::-1], [0, 0, 2, 1])
self.assertEqual(SomeInts((1, 2)).a[::2], [1, 0])
self.assertEqual(SomeInts((1, 2)).a[1:5:6], [2])
self.assertEqual(SomeInts((1, 2)).a[6:4:-1], [])
self.assertEqual(SomeInts((1, 2, 3, 4)).a[:], [1, 2, 3, 4])
self.assertEqual(SomeInts((1, 2, 3, 4)).a[::], [1, 2, 3, 4])
# too long
# XXX Should raise ValueError?, not RuntimeError
self.assertRaises(RuntimeError, SomeInts, (1, 2, 3, 4, 5))
def test_nested_initializers(self):
# test initializing nested structures
class Phone(Structure):
_fields_ = [(""areacode"", c_char*6),
(""number"", c_char*12)]
class Person(Structure):
_fields_ = [(""name"", c_char * 12),
(""phone"", Phone),
(""age"", c_int)]
p = Person(b""Someone"", (b""1234"", b""5678""), 5)
self.assertEqual(p.name, b""Someone"")
self.assertEqual(p.phone.areacode, b""1234"")
self.assertEqual(p.phone.number, b""5678"")
self.assertEqual(p.age, 5)
def test_structures_with_wchar(self):
try:
c_wchar
except NameError:
return # no unicode
class PersonW(Structure):
_fields_ = [(""name"", c_wchar * 12),
(""age"", c_int)]
p = PersonW(""Someone \xe9"")
self.assertEqual(p.name, ""Someone \xe9"")
self.assertEqual(PersonW(""1234567890"").name, ""1234567890"")
self.assertEqual(PersonW(""12345678901"").name, ""12345678901"")
# exact fit
self.assertEqual(PersonW(""123456789012"").name, ""123456789012"")
#too long
self.assertRaises(ValueError, PersonW, ""1234567890123"")
def test_init_errors(self):
class Phone(Structure):
_fields_ = [(""areacode"", c_char*6),
(""number"", c_char*12)]
class Person(Structure):
_fields_ = [(""name"", c_char * 12),
(""phone"", Phone),
(""age"", c_int)]
cls, msg = self.get_except(Person, b""Someone"", (1, 2))
self.assertEqual(cls, RuntimeError)
self.assertEqual(msg,
""(Phone) : ""
""expected string, int found"")
cls, msg = self.get_except(Person, b""Someone"", (b""a"", b""b"", b""c""))
self.assertEqual(cls, RuntimeError)
if issubclass(Exception, object):
self.assertEqual(msg,
""(Phone) : too many initializers"")
else:
self.assertEqual(msg, ""(Phone) TypeError: too many initializers"")
def test_huge_field_name(self):
# issue12881: segfault with large structure field names
def create_class(length):
class S(Structure):
_fields_ = [('x' * length, c_int)]
for length in [10 ** i for i in range(0, 8)]:
try:
create_class(length)
except MemoryError:
# MemoryErrors are OK, we just don't want to segfault
pass
def get_except(self, func, *args):
try:
func(*args)
except Exception as detail:
return detail.__class__, str(detail)
## def test_subclass_creation(self):
## meta = type(Structure)
## # same as 'class X(Structure): pass'
## # fails, since we need either a _fields_ or a _abstract_ attribute
## cls, msg = self.get_except(meta, ""X"", (Structure,), {})
## self.assertEqual((cls, msg),
## (AttributeError, ""class must define a '_fields_' attribute""))
def test_abstract_class(self):
class X(Structure):
_abstract_ = ""something""
# try 'X()'
cls, msg = self.get_except(eval, ""X()"", locals())
self.assertEqual((cls, msg), (TypeError, ""abstract class""))
def test_methods(self):
## class X(Structure):
## _fields_ = []
self.assertTrue(""in_dll"" in dir(type(Structure)))
self.assertTrue(""from_address"" in dir(type(Structure)))
self.assertTrue(""in_dll"" in dir(type(Structure)))
def test_positional_args(self):
# see also http://bugs.python.org/issue5042
class W(Structure):
_fields_ = [(""a"", c_int), (""b"", c_int)]
class X(W):
_fields_ = [(""c"", c_int)]
class Y(X):
pass
class Z(Y):
_fields_ = [(""d"", c_int), (""e"", c_int), (""f"", c_int)]
z = Z(1, 2, 3, 4, 5, 6)
self.assertEqual((z.a, z.b, z.c, z.d, z.e, z.f),
(1, 2, 3, 4, 5, 6))
z = Z(1)
self.assertEqual((z.a, z.b, z.c, z.d, z.e, z.f),
(1, 0, 0, 0, 0, 0))
self.assertRaises(TypeError, lambda: Z(1, 2, 3, 4, 5, 6, 7))
class PointerMemberTestCase(unittest.TestCase):
def test(self):
# a Structure with a POINTER field
class S(Structure):
_fields_ = [(""array"", POINTER(c_int))]
s = S()
# We can assign arrays of the correct type
s.array = (c_int * 3)(1, 2, 3)
items = [s.array[i] for i in range(3)]
self.assertEqual(items, [1, 2, 3])
# The following are bugs, but are included here because the unittests
# also describe the current behaviour.
#
# This fails with SystemError: bad arg to internal function
# or with IndexError (with a patch I have)
s.array[0] = 42
items = [s.array[i] for i in range(3)]
self.assertEqual(items, [42, 2, 3])
s.array[0] = 1
## s.array[1] = 42
items = [s.array[i] for i in range(3)]
self.assertEqual(items, [1, 2, 3])
def test_none_to_pointer_fields(self):
class S(Structure):
_fields_ = [(""x"", c_int),
(""p"", POINTER(c_int))]
s = S()
s.x = 12345678
s.p = None
self.assertEqual(s.x, 12345678)
class TestRecursiveStructure(unittest.TestCase):
def test_contains_itself(self):
class Recursive(Structure):
pass
try:
Recursive._fields_ = [(""next"", Recursive)]
except AttributeError as details:
self.assertTrue(""Structure or union cannot contain itself"" in
str(details))
else:
self.fail(""Structure or union cannot contain itself"")
def test_vice_versa(self):
class First(Structure):
pass
class Second(Structure):
pass
First._fields_ = [(""second"", Second)]
try:
Second._fields_ = [(""first"", First)]
except AttributeError as details:
self.assertTrue(""_fields_ is final"" in
str(details))
else:
self.fail(""AttributeError not raised"")
if __name__ == '__main__':
unittest.main()
",1
" modify it
# under the terms of the MIT License; see LICENSE file for more details.
""""""Create oauthclient tables.""""""
import sqlalchemy as sa
import sqlalchemy_utils
from alembic import op
from sqlalchemy.engine.reflection import Inspector
# revision identifiers, used by Alembic.
revision = '97bbc733896c'
down_revision = '44ab9963e8cf'
branch_labels = ()
depends_on = '9848d0149abd'
def upgrade():
""""""Upgrade database.""""""
op.create_table(
'oauthclient_remoteaccount',
sa.Column('id', sa.Integer(), nullable=False),
sa.Column('user_id', sa.Integer(), nullable=False),
sa.Column('client_id', sa.String(length=255), nullable=False),
sa.Column(
'extra_data',
sqlalchemy_utils.JSONType(),
nullable=False),
sa.ForeignKeyConstraint(['user_id'], [u'accounts_user.id'], ),
sa.PrimaryKeyConstraint('id'),
sa.UniqueConstraint('user_id', 'client_id')
)
op.create_table(
'oauthclient_useridentity',
sa.Column('id', sa.String(length=255), nullable=False),
sa.Column('method', sa.String(length=255), nullable=False),
sa.Column('id_user', sa.Integer(), nullable=False),
sa.ForeignKeyConstraint(['id_user'], [u'accounts_user.id'], ),
sa.PrimaryKeyConstraint('id', 'method')
)
op.create_index(
'useridentity_id_user_method', 'oauthclient_useridentity',
['id_user', 'method'], unique=True
)
op.create_table(
'oauthclient_remotetoken',
sa.Column('id_remote_account', sa.Integer(), nullable=False),
sa.Column('token_type', sa.String(length=40), nullable=False),
sa.Column(
'access_token',
sqlalchemy_utils.EncryptedType(),
nullable=False),
sa.Column('secret', sa.Text(), nullable=False),
sa.ForeignKeyConstraint(
['id_remote_account'], [u'oauthclient_remoteaccount.id'],
name='fk_oauthclient_remote_token_remote_account'
),
sa.PrimaryKeyConstraint('id_remote_account', 'token_type')
)
def downgrade():
""""""Downgrade database.""""""
ctx = op.get_context()
insp = Inspector.from_engine(ctx.connection.engine)
op.drop_table('oauthclient_remotetoken')
for fk in insp.get_foreign_keys('oauthclient_useridentity'):
if fk['referred_table'] == 'accounts_user':
op.drop_constraint(
op.f(fk['name']),
'oauthclient_useridentity',
type_='foreignkey'
)
op.drop_index(
'useridentity_id_user_method',
table_name='oauthclient_useridentity')
op.drop_table('oauthclient_useridentity')
op.drop_table('oauthclient_remoteaccount')
",1
"opaque_keys.edx.keys import CourseKey
def get_mutually_exclusive_required_option(options, *selections):
""""""
Validates that exactly one of the 2 given options is specified.
Returns the name of the found option.
""""""
selected = [sel for sel in selections if options.get(sel)]
if len(selected) != 1:
selection_string = ', '.join(f'--{selection}' for selection in selections)
raise CommandError(f'Must specify exactly one of {selection_string}')
return selected[0]
def validate_mutually_exclusive_option(options, option_1, option_2):
""""""
Validates that both of the 2 given options are not specified.
""""""
if options.get(option_1) and options.get(option_2):
raise CommandError(f'Both --{option_1} and --{option_2} cannot be specified.')
def validate_dependent_option(options, dependent_option, depending_on_option):
""""""
Validates that option_1 is specified if dependent_option is specified.
""""""
if options.get(dependent_option) and not options.get(depending_on_option):
raise CommandError(f'Option --{dependent_option} requires option --{depending_on_option}.')
def parse_course_keys(course_key_strings):
""""""
Parses and returns a list of CourseKey objects from the given
list of course key strings.
""""""
try:
return [CourseKey.from_string(course_key_string) for course_key_string in course_key_strings]
except InvalidKeyError as error:
raise CommandError('Invalid key specified: {}'.format(str(error))) # lint-amnesty, pylint: disable=raise-missing-from
",1
" ConfigNothing, NoSave
from enigma import eAVSwitch, getDesktop
from SystemInfo import SystemInfo
from os import path as os_path
class AVSwitch:
def setInput(self, input):
INPUT = { ""ENCODER"": 0, ""SCART"": 1, ""AUX"": 2 }
eAVSwitch.getInstance().setInput(INPUT[input])
def setColorFormat(self, value):
eAVSwitch.getInstance().setColorFormat(value)
def setAspectRatio(self, value):
eAVSwitch.getInstance().setAspectRatio(value)
def setSystem(self, value):
eAVSwitch.getInstance().setVideomode(value)
def getOutputAspect(self):
valstr = config.av.aspectratio.value
if valstr in (""4_3_letterbox"", ""4_3_panscan""): # 4:3
return (4,3)
elif valstr == ""16_9"": # auto ... 4:3 or 16:9
try:
aspect_str = open(""/proc/stb/vmpeg/0/aspect"", ""r"").read()
if aspect_str == ""1"": # 4:3
return (4,3)
except IOError:
pass
elif valstr in (""16_9_always"", ""16_9_letterbox""): # 16:9
pass
elif valstr in (""16_10_letterbox"", ""16_10_panscan""): # 16:10
return (16,10)
return (16,9)
def getFramebufferScale(self):
aspect = self.getOutputAspect()
fb_size = getDesktop(0).size()
return (aspect[0] * fb_size.height(), aspect[1] * fb_size.width())
def getAspectRatioSetting(self):
valstr = config.av.aspectratio.value
if valstr == ""4_3_letterbox"":
val = 0
elif valstr == ""4_3_panscan"":
val = 1
elif valstr == ""16_9"":
val = 2
elif valstr == ""16_9_always"":
val = 3
elif valstr == ""16_10_letterbox"":
val = 4
elif valstr == ""16_10_panscan"":
val = 5
elif valstr == ""16_9_letterbox"":
val = 6
return val
def setAspectWSS(self, aspect=None):
if not config.av.wss.value:
value = 2 # auto(4:3_off)
else:
value = 1 # auto
eAVSwitch.getInstance().setWSS(value)
def InitAVSwitch():
config.av = ConfigSubsection()
config.av.yuvenabled = ConfigBoolean(default=False)
colorformat_choices = {""cvbs"": _(""CVBS""), ""rgb"": _(""RGB""), ""svideo"": _(""S-Video"")}
# when YUV is not enabled, don't let the user select it
if config.av.yuvenabled.value:
colorformat_choices[""yuv""] = _(""YPbPr"")
# ikseong
config.av.colorformat = ConfigSelection(choices=colorformat_choices, default=""cvbs"")
config.av.aspectratio = ConfigSelection(choices={
""4_3_letterbox"": _(""4:3 Letterbox""),
""4_3_panscan"": _(""4:3 PanScan""),
""16_9"": _(""16:9""),
""16_9_always"": _(""16:9 always""),
""16_10_letterbox"": _(""16:10 Letterbox""),
""16_10_panscan"": _(""16:10 PanScan""),
""16_9_letterbox"": _(""16:9 Letterbox"")},
default = ""4_3_letterbox"")
config.av.aspect = ConfigSelection(choices={
""4_3"": _(""4:3""),
""16_9"": _(""16:9""),
""16_10"": _(""16:10""),
""auto"": _(""Automatic"")},
default = ""auto"")
config.av.policy_169 = ConfigSelection(choices={
# TRANSLATORS: (aspect ratio policy: black bars on top/bottom) in doubt, keep english term.
""letterbox"": _(""Letterbox""),
# TRANSLATORS: (aspect ratio policy: cropped content on left/right) in doubt, keep english term
""panscan"": _(""Pan&Scan""),
# TRANSLATORS: (aspect ratio policy: display as fullscreen, even if this breaks the aspect)
""scale"": _(""Just Scale"")},
default = ""letterbox"")
config.av.policy_43 = ConfigSelection(choices={
# TRANSLATORS: (aspect ratio policy: black bars on left/right) in doubt, keep english term.
""pillarbox"": _(""Pillarbox""),
# TRANSLATORS: (aspect ratio policy: cropped content on left/right) in doubt, keep english term
""panscan"": _(""Pan&Scan""),
# TRANSLATORS: (aspect ratio policy: display as fullscreen, with stretching the left/right)
""nonlinear"": _(""Nonlinear""),
# TRANSLATORS: (aspect ratio policy: display as fullscreen, even if this breaks the aspect)
""scale"": _(""Just Scale"")},
default = ""pillarbox"")
config.av.tvsystem = ConfigSelection(choices = {""pal"": _(""PAL""), ""ntsc"": _(""NTSC""), ""multinorm"": _(""multinorm"")}, default=""pal"")
config.av.wss = ConfigEnableDisable(default = True)
config.av.defaultac3 = ConfigYesNo(default = False)
config.av.generalAC3delay = ConfigSelectionNumber(-1000, 1000, 25, default = 0)
config.av.generalPCMdelay = ConfigSelectionNumber(-1000, 1000, 25, default = 0)
config.av.vcrswitch = ConfigEnableDisable(default = False)
iAVSwitch = AVSwitch()
def setColorFormat(configElement):
map = {""cvbs"": 0, ""rgb"": 1, ""svideo"": 2, ""yuv"": 3}
iAVSwitch.setColorFormat(map[configElement.value])
def setAspectRatio(configElement):
map = {""4_3_letterbox"": 0, ""4_3_panscan"": 1, ""16_9"": 2, ""16_9_always"": 3, ""16_10_letterbox"": 4, ""16_10_panscan"": 5, ""16_9_letterbox"" : 6}
iAVSwitch.setAspectRatio(map[configElement.value])
def setSystem(configElement):
map = {""pal"": 0, ""ntsc"": 1, ""multinorm"" : 2}
iAVSwitch.setSystem(map[configElement.value])
def setWSS(configElement):
iAVSwitch.setAspectWSS()
# this will call the ""setup-val"" initial
config.av.colorformat.addNotifier(setColorFormat)
config.av.aspectratio.addNotifier(setAspectRatio)
config.av.tvsystem.addNotifier(setSystem)
config.av.wss.addNotifier(setWSS)
iAVSwitch.setInput(""ENCODER"") # init on startup
SystemInfo[""ScartSwitch""] = eAVSwitch.getInstance().haveScartSwitch()
try:
can_downmix = open(""/proc/stb/audio/ac3_choices"", ""r"").read()[:-1].find(""downmix"") != -1
except:
can_downmix = False
SystemInfo[""CanDownmixAC3""] = can_downmix
if can_downmix:
def setAC3Downmix(configElement):
open(""/proc/stb/audio/ac3"", ""w"").write(configElement.value and ""downmix"" or ""passthrough"")
config.av.downmix_ac3 = ConfigYesNo(default = True)
config.av.downmix_ac3.addNotifier(setAC3Downmix)
try:
can_downmix_aac = open(""/proc/stb/audio/aac_choices"", ""r"").read()[:-1].find(""downmix"") != -1
except:
can_downmix_aac = False
SystemInfo[""CanDownmixAAC""] = can_downmix_aac
if can_downmix_aac:
def setAACDownmix(configElement):
open(""/proc/stb/audio/aac"", ""w"").write(configElement.value and ""downmix"" or ""passthrough"")
config.av.downmix_aac = ConfigYesNo(default = True)
config.av.downmix_aac.addNotifier(setAACDownmix)
try:
can_osd_alpha = open(""/proc/stb/video/alpha"", ""r"") and True or False
except:
can_osd_alpha = False
SystemInfo[""CanChangeOsdAlpha""] = can_osd_alpha
def setAlpha(config):
open(""/proc/stb/video/alpha"", ""w"").write(str(config.value))
if can_osd_alpha:
config.av.osd_alpha = ConfigSlider(default=255, limits=(0,255))
config.av.osd_alpha.addNotifier(setAlpha)
if os_path.exists(""/proc/stb/vmpeg/0/pep_scaler_sharpness""):
def setScaler_sharpness(config):
myval = int(config.value)
try:
print ""--> setting scaler_sharpness to: %0.8X"" % myval
open(""/proc/stb/vmpeg/0/pep_scaler_sharpness"", ""w"").write(""%0.8X"" % myval)
open(""/proc/stb/vmpeg/0/pep_apply"", ""w"").write(""1"")
except IOError:
print ""couldn't write pep_scaler_sharpness""
config.av.scaler_sharpness = ConfigSlider(default=13, limits=(0,26))
config.av.scaler_sharpness.addNotifier(setScaler_sharpness)
else:
config.av.scaler_sharpness = NoSave(ConfigNothing())
",1
" self.cg = CharacterGeneratorMock(width = 9, height = 14)
self.mda = MonochromeDisplayAdapter(self.cg)
# Hijack reset so it doesn't call into Pygame during the tests.
self.reset_count = 0
self.mda.reset = self.reset_testable
def reset_testable(self):
self.reset_count += 1
def test_ports_list(self):
self.assertEqual(self.mda.get_ports_list(), [0x03B0, 0x03B1, 0x03B2, 0x03B3,
0x03B4, 0x03B5, 0x03B6, 0x03B7,
0x03B8, 0x03B9, 0x03BA, 0x03BB])
def test_get_memory_size(self):
self.assertEqual(self.mda.get_memory_size(), 4096)
def test_initial_state(self):
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.control_reg, 0x00)
self.assertEqual(self.mda.screen, None)
self.assertEqual(self.mda.char_generator, self.cg)
self.assertEqual(len(self.mda.video_ram), 4096)
def test_mem_write_byte_updates_video_ram(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
def test_mem_write_byte_calls_char_generator_top_left(self):
self.mda.mem_write_byte(0x0000, 0x41)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_calls_char_generator_bottom_right(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
def test_mem_write_byte_char_before_attribute(self):
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_attribute_before_char(self):
self.mda.mem_write_byte(3999, MDA_ATTR_INTENSITY)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
self.mda.mem_write_byte(3998, 0xFF)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0xFF, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_byte_write_off_screen(self):
self.mda.mem_write_byte(4000, 0xFF)
self.assertEqual(self.cg.last_blit, None)
def test_mem_read_byte(self):
self.mda.video_ram[77] = 0xA5
self.assertEqual(self.mda.mem_read_byte(77), 0xA5)
def test_mem_read_byte_off_screen(self):
self.assertEqual(self.mda.mem_read_byte(4000), 0x00)
@unittest.skip(""We need to initialize Pygame exactly once at startup."")
def test_reset_on_high_resolution_enable(self):
self.assertEqual(self.reset_count, 0)
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
# Second write shouldn't call reset again.
self.mda.io_write_byte(0x3B8, 0x01)
self.assertEqual(self.reset_count, 1)
def test_mem_write_word_at_top_left(self):
self.mda.mem_write_word(0x0000, 0x0841) # 'A' with intensity.
self.assertEqual(self.mda.video_ram[0x0000], 0x41)
self.assertEqual(self.mda.video_ram[0x0001], 0x08)
self.assertEqual(self.cg.last_blit, (None, (0, 0), 0x41, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right(self):
self.mda.mem_write_word(3998, 0x085A) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x5A)
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x5A, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_write_word_at_bottom_right_just_past(self):
self.mda.mem_write_word(3999, 0xFF08) # 'Z' with intensity.
self.assertEqual(self.mda.video_ram[3998], 0x00) # Should be unmodified.
self.assertEqual(self.mda.video_ram[3999], 0x08)
self.assertEqual(self.cg.last_blit, (None, (711, 336), 0x00, MDA_BRIGHT_GREEN, MDA_BLACK))
def test_mem_read_word(self):
self.mda.video_ram[0x0000] = 0x41
self.mda.video_ram[0x0001] = 0x08
self.assertEqual(self.mda.mem_read_word(0x0000), 0x0841)
def test_mem_read_word_just_past_the_end(self):
self.mda.video_ram[3998] = 0x12
self.mda.video_ram[3999] = 0x34
self.assertEqual(self.mda.mem_read_word(3999), 0x0034)
def test_horizontal_retrace_toggles(self):
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF1)
self.assertEqual(self.mda.io_read_byte(0x3BA), 0xF0)
def test_current_pixel_updates_on_status_read(self):
self.assertEqual(self.mda.current_pixel, [0, 0])
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [1, 0])
def test_current_pixel_wraps_right(self):
self.mda.current_pixel = [719, 0]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 1])
def test_current_pixel_wraps_bottom(self):
self.mda.current_pixel = [719, 349]
self.mda.io_read_byte(0x3BA)
self.assertEqual(self.mda.current_pixel, [0, 0])
",1
"portError:
try:
import pydot
from networkx.drawing.nx_pydot import graphviz_layout
except ImportError:
raise ImportError(""This example needs Graphviz and either ""
""PyGraphviz or pydot"")
G = nx.balanced_tree(3, 5)
pos = graphviz_layout(G, prog='twopi', args='')
plt.figure(figsize=(8, 8))
nx.draw(G, pos, node_size=20, alpha=0.5, node_color=""blue"", with_labels=False)
plt.axis('equal')
plt.savefig('circular_tree.png')
plt.show()
",1
"__ import absolute_import, division, print_function
__metaclass__ = type
ANSIBLE_METADATA = {'metadata_version': '1.1',
'status': ['preview'],
'supported_by': 'community'}
DOCUMENTATION = '''
module: sf_account_manager
short_description: Manage SolidFire accounts
extends_documentation_fragment:
- netapp.solidfire
version_added: '2.3'
author: Sumit Kumar (sumit4@netapp.com)
description:
- Create, destroy, or update accounts on SolidFire
options:
state:
description:
- Whether the specified account should exist or not.
required: true
choices: ['present', 'absent']
name:
description:
- Unique username for this account. (May be 1 to 64 characters in length).
required: true
new_name:
description:
- New name for the user account.
required: false
default: None
initiator_secret:
description:
- CHAP secret to use for the initiator. Should be 12-16 characters long and impenetrable.
- The CHAP initiator secrets must be unique and cannot be the same as the target CHAP secret.
- If not specified, a random secret is created.
required: false
target_secret:
description:
- CHAP secret to use for the target (mutual CHAP authentication).
- Should be 12-16 characters long and impenetrable.
- The CHAP target secrets must be unique and cannot be the same as the initiator CHAP secret.
- If not specified, a random secret is created.
required: false
attributes:
description: List of Name/Value pairs in JSON object format.
required: false
account_id:
description:
- The ID of the account to manage or update.
required: false
default: None
status:
description:
- Status of the account.
required: false
'''
EXAMPLES = """"""
- name: Create Account
sf_account_manager:
hostname: ""{{ solidfire_hostname }}""
username: ""{{ solidfire_username }}""
password: ""{{ solidfire_password }}""
state: present
name: TenantA
- name: Modify Account
sf_account_manager:
hostname: ""{{ solidfire_hostname }}""
username: ""{{ solidfire_username }}""
password: ""{{ solidfire_password }}""
state: present
name: TenantA
new_name: TenantA-Renamed
- name: Delete Account
sf_account_manager:
hostname: ""{{ solidfire_hostname }}""
username: ""{{ solidfire_username }}""
password: ""{{ solidfire_password }}""
state: absent
name: TenantA-Renamed
""""""
RETURN = """"""
""""""
import traceback
from ansible.module_utils.basic import AnsibleModule
from ansible.module_utils._text import to_native
import ansible.module_utils.netapp as netapp_utils
HAS_SF_SDK = netapp_utils.has_sf_sdk()
class SolidFireAccount(object):
def __init__(self):
self.argument_spec = netapp_utils.ontap_sf_host_argument_spec()
self.argument_spec.update(dict(
state=dict(required=True, choices=['present', 'absent']),
name=dict(required=True, type='str'),
account_id=dict(required=False, type='int', default=None),
new_name=dict(required=False, type='str', default=None),
initiator_secret=dict(required=False, type='str'),
target_secret=dict(required=False, type='str'),
attributes=dict(required=False, type='dict'),
status=dict(required=False, type='str'),
))
self.module = AnsibleModule(
argument_spec=self.argument_spec,
supports_check_mode=True
)
p = self.module.params
# set up state variables
self.state = p['state']
self.name = p['name']
self.account_id = p['account_id']
self.new_name = p['new_name']
self.initiator_secret = p['initiator_secret']
self.target_secret = p['target_secret']
self.attributes = p['attributes']
self.status = p['status']
if HAS_SF_SDK is False:
self.module.fail_json(msg=""Unable to import the SolidFire Python SDK"")
else:
self.sfe = netapp_utils.create_sf_connection(module=self.module)
def get_account(self):
""""""
Return account object if found
:return: Details about the account. None if not found.
:rtype: dict
""""""
account_list = self.sfe.list_accounts()
for account in account_list.accounts:
if account.username == self.name:
# Update self.account_id:
if self.account_id is not None:
if account.account_id == self.account_id:
return account
else:
self.account_id = account.account_id
return account
return None
def create_account(self):
try:
self.sfe.add_account(username=self.name,
initiator_secret=self.initiator_secret,
target_secret=self.target_secret,
attributes=self.attributes)
except Exception as e:
self.module.fail_json(msg='Error creating account %s: %s)' % (self.name, to_native(e)),
exception=traceback.format_exc())
def delete_account(self):
try:
self.sfe.remove_account(account_id=self.account_id)
except Exception as e:
self.module.fail_json(msg='Error deleting account %s: %s' % (self.account_id, to_native(e)),
exception=traceback.format_exc())
def update_account(self):
try:
self.sfe.modify_account(account_id=self.account_id,
username=self.new_name,
status=self.status,
initiator_secret=self.initiator_secret,
target_secret=self.target_secret,
attributes=self.attributes)
except Exception as e:
self.module.fail_json(msg='Error updating account %s: %s' % (self.account_id, to_native(e)),
exception=traceback.format_exc())
def apply(self):
changed = False
account_exists = False
update_account = False
account_detail = self.get_account()
if account_detail:
account_exists = True
if self.state == 'absent':
changed = True
elif self.state == 'present':
# Check if we need to update the account
if account_detail.username is not None and self.new_name is not None and \
account_detail.username != self.new_name:
update_account = True
changed = True
elif account_detail.status is not None and self.status is not None \
and account_detail.status != self.status:
update_account = True
changed = True
elif account_detail.initiator_secret is not None and self.initiator_secret is not None \
and account_detail.initiator_secret != self.initiator_secret:
update_account = True
changed = True
elif account_detail.target_secret is not None and self.target_secret is not None \
and account_detail.target_secret != self.target_secret:
update_account = True
changed = True
elif account_detail.attributes is not None and self.attributes is not None \
and account_detail.attributes != self.attributes:
update_account = True
changed = True
else:
if self.state == 'present':
changed = True
if changed:
if self.module.check_mode:
pass
else:
if self.state == 'present':
if not account_exists:
self.create_account()
elif update_account:
self.update_account()
elif self.state == 'absent':
self.delete_account()
self.module.exit_json(changed=changed)
def main():
v = SolidFireAccount()
v.apply()
if __name__ == '__main__':
main()
",1
"#
# 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 clr import AddReference
AddReference(""System"")
AddReference(""QuantConnect.Algorithm"")
AddReference(""QuantConnect.Common"")
AddReference(""QuantConnect.Indicators"")
from System import *
from QuantConnect import *
from QuantConnect.Indicators import *
from QuantConnect.Data import *
from QuantConnect.Data.Market import *
from QuantConnect.Data.Custom import *
from QuantConnect.Algorithm import *
from QuantConnect.Python import PythonQuandl
###
### The algorithm creates new indicator value with the existing indicator method by Indicator Extensions
### Demonstration of using the external custom datasource Quandl to request the VIX and VXV daily data
###
###
###
###
###
###
###
###
class CustomDataIndicatorExtensionsAlgorithm(QCAlgorithm):
# Initialize the data and resolution you require for your strategy
def Initialize(self):
self.SetStartDate(2014,1,1)
self.SetEndDate(2018,1,1)
self.SetCash(25000)
self.vix = 'CBOE/VIX'
self.vxv = 'CBOE/VXV'
# Define the symbol and ""type"" of our generic data
self.AddData(QuandlVix, self.vix, Resolution.Daily)
self.AddData(Quandl, self.vxv, Resolution.Daily)
# Set up default Indicators, these are just 'identities' of the closing price
self.vix_sma = self.SMA(self.vix, 1, Resolution.Daily)
self.vxv_sma = self.SMA(self.vxv, 1, Resolution.Daily)
# This will create a new indicator whose value is smaVXV / smaVIX
self.ratio = IndicatorExtensions.Over(self.vxv_sma, self.vix_sma)
# Plot indicators each time they update using the PlotIndicator function
self.PlotIndicator(""Ratio"", self.ratio)
self.PlotIndicator(""Data"", self.vix_sma, self.vxv_sma)
# OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
def OnData(self, data):
# Wait for all indicators to fully initialize
if not (self.vix_sma.IsReady and self.vxv_sma.IsReady and self.ratio.IsReady): return
if not self.Portfolio.Invested and self.ratio.Current.Value > 1:
self.MarketOrder(self.vix, 100)
elif self.ratio.Current.Value < 1:
self.Liquidate()
# In CBOE/VIX data, there is a ""vix close"" column instead of ""close"" which is the
# default column namein LEAN Quandl custom data implementation.
# This class assigns new column name to match the the external datasource setting.
class QuandlVix(PythonQuandl):
def __init__(self):
self.ValueColumnName = ""VIX Close""",1
"sys.version_info[0] > 2:
import tkinter
else:
import Tkinter as tkinter
from PIL import Image, ImageTk
# --------------------------------------------------------------------
# an image animation player
class UI(tkinter.Label):
def __init__(self, master, im):
if isinstance(im, list):
# list of images
self.im = im[1:]
im = self.im[0]
else:
# sequence
self.im = im
if im.mode == ""1"":
self.image = ImageTk.BitmapImage(im, foreground=""white"")
else:
self.image = ImageTk.PhotoImage(im)
tkinter.Label.__init__(self, master, image=self.image, bg=""black"", bd=0)
self.update()
duration = im.info.get(""duration"", 100)
self.after(duration, self.next)
def next(self):
if isinstance(self.im, list):
try:
im = self.im[0]
del self.im[0]
self.image.paste(im)
except IndexError:
return # end of list
else:
try:
im = self.im
im.seek(im.tell() + 1)
self.image.paste(im)
except EOFError:
return # end of file
duration = im.info.get(""duration"", 100)
self.after(duration, self.next)
self.update_idletasks()
# --------------------------------------------------------------------
# script interface
if __name__ == ""__main__"":
if not sys.argv[1:]:
print(""Syntax: python player.py imagefile(s)"")
sys.exit(1)
filename = sys.argv[1]
root = tkinter.Tk()
root.title(filename)
if len(sys.argv) > 2:
# list of images
print(""loading..."")
im = []
for filename in sys.argv[1:]:
im.append(Image.open(filename))
else:
# sequence
im = Image.open(filename)
UI(root, im).pack()
root.mainloop()
",1
"6
password = 78910
with:
[bnporc21]
_module = bnporc
website = pp
login = 123456
password = `pass show weboob/bnporc21`
""""""
from __future__ import print_function
import os
import re
import shutil
import subprocess
import sys
import tempfile
FILE = os.getenv('WEBOOB_BACKENDS') or os.path.expanduser('~/.config/weboob/backends')
if not os.path.exists(FILE):
print('the backends file does not exist')
sys.exit(os.EX_NOINPUT)
if not shutil.which('pass'):
print('the ""pass"" tool could not be found')
sys.exit(os.EX_UNAVAILABLE)
errors = 0
seen = set()
backend = None
with open(FILE) as inp:
with tempfile.NamedTemporaryFile('w', delete=False, dir=os.path.dirname(FILE)) as outp:
for line in inp:
line = line.strip()
mtc = re.match(r'password\s*=\s*(\S.*)$', line)
if mtc and not mtc.group(1).startswith('`'):
cmd = ['pass', 'insert', 'weboob/%s' % backend]
stdin = 2 * ('%s\n' % mtc.group(1))
proc = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE)
proc.communicate(stdin.encode('utf-8'))
if proc.returncode == 0:
print('password = `pass show weboob/%s`' % backend, file=outp)
continue
else:
errors += 1
print('warning: could not store password for backend %r' % backend)
mtc = re.match(r'\[(.+)\]', line)
if mtc:
backend = mtc.group(1)
if backend in seen:
print('error: backend %r is present multiple times' % backend)
sys.exit(os.EX_DATAERR)
seen.add(backend)
print(line, file=outp)
os.rename(outp.name, FILE)
if errors:
print('%d errors were encountered when storing passwords securely' % errors)
sys.exit(2)
",1
"t Image
from cfme.containers.provider import ContainersProvider
from cfme.containers.provider import ContainersTestItem
from cfme.utils.appliance.implementations.ui import navigate_to
from cfme.utils.wait import wait_for
pytestmark = [
pytest.mark.meta(server_roles='+smartproxy'),
pytest.mark.usefixtures('setup_provider'),
pytest.mark.tier(1),
pytest.mark.provider([ContainersProvider], scope='function'),
test_requirements.containers
]
AttributeToVerify = namedtuple('AttributeToVerify', ['table', 'attr', 'verifier'])
TESTED_ATTRIBUTES__openscap_off = (
AttributeToVerify('configuration', 'OpenSCAP Results', bool),
AttributeToVerify('configuration', 'OpenSCAP HTML', lambda val: val == 'Available'),
AttributeToVerify('configuration', 'Last scan', dateparser.parse)
)
TESTED_ATTRIBUTES__openscap_on = TESTED_ATTRIBUTES__openscap_off + (
AttributeToVerify('compliance', 'Status', lambda val: val.lower() != 'never verified'),
AttributeToVerify('compliance', 'History', lambda val: val == 'Available')
)
TEST_ITEMS = (
ContainersTestItem(Image, 'openscap_off', is_openscap=False,
tested_attr=TESTED_ATTRIBUTES__openscap_off),
ContainersTestItem(Image, 'openscap_on', is_openscap=True,
tested_attr=TESTED_ATTRIBUTES__openscap_on)
)
NUM_SELECTED_IMAGES = 1
@pytest.fixture(scope='function')
def delete_all_container_tasks(appliance):
col = appliance.collections.tasks.filter({'tab': 'AllTasks'})
col.delete_all()
@pytest.fixture(scope='function')
def random_image_instance(appliance):
collection = appliance.collections.container_images
# add filter for select only active(not archived) images from redHat registry
filter_image_collection = collection.filter({'active': True, 'redhat_registry': True})
return random.sample(filter_image_collection.all(), NUM_SELECTED_IMAGES).pop()
@pytest.mark.polarion('10030')
def test_manage_policies_navigation(random_image_instance):
""""""
Polarion:
assignee: juwatts
caseimportance: high
casecomponent: Containers
initialEstimate: 1/6h
""""""
random_image_instance.assign_policy_profiles('OpenSCAP profile')
@pytest.mark.polarion('10031')
def test_check_compliance(random_image_instance):
""""""
Polarion:
assignee: juwatts
caseimportance: high
casecomponent: Containers
initialEstimate: 1/6h
""""""
random_image_instance.assign_policy_profiles('OpenSCAP profile')
random_image_instance.check_compliance()
def get_table_attr(instance, table_name, attr):
# Trying to read the table attribute
view = navigate_to(instance, 'Details', force=True)
table = getattr(view.entities, table_name, None)
if table:
return table.read().get(attr)
@pytest.mark.parametrize(('test_item'), TEST_ITEMS)
def test_containers_smartstate_analysis(provider, test_item, soft_assert,
delete_all_container_tasks,
random_image_instance):
""""""
Polarion:
assignee: juwatts
caseimportance: high
casecomponent: Containers
initialEstimate: 1/6h
""""""
if test_item.is_openscap:
random_image_instance.assign_policy_profiles('OpenSCAP profile')
else:
random_image_instance.unassign_policy_profiles('OpenSCAP profile')
random_image_instance.perform_smartstate_analysis(wait_for_finish=True)
view = navigate_to(random_image_instance, 'Details')
for tbl, attr, verifier in test_item.tested_attr:
table = getattr(view.entities, tbl)
table_data = {k.lower(): v for k, v in table.read().items()}
if not soft_assert(attr.lower() in table_data,
f'{tbl} table has missing attribute \'{attr}\''):
continue
provider.refresh_provider_relationships()
wait_for_retval = wait_for(lambda: get_table_attr(random_image_instance, tbl, attr),
message='Trying to get attribute ""{}"" of table ""{}""'.format(
attr, tbl),
delay=5, num_sec=120, silent_failure=True)
if not wait_for_retval:
soft_assert(False, 'Could not get attribute ""{}"" for ""{}"" table.'
.format(attr, tbl))
continue
value = wait_for_retval.out
soft_assert(verifier(value),
f'{tbl}.{attr} attribute has unexpected value ({value})')
@pytest.mark.parametrize(('test_item'), TEST_ITEMS)
def test_containers_smartstate_analysis_api(provider, test_item, soft_assert,
delete_all_container_tasks, random_image_instance):
""""""
Test initiating a SmartState Analysis scan via the CFME API through the ManageIQ API Client
entity class.
RFE: BZ 1486362
Polarion:
assignee: juwatts
caseimportance: high
casecomponent: Containers
initialEstimate: 1/6h
""""""
if test_item.is_openscap:
random_image_instance.assign_policy_profiles('OpenSCAP profile')
else:
random_image_instance.unassign_policy_profiles('OpenSCAP profile')
original_scan = random_image_instance.last_scan_attempt_on
random_image_instance.scan()
task = provider.appliance.collections.tasks.instantiate(
name=f""Container Image Analysis: '{random_image_instance.name}'"", tab='AllTasks')
task.wait_for_finished()
soft_assert(original_scan != random_image_instance.last_scan_attempt_on,
'SmartState Anaysis scan has failed')
",1
"ll_requires = []
# Python 2.6 does not include the argparse module.
try:
import argparse
except ImportError:
install_requires.append('argparse')
# Python 2.6 does not include OrderedDict.
try:
from collections import OrderedDict
except ImportError:
install_requires.append('ordereddict')
try:
with open('README.rst') as readme:
long_description = readme.read()
except IOError:
long_description = 'See https://pypi.python.org/pypi/wiggelen'
# This is quite the hack, but we don't want to import our package from here
# since that's recipe for disaster (it might have some uninstalled
# dependencies, or we might import another already installed version).
distmeta = {}
for line in open(os.path.join('wiggelen', '__init__.py')):
try:
field, value = (x.strip() for x in line.split('='))
except ValueError:
continue
if field == '__version_info__':
value = value.strip('[]()')
value = '.'.join(x.strip(' \'""') for x in value.split(','))
else:
value = value.strip('\'""')
distmeta[field] = value
setup(
name='wiggelen',
version=distmeta['__version_info__'],
description='Working with wiggle tracks in Python',
long_description=long_description,
author=distmeta['__author__'],
author_email=distmeta['__contact__'],
url=distmeta['__homepage__'],
license='MIT License',
platforms=['any'],
packages=['wiggelen'],
install_requires=install_requires,
entry_points = {
'console_scripts': ['wiggelen = wiggelen.commands:main']
},
classifiers = [
'Development Status :: 3 - Alpha',
'Intended Audience :: Developers',
'Intended Audience :: Science/Research',
'Operating System :: OS Independent',
'Programming Language :: Python',
'Topic :: Scientific/Engineering',
],
keywords='bioinformatics'
)
",1
"/en/1.9/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: url(r'^$', views.home, name='home')
Class-based views
1. Add an import: from other_app.views import Home
2. Add a URL to urlpatterns: url(r'^$', Home.as_view(), name='home')
Including another URLconf
1. Add an import: from blog import urls as blog_urls
2. Import the include() function: from django.conf.urls import url, include
3. Add a URL to urlpatterns: url(r'^blog/', include(blog_urls))
""""""
from django.conf.urls import url, include
from django.contrib import admin
urlpatterns = [
url(r'^red/', include('apps.red_app.urls', namespace='red_namespace')),
url(r'^blue/', include('apps.blue_app.urls', namespace='blue_namespace')),
url(r'^admin/', admin.site.urls),
]
",1
"ts. 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.
"""""" metrichandler.py """"""
import traceback
import tornado.gen
import tornado.web
from heron.common.src.python.utils.log import Log
from heron.proto import common_pb2
from heron.proto import tmaster_pb2
from heron.tools.tracker.src.python import constants
from heron.tools.tracker.src.python.handlers import BaseHandler
class MetricsHandler(BaseHandler):
""""""
URL - /topologies/metrics
Parameters:
- cluster (required)
- role - (optional) Role used to submit the topology.
- environ (required)
- topology (required) name of the requested topology
- component (required)
- metricname (required, repeated)
- interval (optional)
- instance (optional, repeated)
The response JSON is a map of all the requested
(or if nothing is mentioned, all) components
of the topology, to the metrics that are reported
by that component.
""""""
# pylint: disable=attribute-defined-outside-init
def initialize(self, tracker):
"""""" initialize """"""
self.tracker = tracker
@tornado.gen.coroutine
def get(self):
"""""" get method """"""
try:
cluster = self.get_argument_cluster()
role = self.get_argument_role()
environ = self.get_argument_environ()
topology_name = self.get_argument_topology()
component = self.get_argument_component()
metric_names = self.get_required_arguments_metricnames()
topology = self.tracker.getTopologyByClusterRoleEnvironAndName(
cluster, role, environ, topology_name)
interval = int(self.get_argument(constants.PARAM_INTERVAL, default=-1))
instances = self.get_arguments(constants.PARAM_INSTANCE)
metrics = yield tornado.gen.Task(
self.getComponentMetrics,
topology.tmaster, component, metric_names, instances, interval)
self.write_success_response(metrics)
except Exception as e:
Log.debug(traceback.format_exc())
self.write_error_response(e)
# pylint: disable=too-many-locals, no-self-use, unused-argument
@tornado.gen.coroutine
def getComponentMetrics(self,
tmaster,
componentName,
metricNames,
instances,
interval,
callback=None):
""""""
Get the specified metrics for the given component name of this topology.
Returns the following dict on success:
{
""metrics"": {
: {
: ,
: ,
...
}, ...
},
""interval"": ,
""component"": ""...""
}
Raises exception on failure.
""""""
if not tmaster or not tmaster.host or not tmaster.stats_port:
raise Exception(""No Tmaster found"")
host = tmaster.host
port = tmaster.stats_port
metricRequest = tmaster_pb2.MetricRequest()
metricRequest.component_name = componentName
if len(instances) > 0:
for instance in instances:
metricRequest.instance_id.append(instance)
for metricName in metricNames:
metricRequest.metric.append(metricName)
metricRequest.interval = interval
# Serialize the metricRequest to send as a payload
# with the HTTP request.
metricRequestString = metricRequest.SerializeToString()
url = ""http://{0}:{1}/stats"".format(host, port)
request = tornado.httpclient.HTTPRequest(url,
body=metricRequestString,
method='POST',
request_timeout=5)
Log.debug(""Making HTTP call to fetch metrics"")
Log.debug(""url: "" + url)
try:
client = tornado.httpclient.AsyncHTTPClient()
result = yield client.fetch(request)
Log.debug(""HTTP call complete."")
except tornado.httpclient.HTTPError as e:
raise Exception(str(e))
# Check the response code - error if it is in 400s or 500s
responseCode = result.code
if responseCode >= 400:
message = ""Error in getting metrics from Tmaster, code: "" + responseCode
Log.error(message)
raise Exception(message)
# Parse the response from tmaster.
metricResponse = tmaster_pb2.MetricResponse()
metricResponse.ParseFromString(result.body)
if metricResponse.status.status == common_pb2.NOTOK:
if metricResponse.status.HasField(""message""):
Log.warn(""Received response from Tmaster: %s"", metricResponse.status.message)
# Form the response.
ret = {}
ret[""interval""] = metricResponse.interval
ret[""component""] = componentName
ret[""metrics""] = {}
for metric in metricResponse.metric:
instance = metric.instance_id
for im in metric.metric:
metricname = im.name
value = im.value
if metricname not in ret[""metrics""]:
ret[""metrics""][metricname] = {}
ret[""metrics""][metricname][instance] = value
raise tornado.gen.Return(ret)
",1
"(models.Model):
name = models.CharField(max_length=150)
latin_name = models.CharField(max_length=150)
count = models.IntegerField()
weight = models.FloatField()
# use a non-default name for the default manager
specimens = models.Manager()
def __unicode__(self):
return self.name
class Plant(models.Model):
name = models.CharField(max_length=150)
class Meta:
# For testing when upper case letter in app name; regression for #4057
db_table = ""Fixtures_regress_plant""
class Stuff(models.Model):
name = models.CharField(max_length=20, null=True)
owner = models.ForeignKey(User, null=True)
def __unicode__(self):
return unicode(self.name) + u' is owned by ' + unicode(self.owner)
class Absolute(models.Model):
name = models.CharField(max_length=40)
load_count = 0
def __init__(self, *args, **kwargs):
super(Absolute, self).__init__(*args, **kwargs)
Absolute.load_count += 1
class Parent(models.Model):
name = models.CharField(max_length=10)
class Meta:
ordering = ('id',)
class Child(Parent):
data = models.CharField(max_length=10)
# Models to regression test #7572
class Channel(models.Model):
name = models.CharField(max_length=255)
class Article(models.Model):
title = models.CharField(max_length=255)
channels = models.ManyToManyField(Channel)
class Meta:
ordering = ('id',)
# Models to regression test #11428
class Widget(models.Model):
name = models.CharField(max_length=255)
class Meta:
ordering = ('name',)
def __unicode__(self):
return self.name
class WidgetProxy(Widget):
class Meta:
proxy = True
# Check for forward references in FKs and M2Ms with natural keys
class TestManager(models.Manager):
def get_by_natural_key(self, key):
return self.get(name=key)
class Store(models.Model):
objects = TestManager()
name = models.CharField(max_length=255)
class Meta:
ordering = ('name',)
def __unicode__(self):
return self.name
def natural_key(self):
return (self.name,)
class Person(models.Model):
objects = TestManager()
name = models.CharField(max_length=255)
class Meta:
ordering = ('name',)
def __unicode__(self):
return self.name
# Person doesn't actually have a dependency on store, but we need to define
# one to test the behaviour of the dependency resolution algorithm.
def natural_key(self):
return (self.name,)
natural_key.dependencies = ['fixtures_regress.store']
class Book(models.Model):
name = models.CharField(max_length=255)
author = models.ForeignKey(Person)
stores = models.ManyToManyField(Store)
class Meta:
ordering = ('name',)
def __unicode__(self):
return u'%s by %s (available at %s)' % (
self.name,
self.author.name,
', '.join(s.name for s in self.stores.all())
)
class NKManager(models.Manager):
def get_by_natural_key(self, data):
return self.get(data=data)
class NKChild(Parent):
data = models.CharField(max_length=10, unique=True)
objects = NKManager()
def natural_key(self):
return self.data
def __unicode__(self):
return u'NKChild %s:%s' % (self.name, self.data)
class RefToNKChild(models.Model):
text = models.CharField(max_length=10)
nk_fk = models.ForeignKey(NKChild, related_name='ref_fks')
nk_m2m = models.ManyToManyField(NKChild, related_name='ref_m2ms')
def __unicode__(self):
return u'%s: Reference to %s [%s]' % (
self.text,
self.nk_fk,
', '.join(str(o) for o in self.nk_m2m.all())
)
# ome models with pathological circular dependencies
class Circle1(models.Model):
name = models.CharField(max_length=255)
def natural_key(self):
return self.name
natural_key.dependencies = ['fixtures_regress.circle2']
class Circle2(models.Model):
name = models.CharField(max_length=255)
def natural_key(self):
return self.name
natural_key.dependencies = ['fixtures_regress.circle1']
class Circle3(models.Model):
name = models.CharField(max_length=255)
def natural_key(self):
return self.name
natural_key.dependencies = ['fixtures_regress.circle3']
class Circle4(models.Model):
name = models.CharField(max_length=255)
def natural_key(self):
return self.name
natural_key.dependencies = ['fixtures_regress.circle5']
class Circle5(models.Model):
name = models.CharField(max_length=255)
def natural_key(self):
return self.name
natural_key.dependencies = ['fixtures_regress.circle6']
class Circle6(models.Model):
name = models.CharField(max_length=255)
def natural_key(self):
return self.name
natural_key.dependencies = ['fixtures_regress.circle4']
class ExternalDependency(models.Model):
name = models.CharField(max_length=255)
def natural_key(self):
return self.name
natural_key.dependencies = ['fixtures_regress.book']
# Model for regression test of #11101
class Thingy(models.Model):
name = models.CharField(max_length=255)
",1
"stance():
""""""See if this contraption works in 1 dimension""""""
num1 = random.random()
num2 = random.random()
assert kmeans.ndim_euclidean_distance(num1, num2) == abs(num1-num2)
def test_ndim_distance():
""""""Test to see if changing val by 1 does what it ought to do
convert to float to integer because floating arithmetic makes testing
analytic functions a mess""""""
rand = random.random
point1 = [rand(), rand(), rand(), rand(), rand(), rand()]
point2 = [point1[0]+1] + point1[1:] # just shift x to the right by 1
assert int(round(kmeans.ndim_euclidean_distance(point1, point2))) == 1
def test_maxiters():
""""""ensure the iteration ceiling works""""""
# assert kmeans.should_iter([], [], iterations=29) == True
assert kmeans.should_iter([], [], iterations=30) == False
assert kmeans.should_iter([], [], iterations=31) == False
def test_random_centroid_dimensions():
""""""ensure the correct number of dimensions""""""
dimensions = random.randrange(1, 100)
k = random.randrange(1, 100)
centroids = kmeans.random_centroids(k, dimensions)
for centroid in centroids:
assert len(centroid) == dimensions
def test_iterated_centroid():
""""""ensure that the average across each dimension is returned""""""
new_centroid = kmeans.iterated_centroid([[1, 1, 1], [2, 2, 2]],\
[[100, 200, 300]], [(0, 0), (1, 0)])
np.testing.assert_allclose(new_centroid, np.array([[1.5, 1.5, 1.5]]),\
rtol=1e-5)
",1
"):
self.assertEqual(string_color('Jack'), '79CAE5')
def test_equal_2(self):
self.assertEqual(string_color('Joshua'), '6A10D6')
def test_equal_3(self):
self.assertEqual(string_color('Joshua Smith'), '8F00FB')
def test_equal_4(self):
self.assertEqual(string_color('Hayden Smith'), '7E00EE')
def test_equal_5(self):
self.assertEqual(string_color('Mathew Smith'), '8B00F1')
def test_is_none_1(self):
self.assertIsNone(string_color('a'))
",1
"on package.
# In bugfix releases of the python package, add a '-' suffix and an
# incrementing integer.
# For example, a packaging bugfix release version 1.4.4 of the
# js.jquery package would be version 1.4.4-1 .
version = '0.9.7rt'
def read(*rnames):
return open(os.path.join(os.path.dirname(__file__), *rnames)).read()
long_description = (
read('README.txt')
+ '\n' +
read('js', 'chosen', 'test_chosen.txt')
+ '\n' +
read('CHANGES.txt'))
setup(
name='js.chosen',
version=version,
description=""Fanstatic packaging of Chosen"",
long_description=long_description,
classifiers=[],
keywords='',
author='Fanstatic Developers',
author_email='fanstatic@googlegroups.com',
license='BSD',
packages=find_packages(),namespace_packages=['js'],
include_package_data=True,
zip_safe=False,
install_requires=[
'fanstatic',
'js.jquery',
'setuptools',
],
entry_points={
'fanstatic.libraries': [
'chosen = js.chosen:library',
],
},
)
",1
"it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# 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, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
# __init__.py.py
""""""
import urlparse
from niimanga.libs.exceptions import HtmlError
from requests import request
class Site:
def __init__(self):
pass
def get_html(self, url, method='GET', **kwargs):
resp = request(method, url, **kwargs)
if resp.status_code != 200:
raise HtmlError({'msg': 'external_request_fail', 'url': url})
return resp.content
def fetch_manga_seed_page(self, url, **kwargs):
return self.get_html(url, **kwargs)
def fetch_chapter_seed_page(self, url, **kwargs):
return self.get_html(url, **kwargs)
def fetch_page_image(self, url, **kwargs):
return self.get_html(url, **kwargs)
def search_by_author(self, author):
""""""
Return list of chapter dicts whose keys are:
name
url
site
This should be specifically implemented in each Site subclass. If not,
this method will be used which returns an empty list.
""""""
return []
from mangaeden import MangaEden
from batoto import Batoto
available_sites = [
# Kissmanga(),
# Vitaku(),
Batoto(),
# Mangafox(),
# Mangahere(),
# MangaHereMob(),
MangaEden()
]
# Factory function, return instance of suitable ""site"" class from url
def get_site(url):
netloc = urlparse.urlparse(url).netloc
for site in available_sites:
if netloc in site.netlocs:
return site
return None",1
"mport Archiver
from archiver.parser import parseArgs
args = parseArgs()
from edit import edit
# ==============================================
print args
# TODO: see http://stackoverflow.com/questions/13168083/python-raw-input-replacement-that-uses-a-configurable-text-editor
#-- import pdb
#-- pdb.set_trace()
# ------------------------------------------------------------
# load the user data
# ------------------------------------------------------------
# get the user data directory
user_data_dir = appdirs.user_data_dir('FileArchiver', 'jdthorpe')
if not os.path.exists(user_data_dir) :
os.makedirs(user_data_dir)
# LOAD THE INDEX NAMES AND ACTIVE INDEX
indexes_path = os.path.join(user_data_dir,'INDEXES.json')
if os.path.exists(indexes_path):
with open(indexes_path,'rb') as fh:
indexes = json.load(fh)
else:
indexes= {'active':None,'names':[]}
if not os.path.exists(user_data_dir):
os.makedirs(user_data_dir)
def dumpIndexes():
with open(indexes_path,'wb') as fh:
json.dump(indexes,fh)
# ------------------------------------------------------------
# ------------------------------------------------------------
def getActiveName():
# ACTIVE INDEX NUMER
activeIndex = indexes['active']
if activeIndex is None:
print ""No active index. Use 'list -i' to list available indexies and 'use' to set an active index.""
sys.exit()
# GET THE NAME OF THE INDEX
try:
activeIndexName = indexes['names'][indexes['active']]
except:
print ""Invalid index number""
sys.exit()
return activeIndexName
# ------------------------------------------------------------
# READ-WRITE UTILITY FUNCTIONS
# ------------------------------------------------------------
# TODO: catch specific excepitons:
# except IOError:
# # no such file
# except ValueError as e:
# # invalid json file
def readSettings(name):
"""""" A utility function which loads the index settings from file
""""""
try:
with open(os.path.join(user_data_dir,name+"".settings""),'rb') as fh:
settings = json.load(fh)
except Exception as e:
print ""Error reading index settings""
import pdb
pdb.set_trace()
sys.exit()
return settings
def readData(name):
"""""" A utility function which loads the index data from file
""""""
try:
with open(os.path.join(user_data_dir,name+"".data""),'rb') as fh: data = pickle.load(fh)
except Exception as e:
print ""Error reading index data""
import pdb
pdb.set_trace()
sys.exit()
return data
def dumpSettings(settings,name):
"""""" A utility function which saves the index settings to file
""""""
try:
with open(os.path.join(user_data_dir,name+"".settings""),'wb') as fh:
json.dump(settings,fh)
except Exception as e:
print ""Error writing index settings""
import pdb
pdb.set_trace()
sys.exit()
def dumpData(data,name):
"""""" A utility function which saves the index settings to file
""""""
try:
with open(os.path.join(user_data_dir,name+"".data""),'wb') as fh:
pickle.dump(data,fh)
except:
print ""Error writing index data""
import pdb
pdb.set_trace()
sys.exit()
# ------------------------------------------------------------
# ------------------------------------------------------------
if args.command == 'add':
activeName = getActiveName()
settings = readSettings(activeName)
if args.source is not None:
source = os.path.abspath(args.source)
if not os.path.exists(source):
print 'WARNING: no such directory ""%s""'%(source)
elif not os.path.isdir(source):
print 'ERROR: ""%s"" is not a directory'%(source)
sys.exit()
print 'Adding source directory: %s'%(source)
if not any(samefile(source,f) for f in settings['sourceDirectories']):
settings['sourceDirectories'].append(source)
elif args.exclusions is not None:
import re
try:
re.compile(args.exclusion)
except re.error:
print 'Invalid regular expression ""%s""'%(args.exclusion)
sys.exit()
if args.noic:
settings['directoryExclusionPatterns'].append(args.exclusion)
else:
settings['directoryExclusionPatterns'].append((args.exclusion,2)) # re.I == 2
elif args.archive is not None:
raise NotImplementedError
if settings['archiveDirectory'] is not None:
print ""Archive path has already been set use 'remove' to delete the archive path before setting a new archive path""
archiveDirectory = os.path.abspath(args.archive)
if not os.path.exists(archiveDirectory):
if args.create :
os.makedirs(archiveDirectory)
else:
print 'ERROR: no such directory ""%s""'%(archiveDirectory)
sys.exit()
elif not os.path.isdir(archiveDirectory):
print '""%s"" is not a directory'%(archiveDirectory)
sys.exit()
print 'Setting archive directory to: %s'%(archiveDirectory)
settings['archiveDirectory'] = args.archive
else:
raise NotImplementedError
print 'Error in Arg Parser'
sys.exit()
dumpSettings(settings,activeName)
elif args.command == 'list':
if args.sources:
for f in readSettings(getActiveName())['sourceDirectories']:
print f
elif args.exclusions:
for f in readSettings(getActiveName())['directoryExclusionPatterns']:
print f
elif args.archive:
print readSettings(getActiveName())['archiveDirectory']
elif args.files:
archiver = Archiver()
archiver.data = readData(getActiveName())
for f in archiver:
print f
elif args.indexes:
print 'Active Index: %s (*)'%(getActiveName())
print 'Index Names: '
for i,name in enumerate(indexes['names']):
print ' %s %i: %s'%(
(' ','*')[(i == indexes['active'])+0],
i+1,
name,
)
else:
print 'Error in Arg Parser'
elif args.command == 'remove':
activeName = getActiveName()
settings = readSettings(activeName)
if args.source is not None:
if not (1 <= args.source <= len(settings['sourceDirectories'])):
print 'Invalid index %i'%(args.source)
del settings['sourceDirectories'][args.source - 1]
elif args.exclusion is not None:
raise NotImplementedError
if not (1 <= args.exclusion <= len(settings['directoryExclusionPatterns'])):
print 'Invalid index %i'%(args.exclusion)
del settings['directoryExclusionPatterns'][args.exclusion - 1]
elif args.archive is not None:
raise NotImplementedError
settings['archiveDirectory'] = None
else:
raise NotImplementedError
print 'Error in Arg Parser'
sys.exit()
dumpSettings(settings,activeName)
elif args.command == 'update':
activeName = getActiveName()
settings = readSettings(activeName)
if not len(settings['sourceDirectories']):
print ""Error: no source directories in the active index. Please add a source directory via 'add -s'""
archiver = Archiver(
settings = readSettings(activeName),
data = readData(activeName))
archiver.update()
dumpSettings(archiver.settings,activeName)
dumpData(archiver.data,activeName)
elif args.command == 'clean':
raise NotImplementedError
activeName = getActiveName()
archiver = Archiver(
settings = readSettings(activeName),
data = readData(activeName))
archiver.clean()
dumpSettings(archiver.settings,activeName)
dumpData(archiver.data,activeName)
elif args.command == 'copy':
raise NotImplementedError
activeName = getActiveName()
settings = readSettings(activeName),
if settings['archiveDirectory'] is None:
print ""ERROR Archive directory not set. Use 'add -a' to set the archive directory.""
sys.exit()
Index(
settings = settings,
data = readData(activeName)).copy()
elif args.command == 'diskimages':
raise NotImplementedError
if args.size is None or args.size == ""DVD"":
size = 4.65*1<<20
elif args.size == ""CD"":
size = 645*1<<20
elif args.size == ""DVD"":
size = 4.65*1<<20
elif args.size == ""DVD-dual"":
size = 8.5*1<<30
elif args.size == ""BD"":
size = 25*1<<30
elif args.size == ""BD-dual"":
size = 50*1<<30
elif args.size == ""BD-tripple"":
size = 75*1<<30
elif args.size == ""BD-xl"":
size = 100*1<<30
else:
try:
size = int(float(args.size))
except:
print 'ERROR: unable to coerce ""%s"" to float or int'%(args.size)
sys.exit()
activeName = getActiveName()
settings = readSettings(activeName),
# GET THE DIRECTORY ARGUMENT
if args.directory is not None:
directory = args.directory
else:
if settings['archiveDirectory'] is None:
print ""ERROR Archive directory not set and no directory specified. Use 'diskimages -d' to specifiy the disk image directory or 'add -a' to set the archive directory.""
sys.exit()
else:
directory = os.path.join(settings['archiveDirectory'],'Disk Images')
# VALIDATE THE DIRECTORY
if not os.path.exists(directory):
if args.create :
os.makedirs(directory)
else:
print 'ERROR: no such directory ""%s""'%(directory)
sys.exit()
elif not os.path.isdir(directory):
print '""%s"" is not a directory'%(directory)
sys.exit()
# get the FPBF argument
if args.fpbf is not None:
FPBF = True
elif args.nofpbf is not None:
FPBF = False
else:
FPBF = sys.platform == 'darwin'
Index( settings = settings,
data = readData(activeName)).diskimages(directory,size,FPBF)
elif args.command == 'settings':
activeName = getActiveName()
if args.export is not None:
raise NotImplementedError
with open(args.export,'rb') as fh:
json.dump(readSettings(activeName),fh,indent=2,separators=(',', ': '))
elif args.load is not None:
raise NotImplementedError
with open(args.export,'wb') as fh:
settings = json.load(fh)
# give a chance for the settings to be validated
try:
archiver = Archiver(settings=settings)
except:
print ""ERROR: invalid settings file""
dumpSettings(archiver.settings,args.name)
elif args.edit is not None:
settings = readSettings(activeName)
old = settings['identifierSettings'][args.edit]
new = edit(json.dumps(old,indent=2,separators=(',', ': ')))
settings['identifierSettings'][args.edit]= json.loads(new)
dumpSettings(settings,activeName)
else :
print json.dumps(readSettings(activeName),indent=2,separators=(',', ': '))
elif args.command == 'create':
if args.name in indexes['names']:
print ""An index by the name '%s' already exists""%(args.name)
sys.exit()
import re
validater = re.compile(r'^[-() _a-zA-Z0-9](?:[-() _.a-zA-Z0-9]+[-() _a-zA-Z0-9])$')
if validater.match(args.name) is None:
print ""ERROR: names must be composed of letters, numbers, hypen, underscore, space and dot charactes an not end or begin with a dot""
sys.exit()
archiver = Index()
dumpSettings(archiver.settings,args.name)
dumpData(archiver.data,args.name)
indexes['names'].append(args.name)
dumpIndexes()
# TODO: check if there are no other indexies. if so, make the new one active.
print ""Created index '%s'""%(args.name)
elif args.command == 'save':
raise NotImplementedError
Index( settings = readSettings(getActiveName()),
data = readData(getActiveName())).save(args.filename)
elif args.command == 'use':
print indexes['names']
if not args.name in indexes['names']:
print ""ERROR: No such index named '%s'""%(args.name)
sys.exit()
indexes['active'] =indexes['names'].index(args.name)
dumpIndexes()
elif args.command == 'delete':
if not args.name in indexes['names']:
print ""ERROR: No such index named '%s'""%(args.name)
sys.exit()
nameIindex = indexes['names'].index(args.name)
if indexes['active'] == nameIindex:
print 'WARNING: deleting active index'
indexes['active'] = None
del indexes['names'][nameIindex]
dumpIndexes()
else :
print ""unknown command %s""%(args.command)
",1
"erved.
#
# 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.
""""""Metadata request handler.""""""
import hashlib
import hmac
import os
from oslo_config import cfg
from oslo_log import log as logging
import six
import webob.dec
import webob.exc
from nova.api.metadata import base
from nova import conductor
from nova import exception
from nova.i18n import _
from nova.i18n import _LE
from nova.i18n import _LW
from nova.openstack.common import memorycache
from nova import utils
from nova import wsgi
CACHE_EXPIRATION = 15 # in seconds
CONF = cfg.CONF
CONF.import_opt('use_forwarded_for', 'nova.api.auth')
metadata_proxy_opts = [
cfg.BoolOpt(
'service_metadata_proxy',
default=False,
help='Set flag to indicate Neutron will proxy metadata requests and '
'resolve instance ids.'),
cfg.StrOpt(
'metadata_proxy_shared_secret',
default='', secret=True,
help='Shared secret to validate proxies Neutron metadata requests'),
]
CONF.register_opts(metadata_proxy_opts, 'neutron')
LOG = logging.getLogger(__name__)
class MetadataRequestHandler(wsgi.Application):
""""""Serve metadata.""""""
def __init__(self):
self._cache = memorycache.get_client()
self.conductor_api = conductor.API()
def get_metadata_by_remote_address(self, address):
if not address:
raise exception.FixedIpNotFoundForAddress(address=address)
cache_key = 'metadata-%s' % address
data = self._cache.get(cache_key)
if data:
return data
try:
data = base.get_metadata_by_address(self.conductor_api, address)
except exception.NotFound:
return None
self._cache.set(cache_key, data, CACHE_EXPIRATION)
return data
def get_metadata_by_instance_id(self, instance_id, address):
cache_key = 'metadata-%s' % instance_id
data = self._cache.get(cache_key)
if data:
return data
try:
data = base.get_metadata_by_instance_id(self.conductor_api,
instance_id, address)
except exception.NotFound:
return None
self._cache.set(cache_key, data, CACHE_EXPIRATION)
return data
@webob.dec.wsgify(RequestClass=wsgi.Request)
def __call__(self, req):
if os.path.normpath(req.path_info) == ""/"":
resp = base.ec2_md_print(base.VERSIONS + [""latest""])
req.response.body = resp
req.response.content_type = base.MIME_TYPE_TEXT_PLAIN
return req.response
if CONF.neutron.service_metadata_proxy:
meta_data = self._handle_instance_id_request(req)
else:
if req.headers.get('X-Instance-ID'):
LOG.warning(
_LW(""X-Instance-ID present in request headers. The ""
""'service_metadata_proxy' option must be ""
""enabled to process this header.""))
meta_data = self._handle_remote_ip_request(req)
if meta_data is None:
raise webob.exc.HTTPNotFound()
try:
data = meta_data.lookup(req.path_info)
except base.InvalidMetadataPath:
raise webob.exc.HTTPNotFound()
if callable(data):
return data(req, meta_data)
resp = base.ec2_md_print(data)
if isinstance(resp, six.text_type):
req.response.text = resp
else:
req.response.body = resp
req.response.content_type = meta_data.get_mimetype()
return req.response
def _handle_remote_ip_request(self, req):
remote_address = req.remote_addr
if CONF.use_forwarded_for:
remote_address = req.headers.get('X-Forwarded-For', remote_address)
try:
meta_data = self.get_metadata_by_remote_address(remote_address)
except Exception:
LOG.exception(_LE('Failed to get metadata for ip: %s'),
remote_address)
msg = _('An unknown error has occurred. '
'Please try your request again.')
raise webob.exc.HTTPInternalServerError(
explanation=six.text_type(msg))
if meta_data is None:
LOG.error(_LE('Failed to get metadata for ip: %s'),
remote_address)
return meta_data
def _handle_instance_id_request(self, req):
instance_id = req.headers.get('X-Instance-ID')
tenant_id = req.headers.get('X-Tenant-ID')
signature = req.headers.get('X-Instance-ID-Signature')
remote_address = req.headers.get('X-Forwarded-For')
# Ensure that only one header was passed
if instance_id is None:
msg = _('X-Instance-ID header is missing from request.')
elif signature is None:
msg = _('X-Instance-ID-Signature header is missing from request.')
elif tenant_id is None:
msg = _('X-Tenant-ID header is missing from request.')
elif not isinstance(instance_id, six.string_types):
msg = _('Multiple X-Instance-ID headers found within request.')
elif not isinstance(tenant_id, six.string_types):
msg = _('Multiple X-Tenant-ID headers found within request.')
else:
msg = None
if msg:
raise webob.exc.HTTPBadRequest(explanation=msg)
expected_signature = hmac.new(
CONF.neutron.metadata_proxy_shared_secret,
instance_id,
hashlib.sha256).hexdigest()
if not utils.constant_time_compare(expected_signature, signature):
if instance_id:
LOG.warning(_LW('X-Instance-ID-Signature: %(signature)s does '
'not match the expected value: '
'%(expected_signature)s for id: '
'%(instance_id)s. Request From: '
'%(remote_address)s'),
{'signature': signature,
'expected_signature': expected_signature,
'instance_id': instance_id,
'remote_address': remote_address})
msg = _('Invalid proxy request signature.')
raise webob.exc.HTTPForbidden(explanation=msg)
try:
meta_data = self.get_metadata_by_instance_id(instance_id,
remote_address)
except Exception:
LOG.exception(_LE('Failed to get metadata for instance id: %s'),
instance_id)
msg = _('An unknown error has occurred. '
'Please try your request again.')
raise webob.exc.HTTPInternalServerError(
explanation=six.text_type(msg))
if meta_data is None:
LOG.error(_LE('Failed to get metadata for instance id: %s'),
instance_id)
elif meta_data.instance.project_id != tenant_id:
LOG.warning(_LW(""Tenant_id %(tenant_id)s does not match tenant_id ""
""of instance %(instance_id)s.""),
{'tenant_id': tenant_id, 'instance_id': instance_id})
# causes a 404 to be raised
meta_data = None
return meta_data
",1
"ll on
a set of subjects and then make an average subject.
python smri_freesurfer.py
Import necessary modules from nipype.
""""""
import os
import nipype.pipeline.engine as pe
import nipype.interfaces.io as nio
from nipype.interfaces.freesurfer.preprocess import ReconAll
from nipype.interfaces.freesurfer.utils import MakeAverageSubject
subject_list = ['s1', 's3']
data_dir = os.path.abspath('data')
subjects_dir = os.path.abspath('amri_freesurfer_tutorial/subjects_dir')
wf = pe.Workflow(name=""l1workflow"")
wf.base_dir = os.path.abspath('amri_freesurfer_tutorial/workdir')
""""""
Grab data
""""""
datasource = pe.MapNode(interface=nio.DataGrabber(infields=['subject_id'],
outfields=['struct']),
name='datasource',
iterfield=['subject_id'])
datasource.inputs.base_directory = data_dir
datasource.inputs.template = '%s/%s.nii'
datasource.inputs.template_args = dict(struct=[['subject_id', 'struct']])
datasource.inputs.subject_id = subject_list
""""""
Run recon-all
""""""
recon_all = pe.MapNode(interface=ReconAll(), name='recon_all',
iterfield=['subject_id', 'T1_files'])
recon_all.inputs.subject_id = subject_list
if not os.path.exists(subjects_dir):
os.mkdir(subjects_dir)
recon_all.inputs.subjects_dir = subjects_dir
wf.connect(datasource, 'struct', recon_all, 'T1_files')
""""""
Make average subject
""""""
average = pe.Node(interface=MakeAverageSubject(), name=""average"")
average.inputs.subjects_dir = subjects_dir
wf.connect(recon_all, 'subject_id', average, 'subjects_ids')
wf.run(""MultiProc"", plugin_args={'n_procs': 4})
",1
"/docs.djangoproject.com/en/1.11/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.11/ref/settings/
""""""
import os
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.11/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = '$-2ijwgs8-3i*r#j@1ian5xrp+17)fz)%cdjjhwa#4x&%lk7v@'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True
ALLOWED_HOSTS = []
# Application definition
INSTALLED_APPS = [
'keys',
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
]
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'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',
]
ROOT_URLCONF = 'keyman.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django.DjangoTemplates',
'DIRS': [],
'APP_DIRS': True,
'OPTIONS': {
'context_processors': [
'django.template.context_processors.debug',
'django.template.context_processors.request',
'django.contrib.auth.context_processors.auth',
'django.contrib.messages.context_processors.messages',
],
},
},
]
WSGI_APPLICATION = 'keyman.wsgi.application'
# Database
# https://docs.djangoproject.com/en/1.11/ref/settings/#databases
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
}
# Password validation
# https://docs.djangoproject.com/en/1.11/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/1.11/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/1.11/howto/static-files/
STATIC_URL = '/static/'
",1
""" This class extends the base TransactionCase, in order to test the
accounting with localization setups. It is configured to run the tests after
the installation of all modules, and will SKIP TESTS ifit cannot find an already
configured accounting (which means no localization module has been installed).
""""""
post_install = True
at_install = False
def setUp(self):
super(AccountingTestCase, self).setUp()
domain = [('company_id', '=', self.env.ref('base.main_company').id)]
if not self.env['account.account'].search_count(domain):
self.skipTest(""No Chart of account found"")
def check_complete_move(self, move, theorical_lines):
for aml in move.line_ids:
line = (aml.name, round(aml.debit, 2), round(aml.credit, 2))
if line in theorical_lines:
theorical_lines.remove(line)
else:
raise ValidationError('Unexpected journal item. (label: %s, debit: %s, credit: %s)' % (aml.name, round(aml.debit, 2), round(aml.credit, 2)))
if theorical_lines:
raise ValidationError('Remaining theorical line (not found). %s)' % ([(aml[0], aml[1], aml[2]) for aml in theorical_lines]))
return True
def ensure_account_property(self, property_name):
'''Ensure the ir.property targetting an account.account passed as parameter exists.
In case it's not: create it with a random account. This is useful when testing with
partially defined localization (missing stock properties for example)
:param property_name: The name of the property.
'''
company_id = self.env.user.company_id
field_id = self.env['ir.model.fields'].search(
[('model', '=', 'product.template'), ('name', '=', property_name)], limit=1)
property_id = self.env['ir.property'].search([
('company_id', '=', company_id.id),
('name', '=', property_name),
('res_id', '=', None),
('fields_id', '=', field_id.id)], limit=1)
account_id = self.env['account.account'].search([('company_id', '=', company_id.id)], limit=1)
value_reference = 'account.account,%d' % account_id.id
if property_id and not property_id.value_reference:
property_id.value_reference = value_reference
else:
self.env['ir.property'].create({
'name': property_name,
'company_id': company_id.id,
'fields_id': field_id.id,
'value_reference': value_reference,
})
",1
"according to PEP 3119.
DON'T USE THIS MODULE DIRECTLY! The classes here should be imported
via collections; they are defined here only to alleviate certain
bootstrapping issues. Unit tests are in test_collections.
""""""
from abc import ABCMeta, abstractmethod
import sys
__all__ = [""Hashable"", ""Iterable"", ""Iterator"",
""Sized"", ""Container"", ""Callable"",
""Set"", ""MutableSet"",
""Mapping"", ""MutableMapping"",
""MappingView"", ""KeysView"", ""ItemsView"", ""ValuesView"",
""Sequence"", ""MutableSequence"",
]
### ONE-TRICK PONIES ###
class Hashable:
__metaclass__ = ABCMeta
@abstractmethod
def __hash__(self):
return 0
@classmethod
def __subclasshook__(cls, C):
if cls is Hashable:
for B in C.__mro__:
if ""__hash__"" in B.__dict__:
if B.__dict__[""__hash__""]:
return True
break
return NotImplemented
class Iterable:
__metaclass__ = ABCMeta
@abstractmethod
def __iter__(self):
while False:
yield None
@classmethod
def __subclasshook__(cls, C):
if cls is Iterable:
if any(""__iter__"" in B.__dict__ for B in C.__mro__):
return True
return NotImplemented
Iterable.register(str)
class Iterator(Iterable):
@abstractmethod
def __next__(self):
raise StopIteration
def __iter__(self):
return self
@classmethod
def __subclasshook__(cls, C):
if cls is Iterator:
if any(""next"" in B.__dict__ for B in C.__mro__):
return True
return NotImplemented
class Sized:
__metaclass__ = ABCMeta
@abstractmethod
def __len__(self):
return 0
@classmethod
def __subclasshook__(cls, C):
if cls is Sized:
if any(""__len__"" in B.__dict__ for B in C.__mro__):
return True
return NotImplemented
class Container:
__metaclass__ = ABCMeta
@abstractmethod
def __contains__(self, x):
return False
@classmethod
def __subclasshook__(cls, C):
if cls is Container:
if any(""__contains__"" in B.__dict__ for B in C.__mro__):
return True
return NotImplemented
class Callable:
__metaclass__ = ABCMeta
@abstractmethod
def __call__(self, *args, **kwds):
return False
@classmethod
def __subclasshook__(cls, C):
if cls is Callable:
if any(""__call__"" in B.__dict__ for B in C.__mro__):
return True
return NotImplemented
### SETS ###
class Set(Sized, Iterable, Container):
""""""A set is a finite, iterable container.
This class provides concrete generic implementations of all
methods except for __contains__, __iter__ and __len__.
To override the comparisons (presumably for speed, as the
semantics are fixed), all you have to do is redefine __le__ and
then the other operations will automatically follow suit.
""""""
def __le__(self, other):
if not isinstance(other, Set):
return NotImplemented
if len(self) > len(other):
return False
for elem in self:
if elem not in other:
return False
return True
def __lt__(self, other):
if not isinstance(other, Set):
return NotImplemented
return len(self) < len(other) and self.__le__(other)
def __gt__(self, other):
if not isinstance(other, Set):
return NotImplemented
return other < self
def __ge__(self, other):
if not isinstance(other, Set):
return NotImplemented
return other <= self
def __eq__(self, other):
if not isinstance(other, Set):
return NotImplemented
return len(self) == len(other) and self.__le__(other)
def __ne__(self, other):
return not (self == other)
@classmethod
def _from_iterable(cls, it):
'''Construct an instance of the class from any iterable input.
Must override this method if the class constructor signature
does not accept an iterable for an input.
'''
return cls(it)
def __and__(self, other):
if not isinstance(other, Iterable):
return NotImplemented
return self._from_iterable(value for value in other if value in self)
def isdisjoint(self, other):
for value in other:
if value in self:
return False
return True
def __or__(self, other):
if not isinstance(other, Iterable):
return NotImplemented
chain = (e for s in (self, other) for e in s)
return self._from_iterable(chain)
def __sub__(self, other):
if not isinstance(other, Set):
if not isinstance(other, Iterable):
return NotImplemented
other = self._from_iterable(other)
return self._from_iterable(value for value in self
if value not in other)
def __xor__(self, other):
if not isinstance(other, Set):
if not isinstance(other, Iterable):
return NotImplemented
other = self._from_iterable(other)
return (self - other) | (other - self)
# Sets are not hashable by default, but subclasses can change this
__hash__ = None
def _hash(self):
""""""Compute the hash value of a set.
Note that we don't define __hash__: not all sets are hashable.
But if you define a hashable set type, its __hash__ should
call this function.
This must be compatible __eq__.
All sets ought to compare equal if they contain the same
elements, regardless of how they are implemented, and
regardless of the order of the elements; so there's not much
freedom for __eq__ or __hash__. We match the algorithm used
by the built-in frozenset type.
""""""
MAX = sys.maxint
MASK = 2 * MAX + 1
n = len(self)
h = 1927868237 * (n + 1)
h &= MASK
for x in self:
hx = hash(x)
h ^= (hx ^ (hx << 16) ^ 89869747) * 3644798167
h &= MASK
h = h * 69069 + 907133923
h &= MASK
if h > MAX:
h -= MASK + 1
if h == -1:
h = 590923713
return h
Set.register(frozenset)
class MutableSet(Set):
@abstractmethod
def add(self, value):
""""""Return True if it was added, False if already there.""""""
raise NotImplementedError
@abstractmethod
def discard(self, value):
""""""Return True if it was deleted, False if not there.""""""
raise NotImplementedError
def remove(self, value):
""""""Remove an element. If not a member, raise a KeyError.""""""
if value not in self:
raise KeyError(value)
self.discard(value)
def pop(self):
""""""Return the popped value. Raise KeyError if empty.""""""
it = iter(self)
try:
value = it.__next__()
except StopIteration:
raise KeyError
self.discard(value)
return value
def clear(self):
""""""This is slow (creates N new iterators!) but effective.""""""
try:
while True:
self.pop()
except KeyError:
pass
def __ior__(self, it):
for value in it:
self.add(value)
return self
def __iand__(self, c):
for value in self:
if value not in c:
self.discard(value)
return self
def __ixor__(self, it):
if not isinstance(it, Set):
it = self._from_iterable(it)
for value in it:
if value in self:
self.discard(value)
else:
self.add(value)
return self
def __isub__(self, it):
for value in it:
self.discard(value)
return self
MutableSet.register(set)
### MAPPINGS ###
class Mapping(Sized, Iterable, Container):
@abstractmethod
def __getitem__(self, key):
raise KeyError
def get(self, key, default=None):
try:
return self[key]
except KeyError:
return default
def __contains__(self, key):
try:
self[key]
except KeyError:
return False
else:
return True
def iterkeys(self):
return iter(self)
def itervalues(self):
for key in self:
yield self[key]
def iteritems(self):
for key in self:
yield (key, self[key])
def keys(self):
return list(self)
def items(self):
return [(key, self[key]) for key in self]
def values(self):
return [self[key] for key in self]
# Mappings are not hashable by default, but subclasses can change this
__hash__ = None
def __eq__(self, other):
return isinstance(other, Mapping) and \
dict(self.items()) == dict(other.items())
def __ne__(self, other):
return not (self == other)
class MappingView(Sized):
def __init__(self, mapping):
self._mapping = mapping
def __len__(self):
return len(self._mapping)
class KeysView(MappingView, Set):
def __contains__(self, key):
return key in self._mapping
def __iter__(self):
for key in self._mapping:
yield key
class ItemsView(MappingView, Set):
def __contains__(self, item):
key, value = item
try:
v = self._mapping[key]
except KeyError:
return False
else:
return v == value
def __iter__(self):
for key in self._mapping:
yield (key, self._mapping[key])
class ValuesView(MappingView):
def __contains__(self, value):
for key in self._mapping:
if value == self._mapping[key]:
return True
return False
def __iter__(self):
for key in self._mapping:
yield self._mapping[key]
class MutableMapping(Mapping):
@abstractmethod
def __setitem__(self, key, value):
raise KeyError
@abstractmethod
def __delitem__(self, key):
raise KeyError
__marker = object()
def pop(self, key, default=__marker):
try:
value = self[key]
except KeyError:
if default is self.__marker:
raise
return default
else:
del self[key]
return value
def popitem(self):
try:
key = next(iter(self))
except StopIteration:
raise KeyError
value = self[key]
del self[key]
return key, value
def clear(self):
try:
while True:
self.popitem()
except KeyError:
pass
def update(self, other=(), **kwds):
if isinstance(other, Mapping):
for key in other:
self[key] = other[key]
elif hasattr(other, ""keys""):
for key in other.keys():
self[key] = other[key]
else:
for key, value in other:
self[key] = value
for key, value in kwds.items():
self[key] = value
def setdefault(self, key, default=None):
try:
return self[key]
except KeyError:
self[key] = default
return default
MutableMapping.register(dict)
### SEQUENCES ###
class Sequence(Sized, Iterable, Container):
""""""All the operations on a read-only sequence.
Concrete subclasses must override __new__ or __init__,
__getitem__, and __len__.
""""""
@abstractmethod
def __getitem__(self, index):
raise IndexError
def __iter__(self):
i = 0
try:
while True:
v = self[i]
yield v
i += 1
except IndexError:
return
def __contains__(self, value):
for v in self:
if v == value:
return True
return False
def __reversed__(self):
for i in reversed(range(len(self))):
yield self[i]
def index(self, value):
for i, v in enumerate(self):
if v == value:
return i
raise ValueError
def count(self, value):
return sum(1 for v in self if v == value)
Sequence.register(tuple)
Sequence.register(basestring)
Sequence.register(buffer)
class MutableSequence(Sequence):
@abstractmethod
def __setitem__(self, index, value):
raise IndexError
@abstractmethod
def __delitem__(self, index):
raise IndexError
@abstractmethod
def insert(self, index, value):
raise IndexError
def append(self, value):
self.insert(len(self), value)
def reverse(self):
n = len(self)
for i in range(n//2):
self[i], self[n-i-1] = self[n-i-1], self[i]
def extend(self, values):
for v in values:
self.append(v)
def pop(self, index=-1):
v = self[index]
del self[index]
return v
def remove(self, value):
del self[self.index(value)]
def __iadd__(self, values):
self.extend(values)
MutableSequence.register(list)
",1
"ents.device_tracker import (
DOMAIN,
PLATFORM_SCHEMA as PARENT_PLATFORM_SCHEMA,
DeviceScanner,
)
from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
import homeassistant.helpers.config_validation as cv
_LOGGER = logging.getLogger(__name__)
CONF_DHCP_SOFTWARE = ""dhcp_software""
DEFAULT_DHCP_SOFTWARE = ""dnsmasq""
DHCP_SOFTWARES = [""dnsmasq"", ""odhcpd"", ""none""]
PLATFORM_SCHEMA = PARENT_PLATFORM_SCHEMA.extend(
{
vol.Required(CONF_HOST): cv.string,
vol.Required(CONF_PASSWORD): cv.string,
vol.Required(CONF_USERNAME): cv.string,
vol.Optional(CONF_DHCP_SOFTWARE, default=DEFAULT_DHCP_SOFTWARE): vol.In(
DHCP_SOFTWARES
),
}
)
def get_scanner(hass, config):
""""""Validate the configuration and return an ubus scanner.""""""
dhcp_sw = config[DOMAIN][CONF_DHCP_SOFTWARE]
if dhcp_sw == ""dnsmasq"":
scanner = DnsmasqUbusDeviceScanner(config[DOMAIN])
elif dhcp_sw == ""odhcpd"":
scanner = OdhcpdUbusDeviceScanner(config[DOMAIN])
else:
scanner = UbusDeviceScanner(config[DOMAIN])
return scanner if scanner.success_init else None
def _refresh_on_access_denied(func):
""""""If remove rebooted, it lost our session so rebuild one and try again.""""""
def decorator(self, *args, **kwargs):
""""""Wrap the function to refresh session_id on PermissionError.""""""
try:
return func(self, *args, **kwargs)
except PermissionError:
_LOGGER.warning(
""Invalid session detected.""
"" Trying to refresh session_id and re-run RPC""
)
self.ubus.connect()
return func(self, *args, **kwargs)
return decorator
class UbusDeviceScanner(DeviceScanner):
""""""
This class queries a wireless router running OpenWrt firmware.
Adapted from Tomato scanner.
""""""
def __init__(self, config):
""""""Initialize the scanner.""""""
host = config[CONF_HOST]
self.username = config[CONF_USERNAME]
self.password = config[CONF_PASSWORD]
self.parse_api_pattern = re.compile(r""(?P\w*) = (?P.*);"")
self.last_results = {}
self.url = f""http://{host}/ubus""
self.ubus = Ubus(self.url, self.username, self.password)
self.hostapd = []
self.mac2name = None
self.success_init = self.ubus.connect() is not None
def scan_devices(self):
""""""Scan for new devices and return a list with found device IDs.""""""
self._update_info()
return self.last_results
def _generate_mac2name(self):
""""""Return empty MAC to name dict. Overridden if DHCP server is set.""""""
self.mac2name = {}
@_refresh_on_access_denied
def get_device_name(self, device):
""""""Return the name of the given device or None if we don't know.""""""
if self.mac2name is None:
self._generate_mac2name()
if self.mac2name is None:
# Generation of mac2name dictionary failed
return None
name = self.mac2name.get(device.upper(), None)
return name
@_refresh_on_access_denied
def _update_info(self):
""""""Ensure the information from the router is up to date.
Returns boolean if scanning successful.
""""""
if not self.success_init:
return False
_LOGGER.info(""Checking hostapd"")
if not self.hostapd:
hostapd = self.ubus.get_hostapd()
self.hostapd.extend(hostapd.keys())
self.last_results = []
results = 0
# for each access point
for hostapd in self.hostapd:
if result := self.ubus.get_hostapd_clients(hostapd):
results = results + 1
# Check for each device is authorized (valid wpa key)
for key in result[""clients""].keys():
device = result[""clients""][key]
if device[""authorized""]:
self.last_results.append(key)
return bool(results)
class DnsmasqUbusDeviceScanner(UbusDeviceScanner):
""""""Implement the Ubus device scanning for the dnsmasq DHCP server.""""""
def __init__(self, config):
""""""Initialize the scanner.""""""
super().__init__(config)
self.leasefile = None
def _generate_mac2name(self):
if self.leasefile is None:
if result := self.ubus.get_uci_config(""dhcp"", ""dnsmasq""):
values = result[""values""].values()
self.leasefile = next(iter(values))[""leasefile""]
else:
return
result = self.ubus.file_read(self.leasefile)
if result:
self.mac2name = {}
for line in result[""data""].splitlines():
hosts = line.split("" "")
self.mac2name[hosts[1].upper()] = hosts[3]
else:
# Error, handled in the ubus.file_read()
return
class OdhcpdUbusDeviceScanner(UbusDeviceScanner):
""""""Implement the Ubus device scanning for the odhcp DHCP server.""""""
def _generate_mac2name(self):
if result := self.ubus.get_dhcp_method(""ipv4leases""):
self.mac2name = {}
for device in result[""device""].values():
for lease in device[""leases""]:
mac = lease[""mac""] # mac = aabbccddeeff
# Convert it to expected format with colon
mac = "":"".join(mac[i : i + 2] for i in range(0, len(mac), 2))
self.mac2name[mac.upper()] = lease[""hostname""]
else:
# Error, handled in the ubus.get_dhcp_method()
return
",1
"n import login_required, current_user
from realms.lib.util import to_canonical, remove_ext, gravatar_url
from .models import PageNotFound
blueprint = Blueprint('wiki', __name__)
@blueprint.route(""/_commit//"")
def commit(name, sha):
if current_app.config.get('PRIVATE_WIKI') and current_user.is_anonymous():
return current_app.login_manager.unauthorized()
cname = to_canonical(name)
data = g.current_wiki.get_page(cname, sha=sha)
if not data:
abort(404)
return render_template('wiki/page.html', name=name, page=data, commit=sha)
@blueprint.route(r""/_compare//"")
def compare(name, fsha, dots, lsha):
if current_app.config.get('PRIVATE_WIKI') and current_user.is_anonymous():
return current_app.login_manager.unauthorized()
diff = g.current_wiki.compare(name, fsha, lsha)
return render_template('wiki/compare.html',
name=name, diff=diff, old=fsha, new=lsha)
@blueprint.route(""/_revert"", methods=['POST'])
@login_required
def revert():
cname = to_canonical(request.form.get('name'))
commit = request.form.get('commit')
message = request.form.get('message', ""Reverting %s"" % cname)
if not current_app.config.get('ALLOW_ANON') and current_user.is_anonymous():
return dict(error=True, message=""Anonymous posting not allowed""), 403
if cname in current_app.config.get('WIKI_LOCKED_PAGES'):
return dict(error=True, message=""Page is locked""), 403
try:
sha = g.current_wiki.revert_page(cname,
commit,
message=message,
username=current_user.username,
email=current_user.email)
except PageNotFound as e:
return dict(error=True, message=e.message), 404
if sha:
flash(""Page reverted"")
return dict(sha=sha)
@blueprint.route(""/_history/"")
def history(name):
if current_app.config.get('PRIVATE_WIKI') and current_user.is_anonymous():
return current_app.login_manager.unauthorized()
hist = g.current_wiki.get_history(name)
for item in hist:
item['gravatar'] = gravatar_url(item['author_email'])
return render_template('wiki/history.html', name=name, history=hist)
@blueprint.route(""/_edit/"")
@login_required
def edit(name):
cname = to_canonical(name)
page = g.current_wiki.get_page(name)
if not page:
# Page doesn't exist
return redirect(url_for('wiki.create', name=cname))
name = remove_ext(page['path'])
g.assets['js'].append('editor.js')
return render_template('wiki/edit.html',
name=name,
content=page.get('data'),
info=page.get('info'),
sha=page.get('sha'),
partials=page.get('partials'))
@blueprint.route(""/_create/"", defaults={'name': None})
@blueprint.route(""/_create/"")
@login_required
def create(name):
cname = to_canonical(name) if name else """"
if cname and g.current_wiki.get_page(cname):
# Page exists, edit instead
return redirect(url_for('wiki.edit', name=cname))
g.assets['js'].append('editor.js')
return render_template('wiki/edit.html',
name=cname,
content="""",
info={})
def _get_subdir(path, depth):
parts = path.split('/', depth)
if len(parts) > depth:
return parts[-2]
def _tree_index(items, path=""""):
depth = len(path.split(""/""))
items = filter(lambda x: x['name'].startswith(path), items)
items = sorted(items, key=lambda x: x['name'])
for subdir, items in itertools.groupby(items, key=lambda x: _get_subdir(x['name'], depth)):
if not subdir:
for item in items:
yield dict(item, dir=False)
else:
size = 0
ctime = sys.maxint
mtime = 0
for item in items:
size += item['size']
ctime = min(item['ctime'], ctime)
mtime = max(item['mtime'], mtime)
yield dict(name=path + subdir + ""/"",
mtime=mtime,
ctime=ctime,
size=size,
dir=True)
@blueprint.route(""/_index"", defaults={""path"": """"})
@blueprint.route(""/_index/"")
def index(path):
if current_app.config.get('PRIVATE_WIKI') and current_user.is_anonymous():
return current_app.login_manager.unauthorized()
items = g.current_wiki.get_index()
if path:
path = to_canonical(path) + ""/""
return render_template('wiki/index.html', index=_tree_index(items, path=path), path=path)
@blueprint.route(""/"", methods=['POST', 'PUT', 'DELETE'])
@login_required
def page_write(name):
cname = to_canonical(name)
if not cname:
return dict(error=True, message=""Invalid name"")
if not current_app.config.get('ALLOW_ANON') and current_user.is_anonymous():
return dict(error=True, message=""Anonymous posting not allowed""), 403
if request.method == 'POST':
# Create
if cname in current_app.config.get('WIKI_LOCKED_PAGES'):
return dict(error=True, message=""Page is locked""), 403
sha = g.current_wiki.write_page(cname,
request.form['content'],
message=request.form['message'],
create=True,
username=current_user.username,
email=current_user.email)
elif request.method == 'PUT':
edit_cname = to_canonical(request.form['name'])
if edit_cname in current_app.config.get('WIKI_LOCKED_PAGES'):
return dict(error=True, message=""Page is locked""), 403
if edit_cname != cname:
g.current_wiki.rename_page(cname, edit_cname)
sha = g.current_wiki.write_page(edit_cname,
request.form['content'],
message=request.form['message'],
username=current_user.username,
email=current_user.email)
return dict(sha=sha)
elif request.method == 'DELETE':
# DELETE
if cname in current_app.config.get('WIKI_LOCKED_PAGES'):
return dict(error=True, message=""Page is locked""), 403
sha = g.current_wiki.delete_page(cname,
username=current_user.username,
email=current_user.email)
return dict(sha=sha)
@blueprint.route(""/"", defaults={'name': 'home'})
@blueprint.route(""/"")
def page(name):
if current_app.config.get('PRIVATE_WIKI') and current_user.is_anonymous():
return current_app.login_manager.unauthorized()
cname = to_canonical(name)
if cname != name:
return redirect(url_for('wiki.page', name=cname))
data = g.current_wiki.get_page(cname)
if data:
return render_template('wiki/page.html', name=cname, page=data, partials=data.get('partials'))
else:
return redirect(url_for('wiki.create', name=cname))
",1
".contrib.sessions',
'django.contrib.sites',
'django.contrib.admin',
'mptt',
'cms',
'menus',
'djangocms_inherit',
'south',
]
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': ':memory:',
}
}
TEMPLATE_CONTEXT_PROCESSORS = [
'django.core.context_processors.auth',
'django.core.context_processors.i18n',
'django.core.context_processors.request',
'django.core.context_processors.media',
'django.core.context_processors.static',
'cms.context_processors.media',
'sekizai.context_processors.sekizai',
]
ROOT_URLCONF = 'cms.urls'
def schemamigration():
# turn ``schemamigration.py --initial`` into
# ``manage.py schemamigration cmsplugin_disqus --initial`` and setup the
# enviroment
from django.conf import settings
from django.core.management import ManagementUtility
settings.configure(
INSTALLED_APPS=INSTALLED_APPS,
ROOT_URLCONF=ROOT_URLCONF,
DATABASES=DATABASES,
TEMPLATE_CONTEXT_PROCESSORS=TEMPLATE_CONTEXT_PROCESSORS
)
argv = list(sys.argv)
argv.insert(1, 'schemamigration')
argv.insert(2, 'djangocms_inherit')
utility = ManagementUtility(argv)
utility.execute()
if __name__ == ""__main__"":
schemamigration()
",1
"
__all__ = ['TextVisual']
VS = """"""
gl_Position.x += (offset - text_width / 2) * spacing.x / window_size.x;
gl_Position.y -= index * spacing.y / window_size.y;
gl_Position.xy = gl_Position.xy + posoffset / window_size;
gl_PointSize = point_size;
flat_text_map = text_map;
""""""
def FS(background_transparent=True):
if background_transparent:
background_transparent_shader = ""letter_alpha""
else:
background_transparent_shader = ""1.""
fs = """"""
// relative coordinates of the pixel within the sprite (in [0,1])
float x = gl_PointCoord.x;
float y = gl_PointCoord.y;
// size of the corresponding character
float w = flat_text_map.z;
float h = flat_text_map.w;
// display the character at the left of the sprite
float delta = h / w;
x = delta * x;
if ((x >= 0) && (x <= 1))
{
// coordinates of the character in the font atlas
vec2 coord = flat_text_map.xy + vec2(w * x, h * y);
float letter_alpha = texture2D(tex_sampler, coord).a;
out_color = color * letter_alpha;
out_color.a = %s;
}
else
out_color = vec4(0, 0, 0, 0);
"""""" % background_transparent_shader
return fs
class TextVisual(Visual):
""""""Template for displaying short text on a single line.
It uses the following technique: each character is rendered as a sprite,
i.e. a pixel with a large point size, and a single texture for every point.
The texture contains a font atlas, i.e. all characters in a given font.
Every point comes with coordinates that indicate which small portion
of the font atlas to display (that portion corresponds to the character).
This is all done automatically, thanks to a font atlas stored in the
`fontmaps` folder. There needs to be one font atlas per font and per font
size. Also, there is a configuration text file with the coordinates and
size of every character. The software used to generate font maps is
AngelCode Bitmap Font Generator.
For now, there is only the Segoe font.
""""""
def position_compound(self, coordinates=None):
""""""Compound variable with the position of the text. All characters
are at the exact same position, and are then shifted in the vertex
shader.""""""
if coordinates is None:
coordinates = (0., 0.)
if type(coordinates) == tuple:
coordinates = [coordinates]
coordinates = np.array(coordinates)
position = np.repeat(coordinates, self.textsizes, axis=0)
return dict(position=position)
def text_compound(self, text):
""""""Compound variable for the text string. It changes the text map,
the character position, and the text width.""""""
coordinates = self.coordinates
if ""\n"" in text:
text = text.split(""\n"")
if type(text) == list:
self.textsizes = [len(t) for t in text]
text = """".join(text)
if type(coordinates) != list:
coordinates = [coordinates] * len(self.textsizes)
index = np.repeat(np.arange(len(self.textsizes)), self.textsizes)
text_map = self.get_map(text)
# offset for all characters in the merging of all texts
offset = np.hstack((0., np.cumsum(text_map[:, 2])[:-1]))
# for each text, the cumsum of the length of all texts strictly
# before
d = np.hstack(([0], np.cumsum(self.textsizes)[:-1]))
# compensate the offsets for the length of each text
offset -= np.repeat(offset[d], self.textsizes)
text_width = 0.
else:
self.textsizes = len(text)
text_map = self.get_map(text)
offset = np.hstack((0., np.cumsum(text_map[:, 2])[:-1]))
text_width = offset[-1]
index = np.zeros(len(text))
self.size = len(text)
d = dict(text_map=text_map, offset=offset, text_width=text_width,
index=index)
d.update(self.position_compound(coordinates))
return d
def initialize_font(self, font, fontsize):
""""""Initialize the specified font at a given size.""""""
self.texture, self.matrix, self.get_map = load_font(font, fontsize)
def initialize(self, text, coordinates=(0., 0.), font='segoe', fontsize=24,
color=None, letter_spacing=None, interline=0., autocolor=None,
background_transparent=True,
prevent_constrain=False, depth=None, posoffset=None):
""""""Initialize the text template.""""""
if prevent_constrain:
self.constrain_ratio = False
if autocolor is not None:
color = get_color(autocolor)
if color is None:
color = self.default_color
self.size = len(text)
self.primitive_type = 'POINTS'
self.interline = interline
text_length = self.size
self.initialize_font(font, fontsize)
self.coordinates = coordinates
point_size = float(self.matrix[:,4].max() * self.texture.shape[1])
# template attributes and varyings
self.add_attribute(""position"", vartype=""float"", ndim=2, data=np.zeros((self.size, 2)))
self.add_attribute(""offset"", vartype=""float"", ndim=1)
self.add_attribute(""index"", vartype=""float"", ndim=1)
self.add_attribute(""text_map"", vartype=""float"", ndim=4)
self.add_varying(""flat_text_map"", vartype=""float"", flat=True, ndim=4)
if posoffset is None:
posoffset = (0., 0.)
self.add_uniform('posoffset', vartype='float', ndim=2, data=posoffset)
# texture
self.add_texture(""tex_sampler"", size=self.texture.shape[:2], ndim=2,
ncomponents=self.texture.shape[2],
data=self.texture)
# pure heuristic (probably bogus)
if letter_spacing is None:
letter_spacing = (100 + 17. * fontsize)
self.add_uniform(""spacing"", vartype=""float"", ndim=2,
data=(letter_spacing, interline))
self.add_uniform(""point_size"", vartype=""float"", ndim=1,
data=point_size)
# one color per
if isinstance(color, np.ndarray) and color.ndim > 1:
self.add_attribute('color0', vartype=""float"", ndim=4, data=color)
self.add_varying('color', vartype=""float"", ndim=4)
self.add_vertex_main('color = color0;')
else:
self.add_uniform(""color"", vartype=""float"", ndim=4, data=color)
self.add_uniform(""text_width"", vartype=""float"", ndim=1)
# compound variables
self.add_compound(""text"", fun=self.text_compound, data=text)
self.add_compound(""coordinates"", fun=self.position_compound, data=coordinates)
# vertex shader
self.add_vertex_main(VS, after='viewport')
# fragment shader
self.add_fragment_main(FS(background_transparent))
self.depth = depth",1
" = logging.getLogger('rdopkg')
log.setLevel(logging.INFO)
if len(log.handlers) < 1:
formatter = logging.Formatter(fmt='%(message)s')
handler = logging.StreamHandler()
handler.setFormatter(formatter)
log.addHandler(handler)
class LogTerminal(terminal.Terminal):
@property
def warn(self):
return self.yellow
@property
def important(self):
return self.yellow_bold
@property
def error(self):
return self.red
@property
def good(self):
return self.green
@property
def cmd(self):
return self.cyan
term = LogTerminal()
def set_colors(colors):
global term
if colors == 'yes':
if not terminal.COLOR_TERMINAL:
return False
term = LogTerminal(force_styling=True)
return True
elif colors == 'no':
if not terminal.COLOR_TERMINAL:
return True
term = LogTerminal(force_styling=None)
return True
elif colors == 'auto':
term = LogTerminal()
return True
return False
def error(*args, **kwargs):
if args:
largs = list(args)
largs[0] = term.error(args[0])
args = tuple(largs)
log.error(*args, **kwargs)
def warn(*args, **kwargs):
if args:
largs = list(args)
largs[0] = term.warn(args[0])
args = tuple(largs)
log.warning(*args, **kwargs)
def success(*args, **kwargs):
if args:
largs = list(args)
largs[0] = term.good(args[0])
args = tuple(largs)
log.info(*args, **kwargs)
def info(*args, **kwargs):
log.info(*args, **kwargs)
def verbose(*args, **kwargs):
log.log(VERBOSE, *args, **kwargs)
def debug(*args, **kwargs):
log.debug(*args, **kwargs)
def command(*args, **kwargs):
log.info(*args, **kwargs)
",1
"m odoo.addons.payment.models.payment_acquirer import ValidationError
from odoo.addons.payment_paypal.controllers.main import PaypalController
from odoo.tools.float_utils import float_compare
_logger = logging.getLogger(__name__)
class AcquirerPaypal(models.Model):
_inherit = 'payment.acquirer'
provider = fields.Selection(selection_add=[('paypal', 'Paypal')])
paypal_email_account = fields.Char('Paypal Email ID', required_if_provider='paypal', groups='base.group_user')
paypal_seller_account = fields.Char(
'Paypal Merchant ID', groups='base.group_user',
help='The Merchant ID is used to ensure communications coming from Paypal are valid and secured.')
paypal_use_ipn = fields.Boolean('Use IPN', default=True, help='Paypal Instant Payment Notification', groups='base.group_user')
paypal_pdt_token = fields.Char(string='Paypal PDT Token', help='Payment Data Transfer allows you to receive notification of successful payments as they are made.', groups='base.group_user')
# Server 2 server
paypal_api_enabled = fields.Boolean('Use Rest API', default=False)
paypal_api_username = fields.Char('Rest API Username', groups='base.group_user')
paypal_api_password = fields.Char('Rest API Password', groups='base.group_user')
paypal_api_access_token = fields.Char('Access Token', groups='base.group_user')
paypal_api_access_token_validity = fields.Datetime('Access Token Validity', groups='base.group_user')
# Default paypal fees
fees_dom_fixed = fields.Float(default=0.35)
fees_dom_var = fields.Float(default=3.4)
fees_int_fixed = fields.Float(default=0.35)
fees_int_var = fields.Float(default=3.9)
def _get_feature_support(self):
""""""Get advanced feature support by provider.
Each provider should add its technical in the corresponding
key for the following features:
* fees: support payment fees computations
* authorize: support authorizing payment (separates
authorization and capture)
* tokenize: support saving payment data in a payment.tokenize
object
""""""
res = super(AcquirerPaypal, self)._get_feature_support()
res['fees'].append('paypal')
return res
@api.model
def _get_paypal_urls(self, environment):
"""""" Paypal URLS """"""
if environment == 'prod':
return {
'paypal_form_url': 'https://www.paypal.com/cgi-bin/webscr',
'paypal_rest_url': 'https://api.paypal.com/v1/oauth2/token',
}
else:
return {
'paypal_form_url': 'https://www.sandbox.paypal.com/cgi-bin/webscr',
'paypal_rest_url': 'https://api.sandbox.paypal.com/v1/oauth2/token',
}
@api.multi
def paypal_compute_fees(self, amount, currency_id, country_id):
"""""" Compute paypal fees.
:param float amount: the amount to pay
:param integer country_id: an ID of a res.country, or None. This is
the customer's country, to be compared to
the acquirer company country.
:return float fees: computed fees
""""""
if not self.fees_active:
return 0.0
country = self.env['res.country'].browse(country_id)
if country and self.company_id.country_id.id == country.id:
percentage = self.fees_dom_var
fixed = self.fees_dom_fixed
else:
percentage = self.fees_int_var
fixed = self.fees_int_fixed
fees = (percentage / 100.0 * amount + fixed) / (1 - percentage / 100.0)
return fees
@api.multi
def paypal_form_generate_values(self, values):
base_url = self.env['ir.config_parameter'].sudo().get_param('web.base.url')
paypal_tx_values = dict(values)
paypal_tx_values.update({
'cmd': '_xclick',
'business': self.paypal_email_account,
'item_name': '%s: %s' % (self.company_id.name, values['reference']),
'item_number': values['reference'],
'amount': values['amount'],
'currency_code': values['currency'] and values['currency'].name or '',
'address1': values.get('partner_address'),
'city': values.get('partner_city'),
'country': values.get('partner_country') and values.get('partner_country').code or '',
'state': values.get('partner_state') and (values.get('partner_state').code or values.get('partner_state').name) or '',
'email': values.get('partner_email'),
'zip_code': values.get('partner_zip'),
'first_name': values.get('partner_first_name'),
'last_name': values.get('partner_last_name'),
'paypal_return': urls.url_join(base_url, PaypalController._return_url),
'notify_url': urls.url_join(base_url, PaypalController._notify_url),
'cancel_return': urls.url_join(base_url, PaypalController._cancel_url),
'handling': '%.2f' % paypal_tx_values.pop('fees', 0.0) if self.fees_active else False,
'custom': json.dumps({'return_url': '%s' % paypal_tx_values.pop('return_url')}) if paypal_tx_values.get('return_url') else False,
})
return paypal_tx_values
@api.multi
def paypal_get_form_action_url(self):
return self._get_paypal_urls(self.environment)['paypal_form_url']
class TxPaypal(models.Model):
_inherit = 'payment.transaction'
paypal_txn_type = fields.Char('Transaction type')
# --------------------------------------------------
# FORM RELATED METHODS
# --------------------------------------------------
@api.model
def _paypal_form_get_tx_from_data(self, data):
reference, txn_id = data.get('item_number'), data.get('txn_id')
if not reference or not txn_id:
error_msg = _('Paypal: received data with missing reference (%s) or txn_id (%s)') % (reference, txn_id)
_logger.info(error_msg)
raise ValidationError(error_msg)
# find tx -> @TDENOTE use txn_id ?
txs = self.env['payment.transaction'].search([('reference', '=', reference)])
if not txs or len(txs) > 1:
error_msg = 'Paypal: received data for reference %s' % (reference)
if not txs:
error_msg += '; no order found'
else:
error_msg += '; multiple order found'
_logger.info(error_msg)
raise ValidationError(error_msg)
return txs[0]
@api.multi
def _paypal_form_get_invalid_parameters(self, data):
invalid_parameters = []
_logger.info('Received a notification from Paypal with IPN version %s', data.get('notify_version'))
if data.get('test_ipn'):
_logger.warning(
'Received a notification from Paypal using sandbox'
),
# TODO: txn_id: shoudl be false at draft, set afterwards, and verified with txn details
if self.acquirer_reference and data.get('txn_id') != self.acquirer_reference:
invalid_parameters.append(('txn_id', data.get('txn_id'), self.acquirer_reference))
# check what is buyed
if float_compare(float(data.get('mc_gross', '0.0')), (self.amount + self.fees), 2) != 0:
invalid_parameters.append(('mc_gross', data.get('mc_gross'), '%.2f' % self.amount)) # mc_gross is amount + fees
if data.get('mc_currency') != self.currency_id.name:
invalid_parameters.append(('mc_currency', data.get('mc_currency'), self.currency_id.name))
if 'handling_amount' in data and float_compare(float(data.get('handling_amount')), self.fees, 2) != 0:
invalid_parameters.append(('handling_amount', data.get('handling_amount'), self.fees))
# check buyer
if self.payment_token_id and data.get('payer_id') != self.payment_token_id.acquirer_ref:
invalid_parameters.append(('payer_id', data.get('payer_id'), self.payment_token_id.acquirer_ref))
# check seller
if data.get('receiver_id') and self.acquirer_id.paypal_seller_account and data['receiver_id'] != self.acquirer_id.paypal_seller_account:
invalid_parameters.append(('receiver_id', data.get('receiver_id'), self.acquirer_id.paypal_seller_account))
if not data.get('receiver_id') or not self.acquirer_id.paypal_seller_account:
# Check receiver_email only if receiver_id was not checked.
# In Paypal, this is possible to configure as receiver_email a different email than the business email (the login email)
# In Odoo, there is only one field for the Paypal email: the business email. This isn't possible to set a receiver_email
# different than the business email. Therefore, if you want such a configuration in your Paypal, you are then obliged to fill
# the Merchant ID in the Paypal payment acquirer in Odoo, so the check is performed on this variable instead of the receiver_email.
# At least one of the two checks must be done, to avoid fraudsters.
if data.get('receiver_email') != self.acquirer_id.paypal_email_account:
invalid_parameters.append(('receiver_email', data.get('receiver_email'), self.acquirer_id.paypal_email_account))
return invalid_parameters
@api.multi
def _paypal_form_validate(self, data):
status = data.get('payment_status')
res = {
'acquirer_reference': data.get('txn_id'),
'paypal_txn_type': data.get('payment_type'),
}
if status in ['Completed', 'Processed']:
_logger.info('Validated Paypal payment for tx %s: set as done' % (self.reference))
try:
# dateutil and pytz don't recognize abbreviations PDT/PST
tzinfos = {
'PST': -8 * 3600,
'PDT': -7 * 3600,
}
date = dateutil.parser.parse(data.get('payment_date'), tzinfos=tzinfos).astimezone(pytz.utc)
except:
date = fields.Datetime.now()
res.update(date=date)
self._set_transaction_done()
return self.write(res)
elif status in ['Pending', 'Expired']:
_logger.info('Received notification for Paypal payment %s: set as pending' % (self.reference))
res.update(state_message=data.get('pending_reason', ''))
self._set_transaction_pending()
return self.write(res)
else:
error = 'Received unrecognized status for Paypal payment %s: %s, set as error' % (self.reference, status)
_logger.info(error)
res.update(state_message=error)
self._set_transaction_cancel()
return self.write(res)
",1
"el for root logger so it will be possible for a client
# to subscribe and receive logs for any log level
logger.setLevel(0)
class QueueingLogHandler(logging.Handler):
"""""" A simple logging handler which puts all emitted logs into a
gevent queue.
""""""
def __init__(self, queue, level, formatter):
super(QueueingLogHandler, self).__init__()
self._queue = queue
self.setLevel(level)
self.setFormatter(formatter)
def emit(self, record):
msg = self.format(record)
self._queue.put_nowait(msg)
def close(self):
super(QueueingLogHandler, self).close()
self._queue.put_nowait(None)
@property
def emitted(self):
return self._queue
class TestService(object):
_HANDLER_CLASS = QueueingLogHandler
_DEFAULT_FORMAT = '%(name)s - %(levelname)s - %(asctime)s - %(message)s'
logger = logging.getLogger(""service"")
def __init__(self):
self._logging_handlers = set()
def test(self, logger_name, logger_level, message):
logger = logging.getLogger(logger_name)
getattr(logger, logger_level.lower())(message)
def available_loggers(self):
"""""" List of initalized loggers """"""
return logging.getLogger().manager.loggerDict.keys()
def close_log_streams(self):
"""""" Closes all log_stream streams. """"""
while self._logging_handlers:
self._logging_handlers.pop().close()
@zerorpc.stream
def log_stream(self, logger_name, level_name, format_str):
"""""" Attaches a log handler to the specified logger and sends emitted logs
back as stream.
""""""
if logger_name != """" and logger_name not in self.available_loggers():
raise ValueError(""logger {0} is not available"".format(logger_name))
level_name_upper = level_name.upper() if level_name else ""NOTSET""
try:
level = getattr(logging, level_name_upper)
except AttributeError, e:
raise AttributeError(""log level {0} is not available"".format(level_name_upper))
q = gevent.queue.Queue()
fmt = format_str if format_str.strip() else self._DEFAULT_FORMAT
logger = logging.getLogger(logger_name)
formatter = logging.Formatter(fmt)
handler = self._HANDLER_CLASS(q, level, formatter)
logger.addHandler(handler)
self._logging_handlers.add(handler)
self.logger.debug(""new subscriber for {0}/{1}"".format(logger_name or ""root"", level_name_upper))
try:
for msg in handler.emitted:
if msg is None:
return
yield msg
finally:
self._logging_handlers.discard(handler)
handler.close()
self.logger.debug(""subscription finished for {0}/{1}"".format(logger_name or ""root"", level_name_upper))
if __name__ == ""__main__"":
service = TestService()
server = zerorpc.Server(service)
server.bind(sys.argv[1])
logger.warning(""starting service"")
try:
server.run()
except BaseException, e:
logger.error(str(e))
finally:
logger.warning(""shutting down"")
",1
"gpl).
from openerp.addons.financial.tests.financial_test_classes import \
FinancialTestCase
class ManualFinancialProcess(FinancialTestCase):
def setUp(self):
self.financial_model = self.env['financial.move']
super(ManualFinancialProcess, self).setUp()
def test_01_check_return_views(self):
""""""Check if view is correctly called for python code""""""
# test for len(financial.move) == 1
financial_move_id = self.financial_model.search([], limit=1)
action = financial_move_id.action_view_financial('2receive')
self.assertEqual(
action.get('display_name'),
'financial.move.debt.2receive.form (in financial)')
self.assertEqual(
action.get('res_id'), financial_move_id.id)
action = financial_move_id.action_view_financial('2pay')
self.assertEqual(
action.get('display_name'),
'financial.move.debt.2pay.form (in financial)')
self.assertEqual(
action.get('res_id'), financial_move_id.id)
# test for len(financial.move) > 1
financial_move_id = self.financial_model.search([], limit=2)
action = financial_move_id.action_view_financial('2pay')
self.assertEqual(action.get('domain')[0][2], financial_move_id.ids)
# test for len(financial.move) < 1
action = self.financial_model.action_view_financial('2pay')
self.assertEqual(action.get('type'), 'ir.actions.act_window_close')
",1
"of the bot every day for some time
Simulates the user going to sleep every day for some time, the sleep time
and the duration is changed every day by a random offset defined in the
config file
Example Config:
""sleep_schedule"": [
{
""time"": ""12:00"",
""duration"": ""5:30"",
""time_random_offset"": ""00:30"",
""duration_random_offset"": ""00:30"",
""wake_up_at_location"": """"
},
{
""time"": ""17:45"",
""duration"": ""3:00"",
""time_random_offset"": ""01:00"",
""duration_random_offset"": ""00:30"",
""wake_up_at_location"": """"
}
]
time: (HH:MM) local time that the bot should sleep
duration: (HH:MM) the duration of sleep
time_random_offset: (HH:MM) random offset of time that the sleep will start
for this example the possible start time is 11:30-12:30
duration_random_offset: (HH:MM) random offset of duration of sleep
for this example the possible duration is 5:00-6:00
wake_up_at_location: (lat, long | lat, long, alt | """") the location at which the bot wake up
*Note that an empty string ("""") will not change the location*. """"""
LOG_INTERVAL_SECONDS = 600
SCHEDULING_MARGIN = timedelta(minutes=10) # Skip if next sleep is RESCHEDULING_MARGIN from now
def __init__(self, bot, config):
self.bot = bot
self._process_config(config)
self._schedule_next_sleep()
self._calculate_current_sleep()
def work(self):
if self._should_sleep_now():
self._sleep()
wake_up_at_location = self._wake_up_at_location
self._schedule_next_sleep()
if wake_up_at_location:
if hasattr(self.bot, 'api'): # Check if api is already initialized
self.bot.api.set_position(wake_up_at_location[0],wake_up_at_location[1],wake_up_at_location[2])
else:
self.bot.wake_location = wake_up_at_location
if hasattr(self.bot, 'api'): self.bot.login() # Same here
def _process_config(self, config):
self.entries = []
for entry in config:
prepared = {}
prepared['time'] = datetime.strptime(entry['time'] if 'time' in entry else '01:00', '%H:%M')
# Using datetime for easier stripping of timedeltas
raw_duration = datetime.strptime(entry['duration'] if 'duration' in entry else '07:00', '%H:%M')
duration = int(timedelta(hours=raw_duration.hour, minutes=raw_duration.minute).total_seconds())
raw_time_random_offset = datetime.strptime(entry['time_random_offset'] if 'time_random_offset' in entry else '01:00', '%H:%M')
time_random_offset = int(
timedelta(
hours=raw_time_random_offset.hour, minutes=raw_time_random_offset.minute).total_seconds())
raw_duration_random_offset = datetime.strptime(entry['duration_random_offset'] if 'duration_random_offset' in entry else '00:30', '%H:%M')
duration_random_offset = int(
timedelta(
hours=raw_duration_random_offset.hour, minutes=raw_duration_random_offset.minute).total_seconds())
raw_wake_up_at_location = entry['wake_up_at_location'] if 'wake_up_at_location' in entry else ''
if raw_wake_up_at_location:
try:
wake_up_at_location = raw_wake_up_at_location.split(',',2)
lat=float(wake_up_at_location[0])
lng=float(wake_up_at_location[1])
if len(wake_up_at_location) == 3:
alt=float(wake_up_at_location[2])
else:
alt = uniform(self.bot.config.alt_min, self.bot.config.alt_max)
except ValueError:
raise ValueError('SleepSchedule wake_up_at_location, parsing error in location') #TODO there must be a more elegant way to do it...
prepared['wake_up_at_location'] = [lat, lng, alt]
prepared['duration'] = duration
prepared['time_random_offset'] = time_random_offset
prepared['duration_random_offset'] = duration_random_offset
self.entries.append(prepared)
def _schedule_next_sleep(self):
self._next_sleep, self._next_duration, self._wake_up_at_location = self._get_next_sleep_schedule()
self.bot.event_manager.emit(
'next_sleep',
sender=self,
formatted=""Next sleep at {time}"",
data={
'time': str(self._next_sleep)
}
)
def _calculate_current_sleep(self):
self._current_sleep = self._next_sleep - timedelta(days=1)
current_duration = self._next_duration
self._current_end = self._current_sleep + timedelta(seconds = current_duration)
def _should_sleep_now(self):
if datetime.now() >= self._next_sleep:
return True
if datetime.now() >= self._current_sleep and datetime.now() < self._current_end:
self._next_duration = (self._current_end - datetime.now()).total_seconds()
return True
return False
def _get_next_sleep_schedule(self):
now = datetime.now() + self.SCHEDULING_MARGIN
times = []
for index in range(len(self.entries)):
next_time = now.replace(hour=self.entries[index]['time'].hour, minute=self.entries[index]['time'].minute)
next_time += timedelta(seconds=self._get_random_offset(self.entries[index]['time_random_offset']))
# If sleep time is passed add one day
if next_time <= now:
next_time += timedelta(days=1)
times.append(next_time)
diffs = {}
for index in range(len(self.entries)):
diff = (times[index]-now).total_seconds()
if diff >= 0: diffs[index] = diff
closest = min(diffs.iterkeys(), key=lambda x: diffs[x])
next_time = times[closest]
next_duration = self._get_next_duration(self.entries[closest])
location = self.entries[closest]['wake_up_at_location'] if 'wake_up_at_location' in self.entries[closest] else ''
return next_time, next_duration, location
def _get_next_duration(self, entry):
duration = entry['duration'] + self._get_random_offset(entry['duration_random_offset'])
return duration
def _get_random_offset(self, max_offset):
offset = uniform(-max_offset, max_offset)
return int(offset)
def _sleep(self):
sleep_to_go = self._next_duration
sleep_m, sleep_s = divmod(sleep_to_go, 60)
sleep_h, sleep_m = divmod(sleep_m, 60)
sleep_hms = '%02d:%02d:%02d' % (sleep_h, sleep_m, sleep_s)
now = datetime.now()
wake = str(now + timedelta(seconds=sleep_to_go))
self.bot.event_manager.emit(
'bot_sleep',
sender=self,
formatted=""Sleeping for {time_hms}, wake at {wake}"",
data={
'time_hms': sleep_hms,
'wake': wake
}
)
while sleep_to_go > 0:
if sleep_to_go < self.LOG_INTERVAL_SECONDS:
sleep(sleep_to_go)
sleep_to_go = 0
else:
sleep(self.LOG_INTERVAL_SECONDS)
sleep_to_go -= self.LOG_INTERVAL_SECONDS
",1
"
""""""
Scheduling utility methods and classes.
@author: Jp Calderone
""""""
__metaclass__ = type
import time
from zope.interface import implements
from twisted.python import reflect
from twisted.python.failure import Failure
from twisted.internet import base, defer
from twisted.internet.interfaces import IReactorTime
class LoopingCall:
""""""Call a function repeatedly.
If C{f} returns a deferred, rescheduling will not take place until the
deferred has fired. The result value is ignored.
@ivar f: The function to call.
@ivar a: A tuple of arguments to pass the function.
@ivar kw: A dictionary of keyword arguments to pass to the function.
@ivar clock: A provider of
L{twisted.internet.interfaces.IReactorTime}. The default is
L{twisted.internet.reactor}. Feel free to set this to
something else, but it probably ought to be set *before*
calling L{start}.
@type running: C{bool}
@ivar running: A flag which is C{True} while C{f} is scheduled to be called
(or is currently being called). It is set to C{True} when L{start} is
called and set to C{False} when L{stop} is called or if C{f} raises an
exception. In either case, it will be C{False} by the time the
C{Deferred} returned by L{start} fires its callback or errback.
@type _expectNextCallAt: C{float}
@ivar _expectNextCallAt: The time at which this instance most recently
scheduled itself to run.
@type _realLastTime: C{float}
@ivar _realLastTime: When counting skips, the time at which the skip
counter was last invoked.
@type _runAtStart: C{bool}
@ivar _runAtStart: A flag indicating whether the 'now' argument was passed
to L{LoopingCall.start}.
""""""
call = None
running = False
deferred = None
interval = None
_expectNextCallAt = 0.0
_runAtStart = False
starttime = None
def __init__(self, f, *a, **kw):
self.f = f
self.a = a
self.kw = kw
from twisted.internet import reactor
self.clock = reactor
def withCount(cls, countCallable):
""""""
An alternate constructor for L{LoopingCall} that makes available the
number of calls which should have occurred since it was last invoked.
Note that this number is an C{int} value; It represents the discrete
number of calls that should have been made. For example, if you are
using a looping call to display an animation with discrete frames, this
number would be the number of frames to advance.
The count is normally 1, but can be higher. For example, if the reactor
is blocked and takes too long to invoke the L{LoopingCall}, a Deferred
returned from a previous call is not fired before an interval has
elapsed, or if the callable itself blocks for longer than an interval,
preventing I{itself} from being called.
@param countCallable: A callable that will be invoked each time the
resulting LoopingCall is run, with an integer specifying the number
of calls that should have been invoked.
@type countCallable: 1-argument callable which takes an C{int}
@return: An instance of L{LoopingCall} with call counting enabled,
which provides the count as the first positional argument.
@rtype: L{LoopingCall}
@since: 9.0
""""""
def counter():
now = self.clock.seconds()
lastTime = self._realLastTime
if lastTime is None:
lastTime = self.starttime
if self._runAtStart:
lastTime -= self.interval
self._realLastTime = now
lastInterval = self._intervalOf(lastTime)
thisInterval = self._intervalOf(now)
count = thisInterval - lastInterval
return countCallable(count)
self = cls(counter)
self._realLastTime = None
return self
withCount = classmethod(withCount)
def _intervalOf(self, t):
""""""
Determine the number of intervals passed as of the given point in
time.
@param t: The specified time (from the start of the L{LoopingCall}) to
be measured in intervals
@return: The C{int} number of intervals which have passed as of the
given point in time.
""""""
elapsedTime = t - self.starttime
intervalNum = int(elapsedTime / self.interval)
return intervalNum
def start(self, interval, now=True):
""""""
Start running function every interval seconds.
@param interval: The number of seconds between calls. May be
less than one. Precision will depend on the underlying
platform, the available hardware, and the load on the system.
@param now: If True, run this call right now. Otherwise, wait
until the interval has elapsed before beginning.
@return: A Deferred whose callback will be invoked with
C{self} when C{self.stop} is called, or whose errback will be
invoked when the function raises an exception or returned a
deferred that has its errback invoked.
""""""
assert not self.running, (""Tried to start an already running ""
""LoopingCall."")
if interval < 0:
raise ValueError, ""interval must be >= 0""
self.running = True
d = self.deferred = defer.Deferred()
self.starttime = self.clock.seconds()
self._expectNextCallAt = self.starttime
self.interval = interval
self._runAtStart = now
if now:
self()
else:
self._reschedule()
return d
def stop(self):
""""""Stop running function.
""""""
assert self.running, (""Tried to stop a LoopingCall that was ""
""not running."")
self.running = False
if self.call is not None:
self.call.cancel()
self.call = None
d, self.deferred = self.deferred, None
d.callback(self)
def reset(self):
""""""
Skip the next iteration and reset the timer.
@since: 11.1
""""""
assert self.running, (""Tried to reset a LoopingCall that was ""
""not running."")
if self.call is not None:
self.call.cancel()
self.call = None
self._expectNextCallAt = self.clock.seconds()
self._reschedule()
def __call__(self):
def cb(result):
if self.running:
self._reschedule()
else:
d, self.deferred = self.deferred, None
d.callback(self)
def eb(failure):
self.running = False
d, self.deferred = self.deferred, None
d.errback(failure)
self.call = None
d = defer.maybeDeferred(self.f, *self.a, **self.kw)
d.addCallback(cb)
d.addErrback(eb)
def _reschedule(self):
""""""
Schedule the next iteration of this looping call.
""""""
if self.interval == 0:
self.call = self.clock.callLater(0, self)
return
currentTime = self.clock.seconds()
# Find how long is left until the interval comes around again.
untilNextTime = (self._expectNextCallAt - currentTime) % self.interval
# Make sure it is in the future, in case more than one interval worth
# of time passed since the previous call was made.
nextTime = max(
self._expectNextCallAt + self.interval, currentTime + untilNextTime)
# If the interval falls on the current time exactly, skip it and
# schedule the call for the next interval.
if nextTime == currentTime:
nextTime += self.interval
self._expectNextCallAt = nextTime
self.call = self.clock.callLater(nextTime - currentTime, self)
def __repr__(self):
if hasattr(self.f, 'func_name'):
func = self.f.func_name
if hasattr(self.f, 'im_class'):
func = self.f.im_class.__name__ + '.' + func
else:
func = reflect.safe_repr(self.f)
return 'LoopingCall<%r>(%s, *%s, **%s)' % (
self.interval, func, reflect.safe_repr(self.a),
reflect.safe_repr(self.kw))
class SchedulerError(Exception):
""""""
The operation could not be completed because the scheduler or one of its
tasks was in an invalid state. This exception should not be raised
directly, but is a superclass of various scheduler-state-related
exceptions.
""""""
class SchedulerStopped(SchedulerError):
""""""
The operation could not complete because the scheduler was stopped in
progress or was already stopped.
""""""
class TaskFinished(SchedulerError):
""""""
The operation could not complete because the task was already completed,
stopped, encountered an error or otherwise permanently stopped running.
""""""
class TaskDone(TaskFinished):
""""""
The operation could not complete because the task was already completed.
""""""
class TaskStopped(TaskFinished):
""""""
The operation could not complete because the task was stopped.
""""""
class TaskFailed(TaskFinished):
""""""
The operation could not complete because the task died with an unhandled
error.
""""""
class NotPaused(SchedulerError):
""""""
This exception is raised when a task is resumed which was not previously
paused.
""""""
class _Timer(object):
MAX_SLICE = 0.01
def __init__(self):
self.end = time.time() + self.MAX_SLICE
def __call__(self):
return time.time() >= self.end
_EPSILON = 0.00000001
def _defaultScheduler(x):
from twisted.internet import reactor
return reactor.callLater(_EPSILON, x)
class CooperativeTask(object):
""""""
A L{CooperativeTask} is a task object inside a L{Cooperator}, which can be
paused, resumed, and stopped. It can also have its completion (or
termination) monitored.
@see: L{CooperativeTask.cooperate}
@ivar _iterator: the iterator to iterate when this L{CooperativeTask} is
asked to do work.
@ivar _cooperator: the L{Cooperator} that this L{CooperativeTask}
participates in, which is used to re-insert it upon resume.
@ivar _deferreds: the list of L{defer.Deferred}s to fire when this task
completes, fails, or finishes.
@type _deferreds: L{list}
@type _cooperator: L{Cooperator}
@ivar _pauseCount: the number of times that this L{CooperativeTask} has
been paused; if 0, it is running.
@type _pauseCount: L{int}
@ivar _completionState: The completion-state of this L{CooperativeTask}.
C{None} if the task is not yet completed, an instance of L{TaskStopped}
if C{stop} was called to stop this task early, of L{TaskFailed} if the
application code in the iterator raised an exception which caused it to
terminate, and of L{TaskDone} if it terminated normally via raising
L{StopIteration}.
@type _completionState: L{TaskFinished}
""""""
def __init__(self, iterator, cooperator):
""""""
A private constructor: to create a new L{CooperativeTask}, see
L{Cooperator.cooperate}.
""""""
self._iterator = iterator
self._cooperator = cooperator
self._deferreds = []
self._pauseCount = 0
self._completionState = None
self._completionResult = None
cooperator._addTask(self)
def whenDone(self):
""""""
Get a L{defer.Deferred} notification of when this task is complete.
@return: a L{defer.Deferred} that fires with the C{iterator} that this
L{CooperativeTask} was created with when the iterator has been
exhausted (i.e. its C{next} method has raised L{StopIteration}), or
fails with the exception raised by C{next} if it raises some other
exception.
@rtype: L{defer.Deferred}
""""""
d = defer.Deferred()
if self._completionState is None:
self._deferreds.append(d)
else:
d.callback(self._completionResult)
return d
def pause(self):
""""""
Pause this L{CooperativeTask}. Stop doing work until
L{CooperativeTask.resume} is called. If C{pause} is called more than
once, C{resume} must be called an equal number of times to resume this
task.
@raise TaskFinished: if this task has already finished or completed.
""""""
self._checkFinish()
self._pauseCount += 1
if self._pauseCount == 1:
self._cooperator._removeTask(self)
def resume(self):
""""""
Resume processing of a paused L{CooperativeTask}.
@raise NotPaused: if this L{CooperativeTask} is not paused.
""""""
if self._pauseCount == 0:
raise NotPaused()
self._pauseCount -= 1
if self._pauseCount == 0 and self._completionState is None:
self._cooperator._addTask(self)
def _completeWith(self, completionState, deferredResult):
""""""
@param completionState: a L{TaskFinished} exception or a subclass
thereof, indicating what exception should be raised when subsequent
operations are performed.
@param deferredResult: the result to fire all the deferreds with.
""""""
self._completionState = completionState
self._completionResult = deferredResult
if not self._pauseCount:
self._cooperator._removeTask(self)
# The Deferreds need to be invoked after all this is completed, because
# a Deferred may want to manipulate other tasks in a Cooperator. For
# example, if you call ""stop()"" on a cooperator in a callback on a
# Deferred returned from whenDone(), this CooperativeTask must be gone
# from the Cooperator by that point so that _completeWith is not
# invoked reentrantly; that would cause these Deferreds to blow up with
# an AlreadyCalledError, or the _removeTask to fail with a ValueError.
for d in self._deferreds:
d.callback(deferredResult)
def stop(self):
""""""
Stop further processing of this task.
@raise TaskFinished: if this L{CooperativeTask} has previously
completed, via C{stop}, completion, or failure.
""""""
self._checkFinish()
self._completeWith(TaskStopped(), Failure(TaskStopped()))
def _checkFinish(self):
""""""
If this task has been stopped, raise the appropriate subclass of
L{TaskFinished}.
""""""
if self._completionState is not None:
raise self._completionState
def _oneWorkUnit(self):
""""""
Perform one unit of work for this task, retrieving one item from its
iterator, stopping if there are no further items in the iterator, and
pausing if the result was a L{defer.Deferred}.
""""""
try:
result = self._iterator.next()
except StopIteration:
self._completeWith(TaskDone(), self._iterator)
except:
self._completeWith(TaskFailed(), Failure())
else:
if isinstance(result, defer.Deferred):
self.pause()
def failLater(f):
self._completeWith(TaskFailed(), f)
result.addCallbacks(lambda result: self.resume(),
failLater)
class Cooperator(object):
""""""
Cooperative task scheduler.
""""""
def __init__(self,
terminationPredicateFactory=_Timer,
scheduler=_defaultScheduler,
started=True):
""""""
Create a scheduler-like object to which iterators may be added.
@param terminationPredicateFactory: A no-argument callable which will
be invoked at the beginning of each step and should return a
no-argument callable which will return True when the step should be
terminated. The default factory is time-based and allows iterators to
run for 1/100th of a second at a time.
@param scheduler: A one-argument callable which takes a no-argument
callable and should invoke it at some future point. This will be used
to schedule each step of this Cooperator.
@param started: A boolean which indicates whether iterators should be
stepped as soon as they are added, or if they will be queued up until
L{Cooperator.start} is called.
""""""
self._tasks = []
self._metarator = iter(())
self._terminationPredicateFactory = terminationPredicateFactory
self._scheduler = scheduler
self._delayedCall = None
self._stopped = False
self._started = started
def coiterate(self, iterator, doneDeferred=None):
""""""
Add an iterator to the list of iterators this L{Cooperator} is
currently running.
@param doneDeferred: If specified, this will be the Deferred used as
the completion deferred. It is suggested that you use the default,
which creates a new Deferred for you.
@return: a Deferred that will fire when the iterator finishes.
""""""
if doneDeferred is None:
doneDeferred = defer.Deferred()
CooperativeTask(iterator, self).whenDone().chainDeferred(doneDeferred)
return doneDeferred
def cooperate(self, iterator):
""""""
Start running the given iterator as a long-running cooperative task, by
calling next() on it as a periodic timed event.
@param iterator: the iterator to invoke.
@return: a L{CooperativeTask} object representing this task.
""""""
return CooperativeTask(iterator, self)
def _addTask(self, task):
""""""
Add a L{CooperativeTask} object to this L{Cooperator}.
""""""
if self._stopped:
self._tasks.append(task) # XXX silly, I know, but _completeWith
# does the inverse
task._completeWith(SchedulerStopped(), Failure(SchedulerStopped()))
else:
self._tasks.append(task)
self._reschedule()
def _removeTask(self, task):
""""""
Remove a L{CooperativeTask} from this L{Cooperator}.
""""""
self._tasks.remove(task)
# If no work left to do, cancel the delayed call:
if not self._tasks and self._delayedCall:
self._delayedCall.cancel()
self._delayedCall = None
def _tasksWhileNotStopped(self):
""""""
Yield all L{CooperativeTask} objects in a loop as long as this
L{Cooperator}'s termination condition has not been met.
""""""
terminator = self._terminationPredicateFactory()
while self._tasks:
for t in self._metarator:
yield t
if terminator():
return
self._metarator = iter(self._tasks)
def _tick(self):
""""""
Run one scheduler tick.
""""""
self._delayedCall = None
for taskObj in self._tasksWhileNotStopped():
taskObj._oneWorkUnit()
self._reschedule()
_mustScheduleOnStart = False
def _reschedule(self):
if not self._started:
self._mustScheduleOnStart = True
return
if self._delayedCall is None and self._tasks:
self._delayedCall = self._scheduler(self._tick)
def start(self):
""""""
Begin scheduling steps.
""""""
self._stopped = False
self._started = True
if self._mustScheduleOnStart:
del self._mustScheduleOnStart
self._reschedule()
def stop(self):
""""""
Stop scheduling steps. Errback the completion Deferreds of all
iterators which have been added and forget about them.
""""""
self._stopped = True
for taskObj in self._tasks:
taskObj._completeWith(SchedulerStopped(),
Failure(SchedulerStopped()))
self._tasks = []
if self._delayedCall is not None:
self._delayedCall.cancel()
self._delayedCall = None
_theCooperator = Cooperator()
def coiterate(iterator):
""""""
Cooperatively iterate over the given iterator, dividing runtime between it
and all other iterators which have been passed to this function and not yet
exhausted.
""""""
return _theCooperator.coiterate(iterator)
def cooperate(iterator):
""""""
Start running the given iterator as a long-running cooperative task, by
calling next() on it as a periodic timed event.
@param iterator: the iterator to invoke.
@return: a L{CooperativeTask} object representing this task.
""""""
return _theCooperator.cooperate(iterator)
class Clock:
""""""
Provide a deterministic, easily-controlled implementation of
L{IReactorTime.callLater}. This is commonly useful for writing
deterministic unit tests for code which schedules events using this API.
""""""
implements(IReactorTime)
rightNow = 0.0
def __init__(self):
self.calls = []
def seconds(self):
""""""
Pretend to be time.time(). This is used internally when an operation
such as L{IDelayedCall.reset} needs to determine a a time value
relative to the current time.
@rtype: C{float}
@return: The time which should be considered the current time.
""""""
return self.rightNow
def _sortCalls(self):
""""""
Sort the pending calls according to the time they are scheduled.
""""""
self.calls.sort(lambda a, b: cmp(a.getTime(), b.getTime()))
def callLater(self, when, what, *a, **kw):
""""""
See L{twisted.internet.interfaces.IReactorTime.callLater}.
""""""
dc = base.DelayedCall(self.seconds() + when,
what, a, kw,
self.calls.remove,
lambda c: None,
self.seconds)
self.calls.append(dc)
self._sortCalls()
return dc
def getDelayedCalls(self):
""""""
See L{twisted.internet.interfaces.IReactorTime.getDelayedCalls}
""""""
return self.calls
def advance(self, amount):
""""""
Move time on this clock forward by the given amount and run whatever
pending calls should be run.
@type amount: C{float}
@param amount: The number of seconds which to advance this clock's
time.
""""""
self.rightNow += amount
self._sortCalls()
while self.calls and self.calls[0].getTime() <= self.seconds():
call = self.calls.pop(0)
call.called = 1
call.func(*call.args, **call.kw)
self._sortCalls()
def pump(self, timings):
""""""
Advance incrementally by the given set of times.
@type timings: iterable of C{float}
""""""
for amount in timings:
self.advance(amount)
def deferLater(clock, delay, callable, *args, **kw):
""""""
Call the given function after a certain period of time has passed.
@type clock: L{IReactorTime} provider
@param clock: The object which will be used to schedule the delayed
call.
@type delay: C{float} or C{int}
@param delay: The number of seconds to wait before calling the function.
@param callable: The object to call after the delay.
@param *args: The positional arguments to pass to C{callable}.
@param **kw: The keyword arguments to pass to C{callable}.
@rtype: L{defer.Deferred}
@return: A deferred that fires with the result of the callable when the
specified time has elapsed.
""""""
def deferLaterCancel(deferred):
delayedCall.cancel()
d = defer.Deferred(deferLaterCancel)
d.addCallback(lambda ignored: callable(*args, **kw))
delayedCall = clock.callLater(delay, d.callback, None)
return d
__all__ = [
'LoopingCall',
'Clock',
'SchedulerStopped', 'Cooperator', 'coiterate',
'deferLater',
]
",1
"mplate_values(url_root):
""""""
Show documentation about voterStarOnSave
""""""
required_query_parameter_list = [
{
'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',
},
{
'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': 'kind_of_ballot_item',
'value': 'string', # boolean, integer, long, string
'description': 'What is the type of ballot item for which we are saving the \'on\' status? '
'(kind_of_ballot_item is either ""OFFICE"", ""CANDIDATE"", ""POLITICIAN"" or ""MEASURE"")',
},
{
'name': 'ballot_item_id',
'value': 'integer', # boolean, integer, long, string
'description': 'The unique internal identifier for this ballot_item '
'(either ballot_item_id OR ballot_item_we_vote_id required -- not both. '
'If it exists, ballot_item_id is used instead of ballot_item_we_vote_id)',
},
{
'name': 'ballot_item_we_vote_id',
'value': 'string', # boolean, integer, long, string
'description': 'The unique identifier for this ballot_item across all networks '
'(either ballot_item_id OR ballot_item_we_vote_id required -- not both. '
'NOTE: In the future we might support other identifiers used in the industry.',
},
]
optional_query_parameter_list = [
]
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. Missing voter_id while trying to save.',
},
{
'code': 'STAR_ON_OFFICE CREATE/UPDATE ITEM_STARRED',
'description': '',
},
{
'code': 'STAR_ON_CANDIDATE CREATE/UPDATE ITEM_STARRED',
'description': '',
},
{
'code': 'STAR_ON_MEASURE CREATE/UPDATE ITEM_STARRED',
'description': '',
},
]
try_now_link_variables_dict = {
'kind_of_ballot_item': 'CANDIDATE',
'ballot_item_id': '5655',
}
api_response = '{\n' \
' ""status"": string (description of what happened),\n' \
' ""success"": boolean (did the save happen?),\n' \
' ""ballot_item_id"": integer,\n' \
' ""ballot_item_we_vote_id"": string,\n' \
' ""kind_of_ballot_item"": string (CANDIDATE, MEASURE),\n' \
'}'
template_values = {
'api_name': 'voterStarOnSave',
'api_slug': 'voterStarOnSave',
'api_introduction':
""Save or create private 'star on' state for the current voter for a measure, an office or candidate."",
'try_now_link': 'apis_v1:voterStarOnSaveView',
'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
",1
"go_pgjson.fields
import django.utils.timezone
import django.db.models.deletion
import djorm_pgarray.fields
import taiga.projects.history.models
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
('users', '0002_auto_20140903_0916'),
]
operations = [
migrations.CreateModel(
name='Membership',
fields=[
('id', models.AutoField(serialize=False, primary_key=True, auto_created=True, verbose_name='ID')),
('is_owner', models.BooleanField(default=False)),
('email', models.EmailField(max_length=255, null=True, default=None, verbose_name='email', blank=True)),
('created_at', models.DateTimeField(default=django.utils.timezone.now, verbose_name='creado el')),
('token', models.CharField(max_length=60, null=True, default=None, verbose_name='token', blank=True)),
('invited_by_id', models.IntegerField(null=True, blank=True)),
],
options={
'ordering': ['project', 'user__full_name', 'user__username', 'user__email', 'email'],
'verbose_name_plural': 'membershipss',
'permissions': (('view_membership', 'Can view membership'),),
'verbose_name': 'membership',
},
bases=(models.Model,),
),
migrations.CreateModel(
name='Project',
fields=[
('id', models.AutoField(serialize=False, primary_key=True, auto_created=True, verbose_name='ID')),
('tags', djorm_pgarray.fields.TextArrayField(dbtype='text', verbose_name='tags')),
('name', models.CharField(max_length=250, unique=True, verbose_name='name')),
('slug', models.SlugField(max_length=250, unique=True, verbose_name='slug', blank=True)),
('description', models.TextField(verbose_name='description')),
('created_date', models.DateTimeField(default=django.utils.timezone.now, verbose_name='created date')),
('modified_date', models.DateTimeField(verbose_name='modified date')),
('total_milestones', models.IntegerField(null=True, default=0, verbose_name='total of milestones', blank=True)),
('total_story_points', models.FloatField(default=0, verbose_name='total story points')),
('is_backlog_activated', models.BooleanField(default=True, verbose_name='active backlog panel')),
('is_kanban_activated', models.BooleanField(default=False, verbose_name='active kanban panel')),
('is_wiki_activated', models.BooleanField(default=True, verbose_name='active wiki panel')),
('is_issues_activated', models.BooleanField(default=True, verbose_name='active issues panel')),
('videoconferences', models.CharField(max_length=250, null=True, choices=[('appear-in', 'AppearIn'), ('talky', 'Talky'), ('jitsi', 'Jitsi')], verbose_name='videoconference system', blank=True)),
('videoconferences_salt', models.CharField(max_length=250, null=True, verbose_name='videoconference room salt', blank=True)),
('anon_permissions', djorm_pgarray.fields.TextArrayField(choices=[('view_project', 'View project'), ('view_milestones', 'View milestones'), ('view_us', 'View user stories'), ('view_tasks', 'View tasks'), ('view_issues', 'View issues'), ('view_wiki_pages', 'View wiki pages'), ('view_wiki_links', 'View wiki links')], dbtype='text', default=[], verbose_name='anonymous permissions')),
('public_permissions', djorm_pgarray.fields.TextArrayField(choices=[('view_project', 'View project'), ('view_milestones', 'View milestones'), ('view_us', 'View user stories'), ('view_issues', 'View issues'), ('vote_issues', 'Vote issues'), ('view_tasks', 'View tasks'), ('view_wiki_pages', 'View wiki pages'), ('view_wiki_links', 'View wiki links'), ('request_membership', 'Request membership'), ('add_us_to_project', 'Add user story to project'), ('add_comments_to_us', 'Add comments to user stories'), ('add_comments_to_task', 'Add comments to tasks'), ('add_issue', 'Add issues'), ('add_comments_issue', 'Add comments to issues'), ('add_wiki_page', 'Add wiki page'), ('modify_wiki_page', 'Modify wiki page'), ('add_wiki_link', 'Add wiki link'), ('modify_wiki_link', 'Modify wiki link')], dbtype='text', default=[], verbose_name='user permissions')),
('is_private', models.BooleanField(default=False, verbose_name='is private')),
('tags_colors', djorm_pgarray.fields.TextArrayField(dbtype='text', dimension=2, default=[], null=False, verbose_name='tags colors')),
],
options={
'ordering': ['name'],
'verbose_name_plural': 'projects',
'permissions': (('view_project', 'Can view project'),),
'verbose_name': 'project',
},
bases=(models.Model,),
),
migrations.AddField(
model_name='project',
name='members',
field=models.ManyToManyField(to=settings.AUTH_USER_MODEL, related_name='projects', verbose_name='members', through='projects.Membership'),
preserve_default=True,
),
migrations.AddField(
model_name='project',
name='owner',
field=models.ForeignKey(to=settings.AUTH_USER_MODEL, related_name='owned_projects', verbose_name='owner'),
preserve_default=True,
),
migrations.AddField(
model_name='membership',
name='user',
field=models.ForeignKey(blank=True, default=None, to=settings.AUTH_USER_MODEL, null=True, related_name='memberships'),
preserve_default=True,
),
migrations.AddField(
model_name='membership',
name='project',
field=models.ForeignKey(default=1, to='projects.Project', related_name='memberships'),
preserve_default=False,
),
migrations.AlterUniqueTogether(
name='membership',
unique_together=set([('user', 'project')]),
),
migrations.AddField(
model_name='membership',
name='role',
field=models.ForeignKey(related_name='memberships', to='users.Role', default=1),
preserve_default=False,
),
]
",1
"erdev.org>
# date: 2012/04/20
# copy: (C) Copyright 2012-EOT metagriffin -- see LICENSE.txt
#------------------------------------------------------------------------------
# This software 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 software 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 http://www.gnu.org/licenses/.
#------------------------------------------------------------------------------
from .tracker import *
from .merger import *
#------------------------------------------------------------------------------
# end of $Id$
#------------------------------------------------------------------------------
",1
"jaca z Google Scholar
## Copyright (C) 2013 Damian Baran
##
## 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
""""""
""*** YOUR CODE HERE ***""
util.raiseNotDefined()
# Abbreviation
better = betterEvaluationFunction
class ContestAgent(MultiAgentSearchAgent):
""""""
Your agent for the mini-contest
""""""
def getAction(self, gameState):
""""""
Returns an action. You can use any method you want and search to any depth you want.
Just remember that the mini-contest is timed, so you have to trade off speed and computation.
Ghosts don't behave randomly anymore, but they aren't perfect either -- they'll usually
just make a beeline straight towards Pacman (or away from him if they're scared!)
""""""
""*** YOUR CODE HERE ***""
util.raiseNotDefined()
",1
" cv2.imread(""img/Slide2.jpg"", 0)
img = cv2.imread(""unsorted/Unit Tests/lambda.png"", 0)
im_size = img.shape
returnedCanny = cv2.Canny(img, 50, 150, apertureSize = 3)
cv2.imshow(""newcanny"", returnedCanny)
skel_dst = util.morpho(returnedCanny)
out = edge_detect.mask_contours(edge_detect.create_img(skel_dst))
res = []
# print(np.squeeze(out[0]))
# print(out[0][0])
for i in range(len(out)):
# Add the first point to the end so the shape closes
current = np.squeeze(out[i])
# print('current', current)
# print('first', out[i][0])
if current.shape[0] > 2:
# res.append(np.concatenate((current, out[i][0])))
# print(res[-1])
res.append(current)
# print(np.concatenate((np.squeeze(out[i]), out[i][0])))
res = np.array(res)
util.sqz_contours(res)
res = lineseg.lineseg(np.array([res[1]]), tol=5)
print(res, ""res"")
""""""
for x in range(len(res)):
for y in range(lan ):
""""""
drawedgelist.drawedgelist(res, img)
""""""
seglist = []
for i in range(res.shape[0]):
# print('shape', res[i].shape)
if res[i].shape[0] > 2:
# print(res[i])
# print(res[i][0])
seglist.append(np.concatenate((res[i], [res[i][0]])))
else:
seglist.append(res[i])
seglist = np.array(seglist)
""""""
#print(seglist, ""seglist"")
#print(len(seglist), ""seglist len"")
#print(seglist.shape, ""seglistshape"")
#drawedgelist.drawedgelist(seglist)
""""""
# ******* SECTION 2 *******
# SEGMENT AND LABEL THE CURVATURE LINES (CONVEX/CONCAVE).
LineFeature, ListPoint = Lseg_to_Lfeat_v4.create_linefeatures(seglist, res, im_size)
Line_new, ListPoint_new, line_merged = merge_lines_v4.merge_lines(LineFeature, ListPoint, 10, im_size)
#print(Line_new, ""line new"")
print(len(Line_new), ""len line new"")
util.draw_lf(Line_new, blank_image)
line_newC = LabelLineCurveFeature_v4.classify_curves(img, Line_new, ListPoint_new, 11)""""""",1
"cept 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 warnings
from typing import Awaitable, Callable, Dict, Optional, Sequence, Tuple, Union
from google.api_core import gapic_v1 # type: ignore
from google.api_core import grpc_helpers_async # type: ignore
from google.auth import credentials as ga_credentials # type: ignore
from google.auth.transport.grpc import SslCredentials # type: ignore
import packaging.version
import grpc # type: ignore
from grpc.experimental import aio # type: ignore
from google.analytics.data_v1alpha.types import analytics_data_api
from .base import AlphaAnalyticsDataTransport, DEFAULT_CLIENT_INFO
from .grpc import AlphaAnalyticsDataGrpcTransport
class AlphaAnalyticsDataGrpcAsyncIOTransport(AlphaAnalyticsDataTransport):
""""""gRPC AsyncIO backend transport for AlphaAnalyticsData.
Google Analytics reporting data service.
This class defines the same methods as the primary client, so the
primary client can load the underlying transport implementation
and call it.
It sends protocol buffers over the wire using gRPC (which is built on
top of HTTP/2); the ``grpcio`` package must be installed.
""""""
_grpc_channel: aio.Channel
_stubs: Dict[str, Callable] = {}
@classmethod
def create_channel(
cls,
host: str = ""analyticsdata.googleapis.com"",
credentials: ga_credentials.Credentials = None,
credentials_file: Optional[str] = None,
scopes: Optional[Sequence[str]] = None,
quota_project_id: Optional[str] = None,
**kwargs,
) -> aio.Channel:
""""""Create and return a gRPC AsyncIO channel object.
Args:
host (Optional[str]): The host for the channel to use.
credentials (Optional[~.Credentials]): The
authorization credentials to attach to requests. These
credentials identify this application to the service. If
none are specified, the client will attempt to ascertain
the credentials from the environment.
credentials_file (Optional[str]): A file with credentials that can
be loaded with :func:`google.auth.load_credentials_from_file`.
This argument is ignored if ``channel`` is provided.
scopes (Optional[Sequence[str]]): A optional list of scopes needed for this
service. These are only used when credentials are not specified and
are passed to :func:`google.auth.default`.
quota_project_id (Optional[str]): An optional project to use for billing
and quota.
kwargs (Optional[dict]): Keyword arguments, which are passed to the
channel creation.
Returns:
aio.Channel: A gRPC AsyncIO channel object.
""""""
return grpc_helpers_async.create_channel(
host,
credentials=credentials,
credentials_file=credentials_file,
quota_project_id=quota_project_id,
default_scopes=cls.AUTH_SCOPES,
scopes=scopes,
default_host=cls.DEFAULT_HOST,
**kwargs,
)
def __init__(
self,
*,
host: str = ""analyticsdata.googleapis.com"",
credentials: ga_credentials.Credentials = None,
credentials_file: Optional[str] = None,
scopes: Optional[Sequence[str]] = None,
channel: aio.Channel = None,
api_mtls_endpoint: str = None,
client_cert_source: Callable[[], Tuple[bytes, bytes]] = None,
ssl_channel_credentials: grpc.ChannelCredentials = None,
client_cert_source_for_mtls: Callable[[], Tuple[bytes, bytes]] = None,
quota_project_id=None,
client_info: gapic_v1.client_info.ClientInfo = DEFAULT_CLIENT_INFO,
always_use_jwt_access: Optional[bool] = False,
) -> None:
""""""Instantiate the transport.
Args:
host (Optional[str]):
The hostname to connect to.
credentials (Optional[google.auth.credentials.Credentials]): The
authorization credentials to attach to requests. These
credentials identify the application to the service; if none
are specified, the client will attempt to ascertain the
credentials from the environment.
This argument is ignored if ``channel`` is provided.
credentials_file (Optional[str]): A file with credentials that can
be loaded with :func:`google.auth.load_credentials_from_file`.
This argument is ignored if ``channel`` is provided.
scopes (Optional[Sequence[str]]): A optional list of scopes needed for this
service. These are only used when credentials are not specified and
are passed to :func:`google.auth.default`.
channel (Optional[aio.Channel]): A ``Channel`` instance through
which to make calls.
api_mtls_endpoint (Optional[str]): Deprecated. The mutual TLS endpoint.
If provided, it overrides the ``host`` argument and tries to create
a mutual TLS channel with client SSL credentials from
``client_cert_source`` or application default SSL credentials.
client_cert_source (Optional[Callable[[], Tuple[bytes, bytes]]]):
Deprecated. A callback to provide client SSL certificate bytes and
private key bytes, both in PEM format. It is ignored if
``api_mtls_endpoint`` is None.
ssl_channel_credentials (grpc.ChannelCredentials): SSL credentials
for the grpc channel. It is ignored if ``channel`` is provided.
client_cert_source_for_mtls (Optional[Callable[[], Tuple[bytes, bytes]]]):
A callback to provide client certificate bytes and private key bytes,
both in PEM format. It is used to configure a mutual TLS channel. It is
ignored if ``channel`` or ``ssl_channel_credentials`` is provided.
quota_project_id (Optional[str]): An optional project to use for billing
and quota.
client_info (google.api_core.gapic_v1.client_info.ClientInfo):
The client info used to send a user-agent string along with
API requests. If ``None``, then default info will be used.
Generally, you only need to set this if you're developing
your own client library.
always_use_jwt_access (Optional[bool]): Whether self signed JWT should
be used for service account credentials.
Raises:
google.auth.exceptions.MutualTlsChannelError: If mutual TLS transport
creation failed for any reason.
google.api_core.exceptions.DuplicateCredentialArgs: If both ``credentials``
and ``credentials_file`` are passed.
""""""
self._grpc_channel = None
self._ssl_channel_credentials = ssl_channel_credentials
self._stubs: Dict[str, Callable] = {}
if api_mtls_endpoint:
warnings.warn(""api_mtls_endpoint is deprecated"", DeprecationWarning)
if client_cert_source:
warnings.warn(""client_cert_source is deprecated"", DeprecationWarning)
if channel:
# Ignore credentials if a channel was passed.
credentials = False
# If a channel was explicitly provided, set it.
self._grpc_channel = channel
self._ssl_channel_credentials = None
else:
if api_mtls_endpoint:
host = api_mtls_endpoint
# Create SSL credentials with client_cert_source or application
# default SSL credentials.
if client_cert_source:
cert, key = client_cert_source()
self._ssl_channel_credentials = grpc.ssl_channel_credentials(
certificate_chain=cert, private_key=key
)
else:
self._ssl_channel_credentials = SslCredentials().ssl_credentials
else:
if client_cert_source_for_mtls and not ssl_channel_credentials:
cert, key = client_cert_source_for_mtls()
self._ssl_channel_credentials = grpc.ssl_channel_credentials(
certificate_chain=cert, private_key=key
)
# The base transport sets the host, credentials and scopes
super().__init__(
host=host,
credentials=credentials,
credentials_file=credentials_file,
scopes=scopes,
quota_project_id=quota_project_id,
client_info=client_info,
always_use_jwt_access=always_use_jwt_access,
)
if not self._grpc_channel:
self._grpc_channel = type(self).create_channel(
self._host,
credentials=self._credentials,
credentials_file=credentials_file,
scopes=self._scopes,
ssl_credentials=self._ssl_channel_credentials,
quota_project_id=quota_project_id,
options=[
(""grpc.max_send_message_length"", -1),
(""grpc.max_receive_message_length"", -1),
],
)
# Wrap messages. This must be done after self._grpc_channel exists
self._prep_wrapped_messages(client_info)
@property
def grpc_channel(self) -> aio.Channel:
""""""Create the channel designed to connect to this service.
This property caches on the instance; repeated calls return
the same channel.
""""""
# Return the channel from cache.
return self._grpc_channel
@property
def run_report(
self,
) -> Callable[
[analytics_data_api.RunReportRequest],
Awaitable[analytics_data_api.RunReportResponse],
]:
r""""""Return a callable for the run report method over gRPC.
Returns a customized report of your Google Analytics
event data. Reports contain statistics derived from data
collected by the Google Analytics tracking code. The
data returned from the API is as a table with columns
for the requested dimensions and metrics. Metrics are
individual measurements of user activity on your
property, such as active users or event count.
Dimensions break down metrics across some common
criteria, such as country or event name.
Returns:
Callable[[~.RunReportRequest],
Awaitable[~.RunReportResponse]]:
A function that, when called, will call the underlying RPC
on the server.
""""""
# Generate a ""stub function"" on-the-fly which will actually make
# the request.
# gRPC handles serialization and deserialization, so we just need
# to pass in the functions for each.
if ""run_report"" not in self._stubs:
self._stubs[""run_report""] = self.grpc_channel.unary_unary(
""/google.analytics.data.v1alpha.AlphaAnalyticsData/RunReport"",
request_serializer=analytics_data_api.RunReportRequest.serialize,
response_deserializer=analytics_data_api.RunReportResponse.deserialize,
)
return self._stubs[""run_report""]
@property
def run_pivot_report(
self,
) -> Callable[
[analytics_data_api.RunPivotReportRequest],
Awaitable[analytics_data_api.RunPivotReportResponse],
]:
r""""""Return a callable for the run pivot report method over gRPC.
Returns a customized pivot report of your Google
Analytics event data. Pivot reports are more advanced
and expressive formats than regular reports. In a pivot
report, dimensions are only visible if they are included
in a pivot. Multiple pivots can be specified to further
dissect your data.
Returns:
Callable[[~.RunPivotReportRequest],
Awaitable[~.RunPivotReportResponse]]:
A function that, when called, will call the underlying RPC
on the server.
""""""
# Generate a ""stub function"" on-the-fly which will actually make
# the request.
# gRPC handles serialization and deserialization, so we just need
# to pass in the functions for each.
if ""run_pivot_report"" not in self._stubs:
self._stubs[""run_pivot_report""] = self.grpc_channel.unary_unary(
""/google.analytics.data.v1alpha.AlphaAnalyticsData/RunPivotReport"",
request_serializer=analytics_data_api.RunPivotReportRequest.serialize,
response_deserializer=analytics_data_api.RunPivotReportResponse.deserialize,
)
return self._stubs[""run_pivot_report""]
@property
def batch_run_reports(
self,
) -> Callable[
[analytics_data_api.BatchRunReportsRequest],
Awaitable[analytics_data_api.BatchRunReportsResponse],
]:
r""""""Return a callable for the batch run reports method over gRPC.
Returns multiple reports in a batch. All reports must
be for the same Entity.
Returns:
Callable[[~.BatchRunReportsRequest],
Awaitable[~.BatchRunReportsResponse]]:
A function that, when called, will call the underlying RPC
on the server.
""""""
# Generate a ""stub function"" on-the-fly which will actually make
# the request.
# gRPC handles serialization and deserialization, so we just need
# to pass in the functions for each.
if ""batch_run_reports"" not in self._stubs:
self._stubs[""batch_run_reports""] = self.grpc_channel.unary_unary(
""/google.analytics.data.v1alpha.AlphaAnalyticsData/BatchRunReports"",
request_serializer=analytics_data_api.BatchRunReportsRequest.serialize,
response_deserializer=analytics_data_api.BatchRunReportsResponse.deserialize,
)
return self._stubs[""batch_run_reports""]
@property
def batch_run_pivot_reports(
self,
) -> Callable[
[analytics_data_api.BatchRunPivotReportsRequest],
Awaitable[analytics_data_api.BatchRunPivotReportsResponse],
]:
r""""""Return a callable for the batch run pivot reports method over gRPC.
Returns multiple pivot reports in a batch. All
reports must be for the same Entity.
Returns:
Callable[[~.BatchRunPivotReportsRequest],
Awaitable[~.BatchRunPivotReportsResponse]]:
A function that, when called, will call the underlying RPC
on the server.
""""""
# Generate a ""stub function"" on-the-fly which will actually make
# the request.
# gRPC handles serialization and deserialization, so we just need
# to pass in the functions for each.
if ""batch_run_pivot_reports"" not in self._stubs:
self._stubs[""batch_run_pivot_reports""] = self.grpc_channel.unary_unary(
""/google.analytics.data.v1alpha.AlphaAnalyticsData/BatchRunPivotReports"",
request_serializer=analytics_data_api.BatchRunPivotReportsRequest.serialize,
response_deserializer=analytics_data_api.BatchRunPivotReportsResponse.deserialize,
)
return self._stubs[""batch_run_pivot_reports""]
@property
def get_metadata(
self,
) -> Callable[
[analytics_data_api.GetMetadataRequest], Awaitable[analytics_data_api.Metadata]
]:
r""""""Return a callable for the get metadata method over gRPC.
Returns metadata for dimensions and metrics available in
reporting methods. Used to explore the dimensions and metrics.
In this method, a Google Analytics GA4 Property Identifier is
specified in the request, and the metadata response includes
Custom dimensions and metrics as well as Universal metadata.
For example if a custom metric with parameter name
``levels_unlocked`` is registered to a property, the Metadata
response will contain ``customEvent:levels_unlocked``. Universal
metadata are dimensions and metrics applicable to any property
such as ``country`` and ``totalUsers``.
Returns:
Callable[[~.GetMetadataRequest],
Awaitable[~.Metadata]]:
A function that, when called, will call the underlying RPC
on the server.
""""""
# Generate a ""stub function"" on-the-fly which will actually make
# the request.
# gRPC handles serialization and deserialization, so we just need
# to pass in the functions for each.
if ""get_metadata"" not in self._stubs:
self._stubs[""get_metadata""] = self.grpc_channel.unary_unary(
""/google.analytics.data.v1alpha.AlphaAnalyticsData/GetMetadata"",
request_serializer=analytics_data_api.GetMetadataRequest.serialize,
response_deserializer=analytics_data_api.Metadata.deserialize,
)
return self._stubs[""get_metadata""]
@property
def run_realtime_report(
self,
) -> Callable[
[analytics_data_api.RunRealtimeReportRequest],
Awaitable[analytics_data_api.RunRealtimeReportResponse],
]:
r""""""Return a callable for the run realtime report method over gRPC.
The Google Analytics Realtime API returns a
customized report of realtime event data for your
property. These reports show events and usage from the
last 30 minutes.
Returns:
Callable[[~.RunRealtimeReportRequest],
Awaitable[~.RunRealtimeReportResponse]]:
A function that, when called, will call the underlying RPC
on the server.
""""""
# Generate a ""stub function"" on-the-fly which will actually make
# the request.
# gRPC handles serialization and deserialization, so we just need
# to pass in the functions for each.
if ""run_realtime_report"" not in self._stubs:
self._stubs[""run_realtime_report""] = self.grpc_channel.unary_unary(
""/google.analytics.data.v1alpha.AlphaAnalyticsData/RunRealtimeReport"",
request_serializer=analytics_data_api.RunRealtimeReportRequest.serialize,
response_deserializer=analytics_data_api.RunRealtimeReportResponse.deserialize,
)
return self._stubs[""run_realtime_report""]
__all__ = (""AlphaAnalyticsDataGrpcAsyncIOTransport"",)
",1
"fix
from hepdata.ext.elasticsearch.api import index_record_ids, push_data_keywords
from hepdata.modules.submission.models import HEPSubmission, DataSubmission
from hepdata.modules.records.utils.common import get_record_by_id
from hepdata.modules.records.utils.doi_minter import generate_doi_for_table
from hepdata.modules.records.utils.submission import finalise_datasubmission
@fix.command()
@with_appcontext
def create_missing_datasubmission_records():
# Get submissions with missing IDs
missing_submissions = DataSubmission.query \
.join(HEPSubmission, HEPSubmission.publication_recid == DataSubmission.publication_recid) \
.filter(
DataSubmission.associated_recid == None,
DataSubmission.publication_inspire_id == None,
DataSubmission.version == HEPSubmission.version,
HEPSubmission.overall_status == 'finished')
missing_submissions = missing_submissions.all()
if not missing_submissions:
print(""No datasubmissions found with missing record or inspire ids."")
return
# Organise missing submissions by publication
submissions_by_publication = {}
for submission in missing_submissions:
if submission.publication_recid in submissions_by_publication:
submissions_by_publication[submission.publication_recid].append(submission)
else:
submissions_by_publication[submission.publication_recid] = [submission]
# Loop through each publication
for publication_recid, submissions in submissions_by_publication.items():
publication_record = get_record_by_id(publication_recid)
current_time = ""{:%Y-%m-%d %H:%M:%S}"".format(datetime.utcnow())
generated_record_ids = []
for submission in submissions:
# Finalise each data submission that does not have a record
finalise_datasubmission(current_time, {},
generated_record_ids,
publication_record, publication_recid,
submission,
submission.version)
# Register the datasubmission's DOI
if not current_app.config.get('TESTING', False):
generate_doi_for_table.delay(submission.doi)
print(f""Generated DOI {submission.doi}"")
else:
print(f""Would generate DOI {submission.doi}"")
# finalise_datasubmission does not commit, so commit once for each publication
db.session.commit()
# Reindex the publication and its updated datasubmissions
index_record_ids([publication_recid] + generated_record_ids)
push_data_keywords(pub_ids=[publication_recid])
",1
"he 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 django.utils.translation import ugettext_lazy as _
import horizon
class AlarmsVitrage(horizon.Panel):
name = _(""Alarms"")
slug = ""vitragealarms""
",1
"jit('void(uint8[:], int32, int32[:], int32[:])')
def lbp_kernel(input, neighborhood, powers, h):
i = cuda.grid(1)
r = 0
if i < input.shape[0] - 2 * neighborhood:
i += neighborhood
for j in range(i - neighborhood, i):
if input[j] >= input[i]:
r += powers[j - i + neighborhood]
for j in range(i + 1, i + neighborhood + 1):
if input[j] >= input[i]:
r += powers[j - i + neighborhood - 1]
cuda.atomic.add(h, r, 1)
def extract_1dlbp_gpu(input, neighborhood, d_powers):
maxThread = 512
blockDim = maxThread
d_input = cuda.to_device(input)
hist = np.zeros(2 ** (2 * neighborhood), dtype='int32')
gridDim = (len(input) - 2 * neighborhood + blockDim) / blockDim
d_hist = cuda.to_device(hist)
lbp_kernel[gridDim, blockDim](d_input, neighborhood, d_powers, d_hist)
d_hist.to_host()
return hist
def extract_1dlbp_gpu_debug(input, neighborhood, powers, res):
maxThread = 512
blockDim = maxThread
gridDim = (len(input) - 2 * neighborhood + blockDim) / blockDim
for block in range(0, gridDim):
for thread in range(0, blockDim):
r = 0
i = blockDim * block + thread
if i < input.shape[0] - 2 * neighborhood:
i += neighborhood
for j in range(i - neighborhood, i):
if input[j] >= input[i]:
r += powers[j - i + neighborhood]
for j in range(i + 1, i + neighborhood + 1):
if input[j] >= input[i]:
r += powers[j - i + neighborhood - 1]
res[r] += 1
return res
@jit(""int32[:](uint8[:], int64, int32[:], int32[:])"", nopython=True)
def extract_1dlbp_cpu_jit(input, neighborhood, powers, res):
maxThread = 512
blockDim = maxThread
gridDim = (len(input) - 2 * neighborhood + blockDim) / blockDim
for block in range(0, gridDim):
for thread in range(0, blockDim):
r = 0
i = blockDim * block + thread
if i < input.shape[0] - 2 * neighborhood:
i += neighborhood
for j in range(i - neighborhood, i):
if input[j] >= input[i]:
r += powers[j - i + neighborhood]
for j in range(i + 1, i + neighborhood + 1):
if input[j] >= input[i]:
r += powers[j - i + neighborhood - 1]
res[r] += 1
return res
def extract_1dlbp_cpu(input, neighborhood, p):
""""""
Extract the 1d lbp pattern on CPU
""""""
res = np.zeros(1 << (2 * neighborhood))
for i in range(neighborhood, len(input) - neighborhood):
left = input[i - neighborhood : i]
right = input[i + 1 : i + neighborhood + 1]
both = np.r_[left, right]
res[np.sum(p [both >= input[i]])] += 1
return res
X = np.arange(3, 7)
X = 10 ** X
neighborhood = 4
cpu_times = np.zeros(X.shape[0])
cpu_times_simple = cpu_times.copy()
cpu_times_jit = cpu_times.copy()
gpu_times = np.zeros(X.shape[0])
p = 1 << np.array(range(0, 2 * neighborhood), dtype='int32')
d_powers = cuda.to_device(p)
for i, x in enumerate(X):
input = np.random.randint(0, 256, size = x).astype(np.uint8)
print ""Length: {0}"".format(x)
print ""--------------""
start = timer()
h_cpu = extract_1dlbp_cpu(input, neighborhood, p)
cpu_times[i] = timer() - start
print ""Finished on CPU: time: {0:3.5f}s"".format(cpu_times[i])
res = np.zeros(1 << (2 * neighborhood), dtype='int32')
start = timer()
h_cpu_simple = extract_1dlbp_gpu_debug(input, neighborhood, p, res)
cpu_times_simple[i] = timer() - start
print ""Finished on CPU (simple): time: {0:3.5f}s"".format(cpu_times_simple[i])
res = np.zeros(1 << (2 * neighborhood), dtype='int32')
start = timer()
h_cpu_jit = extract_1dlbp_cpu_jit(input, neighborhood, p, res)
cpu_times_jit[i] = timer() - start
print ""Finished on CPU (numba: jit): time: {0:3.5f}s"".format(cpu_times_jit[i])
start = timer()
h_gpu = extract_1dlbp_gpu(input, neighborhood, d_powers)
gpu_times[i] = timer() - start
print ""Finished on GPU: time: {0:3.5f}s"".format(gpu_times[i])
print ""All h_cpu == h_gpu: "", (h_cpu_jit == h_gpu).all() and (h_cpu_simple == h_cpu_jit).all() and (h_cpu == h_cpu_jit).all()
print ''
f = plt.figure(figsize=(10, 5))
plt.plot(X, cpu_times, label = ""CPU"")
plt.plot(X, cpu_times_simple, label = ""CPU non-vectorized"")
plt.plot(X, cpu_times_jit, label = ""CPU jit"")
plt.plot(X, gpu_times, label = ""GPU"")
plt.yscale('log')
plt.xscale('log')
plt.xlabel('input length')
plt.ylabel('time, sec')
plt.legend()
plt.show()
",1
"ication
from five import grok
class IPublicationFolder(IIngestableFolder):
u'''Folder containing publications.'''
class PublicationIngestor(Ingestor):
u'''RDF ingestor for publication.'''
grok.context(IPublicationFolder)
def getContainedObjectInterface(self):
return IPublication
class View(IngestableFolderView):
u'''View for an publication folder'''
grok.context(IPublicationFolder)
",1
".
# 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 .sub_resource import SubResource
class ApplicationGatewaySslPredefinedPolicy(SubResource):
""""""An Ssl predefined policy.
:param id: Resource ID.
:type id: str
:param name: Name of Ssl predefined policy.
:type name: str
:param cipher_suites: Ssl cipher suites to be enabled in the specified
order for application gateway.
:type cipher_suites: list[str or
~azure.mgmt.network.v2017_10_01.models.ApplicationGatewaySslCipherSuite]
:param min_protocol_version: Minimum version of Ssl protocol to be
supported on application gateway. Possible values include: 'TLSv1_0',
'TLSv1_1', 'TLSv1_2'
:type min_protocol_version: str or
~azure.mgmt.network.v2017_10_01.models.ApplicationGatewaySslProtocol
""""""
_attribute_map = {
'id': {'key': 'id', 'type': 'str'},
'name': {'key': 'name', 'type': 'str'},
'cipher_suites': {'key': 'properties.cipherSuites', 'type': '[str]'},
'min_protocol_version': {'key': 'properties.minProtocolVersion', 'type': 'str'},
}
def __init__(self, **kwargs):
super(ApplicationGatewaySslPredefinedPolicy, self).__init__(**kwargs)
self.name = kwargs.get('name', None)
self.cipher_suites = kwargs.get('cipher_suites', None)
self.min_protocol_version = kwargs.get('min_protocol_version', None)
",1
"ETEPATH)
from ete2 import Tree, TreeStyle, NodeStyle, PhyloTree, faces, random_color
from ete2.treeview.faces import *
from ete2.treeview.main import _NODE_TYPE_CHECKER, FACE_POSITIONS
sys.path.insert(0, os.path.join(ETEPATH, ""examples/treeview""))
import face_grid, bubble_map, item_faces, node_style, node_background, face_positions, face_rotation, seq_motif_faces, barchart_and_piechart_faces
sys.path.insert(0, os.path.join(ETEPATH, ""examples/phylogenies""))
import phylotree_visualization
CONT = 0
class Test_Coretype_Treeview(unittest.TestCase):
"""""" Tests tree basics. """"""
def test_renderer(self):
main_tree = Tree()
main_tree.dist = 0
t, ts = face_grid.get_example_tree()
t_grid = TreeFace(t, ts)
n = main_tree.add_child()
n.add_face(t_grid, 0, ""aligned"")
t, ts = bubble_map.get_example_tree()
t_bubble = TreeFace(t, ts)
n = main_tree.add_child()
n.add_face(t_bubble, 0, ""aligned"")
t, ts = item_faces.get_example_tree()
t_items = TreeFace(t, ts)
n = main_tree.add_child()
n.add_face(t_items, 0, ""aligned"")
t, ts = node_style.get_example_tree()
t_nodest = TreeFace(t, ts)
n = main_tree.add_child()
n.add_face(t_nodest, 0, ""aligned"")
t, ts = node_background.get_example_tree()
t_bg = TreeFace(t, ts)
n = main_tree.add_child()
n.add_face(t_bg, 0, ""aligned"")
t, ts = face_positions.get_example_tree()
t_fpos = TreeFace(t, ts)
n = main_tree.add_child()
n.add_face(t_fpos, 0, ""aligned"")
t, ts = phylotree_visualization.get_example_tree()
t_phylo = TreeFace(t, ts)
n = main_tree.add_child()
n.add_face(t_phylo, 0, ""aligned"")
t, ts = face_rotation.get_example_tree()
temp_facet = TreeFace(t, ts)
n = main_tree.add_child()
n.add_face(temp_facet, 0, ""aligned"")
t, ts = seq_motif_faces.get_example_tree()
temp_facet = TreeFace(t, ts)
n = main_tree.add_child()
n.add_face(temp_facet, 0, ""aligned"")
t, ts = barchart_and_piechart_faces.get_example_tree()
temp_facet = TreeFace(t, ts)
n = main_tree.add_child()
n.add_face(temp_facet, 0, ""aligned"")
#Test orphan nodes and trees with 0 branch length
t, ts = Tree(), TreeStyle()
t.populate(5)
for n in t.traverse():
n.dist = 0
temp_tface = TreeFace(t, ts)
n = main_tree.add_child()
n.add_face(temp_tface, 0, ""aligned"")
ts.optimal_scale_level = ""full""
temp_tface = TreeFace(t, ts)
n = main_tree.add_child()
n.add_face(temp_tface, 0, ""aligned"")
ts = TreeStyle()
t.populate(5)
ts.mode = ""c""
temp_tface = TreeFace(t, ts)
n = main_tree.add_child()
n.add_face(temp_tface, 0, ""aligned"")
ts.optimal_scale_level = ""full""
temp_tface = TreeFace(t, ts)
n = main_tree.add_child()
n.add_face(temp_tface, 0, ""aligned"")
t, ts = Tree(), TreeStyle()
temp_tface = TreeFace(Tree('node;'), ts)
n = main_tree.add_child()
n.add_face(temp_tface, 0, ""aligned"")
t, ts = Tree(), TreeStyle()
ts.mode = ""c""
temp_tface = TreeFace(Tree('node;'), ts)
n = main_tree.add_child()
n.add_face(temp_tface, 0, ""aligned"")
t, ts = Tree(), TreeStyle()
ts.mode = ""c""
temp_tface = TreeFace(Tree(), ts)
n = main_tree.add_child()
n.add_face(temp_tface, 0, ""aligned"")
t, ts = Tree(), TreeStyle()
temp_tface = TreeFace(Tree(), ts)
n = main_tree.add_child()
n.add_face(temp_tface, 0, ""aligned"")
# TEST TIGHT TEST WRAPPING
chars = [""."" ""p"", ""j"", ""jJ""]
def layout(node):
global CONT
if CONT >= len(chars):
CONT = 0
if node.is_leaf():
node.img_style[""size""] = 0
F2= AttrFace(""name"", tight_text=True)
F= TextFace(chars[CONT], tight_text=True)
F.inner_border.width = 0
F2.inner_border.width = 0
#faces.add_face_to_node(F ,node, 0, position=""branch-right"")
faces.add_face_to_node(F2 ,node, 1, position=""branch-right"")
CONT += 1
t = Tree()
t.populate(20, random_branches=True)
ts = TreeStyle()
ts.layout_fn = layout
ts.mode = ""c""
ts.show_leaf_name = False
temp_tface = TreeFace(t, ts)
n = main_tree.add_child()
n.add_face(temp_tface, 0, ""aligned"")
# MAIN TREE
ms = TreeStyle()
ms.mode = ""r""
ms.show_leaf_name = False
main_tree.render('test.png', tree_style=ms)
main_tree.render('test.svg', tree_style=ms)
if __name__ == '__main__':
unittest.main()
",1
"ible quotes, right to the chat.
Usage:
/bible - Random quote
/bible Genesis 1:3 - Specific verse
/bible help - This help text
Verses are specified in the format {book} {chapter}:{verse}
TODO: Book acronyms, e.g. Gen -> Genesis
TODO: Verse ranges, e.g. Genesis 1:1-3
""""""
BIBLE_FILE = ""plugins/bible/en_kjv.json""
BIBLE_URL = 'https://raw.githubusercontent.com/thiagobodruk/bible/master/json/en_kjv.json'
plugin = create_plugin(name='bible', author='CianLR', help=HELP_STR)
bible = None
book_to_index = {}
def make_book_to_index(bible):
btoi = {}
for i, book in enumerate(bible):
btoi[book['name'].lower()] = i
return btoi
@plugin.setup()
def plugin_setup():
global bible, book_to_index
try:
bible = json.loads(open(BIBLE_FILE, encoding='utf-8-sig').read())
book_to_index = make_book_to_index(bible)
return
except BaseException as e:
pass
# We've tried nothing and we're all out of ideas, download a new bible.
try:
bible = json.loads(
requests.get(BIBLE_URL).content.decode('utf-8-sig'))
except BaseException as e:
return ""Error loading bible: "" + str(e)
book_to_index = make_book_to_index(bible)
with open(BIBLE_FILE, 'w') as f:
json.dump(bible, f)
@plugin.listen(command='bible help')
def help_command(bot, message: SteelyMessage, **kwargs):
bot.sendMessage(
HELP_STR,
thread_id=message.thread_id, thread_type=message.thread_type)
def is_valid_quote(book, chapter, verse):
return (0 <= book < len(bible) and
0 <= chapter < len(bible[book]['chapters']) and
0 <= verse < len(bible[book]['chapters'][chapter]))
def get_quote(book, chapter, verse):
return ""{}\n - {} {}:{}"".format(
bible[book][""chapters""][chapter][verse],
bible[book][""name""], chapter + 1, verse + 1)
def get_quote_from_ref(book_name, ref):
if book_name.lower() not in book_to_index:
return ""Could not find book name: "" + book_name
book_i = book_to_index[book_name.lower()]
if len(ref.split(':')) != 2:
return 'Reference not in form ""Book Chapter:Passage""'
chapter, verse = ref.split(':')
if not chapter.isnumeric():
return ""Chapter must be an int""
chapter_i = int(chapter) - 1
if not verse.isnumeric():
return ""Passage must be an int""
verse_i = int(verse) - 1
if not is_valid_quote(book_i, chapter_i, verse_i):
return ""Verse or chapter out of range""
return get_quote(book_i, chapter_i, verse_i)
@plugin.listen(command='bible [book] [passage]')
def passage_command(bot, message: SteelyMessage, **kwargs):
if 'passage' not in kwargs:
book = random.randrange(len(bible))
chapter = random.randrange(len(bible[book][""chapters""]))
verse = random.randrange(len(bible[book][""chapters""][chapter]))
bot.sendMessage(
get_quote(book, chapter, verse),
thread_id=message.thread_id, thread_type=message.thread_type)
else:
bot.sendMessage(
get_quote_from_ref(kwargs['book'], kwargs['passage']),
thread_id=message.thread_id, thread_type=message.thread_type)
",1
"lf, op_map):
processed = {}
for pattern, f in op_map.iteritems():
s = self._build_pattern_groups(pattern.lower())
processed[re.compile(s)] = f
self.operations = processed
def execute(self, context, op):
s = ""%04x"" % op
for pattern, f in self.operations.iteritems():
m = pattern.match(s)
if m:
return f(context, *[int(v, base=16) for v in m.groups()])
assert False, s
def _build_pattern_groups(self, pattern):
s = pattern.replace('?', '.')
for id in ['x', 'y', 'z']:
m = re.search('%s+' % id, s)
if m:
s = s[:m.start()] + ('(.{%s})' % (m.end() - m.start())) + s[m.end():]
return '^' + s + '$'
def set_mem_v0_vx(context, x):
for i in range(x):
context.memory.write_byte(context.index_reg + i, context.v[i])
context.pc += 2
def fill_v0_vx(context, x):
for i in range(x+1):
context.v[i] = context.memory.get_byte(context.index_reg + i)
context.pc += 2
def set_bcd_vx(context, x):
val = int(context.v[x])
context.memory.write_byte(context.index_reg, val / 100)
context.memory.write_byte(context.index_reg + 1, val % 100 / 10)
context.memory.write_byte(context.index_reg + 2, val % 100 % 10)
context.pc += 2
def set_i_font(context, x):
context.index_reg = context.memory.get_font_address(context.v[x])
context.pc += 2
def add_reg_ind(context, x):
context.index_reg += context.v[x]
context.pc += 2
def set_delay_timer(context, x):
context.delay_timer = context.v[x]
context.pc += 2
def set_sound_timer(context, x):
context.sound_timer = context.v[x]
context.pc += 2
def set_vx_key_pressed(context, x):
context.v[x] = context.keypad.wait_for_keypress()
context.pc += 2
def set_vx_delay_timer(context, x):
context.v[x] = context.delay_timer
context.pc += 2
def skip_key_vx(context, x, result=True):
if context.keypad.is_keypressed(context.v[x]) == result:
context.pc += 2
context.pc += 2
def draw_sprite(context, x, y, n):
sprite = []
for cb in range(n):
sprite.append(context.memory.get_byte(context.index_reg + cb))
collision = context.screen.draw(context.v[x], context.v[y], sprite)
context.v[15] = collision
context.pc += 2
def jump_nnn_v0(context, nnn):
context.pc = context.v[0] + nnn
def set_vx_rand(context, x, nn):
import random
context.v[x] = random.randint(0, 0xFF) & nn
context.pc += 2
def jump_noteq(context, x, y):
if context.v[x] != context.v[y]:
context.pc += 2
context.pc += 2
def shift_vy_left(context, x, y):
context.v[15] = context.v[15] >> 7 # First value
context.v[x] = (context.v[y] << 1) % 255
context.pc += 2
def shift_right(context, x, y):
context.v[15] = context.v[y] & 0x1
context.v[x] = context.v[y] >> 1
context.pc += 2
def sub_vx_vy_vf(context, x, y):
logging.info('Setting V[X] = V[X] - V[Y], V[F] = 1 if V[Y] > V[X]')
context.v[15] = 1 if context.v[y] > context.v[x] else 0
context.v[x] = context.v[x] - context.v[y]
context.pc += 2
def add_vx_vy(context, x, y):
logging.info('Setting V[X] = V[X] + V[Y]')
val = context.v[x] + context.v[y]
context.v[15] = 1 if val > 255 else 0
context.v[x] = val % 256
context.pc += 2
def sub_vx_vy(context, x, y):
logging.info('Setting V[X] = V[X] - V[Y]')
val = context.v[x] - context.v[y]
context.v[15] = 1 if val < 0 else 0
context.v[x] = val % 256
context.pc += 2
def set_vx_or_vy(context, x, y):
logging.info('Setting V[X] = V[X] | V[Y]')
context.v[x] = context.v[x] | context.v[y]
context.pc += 2
def set_vx_xor_vy(context, x, y):
logging.info('Setting V[X] = V[X] ^ V[Y]')
context.v[x] = context.v[x] ^ context.v[y]
context.pc += 2
def set_vx_and_vy(context, x, y):
logging.info('Setting V[X] = V[X] & V[Y]')
context.v[x] = context.v[x] & context.v[y]
context.pc += 2
def set_vx_vy(context, x, y):
logging.info('Setting V[X] = V[Y]')
context.v[x] = context.v[y]
context.pc += 2
def add_reg(context, x, nnn):
logging.info('Adding NNN to V[X]')
context.v[x] = (context.v[x] + nnn) % 256
context.pc += 2
def set_i(context, nnn):
logging.info('Setting NNN to index_reg')
context.index_reg = nnn
context.pc += 2
def pop_stack(context):
logging.info('Returning from a subroutine')
context.pc = context.stack.pop()
def call_rca1082(context, address): #TODO
print(""operation not implemented yet:"", address)
context.pc += 1
def clear(context):
logging.info('Clearing screen')
context.screen.clear()
context.pc += 2
def jump(context, address):
logging.info('Jump at 0x%2x address' % address)
context.pc = address
def call(context, address):
logging.info('Calling subroutine at 0x%2x address' % address)
context.pc += 2
context.stack.append(context.pc)
context.pc = address
def skip_equal(context, x, nnn, ifeq=True):
logging.info('Skip if V[X] === NNN is %s' % ifeq)
if (context.v[x] == nnn) == ifeq:
context.pc += 2
context.pc += 2
def skip_eq_reg(context, x, y):
logging.info('Skip if V[X] === V[Y]')
if context.v[x] == context.v[y]:
context.pc += 2
context.pc += 2
def set_reg(context, x, nnn):
logging.info('Set NNN to cpu reg V[x]')
context.v[x] = nnn
context.pc += 2
op_map = {
'0?E0': clear,
'0?EE': pop_stack,
'0XXX': call_rca1082,
'1XXX': jump,
'2XXX': call,
'3XYY': skip_equal,
'4XYY': lambda context, x, nn: skip_equal(context, x, nn, ifeq = False),
'5XY0': skip_eq_reg,
'6XYY': set_reg,
'7XYY': add_reg,
'8XY0': set_vx_vy,
'8XY1': set_vx_or_vy,
'8XY2': set_vx_and_vy,
'8XY3': set_vx_xor_vy,
'8XY4': add_vx_vy,
'8XY5': sub_vx_vy,
'8XY6': shift_right,
'8XY7': sub_vx_vy_vf,
'8XYE': shift_vy_left,
'9XY0': jump_noteq,
'AXXX': set_i,
'BXXX': jump_nnn_v0,
'CXYY': set_vx_rand,
'DXYZ': draw_sprite,
'EX9E': lambda context, x: skip_key_vx(x, result=False),
'EXA1': skip_key_vx,
'FX07': set_vx_delay_timer,
'FX0A': set_vx_key_pressed,
'FX15': set_delay_timer,
'FX18': set_sound_timer,
'FX1E': add_reg_ind,
'FX29': set_i_font,
'FX33': set_bcd_vx,
'FX55': set_mem_v0_vx,
'FX65': fill_v0_vx
}
",1
" or later.
# This is a standalone program that converts a tabulated version of the Stixrude and Lithgow-Bertelloni data format into the standard burnman format (printed to stdout)
import sys
def read_dataset(datafile):
f=open(datafile,'r')
ds=[]
for line in f:
ds.append(line.decode('utf-8').split())
return ds
ds=read_dataset('HHPH2013_endmembers.dat')
print '# BurnMan - a lower mantle toolkit'
print '# Copyright (C) 2012, 2013, Heister, T., Unterborn, C., Rose, I. and Cottaar, S.'
print '# Released under GPL v2 or later.'
print ''
print '""""""'
print 'HHPH_2013'
print 'Minerals from Holland et al 2013 and references therein'
print 'The values in this document are all in S.I. units,'
print 'unlike those in the original paper'
print 'File autogenerated using HHPHdata_to_burnman.py'
print '""""""'
print ''
print 'from burnman.mineral import Mineral'
print 'from burnman.solidsolution import SolidSolution'
print 'from burnman.solutionmodel import *'
print 'from burnman.processchemistry import read_masses, dictionarize_formula, formula_mass'
print ''
print 'atomic_masses=read_masses()'
print ''
print '""""""'
print 'ENDMEMBERS'
print '""""""'
print ''
param_scales = [ -1., -1., #not nubmers, so we won't scale
1.e3, 1.e3, #kJ -> J
1.0, # J/K/mol
1.e-5, # kJ/kbar/mol -> m^3/mol
1.e3, 1.e-2, 1.e3, 1.e3, # kJ -> J and table conversion for b
1.e-5, # table conversion
1.e8, # kbar -> Pa
1.0, # no scale for K'0
1.e-8] #GPa -> Pa # no scale for eta_s
formula='0'
for idx, m in enumerate(ds):
if idx == 0:
param_names=m
else:
print 'class', m[0].lower(), '(Mineral):'
print ' def __init__(self):'
print ''.join([' formula=\'',m[1],'\''])
print ' formula = dictionarize_formula(formula)'
print ' self.params = {'
print ''.join([' \'name\': \'', m[0], '\','])
print ' \'formula\': formula,'
print ' \'equation_of_state\': \'hp_tmt\','
for pid, param in enumerate(m):
if pid > 1 and pid != 3 and pid<6:
print ' \''+param_names[pid]+'\':', float(param)*param_scales[pid], ','
print ' \'Cp\':', [round(float(m[i])*param_scales[i],10) for i in [6, 7, 8, 9]], ','
for pid, param in enumerate(m):
if pid > 9:
print ' \''+param_names[pid]+'\':', float(param)*param_scales[pid], ','
print ' \'n\': sum(formula.values()),'
print ' \'molar_mass\': formula_mass(formula, atomic_masses)}'
print ''
print ' self.uncertainties = {'
print ' \''+param_names[3]+'\':', float(m[3])*param_scales[3], '}'
print ' Mineral.__init__(self)'
print ''
",1
"growth_rate_1_year_out, sga_of_sales, da_of_sales, capex_of_sales, nwc_of_sales, levered_beta, current_yield, exit_multiple, ticker):
assumptions = {}
try:
assumptions['Tax Rate'] = float(tax_rate)/100.0
assumptions['Growth Rate 1 year out'] = float(growth_rate_1_year_out)/100.0
assumptions['SGA % of sales'] = float(sga_of_sales)/100.0
assumptions['D&A % of sales'] = float(da_of_sales)/100.0
assumptions['CAPEX % of sales'] = float(capex_of_sales)/100.0
assumptions['NWC % of sales'] = float(nwc_of_sales)/100.0
assumptions['Levered Beta'] = float(levered_beta)
assumptions['Current Yield'] = float(current_yield)/100.0
assumptions['Exit Multiple'] = float(exit_multiple)
except ValueError:
return 'Invalid DCF Input. Please try again.
'
ticker = ticker.split(' ')[0]
if not ticker.isalnum():
return 'Invalid Ticker. Please try again.
'
return calc_dcf(assumptions, ticker.upper())
",1
"gestBST(root):
if root.left is None and root.right is None:
return True, 1, root.value, root.value
if root.left:
isBSTL, sizeL, minL, maxL = largestBST(root.left)
else:
isBSTL = True
sizeL = 0
minL = -float('inf')
if root.right:
isBSTR, sizeR, minR, maxR = largestBST(root.right)
else:
isBSTR = True
sizeR = 0
maxR = float('inf')
if isBSTL and isBSTR:
if maxL <= root.value <= minR:
return True, sizeL+sizeR+1, minL, maxR,
size = max(sizeL, sizeR)
return False, size , None, None
root1 = BTree()
root1.value = 0
root2 = BTree()
root2.value = 0
generateRandomTree(root2,2)
generateRandomTree(root1,2)
root1.left.left.left = root2
inorder(root1)
print largestBST(root1)
",1
"ttings as django_settings
from django.db.models import signals
from know.plugins.attachments import settings
from know import managers
from know.models.pluginbase import ReusablePlugin
from know.models.article import BaseRevisionMixin
class IllegalFileExtension(Exception):
""""""File extension on upload is not allowed""""""
pass
class Attachment(ReusablePlugin):
objects = managers.ArticleFkManager()
current_revision = models.OneToOneField(
'AttachmentRevision',
verbose_name=_(u'current revision'),
blank=True,
null=True,
related_name='current_set',
help_text=_(u'The revision of this attachment currently in use (on all articles using the attachment)'),
)
original_filename = models.CharField(
max_length=256,
verbose_name=_(u'original filename'),
blank=True,
null=True,
)
def can_write(self, **kwargs):
user = kwargs.get('user', None)
if not settings.ANONYMOUS and (not user or user.is_anonymous()):
return False
return ReusablePlugin.can_write(self, **kwargs)
def can_delete(self, user):
return self.can_write(user=user)
class Meta:
verbose_name = _(u'attachment')
verbose_name_plural = _(u'attachments')
app_label = settings.APP_LABEL
def __unicode__(self):
return ""%s: %s"" % (self.article.current_revision.title, self.original_filename)
def extension_allowed(filename):
try:
extension = filename.split(""."")[-1]
except IndexError:
# No extension
raise IllegalFileExtension(""No file extension found in filename. That's not okay!"")
if not extension.lower() in map(lambda x: x.lower(), settings.FILE_EXTENSIONS):
raise IllegalFileExtension(""The following filename is illegal: %s. Extension has to be one of %s"" %
(filename, "", "".join(settings.FILE_EXTENSIONS)))
return extension
def upload_path(instance, filename):
from os import path
extension = extension_allowed(filename)
# Has to match original extension filename
if instance.id and instance.attachment and instance.attachment.original_filename:
original_extension = instance.attachment.original_filename.split(""."")[-1]
if not extension.lower() == original_extension:
raise IllegalFileExtension(""File extension has to be '%s', not '%s'."" %
(original_extension, extension.lower()))
elif instance.attachment:
instance.attachment.original_filename = filename
upload_path = settings.UPLOAD_PATH
upload_path = upload_path.replace('%aid', str(instance.attachment.article.id))
if settings.UPLOAD_PATH_OBSCURIFY:
import random
import hashlib
m = hashlib.md5(str(random.randint(0, 100000000000000)))
upload_path = path.join(upload_path, m.hexdigest())
if settings.APPEND_EXTENSION:
filename += '.upload'
return path.join(upload_path, filename)
class AttachmentRevision(BaseRevisionMixin, models.Model):
attachment = models.ForeignKey('Attachment')
file = models.FileField(
upload_to=upload_path,
max_length=255,
verbose_name=_(u'file'),
storage=settings.STORAGE_BACKEND,
)
description = models.TextField(
blank=True,
)
class Meta:
verbose_name = _(u'attachment revision')
verbose_name_plural = _(u'attachment revisions')
ordering = ('created',)
get_latest_by = ('revision_number',)
app_label = settings.APP_LABEL
def get_filename(self):
""""""Used to retrieve the filename of a revision.
But attachment.original_filename should always be used in the frontend
such that filenames stay consistent.""""""
# TODO: Perhaps we can let file names change when files are replaced?
if not self.file:
return None
filename = self.file.name.split(""/"")[-1]
return ""."".join(filename.split(""."")[:-1])
def get_size(self):
""""""Used to retrieve the file size and not cause exceptions.""""""
try:
return self.file.size
except OSError:
return None
except ValueError:
return None
def save(self, *args, **kwargs):
if (not self.id and
not self.previous_revision and
self.attachment and
self.attachment.current_revision and
self.attachment.current_revision != self):
self.previous_revision = self.attachment.current_revision
if not self.revision_number:
try:
previous_revision = self.attachment.attachmentrevision_set.latest()
self.revision_number = previous_revision.revision_number + 1
# NB! The above should not raise the below exception, but somehow it does.
except AttachmentRevision.DoesNotExist, Attachment.DoesNotExist:
self.revision_number = 1
super(AttachmentRevision, self).save(*args, **kwargs)
if not self.attachment.current_revision:
# If I'm saved from Django admin, then article.current_revision is me!
self.attachment.current_revision = self
self.attachment.save()
def __unicode__(self):
return ""%s: %s (r%d)"" % (self.attachment.article.current_revision.title,
self.attachment.original_filename,
self.revision_number)
def on_revision_delete(instance, *args, **kwargs):
if not instance.file:
return
# Remove file
path = instance.file.path.split(""/"")[:-1]
instance.file.delete(save=False)
# Clean up empty directories
# Check for empty folders in the path. Delete the first two.
if len(path[-1]) == 32:
# Path was (most likely) obscurified so we should look 2 levels down
max_depth = 2
else:
max_depth = 1
for depth in range(0, max_depth):
delete_path = ""/"".join(path[:-depth] if depth > 0 else path)
try:
if len(os.listdir(os.path.join(django_settings.MEDIA_ROOT, delete_path))) == 0:
os.rmdir(delete_path)
except OSError:
# Raised by os.listdir if directory is missing
pass
signals.pre_delete.connect(on_revision_delete, AttachmentRevision)
",1
" RPi.GPIO as GPIO # remove!!!
from emotions import angry, happy, confused
# from pysabertooth import Sabertooth
# from smc import SMC
from library import LEDDisplay
from library import factory
from library import reset_all_hw
# Leg Motor Speed Global
global_LegMotor = 70
# # Happy Emotion
# def happy(leds, servos, mc, audio):
# print(""4"")
# print(""Happy"")
#
# # Dome Motor Initialization
# # mc = SMC(dome_motor_port, 115200)
# # mc.init()
#
# # Spins Motor
# # mc.init()
# mc.speed(3200)
#
# # LED Matrix Green
# # breadboard has mono
# # R2 has bi-color leds
# # mono:0 bi:1
# # led_type = 0
# # leds = [0]*5
# # leds[1] = LEDDisplay(0x70, led_type)
# # leds[2] = LEDDisplay(0x71, led_type)
# # leds[3] = LEDDisplay(0x72, led_type)
# # leds[4] = LEDDisplay(0x73, led_type)
#
# for x in [0, 1, 2, 3, 4, 5, 6, 7]:
# for y in [0, 1, 2, 3, 4, 5, 6, 7]:
# for i in range(1, 5):
# leds[i].set(x, y, 1)
#
# for i in range(1, 5):
# leds[i].write()
#
# # Servo Wave
# # s0.angle = 0
# # time.sleep(0.2)
# # s1.angle = 0
# # time.sleep(0.2)
# # s2.angle = 0
# # time.sleep(0.2)
# # s3.angle = 0
# # time.sleep(0.2)
# # s4.angle = 0
# # time.sleep(0.5)
# # s4.angle = 130
# # time.sleep(0.2)
# # s3.angle = 130
# # time.sleep(0.2)
# # s2.angle = 130
# # time.sleep(0.2)
# # s1.angle = 130
# # time.sleep(0.2)
# # s0.angle = 130
#
# for a in [0, 130]:
# for i in range(4):
# servos[i].angle = a
# time.sleep(0.2)
# time.sleep(0.5)
#
# time.sleep(1.5)
# mc.stop()
# time.sleep(1.5)
# for i in range(1, 5):
# leds[i].clear()
#
#
# # Confused Emotion
# def confused(leds, servos, mc, audio):
# print(""5"")
# print(""Confused"")
# # LED Matrix Yellow
# # leds = [0]*5
# # leds[1] = LEDDisplay(0x70, 1)
# # leds[2] = LEDDisplay(0x71, 1)
# # leds[3] = LEDDisplay(0x72, 1)
# # leds[4] = LEDDisplay(0x73, 1)
#
# for x in [0, 1, 2, 3, 4, 5, 6, 7]:
# for y in [0, 1, 2, 3, 4, 5, 6, 7]:
# for i in range(1, 5):
# leds[i].set(x, y, 3)
# for i in range(1, 5):
# leds[i].write()
# time.sleep(3)
# for i in range(1, 5):
# leds[i].clear()
#
#
# # Angry Emotion
# def angry(leds, servos, mc, audio):
# print(""6"")
# print(""Angry"")
# # LED Matrix Red
# # leds = [0]*5
# # leds[1] = LEDDisplay(0x70, 1)
# # leds[2] = LEDDisplay(0x71, 1)
# # leds[3] = LEDDisplay(0x72, 1)
# # leds[4] = LEDDisplay(0x73, 1)
#
# for x in [0, 1, 2, 3, 4, 5, 6, 7]:
# for y in [0, 1, 2, 3, 4, 5, 6, 7]:
# for i in range(1, 5):
# leds[i].set(x, y, 2)
#
# for i in range(1, 5):
# leds[i].write()
#
# # Plays Imperial Theme Sound
# audio.sound('imperial')
#
# # Servo Open and Close
# # s0.angle = 0
# # s1.angle = 0
# # s2.angle = 0
# # s3.angle = 0
# # s4.angle = 0
# # time.sleep(1)
# # s4.angle = 130
# # s3.angle = 130
# # s2.angle = 130
# # s1.angle = 130
# # s0.angle = 130
#
# for a in [0, 130]:
# for i in range(5):
# servos[i].angle = a
# time.sleep(1)
#
# time.sleep(3)
# for i in range(1, 5):
# leds[i].clear()
#######################################
# original remote
#######################################
# # Remote Mode
# def remote(remoteflag, namespace):
# print(""Remote"")
#
# # create objects
# (leds, dome, legs, servos, Flash) = factory(['leds', 'dome', 'legs', 'servos', 'flashlight'])
#
# # initalize everything
# dome.init()
# dome.speed(0)
#
# legs.drive(1, 0)
# legs.drive(2, 0)
#
# for s in servos:
# s.angle = 0
# time.sleep(0.25)
#
# # what is this???
# GPIO.setmode(GPIO.BCM)
# GPIO.setwarnings(False)
# GPIO.setup(26, GPIO.OUT)
#
# # Joystick Initialization
# js = Joystick()
#
# # get audio
# audio = namespace.audio
#
# # Flash = FlashlightPWM(15)
# # Flash = namespace.flashlight
#
# while(remoteflag.is_set()):
# try:
# # Button Initialization
# ps4 = js.get()
# btnSquare = ps4.buttons[0]
# btnTriangle = ps4.buttons[1]
# btnCircle = ps4.buttons[2]
# btnX = ps4.buttons[3]
# btnLeftStickLeftRight = ps4.leftStick.y
# btnLeftStickUpDown = ps4.leftStick.x
# btnRightStickLeftRight = ps4.rightStick.y
# btnRightStickUpDown = ps4.rightStick.x
# Left1 = ps4.shoulder[0]
# Right1 = ps4.shoulder[1]
# Left2 = ps4.triggers.x
# Right2 = ps4.triggers.y
# hat = ps4.hat
#
# # print(""PRINT"")
#
# # Button Controls
# if hat == 1:
# # Happy Emotion
# print(""Arrow Up Pressed"")
# happy(leds, servos, dome, audio) # namespace.emotions['happy'](leds, servos, mc, audio)
# if hat == 8:
# # Confused Emotion
# print(""Arrow Left Pressed"")
# confused(leds, servos, dome, audio)
# if hat == 2:
# # Angry Emotion
# print(""Arrow Right Pressed"")
# angry(leds, servos, dome, audio)
# if hat == 4:
# print(""Arrow Down Pressed"")
# if btnSquare == 1:
# # word = random_char(2)
# audio.speak_random(2)
# time.sleep(0.5)
# if btnTriangle == 1:
# # FlashLight ON
# GPIO.output(26, GPIO.HIGH)
# Flash.pwm.set_pwm(15, 0, 130)
# if btnCircle == 1:
# # FlashLight OFF
# GPIO.output(26, GPIO.LOW)
# Flash.pwm.set_pwm(15, 0, 0)
# if btnX == 1:
# for x in [0, 1, 2, 3, 4, 5, 6, 7]:
# for y in [0, 1, 2, 3, 4, 5, 6, 7]:
# if x == randint(0, 8) or y == randint(0, 8):
# for i in range(1, 5):
# leds[i].set(x, y, randint(0, 4))
# else:
# for i in range(1, 5):
# leds[i].set(x, y, 4)
# for i in range(1, 5):
# leds[i].write()
# time.sleep(0.1)
# for i in range(1, 5):
# leds[i].clear()
# if Left1 == 1:
# # Dome Motor Forward
# dome.speed(3200)
# time.sleep(2)
# dome.speed(0)
# if Right1 == 1:
# # Dome Motor Backward
# dome.speed(-3200)
# time.sleep(2)
# dome.speed(0)
# # if Left1 == 0 or Right1 == 0:
# # # Dome Motor Stop
# # dome.speed(0)
# # if Left2 > 1:
# # # Servo Open
# # s0.angle = 0
# # s1.angle = 0
# # s2.angle = 0
# # s3.angle = 0
# # s4.angle = 0
# # Flash.pwm.set_pwm(15, 0, 3000)
# #
# # if Right2 > 1:
# # # Servo Close
# # s0.angle = 130
# # s1.angle = 130
# # s2.angle = 130
# # s3.angle = 130
# # s4.angle = 130
# # Flash.pwm.set_pwm(15, 0, 130)
# if Left2 > 1:
# for s in servos:
# s.angle = 0
# time.sleep(0.25)
# Flash.pwm.set_pwm(15, 0, 300)
# if Right2 > 1:
# for s in servos:
# s.angle = 130
# time.sleep(0.25)
# Flash.pwm.set_pwm(15, 0, 130)
# if btnLeftStickLeftRight < 0.3 and btnLeftStickLeftRight > -0.3:
# legs.drive(1, 0)
# if btnRightStickUpDown < 0.3 and btnRightStickUpDown > -0.3:
# legs.drive(2, 0)
# if btnRightStickUpDown >= 0.3:
# # Right and Left Motor Forward
# legs.drive(1, btnRightStickUpDown*global_LegMotor)
# legs.drive(2, btnRightStickUpDown*-global_LegMotor)
# if btnRightStickUpDown <= -0.3:
# # Right and Left Motor Backward
# legs.drive(1, btnRightStickUpDown*global_LegMotor)
# legs.drive(2, btnRightStickUpDown*-global_LegMotor)
# if btnLeftStickLeftRight <= 0.3:
# # Turn Left
# legs.drive(1, btnLeftStickLeftRight*(-global_LegMotor))
# legs.drive(2, btnLeftStickLeftRight*-global_LegMotor)
# if btnLeftStickLeftRight >= -0.3:
# # Turn Right
# legs.drive(1, btnLeftStickLeftRight*(-global_LegMotor))
# legs.drive(2, btnLeftStickLeftRight*-global_LegMotor)
#
# except KeyboardInterrupt:
# print('js exiting ...')
# return
# return
def remote_func(hw, ns):
print(""Remote"")
dome = hw['dome']
dome.speed(0)
legs = hw['legs']
legs.drive(1, 0)
legs.drive(2, 0)
flashlight = hw['flashlight']
audio = hw['audio']
audio.speak('start')
while ns.current_state == 3:
print('remote ...')
spd = random.randint(0, 40)
legs.drive(1, spd)
legs.drive(2, spd)
dome.speed(spd)
time.sleep(0.5)
legs.drive(1, 0)
legs.drive(2, 0)
dome.speed(0)
time.sleep(0.1)
return
###### real loop here #####
# Joystick Initialization
js = Joystick()
while ns.current_state == 3:
try:
# Button Initialization
ps4 = js.get()
btnSquare = ps4.buttons[0]
btnTriangle = ps4.buttons[1]
btnCircle = ps4.buttons[2]
btnX = ps4.buttons[3]
btnLeftStickLeftRight = ps4.leftStick.y
btnLeftStickUpDown = ps4.leftStick.x
btnRightStickLeftRight = ps4.rightStick.y
btnRightStickUpDown = ps4.rightStick.x
Left1 = ps4.shoulder[0]
Right1 = ps4.shoulder[1]
Left2 = ps4.triggers.x
Right2 = ps4.triggers.y
hat = ps4.hat
# print(""PRINT"")
# Button Controls
if hat == 1:
# Happy Emotion
print(""Arrow Up Pressed"")
happy(leds, servos, dome, audio) # namespace.emotions['happy'](leds, servos, mc, audio)
if hat == 8:
# Confused Emotion
print(""Arrow Left Pressed"")
confused(leds, servos, dome, audio)
if hat == 2:
# Angry Emotion
print(""Arrow Right Pressed"")
angry(leds, servos, dome, audio)
if hat == 4:
print(""Arrow Down Pressed"")
if btnSquare == 1:
# word = random_char(2)
audio.speak_random(2)
time.sleep(0.5)
if btnTriangle == 1:
# FlashLight ON
GPIO.output(26, GPIO.HIGH)
Flash.pwm.set_pwm(15, 0, 130)
if btnCircle == 1:
# FlashLight OFF
GPIO.output(26, GPIO.LOW)
Flash.pwm.set_pwm(15, 0, 0)
if btnX == 1:
for x in [0, 1, 2, 3, 4, 5, 6, 7]:
for y in [0, 1, 2, 3, 4, 5, 6, 7]:
if x == randint(0, 8) or y == randint(0, 8):
for i in range(1, 5):
leds[i].set(x, y, randint(0, 4))
else:
for i in range(1, 5):
leds[i].set(x, y, 4)
for i in range(1, 5):
leds[i].write()
time.sleep(0.1)
for i in range(1, 5):
leds[i].clear()
if Left1 == 1:
# Dome Motor Forward
dome.speed(3200)
time.sleep(2)
dome.speed(0)
if Right1 == 1:
# Dome Motor Backward
dome.speed(-3200)
time.sleep(2)
dome.speed(0)
# if Left1 == 0 or Right1 == 0:
# # Dome Motor Stop
# dome.speed(0)
# if Left2 > 1:
# # Servo Open
# s0.angle = 0
# s1.angle = 0
# s2.angle = 0
# s3.angle = 0
# s4.angle = 0
# Flash.pwm.set_pwm(15, 0, 3000)
#
# if Right2 > 1:
# # Servo Close
# s0.angle = 130
# s1.angle = 130
# s2.angle = 130
# s3.angle = 130
# s4.angle = 130
# Flash.pwm.set_pwm(15, 0, 130)
if Left2 > 1:
for s in servos:
s.angle = 0
time.sleep(0.25)
Flash.pwm.set_pwm(15, 0, 300)
if Right2 > 1:
for s in servos:
s.angle = 130
time.sleep(0.25)
Flash.pwm.set_pwm(15, 0, 130)
if btnLeftStickLeftRight < 0.3 and btnLeftStickLeftRight > -0.3:
legs.drive(1, 0)
if btnRightStickUpDown < 0.3 and btnRightStickUpDown > -0.3:
legs.drive(2, 0)
if btnRightStickUpDown >= 0.3:
# Right and Left Motor Forward
legs.drive(1, btnRightStickUpDown*global_LegMotor)
legs.drive(2, btnRightStickUpDown*-global_LegMotor)
if btnRightStickUpDown <= -0.3:
# Right and Left Motor Backward
legs.drive(1, btnRightStickUpDown*global_LegMotor)
legs.drive(2, btnRightStickUpDown*-global_LegMotor)
if btnLeftStickLeftRight <= 0.3:
# Turn Left
legs.drive(1, btnLeftStickLeftRight*(-global_LegMotor))
legs.drive(2, btnLeftStickLeftRight*-global_LegMotor)
if btnLeftStickLeftRight >= -0.3:
# Turn Right
legs.drive(1, btnLeftStickLeftRight*(-global_LegMotor))
legs.drive(2, btnLeftStickLeftRight*-global_LegMotor)
except KeyboardInterrupt:
print('js exiting ...')
return
# exiting, reset all hw
reset_all_hw(hw)
return
",1
"sim: LungEnv, pid_K=[0.0, 0.0], decay=0.1, **kwargs):
self.base_controller = base_controller
self.sim = sim
self.I = 0.0
self.K = pid_K
self.decay = decay
self.reset()
def reset(self):
self.base_controller.reset()
self.sim.reset()
self.I = 0.0
def compute_action(self, state, t):
u_in_base, u_out = self.base_controller(state, t)
err = self.sim.pressure - state
self.I = self.I * (1 - self.decay) + err * self.decay
pid_correction = self.K[0] * err + self.K[1] * self.I
u_in = torch.clamp(u_in_base + pid_correction, min=0.0, max=100.0)
self.sim(u_in, u_out, t)
return u_in, u_out
",1
"enti-Wilson
#
# 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 brightcove.core import APIObject, Field, DateTimeField, ListField, EnumField
from brightcove.objects import ItemCollection, enum
ChannelNameEnum = enum('ten', 'eleven', 'one')
PlaylistTypeEnum = enum('full_episodes', 'web_extras', 'news', 'season', 'week', 'category', 'special', 'preview')
MediaDeliveryEnum = enum('default', 'http', 'http_ios')
class EnumNumField(Field):
def __init__(self, enum_cls, help=None):
self.help = help
self.enum_cls = enum_cls
def to_python(self, value):
for i, field in enumerate(self.enum_cls._fields):
if i == value:
return field
raise Exception('Invalid Enum: %s' % value)
def from_python(self, value):
return self.enum_cls._fields[value]
class Playlist(APIObject):
_fields = ['name', 'type', 'season', 'week', 'query']
type = EnumField(PlaylistTypeEnum)
def __repr__(self):
return ''.format(self.name)
class Show(APIObject):
_fields = ['showName', 'channelName', 'videoLink', 'mobileLink', 'logo', 'fanart', 'playlists']
channelName = EnumField(ChannelNameEnum)
playlists = ListField(Playlist)
def __repr__(self):
return ''.format(self.showName)
class AMFRendition(APIObject):
_fields = ['defaultURL', 'audioOnly', 'mediaDeliveryType', 'encodingRate',
'frameHeight', 'frameWidth', 'size',
'videoCodec', 'videoContainer']
mediaDeliveryType = EnumNumField(MediaDeliveryEnum)
def __repr__(self):
return ''.format(self.encodingRate, self.mediaDeliveryType, self.frameWidth, self.frameHeight)
class ShowItemCollection(ItemCollection):
_item_class = Show
items = ListField(Show)
class PlaylistItemCollection(ItemCollection):
_item_class = Playlist
items = ListField(Playlist)
class MediaRenditionItemCollection(ItemCollection):
_item_class = AMFRendition
items = ListField(AMFRendition)
",1
"ens.Standby import TryQuitMainloop
from . crossepglib import *
from . crossepg_downloader import CrossEPG_Downloader
from . crossepg_importer import CrossEPG_Importer
from . crossepg_converter import CrossEPG_Converter
from . crossepg_loader import CrossEPG_Loader
from . crossepg_setup import CrossEPG_Setup
from . crossepg_menu import CrossEPG_Menu
from . crossepg_auto import CrossEPG_Auto
class CrossEPG_Main:
def __init__(self):
self.config = CrossEPG_Config()
self.patchtype = getEPGPatchType()
def downloader(self, session):
self.session = session
CrossEPG_Auto.instance.lock = True
CrossEPG_Auto.instance.stop()
self.config.load()
if self.config.configured == 0:
self.session.openWithCallback(self.configureCallback, MessageBox, _(""You need to configure crossepg before starting downloader.\nWould You like to do it now ?""), type=MessageBox.TYPE_YESNO)
else:
self.config.deleteLog()
self.session.openWithCallback(self.downloadCallback, CrossEPG_Downloader, self.config.providers)
def configureCallback(self, result):
if result is True:
self.session.open(CrossEPG_Setup)
def loaderAsPlugin(self, session):
self.session = session
CrossEPG_Auto.instance.lock = True
CrossEPG_Auto.instance.stop()
self.loader()
def downloadCallback(self, ret):
if ret:
if self.config.csv_import_enabled == 1:
self.importer()
else:
if self.patchtype != 3:
self.converter()
else:
self.loader()
else:
CrossEPG_Auto.instance.lock = False
def importer(self):
self.session.openWithCallback(self.importerCallback, CrossEPG_Importer)
def importerCallback(self, ret):
if ret:
if self.patchtype != 3:
self.converter()
else:
self.loader()
else:
CrossEPG_Auto.instance.lock = False
def converter(self):
self.session.openWithCallback(self.converterCallback, CrossEPG_Converter)
def converterCallback(self, ret):
if ret:
if self.patchtype != -1:
self.loader()
else:
if self.config.download_manual_reboot:
self.session.open(TryQuitMainloop, 3)
else:
CrossEPG_Auto.instance.lock = False
else:
CrossEPG_Auto.instance.lock = False
def loader(self):
self.session.openWithCallback(self.loaderCallback, CrossEPG_Loader)
def loaderCallback(self, ret):
CrossEPG_Auto.instance.lock = False
def setup(self, session, **kwargs):
CrossEPG_Auto.instance.lock = True
session.openWithCallback(self.setupCallback, CrossEPG_Menu)
def setupCallback(self):
CrossEPG_Auto.instance.lock = False
CrossEPG_Auto.instance.doneConfiguring()
crossepg_main = CrossEPG_Main()
",1
"it under
# the terms of the GNU Lesser General Public License as published by the
# Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Iris 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 Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public License
# along with Iris. If not, see
#############################################################################
###########
# imports #
###########
import sys
sys.path.insert(0,'../../../build/swig/python')
import os
import yui
log = yui.YUILog.instance()
log.setLogFileName(""/tmp/debug.log"")
log.enableDebugLogging( True )
appl = yui.YUI.application()
appl.setApplicationTitle(""Show dialogs example"")
#################
# class mainGui #
#################
class Info(object):
def __init__(self,title,richtext,text):
self.title=title
self.richtext=richtext
self.text=text
class mainGui():
""""""
Main class
""""""
def __init__(self):
self.factory = yui.YUI.widgetFactory()
self.dialog = self.factory.createPopupDialog()
mainvbox = self.factory.createVBox(self.dialog)
frame = self.factory.createFrame(mainvbox,""Test frame"")
HBox = self.factory.createHBox(frame)
self.aboutbutton = self.factory.createPushButton(HBox,""&About"")
self.closebutton = self.factory.createPushButton(self.factory.createRight(HBox), ""&Close"")
def ask_YesOrNo(self, info):
yui.YUI.widgetFactory
mgafactory = yui.YMGAWidgetFactory.getYMGAWidgetFactory(yui.YExternalWidgets.externalWidgetFactory(""mga""))
dlg = mgafactory.createDialogBox(yui.YMGAMessageBox.B_TWO)
dlg.setTitle(info.title)
dlg.setText(info.text, info.richtext)
dlg.setButtonLabel(""Yes"", yui.YMGAMessageBox.B_ONE)
dlg.setButtonLabel(""No"", yui.YMGAMessageBox.B_TWO)
dlg.setMinSize(50, 5);
return dlg.show() == yui.YMGAMessageBox.B_ONE
def aboutDialog(self):
yui.YUI.widgetFactory;
mgafactory = yui.YMGAWidgetFactory.getYMGAWidgetFactory(yui.YExternalWidgets.externalWidgetFactory(""mga""))
dlg = mgafactory.createAboutDialog(""About dialog title example"", ""1.0.0"", ""GPLv3"",
""Angelo Naselli"", ""This beautiful test example shows how it is easy to play with libyui bindings"", """")
dlg.show();
def handleevent(self):
""""""
Event-handler for the 'widgets' demo
""""""
while True:
event = self.dialog.waitForEvent()
if event.eventType() == yui.YEvent.CancelEvent:
self.dialog.destroy()
break
if event.widget() == self.closebutton:
info = Info(""Quit confirmation"", 1, ""Are you sure you want to quit?"")
if self.ask_YesOrNo(info):
self.dialog.destroy()
break
if event.widget() == self.aboutbutton:
self.aboutDialog()
if __name__ == ""__main__"":
main_gui = mainGui()
main_gui.handleevent()
",1
" * m2, sy + dy * m2): m = m2
return (sx + dx*m, sy + dy*m)
def norm(x, y):
l = (x*x + y*y)**0.5
return (x/l, y/l)
sx, sy = 0, 10.1
dx, dy = 1.4, -19.7
for I in range(999):
sx, sy = coll(sx, sy, dx, dy)
if sy > 0 and abs(sx) <= 0.01:
print(I)
break
mx, my = norm(1, -4*sx/sy)
d = mx*dx + my*dy
dx, dy = -dx + 2 * mx * d, -dy + 2 * my * d
",1
".schema import StringField, DateTimeField, IntegerField
from resource_api.service import Service
from resource_api.errors import ValidationError
RE_SHA1 = re.compile(""^[a-f0-9]{40}$"")
SHELVE_PATH = ""/tmp/school.shelve.db""
class ShelveService(Service):
def __init__(self):
super(ShelveService, self).__init__()
self._storage = shelve.open(SHELVE_PATH, writeback=True)
def _get_context(self):
return {""storage"": self._storage}
def _get_user(self, data):
return None
def __del__(self):
self._storage.close()
class Resource(BaseResource):
def __init__(self, context):
super(Resource, self).__init__(context)
self._storage = context[""storage""]
def exists(self, user, pk):
return pk in self._storage.get(self.get_name(), {})
def get_data(self, user, pk):
return self._storage.get(self.get_name(), {}).get(pk)
def delete(self, user, pk):
self._storage.get(self.get_name(), {}).pop(pk)
self._storage.sync()
def create(self, user, pk, data):
if self.get_name() not in self._storage:
self._storage[self.get_name()] = {}
self._storage[self.get_name()][pk] = data
self._storage.sync()
def update(self, user, pk, data):
self._storage[self.get_name()][pk].update(data)
self._storage.sync()
def get_uris(self, user, params=None):
return self._storage.get(self.get_name(), {}).keys()
def get_count(self, user, params=None):
return len(self.get_uris(params))
class Link(BaseLink):
def __init__(self, context):
super(Link, self).__init__(context)
self._storage = context[""storage""]
def exists(self, user, pk, rel_pk):
return rel_pk in self._storage.get((pk, self.get_name()), {})
def get_data(self, user, pk, rel_pk):
return self._storage.get((pk, self.get_name()), {}).get(rel_pk)
def create(self, user, pk, rel_pk, data=None):
key = (pk, self.get_name())
if key not in self._storage:
self._storage[key] = {}
self._storage[key][rel_pk] = data
self._storage.sync()
def update(self, user, pk, rel_pk, data):
self._storage[key][rel_pk].update(data)
self._storage.sync()
def delete(self, user, pk, rel_pk):
self._storage.get((pk, self.get_name()), {}).pop(rel_pk)
self._storage.sync()
def get_uris(self, user, pk, params=None):
return self._storage.get((pk, self.get_name()), {}).keys()
def get_count(self, user, pk, params=None):
return len(self.get_uris(pk, params))
class Student(Resource):
"""""" A pupil """"""
class Schema:
email = StringField(regex=""[^@]+@[^@]+\.[^@]+"", pk=True,
description=""Addess to which the notifications shall be sent"")
first_name = StringField(description=""Given name(s)"")
last_name = StringField(description=""Family name(s)"")
birthday = DateTimeField()
class Links:
class courses(Link):
"""""" Courses the student has ever attended """"""
class Schema:
grade = IntegerField(min_val=1, max_val=5)
target = ""Course""
related_name = ""students""
master = True
class comments(Link):
"""""" Comments made by the student """"""
target = ""Comment""
related_name = ""student""
class ratings(Link):
"""""" Ratings given by the student """"""
target = ""TeacherRating""
related_name = ""student""
class Teacher(Resource):
"""""" A lecturer """"""
class Schema:
email = StringField(regex=""[^@]+@[^@]+\.[^@]+"", pk=True,
description=""Addess to which the notifications shall be sent"")
first_name = StringField(description=""Given name(s)"")
last_name = StringField(description=""Family name(s)"")
category = StringField(description=""TQS Category"", choices=[""four"", ""five"", ""five plus"", ""six""])
class Links:
class ratings(Link):
"""""" Ratings given to the teacher """"""
target = ""TeacherRating""
related_name = ""teacher""
class courses(Link):
"""""" Courses the teacher is responsible for """"""
target = ""Course""
related_name = ""teacher""
class Course(Resource):
"""""" An educational unit represinting the lessons for a specific set of topics """"""
class Schema:
name = StringField(pk=True, description=""Name of the course. E.g. physics, maths."")
duration = IntegerField(description=""Length of the course in weeks"")
class Links:
class teacher(Link):
"""""" The lecturer of the course """"""
target = ""Teacher""
related_name = ""courses""
cardinality = Link.cardinalities.ONE
master = True
required = True
class comments(Link):
"""""" All comments made about the course """"""
target = ""Comment""
related_name = ""course""
class ratings(Link):
"""""" All ratings that were given to the teachers of the specific course """"""
target = ""TeacherRating""
related_name = ""course""
class students(Link):
"""""" All pupils who attend the course """"""
target = ""Student""
related_name = ""courses""
class AutoGenSha1UriPolicy(AbstractUriPolicy):
"""""" Uses a randomly generated sha1 as a primary key """"""
@property
def type(self):
return ""autogen_policy""
def generate_pk(self, data):
return os.urandom(16).encode('hex')
def serialize(self, pk):
return pk
def deserialize(self, pk):
if not isinstance(pk, basestring):
raise ValidationError(""Has to be string"")
if not RE_SHA1.match(value):
raise ValidationError(""PK is not a valid SHA1"")
return pk
class Comment(Resource):
"""""" Student's comment about the course """"""
UriPolicy = AutoGenSha1UriPolicy
class Schema:
pk = StringField(pk=True, description=""Identifier of the resource"")
value = StringField(description=""Text of the comment"")
creation_time = DateTimeField(description=""Time when the comment was added (for sorting purpose)"")
class Links:
class student(Link):
"""""" The pupil who made the comment """"""
target = ""Student""
related_name = ""comments""
cardinality = Link.cardinalities.ONE
master = True
required = True
class course(Link):
"""""" The subject the comment was made about """"""
target = ""Course""
related_name = ""comments""
cardinality = Link.cardinalities.ONE
master = True
required = True
class TeacherRating(Resource):
"""""" Student's rating about teacher's performance """"""
UriPolicy = AutoGenSha1UriPolicy
class Schema:
pk = StringField(pk=True, description=""Identifier of the resource"")
value = IntegerField(min_val=0, max_val=100, description=""Lecturer's performance identifier "")
creation_time = DateTimeField(description=""Time when the rating was added (for sorting purpose)"")
class Links:
class student(Link):
"""""" The pupil who gave the rating to the teacher """"""
target = ""Student""
related_name = ""ratings""
cardinality = Link.cardinalities.ONE
master = True
required = True
class course(Link):
"""""" The subject with respect to which the rating was given """"""
target = ""Course""
related_name = ""ratings""
cardinality = Link.cardinalities.ONE
master = True
required = True
class teacher(Link):
"""""" The lecturer to whom the rating is related """"""
target = ""Teacher""
related_name = ""ratings""
cardinality = Link.cardinalities.ONE
master = True
required = True
srv = ShelveService()
srv.register(Student)
srv.register(Teacher)
srv.register(Course)
srv.register(Comment)
srv.register(TeacherRating)
srv.setup()
",1
" Field(object):
required = True
""""""Field is required and an exception will be raised if missing""""""
missing_value = None
""""""Value to use when field is missing and not required""""""
strict = False
""""""Field value must pass validation or an exception will be raised""""""
cast_cls = None
data = None
def __init__(self, required=True, missing_value=None, strict=False):
self.required = required
self.missing_value = missing_value
self.strict = strict
def _validate(self, value):
return True
def _cast_type(self, value):
return self.cast_cls(value)
def set_data(self, value):
if self.strict:
if not self._validate(value):
raise FieldValidationException('%s does not '
'except this value'
% self.__class__.__name__)
elif self.cast_cls is not None:
value = self._cast_type(value)
self.data = value
class CharField(Field):
pass
class StringField(Field):
cast_cls = str
def _validate(self, value):
if not isinstance(value, (str, unicode)):
return False
return True
class IntField(Field):
cast_cls = int
_cast_fallback_value = 0
def __init__(self, *args, **kwargs):
super(IntField, self).__init__(*args, **kwargs)
if self.missing_value is None:
self.missing_value = self._cast_fallback_value
def _cast_type(self, value):
try:
return self.cast_cls(value)
except ValueError, exc:
if self.missing_value is False:
raise FieldTypeConversionError('Could not convert '
'data or use missing_value: %s'
% exc)
return self.missing_value
class FloatField(IntField):
cast_class = float
_cast_fallback_value = 0.0
class ListField(Field):
cls = None
""""""Field class to represent list items""""""
def __init__(self, cls, *args, **kwargs):
assert isinstance(cls, Field), 'cls is not a valid Field instance'
self.cls = cls
super(ListField, self).__init__(*args, **kwargs)
def _validate(self, value):
if not isinstance(value, (list, tuple)):
raise FieldValidationException('ListField requires data '
'to be a sequence type')
for x in value:
self.cls.set_data(value)
self.data = value
return True
class Vector(object):
def __init__(self):
self.input_data = {}
self._fields = {}
self._map = {}
self._required = []
self._setup_fields()
def get_name(self):
return self.__class__.__name__
def __call__(self, data):
return self.input(data)
def input(self, data):
self._map = {}
if not isinstance(data, dict):
raise VectorInputTypeError('Vector input not a dictionary')
self._validate(data)
self._map_attrs(data)
def _setup_fields(self):
self._fields = {}
for a in dir(self):
v = getattr(self, a)
if isinstance(v, Field):
self._fields[a] = v
if v.required:
self._required.append(a)
self._reset_fields()
def _reset_fields(self):
for f in self.get_fields():
setattr(self, f, None)
def _validate(self, input_data):
for f in self._required:
if f not in input_data:
raise FieldRequiredError('Missing field %s is a required field'
% f)
for k, v in input_data.iteritems():
if k in self.get_fields():
f = self.get_field(k)
f.set_data(v)
def _map_attrs(self, input_data):
self.input_data = input_data
for k, v in self.input_data.iteritems():
if k in self.get_fields():
# setattr(self, k, self.get_field(k).data)
self._map[k] = self.get_field(k).data
else:
# setattr(self, k, v)
self._map[k] = v
for k, v in self._map.iteritems():
setattr(self, k, v)
def get_fields(self):
return self._fields
def get_field(self, name):
return self._fields[name]
@property
def data(self):
return self._map
",1
", 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 Salesforce.com nor the names of its contributors
# may be used to endorse or promote products derived from this
# software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
# TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
# USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
import numpy
import scipy.stats
from collections import defaultdict
def scores_to_probs(scores):
scores = numpy.array(scores)
scores -= scores.max()
probs = numpy.exp(scores, out=scores)
probs /= probs.sum()
return probs
def score_to_empirical_kl(score, count):
""""""
Convert total log score to KL( empirical || model ),
where the empirical pdf is uniform over `count` datapoints.
""""""
count = float(count)
return -score / count - numpy.log(count)
def print_histogram(probs, counts):
WIDTH = 60.0
max_count = max(counts)
print '{: >8} {: >8}'.format('Prob', 'Count')
for prob, count in sorted(zip(probs, counts), reverse=True):
width = int(round(WIDTH * count / max_count))
print '{: >8.3f} {: >8d} {}'.format(prob, count, '-' * width)
def multinomial_goodness_of_fit(
probs,
counts,
total_count,
truncated=False,
plot=False):
""""""
Pearson's chi^2 test, on possibly truncated data.
http://en.wikipedia.org/wiki/Pearson%27s_chi-squared_test
Returns:
p-value of truncated multinomial sample.
""""""
assert len(probs) == len(counts)
assert truncated or total_count == sum(counts)
chi_squared = 0
dof = 0
if plot:
print_histogram(probs, counts)
for p, c in zip(probs, counts):
if p == 1:
return 1 if c == total_count else 0
assert p < 1, 'bad probability: %g' % p
if p > 0:
mean = total_count * p
variance = total_count * p * (1 - p)
assert variance > 1,\
'WARNING goodness of fit is inaccurate; use more samples'
chi_squared += (c - mean) ** 2 / variance
dof += 1
else:
print 'WARNING zero probability in goodness-of-fit test'
if c > 0:
return float('inf')
if not truncated:
dof -= 1
survival = scipy.stats.chi2.sf(chi_squared, dof)
return survival
def unif01_goodness_of_fit(samples, plot=False):
""""""
Bin uniformly distributed samples and apply Pearson's chi^2 test.
""""""
samples = numpy.array(samples, dtype=float)
assert samples.min() >= 0.0
assert samples.max() <= 1.0
bin_count = int(round(len(samples) ** 0.333))
assert bin_count >= 7, 'WARNING imprecise test, use more samples'
probs = numpy.ones(bin_count, dtype=numpy.float) / bin_count
counts = numpy.zeros(bin_count, dtype=numpy.int)
for sample in samples:
counts[int(bin_count * sample)] += 1
return multinomial_goodness_of_fit(probs, counts, len(samples), plot=plot)
def density_goodness_of_fit(samples, probs, plot=False):
""""""
Transform arbitrary continuous samples to unif01 distribution
and assess goodness of fit via Pearson's chi^2 test.
Inputs:
samples - a list of real-valued samples from a distribution
probs - a list of probability densities evaluated at those samples
""""""
assert len(samples) == len(probs)
assert len(samples) > 100, 'WARNING imprecision; use more samples'
pairs = zip(samples, probs)
pairs.sort()
samples = numpy.array([x for x, p in pairs])
probs = numpy.array([p for x, p in pairs])
density = numpy.sqrt(probs[1:] * probs[:-1])
gaps = samples[1:] - samples[:-1]
unif01_samples = 1.0 - numpy.exp(-len(samples) * gaps * density)
return unif01_goodness_of_fit(unif01_samples, plot=plot)
def discrete_goodness_of_fit(
samples,
probs_dict,
truncate_beyond=8,
plot=False):
""""""
Transform arbitrary discrete data to multinomial
and assess goodness of fit via Pearson's chi^2 test.
""""""
assert len(samples) > 100, 'WARNING imprecision; use more samples'
counts = defaultdict(lambda: 0)
for sample in samples:
assert sample in probs_dict
counts[sample] += 1
items = [(prob, counts.get(i, 0)) for i, prob in probs_dict.iteritems()]
items.sort(reverse=True)
truncated = (truncate_beyond and truncate_beyond < len(items))
if truncated:
items = items[:truncate_beyond]
probs = [prob for prob, count in items]
counts = [count for prob, count in items]
return multinomial_goodness_of_fit(
probs,
counts,
len(samples),
truncated=truncated,
plot=plot)
def bin_samples(samples, k=10, support=[]):
""""""
Bins a collection of univariate samples into k bins of equal
fill via the empirical cdf, to be used in goodness of fit testing.
Returns
counts : array k x 1
bin_ranges : arrary k x 2
each count is the number of samples in [bin_min, bin_max)
except for the last bin which is [bin_min, bin_max]
list partitioning algorithm adapted from Mark Dickinson:
http://stackoverflow.com/questions/2659900
""""""
samples = sorted(samples)
N = len(samples)
q, r = divmod(N, k)
#we need to distribute the remainder relatively evenly
#tests will be inaccurate if we have small bins at the end
indices = [i * q + min(r, i) for i in range(k + 1)]
bins = [samples[indices[i]: indices[i + 1]] for i in range(k)]
bin_ranges = []
counts = []
for i in range(k):
bin_min = bins[i][0]
try:
bin_max = bins[i + 1][0]
except IndexError:
bin_max = bins[i][-1]
bin_ranges.append([bin_min, bin_max])
counts.append(len(bins[i]))
if support:
bin_ranges[0][0] = support[0]
bin_ranges[-1][1] = support[1]
return numpy.array(counts), numpy.array(bin_ranges)
def histogram(samples, bin_count=None):
if bin_count is None:
bin_count = numpy.max(samples) + 1
v = numpy.zeros(bin_count, dtype=int)
for sample in samples:
v[sample] += 1
return v
",1
"ango.contrib.auth import authenticate, login
from django.shortcuts import redirect
from django.core.urlresolvers import reverse
from biz.djangoapps.ga_manager.models import Manager
log = logging.getLogger(__name__)
LOGIN_ADMIN = 1
LOGIN_ERROR = -1
LOGIN_DEFAULT = 0
LOGIN_ERROR_AUTH = -2
def index(request):
""""""
lists content of Login
""""""
next_url = request.GET.get('next', '')
if request.user.is_active:
if request.user.is_authenticated():
if next_url == '':
return redirect(reverse('biz:index'))
else:
return redirect(next_url)
account_check = LOGIN_DEFAULT
post_email = request.POST.get('email', '')
post_password = request.POST.get(""password"")
post_remember = False
if request.method == 'POST':
next_url = request.POST.get(""next"", '')
if ""remember"" in request.POST:
post_remember = True
if not 0 < len(post_email) <= 255:
log.info('Login failed - email length over')
account_check = LOGIN_ERROR
if not 0 < len(post_password) <= 255:
log.info('Login failed - password length over')
account_check = LOGIN_ERROR
if User.objects.filter(email=post_email, is_active=True).exists():
user = User.objects.get(email=post_email, is_active=True)
else:
log.info(""Login failed - password for {0} is invalid"".format(post_email))
account_check = LOGIN_ERROR
if account_check == LOGIN_ERROR:
return render_to_response('gx_login/login.html', {'account_check': account_check, 'next_url': next_url, 'email': post_email})
if user.check_password(post_password):
mgs = Manager.get_managers(user)
if any([mg.is_aggregator() for mg in mgs]):
account_check = LOGIN_ADMIN
if any([mg.is_director() for mg in mgs]):
account_check = LOGIN_ADMIN
if any([mg.is_manager() for mg in mgs]):
account_check = LOGIN_ADMIN
if any([mg.is_platformer() for mg in mgs]):
account_check = LOGIN_ADMIN
if account_check == LOGIN_ADMIN:
# Auto Updating Last Login Datetime
user = authenticate(username=user.username, password=post_password)
login(request, user)
if post_remember:
# Session Retention 7 days
request.session.set_expiry(604800)
else:
request.session.set_expiry(0)
if next_url == '':
return redirect(reverse('biz:index'))
else:
return redirect(next_url)
else:
account_check = LOGIN_ERROR_AUTH
else:
log.info('Login failed - password mismatch')
account_check = LOGIN_ERROR
return render_to_response('gx_login/login.html', {'account_check': account_check, 'next_url': next_url, 'email': post_email})
",1
"ile 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.
Ref: https://github.com/swagger-api/swagger-codegen
""""""
from pprint import pformat
from six import iteritems
class Chassis100ChassisActions(object):
""""""
NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually.
""""""
def __init__(self):
""""""
Chassis100ChassisActions - a model defined in Swagger
:param dict swaggerTypes: The key is attribute name
and the value is attribute type.
:param dict attributeMap: The key is attribute name
and the value is json key in definition.
""""""
self.swagger_types = {
'oem': 'object',
'chassis_reset': 'Chassis100Reset'
}
self.attribute_map = {
'oem': 'Oem',
'chassis_reset': '#Chassis.Reset'
}
self._oem = None
self._chassis_reset = None
@property
def oem(self):
""""""
Gets the oem of this Chassis100ChassisActions.
:return: The oem of this Chassis100ChassisActions.
:rtype: object
""""""
return self._oem
@oem.setter
def oem(self, oem):
""""""
Sets the oem of this Chassis100ChassisActions.
:param oem: The oem of this Chassis100ChassisActions.
:type: object
""""""
self._oem = oem
@property
def chassis_reset(self):
""""""
Gets the chassis_reset of this Chassis100ChassisActions.
:return: The chassis_reset of this Chassis100ChassisActions.
:rtype: Chassis100Reset
""""""
return self._chassis_reset
@chassis_reset.setter
def chassis_reset(self, chassis_reset):
""""""
Sets the chassis_reset of this Chassis100ChassisActions.
:param chassis_reset: The chassis_reset of this Chassis100ChassisActions.
:type: Chassis100Reset
""""""
self._chassis_reset = chassis_reset
def to_dict(self):
""""""
Returns the model properties as a dict
""""""
result = {}
for attr, _ in 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()
else:
result[attr] = value
return result
def to_str(self):
""""""
Returns the string representation of the model
""""""
return 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
""""""
return self.__dict__ == other.__dict__
def __ne__(self, other):
""""""
Returns true if both objects are not equal
""""""
return not self == other
",1
"):
prefix_count_top = running_counts[top]
suffix_count_top = total_counts[top] - prefix_count_top
return (prefix_count_top * 2 > i + 1) and (suffix_count_top * 2 > len(A) - i - 1)
total_counts = Counter(A)
running_counts = defaultdict(int)
top = A[0]
result = 0
for i in xrange(len(A) - 1):
n = A[i]
running_counts[n] += 1
top = top if running_counts[top] >= running_counts[n] else n
if _is_equi_leader(i):
result += 1
return result
",1
" 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 ; got u'my_name' (a )
So that `check_name()` can be easily used within an assignment, ``name``
is returned unchanged if it passes the check. For example:
>>> n = check_name('my_name')
>>> n
'my_name'
:param name: Identifier to test.
""""""
if type(name) is not str:
raise TypeError(
TYPE_ERROR % ('name', str, name, type(name))
)
if re.match(NAME_REGEX, name) is None:
raise ValueError(
NAME_ERROR % (NAME_REGEX, name)
)
return name
class NameSpace(ReadOnly):
""""""
A read-only name-space with handy container behaviours.
A `NameSpace` instance is an ordered, immutable mapping object whose values
can also be accessed as attributes. A `NameSpace` instance is constructed
from an iterable providing its *members*, which are simply arbitrary objects
with a ``name`` attribute whose value:
1. Is unique among the members
2. Passes the `check_name()` function
Beyond that, no restrictions are placed on the members: they can be
classes or instances, and of any type.
The members can be accessed as attributes on the `NameSpace` instance or
through a dictionary interface. For example, say we create a `NameSpace`
instance from a list containing a single member, like this:
>>> class my_member(object):
... name = 'my_name'
...
>>> namespace = NameSpace([my_member])
>>> namespace
NameSpace(<1 member>, sort=True)
We can then access ``my_member`` both as an attribute and as a dictionary
item:
>>> my_member is namespace.my_name # As an attribute
True
>>> my_member is namespace['my_name'] # As dictionary item
True
For a more detailed example, say we create a `NameSpace` instance from a
generator like this:
>>> class Member(object):
... def __init__(self, i):
... self.i = i
... self.name = 'member%d' % i
... def __repr__(self):
... return 'Member(%d)' % self.i
...
>>> ns = NameSpace(Member(i) for i in xrange(3))
>>> ns
NameSpace(<3 members>, sort=True)
As above, the members can be accessed as attributes and as dictionary items:
>>> ns.member0 is ns['member0']
True
>>> ns.member1 is ns['member1']
True
>>> ns.member2 is ns['member2']
True
Members can also be accessed by index and by slice. For example:
>>> ns[0]
Member(0)
>>> ns[-1]
Member(2)
>>> ns[1:]
(Member(1), Member(2))
(Note that slicing a `NameSpace` returns a ``tuple``.)
`NameSpace` instances provide standard container emulation for membership
testing, counting, and iteration. For example:
>>> 'member3' in ns # Is there a member named 'member3'?
False
>>> 'member2' in ns # But there is a member named 'member2'
True
>>> len(ns) # The number of members
3
>>> list(ns) # Iterate through the member names
['member0', 'member1', 'member2']
Although not a standard container feature, the `NameSpace.__call__()` method
provides a convenient (and efficient) way to iterate through the *members*
(as opposed to the member names). Think of it like an ordered version of
the ``dict.itervalues()`` method. For example:
>>> list(ns[name] for name in ns) # One way to do it
[Member(0), Member(1), Member(2)]
>>> list(ns()) # A more efficient, simpler way to do it
[Member(0), Member(1), Member(2)]
Another convenience method is `NameSpace.__todict__()`, which will return
a copy of the ``dict`` mapping the member names to the members.
For example:
>>> ns.__todict__()
{'member1': Member(1), 'member0': Member(0), 'member2': Member(2)}
As `NameSpace.__init__()` locks the instance, `NameSpace` instances are
read-only from the get-go. An ``AttributeError`` is raised if you try to
set *any* attribute on a `NameSpace` instance. For example:
>>> ns.member3 = Member(3) # Lets add that missing 'member3'
Traceback (most recent call last):
...
AttributeError: locked: cannot set NameSpace.member3 to Member(3)
(For information on the locking protocol, see the `ReadOnly` class, of which
`NameSpace` is a subclass.)
By default the members will be sorted alphabetically by the member name.
For example:
>>> sorted_ns = NameSpace([Member(7), Member(3), Member(5)])
>>> sorted_ns
NameSpace(<3 members>, sort=True)
>>> list(sorted_ns)
['member3', 'member5', 'member7']
>>> sorted_ns[0]
Member(3)
But if the instance is created with the ``sort=False`` keyword argument, the
original order of the members is preserved. For example:
>>> unsorted_ns = NameSpace([Member(7), Member(3), Member(5)], sort=False)
>>> unsorted_ns
NameSpace(<3 members>, sort=False)
>>> list(unsorted_ns)
['member7', 'member3', 'member5']
>>> unsorted_ns[0]
Member(7)
The `NameSpace` class is used in many places throughout freeIPA. For a few
examples, see the `plugable.API` and the `frontend.Command` classes.
""""""
def __init__(self, members, sort=True, name_attr='name'):
""""""
:param members: An iterable providing the members.
:param sort: Whether to sort the members by member name.
""""""
if type(sort) is not bool:
raise TypeError(
TYPE_ERROR % ('sort', bool, sort, type(sort))
)
self.__sort = sort
if sort:
self.__members = tuple(
sorted(members, key=lambda m: getattr(m, name_attr))
)
else:
self.__members = tuple(members)
self.__names = tuple(getattr(m, name_attr) for m in self.__members)
self.__map = dict()
for member in self.__members:
name = check_name(getattr(member, name_attr))
if name in self.__map:
raise AttributeError(OVERRIDE_ERROR %
(self.__class__.__name__, name, self.__map[name], member)
)
assert not hasattr(self, name), 'Ouch! Has attribute %r' % name
self.__map[name] = member
setattr(self, name, member)
lock(self)
def __len__(self):
""""""
Return the number of members.
""""""
return len(self.__members)
def __iter__(self):
""""""
Iterate through the member names.
If this instance was created with ``sort=False``, the names will be in
the same order as the members were passed to the constructor; otherwise
the names will be in alphabetical order (which is the default).
This method is like an ordered version of ``dict.iterkeys()``.
""""""
for name in self.__names:
yield name
def __call__(self):
""""""
Iterate through the members.
If this instance was created with ``sort=False``, the members will be
in the same order as they were passed to the constructor; otherwise the
members will be in alphabetical order by name (which is the default).
This method is like an ordered version of ``dict.itervalues()``.
""""""
for member in self.__members:
yield member
def __contains__(self, name):
""""""
Return ``True`` if namespace has a member named ``name``.
""""""
return name in self.__map
def __getitem__(self, key):
""""""
Return a member by name or index, or return a slice of members.
:param key: The name or index of a member, or a slice object.
""""""
if isinstance(key, basestring):
return self.__map[key]
if type(key) in (int, slice):
return self.__members[key]
raise TypeError(
TYPE_ERROR % ('key', (str, int, slice), key, type(key))
)
def __repr__(self):
""""""
Return a pseudo-valid expression that could create this instance.
""""""
cnt = len(self)
if cnt == 1:
m = 'member'
else:
m = 'members'
return '%s(<%d %s>, sort=%r)' % (
self.__class__.__name__,
cnt,
m,
self.__sort,
)
def __todict__(self):
""""""
Return a copy of the private dict mapping member name to member.
""""""
return dict(self.__map)
",1
"er):
""""""Add CLI options related to Testimony token based mark collection""""""
parser.addoption(
'--importance',
help='Comma separated list of importance levels to include in test collection',
)
parser.addoption(
'--component',
help='Comma separated list of component names to include in test collection',
)
parser.addoption(
'--assignee',
help='Comma separated list of assignees to include in test collection',
)
def pytest_configure(config):
""""""Register markers related to testimony tokens""""""
for marker in [
'importance: CaseImportance testimony token, use --importance to filter',
'component: Component testimony token, use --component to filter',
'assignee: Assignee testimony token, use --assignee to filter',
]:
config.addinivalue_line(""markers"", marker)
component_regex = re.compile(
# To match :CaseComponent: FooBar
r'\s*:CaseComponent:\s*(?P\S*)',
re.IGNORECASE,
)
importance_regex = re.compile(
# To match :CaseImportance: Critical
r'\s*:CaseImportance:\s*(?P\S*)',
re.IGNORECASE,
)
assignee_regex = re.compile(
# To match :Assignee: jsmith
r'\s*:Assignee:\s*(?P\S*)',
re.IGNORECASE,
)
@pytest.hookimpl(tryfirst=True)
def pytest_collection_modifyitems(session, items, config):
""""""Add markers for testimony tokens""""""
# split the option string and handle no option, single option, multiple
# config.getoption(default) doesn't work like you think it does, hence or ''
importance = [i for i in (config.getoption('importance') or '').split(',') if i != '']
component = [c for c in (config.getoption('component') or '').split(',') if c != '']
assignee = [a for a in (config.getoption('assignee') or '').split(',') if a != '']
selected = []
deselected = []
logger.info('Processing test items to add testimony token markers')
for item in items:
if item.nodeid.startswith('tests/robottelo/'):
# Unit test, no testimony markers
continue
# apply the marks for importance, component, and assignee
# Find matches from docstrings starting at smallest scope
item_docstrings = [
d
for d in map(inspect.getdoc, (item.function, getattr(item, 'cls', None), item.module))
if d is not None
]
item_mark_names = [m.name for m in item.iter_markers()]
for docstring in item_docstrings:
# Add marker starting at smallest docstring scope
# only add the mark if it hasn't already been applied at a lower scope
doc_component = component_regex.findall(docstring)
if doc_component and 'component' not in item_mark_names:
item.add_marker(pytest.mark.component(doc_component[0]))
doc_importance = importance_regex.findall(docstring)
if doc_importance and 'importance' not in item_mark_names:
item.add_marker(pytest.mark.importance(doc_importance[0]))
doc_assignee = assignee_regex.findall(docstring)
if doc_assignee and 'assignee' not in item_mark_names:
item.add_marker(pytest.mark.assignee(doc_assignee[0]))
# exit early if no filters were passed
if importance or component or assignee:
# Filter test collection based on CLI options for filtering
# filters should be applied together
# such that --component Repository --importance Critical --assignee jsmith
# only collects tests which have all three of these marks
# https://github.com/pytest-dev/pytest/issues/1373 Will make this way easier
# testimony requires both importance and component, this will blow up if its forgotten
importance_marker = item.get_closest_marker('importance').args[0]
if importance and importance_marker not in importance:
logger.debug(
f'Deselected test {item.nodeid} due to ""--importance {importance}"",'
f'test has importance mark: {importance_marker}'
)
deselected.append(item)
continue
component_marker = item.get_closest_marker('component').args[0]
if component and component_marker not in component:
logger.debug(
f'Deselected test {item.nodeid} due to ""--component {component}"",'
f'test has component mark: {component_marker}'
)
deselected.append(item)
continue
assignee_marker = item.get_closest_marker('assignee').args[0]
if assignee and assignee_marker not in assignee:
logger.debug(
f'Deselected test {item.nodeid} due to ""--assignee {assignee}"",'
f'test has assignee mark: {assignee_marker}'
)
deselected.append(item)
continue
selected.append(item)
# selected will be empty if no filter option was passed, defaulting to full items list
items[:] = selected if deselected else items
config.hook.pytest_deselected(items=deselected)
",1
"altura)/2
print result2
def cast():
lista=[1,2,3,""hola""]
tupla=(1,2,3)
diccinario={""key1"":""Diego"",""key2"":""Piqui"",""key3"":""Chuy""}
for k,v in diccionario:
print ""%s %s"" % (k,v)
class Estudiante(object):
def __init__(self, nombre, edad):
self.nombre=nombre
self.edad=edad
def hola(self):
return self.nombre
def esMayor(self):
if self.edad>=18:
return true
else:
return false
def EXCEPTION():
try:
3/0
except Exception:
print ""error""
def main():
e=Estudiante(""Diego"",22)
print""Hola %s"" % e.hola()
if e.esMayor():
print""Es mayor de edad""
else:
print""Es menor de edad""
contador = 0
while contador <=10:
print contador
contador +=1
EXCEPTION():
def getWeb():
try:
web=urllib2.urlopen(""http://itjiquilpan.edu.mx/"")
print web.read()
web.close()
except urllib2.HTTPError, e:
print e
except urllib2.URLError as e:
print e
def main():
cast()
if __name__==""__main__"":
main()
",1
"720 3.78326969 -0.00000000 -0.00000000 3.96610412 0.00000000 3.52668267 0.00000000 -0.00000000 -2.98430053 0.00000000 -0.00000000 0.00000000 -0.00000000 1.26744725 -0.00000000 2.16730601
1 1.43043000 0.00000000 1.10716000 0.33193836 -0.16057903 -0.00000000 -0.11299312 1.55235099 -0.00000000 1.15495299 0.60859677 -0.00000000 1.21104235 -4.46820475 0.00000000 -4.55909022 -0.05601735 0.00000000 -3.72029878 -0.00000000 0.46039909 -0.00000000 -2.40410436
1 -1.43043000 0.00000000 1.10716000 0.33193836 0.16057903 -0.00000000 -0.11299312 1.55235099 -0.00000000 -1.15495299 0.60859677 0.00000000 1.21104235 4.46820475 -0.00000000 -4.55909022 0.05601735 0.00000000 3.72029878 -0.00000000 0.46039909 -0.00000000 -2.40410436
Time used in Loprop : 0.45 (cpu) 0.11 (wall)
""""""
STR_BOND = """"""AU
5 1 22 1
1 0.00000000 0.00000000 0.00000000 -0.66387672 0.00000000 -0.00000000 0.41788500 1.19165567 0.00000000 0.00000000 2.74891057 0.00000000 1.33653383 0.00000000 0.00000000 4.18425484 0.00000000 -0.00000000 -0.00000000 -0.00000000 0.19037387 0.00000000 5.96033807
1 0.71521500 0.00000000 0.55358000 0.00000000 -0.06567795 -0.00000000 -0.07278780 2.59161403 -0.00000000 1.21719355 1.98015668 -0.00000000 2.19014883 -7.24839104 0.00000000 -7.16855538 0.59534043 0.00000000 -5.74640170 -0.00000000 1.07707338 -0.00000000 -3.79303206
1 1.43043000 0.00000000 1.10716000 0.33193836 -0.12774005 0.00000000 -0.07659922 0.25654398 0.00000000 0.16487465 -0.00000000 -0.00000000 0.11596794 -0.84400923 0.00000000 -0.97481253 -0.35368757 -0.00000000 -0.84709793 0.00000000 -0.07813759 0.00000000 -0.50758833
1 -0.71521500 0.00000000 0.55358000 0.00000000 0.06567795 -0.00000000 -0.07278780 2.59161403 -0.00000000 1.21719355 -1.98015668 0.00000000 2.19014883 7.24839104 -0.00000000 -7.16855538 -0.59534043 0.00000000 5.74640170 -0.00000000 1.07707338 -0.00000000 -3.79303206
1 -1.43043000 0.00000000 1.10716000 0.33193836 0.12774005 0.00000000 -0.07659922 0.25654398 -0.00000000 -0.16487465 0.00000000 0.00000000 0.11596794 0.84400923 -0.00000000 -0.97481253 0.35368757 0.00000000 0.84709793 -0.00000000 -0.07813759 -0.00000000 -0.50758833
Time used in Loprop : 0.45 (cpu) 0.11 (wall)
""""""
class TestBondH2O:
""""""H2O tests bonded versus non-bonden results""""""
def setup(self):
# Read in string that is for no bonds output
lines = [line for line in STR_BOND.split(""\n"") if len(line.split()) > 10]
a0 = 1.0
self.n_bond = np.array([8.0, 0.0, 1.0, 0.0, 1.0], dtype=float)
self.r_bond = a0 * np.array([l.split()[1:4] for l in lines], dtype=float)
self.q_bond = np.array([l.split()[4] for l in lines], dtype=float)
self.d_bond = np.array([l.split()[5:8] for l in lines], dtype=float)
self.a_bond = np.array([l.split()[8:15] for l in lines], dtype=float)
self.b_bond = np.array([l.split()[15:26] for l in lines], dtype=float)
self.coc_bond = np.einsum(""ij,i"", self.r_bond, self.n_bond) / self.n_bond.sum()
# Read in string that is for bonds output -b
lines = [line for line in STR_NOBOND.split(""\n"") if len(line.split()) > 10]
self.n_nobond = np.array([8.0, 1.0, 1.0], dtype=float)
self.r_nobond = a0 * np.array([l.split()[1:4] for l in lines], dtype=float)
self.q_nobond = np.array([l.split()[4] for l in lines], dtype=float)
self.d_nobond = np.array([l.split()[5:8] for l in lines], dtype=float)
self.a_nobond = np.array([l.split()[8:15] for l in lines], dtype=float)
self.b_nobond = np.array([l.split()[15:26] for l in lines], dtype=float)
self.coc_nobond = (
np.einsum(""ij,i"", self.r_nobond, self.n_nobond) / self.n_nobond.sum()
)
def test_bond_nobond_properties(self):
""""""Center-of-charge equality""""""
np.testing.assert_allclose(self.coc_bond, self.coc_nobond)
def test_a(self):
""""""Polarizability equality""""""
a_tot_bond = np.sum(self.a_bond)
a_tot_nobond = np.sum(self.a_nobond)
np.testing.assert_allclose(a_tot_bond, a_tot_nobond)
def test_b(self):
""""""Hyperpolarizability equality""""""
b_tot_bond = np.sum(self.b_bond)
b_tot_nobond = np.sum(self.b_nobond)
np.testing.assert_allclose(b_tot_bond, b_tot_nobond)
def test_dip(self):
""""""Dipole equality""""""
dip_bond = np.einsum(
""ij,i"", (self.r_bond - self.coc_bond), self.q_bond
) + self.d_bond.sum(axis=0)
dip_nobond = np.einsum(
""ij,i"", (self.r_nobond - self.coc_nobond), self.q_nobond
) + self.d_nobond.sum(axis=0)
np.testing.assert_allclose(dip_bond, dip_nobond)
class TestBondH2S:
""""""H2O tests bonded versus non-bonden results""""""
def setup(self):
# Read in string that is for no bonds output
lines = [line for line in STR_BOND.split(""\n"") if len(line.split()) > 10]
a0 = 1.0
self.n_bond = np.array([16.0, 0.0, 1.0, 0.0, 1.0], dtype=float)
self.r_bond = a0 * np.array([l.split()[1:4] for l in lines], dtype=float)
self.q_bond = np.array([l.split()[4] for l in lines], dtype=float)
self.d_bond = np.array([l.split()[5:8] for l in lines], dtype=float)
self.a_bond = np.array([l.split()[8:15] for l in lines], dtype=float)
self.b_bond = np.array([l.split()[15:26] for l in lines], dtype=float)
self.coc_bond = np.einsum(""ij,i"", self.r_bond, self.n_bond) / self.n_bond.sum()
# Read in string that is for bonds output -b
lines = [line for line in STR_NOBOND.split(""\n"") if len(line.split()) > 10]
self.n_nobond = np.array([16.0, 1.0, 1.0], dtype=float)
self.r_nobond = a0 * np.array([l.split()[1:4] for l in lines], dtype=float)
self.q_nobond = np.array([l.split()[4] for l in lines], dtype=float)
self.d_nobond = np.array([l.split()[5:8] for l in lines], dtype=float)
self.a_nobond = np.array([l.split()[8:15] for l in lines], dtype=float)
self.b_nobond = np.array([l.split()[15:26] for l in lines], dtype=float)
self.coc_nobond = (
np.einsum(""ij,i"", self.r_nobond, self.n_nobond) / self.n_nobond.sum()
)
def test_bond_nobond_properties(self):
""""""Center-of-charge equality""""""
np.testing.assert_allclose(self.coc_bond, self.coc_nobond)
def test_a(self):
""""""Polarizability equality""""""
a_tot_bond = np.sum(self.a_bond)
a_tot_nobond = np.sum(self.a_nobond)
np.testing.assert_allclose(a_tot_bond, a_tot_nobond)
def test_b(self):
""""""Hyperpolarizability equality""""""
b_tot_bond = np.sum(self.b_bond)
b_tot_nobond = np.sum(self.b_nobond)
np.testing.assert_allclose(b_tot_bond, b_tot_nobond)
def test_dip(self):
""""""Dipole equality""""""
dip_bond = np.einsum(
""ij,i"", (self.r_bond - self.coc_bond), self.q_bond
) + self.d_bond.sum(axis=0)
dip_nobond = np.einsum(
""ij,i"", (self.r_nobond - self.coc_nobond), self.q_nobond
) + self.d_nobond.sum(axis=0)
np.testing.assert_allclose(dip_bond, dip_nobond)
",1
"pher import decryptMessage
def main():
# 1. How many prime numbers are there?
# Hint: Check page 322
message = ""Iymdi ah rv urxxeqfi fjdjqv gu gzuqw clunijh."" # Encrypted with key ""PRIMES""
#print(decryptMessage(blank, blank)) # Fill in the blanks
# 2. What are integers that are not prime called?
# Hint: Check page 323
message = ""Vbmggpcw wlvx njr bhv pctqh emi psyzxf czxtrwdxr fhaugrd."" # Encrypted with key ""NOTCALLEDEVENS""
#print(decryptMessage(blank, blank)) # Fill in the blanks
# 3. What are two algorithms for finding prime numbers?
# Hint: Check page 323
# Encrypted with key ""ALGORITHMS""
message = ""Tsk hyzxl mdgzxwkpfz gkeo ob kpbz ngov gfv: bkpmd dtbwjqhu, eaegk cw Mkhfgsenseml, hzv Rlhwe-Ubsxwr.""
#print(decryptMessage(blank, blank)) # Fill in the blanks
# If PracticeQuestions.py is run (instead of imported as a module), call
# the main() function:
if __name__ == '__main__':
main()
",1
"turn {""type"": item_type, ""amount"": amount}
class SagaAPI(object):
secret = """"
episodeLengths = {}
apiUrl = """"
clientApi = """"
unlockLevelItemId = -1
unlockLevelImage = """"
debug = True
def __init__(self, session, userId):
self.session = session
self.userId = userId
def api_get(self, method, params):
response = requests.get(self.apiUrl + ""/"" + method, params=params)
if self.debug:
print self.apiUrl + ""/"" + method + ""\n""
print ""===============================\n""
print response.text
print ""\n""
return response
def hand_out_winnings(self, item_type, amount):
item = [
ApiItemAmount(item_type, amount)
]
params = {
""_session"": self.session,
""arg0"": json.dumps(item),
""arg1"": 1,
""arg2"": 1,
""arg3"": ""hash"",
}
return self.api_get(""handOutItemWinnings"", params)
# gets the balance of all the items that the player has
def get_balance(self):
params = {""_session"": self.session}
return self.api_get(""getBalance"", params)
def get_gameInitLight(self):
params = {""_session"": self.session}
return self.api_get(""gameInitLight"", params)
# full list with level details
def get_gameInit(self):
params = {""_session"": self.session}
return self.api_get(""gameInit"", params)
def add_life(self):
params = {""_session"": self.session}
return self.api_get(""addLife"", params)
def is_level_unlocked(self, episode, level):
params = {""_session"": self.session, ""arg0"": episode, ""arg1"": level}
response = self.api_get(""isLevelUnlocked"", params)
return response.text == ""true""
def poll_episodeChampions(self, episode):
params = {""_session"": self.session, ""arg0"": episode}
return self.api_get(""getEpisodeChampions"", params)
def poll_levelScores(self, episode, level):
params = {""_session"": self.session, ""arg0"": episode, ""arg1"": level}
return self.api_get(""getLevelToplist"", params)
def post_unlockLevel(self, episode, level):
params = {""_session"": self.session}
placement = ""Map,%s,%s"" % (episode, level)
payload = [{
""method"": ""ProductApi.purchase"",
""id"": 0,
""params"": [{
""imageUrl"": self.unlockLevelImage,
""orderItems"": [{
""productPackageType"": self.unlockLevelItemId,
""receiverCoreUserId"": self.userId
}],
""placement"": placement,
""title"": ""Level Unlock"",
""description"": ""Buy your way to the next level."",
""currency"": ""KHC""
}]
}]
unlockAttempt = requests.post(self.clientApi, verify=False, params=params, data=json.dumps(payload)).json()
if self.debug:
print json.dumps(unlockAttempt, sort_keys = False, indent = 4)
return unlockAttempt[0][""result""][""status""] == ""ok""
def start_game(self, episode, level):
params = {""_session"": self.session, ""arg0"": episode, ""arg1"": level}
return self.api_get(""gameStart"", params).json()[""seed""]
def end_game(self, episode, level, seed, score=None):
if score is None:
score = random.randrange(3000, 6000) * 100
dic = {
""timeLeftPercent"": -1,
""episodeId"": episode,
""levelId"": level,
""score"": score,
""variant"": 0,
""seed"": seed,
""reason"": 0,
""userId"": self.userId,
""secret"": self.secret
}
dic[""cs""] = hashlib.md5(""%(episodeId)s:%(levelId)s:%(score)s:%(timeLeftPercent)s:%(userId)s:%(seed)s:%(secret)s"" % dic).hexdigest()[:6]
params = {""_session"": self.session, ""arg0"": json.dumps(dic)}
return self.api_get(""gameEnd"", params)
def print_scores(self, episode, level):
scores = self.poll_levelScores(episode, level).json()
print json.dumps(scores.values()[0][0], sort_keys = False, indent = 4)
print json.dumps(scores.values()[0][1], sort_keys = False, indent = 4)
print json.dumps(scores.values()[0][2], sort_keys = False, indent = 4)
def print_status(self):
print json.dumps(self.poll_status().json(), sort_keys = False, indent = 4)
def complete_level(self, level):
targetEpisode, targetLevel = self.get_episode_level(level)
is_unlocked = self.is_level_unlocked(targetEpisode, targetLevel)
if not is_unlocked:
self.complete_level(level - 1)
response = self.play_game(targetEpisode, targetLevel).json()
if response[""episodeId""] == -1:
needUnlock = False
for event in response[""events""]:
if event[""type""] == ""LEVEL_LOCKED"":
needUnlock = True
break
if needUnlock:
self.post_unlockLevel(targetEpisode, targetLevel)
self.complete_level(level)
print ""Beat episode {0} level {1}"".format(targetEpisode, targetLevel)
def get_episode_level(self, level):
if len(self.episodeLengths) == 0:
response = self.get_gameInit()
episodeDescriptions = response.json()[""universeDescription""][""episodeDescriptions""]
for episode in episodeDescriptions:
self.episodeLengths[episode[""episodeId""]] = len(episode[""levelDescriptions""])
targetEpisode = -1
targetLevel = level
currentEpisode = 1
while targetEpisode == -1:
if targetLevel > self.episodeLengths[currentEpisode]:
targetLevel = targetLevel - self.episodeLengths[currentEpisode]
currentEpisode = currentEpisode + 1
else:
targetEpisode = currentEpisode
break
return targetEpisode, targetLevel
def play_gameAutoScore(self, episode, level, starProgressions=None):
if starProgressions is not None:
minPoints = starProgressions[""universeDescription""][""episodeDescriptions""][episode-1][""levelDescriptions""][level-1][""starProgressions""][2][""points""]
randomScore = 1
while (randomScore % 2 != 0):
# generate a random number at most 50000 points over the min 3 star and keep trying until it is even
randomScore = random.randrange(minPoints/10, minPoints/10+5000)
myScore = randomScore * 10
# print ""Score: %s out of %s"" % (myScore, minPoints)
else:
# revert to pulling the top scores. This probably won't work if none of your friends have made it to that level
scoreList = self.poll_levelScores(episode, level).json()
# take the top score and add 5000 points
myScore = scoreList.values()[0][0][""value""] + 5000
return self.play_game(episode, level, myScore)
def play_gameLoop(self, episode, level):
# create a JSON file full of tons and tons of data but only call it once since it is so large
starProgressions = self.get_gameInit().json()
while True:
try:
result = self.play_gameAutoScore(episode, level, starProgressions).json()
try:
# This is not quite right but it works since LEVEL_GOLD_REWARD still has a episodeId and levelId like LEVEL_UNLOCKED
# This only beats new levels that reported back the new unlocked level
data = json.loads(result[""events""][0].values()[2])
data[""episodeId""]
data[""levelId""]
level = level + 1
except KeyError:
print ""Next level wasn't reported, Trying to unlock episode %s..."" % (episode+1)
self.post_unlockLevel(episode, level-1)
episode = episode + 1
level = 1
except:
print sys.exc_info()[0]
break
except IndexError:
print ""Next level wasn't reported, Trying to unlock episode %s..."" % (episode+1)
self.post_unlockLevel(episode, level-1)
episode = episode + 1
level = 1
except:
print sys.exc_info()[0]
break
def play_game(self, episode, level, score=None):
seed = self.start_game(episode, level)
return self.end_game(episode, level, seed, score)",1
"rho_gas = 2080.
# Expected outputs... BRINE case
vp_brine = 2850.5
vs_brine = 1416.1
rho_brine = 2210.0
phi = 0.275 # Don't know this... reading from fig
rhohc = 250.0 # gas
rhow = 1040.0 # brine
sw = 0.3 # Don't know this... just guessing
swnew = 1.0 # Don't know this... just guessing
khc = 207000000.0 # gas
kw = 2950000000.0 # brine
kclay = 25000000000.0
kqtz = 37000000000.0
vclay = 0.05
kmin = 36266406250.0 # Don't know this... reading from fig
class FluidsubTest(unittest.TestCase):
""""""
Tests fluid sub calculations against Smith et al 2003.
https://dl.dropboxusercontent.com/u/14965965/Smith_etal_2003.pdf
""""""
def test_avseth(self):
# Base case: gas
# Subbing with: brine
sub = fluidsub.avseth_fluidsub(vp=vp_gas,
vs=vs_gas,
rho=rho_gas,
phi=phi,
rhof1=rhohc,
rhof2=rhow,
kmin=37000000000,
kf1=khc,
kf2=kw)
self.assertAlmostEqual(sub[0], vp_brine, places=-1) # Cannot match :(
self.assertAlmostEqual(sub[1], vs_brine, places=-1) # Cannot match :(
self.assertAlmostEqual(sub[2], rho_brine, places=-1) # Cannot match :(
def test_smith(self):
# Base case: gas
# Subbing with: brine
sub = fluidsub.smith_fluidsub(vp=vp_gas,
vs=vs_gas,
rho=rho_gas,
phi=phi,
rhohc=rhohc,
rhow=rhow,
sw=sw,
swnew=swnew,
khc=khc,
kw=kw,
kclay=kclay,
kqtz=kqtz,
vclay=vclay)
self.assertAlmostEqual(sub[0], vp_brine, places=-1)
self.assertAlmostEqual(sub[1], vs_brine, places=-1)
self.assertAlmostEqual(sub[2], rho_brine, places=-1) # Cannot match :(
if __name__ == '__main__':
suite = unittest.TestLoader().loadTestsFromTestCase(FluidsubTest)
unittest.TextTestRunner(verbosity=2).run(suite)
",1
" #
# Copyright 2012 Vincent Jacques #
# Copyright 2012 Zearin #
# Copyright 2013 AKFish #
# Copyright 2013 Bill Mill #
# Copyright 2013 Vincent Jacques #
# Copyright 2013 davidbrai #
# #
# This file is part of PyGithub. http://jacquev6.github.com/PyGithub/ #
# #
# PyGithub is free software: you can redistribute it and/or modify it under #
# the terms of the GNU Lesser General Public License as published by the Free #
# Software Foundation, either version 3 of the License, or (at your option) #
# any later version. #
# #
# PyGithub 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 Lesser General Public License for more #
# details. #
# #
# You should have received a copy of the GNU Lesser General Public License #
# along with PyGithub. If not, see `_.
You can simply enumerate through instances of this class::
for repo in user.get_repos():
print repo.name
You can also index them or take slices::
second_repo = user.get_repos()[1]
first_repos = user.get_repos()[:10]
If you want to iterate in reversed order, just do::
for repo in user.get_repos().reversed:
print repo.name
And if you really need it, you can explicitely access a specific page::
some_repos = user.get_repos().get_page(0)
some_other_repos = user.get_repos().get_page(3)
""""""
def __init__(self, contentClass, requester, firstUrl, firstParams, headers=None):
PaginatedListBase.__init__(self)
self.__requester = requester
self.__contentClass = contentClass
self.__firstUrl = firstUrl
self.__firstParams = firstParams or ()
self.__nextUrl = firstUrl
self.__nextParams = firstParams or {}
self.__headers = headers
if self.__requester.per_page != 30:
self.__nextParams[""per_page""] = self.__requester.per_page
self._reversed = False
self.__totalCount = None
@property
def totalCount(self):
if not self.__totalCount:
self._grow()
return self.__totalCount
def _getLastPageUrl(self):
headers, data = self.__requester.requestJsonAndCheck(
""GET"",
self.__firstUrl,
parameters=self.__nextParams,
headers=self.__headers
)
links = self.__parseLinkHeader(headers)
lastUrl = links.get(""last"")
return lastUrl
@property
def reversed(self):
r = PaginatedList(self.__contentClass, self.__requester, self.__firstUrl, self.__firstParams)
r.__reverse()
return r
def __reverse(self):
self._reversed = True
lastUrl = self._getLastPageUrl()
if lastUrl:
self.__nextUrl = lastUrl
def _couldGrow(self):
return self.__nextUrl is not None
def _fetchNextPage(self):
headers, data = self.__requester.requestJsonAndCheck(
""GET"",
self.__nextUrl,
parameters=self.__nextParams,
headers=self.__headers
)
data = data if data else []
self.__nextUrl = None
if len(data) > 0:
links = self.__parseLinkHeader(headers)
if self._reversed:
if ""prev"" in links:
self.__nextUrl = links[""prev""]
elif ""next"" in links:
self.__nextUrl = links[""next""]
self.__nextParams = None
if 'items' in data:
self.__totalCount = data['total_count']
data = data[""items""]
content = [
self.__contentClass(self.__requester, headers, element, completed=False)
for element in data if element is not None
]
if self._reversed:
return content[::-1]
return content
def __parseLinkHeader(self, headers):
links = {}
if ""link"" in headers:
linkHeaders = headers[""link""].split("", "")
for linkHeader in linkHeaders:
(url, rel) = linkHeader.split(""; "")
url = url[1:-1]
rel = rel[5:-1]
links[rel] = url
return links
def get_page(self, page):
params = dict(self.__firstParams)
if page != 0:
params[""page""] = page + 1
if self.__requester.per_page != 30:
params[""per_page""] = self.__requester.per_page
headers, data = self.__requester.requestJsonAndCheck(
""GET"",
self.__firstUrl,
parameters=params,
headers=self.__headers
)
if 'items' in data:
self.__totalCount = data['total_count']
data = data[""items""]
return [
self.__contentClass(self.__requester, headers, element, completed=False)
for element in data
]
",1
"ient = SC2CastsClient()
TEST_DATA_DIR = 'data'
# test cases:
def test_titles():
pass
# test cases:
def test_casts():
with open(TEST_DATA_DIR + '/all', 'r') as f:
test_data = f.read()
#print test_data
actual = parser.casts(test_data)
pprint(actual)
# TODO check each cast
# test cases:
# bo3 in 1 game
# 1 game
# 3 games
# 5 games
def test_games_bo3_in_1_game():
with open(TEST_DATA_DIR + '/cast14719-Soulkey-vs-Cure-Best-of-3-All-in-1-video-IEM-Cologne-2014-Korean-Qualifier', 'r') as f:
test_data = f.read()
#print test_data
actual = parser.games(test_data)
assert len(actual) == 1
assert actual[0]['game_id'] == 'Gt4E3rIUhoA'
assert actual[0]['game_title'] == 'Game 1'
# games 4 and 5 not played
def test_games_5_games():
with open(TEST_DATA_DIR + '/cast14705-KT-Rolster-vs-Prime-Best-of-5-2014-Proleague-Round-1', 'r') as f:
test_data = f.read()
#print test_data
actual = parser.games(test_data)
print actual
assert len(actual) == 5
assert actual[0]['game_id'] == 'QqSRtBVEXDs'
assert actual[0]['game_title'] == 'Game 1'
assert actual[1]['game_id'] == '5lFLuOKYTa8'
assert actual[1]['game_title'] == 'Game 2'
assert actual[2]['game_id'] == 'wNhcT-NenNs'
assert actual[2]['game_title'] == 'Game 3'
assert actual[3]['game_id'] == ''
assert actual[3]['game_title'] == 'Game 4'
assert actual[4]['game_id'] == ''
assert actual[4]['game_title'] == 'Game 5'
# test cases:
def test_events():
with open(TEST_DATA_DIR + '/browse', 'r') as f:
test_data = f.read()
actual = parser.events(test_data)
pprint(actual)
# test cases:
def test_casters():
with open(TEST_DATA_DIR + '/browse', 'r') as f:
test_data = f.read()
actual = parser.casters(test_data)
pprint(actual)
# test cases:
def test_matchups():
with open(TEST_DATA_DIR + '/browse', 'r') as f:
test_data = f.read()
actual = parser.matchups(test_data)
assert len(actual) == 6
# TODO test that the actual URLs are still valid
# client tests
def test_client_matchups():
actual = client.matchups()
assert len(actual) == 6
'''
",1
": %s) id %s. ppid %s' % (name, os.getpid(), os.getppid()))
time.sleep(3)
print(time.asctime(), 'child process end')
if __name__ == '__main__':
p = Process(target = proc, args = ('child',))
print(time.asctime(), 'child process will start')
p.start()
p.join()
print('first child process end')
pl = Pool(4)
for index in range(4):
pl.apply_async(proc, args = (index,))
pl.close()
pl.join()
print(time.asctime(), 'parent process end')
",1
"re; you can redistribute it and/or
## modify it under the terms of the GNU General Public License as
## published by the Free Software Foundation; either version 2 of the
## License, or (at your option) any later version.
##
## Invenio 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 Invenio; if not, write to the Free Software Foundation, Inc.,
## 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
""""""Unit tests for the ranking engine.""""""
__revision__ = ""$Id$""
from invenio.importutils import lazy_import
from invenio.testutils import make_test_suite, run_test_suite, InvenioTestCase
bibrank_tag_based_indexer = lazy_import('invenio.bibrank_tag_based_indexer')
split_ranges = lazy_import('invenio.bibrank:split_ranges')
class TestListSetOperations(InvenioTestCase):
""""""Test list set operations.""""""
def test_union_dicts(self):
""""""bibrank tag based indexer - union dicts""""""
self.assertEqual({1: 5, 2: 6, 3: 9, 4: 10, 10: 1}, bibrank_tag_based_indexer.union_dicts({1: 5, 2: 6, 3: 9}, {3:9, 4:10, 10: 1}))
def test_split_ranges(self):
""""""bibrank tag based indexer - split ranges""""""
self.assertEqual([[0, 500], [600, 1000]], split_ranges(""0-500,600-1000""))
TEST_SUITE = make_test_suite(TestListSetOperations,)
if __name__ == ""__main__"":
run_test_suite(TEST_SUITE)
",1
" ""input"": [5, -5],
""answer"": 10,
""explanation"": ""5-(-5)=10""
},
{
""input"": [10.2, -2.2, 0, 1.1, 0.5],
""answer"": 12.4,
""explanation"": ""10.2-(-2.2)=12.4""
},
{
""input"": [],
""answer"": 0,
""explanation"": ""Empty""
},
{""input"": [-99.9, 99.9],
""answer"": 199.8,
""explanation"": ""99.9-(-99.9)""},
{""input"": [1, 1],
""answer"": 0,
""explanation"": ""1-1""},
{""input"": [0, 0, 0, 0],
""answer"": 0,
""explanation"": ""0-0""},
{""input"": [36.0, -26.0, -7.5, 0.9, 0.53, -6.6, -71.0, 0.53, -48.0, 57.0, 69.0, 0.063, -4.7, 0.01, 9.2],
""answer"": 140.0,
""explanation"": ""69.0-(-71.0)""},
{""input"": [-0.035, 0.0, -0.1, 83.0, 0.28, 60.0],
""answer"": 83.1,
""explanation"": ""83.0-(-0.1)""},
{""input"": [0.02, 0.93, 0.066, -94.0, -0.91, -21.0, -7.2, -0.018, 26.0],
""answer"": 120.0,
""explanation"": ""26.0-(-94.0)""},
{""input"": [89.0, 0.014, 2.9, -1.2, 5.8],
""answer"": 90.2,
""explanation"": ""89.0-(-1.2)""},
{""input"": [-69.0, 0.0, 0.0, -0.051, -0.021, -0.81],
""answer"": 69.0,
""explanation"": ""0.0-(-69.0)""},
{""input"": [-0.07],
""answer"": 0.0,
""explanation"": ""-0.07-(-0.07)""},
{""input"": [0.074, 0.12, -0.4, 4.0, -1.7, 3.0, -5.1, 0.57, -54.0, -41.0, -5.2, -5.6, 3.8, 0.054, -35.0, -5.0,
-0.005, 0.034],
""answer"": 58.0,
""explanation"": ""4.0-(-54.0)""},
{""input"": [29.0, 0.47, -4.5, -6.7, -0.051, -0.82, -0.074, -4.0, -0.015, -0.015, -8.0, -0.43],
""answer"": 37.0,
""explanation"": ""29.0-(-8.0)""},
{""input"": [-0.036, -0.11, -0.55, -64.0],
""answer"": 63.964,
""explanation"": ""-0.036-(-64.0)""},
{""input"": [-0.092, -0.079, -0.31, -0.87, -28.0, -6.2, -0.097, -5.8, -0.025, -28.0, -4.7, -2.9, -8.0, -0.093,
-13.0, -73.0],
""answer"": 72.975,
""explanation"": ""-0.025-(-73.0)""},
{""input"": [-0.015, 7.6],
""answer"": 7.615,
""explanation"": ""7.6-(-0.015)""},
{""input"": [-46.0, 0.19, -0.08, -4.0, 4.4, 0.071, -0.029, -0.034, 28.0, 0.043, -97.0],
""answer"": 125.0,
""explanation"": ""28.0-(-97.0)""},
{""input"": [32.0, -0.07, -0.056, -6.4, 0.084],
""answer"": 38.4,
""explanation"": ""32.0-(-6.4)""},
{""input"": [0.017, 0.015, 0.69, 0.78],
""answer"": 0.765,
""explanation"": ""0.78-0.015""},
]
}
",1
"Case):
def setUp(self):
self.test_file = test_file = pysal.examples.get_path('ohio.swm')
self.obj = ArcGISSwmIO(test_file, 'r')
def test_close(self):
f = self.obj
f.close()
self.failUnlessRaises(ValueError, f.read)
def test_read(self):
w = self.obj.read()
self.assertEqual(88, w.n)
self.assertEqual(5.25, w.mean_neighbors)
self.assertEqual([1.0, 1.0, 1.0, 1.0], w[1].values())
def test_seek(self):
self.test_read()
self.failUnlessRaises(StopIteration, self.obj.read)
self.obj.seek(0)
self.test_read()
def test_write(self):
w = self.obj.read()
f = tempfile.NamedTemporaryFile(
suffix='.swm', dir=pysal.examples.get_path(''))
fname = f.name
f.close()
o = pysal.open(fname, 'w')
o.write(w)
o.close()
wnew = pysal.open(fname, 'r').read()
self.assertEqual(wnew.pct_nonzero, w.pct_nonzero)
os.remove(fname)
if __name__ == '__main__':
unittest.main()
",1
"All rights reserved.
#
# The full license is in the file LICENSE.txt, distributed with this software.
#-----------------------------------------------------------------------------
'''
'''
#-----------------------------------------------------------------------------
# Boilerplate
#-----------------------------------------------------------------------------
import logging # isort:skip
log = logging.getLogger(__name__)
#-----------------------------------------------------------------------------
# Imports
#-----------------------------------------------------------------------------
# Bokeh imports
from .notebook import run_notebook_hook
from .state import curstate
#-----------------------------------------------------------------------------
# Globals and constants
#-----------------------------------------------------------------------------
__all__ = (
'output_file',
'output_notebook',
'reset_output',
)
#-----------------------------------------------------------------------------
# General API
#-----------------------------------------------------------------------------
def output_file(filename, title=""Bokeh Plot"", mode=None, root_dir=None):
'''Configure the default output state to generate output saved
to a file when :func:`show` is called.
Does not change the current ``Document`` from ``curdoc()``. File and notebook
output may be active at the same time, so e.g., this does not clear the
effects of ``output_notebook()``.
Args:
filename (str) : a filename for saving the HTML document
title (str, optional) : a title for the HTML document (default: ""Bokeh Plot"")
mode (str, optional) : how to include BokehJS (default: ``'cdn'``)
One of: ``'inline'``, ``'cdn'``, ``'relative(-dev)'`` or
``'absolute(-dev)'``. See :class:`bokeh.resources.Resources` for more details.
root_dir (str, optional) : root directory to use for 'absolute' resources. (default: None)
This value is ignored for other resource types, e.g. ``INLINE`` or
``CDN``.
Returns:
None
.. note::
Generally, this should be called at the beginning of an interactive
session or the top of a script.
.. warning::
This output file will be overwritten on every save, e.g., each time
show() or save() is invoked.
'''
curstate().output_file(
filename,
title=title,
mode=mode,
root_dir=root_dir
)
def output_notebook(resources=None, verbose=False, hide_banner=False, load_timeout=5000, notebook_type='jupyter'):
''' Configure the default output state to generate output in notebook cells
when :func:`show` is called. Note that, :func:`show` may be called multiple
times in a single cell to display multiple objects in the output cell. The
objects will be displayed in order.
Args:
resources (Resource, optional) :
How and where to load BokehJS from (default: CDN)
verbose (bool, optional) :
whether to display detailed BokehJS banner (default: False)
hide_banner (bool, optional):
whether to hide the Bokeh banner (default: False)
load_timeout (int, optional) :
Timeout in milliseconds when plots assume load timed out (default: 5000)
notebook_type (string, optional):
Notebook type (default: jupyter)
Returns:
None
.. note::
Generally, this should be called at the beginning of an interactive
session or the top of a script.
'''
# verify notebook_type first in curstate().output_notebook
curstate().output_notebook(notebook_type)
run_notebook_hook(notebook_type, 'load', resources, verbose, hide_banner, load_timeout)
def reset_output(state=None):
''' Clear the default state of all output modes.
Returns:
None
'''
curstate().reset()
#-----------------------------------------------------------------------------
# Dev API
#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------
# Private API
#-----------------------------------------------------------------------------
#-----------------------------------------------------------------------------
# Code
#-----------------------------------------------------------------------------
",1
" is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys
import os
import shlex
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#sys.path.insert(0, os.path.abspath('.'))
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
'sphinx.ext.autodoc',
'sphinx.ext.todo',
'sphinx.ext.pngmath',
'sphinx.ext.ifconfig',
'sphinx.ext.viewcode',
]
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
# source_suffix = ['.rst', '.md']
source_suffix = '.rst'
# The encoding of source files.
#source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u'last_letter'
copyright = u'2014, George Zogopoulos - Papaliakos'
author = u'George Zogopoulos - Papaliakos'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = '0.5'
# The full version, including alpha/beta/rc tags.
release = '0.5'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set ""language"" from the command line for these cases.
language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = []
# The reST default role (used for this markup: `text`) to use for all
# documents.
#default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []
# If true, keep warnings as ""system message"" paragraphs in the built documents.
#keep_warnings = False
# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = True
# -- Options for HTML output ----------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme = 'sphinx_rtd_theme'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
html_theme_path = [""_static/themes"", ]
# The name for this set of Sphinx documents. If None, it defaults to
# "" v documentation"".
#html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
#html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named ""default.css"" will overwrite the builtin ""default.css"".
html_static_path = ['_static']
# Add any extra paths that contain custom files (such as robots.txt or
# .htaccess) here, relative to this directory. These files are copied
# directly to the root of the documentation.
#html_extra_path = []
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
html_domain_indices = False
# If false, no index is generated.
html_use_index = False
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
html_show_sourcelink = False
# If true, ""Created using Sphinx"" is shown in the HTML footer. Default is True.
html_show_sphinx = False
# If true, ""(C) Copyright ..."" is shown in the HTML footer. Default is True.
html_show_copyright = False
# If true, an OpenSearch description file will be output, and all pages will
# contain a tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. "".xhtml"").
#html_file_suffix = None
# Language to be used for generating the HTML full-text search index.
# Sphinx supports the following languages:
# 'da', 'de', 'en', 'es', 'fi', 'fr', 'hu', 'it', 'ja'
# 'nl', 'no', 'pt', 'ro', 'ru', 'sv', 'tr'
#html_search_language = 'en'
# A dictionary with options for the search language support, empty by default.
# Now only 'ja' uses this config value
#html_search_options = {'type': 'default'}
# The name of a javascript file (relative to the configuration directory) that
# implements a search results scorer. If empty, the default will be used.
#html_search_scorer = 'scorer.js'
# Output file base name for HTML help builder.
htmlhelp_basename = 'last_letter_doc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#'preamble': '',
# Latex figure (float) alignment
#'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, 'last_letter.tex', u'last_letter Documentation',
u'George Zogopoulos - Papaliakos', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
#latex_logo = None
# For ""manual"" documents, if this is true, then toplevel headings are parts,
# not chapters.
#latex_use_parts = False
# If true, show page references after internal links.
#latex_show_pagerefs = False
# If true, show URL addresses after external links.
#latex_show_urls = False
# Documents to append as an appendix to all manuals.
#latex_appendices = []
# If false, no module index is generated.
#latex_domain_indices = True
# -- Options for manual page output ---------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
(master_doc, 'last_letter', u'last_letter Documentation',
[author], 1)
]
# If true, show URL addresses after external links.
#man_show_urls = False
# -- Options for Texinfo output -------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(master_doc, 'last_letter', u'last_letter Documentation',
author, 'last_letter', 'A collection of ROS packages for UAV simulation and autopilot development.',
'Miscellaneous'),
]
# Documents to append as an appendix to all manuals.
#texinfo_appendices = []
# If false, no module index is generated.
#texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#texinfo_show_urls = 'footnote'
# If true, do not generate a @detailmenu in the ""Top"" node's menu.
#texinfo_no_detailmenu = False
# -- Options for Epub output ----------------------------------------------
# Bibliographic Dublin Core info.
epub_title = project
epub_author = author
epub_publisher = author
epub_copyright = copyright
# The basename for the epub file. It defaults to the project name.
#epub_basename = project
# The HTML theme for the epub output. Since the default themes are not optimized
# for small screen space, using the same theme for HTML and epub output is
# usually not wise. This defaults to 'epub', a theme designed to save visual
# space.
#epub_theme = 'epub'
# The language of the text. It defaults to the language option
# or 'en' if the language is not set.
#epub_language = ''
# The scheme of the identifier. Typical schemes are ISBN or URL.
#epub_scheme = ''
# The unique identifier of the text. This can be a ISBN number
# or the project homepage.
#epub_identifier = ''
# A unique identification for the text.
#epub_uid = ''
# A tuple containing the cover image and cover page html template filenames.
#epub_cover = ()
# A sequence of (type, uri, title) tuples for the guide element of content.opf.
#epub_guide = ()
# HTML files that should be inserted before the pages created by sphinx.
# The format is a list of tuples containing the path and title.
#epub_pre_files = []
# HTML files shat should be inserted after the pages created by sphinx.
# The format is a list of tuples containing the path and title.
#epub_post_files = []
# A list of files that should not be packed into the epub file.
epub_exclude_files = ['search.html']
# The depth of the table of contents in toc.ncx.
#epub_tocdepth = 3
# Allow duplicate toc entries.
#epub_tocdup = True
# Choose between 'default' and 'includehidden'.
#epub_tocscope = 'default'
# Fix unsupported image types using the Pillow.
#epub_fix_images = False
# Scale large images.
#epub_max_image_width = 0
# How to display URL addresses: 'footnote', 'no', or 'inline'.
#epub_show_urls = 'inline'
# If false, no index is generated.
#epub_use_index = True
",1
"_order = preorder.split(',')
stack = []
for node in arr_pre_order:
stack.append(node)
while len(stack) > 1 and stack[-1] == '#' and stack[-2] == '#':
stack.pop()
stack.pop()
if len(stack) < 1:
return False
stack[-1] = '#'
if len(stack) == 1 and stack[0] == '#':
return True
return False
",1
"go.db import models, connections, transaction
from django.urls import reverse
from django_tenants.clone import CloneSchema
from .postgresql_backend.base import _check_schema_name
from .signals import post_schema_sync, schema_needs_to_be_sync
from .utils import get_creation_fakes_migrations, get_tenant_base_schema
from .utils import schema_exists, get_tenant_domain_model, get_public_schema_name, get_tenant_database_alias
class TenantMixin(models.Model):
""""""
All tenant models must inherit this class.
""""""
auto_drop_schema = False
""""""
USE THIS WITH CAUTION!
Set this flag to true on a parent class if you want the schema to be
automatically deleted if the tenant row gets deleted.
""""""
auto_create_schema = True
""""""
Set this flag to false on a parent class if you don't want the schema
to be automatically created upon save.
""""""
schema_name = models.CharField(max_length=63, unique=True, db_index=True,
validators=[_check_schema_name])
domain_url = None
""""""
Leave this as None. Stores the current domain url so it can be used in the logs
""""""
domain_subfolder = None
""""""
Leave this as None. Stores the subfolder in subfolder routing was used
""""""
_previous_tenant = []
class Meta:
abstract = True
def __enter__(self):
""""""
Syntax sugar which helps in celery tasks, cron jobs, and other scripts
Usage:
with Tenant.objects.get(schema_name='test') as tenant:
# run some code in tenant test
# run some code in previous tenant (public probably)
""""""
connection = connections[get_tenant_database_alias()]
self._previous_tenant.append(connection.tenant)
self.activate()
return self
def __exit__(self, exc_type, exc_val, exc_tb):
connection = connections[get_tenant_database_alias()]
connection.set_tenant(self._previous_tenant.pop())
def activate(self):
""""""
Syntax sugar that helps at django shell with fast tenant changing
Usage:
Tenant.objects.get(schema_name='test').activate()
""""""
connection = connections[get_tenant_database_alias()]
connection.set_tenant(self)
@classmethod
def deactivate(cls):
""""""
Syntax sugar, return to public schema
Usage:
test_tenant.deactivate()
# or simpler
Tenant.deactivate()
""""""
connection = connections[get_tenant_database_alias()]
connection.set_schema_to_public()
def save(self, verbosity=1, *args, **kwargs):
connection = connections[get_tenant_database_alias()]
is_new = self.pk is None
has_schema = hasattr(connection, 'schema_name')
if has_schema and is_new and connection.schema_name != get_public_schema_name():
raise Exception(""Can't create tenant outside the public schema. ""
""Current schema is %s."" % connection.schema_name)
elif has_schema and not is_new and connection.schema_name not in (self.schema_name, get_public_schema_name()):
raise Exception(""Can't update tenant outside it's own schema or ""
""the public schema. Current schema is %s.""
% connection.schema_name)
super().save(*args, **kwargs)
if has_schema and is_new and self.auto_create_schema:
try:
self.create_schema(check_if_exists=True, verbosity=verbosity)
post_schema_sync.send(sender=TenantMixin, tenant=self.serializable_fields())
except Exception:
# We failed creating the tenant, delete what we created and
# re-raise the exception
self.delete(force_drop=True)
raise
elif is_new:
# although we are not using the schema functions directly, the signal might be registered by a listener
schema_needs_to_be_sync.send(sender=TenantMixin, tenant=self.serializable_fields())
elif not is_new and self.auto_create_schema and not schema_exists(self.schema_name):
# Create schemas for existing models, deleting only the schema on failure
try:
self.create_schema(check_if_exists=True, verbosity=verbosity)
post_schema_sync.send(sender=TenantMixin, tenant=self.serializable_fields())
except Exception:
# We failed creating the schema, delete what we created and
# re-raise the exception
self._drop_schema()
raise
def serializable_fields(self):
"""""" in certain cases the user model isn't serializable so you may want to only send the id """"""
return self
def _drop_schema(self, force_drop=False):
"""""" Drops the schema""""""
connection = connections[get_tenant_database_alias()]
has_schema = hasattr(connection, 'schema_name')
if has_schema and connection.schema_name not in (self.schema_name, get_public_schema_name()):
raise Exception(""Can't delete tenant outside it's own schema or ""
""the public schema. Current schema is %s.""
% connection.schema_name)
if has_schema and schema_exists(self.schema_name) and (self.auto_drop_schema or force_drop):
self.pre_drop()
cursor = connection.cursor()
cursor.execute('DROP SCHEMA ""%s"" CASCADE' % self.schema_name)
def pre_drop(self):
""""""
This is a routine which you could override to backup the tenant schema before dropping.
:return:
""""""
def delete(self, force_drop=False, *args, **kwargs):
""""""
Deletes this row. Drops the tenant's schema if the attribute
auto_drop_schema set to True.
""""""
self._drop_schema(force_drop)
super().delete(*args, **kwargs)
def create_schema(self, check_if_exists=False, sync_schema=True,
verbosity=1):
""""""
Creates the schema 'schema_name' for this tenant. Optionally checks if
the schema already exists before creating it. Returns true if the
schema was created, false otherwise.
""""""
# safety check
connection = connections[get_tenant_database_alias()]
_check_schema_name(self.schema_name)
cursor = connection.cursor()
if check_if_exists and schema_exists(self.schema_name):
return False
fake_migrations = get_creation_fakes_migrations()
if sync_schema:
if fake_migrations:
# copy tables and data from provided model schema
base_schema = get_tenant_base_schema()
clone_schema = CloneSchema()
clone_schema.clone_schema(base_schema, self.schema_name)
call_command('migrate_schemas',
tenant=True,
fake=True,
schema_name=self.schema_name,
interactive=False,
verbosity=verbosity)
else:
# create the schema
cursor.execute('CREATE SCHEMA ""%s""' % self.schema_name)
call_command('migrate_schemas',
tenant=True,
schema_name=self.schema_name,
interactive=False,
verbosity=verbosity)
connection.set_schema_to_public()
def get_primary_domain(self):
""""""
Returns the primary domain of the tenant
""""""
try:
domain = self.domains.get(is_primary=True)
return domain
except get_tenant_domain_model().DoesNotExist:
return None
def reverse(self, request, view_name):
""""""
Returns the URL of this tenant.
""""""
http_type = 'https://' if request.is_secure() else 'http://'
domain = get_current_site(request).domain
url = ''.join((http_type, self.schema_name, '.', domain, reverse(view_name)))
return url
def get_tenant_type(self):
""""""
Get the type of tenant. Will only work for multi type tenants
:return: str
""""""
return getattr(self, settings.MULTI_TYPE_DATABASE_FIELD)
class DomainMixin(models.Model):
""""""
All models that store the domains must inherit this class
""""""
domain = models.CharField(max_length=253, unique=True, db_index=True)
tenant = models.ForeignKey(settings.TENANT_MODEL, db_index=True, related_name='domains',
on_delete=models.CASCADE)
# Set this to true if this is the primary domain
is_primary = models.BooleanField(default=True, db_index=True)
@transaction.atomic
def save(self, *args, **kwargs):
# Get all other primary domains with the same tenant
domain_list = self.__class__.objects.filter(tenant=self.tenant, is_primary=True).exclude(pk=self.pk)
# If we have no primary domain yet, set as primary domain by default
self.is_primary = self.is_primary or (not domain_list.exists())
if self.is_primary:
# Remove primary status of existing domains for tenant
domain_list.update(is_primary=False)
super().save(*args, **kwargs)
class Meta:
abstract = True
",1
" 'wr': 4,
'te': 5,
}
def make_url(pos, wk):
ii = pos_idx_map[pos]
fstr = ""http://fantasydata.com/nfl-stats/nfl-fantasy-football-stats.aspx?fs=1&stype=0&sn=1&w=%s&s=&t=0&p=%s&st=FantasyPointsPPR&d=1&ls=&live=false"" \
% (wk, ii)
return fstr
def html2df(soup):
table = soup.find('table')
headers = [header.text.lower() for header in table.find_all('th')]
rows = []
for row in table.find_all('tr'):
rows.append([val.text.encode('utf8') for val in row.find_all('td')])
rows = [rr for rr in rows if len(rr) > 0]
df = pd.DataFrame.from_records(rows)
df.columns = headers
return df
def position_html_local(posn):
dflist = []
for ii in range(1, 17):
fname = '%s%s.html' % (posn, ii)
with open(fname) as f:
df = html2df(BeautifulSoup(f))
df['wk'] = ii
df.columns = header_clean(df.columns, posn)
dflist.append(df)
return pd.concat(dflist)
def position_html(posn):
dflist = []
for ii in range(1, 17):
fname = make_url(posn, ii)
df = html2df(BeautifulSoup(urlopen(fname)))
df['wk'] = ii
df.columns = header_clean(df.columns, posn)
dflist.append(df)
return pd.concat(dflist)
pos_header_suffixes = {
'qb': ['_pass', '_rush'],
'rb': ['_rush', '_recv'],
'wr': ['_recv'],
'te': ['_recv'],
}
exclude_cols = ['rk', 'player', 'team', 'pos', 'fantasy points',
'wk', 'fum', 'lost', 'qb rating']
def header_clean(header, posn):
res = []
if posn in pos_header_suffixes:
suffixes = pos_header_suffixes[posn]
seen_dict = {hh: 0 for hh in header}
for hh in header:
if not hh in exclude_cols:
hres = hh + suffixes[seen_dict[hh]]
seen_dict[hh] += 1
res.append(hres)
else:
res.append(hh)
else:
res = header
return res
if __name__ == '__main__':
data_all = {}
for pp in ['qb', 'wr', 'rb', 'te']:
data_all[pp] = position_html_local(pp)
data_all[pp].to_pickle('%s.pkl' % pp)
",1
"forms, with or without
# modification, are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# * Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
# * Neither the name of the copyright holder nor the names of its contributors
# may be used to endorse or promote products derived from this software without
# specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS"" AND
# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
from .fetchers import NUPermissionsFetcher
from .fetchers import NUMetadatasFetcher
from .fetchers import NUGlobalMetadatasFetcher
from bambou import NURESTObject
class NUVMResync(NURESTObject):
"""""" Represents a VMResync in the VSD
Notes:
Provide information about the state of a VM resync request.
""""""
__rest_name__ = ""resync""
__resource_name__ = ""resync""
## Constants
CONST_STATUS_IN_PROGRESS = ""IN_PROGRESS""
CONST_ENTITY_SCOPE_GLOBAL = ""GLOBAL""
CONST_STATUS_SUCCESS = ""SUCCESS""
CONST_ENTITY_SCOPE_ENTERPRISE = ""ENTERPRISE""
def __init__(self, **kwargs):
"""""" Initializes a VMResync instance
Notes:
You can specify all parameters while calling this methods.
A special argument named `data` will enable you to load the
object from a Python dictionary
Examples:
>>> vmresync = NUVMResync(id=u'xxxx-xxx-xxx-xxx', name=u'VMResync')
>>> vmresync = NUVMResync(data=my_dict)
""""""
super(NUVMResync, self).__init__()
# Read/Write Attributes
self._last_request_timestamp = None
self._last_time_resync_initiated = None
self._last_updated_by = None
self._last_updated_date = None
self._embedded_metadata = None
self._entity_scope = None
self._creation_date = None
self._status = None
self._owner = None
self._external_id = None
self.expose_attribute(local_name=""last_request_timestamp"", remote_name=""lastRequestTimestamp"", attribute_type=int, is_required=False, is_unique=False)
self.expose_attribute(local_name=""last_time_resync_initiated"", remote_name=""lastTimeResyncInitiated"", attribute_type=int, is_required=False, is_unique=False)
self.expose_attribute(local_name=""last_updated_by"", remote_name=""lastUpdatedBy"", attribute_type=str, is_required=False, is_unique=False)
self.expose_attribute(local_name=""last_updated_date"", remote_name=""lastUpdatedDate"", attribute_type=str, is_required=False, is_unique=False)
self.expose_attribute(local_name=""embedded_metadata"", remote_name=""embeddedMetadata"", attribute_type=list, is_required=False, is_unique=False)
self.expose_attribute(local_name=""entity_scope"", remote_name=""entityScope"", attribute_type=str, is_required=False, is_unique=False, choices=[u'ENTERPRISE', u'GLOBAL'])
self.expose_attribute(local_name=""creation_date"", remote_name=""creationDate"", attribute_type=str, is_required=False, is_unique=False)
self.expose_attribute(local_name=""status"", remote_name=""status"", attribute_type=str, is_required=False, is_unique=False, choices=[u'IN_PROGRESS', u'SUCCESS'])
self.expose_attribute(local_name=""owner"", remote_name=""owner"", attribute_type=str, is_required=False, is_unique=False)
self.expose_attribute(local_name=""external_id"", remote_name=""externalID"", attribute_type=str, is_required=False, is_unique=True)
# Fetchers
self.permissions = NUPermissionsFetcher.fetcher_with_object(parent_object=self, relationship=""child"")
self.metadatas = NUMetadatasFetcher.fetcher_with_object(parent_object=self, relationship=""child"")
self.global_metadatas = NUGlobalMetadatasFetcher.fetcher_with_object(parent_object=self, relationship=""child"")
self._compute_args(**kwargs)
# Properties
@property
def last_request_timestamp(self):
"""""" Get last_request_timestamp value.
Notes:
Time of the last timestamp received
This attribute is named `lastRequestTimestamp` in VSD API.
""""""
return self._last_request_timestamp
@last_request_timestamp.setter
def last_request_timestamp(self, value):
"""""" Set last_request_timestamp value.
Notes:
Time of the last timestamp received
This attribute is named `lastRequestTimestamp` in VSD API.
""""""
self._last_request_timestamp = value
@property
def last_time_resync_initiated(self):
"""""" Get last_time_resync_initiated value.
Notes:
Time that the resync was initiated
This attribute is named `lastTimeResyncInitiated` in VSD API.
""""""
return self._last_time_resync_initiated
@last_time_resync_initiated.setter
def last_time_resync_initiated(self, value):
"""""" Set last_time_resync_initiated value.
Notes:
Time that the resync was initiated
This attribute is named `lastTimeResyncInitiated` in VSD API.
""""""
self._last_time_resync_initiated = value
@property
def last_updated_by(self):
"""""" Get last_updated_by value.
Notes:
ID of the user who last updated the object.
This attribute is named `lastUpdatedBy` in VSD API.
""""""
return self._last_updated_by
@last_updated_by.setter
def last_updated_by(self, value):
"""""" Set last_updated_by value.
Notes:
ID of the user who last updated the object.
This attribute is named `lastUpdatedBy` in VSD API.
""""""
self._last_updated_by = value
@property
def last_updated_date(self):
"""""" Get last_updated_date value.
Notes:
Time stamp when this object was last updated.
This attribute is named `lastUpdatedDate` in VSD API.
""""""
return self._last_updated_date
@last_updated_date.setter
def last_updated_date(self, value):
"""""" Set last_updated_date value.
Notes:
Time stamp when this object was last updated.
This attribute is named `lastUpdatedDate` in VSD API.
""""""
self._last_updated_date = value
@property
def embedded_metadata(self):
"""""" Get embedded_metadata value.
Notes:
Metadata objects associated with this entity. This will contain a list of Metadata objects if the API request is made using the special flag to enable the embedded Metadata feature. Only a maximum of Metadata objects is returned based on the value set in the system configuration.
This attribute is named `embeddedMetadata` in VSD API.
""""""
return self._embedded_metadata
@embedded_metadata.setter
def embedded_metadata(self, value):
"""""" Set embedded_metadata value.
Notes:
Metadata objects associated with this entity. This will contain a list of Metadata objects if the API request is made using the special flag to enable the embedded Metadata feature. Only a maximum of Metadata objects is returned based on the value set in the system configuration.
This attribute is named `embeddedMetadata` in VSD API.
""""""
self._embedded_metadata = value
@property
def entity_scope(self):
"""""" Get entity_scope value.
Notes:
Specify if scope of entity is Data center or Enterprise level
This attribute is named `entityScope` in VSD API.
""""""
return self._entity_scope
@entity_scope.setter
def entity_scope(self, value):
"""""" Set entity_scope value.
Notes:
Specify if scope of entity is Data center or Enterprise level
This attribute is named `entityScope` in VSD API.
""""""
self._entity_scope = value
@property
def creation_date(self):
"""""" Get creation_date value.
Notes:
Time stamp when this object was created.
This attribute is named `creationDate` in VSD API.
""""""
return self._creation_date
@creation_date.setter
def creation_date(self, value):
"""""" Set creation_date value.
Notes:
Time stamp when this object was created.
This attribute is named `creationDate` in VSD API.
""""""
self._creation_date = value
@property
def status(self):
"""""" Get status value.
Notes:
Status of the resync
""""""
return self._status
@status.setter
def status(self, value):
"""""" Set status value.
Notes:
Status of the resync
""""""
self._status = value
@property
def owner(self):
"""""" Get owner value.
Notes:
Identifies the user that has created this object.
""""""
return self._owner
@owner.setter
def owner(self, value):
"""""" Set owner value.
Notes:
Identifies the user that has created this object.
""""""
self._owner = value
@property
def external_id(self):
"""""" Get external_id value.
Notes:
External object ID. Used for integration with third party systems
This attribute is named `externalID` in VSD API.
""""""
return self._external_id
@external_id.setter
def external_id(self, value):
"""""" Set external_id value.
Notes:
External object ID. Used for integration with third party systems
This attribute is named `externalID` in VSD API.
""""""
self._external_id = value
",1
"__ / / __/ ___/ ___/ __ `/_ / / _ \
# +------+ / /_/ / / /_/ /__/ / / /_/ / / /_/ __/
# || || /_____/_/\__/\___/_/ \__,_/ /___/\___/
#
# Copyright (C) 2014 Bitcraze AB
#
# Crazyflie Nano Quadcopter Client
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# 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, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
# MA 02110-1301, USA.
""""""
Find all the available input interfaces and try to initialize them.
""""""
import os
import glob
import logging
from ..inputreaderinterface import InputReaderInterface
__author__ = 'Bitcraze AB'
__all__ = ['InputInterface']
logger = logging.getLogger(__name__)
found_interfaces = [os.path.splitext(os.path.basename(f))[0] for f in
glob.glob(os.path.dirname(__file__) + ""/[A-Za-z]*.py"")]
if len(found_interfaces) == 0:
found_interfaces = [os.path.splitext(os.path.basename(f))[0] for
f in glob.glob(os.path.dirname(__file__) +
""/[A-Za-z]*.pyc"")]
logger.info(""Found interfaces: {}"".format(found_interfaces))
initialized_interfaces = []
available_interfaces = []
for interface in found_interfaces:
try:
module = __import__(interface, globals(), locals(), [interface], 1)
main_name = getattr(module, ""MODULE_MAIN"")
initialized_interfaces.append(getattr(module, main_name)())
logger.info(""Successfully initialized [{}]"".format(interface))
except Exception as e:
logger.info(""Could not initialize [{}]: {}"".format(interface, e))
def devices():
# Todo: Support rescanning and adding/removing devices
if len(available_interfaces) == 0:
for reader in initialized_interfaces:
devs = reader.devices()
for dev in devs:
available_interfaces.append(InputInterface(
dev[""name""], dev[""id""], reader))
return available_interfaces
class InputInterface(InputReaderInterface):
def __init__(self, dev_name, dev_id, dev_reader):
super(InputInterface, self).__init__(dev_name, dev_id, dev_reader)
# These devices cannot be mapped and configured
self.supports_mapping = False
# Ask the reader if it wants to limit
# roll/pitch/yaw/thrust for all devices
self.limit_rp = dev_reader.limit_rp
self.limit_thrust = dev_reader.limit_thrust
self.limit_yaw = dev_reader.limit_yaw
def open(self):
self._reader.open(self.id)
def close(self):
self._reader.close(self.id)
def read(self, include_raw=False):
mydata = self._reader.read(self.id)
# Merge interface returned data into InputReader Data Item
for key in list(mydata.keys()):
self.data.set(key, mydata[key])
return self.data
",1
"t.migrate import MigrateCommand
from foobar.app import create_app
from foobar.user.models import User
from foobar.settings import DevConfig, ProdConfig
from foobar.database import db
if os.environ.get(""FOOBAR_ENV"") == 'prod':
app = create_app(ProdConfig)
else:
app = create_app(DevConfig)
HERE = os.path.abspath(os.path.dirname(__file__))
TEST_PATH = os.path.join(HERE, 'tests')
manager = Manager(app)
def _make_context():
""""""Return context dict for a shell session so you can access
app, db, and the User model by default.
""""""
return {'app': app, 'db': db, 'User': User}
@manager.command
def test():
""""""Run the tests.""""""
import pytest
exit_code = pytest.main([TEST_PATH, '--verbose'])
return exit_code
manager.add_command('server', Server())
manager.add_command('shell', Shell(make_context=_make_context))
manager.add_command('db', MigrateCommand)
if __name__ == '__main__':
manager.run()
",1
"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.
#
# SickChill 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 SickChill. If not, see ', methods=['GET'])
@json_response
def get_got(bot_id):
""""""Get bot from database
**Example request**:
.. sourcecode:: http
GET /api/1.0/abusehelper/1 HTTP/1.1
Host: do.cert.europa.eu
Accept: application/json
**Example response**:
.. sourcecode:: http
HTTP/1.0 200 OK
Content-Type: application/json
{
""name"": ""ShadowServerBot"",
""url"": ""http://sample.com/path.html"",
""id"": 1
}
:param bot_id: Bot unique ID
:reqheader Accept: Content type(s) accepted by the client
:resheader Content-Type: this depends on `Accept` header or request
:>json integer id: Bot unique ID
:>json integer name: Bot name
:status 200: ASN found
:status 404: Resource not found
""""""
a = Bot.query.get_or_404(bot_id)
return a.serialize()
@api.route('/abusehelper', methods=['POST', 'PUT'])
@validate('abusehelper', 'add_bot')
@json_response
def add_bot():
""""""Add new bot entry
**Example request**:
.. sourcecode:: http
POST /api/1.0/abusehelper HTTP/1.1
Host: do.cert.europa.eu
Accept: application/json
Content-Type: application/json
{
""name"": ""ShadowServerBot"",
""url"": ""http://sample.com/path.html""
}
**Example response**:
.. sourcecode:: http
HTTP/1.0 201 CREATED
Content-Type: application/json
{
""bot"": {
""name"": ""ShadowServerBot"",
""url"": ""http://sample.com/path.html"",
""id"": 1
},
'message': ""Bot added""
}
:reqheader Accept: Content type(s) accepted by the client
:resheader Content-Type: this depends on `Accept` header or request
:jsonobj integer id: Unique ID of new bot
:>jsonobj integer name: bot name
:>json string message: Status message
:status 201: ASN successfully saved
:status 400: Bad request
""""""
a = Bot.fromdict(request.json)
db.session.add(a)
db.session.commit()
return {'bot': a.serialize(), 'message': 'Bot added'}, 201, \
{'Location': url_for('api.get_bot', bot_id=a.id)}
@api.route('/abusehelper/', methods=['PUT'])
@validate('abusehelper', 'update_bot')
@json_response
def update_bot(bot_id):
return NotImplemented
@api.route('/abusehelper/', methods=['DELETE'])
@json_response
def delete_bot(bot_id):
""""""Delete bot
**Example request**:
.. sourcecode:: http
DELETE /api/1.0/abusehelper/1 HTTP/1.1
Host: do.cert.europa.eu
Accept: application/json
**Example response**:
.. sourcecode:: http
HTTP/1.0 200 OK
Content-Type: application/json
{
""message"": ""Bot deleted""
}
:param bot_id: Bot unique ID.
:reqheader Accept: Content type(s) accepted by the client
:resheader Content-Type: this depends on `Accept` header or request
:>json string message: Action status status
:status 200: Bot was deleted
:status 404: Bot was not found
""""""
a = Bot.query.filter_by(id == bot_id).delete()
if not a:
return {'message': 'No such bot'}, 404
db.session.commit()
return {'message': 'Bot deleted'}
@api.route('/abusehelper', methods=['DELETE'])
@json_response
def delete_abusehelper():
""""""Clear abusehelper table
**Example request**:
.. sourcecode:: http
DELETE /api/1.0/abusehelper HTTP/1.1
Host: do.cert.europa.eu
Accept: application/json
**Example response**:
.. sourcecode:: http
HTTP/1.0 200 OK
Content-Type: application/json
{
""message"": ""Bots deleted""
}
:reqheader Accept: Content type(s) accepted by the client
:resheader Content-Type: this depends on `Accept` header or request
:>json string message: Action status status
:status 200: Bot was deleted
:status 404: Bot was not found
""""""
a = Bot.query.all().delete()
db.session.commit()
current_app.log.debug('Deleted {} abusehelper'.format(a))
return {'message': 'Bots deleted'}
",1
"f, date, life):
""""""Set birth datetime and life.""""""
self.birthdate = date
self.life = life
finalyear = self.birthdate.year + self.life
finaldate = datetime.datetime(finalyear, self.birthdate.month,
self.birthdate.day)
self.finaldate = finaldate - datetime.timedelta(days=1)
def now(self):
""""""Calculate current time.""""""
curdate = datetime.datetime.now()
maxdays = (self.finaldate - self.birthdate).days
curdays = (curdate - self.birthdate).days
curtime = datetime.timedelta(days=1) / maxdays
curtime = curtime * curdays
return datetime.time(
(curtime.seconds / 60) / 60,
(curtime.seconds / 60) % 60,
curtime.seconds % 60)
if __name__ == '__main__':
# options
startyear = 1900
endyear = 2000
life = 200
print startyear, ""<= a <="", endyear
print ""n ="", life
daycount = (datetime.datetime(endyear, 12, 31) -
datetime.datetime(startyear, 1, 1)).days
birthdate = datetime.datetime(startyear, 1, 1) + \
datetime.timedelta(days=random.randint(0, daycount))
args = sys.argv
if len(args) == 4:
year = int(args[1])
month = int(args[2])
date = int(args[3])
birthdate = datetime.datetime(year, month, date)
print ""birthdate:"", birthdate.date()
mylife = DayLife(birthdate, life)
print ""finaldate:"", mylife.finaldate.date()
print ""today:"", mylife.now()
",1
"ker/cy_data_validation"")
from datetime import time
from time_conv import Time
class TimeTestCase(unittest.TestCase):
''' Tests with numbered degrees of bad or good data, on a scale of 0=baddest to 10=goodest '''
def setUp(self):
self.time = Time.check_time("""")
# A string
def test_vbad0(self):
self.time = Time.check_time(""iutoeht"")
correct_time = time(00, 00, 00)
self.assertEqual( correct_time, self.time)
# An out of range whole number
def test_bad1(self):
self.time = Time.check_time(""52304"")
correct_time = time(00, 00, 00)
self.assertEqual( correct_time, self.time)
# Two out of range whole numbers
def test_bad2(self):
self.time = Time.check_time(""70 80"")
correct_time = time(23, 59, 00)
self.assertEqual( correct_time, self.time)
# hours, minutes and seconds formatted crap
def test_middle3(self):
self.time = Time.check_time(""03 - 32/74"")
correct_time = time(3, 32, 59)
self.assertEqual( correct_time, self.time)
# : in between hours and minutes
def test_good4(self):
self.time = Time.check_time(""03:32:50"")
correct_time = time(3, 32, 50)
self.assertEqual( correct_time, self.time)
# removing am or pm
def test_vgood5(self):
self.time = Time.check_time(""3:35pm"")
correct_time = time(15, 35, 00)
self.assertEqual( correct_time, self.time)
def tearDown(self):
self.time = """"
correct_time = """"
if __name__ == '__main__':
unittest.main()
",1
" tuple: (the substring of a path after the last nodeSeparator, the preceding path before it)
If 'base' includes its own baseSeparator - return only a string after it
So if a path is 'OU=Group,OU=Dept,OU=Company', the tuple result would be ('OU=Group,OU=Dept', 'Company')
""""""
node_separator = ','
base_separator = '='
node_base = path[path.rfind(node_separator) + 1:]
if path.find(node_separator) != -1:
node_preceding = path[:len(path) - len(node_base) - 1]
else:
node_preceding = ''
return (node_preceding, node_base[node_base.find(base_separator) + 1:])
def _place_user_onto_tree(user, usertree, user_groups):
""""""
Places a 'user' object on a 'usertree' object according to user's pathField string key
""""""
curr_node = usertree
# Decompose 'OU=Group,OU=Dept,OU=Company' into ('OU=Group,OU=Dept', 'Company')
preceding, base = _node_base_and_rest(user['distinguishedName'])
full_node_path = ''
# Place all path groups onto a tree starting from the outermost
while base != '':
node_found = False
full_node_path = 'OU=' + base + (',' if full_node_path != '' else '') + full_node_path
# Search for corresponding base element on current hierarchy level
for obj in curr_node:
if obj.get('text') == None:
continue
if obj['text'] == base:
node_found = True
curr_node = obj['children']
break
# Create a new group node
if not node_found:
curr_node.append({
'id': 'usergroup_' + str(user_groups[full_node_path]),
'text': base,
'objectType': 'UserGroup',
'children': []
})
curr_node = curr_node[len(curr_node) - 1]['children']
preceding, base = _node_base_and_rest(preceding)
curr_node.append({
'id': 'user_' + str(user['id']),
'text': user['cn'],
'leaf': True,
'iconCls': 'x-fa fa-user' if user['status'] == 1 else 'x-fa fa-user-times',
'objectType': 'User'
})
def _sort_tree(subtree, sort_field):
""""""
Sorts a subtree node by a sortField key of each element
""""""
# Sort eval function, first by group property, then by text
subtree['children'] = sorted(
subtree['children'],
key=lambda obj: (1 if obj.get('children') == None else 0, obj[sort_field]))
for tree_elem in subtree['children']:
if tree_elem.get('children') != None:
_sort_tree(tree_elem, sort_field)
def _collapse_terminal_nodes(subtree):
""""""
Collapses tree nodes which doesn't contain subgroups, just tree leaves
""""""
subtree_has_group_nodes = False
for tree_elem in subtree['children']:
if tree_elem.get('children') != None:
subtree_has_group_nodes = True
_collapse_terminal_nodes(tree_elem)
subtree['expanded'] = subtree_has_group_nodes
def _expand_all_nodes(subtree):
""""""
Expand all level nodes
""""""
for tree_elem in subtree['children']:
if tree_elem.get('children') != None:
_expand_all_nodes(tree_elem)
subtree['expanded'] = True
def _get_user_tree(current_user_properties, Session):
""""""
Build user tree
""""""
current_user_permissions = current_user_properties['user_permissions']
session = Session()
# Get all groups
query_result = session.query(UserGroup.id, UserGroup.distinguishedName).all()
user_groups = {}
for query_result_row in query_result:
user_groups[query_result_row.distinguishedName] = query_result_row.id
# Get all users if ViewUsers permission present
if next((item for item in current_user_permissions if item['permissionName'] == 'ViewUsers'), None) != None:
query_result = session.query(
User.id.label('user_id'), User.cn, User.status, UserGroup.id.label('usergroup_id'),
UserGroup.distinguishedName).join(UserGroup).filter(User.hidden == 0).all()
# Get just the requester otherwise
else:
query_result = session.query(
User.id.label('user_id'), User.cn, User.status, UserGroup.id.label('usergroup_id'),
UserGroup.distinguishedName).join(UserGroup).\
filter(User.id == current_user_properties['user_object']['id'], User.hidden == 0).all()
Session.remove()
# Future tree
user_tree = []
# Place each user on a tree
for query_result_row in query_result:
user_object = {
'id': query_result_row.user_id,
'distinguishedName': query_result_row.distinguishedName,
'status': query_result_row.status,
'cn': query_result_row.cn
}
_place_user_onto_tree(user_object, user_tree, user_groups)
user_tree = {
'id': 'usergroup_0',
'objectType': 'UserGroup',
'text': 'Пользователи',
'children': user_tree
}
# Sort tree elements
_sort_tree(user_tree, 'text')
# Collapse/expand tree nodes
if next((item for item in current_user_permissions if item['permissionName'] == 'ViewUsers'), None) != None:
_collapse_terminal_nodes(user_tree)
else:
_expand_all_nodes(user_tree)
return user_tree
def _get_url_lists(Session):
""""""
Get URL lists
""""""
session = Session()
# Get all urllists from DB
query_result = session.query(UrlList.id, UrlList.name, UrlList.whitelist).all()
Session.remove()
urllist_list = []
# Making a list of them
for query_result_row in query_result:
url_list_object = {
'id': 'urllist_' + str(query_result_row.id),
'text': query_result_row.name,
'leaf': True,
'iconCls': 'x-fa fa-unlock' if query_result_row.whitelist else 'x-fa fa-lock',
'objectType': 'UrlList'
}
urllist_list.append(url_list_object)
url_lists = {
'id': 'urllists',
'objectType': 'UrlLists',
'text': 'Списки URL',
'iconCls': 'x-fa fa-cog',
'children': urllist_list
}
# Sort tree elements
_sort_tree(url_lists, 'text')
return url_lists
def _get_acls(Session):
""""""
Get ACLs
""""""
session = Session()
# Get all access control lists from DB
query_result = session.query(Acl.id, Acl.name).all()
Session.remove()
acl_list = []
# Making a list of them
for query_result_row in query_result:
acl_object = {
'id': 'acl_' + str(query_result_row.id),
'text': query_result_row.name,
'leaf': True,
'iconCls': 'x-fa fa-filter',
'objectType': 'AclContents'
}
acl_list.append(acl_object)
acls = {
'id': 'acls',
'objectType': 'Acls',
'text': 'Списки доступа',
'iconCls': 'x-fa fa-cog',
'children': acl_list
}
# Sort tree elements
_sort_tree(acls, 'text')
return acls
def _get_roles(Session):
""""""
Get user roles
""""""
session = Session()
# Get all roles from DB
query_result = session.query(Role.id, Role.name).all()
Session.remove()
roles_list = []
# Making a list of them
for query_result_row in query_result:
role_object = {
'id': 'role_' + str(query_result_row.id),
'text': query_result_row.name,
'leaf': True,
'iconCls': 'x-fa fa-key',
'objectType': 'Role'
}
roles_list.append(role_object)
roles = {
'id': 'roles',
'objectType': 'Roles',
'text': 'Роли',
'iconCls': 'x-fa fa-cog',
'children': roles_list
}
# Sorting tree elements
_sort_tree(roles, 'text')
return roles
def select_tree(current_user_properties, node_name, Session):
url_lists_node = None
acls_node = None
roles_node = None
users_node = None
current_user_permissions = current_user_properties['user_permissions']
if next((item for item in current_user_permissions if item['permissionName'] == 'ViewSettings'), None) != None:
if node_name in ['root', 'urllists']:
url_lists_node = _get_url_lists(Session)
if node_name in ['root', 'acls']:
acls_node = _get_acls(Session)
if next((item for item in current_user_permissions if item['permissionName'] == 'ViewPermissions'), None) != None:
if node_name in ['root', 'roles']:
roles_node = _get_roles(Session)
if node_name in ['root']:
users_node = _get_user_tree(current_user_properties, Session)
if node_name == 'root':
children_list = []
if url_lists_node is not None:
children_list.append(url_lists_node)
if acls_node is not None:
children_list.append(acls_node)
if roles_node is not None:
children_list.append(roles_node)
if users_node is not None:
children_list.append(users_node)
result = {
'success': True,
'children': children_list
}
elif node_name == 'urllists':
if next((item for item in current_user_permissions if item['permissionName'] == 'ViewSettings'), None) != None:
result = {
'success': True,
'children': url_lists_node['children']
}
else:
return Response('Forbidden', 403)
elif node_name == 'acls':
if next((item for item in current_user_permissions if item['permissionName'] == 'ViewSettings'), None) != None:
result = {
'success': True,
'children': acls_node['children']
}
else:
return Response('Forbidden', 403)
elif node_name == 'roles':
if next((item for item in current_user_permissions if item['permissionName'] == 'ViewPermissions'), None) != None:
result = {
'success': True,
'children': roles_node['children']
}
else:
return Response('Forbidden', 403)
return jsonify(result)
",1
"l
from ..resources.resource import Resource
from ..resources.licenseinfo import LicenseInfo
from ...util import Util
import saklient
str = six.text_type
# module saklient.cloud.models.model_licenseinfo
class Model_LicenseInfo(Model):
## ライセンス種別情報を検索するための機能を備えたクラス。
## @private
# @return {str}
def _api_path(self):
return ""/product/license""
## @private
# @return {str}
def _root_key(self):
return ""LicenseInfo""
## @private
# @return {str}
def _root_key_m(self):
return ""LicenseInfo""
## @private
# @return {str}
def _class_name(self):
return ""LicenseInfo""
## @private
# @param {any} obj
# @param {bool} wrapped=False
# @return {saklient.cloud.resources.resource.Resource}
def _create_resource_impl(self, obj, wrapped=False):
Util.validate_type(wrapped, ""bool"")
return LicenseInfo(self._client, obj, wrapped)
## 次に取得するリストの開始オフセットを指定します。
#
# @param {int} offset オフセット
# @return {saklient.cloud.models.model_licenseinfo.Model_LicenseInfo} this
def offset(self, offset):
Util.validate_type(offset, ""int"")
return self._offset(offset)
## 次に取得するリストの上限レコード数を指定します。
#
# @param {int} count 上限レコード数
# @return {saklient.cloud.models.model_licenseinfo.Model_LicenseInfo} this
def limit(self, count):
Util.validate_type(count, ""int"")
return self._limit(count)
## Web APIのフィルタリング設定を直接指定します。
#
# @param {str} key キー
# @param {any} value 値
# @param {bool} multiple=False valueに配列を与え、OR条件で完全一致検索する場合にtrueを指定します。通常、valueはスカラ値であいまい検索されます。
# @return {saklient.cloud.models.model_licenseinfo.Model_LicenseInfo}
def filter_by(self, key, value, multiple=False):
Util.validate_type(key, ""str"")
Util.validate_type(multiple, ""bool"")
return self._filter_by(key, value, multiple)
## 次のリクエストのために設定されているステートをすべて破棄します。
#
# @return {saklient.cloud.models.model_licenseinfo.Model_LicenseInfo} this
def reset(self):
return self._reset()
## 指定したIDを持つ唯一のリソースを取得します。
#
# @param {str} id
# @return {saklient.cloud.resources.licenseinfo.LicenseInfo} リソースオブジェクト
def get_by_id(self, id):
Util.validate_type(id, ""str"")
return self._get_by_id(id)
## リソースの検索リクエストを実行し、結果をリストで取得します。
#
# @return {saklient.cloud.resources.licenseinfo.LicenseInfo[]} リソースオブジェクトの配列
def find(self):
return self._find()
## 指定した文字列を名前に含むリソースに絞り込みます。
#
# 大文字・小文字は区別されません。
# 半角スペースで区切られた複数の文字列は、それらをすべて含むことが条件とみなされます。
#
# @todo Implement test case
# @param {str} name
# @return {saklient.cloud.models.model_licenseinfo.Model_LicenseInfo}
def with_name_like(self, name):
Util.validate_type(name, ""str"")
return self._with_name_like(name)
## 名前でソートします。
#
# @todo Implement test case
# @param {bool} reverse=False
# @return {saklient.cloud.models.model_licenseinfo.Model_LicenseInfo}
def sort_by_name(self, reverse=False):
Util.validate_type(reverse, ""bool"")
return self._sort_by_name(reverse)
## @ignore
# @param {saklient.cloud.client.Client} client
def __init__(self, client):
super(Model_LicenseInfo, self).__init__(client)
Util.validate_type(client, ""saklient.cloud.client.Client"")
",1
"or t in range(-135, 135):
x = round(halfsize + halfsize * cos(pi * t / 180))
y = round(halfsize + halfsize * sin(pi * t / 180))
picture[x][y] = 1
zoomsz = 1 * halfsize
b = Glyph(['O', 0, 0, size, size, 0, 0, 0, 0, None])
b.set_pix(picture)
c = Glyph()
for t in range(0, 360, 15):
x = round(zoomsz + zoomsz * cos(pi * t / 180))
y = round(zoomsz + zoomsz * sin(pi * t / 180))
b.set_xy_wh((x, y, size, size))
c = c + b
print(b)
print(c)",1
" 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 nova websocketproxy.""""""
import mock
from nova.console import websocketproxy
from nova import exception
from nova import test
class NovaProxyRequestHandlerBaseTestCase(test.TestCase):
def setUp(self):
super(NovaProxyRequestHandlerBaseTestCase, self).setUp()
self.wh = websocketproxy.NovaProxyRequestHandlerBase()
self.wh.socket = mock.MagicMock()
self.wh.msg = mock.MagicMock()
self.wh.do_proxy = mock.MagicMock()
self.wh.headers = mock.MagicMock()
@mock.patch('nova.consoleauth.rpcapi.ConsoleAuthAPI.check_token')
def test_new_websocket_client(self, check_token):
check_token.return_value = {
'host': 'node1',
'port': '10000'
}
self.wh.socket.return_value = ''
self.wh.path = ""ws://127.0.0.1/?token=123-456-789""
self.wh.new_websocket_client()
check_token.assert_called_with(mock.ANY, token=""123-456-789"")
self.wh.socket.assert_called_with('node1', 10000, connect=True)
self.wh.do_proxy.assert_called_with('')
@mock.patch('nova.consoleauth.rpcapi.ConsoleAuthAPI.check_token')
def test_new_websocket_client_token_invalid(self, check_token):
check_token.return_value = False
self.wh.path = ""ws://127.0.0.1/?token=XXX""
self.assertRaises(exception.InvalidToken,
self.wh.new_websocket_client)
check_token.assert_called_with(mock.ANY, token=""XXX"")
@mock.patch('nova.consoleauth.rpcapi.ConsoleAuthAPI.check_token')
def test_new_websocket_client_novnc(self, check_token):
check_token.return_value = {
'host': 'node1',
'port': '10000'
}
self.wh.socket.return_value = ''
self.wh.path = ""http://127.0.0.1/""
self.wh.headers.getheader.return_value = ""token=123-456-789""
self.wh.new_websocket_client()
check_token.assert_called_with(mock.ANY, token=""123-456-789"")
self.wh.socket.assert_called_with('node1', 10000, connect=True)
self.wh.do_proxy.assert_called_with('')
@mock.patch('nova.consoleauth.rpcapi.ConsoleAuthAPI.check_token')
def test_new_websocket_client_novnc_token_invalid(self, check_token):
check_token.return_value = False
self.wh.path = ""http://127.0.0.1/""
self.wh.headers.getheader.return_value = ""token=XXX""
self.assertRaises(exception.InvalidToken,
self.wh.new_websocket_client)
check_token.assert_called_with(mock.ANY, token=""XXX"")
@mock.patch('nova.consoleauth.rpcapi.ConsoleAuthAPI.check_token')
def test_new_websocket_client_internal_access_path(self, check_token):
check_token.return_value = {
'host': 'node1',
'port': '10000',
'internal_access_path': 'vmid'
}
tsock = mock.MagicMock()
tsock.recv.return_value = ""HTTP/1.1 200 OK\r\n\r\n""
self.wh.socket.return_value = tsock
self.wh.path = ""ws://127.0.0.1/?token=123-456-789""
self.wh.new_websocket_client()
check_token.assert_called_with(mock.ANY, token=""123-456-789"")
self.wh.socket.assert_called_with('node1', 10000, connect=True)
self.wh.do_proxy.assert_called_with(tsock)
@mock.patch('nova.consoleauth.rpcapi.ConsoleAuthAPI.check_token')
def test_new_websocket_client_internal_access_path_err(self, check_token):
check_token.return_value = {
'host': 'node1',
'port': '10000',
'internal_access_path': 'xxx'
}
tsock = mock.MagicMock()
tsock.recv.return_value = ""HTTP/1.1 500 Internal Server Error\r\n\r\n""
self.wh.socket.return_value = tsock
self.wh.path = ""ws://127.0.0.1/?token=123-456-789""
self.assertRaises(Exception, self.wh.new_websocket_client) # noqa
check_token.assert_called_with(mock.ANY, token=""123-456-789"")
",1
"t_insert_cmd, base_col_def, print_tree
import sqlite3
from misura.canon.tests import testdir
db = testdir + 'storage/tmpdb'
c1 = testdir + 'storage/Conf.csv'
def go(t):
o = option.Option(**{'handle': t, 'type': t})
o.validate()
return o
class SqlStore(unittest.TestCase):
@classmethod
def setUpClass(cls):
if os.path.exists(db):
os.remove(db)
cls.conn = sqlite3.connect(db, detect_types=sqlite3.PARSE_DECLTYPES)
st0 = option.CsvStore(kid='/base/')
st0.merge_file(c1)
st0.validate()
cls.desc = st0.desc
def test_get_typed_cols(self):
print(get_typed_cols(go('Integer')))
print(get_typed_cols(go('String')))
print(get_typed_cols(go('Point')))
print(get_typed_cols(go('Role')))
print(get_typed_cols(go('RoleIO')))
print(get_typed_cols(go('Log')))
print(get_typed_cols(go('Meta')))
def test_get_insert_cmd(self):
print(get_insert_cmd(go('Integer'), base_col_def))
print(get_insert_cmd(go('String'), base_col_def))
print(get_insert_cmd(go('Point'), base_col_def))
print(get_insert_cmd(go('Role'), base_col_def))
print(get_insert_cmd(go('RoleIO'), base_col_def))
print(get_insert_cmd(go('Log'), base_col_def))
print(get_insert_cmd(go('Meta'), base_col_def))
def test_column_definition(self):
s = option.SqlStore()
print(s.column_definition(go('Integer'))[1])
print(s.column_definition(go('String'))[1])
print(s.column_definition(go('Point'))[1])
print(s.column_definition(go('Role'))[1])
print(s.column_definition(go('RoleIO'))[1])
print(s.column_definition(go('Log'))[1])
print(s.column_definition(go('Meta'))[1])
def test_write_desc(self):
s = option.SqlStore()
s.cursor = self.conn.cursor()
s.write_desc(self.desc)
print('READING')
r = s.read_tree()
print(r)
print('print(tree\n', print_tree(r))
print('WRITING AGAIN')
s.write_tree(r)
print(""READING AGAIN"")
r = s.read_tree()
print(r)
print('print(tree2\n', print_tree(r))
# @unittest.skip('')
def test_tables(self):
st0 = option.CsvStore(kid='ciao')
st0.merge_file(c1)
st = option.SqlStore(kid='ciao')
st.desc = st0.desc
k0 = set(st.desc.keys())
cursor = self.conn.cursor()
st.write_table(cursor, 'conf1')
self.conn.commit()
cursor.execute('select handle from conf1')
r = cursor.fetchall()
k1 = set([eval(k[0]) for k in r])
self.assertEqual(k0, k1)
st2 = option.SqlStore(kid='ciao')
st2.read_table(cursor, 'conf1')
self.assertEqual(st.desc, st2.desc)
if __name__ == ""__main__"":
unittest.main()
",1
"return format_line(prefix='fans'.rjust(RJUST), values=fans)
def format_rpms(rpms):
return format_line(prefix='rpms'.rjust(RJUST), values=rpms)
def format_pwms(pwms):
return format_line(prefix='pwms'.rjust(RJUST), values=pwms)
def format_tmps(tmps):
return format_line(prefix='temps'.rjust(RJUST), values=tmps)
def format_names(names):
return format_line(prefix='names'.rjust(RJUST), values=names)
def format_ports(ports):
return format_line(prefix='ports'.rjust(RJUST), values=ports)
def format_temps(temps):
return format_line(prefix='temps'.rjust(RJUST), values=temps)
def format_ambients(ambients):
return format_line(prefix='ambients'.rjust(RJUST), values=ambients)
def format_limits(limits):
return format_line(prefix='limits'.rjust(RJUST), values=limits)
def format_buffers(buffers):
return format_line(prefix='buffers'.rjust(RJUST), values=buffers)
def format_headrooms(headrooms):
return format_line(prefix='headrooms'.rjust(RJUST), values=headrooms)
def format_directions(directions):
return format_line(prefix='directions'.rjust(RJUST), values=directions)
def format_differences(differences):
return format_line(prefix='differences'.rjust(RJUST), values=differences)
def format_pwms_new(pwms_new):
return format_line(prefix='new pwms'.rjust(RJUST), values=pwms_new)
def format_line(prefix, values):
line = ''
line += prefix
line += ': '
line += '['
for value in values:
try:
if value >= 1:
value = int(round(value, 0))
if 1 > value != 0:
value = str(value)[1:4].ljust(3, '0')
except TypeError:
# value is None
pass
value = str(value) if value is not None else ''
line += value.rjust(6)
line += ', '
line = line[:-len(', ')]
line += ']'
return line
",1
"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, division, print_function
import collections
from contextlib import contextmanager
import pytest
import six
from cryptography.exceptions import UnsupportedAlgorithm
import cryptography_vectors
HashVector = collections.namedtuple(""HashVector"", [""message"", ""digest""])
KeyedHashVector = collections.namedtuple(
""KeyedHashVector"", [""message"", ""digest"", ""key""]
)
def select_backends(names, backend_list):
if names is None:
return backend_list
split_names = [x.strip() for x in names.split(',')]
# this must be duplicated and then removed to preserve the metadata
# pytest associates. Appending backends to a new list doesn't seem to work
selected_backends = []
for backend in backend_list:
if backend.name in split_names:
selected_backends.append(backend)
if len(selected_backends) > 0:
return selected_backends
else:
raise ValueError(
""No backend selected. Tried to select: {0}"".format(split_names)
)
def check_for_iface(name, iface, item):
if name in item.keywords and ""backend"" in item.funcargs:
if not isinstance(item.funcargs[""backend""], iface):
pytest.skip(""{0} backend does not support {1}"".format(
item.funcargs[""backend""], name
))
def check_backend_support(item):
supported = item.keywords.get(""supported"")
if supported and ""backend"" in item.funcargs:
if not supported.kwargs[""only_if""](item.funcargs[""backend""]):
pytest.skip(""{0} ({1})"".format(
supported.kwargs[""skip_message""], item.funcargs[""backend""]
))
elif supported:
raise ValueError(""This mark is only available on methods that take a ""
""backend"")
@contextmanager
def raises_unsupported_algorithm(reason):
with pytest.raises(UnsupportedAlgorithm) as exc_info:
yield exc_info
assert exc_info.value._reason is reason
def load_vectors_from_file(filename, loader):
with cryptography_vectors.open_vector_file(filename) as vector_file:
return loader(vector_file)
def load_nist_vectors(vector_data):
test_data = None
data = []
for line in vector_data:
line = line.strip()
# Blank lines, comments, and section headers are ignored
if not line or line.startswith(""#"") or (line.startswith(""["")
and line.endswith(""]"")):
continue
if line.strip() == ""FAIL"":
test_data[""fail""] = True
continue
# Build our data using a simple Key = Value format
name, value = [c.strip() for c in line.split(""="")]
# Some tests (PBKDF2) contain \0, which should be interpreted as a
# null character rather than literal.
value = value.replace(""\\0"", ""\0"")
# COUNT is a special token that indicates a new block of data
if name.upper() == ""COUNT"":
test_data = {}
data.append(test_data)
continue
# For all other tokens we simply want the name, value stored in
# the dictionary
else:
test_data[name.lower()] = value.encode(""ascii"")
return data
def load_cryptrec_vectors(vector_data):
cryptrec_list = []
for line in vector_data:
line = line.strip()
# Blank lines and comments are ignored
if not line or line.startswith(""#""):
continue
if line.startswith(""K""):
key = line.split("" : "")[1].replace("" "", """").encode(""ascii"")
elif line.startswith(""P""):
pt = line.split("" : "")[1].replace("" "", """").encode(""ascii"")
elif line.startswith(""C""):
ct = line.split("" : "")[1].replace("" "", """").encode(""ascii"")
# after a C is found the K+P+C tuple is complete
# there are many P+C pairs for each K
cryptrec_list.append({
""key"": key,
""plaintext"": pt,
""ciphertext"": ct
})
else:
raise ValueError(""Invalid line in file '{}'"".format(line))
return cryptrec_list
def load_hash_vectors(vector_data):
vectors = []
key = None
msg = None
md = None
for line in vector_data:
line = line.strip()
if not line or line.startswith(""#"") or line.startswith(""[""):
continue
if line.startswith(""Len""):
length = int(line.split("" = "")[1])
elif line.startswith(""Key""):
# HMAC vectors contain a key attribute. Hash vectors do not.
key = line.split("" = "")[1].encode(""ascii"")
elif line.startswith(""Msg""):
# In the NIST vectors they have chosen to represent an empty
# string as hex 00, which is of course not actually an empty
# string. So we parse the provided length and catch this edge case.
msg = line.split("" = "")[1].encode(""ascii"") if length > 0 else b""""
elif line.startswith(""MD""):
md = line.split("" = "")[1]
# after MD is found the Msg+MD (+ potential key) tuple is complete
if key is not None:
vectors.append(KeyedHashVector(msg, md, key))
key = None
msg = None
md = None
else:
vectors.append(HashVector(msg, md))
msg = None
md = None
else:
raise ValueError(""Unknown line in hash vector"")
return vectors
def load_pkcs1_vectors(vector_data):
""""""
Loads data out of RSA PKCS #1 vector files.
""""""
private_key_vector = None
public_key_vector = None
attr = None
key = None
example_vector = None
examples = []
vectors = []
for line in vector_data:
if (
line.startswith(""# PSS Example"") or
line.startswith(""# PKCS#1 v1.5 Signature"")
):
if example_vector:
for key, value in six.iteritems(example_vector):
hex_str = """".join(value).replace("" "", """").encode(""ascii"")
example_vector[key] = hex_str
examples.append(example_vector)
attr = None
example_vector = collections.defaultdict(list)
if line.startswith(""# Message to be signed""):
attr = ""message""
continue
elif line.startswith(""# Salt""):
attr = ""salt""
continue
elif line.startswith(""# Signature""):
attr = ""signature""
continue
elif (
example_vector and
line.startswith(""# ============================================="")
):
for key, value in six.iteritems(example_vector):
hex_str = """".join(value).replace("" "", """").encode(""ascii"")
example_vector[key] = hex_str
examples.append(example_vector)
example_vector = None
attr = None
elif example_vector and line.startswith(""#""):
continue
else:
if attr is not None and example_vector is not None:
example_vector[attr].append(line.strip())
continue
if (
line.startswith(""# Example"") or
line.startswith(""# ============================================="")
):
if key:
assert private_key_vector
assert public_key_vector
for key, value in six.iteritems(public_key_vector):
hex_str = """".join(value).replace("" "", """")
public_key_vector[key] = int(hex_str, 16)
for key, value in six.iteritems(private_key_vector):
hex_str = """".join(value).replace("" "", """")
private_key_vector[key] = int(hex_str, 16)
private_key_vector[""examples""] = examples
examples = []
assert (
private_key_vector['public_exponent'] ==
public_key_vector['public_exponent']
)
assert (
private_key_vector['modulus'] ==
public_key_vector['modulus']
)
vectors.append(
(private_key_vector, public_key_vector)
)
public_key_vector = collections.defaultdict(list)
private_key_vector = collections.defaultdict(list)
key = None
attr = None
if private_key_vector is None or public_key_vector is None:
continue
if line.startswith(""# Private key""):
key = private_key_vector
elif line.startswith(""# Public key""):
key = public_key_vector
elif line.startswith(""# Modulus:""):
attr = ""modulus""
elif line.startswith(""# Public exponent:""):
attr = ""public_exponent""
elif line.startswith(""# Exponent:""):
if key is public_key_vector:
attr = ""public_exponent""
else:
assert key is private_key_vector
attr = ""private_exponent""
elif line.startswith(""# Prime 1:""):
attr = ""p""
elif line.startswith(""# Prime 2:""):
attr = ""q""
elif line.startswith(""# Prime exponent 1:""):
attr = ""dmp1""
elif line.startswith(""# Prime exponent 2:""):
attr = ""dmq1""
elif line.startswith(""# Coefficient:""):
attr = ""iqmp""
elif line.startswith(""#""):
attr = None
else:
if key is not None and attr is not None:
key[attr].append(line.strip())
return vectors
def load_rsa_nist_vectors(vector_data):
test_data = None
p = None
salt_length = None
data = []
for line in vector_data:
line = line.strip()
# Blank lines and section headers are ignored
if not line or line.startswith(""[""):
continue
if line.startswith(""# Salt len:""):
salt_length = int(line.split("":"")[1].strip())
continue
elif line.startswith(""#""):
continue
# Build our data using a simple Key = Value format
name, value = [c.strip() for c in line.split(""="")]
if name == ""n"":
n = int(value, 16)
elif name == ""e"" and p is None:
e = int(value, 16)
elif name == ""p"":
p = int(value, 16)
elif name == ""q"":
q = int(value, 16)
elif name == ""SHAAlg"":
if p is None:
test_data = {
""modulus"": n,
""public_exponent"": e,
""salt_length"": salt_length,
""algorithm"": value,
""fail"": False
}
else:
test_data = {
""modulus"": n,
""p"": p,
""q"": q,
""algorithm"": value
}
if salt_length is not None:
test_data[""salt_length""] = salt_length
data.append(test_data)
elif name == ""e"" and p is not None:
test_data[""public_exponent""] = int(value, 16)
elif name == ""d"":
test_data[""private_exponent""] = int(value, 16)
elif name == ""Result"":
test_data[""fail""] = value.startswith(""F"")
# For all other tokens we simply want the name, value stored in
# the dictionary
else:
test_data[name.lower()] = value.encode(""ascii"")
return data
def load_fips_dsa_key_pair_vectors(vector_data):
""""""
Loads data out of the FIPS DSA KeyPair vector files.
""""""
vectors = []
# When reading_key_data is set to True it tells the loader to continue
# constructing dictionaries. We set reading_key_data to False during the
# blocks of the vectors of N=224 because we don't support it.
reading_key_data = True
for line in vector_data:
line = line.strip()
if not line or line.startswith(""#""):
continue
elif line.startswith(""[mod = L=1024""):
continue
elif line.startswith(""[mod = L=2048, N=224""):
reading_key_data = False
continue
elif line.startswith(""[mod = L=2048, N=256""):
reading_key_data = True
continue
elif line.startswith(""[mod = L=3072""):
continue
if not reading_key_data:
continue
elif reading_key_data:
if line.startswith(""P""):
vectors.append({'p': int(line.split(""="")[1], 16)})
elif line.startswith(""Q""):
vectors[-1]['q'] = int(line.split(""="")[1], 16)
elif line.startswith(""G""):
vectors[-1]['g'] = int(line.split(""="")[1], 16)
elif line.startswith(""X"") and 'x' not in vectors[-1]:
vectors[-1]['x'] = int(line.split(""="")[1], 16)
elif line.startswith(""X"") and 'x' in vectors[-1]:
vectors.append({'p': vectors[-1]['p'],
'q': vectors[-1]['q'],
'g': vectors[-1]['g'],
'x': int(line.split(""="")[1], 16)
})
elif line.startswith(""Y""):
vectors[-1]['y'] = int(line.split(""="")[1], 16)
return vectors
",1
"pt 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.
""""""Container for Google Cloud Bigtable Cells and Streaming Row Contents.""""""
import copy
import six
from gcloud._helpers import _datetime_from_microseconds
from gcloud._helpers import _to_bytes
class Cell(object):
""""""Representation of a Google Cloud Bigtable Cell.
:type value: bytes
:param value: The value stored in the cell.
:type timestamp: :class:`datetime.datetime`
:param timestamp: The timestamp when the cell was stored.
:type labels: list
:param labels: (Optional) List of strings. Labels applied to the cell.
""""""
def __init__(self, value, timestamp, labels=()):
self.value = value
self.timestamp = timestamp
self.labels = list(labels)
@classmethod
def from_pb(cls, cell_pb):
""""""Create a new cell from a Cell protobuf.
:type cell_pb: :class:`._generated.data_pb2.Cell`
:param cell_pb: The protobuf to convert.
:rtype: :class:`Cell`
:returns: The cell corresponding to the protobuf.
""""""
timestamp = _datetime_from_microseconds(cell_pb.timestamp_micros)
if cell_pb.labels:
return cls(cell_pb.value, timestamp, labels=cell_pb.labels)
else:
return cls(cell_pb.value, timestamp)
def __eq__(self, other):
if not isinstance(other, self.__class__):
return False
return (other.value == self.value and
other.timestamp == self.timestamp and
other.labels == self.labels)
def __ne__(self, other):
return not self.__eq__(other)
class PartialCellData(object):
""""""Representation of partial cell in a Google Cloud Bigtable Table.
These are expected to be updated directly from a
:class:`._generated.bigtable_service_messages_pb2.ReadRowsResponse`
:type row_key: bytes
:param row_key: The key for the row holding the (partial) cell.
:type family_name: str
:param family_name: The family name of the (partial) cell.
:type qualifier: bytes
:param qualifier: The column qualifier of the (partial) cell.
:type timestamp_micros: int
:param timestamp_micros: The timestamp (in microsecods) of the
(partial) cell.
:type labels: list of str
:param labels: labels assigned to the (partial) cell
:type value: bytes
:param value: The (accumulated) value of the (partial) cell.
""""""
def __init__(self, row_key, family_name, qualifier, timestamp_micros,
labels=(), value=b''):
self.row_key = row_key
self.family_name = family_name
self.qualifier = qualifier
self.timestamp_micros = timestamp_micros
self.labels = labels
self.value = value
def append_value(self, value):
""""""Append bytes from a new chunk to value.
:type value: bytes
:param value: bytes to append
""""""
self.value += value
class PartialRowData(object):
""""""Representation of partial row in a Google Cloud Bigtable Table.
These are expected to be updated directly from a
:class:`._generated.bigtable_service_messages_pb2.ReadRowsResponse`
:type row_key: bytes
:param row_key: The key for the row holding the (partial) data.
""""""
def __init__(self, row_key):
self._row_key = row_key
self._cells = {}
def __eq__(self, other):
if not isinstance(other, self.__class__):
return False
return (other._row_key == self._row_key and
other._cells == self._cells)
def __ne__(self, other):
return not self.__eq__(other)
def to_dict(self):
""""""Convert the cells to a dictionary.
This is intended to be used with HappyBase, so the column family and
column qualiers are combined (with ``:``).
:rtype: dict
:returns: Dictionary containing all the data in the cells of this row.
""""""
result = {}
for column_family_id, columns in six.iteritems(self._cells):
for column_qual, cells in six.iteritems(columns):
key = (_to_bytes(column_family_id) + b':' +
_to_bytes(column_qual))
result[key] = cells
return result
@property
def cells(self):
""""""Property returning all the cells accumulated on this partial row.
:rtype: dict
:returns: Dictionary of the :class:`Cell` objects accumulated. This
dictionary has two-levels of keys (first for column families
and second for column names/qualifiers within a family). For
a given column, a list of :class:`Cell` objects is stored.
""""""
return copy.deepcopy(self._cells)
@property
def row_key(self):
""""""Getter for the current (partial) row's key.
:rtype: bytes
:returns: The current (partial) row's key.
""""""
return self._row_key
class InvalidReadRowsResponse(RuntimeError):
""""""Exception raised to to invalid response data from back-end.""""""
class InvalidChunk(RuntimeError):
""""""Exception raised to to invalid chunk data from back-end.""""""
class PartialRowsData(object):
""""""Convenience wrapper for consuming a ``ReadRows`` streaming response.
:type response_iterator:
:class:`grpc.framework.alpha._reexport._CancellableIterator`
:param response_iterator: A streaming iterator returned from a
``ReadRows`` request.
""""""
START = ""Start"" # No responses yet processed.
NEW_ROW = ""New row"" # No cells yet complete for row
ROW_IN_PROGRESS = ""Row in progress"" # Some cells complete for row
CELL_IN_PROGRESS = ""Cell in progress"" # Incomplete cell for row
def __init__(self, response_iterator):
self._response_iterator = response_iterator
# Fully-processed rows, keyed by `row_key`
self._rows = {}
# Counter for responses pulled from iterator
self._counter = 0
# Maybe cached from previous response
self._last_scanned_row_key = None
# In-progress row, unset until first response, after commit/reset
self._row = None
# Last complete row, unset until first commit
self._previous_row = None
# In-progress cell, unset until first response, after completion
self._cell = None
# Last complete cell, unset until first completion, after new row
self._previous_cell = None
def __eq__(self, other):
if not isinstance(other, self.__class__):
return False
return other._response_iterator == self._response_iterator
def __ne__(self, other):
return not self.__eq__(other)
@property
def state(self):
""""""State machine state.
:rtype: str
:returns: name of state corresponding to currrent row / chunk
processing.
""""""
if self._last_scanned_row_key is None:
return self.START
if self._row is None:
assert self._cell is None
assert self._previous_cell is None
return self.NEW_ROW
if self._cell is not None:
return self.CELL_IN_PROGRESS
if self._previous_cell is not None:
return self.ROW_IN_PROGRESS
return self.NEW_ROW # row added, no chunk yet processed
@property
def rows(self):
""""""Property returning all rows accumulated from the stream.
:rtype: dict
:returns: row_key -> :class:`PartialRowData`.
""""""
# NOTE: To avoid duplicating large objects, this is just the
# mutable private data.
return self._rows
def cancel(self):
""""""Cancels the iterator, closing the stream.""""""
self._response_iterator.cancel()
def consume_next(self):
""""""Consume the next ``ReadRowsResponse`` from the stream.
Parse the response and its chunks into a new/existing row in
:attr:`_rows`
""""""
response = six.next(self._response_iterator)
self._counter += 1
if self._last_scanned_row_key is None: # first response
if response.last_scanned_row_key:
raise InvalidReadRowsResponse()
self._last_scanned_row_key = response.last_scanned_row_key
row = self._row
cell = self._cell
for chunk in response.chunks:
self._validate_chunk(chunk)
if chunk.reset_row:
row = self._row = None
cell = self._cell = self._previous_cell = None
continue
if row is None:
row = self._row = PartialRowData(chunk.row_key)
if cell is None:
cell = self._cell = PartialCellData(
chunk.row_key,
chunk.family_name.value,
chunk.qualifier.value,
chunk.timestamp_micros,
chunk.labels,
chunk.value)
self._copy_from_previous(cell)
else:
cell.append_value(chunk.value)
if chunk.commit_row:
self._save_current_row()
row = cell = None
continue
if chunk.value_size == 0:
self._save_current_cell()
cell = None
def consume_all(self, max_loops=None):
""""""Consume the streamed responses until there are no more.
This simply calls :meth:`consume_next` until there are no
more to consume.
:type max_loops: int
:param max_loops: (Optional) Maximum number of times to try to consume
an additional ``ReadRowsResponse``. You can use this
to avoid long wait times.
""""""
curr_loop = 0
if max_loops is None:
max_loops = float('inf')
while curr_loop < max_loops:
curr_loop += 1
try:
self.consume_next()
except StopIteration:
break
@staticmethod
def _validate_chunk_status(chunk):
""""""Helper for :meth:`_validate_chunk_row_in_progress`, etc.""""""
# No reseet with other keys
if chunk.reset_row:
_raise_if(chunk.row_key)
_raise_if(chunk.HasField('family_name'))
_raise_if(chunk.HasField('qualifier'))
_raise_if(chunk.timestamp_micros)
_raise_if(chunk.labels)
_raise_if(chunk.value_size)
_raise_if(chunk.value)
# No commit with value size
_raise_if(chunk.commit_row and chunk.value_size > 0)
# No negative value_size (inferred as a general constraint).
_raise_if(chunk.value_size < 0)
def _validate_chunk_new_row(self, chunk):
""""""Helper for :meth:`_validate_chunk`.""""""
assert self.state == self.NEW_ROW
_raise_if(chunk.reset_row)
_raise_if(not chunk.row_key)
_raise_if(not chunk.family_name)
_raise_if(not chunk.qualifier)
# This constraint is not enforced in the Go example.
_raise_if(chunk.value_size > 0 and chunk.commit_row is not False)
# This constraint is from the Go example, not the spec.
_raise_if(self._previous_row is not None and
chunk.row_key <= self._previous_row.row_key)
def _same_as_previous(self, chunk):
""""""Helper for :meth:`_validate_chunk_row_in_progress`""""""
previous = self._previous_cell
return (chunk.row_key == previous.row_key and
chunk.family_name == previous.family_name and
chunk.qualifier == previous.qualifier and
chunk.labels == previous.labels)
def _validate_chunk_row_in_progress(self, chunk):
""""""Helper for :meth:`_validate_chunk`""""""
assert self.state == self.ROW_IN_PROGRESS
self._validate_chunk_status(chunk)
if not chunk.HasField('commit_row') and not chunk.reset_row:
_raise_if(not chunk.timestamp_micros or not chunk.value)
_raise_if(chunk.row_key and
chunk.row_key != self._row.row_key)
_raise_if(chunk.HasField('family_name') and
not chunk.HasField('qualifier'))
previous = self._previous_cell
_raise_if(self._same_as_previous(chunk) and
chunk.timestamp_micros <= previous.timestamp_micros)
def _validate_chunk_cell_in_progress(self, chunk):
""""""Helper for :meth:`_validate_chunk`""""""
assert self.state == self.CELL_IN_PROGRESS
self._validate_chunk_status(chunk)
self._copy_from_current(chunk)
def _validate_chunk(self, chunk):
""""""Helper for :meth:`consume_next`.""""""
if self.state == self.NEW_ROW:
self._validate_chunk_new_row(chunk)
if self.state == self.ROW_IN_PROGRESS:
self._validate_chunk_row_in_progress(chunk)
if self.state == self.CELL_IN_PROGRESS:
self._validate_chunk_cell_in_progress(chunk)
def _save_current_cell(self):
""""""Helper for :meth:`consume_next`.""""""
row, cell = self._row, self._cell
family = row._cells.setdefault(cell.family_name, {})
qualified = family.setdefault(cell.qualifier, [])
complete = Cell.from_pb(self._cell)
qualified.append(complete)
self._cell, self._previous_cell = None, cell
def _copy_from_current(self, chunk):
""""""Helper for :meth:`consume_next`.""""""
current = self._cell
if current is not None:
if not chunk.row_key:
chunk.row_key = current.row_key
if not chunk.HasField('family_name'):
chunk.family_name.value = current.family_name
if not chunk.HasField('qualifier'):
chunk.qualifier.value = current.qualifier
if not chunk.timestamp_micros:
chunk.timestamp_micros = current.timestamp_micros
if not chunk.labels:
chunk.labels.extend(current.labels)
def _copy_from_previous(self, cell):
""""""Helper for :meth:`consume_next`.""""""
previous = self._previous_cell
if previous is not None:
if not cell.row_key:
cell.row_key = previous.row_key
if not cell.family_name:
cell.family_name = previous.family_name
if not cell.qualifier:
cell.qualifier = previous.qualifier
def _save_current_row(self):
""""""Helper for :meth:`consume_next`.""""""
if self._cell:
self._save_current_cell()
self._rows[self._row.row_key] = self._row
self._row, self._previous_row = None, self._row
self._previous_cell = None
def _raise_if(predicate, *args):
""""""Helper for validation methods.""""""
if predicate:
raise InvalidChunk(*args)
",1
"ace, Resource, fields, reqparse
from sqlalchemy.exc import IntegrityError
from packr.models import Message
api = Namespace('contact',
description='Operations related to the contact form')
message = api.model('Contact', {
'email': fields.String(required=True,
description='Contact email'),
'content': fields.String(required=True,
description='Message'),
})
message_id = api.model('ContactCompletion', {
'id': fields.Integer(required=True,
description='id')
})
@api.route('/')
class MessageItem(Resource):
@api.expect(message)
@api.response(204, 'Message successfully received.')
def post(self):
req_parse = reqparse.RequestParser(bundle_errors=True)
req_parse.add_argument('email', type=str, required=True,
help='No email provided',
location='json')
req_parse.add_argument('content', type=str, required=True,
help='No message provided',
location='json')
args = req_parse.parse_args()
email = args.get('email')
content = args.get('content')
if email == '':
return {'message': {'email': 'No email provided'}}, 400
elif not re.match(r""^[A-Za-z0-9.+_-]+@[A-Za-z0-9._-]+\.[a-zA-Z]*$"",
email):
return {'message': {'email': 'Invalid email provided'}}, 400
if content == '':
return {'message': {'content': 'No content provided'}}, 400
new_message = Message(email=email,
content=content,
time=datetime.now())
try:
new_message.save()
except IntegrityError as e:
print(e)
return {
'description': 'Failed to send message.'
}, 409
except Exception as e:
print(e)
return {'description': 'Server encountered an error.'}, 500
return {'email': new_message.email}, 201
def get(self):
if not current_identity and not app.config.get('TESTING'):
return {'message': 'User not authenticated'}, 401
if app.config.get('TESTING') \
or current_identity.role.role_name == ""ADMIN"":
messages = dict()
for message_row in Message.query.filter_by(done=False).all():
messages[message_row.id] = {
""email"": message_row.email,
""time"": message_row.time.isoformat(),
""content"": message_row.content
}
return messages, 201
else:
return {'message': 'Not authorised'}, 401
@api.route('/complete')
class CompleteItem(Resource):
@api.expect(message_id)
@api.response(204, 'Message successfully updated.')
def post(self):
req_parse = reqparse.RequestParser(bundle_errors=True)
req_parse.add_argument('id', type=int, required=True,
help='No id provided',
location='json')
args = req_parse.parse_args()
id = args.get('id')
if id == 0:
return {'message': {'id': 'No id provided'}}, 400
completed_message = Message.query.filter_by(id=id).first()
completed_message.done = True
try:
completed_message.save()
except IntegrityError as e:
print(e)
return {
'description': 'Failed to update message.'
}, 409
except Exception as e:
print(e)
return {'description': 'Server encountered an error.'}, 500
return {'message': ""Message updated""}, 201
",1
"ager (Attributes) :
""""""
UnitManager class -- manages a pool
""""""
# --------------------------------------------------------------------------
#
def __init__ (self, url=None, scheduler='default', session=None) :
Attributes.__init__ (self)
# --------------------------------------------------------------------------
#
def add_pilot (self, pid) :
""""""
add (Compute or Data)-Pilot(s) to the pool
""""""
raise Exception (""%s.add_pilot() is not implemented"" % self.__class__.__name__)
# --------------------------------------------------------------------------
#
def list_pilots (self, ptype=ANY) :
""""""
List IDs of data and/or compute pilots
""""""
raise Exception (""%s.list_pilots() is not implemented"" % self.__class__.__name__)
# --------------------------------------------------------------------------
#
def remove_pilot (self, pid, drain=False) :
""""""
Remove pilot(s) (does not cancel the pilot(s), but removes all units
from the pilot(s).
`drain` determines what happens to the units which are managed by the
removed pilot(s). If `True`, the pilot removal is delayed until all
units reach a final state. If `False` (the default), then `RUNNING`
units will be canceled, and `PENDING` units will be re-assinged to the
unit managers for re-scheduling to other pilots.
""""""
raise Exception (""%s.remove_pilot() is not implemented"" % self.__class__.__name__)
# --------------------------------------------------------------------------
#
def submit_unit (self, description) :
""""""
Instantiate and return (Compute or Data)-Unit object(s)
""""""
raise Exception (""%s.submit_unit() is not implemented"" % self.__class__.__name__)
# --------------------------------------------------------------------------
#
def list_units (self, utype=ANY) :
""""""
List IDs of data and/or compute units
""""""
raise Exception (""%s.list_units() is not implemented"" % self.__class__.__name__)
# --------------------------------------------------------------------------
#
def get_unit (self, uids) :
""""""
Reconnect to and return (Compute or Data)-Unit object(s)
""""""
raise Exception (""%s.get_unit() is not implemented"" % self.__class__.__name__)
# --------------------------------------------------------------------------
#
def wait_unit (self, uids, state=[DONE, FAILED, CANCELED], timeout=-1.0) :
""""""
Wait for given unit(s) to enter given state
""""""
raise Exception (""%s.wait_unit() is not implemented"" % self.__class__.__name__)
# --------------------------------------------------------------------------
#
def cancel_units (self, uids) :
""""""
Cancel given unit(s)
""""""
raise Exception (""%s.cancel_unit() is not implemented"" % self.__class__.__name__)
# ------------------------------------------------------------------------------
#
",1
"Member(models.Model):
""""""A member of compsoc""""""
class Meta:
verbose_name = 'CompSoc Member'
verbose_name_plural = 'CompSoc Members'
index = models.IntegerField(blank=False, help_text=""This field is present just for ordering members based on their posts. President = 2, VPs = 1, Gen. Sec. = 0, Everyone else = -1"", default=-1)
name = models.CharField(max_length=50, help_text='Enter your full name')
image = models.ImageField(blank=False, upload_to='member_images/', help_text='Please select a display image for yourself. This is necessary.')
cropping = ImageRatioField('image', '500x500')
alumni = models.BooleanField(default=False, help_text='Are you an alumni?')
role = models.CharField(max_length=100, help_text=""Enter your post if you hold one. If not, enter 'Member'"")
batch_of = models.CharField(max_length=4, default='2015', help_text='Enter the year you will graduate')
social_link = models.CharField(blank=True, max_length=256, help_text='Enter a link to your Facebook, Twitter, GitHub or any other social network profile. You can leave this blank if you wish!')
def get_social_link(self):
'''
Returns the social_link if present. Otherwise, sends javascript:void(0)
'''
if self.social_link == '':
return 'javascript:void(0)'
else:
return self.social_link
def __str__(self):
return self.name
class Variable(models.Model): ##NOTE: This should not be used anymore
def __str__(self):
warnings.warn('''You are using a ""General Variable"".
Stop doing that.
This is bad design on Arjoonn's part so don't fall into the same trap.
If you are using this for Orfik, that has already been fixed. If you are using this for logos, same thing.
Over a few cycles this entire table will be removed.
''')
return self.name
name = models.CharField(max_length=100)
time = models.DateTimeField()
# Receive the pre_delete signal and delete the image associated with the model instance.
from django.db.models.signals import pre_delete
from django.dispatch.dispatcher import receiver
@receiver(pre_delete, sender=CompMember)
def compsoc_member_delete(sender, instance, **kwargs):
# Pass false so ImageField doesn't save the model.
instance.image.delete(False)
",1
"trides=(1, 1),
padding=(0, 0),
dilation=(1, 1),
groups=1,
channels=None,
kernel_size=None,
data_layout=""NCHW"",
weight_layout=""OIHW"",
out_layout="""",
out_dtype=""""):
r""""""2D convolution.
This operator takes the weight as the convolution kernel
and convolves it with data to produce an output.
In the default case, where the data_layout is `NCHW`
and weight_layout is `OIHW`, conv2d takes in
a data Tensor with shape `(batch_size, in_channels, height, width)`,
and a weight Tensor with shape `(channels, in_channels, kernel_size[0], kernel_size[1])`
to produce an output Tensor with the following rule:
.. math::
\mbox{out}[b, c, y, x] = \sum_{dy, dx, k}
\mbox{data}[b, k, \mbox{strides}[0] * y + dy, \mbox{strides}[1] * x + dx] *
\mbox{weight}[c, k, dy, dx]
Padding and dilation are applied to data and weight respectively before the computation.
This operator accepts data layout specification.
Semantically, the operator will convert the layout to the canonical layout
(`NCHW` for data and `OIHW` for weight), perform the computation,
then convert to the out_layout.
Parameters
----------
data : relay.Expr
The input data to the operator.
weight : relay.Expr
The weight expressions.
strides : tuple of int, optional
The strides of convoltution.
padding : tuple of int, optional
The padding of convolution on both sides of inputs before convolution.
dilation : tuple of int, optional
Specifies the dilation rate to be used for dilated convolution.
groups : int, optional
Number of groups for grouped convolution.
channels : int, optional
Number of output channels of this convolution.
kernel_size : tuple of int, optional
The spatial of the convolution kernel.
data_layout : str, optional
Layout of the input.
weight_layout : str, optional
Layout of the weight.
out_layout : str, optional
Layout of the output, by default, out_layout is the same as data_layout
out_dtype : str, optional
Specifies the output data type for mixed precision conv2d.
Returns
-------
result : relay.Expr
The computed result.
""""""
return _make.conv2d(data, weight, strides, padding, dilation,
groups, channels, kernel_size, data_layout,
weight_layout, out_layout, out_dtype)
def softmax(data, axis):
r""""""Computes softmax.
.. math:: \text{softmax}(x)_i = \frac{exp(x_i)}{\sum_j exp(x_j)}
.. note::
This operator can be optimized away for inference.
Parameters
----------
data: relay.Expr
The input data to the operator.
axis: int
The axis to sum over when computing softmax
""""""
return _make.softmax(data, axis)
def log_softmax(data, axis):
r""""""Computes log softmax.
.. math::
\text{log_softmax}(x)_i = \log \frac{exp(x_i)}{\sum_j exp(x_j)}
.. note::
This operator can be optimized away for inference.
Parameters
----------
data: relay.Expr
The input data to the operator.
axis: int
The axis to sum over when computing softmax
""""""
return _make.log_softmax(data, axis)
def max_pool2d(data,
pool_size=(1, 1),
strides=(1, 1),
padding=(0, 0),
layout=""NCHW"",
ceil_mode=False):
r""""""2D maximum pooling operator.
This operator takes data as input and does 2D max value calculation
with in pool_size sized window by striding defined by stride
In the default case, where the data_layout is `NCHW`
a data Tensor with shape `(batch_size, in_channels, height, width)`,
to produce an output Tensor with the following rule:
with data of shape (b, c, h, w) and pool_size (kh, kw)
.. math::
\mbox{out}(b, c, y, x) = \max_{m=0, \ldots, kh-1} \max_{n=0, \ldots, kw-1}
\mbox{data}(b, c, \mbox{stride}[0] * y + m, \mbox{stride}[1] * x + n)
Padding is applied to data before the computation.
ceil_mode is used to take ceil or floor while computing out shape.
This operator accepts data layout specification.
Parameters
----------
data : relay.Expr
The input data to the operator.
strides : tuple of int, optional
The strides of pooling.
padding : tuple of int, optional
The padding for pooling.
layout : str, optional
Layout of the input.
ceil_mode : bool, optional
To enable or disable ceil while pooling.
Returns
-------
result : relay.Expr
The computed result.
""""""
return _make.max_pool2d(data, pool_size, strides, padding,
layout, ceil_mode)
def avg_pool2d(data,
pool_size=(1, 1),
strides=(1, 1),
padding=(0, 0),
layout=""NCHW"",
ceil_mode=False,
count_include_pad=False):
r""""""2D average pooling operator.
This operator takes data as input and does 2D average value calculation
with in pool_size sized window by striding defined by stride
In the default case, where the data_layout is `NCHW`
a data Tensor with shape `(batch_size, in_channels, height, width)`,
to produce an output Tensor with the following rule:
with data of shape (b, c, h, w), pool_size (kh, kw)
.. math::
\mbox{out}(b, c, y, x) = \frac{1}{kh * kw} \sum_{m=0}^{kh-1} \sum_{n=0}^{kw-1}
\mbox{data}(b, c, \mbox{stride}[0] * y + m, \mbox{stride}[1] * x + n)
Padding is applied to data before the computation.
ceil_mode is used to take ceil or floor while computing out shape.
count_include_pad indicates including or excluding padded input values in computation.
This operator accepts data layout specification.
Parameters
----------
data : relay.Expr
The input data to the operator.
strides : tuple of int, optional
The strides of pooling.
padding : tuple of int, optional
The padding for pooling.
layout : str, optional
Layout of the input.
ceil_mode : bool, optional
To enable or disable ceil while pooling.
count_include_pad : bool, optional
To include padding to compute the average.
Returns
-------
result : relay.Expr
The computed result.
""""""
return _make.avg_pool2d(data, pool_size, strides, padding,
layout, ceil_mode, count_include_pad)
def global_max_pool2d(data,
layout=""NCHW""):
r""""""2D global maximum pooling operator.
This operator takes data as input and does 2D max value calculation
across each window represented by WxH.
In the default case, where the data_layout is `NCHW`
a data Tensor with shape `(batch_size, in_channels, height, width)`,
to produce an output Tensor with the following rule:
with data of shape (b, c, h, w)
.. math::
\mbox{out}(b, c, 1, 1) = \max_{m=0, \ldots, h} \max_{n=0, \ldots, w}
\mbox{data}(b, c, m, n)
Parameters
----------
data : relay.Expr
The input data to the operator.
layout : str, optional
Layout of the input.
Returns
-------
result : relay.Expr
The computed result.
""""""
return _make.global_max_pool2d(data, layout)
def global_avg_pool2d(data,
layout=""NCHW""):
r""""""2D global average pooling operator.
This operator takes data as input and does 2D average value calculation
across each window represented by WxH.
In the default case, where the data_layout is `NCHW`
a data Tensor with shape `(batch_size, in_channels, height, width)`,
to produce an output Tensor with the following rule:
with data of shape (b, c, h, w)
.. math::
\mbox{out}(b, c, 1, 1) = \frac{1}{h * w} \sum_{m=0}^{h-1} \sum_{n=0}^{w-1}
\mbox{data}(b, c, m, n)
Parameters
----------
data : relay.Expr
The input data to the operator.
layout : str, optional
Layout of the input.
Returns
-------
result : relay.Expr
The computed result.
""""""
return _make.global_avg_pool2d(data, layout)
def upsampling(data,
scale=1,
layout=""NCHW"",
method=""NEAREST_NEIGHBOR""):
""""""Upsampling.
This operator takes data as input and does 2D scaling to the given scale factor.
In the default case, where the data_layout is `NCHW`
with data of shape (n, c, h, w)
out will have a shape (n, c, h*scale, w*scale)
method indicates the algorithm to be used while calculating ghe out value
and method can be one of (""BILINEAR"", ""NEAREST_NEIGHBOR"")
Parameters
----------
data : relay.Expr
The input data to the operator.
scale : relay.Expr
The scale factor for upsampling.
layout : str, optional
Layout of the input.
method : str, optional
Scale method to used [NEAREST_NEIGHBOR, BILINEAR].
Returns
-------
result : relay.Expr
The computed result.
""""""
return _make.upsampling(data, scale, layout, method)
def batch_flatten(data):
""""""BatchFlatten.
This operator flattens all the dimensions except for the batch dimension.
which results a 2D output.
For data with shape ``(d1, d2, ..., dk)``
batch_flatten(data) returns reshaped output of shape ``(d1, d2*...*dk)``.
Parameters
----------
data : relay.Expr
The input data to the operator.
Returns
-------
result: relay.Expr
The Flattened result.
""""""
return _make.batch_flatten(data)
",1
"
def checkCollision(self, otherSprite):
if (self.x < otherSprite.x + otherSprite.tw and otherSprite.x < self.x + self.tw
and self.y < otherSprite.y + otherSprite.th and otherSprite.y < self.y + self.th):
return True
else:
return False
class Actor(Sprite):
def __init__(self, xPos, yPos):
super(Actor, self).__init__(xPos, yPos)
self.speed = 5
self.dy = 0
self.d = 3
self.dir = ""right""
# self.newdir = ""right""
self.state = ""standing""
self.walkR = []
self.walkL = []
def loadPics(self):
self.standing = loadImage(""gripe_stand.png"")
self.falling = loadImage(""grfalling.png"")
for i in range(8):
imageName = ""gr"" + str(i) + "".png""
self.walkR.append(loadImage(imageName))
for i in range(8):
imageName = ""gl"" + str(i) + "".png""
self.walkL.append(loadImage(imageName))
def checkWall(self, wall):
if wall.state == ""hidden"":
if (self.x >= wall.x - self.d and
(self.x + 32 <= wall.x + 32 + self.d)):
return False
def move(self):
if self.dir == ""right"":
if self.state == ""walking"":
self.im = self.walkR[frameCount % 8]
self.dx = self.speed
elif self.state == ""standing"":
self.im = self.standing
self.dx = 0
elif self.state == ""falling"":
self.im = self.falling
self.dx = 0
self.dy = 5
elif self.dir == ""left"":
if self.state == ""walking"":
self.im = self.walkL[frameCount % 8]
self.dx = -self.speed
elif self.state == ""standing"":
self.im = self.standing
self.dx = 0
elif self.state == ""falling"":
self.im = self.falling
self.dx = 0
self.dy = 5
else:
self.dx = 0
self.x += self.dx
self.y += self.dy
if self.x <= 0:
self.x = 0
if self.x >= 640 - self.tw:
self.x = 640 -self.tw
def display(self):
image(self.im, self.x, self.y)
class Block(Sprite):
def __init__(self, xPos, yPos):
super(Block, self).__init__(xPos, yPos)
self.state = ""visible""
def loadPics(self):
self.im = loadImage(""block.png"")
def display(self):
if self.state == ""visible"":
image(self.im, self.x, self.y)
",1
"------------------------------------------------------------------
from typing import Any, Sequence, TYPE_CHECKING, Union
from git.types import PathLike
if TYPE_CHECKING:
from .base import Submodule
from weakref import ReferenceType
from git.repo import Repo
from git.refs import Head
from git import Remote
from git.refs import RemoteReference
__all__ = ('sm_section', 'sm_name', 'mkhead', 'find_first_remote_branch',
'SubmoduleConfigParser')
#{ Utilities
def sm_section(name: str) -> str:
"""""":return: section title used in .gitmodules configuration file""""""
return f'submodule ""{name}""'
def sm_name(section: str) -> str:
"""""":return: name of the submodule as parsed from the section name""""""
section = section.strip()
return section[11:-1]
def mkhead(repo: 'Repo', path: PathLike) -> 'Head':
"""""":return: New branch/head instance""""""
return git.Head(repo, git.Head.to_full_path(path))
def find_first_remote_branch(remotes: Sequence['Remote'], branch_name: str) -> 'RemoteReference':
""""""Find the remote branch matching the name of the given branch or raise InvalidGitRepositoryError""""""
for remote in remotes:
try:
return remote.refs[branch_name]
except IndexError:
continue
# END exception handling
# END for remote
raise InvalidGitRepositoryError(""Didn't find remote branch '%r' in any of the given remotes"" % branch_name)
#} END utilities
#{ Classes
class SubmoduleConfigParser(GitConfigParser):
""""""
Catches calls to _write, and updates the .gitmodules blob in the index
with the new data, if we have written into a stream. Otherwise it will
add the local file to the index to make it correspond with the working tree.
Additionally, the cache must be cleared
Please note that no mutating method will work in bare mode
""""""
def __init__(self, *args: Any, **kwargs: Any) -> None:
self._smref: Union['ReferenceType[Submodule]', None] = None
self._index = None
self._auto_write = True
super(SubmoduleConfigParser, self).__init__(*args, **kwargs)
#{ Interface
def set_submodule(self, submodule: 'Submodule') -> None:
""""""Set this instance's submodule. It must be called before
the first write operation begins""""""
self._smref = weakref.ref(submodule)
def flush_to_index(self) -> None:
""""""Flush changes in our configuration file to the index""""""
assert self._smref is not None
# should always have a file here
assert not isinstance(self._file_or_files, BytesIO)
sm = self._smref()
if sm is not None:
index = self._index
if index is None:
index = sm.repo.index
# END handle index
index.add([sm.k_modules_file], write=self._auto_write)
sm._clear_cache()
# END handle weakref
#} END interface
#{ Overridden Methods
def write(self) -> None: # type: ignore[override]
rval: None = super(SubmoduleConfigParser, self).write()
self.flush_to_index()
return rval
# END overridden methods
#} END classes
",1
"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 print_function
from future import standard_library
standard_library.install_aliases()
from builtins import str
from past.builtins import basestring
from datetime import datetime
import logging
from urllib.parse import urlparse
from time import sleep
import airflow
from airflow import hooks, settings
from airflow.exceptions import AirflowException, AirflowSensorTimeout, AirflowSkipException
from airflow.models import BaseOperator, TaskInstance, Connection as DB
from airflow.hooks.base_hook import BaseHook
from airflow.utils.state import State
from airflow.utils.decorators import apply_defaults
class BaseSensorOperator(BaseOperator):
'''
Sensor operators are derived from this class an inherit these attributes.
Sensor operators keep executing at a time interval and succeed when
a criteria is met and fail if and when they time out.
:param soft_fail: Set to true to mark the task as SKIPPED on failure
:type soft_fail: bool
:param poke_interval: Time in seconds that the job should wait in
between each tries
:type poke_interval: int
:param timeout: Time, in seconds before the task times out and fails.
:type timeout: int
'''
ui_color = '#e6f1f2'
@apply_defaults
def __init__(
self,
poke_interval=60,
timeout=60*60*24*7,
soft_fail=False,
*args, **kwargs):
super(BaseSensorOperator, self).__init__(*args, **kwargs)
self.poke_interval = poke_interval
self.soft_fail = soft_fail
self.timeout = timeout
def poke(self, context):
'''
Function that the sensors defined while deriving this class should
override.
'''
raise AirflowException('Override me.')
def execute(self, context):
started_at = datetime.now()
while not self.poke(context):
if (datetime.now() - started_at).total_seconds() > self.timeout:
if self.soft_fail:
raise AirflowSkipException('Snap. Time is OUT.')
else:
raise AirflowSensorTimeout('Snap. Time is OUT.')
sleep(self.poke_interval)
logging.info(""Success criteria met. Exiting."")
class SqlSensor(BaseSensorOperator):
""""""
Runs a sql statement until a criteria is met. It will keep trying until
sql returns no row, or if the first cell in (0, '0', '').
:param conn_id: The connection to run the sensor against
:type conn_id: string
:param sql: The sql to run. To pass, it needs to return at least one cell
that contains a non-zero / empty string value.
""""""
template_fields = ('sql',)
template_ext = ('.hql', '.sql',)
@apply_defaults
def __init__(self, conn_id, sql, *args, **kwargs):
self.sql = sql
self.conn_id = conn_id
super(SqlSensor, self).__init__(*args, **kwargs)
def poke(self, context):
hook = BaseHook.get_connection(self.conn_id).get_hook()
logging.info('Poking: ' + self.sql)
records = hook.get_records(self.sql)
if not records:
return False
else:
if str(records[0][0]) in ('0', '',):
return False
else:
return True
print(records[0][0])
class MetastorePartitionSensor(SqlSensor):
""""""
An alternative to the HivePartitionSensor that talk directly to the
MySQL db. This was created as a result of observing sub optimal
queries generated by the Metastore thrift service when hitting
subpartitioned tables. The Thrift service's queries were written in a
way that wouldn't leverage the indexes.
:param schema: the schema
:type schema: str
:param table: the table
:type table: str
:param partition_name: the partition name, as defined in the PARTITIONS
table of the Metastore. Order of the fields does matter.
Examples: ``ds=2016-01-01`` or
``ds=2016-01-01/sub=foo`` for a sub partitioned table
:type partition_name: str
:param mysql_conn_id: a reference to the MySQL conn_id for the metastore
:type mysql_conn_id: str
""""""
template_fields = ('partition_name', 'table', 'schema')
@apply_defaults
def __init__(
self, table, partition_name, schema=""default"",
mysql_conn_id=""metastore_mysql"",
*args, **kwargs):
self.partition_name = partition_name
self.table = table
self.schema = schema
self.first_poke = True
self.conn_id = mysql_conn_id
super(SqlSensor, self).__init__(*args, **kwargs)
def poke(self, context):
if self.first_poke:
self.first_poke = False
if '.' in self.table:
self.schema, self.table = self.table.split('.')
self.sql = """"""
SELECT 'X'
FROM PARTITIONS A0
LEFT OUTER JOIN TBLS B0 ON A0.TBL_ID = B0.TBL_ID
LEFT OUTER JOIN DBS C0 ON B0.DB_ID = C0.DB_ID
WHERE
B0.TBL_NAME = '{self.table}' AND
C0.NAME = '{self.schema}' AND
A0.PART_NAME = '{self.partition_name}';
"""""".format(self=self)
return super(MetastorePartitionSensor, self).poke(context)
class ExternalTaskSensor(BaseSensorOperator):
""""""
Waits for a task to complete in a different DAG
:param external_dag_id: The dag_id that contains the task you want to
wait for
:type external_dag_id: string
:param external_task_id: The task_id that contains the task you want to
wait for
:type external_task_id: string
:param allowed_states: list of allowed states, default is ``['success']``
:type allowed_states: list
:param execution_delta: time difference with the previous execution to
look at, the default is the same execution_date as the current task.
For yesterday, use [positive!] datetime.timedelta(days=1). Either
execution_delta or execution_date_fn can be passed to
ExternalTaskSensor, but not both.
:type execution_delta: datetime.timedelta
:param execution_date_fn: function that receives the current execution date
and returns the desired execution date to query. Either execution_delta
or execution_date_fn can be passed to ExternalTaskSensor, but not both.
:type execution_date_fn: callable
""""""
@apply_defaults
def __init__(
self,
external_dag_id,
external_task_id,
allowed_states=None,
execution_delta=None,
execution_date_fn=None,
*args, **kwargs):
super(ExternalTaskSensor, self).__init__(*args, **kwargs)
self.allowed_states = allowed_states or [State.SUCCESS]
if execution_delta is not None and execution_date_fn is not None:
raise ValueError(
'Only one of `execution_date` or `execution_date_fn` may'
'be provided to ExternalTaskSensor; not both.')
self.execution_delta = execution_delta
self.execution_date_fn = execution_date_fn
self.external_dag_id = external_dag_id
self.external_task_id = external_task_id
def poke(self, context):
if self.execution_delta:
dttm = context['execution_date'] - self.execution_delta
elif self.execution_date_fn:
dttm = self.execution_date_fn(context['execution_date'])
else:
dttm = context['execution_date']
logging.info(
'Poking for '
'{self.external_dag_id}.'
'{self.external_task_id} on '
'{dttm} ... '.format(**locals()))
TI = TaskInstance
session = settings.Session()
count = session.query(TI).filter(
TI.dag_id == self.external_dag_id,
TI.task_id == self.external_task_id,
TI.state.in_(self.allowed_states),
TI.execution_date == dttm,
).count()
session.commit()
session.close()
return count
class NamedHivePartitionSensor(BaseSensorOperator):
""""""
Waits for a set of partitions to show up in Hive.
:param partition_names: List of fully qualified names of the
partitions to wait for. A fully qualified name is of the
form schema.table/pk1=pv1/pk2=pv2, for example,
default.users/ds=2016-01-01. This is passed as is to the metastore
Thrift client ""get_partitions_by_name"" method. Note that
you cannot use logical operators as in HivePartitionSensor.
:type partition_names: list of strings
:param metastore_conn_id: reference to the metastore thrift service
connection id
:type metastore_conn_id: str
""""""
template_fields = ('partition_names', )
@apply_defaults
def __init__(
self,
partition_names,
metastore_conn_id='metastore_default',
poke_interval=60*3,
*args,
**kwargs):
super(NamedHivePartitionSensor, self).__init__(
poke_interval=poke_interval, *args, **kwargs)
if isinstance(partition_names, basestring):
raise TypeError('partition_names must be an array of strings')
self.metastore_conn_id = metastore_conn_id
self.partition_names = partition_names
self.next_poke_idx = 0
def parse_partition_name(self, partition):
try:
schema, table_partition = partition.split('.')
table, partition = table_partition.split('/', 1)
return schema, table, partition
except ValueError as e:
raise ValueError('Could not parse ' + partition)
def poke(self, context):
if not hasattr(self, 'hook'):
self.hook = airflow.hooks.hive_hooks.HiveMetastoreHook(
metastore_conn_id=self.metastore_conn_id)
def poke_partition(partition):
schema, table, partition = self.parse_partition_name(partition)
logging.info(
'Poking for {schema}.{table}/{partition}'.format(**locals())
)
return self.hook.check_for_named_partition(
schema, table, partition)
while self.next_poke_idx < len(self.partition_names):
if poke_partition(self.partition_names[self.next_poke_idx]):
self.next_poke_idx += 1
else:
return False
return True
class HivePartitionSensor(BaseSensorOperator):
""""""
Waits for a partition to show up in Hive.
Note: Because @partition supports general logical operators, it
can be inefficient. Consider using NamedHivePartitionSensor instead if
you don't need the full flexibility of HivePartitionSensor.
:param table: The name of the table to wait for, supports the dot
notation (my_database.my_table)
:type table: string
:param partition: The partition clause to wait for. This is passed as
is to the metastore Thrift client ""get_partitions_by_filter"" method,
and apparently supports SQL like notation as in `ds='2015-01-01'
AND type='value'` and > < sings as in ""ds>=2015-01-01""
:type partition: string
:param metastore_conn_id: reference to the metastore thrift service
connection id
:type metastore_conn_id: str
""""""
template_fields = ('schema', 'table', 'partition',)
@apply_defaults
def __init__(
self,
table, partition=""ds='{{ ds }}'"",
metastore_conn_id='metastore_default',
schema='default',
poke_interval=60*3,
*args, **kwargs):
super(HivePartitionSensor, self).__init__(
poke_interval=poke_interval, *args, **kwargs)
if not partition:
partition = ""ds='{{ ds }}'""
self.metastore_conn_id = metastore_conn_id
self.table = table
self.partition = partition
self.schema = schema
def poke(self, context):
if '.' in self.table:
self.schema, self.table = self.table.split('.')
logging.info(
'Poking for table {self.schema}.{self.table}, '
'partition {self.partition}'.format(**locals()))
if not hasattr(self, 'hook'):
self.hook = airflow.hooks.hive_hooks.HiveMetastoreHook(
metastore_conn_id=self.metastore_conn_id)
return self.hook.check_for_partition(
self.schema, self.table, self.partition)
class HdfsSensor(BaseSensorOperator):
""""""
Waits for a file or folder to land in HDFS
""""""
template_fields = ('filepath',)
@apply_defaults
def __init__(
self,
filepath,
hdfs_conn_id='hdfs_default',
*args, **kwargs):
super(HdfsSensor, self).__init__(*args, **kwargs)
self.filepath = filepath
self.hdfs_conn_id = hdfs_conn_id
def poke(self, context):
import airflow.hooks.hdfs_hook
sb = airflow.hooks.hdfs_hook.HDFSHook(self.hdfs_conn_id).get_conn()
logging.getLogger(""snakebite"").setLevel(logging.WARNING)
logging.info(
'Poking for file {self.filepath} '.format(**locals()))
try:
files = [f for f in sb.ls([self.filepath])]
except:
return False
return True
class WebHdfsSensor(BaseSensorOperator):
""""""
Waits for a file or folder to land in HDFS
""""""
template_fields = ('filepath',)
@apply_defaults
def __init__(
self,
filepath,
webhdfs_conn_id='webhdfs_default',
*args, **kwargs):
super(WebHdfsSensor, self).__init__(*args, **kwargs)
self.filepath = filepath
self.webhdfs_conn_id = webhdfs_conn_id
def poke(self, context):
c = airflow.hooks.webhdfs_hook.WebHDFSHook(self.webhdfs_conn_id)
logging.info(
'Poking for file {self.filepath} '.format(**locals()))
return c.check_for_path(hdfs_path=self.filepath)
class S3KeySensor(BaseSensorOperator):
""""""
Waits for a key (a file-like instance on S3) to be present in a S3 bucket.
S3 being a key/value it does not support folders. The path is just a key
a resource.
:param bucket_key: The key being waited on. Supports full s3:// style url
or relative path from root level.
:type bucket_key: str
:param bucket_name: Name of the S3 bucket
:type bucket_name: str
:param wildcard_match: whether the bucket_key should be interpreted as a
Unix wildcard pattern
:type wildcard_match: bool
:param s3_conn_id: a reference to the s3 connection
:type s3_conn_id: str
""""""
template_fields = ('bucket_key', 'bucket_name')
@apply_defaults
def __init__(
self, bucket_key,
bucket_name=None,
wildcard_match=False,
s3_conn_id='s3_default',
*args, **kwargs):
super(S3KeySensor, self).__init__(*args, **kwargs)
session = settings.Session()
db = session.query(DB).filter(DB.conn_id == s3_conn_id).first()
if not db:
raise AirflowException(""conn_id doesn't exist in the repository"")
# Parse
if bucket_name is None:
parsed_url = urlparse(bucket_key)
if parsed_url.netloc == '':
raise AirflowException('Please provide a bucket_name')
else:
bucket_name = parsed_url.netloc
if parsed_url.path[0] == '/':
bucket_key = parsed_url.path[1:]
else:
bucket_key = parsed_url.path
self.bucket_name = bucket_name
self.bucket_key = bucket_key
self.wildcard_match = wildcard_match
self.s3_conn_id = s3_conn_id
session.commit()
session.close()
def poke(self, context):
import airflow.hooks.S3_hook
hook = airflow.hooks.S3_hook.S3Hook(s3_conn_id=self.s3_conn_id)
full_url = ""s3://"" + self.bucket_name + ""/"" + self.bucket_key
logging.info('Poking for key : {full_url}'.format(**locals()))
if self.wildcard_match:
return hook.check_for_wildcard_key(self.bucket_key,
self.bucket_name)
else:
return hook.check_for_key(self.bucket_key, self.bucket_name)
class S3PrefixSensor(BaseSensorOperator):
""""""
Waits for a prefix to exist. A prefix is the first part of a key,
thus enabling checking of constructs similar to glob airfl* or
SQL LIKE 'airfl%'. There is the possibility to precise a delimiter to
indicate the hierarchy or keys, meaning that the match will stop at that
delimiter. Current code accepts sane delimiters, i.e. characters that
are NOT special characters in the Python regex engine.
:param bucket_name: Name of the S3 bucket
:type bucket_name: str
:param prefix: The prefix being waited on. Relative path from bucket root level.
:type prefix: str
:param delimiter: The delimiter intended to show hierarchy.
Defaults to '/'.
:type delimiter: str
""""""
template_fields = ('prefix', 'bucket_name')
@apply_defaults
def __init__(
self, bucket_name,
prefix, delimiter='/',
s3_conn_id='s3_default',
*args, **kwargs):
super(S3PrefixSensor, self).__init__(*args, **kwargs)
session = settings.Session()
db = session.query(DB).filter(DB.conn_id == s3_conn_id).first()
if not db:
raise AirflowException(""conn_id doesn't exist in the repository"")
# Parse
self.bucket_name = bucket_name
self.prefix = prefix
self.delimiter = delimiter
self.full_url = ""s3://"" + bucket_name + '/' + prefix
self.s3_conn_id = s3_conn_id
session.commit()
session.close()
def poke(self, context):
logging.info('Poking for prefix : {self.prefix}\n'
'in bucket s3://{self.bucket_name}'.format(**locals()))
import airflow.hooks.S3_hook
hook = airflow.hooks.S3_hook.S3Hook(s3_conn_id=self.s3_conn_id)
return hook.check_for_prefix(
prefix=self.prefix,
delimiter=self.delimiter,
bucket_name=self.bucket_name)
class TimeSensor(BaseSensorOperator):
""""""
Waits until the specified time of the day.
:param target_time: time after which the job succeeds
:type target_time: datetime.time
""""""
template_fields = tuple()
@apply_defaults
def __init__(self, target_time, *args, **kwargs):
super(TimeSensor, self).__init__(*args, **kwargs)
self.target_time = target_time
def poke(self, context):
logging.info(
'Checking if the time ({0}) has come'.format(self.target_time))
return datetime.now().time() > self.target_time
class TimeDeltaSensor(BaseSensorOperator):
""""""
Waits for a timedelta after the task's execution_date + schedule_interval.
In Airflow, the daily task stamped with ``execution_date``
2016-01-01 can only start running on 2016-01-02. The timedelta here
represents the time after the execution period has closed.
:param delta: time length to wait after execution_date before succeeding
:type delta: datetime.timedelta
""""""
template_fields = tuple()
@apply_defaults
def __init__(self, delta, *args, **kwargs):
super(TimeDeltaSensor, self).__init__(*args, **kwargs)
self.delta = delta
def poke(self, context):
dag = context['dag']
target_dttm = dag.following_schedule(context['execution_date'])
target_dttm += self.delta
logging.info('Checking if the time ({0}) has come'.format(target_dttm))
return datetime.now() > target_dttm
class HttpSensor(BaseSensorOperator):
""""""
Executes a HTTP get statement and returns False on failure:
404 not found or response_check function returned False
:param http_conn_id: The connection to run the sensor against
:type http_conn_id: string
:param endpoint: The relative part of the full url
:type endpoint: string
:param params: The parameters to be added to the GET url
:type params: a dictionary of string key/value pairs
:param headers: The HTTP headers to be added to the GET request
:type headers: a dictionary of string key/value pairs
:param response_check: A check against the 'requests' response object.
Returns True for 'pass' and False otherwise.
:type response_check: A lambda or defined function.
:param extra_options: Extra options for the 'requests' library, see the
'requests' documentation (options to modify timeout, ssl, etc.)
:type extra_options: A dictionary of options, where key is string and value
depends on the option that's being modified.
""""""
template_fields = ('endpoint',)
@apply_defaults
def __init__(self,
endpoint,
http_conn_id='http_default',
params=None,
headers=None,
response_check=None,
extra_options=None, *args, **kwargs):
super(HttpSensor, self).__init__(*args, **kwargs)
self.endpoint = endpoint
self.http_conn_id = http_conn_id
self.params = params or {}
self.headers = headers or {}
self.extra_options = extra_options or {}
self.response_check = response_check
self.hook = hooks.http_hook.HttpHook(method='GET', http_conn_id=http_conn_id)
def poke(self, context):
logging.info('Poking: ' + self.endpoint)
try:
response = self.hook.run(self.endpoint,
data=self.params,
headers=self.headers,
extra_options=self.extra_options)
if self.response_check:
# run content check on response
return self.response_check(response)
except AirflowException as ae:
if str(ae).startswith(""404""):
return False
raise ae
return True
",1
"""
import argparse
import datetime
import hashlib
import json
import logging
import os
import resource
import shutil
import sys
import tempfile
import time
import zipfile
def _main():
parser = argparse.ArgumentParser()
parser.add_argument('config', help='JSON configuration file')
parser.add_argument('--only-download', action='store_true', help='Only download GTFS file')
parser.add_argument('--use-no-q-dirs', action='store_true', help='Do not use Q dirs')
args = parser.parse_args()
_init_logging()
start_time = time.time()
logging.debug('started {}'.format(sys.argv))
config = _load_config(args.config)
gtfs_name = config['name']
downloaded_gtfs_zip = _download_gtfs(config['url'])
modify_date = _get_modify_date(downloaded_gtfs_zip)
gtfs_dir = _get_q_dir(config['gtfs_dir'], modify_date, not args.use_no_q_dirs)
gtfs_zip = _rename_gtfs_zip(gtfs_dir, downloaded_gtfs_zip, gtfs_name, modify_date)
if gtfs_zip and (not args.only_download):
log_dir = _get_q_dir(config['log_dir'], modify_date, not args.use_no_q_dirs)
_generate_json(gtfs_name, modify_date, gtfs_zip, config['json_dir'], log_dir)
logging.debug('took {} seconds, max mem: {} megabytes'.format(
int(time.time() - start_time), resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024))
def _init_logging():
log_format = '%(asctime)s %(levelname)s %(filename)s:%(lineno)d %(funcName)s: %(message)s'
logging.basicConfig(filename='generate.log', format=log_format, level=logging.DEBUG)
def _progress(text):
print(text)
logging.debug(text)
def _progress_warning(text):
print('\033[31m{}\033[0m'.format(text))
logging.warning(text)
def _load_config(config_path):
with open(config_path) as config_file:
return json.load(config_file)
def _download_gtfs(url):
output_file, output_filename = tempfile.mkstemp(dir='.')
os.close(output_file)
curl_options = '--header ""Accept-Encoding: gzip"" --location'
command = 'curl {} ""{}"" > {}'.format(curl_options, url, output_filename)
_progress('downloading gtfs file into: {}'.format(os.path.relpath(output_filename)))
_execute_command(command)
return output_filename
def _execute_command(command):
if os.system(command) != 0:
raise SystemExit('failed to execute: {}'.format(command))
def _get_modify_date(zip_filename):
modify_times = _get_modify_times(zip_filename)
if len(modify_times) > 1:
_progress_warning('multiple modify times: {}'.format(modify_times))
return sorted(modify_times)[-1]
def _get_modify_times(zip_filename):
modify_times = set()
with zipfile.ZipFile(zip_filename) as zip_file:
for info in zip_file.infolist():
modify_times.add(datetime.datetime(*info.date_time).strftime('%Y%m%d'))
return modify_times
def _get_q_dir(base_dir, modify_date, create_q_dir):
if create_q_dir:
modify_month = int(modify_date[4:6])
q_dir = '{}_q{}'.format(modify_date[:4], 1 + ((modify_month - 1) // 3))
return os.path.join(base_dir, q_dir)
return base_dir
def _rename_gtfs_zip(gtfs_dir, old_filename, gtfs_name, modify_date):
_create_dir(gtfs_dir)
new_filename = os.path.join(gtfs_dir, '{}_{}.zip'.format(gtfs_name, modify_date))
if os.path.isfile(new_filename):
if _compare_files(old_filename, new_filename):
_progress('downloaded gtfs file is identical to: {}'.format(new_filename))
os.remove(old_filename)
return None
_rename_existing_file(new_filename)
os.rename(old_filename, new_filename)
_progress('renamed: {} -> {}'.format(old_filename, new_filename))
return new_filename
def _create_dir(new_dir):
if not os.path.isdir(new_dir):
os.makedirs(new_dir)
def _compare_files(filename_a, filename_b):
return _get_hash(filename_a) == _get_hash(filename_b)
def _get_hash(filename):
file_hash = hashlib.sha256()
with open(filename, 'rb') as input_file:
file_hash.update(input_file.read())
return file_hash.digest()
def _generate_json(gtfs_name, modify_date, gtfs_zip, json_dir, log_dir):
_create_dir(json_dir)
date_output_file = os.path.join(json_dir, '{}_{}.json'.format(gtfs_name, modify_date))
_rename_existing_file(date_output_file)
_create_dir(log_dir)
log_path = os.path.join(log_dir, 'gtfs2json_{}_{}_{}.log'.format(gtfs_name, modify_date,
_get_now_timestamp()))
_progress('generating json for {}'.format(gtfs_zip))
command = '{}/gtfs2json.py --log-file {} {} {}'.format(os.path.dirname(__file__), log_path,
gtfs_zip, date_output_file)
_execute_command(command)
_create_base_output_file(date_output_file, os.path.join(json_dir, '{}.json'.format(gtfs_name)))
def _create_base_output_file(date_output_file, base_output_file):
if os.path.isfile(base_output_file):
_progress('deleting {}'.format(base_output_file))
os.remove(base_output_file)
_progress('copying {} to {}'.format(date_output_file, base_output_file))
shutil.copyfile(date_output_file, base_output_file)
def _rename_existing_file(filename):
if os.path.isfile(filename):
suffix = filename.split('.')[-1]
new_filename = filename.replace('.{}'.format(suffix),
'_{}.{}'.format(_get_now_timestamp(), suffix))
os.rename(filename, new_filename)
_progress_warning('renamed existing {} file {} -> {}'.format(suffix, filename,
new_filename))
def _get_now_timestamp():
return datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
if __name__ == ""__main__"":
_main()
",1
" function from
a list to a list. These lists are of lists of arbitrary
objects other than streams and agents.
Function f must be stateless, i.e., for any lists u, v:
f(u.extend(v)) = f(u).extend(f(v))
(Stateful functions are given in OpStateful.py with
examples in ExamplesOpWithState.py.)
Let f be a stateless operator on lists and let x be a stream.
If at some point, the value of stream x is a list u then at
that point, the value of stream op(f,x) is the list f(u).
If at a later point, the value of stream x is the list:
u.extend(v) then, at that point the value of stream op(f,x)
is f(u).extend(f(v)).
As a specific example, consider the following f():
def f(lst): return [w * w for w in lst]
If at some point in time, the value of x is [3, 7],
then at that point the value of op(f,x) is f([3, 7])
or [9, 49]. If at a later point, the value of x is
[3, 7, 0, 11, 5] then the value of op(f,x) at that point
is f([3, 7, 0, 11, 5]) or [9, 49, 0, 121, 25].
""""""
if __name__ == '__main__':
if __package__ is None:
import sys
from os import path
sys.path.append( path.dirname( path.dirname( path.abspath(__file__) ) ) )
from Agent import *
from ListOperators import *
from PrintFunctions import print_streams_recent
def example_1():
print ""example_1""
print ""op(f, x): f is a function from a list to a list""
print ""x is a stream \n""
# FUNCTIONS FROM LIST TO LIST
# This example uses the following list operators:
# functions from a list to a list.
# f, g, h, r
# Example A: function using list comprehension
def f(lst): return [w*w for w in lst]
# Example B: function using filter
threshold = 6
def predicate(w):
return w > threshold
def g(lst):
return filter(predicate, lst)
# Example C: function using map
# Raise each element of the list to the n-th power.
n = 3
def power(w):
return w**n
def h(lst):
return map(power, lst)
# Example D: function using another list comprehension
# Discard any element of x that is not a
# multiple of a parameter n, and divide the
# elements that are multiples of n by n.
n = 3
def r(lst):
result = []
for w in lst:
if w%n == 0: result.append(w/n)
return result
# EXAMPLES OF OPERATIONS ON STREAMS
# The input stream for these examples
x = Stream('x')
print 'x is the input stream.'
print 'a is a stream consisting of the squares of the input'
print 'b is the stream consisting of values that exceed 6'
print 'c is the stream consisting of the third powers of the input'
print 'd is the stream consisting of values that are multiples of 3 divided by 3'
print 'newa is the same as a. It is defined in a more succinct fashion.'
print 'newb has squares that exceed 6.'
print ''
# The output streams a, b, c, d obtained by
# applying the list operators f, g, h, r to
# stream x.
a = op(f, x)
b = op(g, x)
c = op(h, x)
d = op(r, x)
# You can also define a function only on streams.
# You can do this using functools in Python or
# by simple encapsulation as shown below.
def F(x): return op(f,x)
def G(x): return op(g,x)
newa = F(x)
newb = G(F(x))
# The advantage is that F is a function only
# of streams. So, function composition looks cleaner
# as in G(F(x))
# Name the output streams to label the output
# so that reading the output is easier.
a.set_name('a')
newa.set_name('newa')
b.set_name('b')
newb.set_name('newb')
c.set_name('c')
d.set_name('d')
# At this point x is the empty stream:
# its value is []
x.extend([3, 7])
# Now the value of x is [3, 7]
print ""FIRST STEP""
print_streams_recent([x, a, b, c, d, newa, newb])
print """"
x.extend([0, 11, 15])
# Now the value of x is [3, 7, 0, 11, 15]
print ""SECOND STEP""
print_streams_recent([x, a, b, c, d, newa, newb])
def main():
example_1()
if __name__ == '__main__':
main()
",1
"om itertools import izip
from Bio.Align import MultipleSeqAlignment
from Bio.Seq import Seq
from scipy import stats
import numpy as np
class virus_clean(object):
""""""docstring for virus_clean""""""
def __init__(self,n_iqd = 5, **kwargs):
'''
parameters
n_std -- number of interquartile distances accepted in molecular clock filter
'''
self.n_iqd = n_iqd
def remove_insertions(self):
'''
remove all columns from the alignment in which the outgroup is gapped
'''
outgroup_ok = np.array(self.sequence_lookup[self.outgroup['strain']])!='-'
for seq in self.viruses:
seq.seq = Seq("""".join(np.array(seq.seq)[outgroup_ok]).upper())
def clean_gaps(self):
'''
remove viruses with gaps -- not part of the standard pipeline
'''
self.viruses = filter(lambda x: '-' in x.seq, self.viruses)
def clean_ambiguous(self):
'''
substitute all ambiguous characters with '-',
ancestral inference will interpret this as missing data
'''
for v in self.viruses:
v.seq = Seq(re.sub(r'[BDEFHIJKLMNOPQRSUVWXYZ]', '-',str(v.seq)))
def unique_date(self):
'''
add a unique numerical date to each leaf. uniqueness is achieved adding a small number
'''
from date_util import numerical_date
og = self.sequence_lookup[self.outgroup['strain']]
if hasattr(og, 'date'):
try:
og.num_date = numerical_date(og.date)
except:
print ""cannot parse date""
og.num_date=""undefined"";
for ii, v in enumerate(self.viruses):
if hasattr(v, 'date'):
try:
v.num_date = numerical_date(v.date, self.date_format['fields']) + 1e-7*(ii+1)
except:
print ""cannot parse date""
v.num_date=""undefined"";
def times_from_outgroup(self):
outgroup_date = self.sequence_lookup[self.outgroup['strain']].num_date
return np.array([x.num_date-outgroup_date for x in self.viruses if x.strain])
def distance_from_outgroup(self):
from seq_util import hamming_distance
outgroup_seq = self.sequence_lookup[self.outgroup['strain']].seq
return np.array([hamming_distance(x.seq, outgroup_seq) for x in self.viruses if x.strain])
def clean_distances(self):
""""""Remove viruses that don't follow a loose clock """"""
times = self.times_from_outgroup()
distances = self.distance_from_outgroup()
slope, intercept, r_value, p_value, std_err = stats.linregress(times, distances)
residuals = slope*times + intercept - distances
r_iqd = stats.scoreatpercentile(residuals,75) - stats.scoreatpercentile(residuals,25)
if self.verbose:
print ""\tslope: "" + str(slope)
print ""\tr: "" + str(r_value)
print ""\tresiduals iqd: "" + str(r_iqd)
new_viruses = []
for (v,r) in izip(self.viruses,residuals):
# filter viruses more than n_std standard devitations up or down
if np.abs(r)1:
print ""\t\tresidual:"", r, ""\nremoved "",v.strain
self.viruses = MultipleSeqAlignment(new_viruses)
def clean_generic(self):
print ""Number of viruses before cleaning:"",len(self.viruses)
self.unique_date()
self.remove_insertions()
self.clean_ambiguous()
self.clean_distances()
self.viruses.sort(key=lambda x:x.num_date)
print ""Number of viruses after outlier filtering:"",len(self.viruses)
",1
"ange(i) for i in d] # 0 [[int]]
y = [(a,b) for a,b in {1:'2'}.iteritems()] # 0 [(int,str)]
b = 1 # 0 int
if 0:
b = '' # 4 str
else:
b = str(b) # 4 str # 12 int
r = 0 # 0 int
if r: # 3 int
r = str(r) # 4 str # 12 int
r # 0
l = range(5) # 0 [int]
l2 = l[2:3] # 0 [int]
x = l2[1] # 0 int
k = 1() # 0 # e 4
del k
k # e 0
l = [] # 0 [int]
x = 1 # 0 int
while x: # 6 int
l = [] # 4 [int]
l.append(1) # 0 [int] # 2 (int) -> None
l = [1, 2] # 0 [int]
l2 = [x for x in l] # 0 []
l2.append('') # 0 []
s = str() # 0 str
s2 = str(s) # 0 str
s3 = repr() # e 5 # 0 str
s4 = repr(s) # 0 str
x = 1 if [] else '' # 0
l = [1] # 0 []
l2 = [''] # 0 [str]
l[:] = l2 # 0 []
b = 1 < 2 < 3 # 0 bool
l = sorted(range(5), key=lambda x:-x) # 0 [int]
d = {} # 0 {:}
d1 = {1:''} # 0 {int:str}
d.update(d1)
d[True] = 1
d # 0 {:}
l = [] # 0 [int]
l1 = [] # 0 []
l.extend(l1)
l.append(2)
l = [] # 0 [<[str]|int>]
l1 = [[]] # 0 [[str]]
l.extend(l1)
l[0].append('') # e 0
l.append(1)
l = [] # 0 [[]]
l2 = [1] # 0 [int]
l3 = [''] # 0 [str]
l.append(l2)
l.append(l3)
for i, s in enumerate(""aoeu""): # 4 int # 7 str
pass
x = 1 # 0 int
y = x + 1.0 # 0 float
y << 1 # e 0
l = [1, 1.0] # 0 [float]
1.0 in [1] # e 0
x = `1` # 0 str
def f():
x = `1` # 4 str
d = dict(a=1) # 0 {str:int}
l = list() # 0 []
i = int(1) # 0 int
i = int(1.2) # 0 int
i = abs(1) # 0 int
i = abs(1.0) # 0 float
d = dict() # 0 {int:int}
d[1] = 2
d2 = dict(d) # 0 {:}
d2[''] = ''
d3 = dict([(1,2)]) # 0 {int:int}
d4 = dict(a=1) # 0 {str:int}
",1
"datetime import datetime
import argparse
import shutil
import math
from glob import glob
import gzip
from shi7 import __version__
from shi7.shi7 import TRUE_FALSE_DICT, read_fastq, axe_adaptors_single_end, axe_adaptors_paired_end, flash_part1, \
flash_part2, split_fwd_rev, match_pairs, link_manicured_names
def make_arg_parser():
parser = argparse.ArgumentParser(description='This is the commandline interface for shi7_learning',
usage='shi7_learning v{version}\nshi7_learning.py -i -o
'.format(error) ",1 "oder from deepy.trainers import SGDTrainer, LearningRateAnnealer from util import get_data, VECTOR_SIZE model_path = os.path.join(os.path.dirname(__file__), ""models"", ""rae1.gz"") if __name__ == '__main__': model = RecursiveAutoEncoder(input_dim=VECTOR_SIZE, rep_dim=10) trainer = SGDTrainer(model) annealer = LearningRateAnnealer() trainer.run(get_data(), epoch_controllers=[annealer]) model.save_params(model_path) ",1 "he prior for U and V we take value 1 for all entries (so exp 1). As a result, each value in R has a value of around 20, and a variance of 100-120. For contrast, the Sanger dataset of 705 by 140 shifted to nonnegative has mean 31.522999753779082 and variance 243.2427345740027. We add Gaussian noise of precision tau = 1 (prior for gamma: alpha=1,beta=1). (Simply using the expectation of our Gamma distribution over tau) """""" import sys, os project_location = os.path.dirname(__file__)+""/../../../"" sys.path.append(project_location) from BNMTF.code.models.distributions.exponential import exponential_draw from BNMTF.code.models.distributions.normal import normal_draw from BNMTF.code.cross_validation.mask import generate_M import numpy, itertools, matplotlib.pyplot as plt def generate_dataset(I,J,K,lambdaU,lambdaV,tau): # Generate U, V U = numpy.zeros((I,K)) for i,k in itertools.product(xrange(0,I),xrange(0,K)): U[i,k] = exponential_draw(lambdaU[i,k]) V = numpy.zeros((J,K)) for j,k in itertools.product(xrange(0,J),xrange(0,K)): V[j,k] = exponential_draw(lambdaV[j,k]) # Generate R true_R = numpy.dot(U,V.T) R = add_noise(true_R,tau) return (U,V,tau,true_R,R) def add_noise(true_R,tau): if numpy.isinf(tau): return numpy.copy(true_R) (I,J) = true_R.shape R = numpy.zeros((I,J)) for i,j in itertools.product(xrange(0,I),xrange(0,J)): R[i,j] = normal_draw(true_R[i,j],tau) return R def try_generate_M(I,J,fraction_unknown,attempts): for attempt in range(1,attempts+1): try: M = generate_M(I,J,fraction_unknown) sums_columns = M.sum(axis=0) sums_rows = M.sum(axis=1) for i,c in enumerate(sums_rows): assert c != 0, ""Fully unobserved row in M, row %s. Fraction %s."" % (i,fraction_unknown) for j,c in enumerate(sums_columns): assert c != 0, ""Fully unobserved column in M, column %s. Fraction %s."" % (j,fraction_unknown) print ""Took %s attempts to generate M."" % attempt return M except AssertionError: pass raise Exception(""Tried to generate M %s times, with I=%s, J=%s, fraction=%s, but failed."" % (attempts,I,J,fraction_unknown)) ########## if __name__ == ""__main__"": output_folder = project_location+""BNMTF/data_toy/bnmf/"" I,J,K = 100, 80, 10 #20, 10, 5 # fraction_unknown = 0.1 alpha, beta = 1., 1. lambdaU = numpy.ones((I,K)) lambdaV = numpy.ones((I,K)) tau = alpha / beta (U,V,tau,true_R,R) = generate_dataset(I,J,K,lambdaU,lambdaV,tau) # Try to generate M M = try_generate_M(I,J,fraction_unknown,attempts=1000) # Store all matrices in text files numpy.savetxt(open(output_folder+""U.txt"",'w'),U) numpy.savetxt(open(output_folder+""V.txt"",'w'),V) numpy.savetxt(open(output_folder+""R_true.txt"",'w'),true_R) numpy.savetxt(open(output_folder+""R.txt"",'w'),R) numpy.savetxt(open(output_folder+""M.txt"",'w'),M) print ""Mean R: %s. Variance R: %s. Min R: %s. Max R: %s."" % (numpy.mean(R),numpy.var(R),R.min(),R.max()) fig = plt.figure() plt.hist(R.flatten(),bins=range(0,int(R.max())+1)) plt.show()",1 "er Research & Fraunhofer SCAI # # This file is part of ESPResSo++. # # ESPResSo++ 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. # # ESPResSo++ 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
Number letter counts
Problem 17
Published on Friday, 17th May 2002, 06:00 pm; Solved by 88413; Difficulty rating: 5%If the numbers 1 to 5 are written out in words: one, two, three, four, five, then there are 3 + 3 + 5 + 4 + 4 = 19 letters used in total.
If all the numbers from 1 to 1000 (one thousand) inclusive were written out in words, how many letters would be used?
NOTE: Do not count spaces or hyphens. For example, 342 (three hundred and forty-two) contains 23 letters and 115 (one hundred and fifteen) contains 20 letters. The use of ""and"" when writing out numbers is in compliance with British usage.
"""""" s={0:"""",1:""one"",2:""two"",3:""three"",4:""four"",5:""five"",6:""six"",7:""seven"",8:""eight"",9:""nine"",10:""ten"",11:""eleven"",12:""twelve"",13:""thirteen"",14:""fourteen"",15:""fifteen"",16:""sixteen"",17:""seventeen"",18:""eighteen"",19:""nineteen"",20:""twenty"",30:""thirty"",40:""forty"",50:""fifty"",60:""sixty"",70:""seventy"",80:""eighty"",90:""ninety""} for i in range(1,1000): if(not i in s.keys()): if(i<100): s[i]=s[i/10*10]+s[i%10] else: s[i]=s[i/100]+""hundred"" if(i%100): s[i]+=""and""+s[i%100] s[1000]=""onethousand"" total=0; for i in s.values(): total+=len(i) print total ",1 "https://www.gnu.org/licenses/gpl-3.0.txt) from __future__ import absolute_import, division, print_function __metaclass__ = type DOCUMENTATION = ''' --- module: group version_added: ""0.0.2"" short_description: Add or remove groups requirements: - groupadd - groupdel - groupmod description: - Manage presence of groups on a host. - For Windows targets, use the M(win_group) module instead. options: name: description: - Name of the group to manage. type: str required: true gid: description: - Optional I(GID) to set for the group. type: int state: description: - Whether the group should be present or not on the remote host. type: str choices: [ absent, present ] default: present system: description: - If I(yes), indicates that the group created is a system group. type: bool default: no local: description: - Forces the use of ""local"" command alternatives on platforms that implement it. - This is useful in environments that use centralized authentication when you want to manipulate the local groups. (e.g. it uses C(lgroupadd) instead of C(groupadd)). - This requires that these commands exist on the targeted host, otherwise it will be a fatal error. type: bool default: no version_added: ""2.6"" non_unique: description: - This option allows to change the group ID to a non-unique value. Requires C(gid). - Not supported on macOS or BusyBox distributions. type: bool default: no version_added: ""2.8"" seealso: - module: user - module: win_group author: - Stephen Fromm (@sfromm) ''' EXAMPLES = ''' - name: Ensure group ""somegroup"" exists group: name: somegroup state: present - name: Ensure group ""docker"" exists with correct gid group: name: docker state: present gid: 1750 ''' RETURN = r''' gid: description: Group ID of the group. returned: When C(state) is 'present' type: int sample: 1001 name: description: Group name returned: always type: str sample: users state: description: Whether the group is present or not returned: always type: str sample: 'absent' system: description: Whether the group is a system group or not returned: When C(state) is 'present' type: bool sample: False ''' import grp import os from ansible.module_utils._text import to_bytes from ansible.module_utils.basic import AnsibleModule from ansible.module_utils.common.sys_info import get_platform_subclass class Group(object): """""" This is a generic Group manipulation class that is subclassed based on platform. A subclass may wish to override the following action methods:- - group_del() - group_add() - group_mod() All subclasses MUST define platform and distribution (which may be None). """""" platform = 'Generic' distribution = None GROUPFILE = '/etc/group' def __new__(cls, *args, **kwargs): new_cls = get_platform_subclass(Group) return super(cls, new_cls).__new__(new_cls) def __init__(self, module): self.module = module self.state = module.params['state'] self.name = module.params['name'] self.gid = module.params['gid'] self.system = module.params['system'] self.local = module.params['local'] self.non_unique = module.params['non_unique'] def execute_command(self, cmd): return self.module.run_command(cmd) def group_del(self): if self.local: command_name = 'lgroupdel' else: command_name = 'groupdel' cmd = [self.module.get_bin_path(command_name, True), self.name] return self.execute_command(cmd) def _local_check_gid_exists(self): if self.gid: for gr in grp.getgrall(): if self.gid == gr.gr_gid and self.name != gr.gr_name: self.module.fail_json(msg=""GID '{0}' already exists with group '{1}'"".format(self.gid, gr.gr_name)) def group_add(self, **kwargs): if self.local: command_name = 'lgroupadd' self._local_check_gid_exists() else: command_name = 'groupadd' cmd = [self.module.get_bin_path(command_name, True)] for key in kwargs: if key == 'gid' and kwargs[key] is not None: cmd.append('-g') cmd.append(str(kwargs[key])) if self.non_unique: cmd.append('-o') elif key == 'system' and kwargs[key] is True: cmd.append('-r') cmd.append(self.name) return self.execute_command(cmd) def group_mod(self, **kwargs): if self.local: command_name = 'lgroupmod' self._local_check_gid_exists() else: command_name = 'groupmod' cmd = [self.module.get_bin_path(command_name, True)] info = self.group_info() for key in kwargs: if key == 'gid': if kwargs[key] is not None and info[2] != int(kwargs[key]): cmd.append('-g') cmd.append(str(kwargs[key])) if self.non_unique: cmd.append('-o') if len(cmd) == 1: return (None, '', '') if self.module.check_mode: return (0, '', '') cmd.append(self.name) return self.execute_command(cmd) def group_exists(self): # The grp module does not distinguish between local and directory accounts. # It's output cannot be used to determine whether or not a group exists locally. # It returns True if the group exists locally or in the directory, so instead # look in the local GROUP file for an existing account. if self.local: if not os.path.exists(self.GROUPFILE): self.module.fail_json(msg=""'local: true' specified but unable to find local group file {0} to parse."".format(self.GROUPFILE)) exists = False name_test = '{0}:'.format(self.name) with open(self.GROUPFILE, 'rb') as f: reversed_lines = f.readlines()[::-1] for line in reversed_lines: if line.startswith(to_bytes(name_test)): exists = True break if not exists: self.module.warn( ""'local: true' specified and group was not found in {file}. "" ""The local group may already exist if the local group database exists somewhere other than {file}."".format(file=self.GROUPFILE)) return exists else: try: if grp.getgrnam(self.name): return True except KeyError: return False def group_info(self): if not self.group_exists(): return False try: info = list(grp.getgrnam(self.name)) except KeyError: return False return info # =========================================== class SunOS(Group): """""" This is a SunOS Group manipulation class. Solaris doesn't have the 'system' group concept. This overrides the following methods from the generic class:- - group_add() """""" platform = 'SunOS' distribution = None GROUPFILE = '/etc/group' def group_add(self, **kwargs): cmd = [self.module.get_bin_path('groupadd', True)] for key in kwargs: if key == 'gid' and kwargs[key] is not None: cmd.append('-g') cmd.append(str(kwargs[key])) if self.non_unique: cmd.append('-o') cmd.append(self.name) return self.execute_command(cmd) # =========================================== class AIX(Group): """""" This is a AIX Group manipulation class. This overrides the following methods from the generic class:- - group_del() - group_add() - group_mod() """""" platform = 'AIX' distribution = None GROUPFILE = '/etc/group' def group_del(self): cmd = [self.module.get_bin_path('rmgroup', True), self.name] return self.execute_command(cmd) def group_add(self, **kwargs): cmd = [self.module.get_bin_path('mkgroup', True)] for key in kwargs: if key == 'gid' and kwargs[key] is not None: cmd.append('id=' + str(kwargs[key])) elif key == 'system' and kwargs[key] is True: cmd.append('-a') cmd.append(self.name) return self.execute_command(cmd) def group_mod(self, **kwargs): cmd = [self.module.get_bin_path('chgroup', True)] info = self.group_info() for key in kwargs: if key == 'gid': if kwargs[key] is not None and info[2] != int(kwargs[key]): cmd.append('id=' + str(kwargs[key])) if len(cmd) == 1: return (None, '', '') if self.module.check_mode: return (0, '', '') cmd.append(self.name) return self.execute_command(cmd) # =========================================== class FreeBsdGroup(Group): """""" This is a FreeBSD Group manipulation class. This overrides the following methods from the generic class:- - group_del() - group_add() - group_mod() """""" platform = 'FreeBSD' distribution = None GROUPFILE = '/etc/group' def group_del(self): cmd = [self.module.get_bin_path('pw', True), 'groupdel', self.name] return self.execute_command(cmd) def group_add(self, **kwargs): cmd = [self.module.get_bin_path('pw', True), 'groupadd', self.name] if self.gid is not None: cmd.append('-g') cmd.append(str(self.gid)) if self.non_unique: cmd.append('-o') return self.execute_command(cmd) def group_mod(self, **kwargs): cmd = [self.module.get_bin_path('pw', True), 'groupmod', self.name] info = self.group_info() cmd_len = len(cmd) if self.gid is not None and int(self.gid) != info[2]: cmd.append('-g') cmd.append(str(self.gid)) if self.non_unique: cmd.append('-o') # modify the group if cmd will do anything if cmd_len != len(cmd): if self.module.check_mode: return (0, '', '') return self.execute_command(cmd) return (None, '', '') class DragonFlyBsdGroup(FreeBsdGroup): """""" This is a DragonFlyBSD Group manipulation class. It inherits all behaviors from FreeBsdGroup class. """""" platform = 'DragonFly' # =========================================== class DarwinGroup(Group): """""" This is a Mac macOS Darwin Group manipulation class. This overrides the following methods from the generic class:- - group_del() - group_add() - group_mod() group manipulation are done using dseditgroup(1). """""" platform = 'Darwin' distribution = None def group_add(self, **kwargs): cmd = [self.module.get_bin_path('dseditgroup', True)] cmd += ['-o', 'create'] if self.gid is not None: cmd += ['-i', str(self.gid)] elif 'system' in kwargs and kwargs['system'] is True: gid = self.get_lowest_available_system_gid() if gid is not False: self.gid = str(gid) cmd += ['-i', str(self.gid)] cmd += ['-L', self.name] (rc, out, err) = self.execute_command(cmd) return (rc, out, err) def group_del(self): cmd = [self.module.get_bin_path('dseditgroup', True)] cmd += ['-o', 'delete'] cmd += ['-L', self.name] (rc, out, err) = self.execute_command(cmd) return (rc, out, err) def group_mod(self, gid=None): info = self.group_info() if self.gid is not None and int(self.gid) != info[2]: cmd = [self.module.get_bin_path('dseditgroup', True)] cmd += ['-o', 'edit'] if gid is not None: cmd += ['-i', str(gid)] cmd += ['-L', self.name] (rc, out, err) = self.execute_command(cmd) return (rc, out, err) return (None, '', '') def get_lowest_available_system_gid(self): # check for lowest available system gid (< 500) try: cmd = [self.module.get_bin_path('dscl', True)] cmd += ['/Local/Default', '-list', '/Groups', 'PrimaryGroupID'] (rc, out, err) = self.execute_command(cmd) lines = out.splitlines() highest = 0 for group_info in lines: parts = group_info.split(' ') if len(parts) > 1: gid = int(parts[-1]) if gid > highest and gid < 500: highest = gid if highest == 0 or highest == 499: return False return (highest + 1) except Exception: return False class OpenBsdGroup(Group): """""" This is a OpenBSD Group manipulation class. This overrides the following methods from the generic class:- - group_del() - group_add() - group_mod() """""" platform = 'OpenBSD' distribution = None GROUPFILE = '/etc/group' def group_del(self): cmd = [self.module.get_bin_path('groupdel', True), self.name] return self.execute_command(cmd) def group_add(self, **kwargs): cmd = [self.module.get_bin_path('groupadd', True)] if self.gid is not None: cmd.append('-g') cmd.append(str(self.gid)) if self.non_unique: cmd.append('-o') cmd.append(self.name) return self.execute_command(cmd) def group_mod(self, **kwargs): cmd = [self.module.get_bin_path('groupmod', True)] info = self.group_info() if self.gid is not None and int(self.gid) != info[2]: cmd.append('-g') cmd.append(str(self.gid)) if self.non_unique: cmd.append('-o') if len(cmd) == 1: return (None, '', '') if self.module.check_mode: return (0, '', '') cmd.append(self.name) return self.execute_command(cmd) # =========================================== class NetBsdGroup(Group): """""" This is a NetBSD Group manipulation class. This overrides the following methods from the generic class:- - group_del() - group_add() - group_mod() """""" platform = 'NetBSD' distribution = None GROUPFILE = '/etc/group' def group_del(self): cmd = [self.module.get_bin_path('groupdel', True), self.name] return self.execute_command(cmd) def group_add(self, **kwargs): cmd = [self.module.get_bin_path('groupadd', True)] if self.gid is not None: cmd.append('-g') cmd.append(str(self.gid)) if self.non_unique: cmd.append('-o') cmd.append(self.name) return self.execute_command(cmd) def group_mod(self, **kwargs): cmd = [self.module.get_bin_path('groupmod', True)] info = self.group_info() if self.gid is not None and int(self.gid) != info[2]: cmd.append('-g') cmd.append(str(self.gid)) if self.non_unique: cmd.append('-o') if len(cmd) == 1: return (None, '', '') if self.module.check_mode: return (0, '', '') cmd.append(self.name) return self.execute_command(cmd) # =========================================== class BusyBoxGroup(Group): """""" BusyBox group manipulation class for systems that have addgroup and delgroup. It overrides the following methods: - group_add() - group_del() - group_mod() """""" def group_add(self, **kwargs): cmd = [self.module.get_bin_path('addgroup', True)] if self.gid is not None: cmd.extend(['-g', str(self.gid)]) if self.system: cmd.append('-S') cmd.append(self.name) return self.execute_command(cmd) def group_del(self): cmd = [self.module.get_bin_path('delgroup', True), self.name] return self.execute_command(cmd) def group_mod(self, **kwargs): # Since there is no groupmod command, modify /etc/group directly info = self.group_info() if self.gid is not None and self.gid != info[2]: with open('/etc/group', 'rb') as f: b_groups = f.read() b_name = to_bytes(self.name) b_current_group_string = b'%s:x:%d:' % (b_name, info[2]) b_new_group_string = b'%s:x:%d:' % (b_name, self.gid) if b':%d:' % self.gid in b_groups: self.module.fail_json(msg=""gid '{gid}' in use"".format(gid=self.gid)) if self.module.check_mode: return 0, '', '' b_new_groups = b_groups.replace(b_current_group_string, b_new_group_string) with open('/etc/group', 'wb') as f: f.write(b_new_groups) return 0, '', '' return None, '', '' class AlpineGroup(BusyBoxGroup): platform = 'Linux' distribution = 'Alpine' def main(): module = AnsibleModule( argument_spec=dict( state=dict(type='str', default='present', choices=['absent', 'present']), name=dict(type='str', required=True), gid=dict(type='int'), system=dict(type='bool', default=False), local=dict(type='bool', default=False), non_unique=dict(type='bool', default=False), ), supports_check_mode=True, required_if=[ ['non_unique', True, ['gid']], ], ) group = Group(module) module.debug('Group instantiated - platform %s' % group.platform) if group.distribution: module.debug('Group instantiated - distribution %s' % group.distribution) rc = None out = '' err = '' result = {} result['name'] = group.name result['state'] = group.state if group.state == 'absent': if group.group_exists(): if module.check_mode: module.exit_json(changed=True) (rc, out, err) = group.group_del() if rc != 0: module.fail_json(name=group.name, msg=err) elif group.state == 'present': if not group.group_exists(): if module.check_mode: module.exit_json(changed=True) (rc, out, err) = group.group_add(gid=group.gid, system=group.system) else: (rc, out, err) = group.group_mod(gid=group.gid) if rc is not None and rc != 0: module.fail_json(name=group.name, msg=err) if rc is None: result['changed'] = False else: result['changed'] = True if out: result['stdout'] = out if err: result['stderr'] = err if group.group_exists(): info = group.group_info() result['system'] = group.system result['gid'] = info[2] module.exit_json(**result) if __name__ == '__main__': main() ",1 "fy # 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
Register
\n"", response.data) def test_user_registration(self): # Ensure registration behaves correctlys. with self.client: response = self.client.post( ""/register"", data=dict( email=""test@tester.com"", password=""testing"", confirm=""testing"", ), follow_redirects=True, ) self.assertIn(b""Welcome"", response.data) self.assertTrue(current_user.email == ""test@tester.com"") self.assertTrue(current_user.is_active()) self.assertEqual(response.status_code, 200) if __name__ == ""__main__"": unittest.main() ",1 " ""Make a class named %%% that is-a %%%."", ""class %%%(object):\n\tdef __init__(self, ***)"" : ""class %%% has-a __init__ hat takes self and *** parameter."", ""class %%%(object):\n\tdef ***(self, @@@)"": ""class %%% has-a function named *** that takes self and @@@ parameter."", ""*** = %%%()"": ""Set *** to an instance of class %%%."", ""***.***(@@@)"": ""From *** get the *** function, and call it with parameters self, @@@."", ""***.*** = '***'"": ""From *** get the *** attribute and set it to '***'."" } # do they want to drill phrases first if len(sys.argv) == 2 and sys.argv[1] == ""english"": PHRASE_FIRST = True else: PHRASE_FIRST = False # load up the word from the website for word in urlopen(WORD_URL).readlines(): WORDS.append(word.strip()) def convert(snippet, phrase): class_names = [w.capitalize() for w in random.sample(WORDS, snippet.count(""%%%""))] other_names = random.sample(WORDS, snippet.count(""***"")) results = [] param_names = [] for i in range(0, snippet.count(""@@@"")): param_count = random.randint(1,3) param_names.append(', '.join(random.sample(WORDS, param_count))) for sentence in snippet, phrase: result = sentence[:] # fake class names for word in class_names: result = result.replace(""%%%"", word, 1) # fake other names for word in other_names: result = result.replace(""***"", word, 1) # fake parameter lists for word in param_names: result = result.replace(""@@@"", word, 1) results.append(result) return results # keep going until they hit CTRL-D try: while True: snippets = PHRASES.keys() random.shuffle(snippets) for snippet in snippets: phrase = PHRASES[snippet] question, answer = convert(snippet, phrase) if PHRASE_FIRST: question, answer = answer, question print question raw_input(""> "") print ""ANSWER: %s\n\n"" % answer except EOFError: print ""\nBye"" ",1 "olivre.org> # # 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 requests from unittest import skip from sure import expect from httpretty import HTTPretty @skip def test_http_passthrough(): url = 'http://httpbin.org/status/200' response1 = requests.get(url) response1 = requests.get(url, stream=True) HTTPretty.enable() HTTPretty.register_uri(HTTPretty.GET, 'http://google.com/', body=""Not Google"") response2 = requests.get('http://google.com/') expect(response2.content).to.equal(b'Not Google') response3 = requests.get(url, stream=True) (response3.content).should.equal(response1.content) HTTPretty.disable() response4 = requests.get(url, stream=True) (response4.content).should.equal(response1.content) @skip def test_https_passthrough(): url = 'https://raw.githubusercontent.com/gabrielfalcao/HTTPretty/master/COPYING' response1 = requests.get(url, stream=True) HTTPretty.enable() HTTPretty.register_uri(HTTPretty.GET, 'https://google.com/', body=""Not Google"") response2 = requests.get('https://google.com/') expect(response2.content).to.equal(b'Not Google') response3 = requests.get(url, stream=True) (response3.content).should.equal(response1.content) HTTPretty.disable() response4 = requests.get(url, stream=True) (response4.content).should.equal(response1.content) ",1 "ation self.use_horizontal_flips = True self.use_vertical_flips = True self.rot_90 = True # anchor box scales self.anchor_box_scales = [1, 2, 4, 8, 16, 32, 64, 124, 256, 512] # anchor box ratios self.anchor_box_ratios = [[1, 1], [1, 2], [2, 1],[1,3],[3,1],[4,1],[1,4],[1,5],[5,1],[1,6],[6,1],[1,7],[7,1],[1,8],[8,1],[1,9],[9,1]] # size to resize the smallest side of the image self.im_size = 600 # image channel-wise mean to subtract self.img_channel_mean = [103.939, 116.779, 123.68] self.img_scaling_factor = 1.0 # number of ROIs at once self.num_rois = 8 # stride at the RPN (this depends on the network configuration) self.rpn_stride = 16 self.balanced_classes = False # scaling the stdev self.std_scaling = 4.0 self.classifier_regr_std = [8.0, 8.0, 4.0, 4.0] # overlaps for RPN self.rpn_min_overlap = 0.3 self.rpn_max_overlap = 0.7 # overlaps for classifier ROIs self.classifier_min_overlap = 0.1 self.classifier_max_overlap = 0.5 # placeholder for the class mapping, automatically generated by the parser self.class_mapping = None #location of pretrained weights for the base network # weight files can be found at: # https://github.com/fchollet/deep-learning-models/releases/download/v0.2/resnet50_weights_th_dim_ordering_th_kernels_notop.h5 # https://github.com/fchollet/deep-learning-models/releases/download/v0.2/resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5 self.model_path = 'model_frcnn.vgg.hdf5' ",1 "CENSE file. import shutil import tempfile from telemetry import decorators from telemetry.testing import options_for_unittests from telemetry.testing import page_test_test_case from measurements import skpicture_printer class SkpicturePrinterUnitTest(page_test_test_case.PageTestTestCase): def setUp(self): self._options = options_for_unittests.GetCopy() self._skp_outdir = tempfile.mkdtemp('_skp_test') def tearDown(self): shutil.rmtree(self._skp_outdir) @decorators.Disabled('android') def testSkpicturePrinter(self): ps = self.CreateStorySetFromFileInUnittestDataDir('blank.html') measurement = skpicture_printer.SkpicturePrinter(self._skp_outdir) results = self.RunMeasurement(measurement, ps, options=self._options) # Picture printing is not supported on all platforms. if results.failures: assert 'not supported' in results.failures[0].exc_info[1].message return saved_picture_count = results.FindAllPageSpecificValuesNamed( 'saved_picture_count') self.assertEquals(len(saved_picture_count), 1) self.assertGreater(saved_picture_count[0].GetRepresentativeNumber(), 0) ",1 "al, LengthGreaterEqual c = hyperdex.client.Client(sys.argv[1], int(sys.argv[2])) def to_objectset(xs): return set([frozenset(x.items()) for x in xs]) assert c.put('kv', 'k', {}) == True assert c.get('kv', 'k') == {'v': {}} assert c.put('kv', 'k', {'v': {1: 3.14, 2: 0.25, 3: 1.0}}) == True assert c.get('kv', 'k') == {'v': {1: 3.14, 2: 0.25, 3: 1.0}} assert c.put('kv', 'k', {'v': {}}) == True assert c.get('kv', 'k') == {'v': {}} ",1 "if setuptools isn't installed but they just return nothing. lexer plugins:: [pygments.lexers] yourlexer = yourmodule:YourLexer formatter plugins:: [pygments.formatters] yourformatter = yourformatter:YourFormatter /.ext = yourformatter:YourFormatter As you can see, you can define extensions for the formatter with a leading slash. syntax plugins:: [pygments.styles] yourstyle = yourstyle:YourStyle filter plugin:: [pygments.filter] yourfilter = yourfilter:YourFilter :copyright: Copyright 2006-2013 by the Pygments team, see AUTHORS. :license: BSD, see LICENSE for details. """""" from __future__ import unicode_literals try: import pkg_resources except ImportError: pkg_resources = None LEXER_ENTRY_POINT = 'pygments.lexers' FORMATTER_ENTRY_POINT = 'pygments.formatters' STYLE_ENTRY_POINT = 'pygments.styles' FILTER_ENTRY_POINT = 'pygments.filters' def find_plugin_lexers(): if pkg_resources is None: return for entrypoint in pkg_resources.iter_entry_points(LEXER_ENTRY_POINT): yield entrypoint.load() def find_plugin_formatters(): if pkg_resources is None: return for entrypoint in pkg_resources.iter_entry_points(FORMATTER_ENTRY_POINT): yield entrypoint.name, entrypoint.load() def find_plugin_styles(): if pkg_resources is None: return for entrypoint in pkg_resources.iter_entry_points(STYLE_ENTRY_POINT): yield entrypoint.name, entrypoint.load() def find_plugin_filters(): if pkg_resources is None: return for entrypoint in pkg_resources.iter_entry_points(FILTER_ENTRY_POINT): yield entrypoint.name, entrypoint.load() ",1 "le_parser __author__ = ""Andrey Konovalov"" __copyright__ = ""Copyright (C) 2014 Andrey Konovalov"" __license__ = ""MIT"" __version__ = ""0.1"" this_dir, this_filename = os.path.split(__file__) SCHEDULE_PATH = os.path.join(this_dir, "".."", ""data"", ""2013_fall"", ""4kurs.xls"") class WeekdayRangeTest(unittest.TestCase): def setUp(self): self.schedule = schedule_parser.Schedule() self.schedule.Parse(SCHEDULE_PATH) def runTest(self): self.assertEqual(self.schedule.GetWeekdayRange(0), (4, 11)) self.assertEqual(self.schedule.GetWeekdayRange(1), (12, 19)) self.assertEqual(self.schedule.GetWeekdayRange(2), (20, 27)) self.assertEqual(self.schedule.GetWeekdayRange(3), (28, 37)) self.assertEqual(self.schedule.GetWeekdayRange(4), (38, 47)) self.assertEqual(self.schedule.GetWeekdayRange(5), (48, 57)) class DepartmentCountTest(unittest.TestCase): def setUp(self): self.schedule = schedule_parser.Schedule() self.schedule.Parse(SCHEDULE_PATH) def runTest(self): self.assertEqual(self.schedule.GetDepartmentCount(), 9) class DepartmentRangeTest(unittest.TestCase): def setUp(self): self.schedule = schedule_parser.Schedule() self.schedule.Parse(SCHEDULE_PATH) def runTest(self): self.assertEqual(self.schedule.GetDepartmentRange(0), (2, 11)) self.assertEqual(self.schedule.GetDepartmentRange(1), (13, 20)) self.assertEqual(self.schedule.GetDepartmentRange(2), (22, 32)) self.assertEqual(self.schedule.GetDepartmentRange(3), (34, 36)) self.assertEqual(self.schedule.GetDepartmentRange(4), (38, 43)) self.assertEqual(self.schedule.GetDepartmentRange(5), (45, 53)) self.assertEqual(self.schedule.GetDepartmentRange(6), (55, 62)) self.assertEqual(self.schedule.GetDepartmentRange(7), (64, 71)) self.assertEqual(self.schedule.GetDepartmentRange(8), (73, 77)) class DepartmentsRowTest(unittest.TestCase): def setUp(self): self.schedule = schedule_parser.Schedule() self.schedule.Parse(SCHEDULE_PATH) def runTest(self): self.assertEqual(self.schedule.GetDepartmentsRow(), 3) class HoursColumnTest(unittest.TestCase): def setUp(self): self.schedule = schedule_parser.Schedule() self.schedule.Parse(SCHEDULE_PATH) def runTest(self): self.assertEqual(self.schedule.GetHoursColumn(), 1) class HoursRangesTest(unittest.TestCase): def setUp(self): self.schedule = schedule_parser.Schedule() self.schedule.Parse(SCHEDULE_PATH) def runTest(self): self.assertEqual(self.schedule.GetHoursRanges(0), [(4, 5), (5, 6), (6, 7), (7, 8), (8, 9), (9, 10), (10, 11)]) self.assertEqual(self.schedule.GetHoursRanges(3), [(28, 30), (30, 31), (31, 32), (32, 34), (34, 35), (35, 36), (36, 37)]) self.assertEqual(self.schedule.GetHoursRanges(5), [(48, 49), (49, 50), (50, 52), (52, 53), (53, 54), (54, 56), (56, 57)]) class GroupCountTest(unittest.TestCase): def setUp(self): self.schedule = schedule_parser.Schedule() self.schedule.Parse(SCHEDULE_PATH) def runTest(self): self.assertEqual(self.schedule.GetGroupCount(0), 9) self.assertEqual(self.schedule.GetGroupCount(1), 7) self.assertEqual(self.schedule.GetGroupCount(2), 8) self.assertEqual(self.schedule.GetGroupCount(3), 2) self.assertEqual(self.schedule.GetGroupCount(4), 5) self.assertEqual(self.schedule.GetGroupCount(5), 8) self.assertEqual(self.schedule.GetGroupCount(6), 7) self.assertEqual(self.schedule.GetGroupCount(7), 7) self.assertEqual(self.schedule.GetGroupCount(8), 4) class GroupListTest(unittest.TestCase): def setUp(self): self.schedule = schedule_parser.Schedule() self.schedule.Parse(SCHEDULE_PATH) def runTest(self): self.assertEqual(self.schedule.GetGroupList(0), ['011', '012', '013', '014', '015', '016', '017', '018', '019']) self.assertEqual(self.schedule.GetGroupList(1), ['021', '022', '023', '024', '025', '026', '028']) self.assertEqual(self.schedule.GetGroupList(3), ['041', '042']) self.assertEqual(self.schedule.GetGroupList(8), ['0111', '0112', '0113', '0114']) class GroupRangeTest(unittest.TestCase): def setUp(self): self.schedule = schedule_parser.Schedule() self.schedule.Parse(SCHEDULE_PATH) def runTest(self): self.assertEqual(self.schedule.GetGroupRange(0, 0), (2, 3)) self.assertEqual(self.schedule.GetGroupRange(0, 1), (3, 4)) self.assertEqual(self.schedule.GetGroupRange(2, 1), (23, 25)) self.assertEqual(self.schedule.GetGroupRange(2, 2), (25, 26)) self.assertEqual(self.schedule.GetGroupRange(2, 3), (26, 28)) self.assertEqual(self.schedule.GetGroupRange(5, 3), (48, 49)) self.assertEqual(self.schedule.GetGroupRange(8, 0), (73, 74)) self.assertEqual(self.schedule.GetGroupRange(8, 3), (76, 77)) class WeekdayByRowTest(unittest.TestCase): def setUp(self): self.schedule = schedule_parser.Schedule() self.schedule.Parse(SCHEDULE_PATH) def runTest(self): self.assertEqual(self.schedule.GetWeekdayByRow(4), 0) self.assertEqual(self.schedule.GetWeekdayByRow(5), 0) self.assertEqual(self.schedule.GetWeekdayByRow(10), 0) self.assertEqual(self.schedule.GetWeekdayByRow(13), 1) self.assertEqual(self.schedule.GetWeekdayByRow(25), 2) self.assertEqual(self.schedule.GetWeekdayByRow(26), 2) self.assertEqual(self.schedule.GetWeekdayByRow(28), 3) self.assertEqual(self.schedule.GetWeekdayByRow(44), 4) self.assertEqual(self.schedule.GetWeekdayByRow(48), 5) self.assertEqual(self.schedule.GetWeekdayByRow(56), 5) class PairByRowTest(unittest.TestCase): def setUp(self): self.schedule = schedule_parser.Schedule() self.schedule.Parse(SCHEDULE_PATH) def runTest(self): self.assertEqual(self.schedule.GetPairByRow(4), (0, 0)) self.assertEqual(self.schedule.GetPairByRow(5), (1, 0)) self.assertEqual(self.schedule.GetPairByRow(10), (6, 0)) self.assertEqual(self.schedule.GetPairByRow(12), (0, 0)) self.assertEqual(self.schedule.GetPairByRow(28), (0, 0)) self.assertEqual(self.schedule.GetPairByRow(29), (0, 1)) self.assertEqual(self.schedule.GetPairByRow(30), (1, 0)) self.assertEqual(self.schedule.GetPairByRow(33), (3, 1)) self.assertEqual(self.schedule.GetPairByRow(56), (6, 0)) class DepartmentByColumnTest(unittest.TestCase): def setUp(self): self.schedule = schedule_parser.Schedule() self.schedule.Parse(SCHEDULE_PATH) def runTest(self): self.assertEqual(self.schedule.GetDepartmentIndexByColumn(2), 0) self.assertEqual(self.schedule.GetDepartmentIndexByColumn(3), 0) self.assertEqual(self.schedule.GetDepartmentIndexByColumn(10), 0) self.assertEqual(self.schedule.GetDepartmentIndexByColumn(13), 1) self.assertEqual(self.schedule.GetDepartmentIndexByColumn(18), 1) self.assertEqual(self.schedule.GetDepartmentIndexByColumn(19), 1) self.assertEqual(self.schedule.GetDepartmentIndexByColumn(22), 2) self.assertEqual(self.schedule.GetDepartmentIndexByColumn(24), 2) self.assertEqual(self.schedule.GetDepartmentIndexByColumn(31), 2) self.assertEqual(self.schedule.GetDepartmentIndexByColumn(39), 4) self.assertEqual(self.schedule.GetDepartmentIndexByColumn(64), 7) self.assertEqual(self.schedule.GetDepartmentIndexByColumn(70), 7) self.assertEqual(self.schedule.GetDepartmentIndexByColumn(73), 8) self.assertEqual(self.schedule.GetDepartmentIndexByColumn(76), 8) class GroupByColumnTest(unittest.TestCase): def setUp(self): self.schedule = schedule_parser.Schedule() self.schedule.Parse(SCHEDULE_PATH) def runTest(self): self.assertEqual(self.schedule.GetGroupIndexByColumn(2), (0, 0)) self.assertEqual(self.schedule.GetGroupIndexByColumn(3), (1, 0)) self.assertEqual(self.schedule.GetGroupIndexByColumn(10), (8, 0)) self.assertEqual(self.schedule.GetGroupIndexByColumn(23), (1, 0)) self.assertEqual(self.schedule.GetGroupIndexByColumn(24), (1, 1)) self.assertEqual(self.schedule.GetGroupIndexByColumn(25), (2, 0)) self.assertEqual(self.schedule.GetGroupIndexByColumn(26), (3, 0)) self.assertEqual(self.schedule.GetGroupIndexByColumn(27), (3, 1)) self.assertEqual(self.schedule.GetGroupIndexByColumn(76), (3, 0)) def suite(): loader = unittest.TestLoader() suite = unittest.TestSuite() suite.addTest(WeekdayRangeTest()) suite.addTest(DepartmentCountTest()) suite.addTest(DepartmentRangeTest()) suite.addTest(DepartmentsRowTest()) suite.addTest(HoursColumnTest()) suite.addTest(HoursRangesTest()) suite.addTest(GroupCountTest()) suite.addTest(GroupListTest()) suite.addTest(GroupRangeTest()) suite.addTest(WeekdayByRowTest()) suite.addTest(PairByRowTest()) suite.addTest(DepartmentByColumnTest()) suite.addTest(GroupByColumnTest()) return suite if __name__ == '__main__': unittest.TextTestRunner(verbosity=2).run(suite()) ",1 "s' id = Column(Integer, Sequence('data_stage01_rnasequencing_analysis_id_seq'), primary_key=True) analysis_id = Column(String(500)) experiment_id = Column(String(50)) sample_name_abbreviation = Column(String(500)) # equivalent to sample_name_abbreviation sample_name = Column(String(500)) # equivalent to sample_name_abbreviation time_point = Column(String(10)) # converted to intermediate in lineage analysis analysis_type = Column(String(100)); # time-course (i.e., multiple time points), paired (i.e., control compared to multiple replicates), group (i.e., single grouping of samples). used_ = Column(Boolean); comment_ = Column(Text); __table_args__ = ( UniqueConstraint('experiment_id','sample_name_abbreviation','sample_name','time_point','analysis_type','analysis_id'), ) def __init__(self, row_dict_I, ): self.analysis_id=row_dict_I['analysis_id']; self.experiment_id=row_dict_I['experiment_id']; self.sample_name_abbreviation=row_dict_I['sample_name_abbreviation']; self.sample_name=row_dict_I['sample_name']; self.time_point=row_dict_I['time_point']; self.analysis_type=row_dict_I['analysis_type']; self.used_=row_dict_I['used_']; self.comment_=row_dict_I['comment_']; def __set__row__(self,analysis_id_I, experiment_id_I, sample_name_abbreviation_I, sample_name_I, time_point_I, analysis_type_I, used__I, comment__I): self.analysis_id=analysis_id_I self.experiment_id=experiment_id_I self.sample_name_abbreviation=sample_name_abbreviation_I self.sample_name=sample_name_I self.time_point=time_point_I self.analysis_type=analysis_type_I self.used_=used__I self.comment_=comment__I def __repr__dict__(self): return {'id':self.id, 'analysis_id':self.analysis_id, 'experiment_id':self.experiment_id, 'sample_name_abbreviation':self.sample_name_abbreviation, 'sample_name':self.sample_name, 'time_point':self.time_point, 'analysis_type':self.analysis_type, 'used_':self.used_, 'comment_':self.comment_} def __repr__json__(self): return json.dumps(self.__repr__dict__())",1 "2 2015 -0400 # # Copyright (C) 2015 Tipsy Bear Studios # For license information, see LICENSE.txt # # ID: version.py [] benjamin@bengfort.com $ """""" Helper module for ORMBad version information. """""" ########################################################################## ## Versioning ########################################################################## __version_info__ = { 'major': 0, 'minor': 1, 'micro': 0, 'releaselevel': 'final', 'serial': 0, } def get_version(short=False): """""" Returns the version from the version info. """""" assert __version_info__['releaselevel'] in ('alpha', 'beta', 'final') vers = [""%(major)i.%(minor)i"" % __version_info__, ] if __version_info__['micro']: vers.append("".%(micro)i"" % __version_info__) if __version_info__['releaselevel'] != 'final' and not short: vers.append('%s%i' % (__version_info__['releaselevel'][0], __version_info__['serial'])) return ''.join(vers) ",1 "aemon import runner from os.path import dirname, abspath # add the shared settings file to namespace sys.path.insert(0, dirname(dirname(abspath(__file__)))) import settings REDIS_CONN = redis.StrictRedis(unix_socket_path=settings.REDIS_SOCKET_PATH) app = Flask(__name__) app.config['PROPAGATE_EXCEPTIONS'] = True @app.route(""/"") def index(): return render_template('index.html'), 200 @app.route(""/app_settings"") def app_settings(): app_settings = {'GRAPHITE_HOST': settings.GRAPHITE_HOST, 'OCULUS_HOST': settings.OCULUS_HOST, 'FULL_NAMESPACE': settings.FULL_NAMESPACE, } resp = json.dumps(app_settings) return resp, 200 @app.route(""/api"", methods=['GET']) def data(): metric = request.args.get('metric', None) try: raw_series = REDIS_CONN.get(metric) if not raw_series: resp = json.dumps({'results': 'Error: No metric by that name'}) return resp, 404 else: unpacker = Unpacker(use_list = False) unpacker.feed(raw_series) timeseries = [item[:2] for item in unpacker] resp = json.dumps({'results': timeseries}) return resp, 200 except Exception as e: error = ""Error: "" + e resp = json.dumps({'results': error}) return resp, 500 class App(): def __init__(self): self.stdin_path = '/dev/null' self.stdout_path = settings.LOG_PATH + '/webapp.log' self.stderr_path = settings.LOG_PATH + '/webapp.log' self.pidfile_path = settings.PID_PATH + '/webapp.pid' self.pidfile_timeout = 5 def run(self): logger.info('starting webapp') logger.info('hosted at %s' % settings.WEBAPP_IP) logger.info('running on port %d' % settings.WEBAPP_PORT) app.run(settings.WEBAPP_IP, settings.WEBAPP_PORT) if __name__ == ""__main__"": """""" Start the server """""" webapp = App() logger = logging.getLogger(""AppLog"") logger.setLevel(logging.DEBUG) formatter = logging.Formatter(""%(asctime)s :: %(message)s"", datefmt=""%Y-%m-%d %H:%M:%S"") handler = logging.FileHandler(settings.LOG_PATH + '/webapp.log') handler.setFormatter(formatter) logger.addHandler(handler) if len(sys.argv) > 1 and sys.argv[1] == 'run': webapp.run() else: daemon_runner = runner.DaemonRunner(webapp) daemon_runner.daemon_context.files_preserve = [handler.stream] daemon_runner.do_action() ",1 "_folder_iterfile from pyquickhelper.ipythonhelper import upgrade_notebook, remove_execution_number class TestConvertNotebooks(unittest.TestCase): """"""Converts notebooks from v3 to v4. Should not be needed anymore."""""" def test_convert_notebooks(self): fLOG( __file__, self._testMethodName, OutputPrint=__name__ == ""__main__"") fold = os.path.abspath(os.path.dirname(__file__)) fold2 = os.path.normpath( os.path.join(fold, "".."", "".."", ""_doc"", ""notebooks"")) for nbf in explore_folder_iterfile(fold2, pattern="".*[.]ipynb""): t = upgrade_notebook(nbf) if t: fLOG(""modified"", nbf) # remove numbers remove_execution_number(nbf, nbf) fold2 = os.path.normpath(os.path.join(fold, "".."", "".."", ""_unittests"")) for nbf in explore_folder_iterfile(fold2, pattern="".*[.]ipynb""): t = upgrade_notebook(nbf) if t: fLOG(""modified"", nbf) if __name__ == ""__main__"": unittest.main() ",1 "turns True or False. The algorithm is called # the ""Ray Casting Method"". # the point_in_poly algorithm was found here: # http://geospatialpython.com/2011/01/point-in-polygon.html def point_in_poly(x,y,poly): n = len(poly) inside = False p1x,p1y = poly[0] for i in range(n+1): p2x,p2y = poly[i % n] if y > min(p1y,p2y): if y <= max(p1y,p2y): if x <= max(p1x,p2x): if p1y != p2y: xints = (y-p1y)*(p2x-p1x)/(p2y-p1y)+p1x if p1x == p2x or x <= xints: inside = not inside p1x,p1y = p2x,p2y return inside # This one is my own version of the ray-trace algorithm which utilises the numpy arrays so that a list of x and y coordinates can be processed in one call and only points inside polygon are returned alongside the indices in case required for future referencing. This saves a fair bit of looping. def points_in_poly(x,y,poly): n = len(poly) inside=np.zeros(x.size,dtype=bool) xints=np.zeros(x.size) p1x,p1y = poly[0] for i in range(n+1): p2x,p2y=poly[i % n] if p1y!=p2y: xints[np.all([y>min(p1y,p2y), y<=max(p1y,p2y), x<=max(p1x,p2x)],axis=0)] = (y[np.all([y>min(p1y,p2y), y<=max(p1y,p2y), x<=max(p1x,p2x)],axis=0)]-p1y)*(p2x-p1x)/(p2y-p1y)+p1x if p1x==p2x: inside[np.all([y>min(p1y,p2y), y<=max(p1y,p2y), x<=max(p1x,p2x)],axis=0)] = np.invert(inside[np.all([y>min(p1y,p2y), y<=max(p1y,p2y), x<=max(p1x,p2x)],axis=0)]) else: inside[np.all([y>min(p1y,p2y), y<=max(p1y,p2y), x<=max(p1x,p2x),x<=xints],axis=0)] = np.invert(inside[np.all([y>min(p1y,p2y), y<=max(p1y,p2y), x<=max(p1x,p2x),x<=xints],axis=0)]) p1x,p1y = p2x,p2y return x[inside],y[inside], inside # This retrieves all points within circular neighbourhood, Terget point is the location around which the neighbourhood search is conducted, for a specified search radius. x and y are vectors with the x and y coordinates of the test points def points_in_radius(x,y,target_x, target_y,radius): inside=np.zeros(x.size,dtype=bool) d2=(x-target_x)**2+(y-target_y)**2 inside = d2<=radius**2 return x[inside],y[inside], inside # filter lidar wth polygon # This function has been updated to include an option to filter by first return location. # The reason for this is so full collections of returns associated with each LiDAR pulse # can be retrieved, which can be an issue at edges in multi-return analyses def filter_lidar_data_by_polygon(in_pts,polygon,filter_by_first_return_location = False): pts = np.zeros((0,in_pts.shape[1])) if in_pts.shape[0]>0: if filter_by_first_return_location: # find first returns mask = in_pts[:,3]==1 x_temp, y_temp, inside_temp = points_in_poly(in_pts[mask,0],in_pts[mask,1],polygon) shots = np.unique(in_pts[mask,6][inside_temp]) # index 6 refers to GPS time inside = np.in1d(in_pts[:,6],shots) # this function retrieves all points corresponding to this GPS time x = in_pts[inside,0] y = in_pts[inside,1] x_temp=None y_temp=None inside_temp=None else: x,y,inside = points_in_poly(in_pts[:,0],in_pts[:,1],polygon) pts = in_pts[inside,:] else: print(""\t\t\t no points in polygon"") return pts # filter lidar by circular neighbourhood def filter_lidar_data_by_neighbourhood(in_pts,target_xy,radius): pts = np.zeros((0,in_pts.shape[1])) if in_pts.shape[0]>0: x,y,inside = points_in_radius(in_pts[:,0],in_pts[:,1],target_xy[0],target_xy[1],radius) pts = in_pts[inside,:] else: print( ""\t\t\t no points in neighbourhood"") return pts ",1 "ontrib.syndication.views import feed as feed_view from django.views.generic import date_based, list_detail from django.views.generic.simple import direct_to_template from django.contrib import admin import django.contrib.auth.views as auth_views from django.conf import settings from django.core.urlresolvers import reverse from django.http import HttpResponseRedirect, HttpResponsePermanentRedirect from django.contrib import admin admin.autodiscover() # Need to move this somewhere more useful and try to make it less hacky but # seems to be the easiest way unfortunately. from django.contrib.auth.models import User User._meta.ordering = ['username'] from frontend.feeds import LatestCodeObjects, LatestCodeObjectsBySearchTerm, LatestCodeObjectsByTag, LatestViewObjects, LatestScraperObjects feeds = { 'all_code_objects': LatestCodeObjects, 'all_scrapers': LatestScraperObjects, 'all_views': LatestViewObjects, 'latest_code_objects_by_search_term': LatestCodeObjectsBySearchTerm, 'latest_code_objects_by_tag': LatestCodeObjectsByTag, } urlpatterns = patterns('', url(r'^$', frontend_views.frontpage, name=""frontpage""), # redirects from old version (would clashes if you happen to have a scraper whose name is list!) (r'^scrapers/list/$', lambda request: HttpResponseRedirect(reverse('scraper_list_wiki_type', args=['scraper']))), url(r'^', include('codewiki.urls')), url(r'^logout/$', auth_views.logout, {'next_page': '/'}, name=""logout""), url(r'^accounts/', include('registration.urls')), url(r'^accounts/resend_activation_email/', frontend_views.resend_activation_email, name=""resend_activation_email""), url(r'^captcha/', include('captcha.urls')), url(r'^attachauth', codewiki.views.attachauth), # allows direct viewing of the django tables url(r'^admin/', include(admin.site.urls)), # favicon (r'^favicon\.ico$', 'django.views.generic.simple.redirect_to', {'url': '/media/images/favicon.ico'}), # RSS feeds url(r'^feeds/(?PSysetm use only! DO NOT MODIFY youself unless you understand the risk.
' p.save() for f in os.listdir(d): if not (f.upper().endswith('.XLSX') or f.upper().endswith('.CSV')): continue #only support *.xlsx and *.csv f=os.path.join(d, f) try: Preference.objects.get(name=f, parent=p) if self.kwargs['force']: raise Preference.DoesNotExist except Preference.DoesNotExist: self.impfile( f ) cnt+=1 Preference(name=f, parent=p).save() logger.debug('Imported {0} file(s)'.format(cnt)) def impfile( self, f ): if not (os.path.isfile(f) and os.access(f, os.R_OK)): logger.warning('The file is not readable: {0}'.format(f)) return fn=f.lower() if fn.endswith('.xlsx'): self.impXlsx(f) elif fn.endswith('.csv'): self.impCsv(f) else: logger.info('Unsupported file: {0}'.format(f)) def imppath( self, p, parent=None): name, seq=self.__get_name__(os.path.basename(p)) if os.path.isdir(p): try: pref=self.__get_pref__(name=name) if pref.count()<1: raise Preference.DoesNotExist pref=pref[0] except Preference.DoesNotExist: pref=Preference(name=name, parent=parent) pref.tipe=AbstractPreference.TYPE_FILEPATH pref.sequence=seq pref.save() for f in os.listdir(p): path=os.path.join(p, f) self.imppath(path, pref) #Handling the ordering after import all the childs ord=1 for c in pref.childs: c.sequence=ord c.save() ord+=1 else: try: pref=self.__get_pref__(name=name) if pref.count()<1: raise Preference.DoesNotExist pref=pref[0] except Preference.DoesNotExist: pref=Preference(name=name, parent=parent) pref.pathValue=p if os.path.isabs(p) else os.path.abspath(p) pref.tipe=AbstractPreference.TYPE_FILEPATH pref.sequence=seq pref.save() def imp(self): disableOrder=getattr(settings, 'DISABLE_REORDER', False) setattr(settings, 'DISABLE_REORDER', True) #Disable the re-ordering features during importing try: f=self.kwargs['file'] if self.kwargs['filepath']: self.imppath(f) elif os.path.isdir(f): self.impdir(f) elif os.path.isfile(f): self.impfile(f) finally: setattr(settings, 'DISABLE_REORDER', disableOrder) #Resume the re-ordering features after importing def gensecret(self): from webframe.models import AbstractPreference key=AbstractPreference.__getSecret__() logger.warning(lm('Your secret is: {0}', key)) def gendoc(self): from django.shortcuts import render from django.template import loader, Template, Context from webframe.providers import template_injection, fmt_injection tmpl=getattr(self.kwargs, 'tmpl', 'webframe/prefDoc.html') logger.warning(lm('Generating the documents according template: {0}', tmpl)) tmpl=loader.get_template(tmpl) params=dict() params.update(template_injection(None)) params.update(fmt_injection(None)) #params['target']=Preference.objects.filter(parent__isnull=True) params['target']=self.__get_pref__() params['TYPES']=Preference.TYPES params['now']=getTime('now') txt=tmpl.render(params) output=self.kwargs.get('file') if not output: output='prefsDoc.html' logger.warning(lm('Generated! Outputing into: {0}', output)) with open(output, 'w') as f: f.write(txt) ",1 "file__) lFile, eError =vhdlFile.utils.read_vhdlfile(os.path.join(sTestDir,'rule_300_test_input.vhd')) dIndentMap = utils.read_indent_file() lExpected = [] lExpected.append('') utils.read_file(os.path.join(sTestDir, 'rule_300_test_input.fixed.vhd'), lExpected) class test_iteration_scheme_rule(unittest.TestCase): def setUp(self): self.oFile = vhdlFile.vhdlFile(lFile) self.assertIsNone(eError) self.oFile.set_indent_map(dIndentMap) def test_rule_300(self): oRule = iteration_scheme.rule_300() self.assertTrue(oRule) self.assertEqual(oRule.name, 'iteration_scheme') self.assertEqual(oRule.identifier, '300') lExpected = [13, 17] oRule.analyze(self.oFile) self.assertEqual(lExpected, utils.extract_violation_lines_from_violation_object(oRule.violations)) def test_fix_rule_300(self): oRule = iteration_scheme.rule_300() oRule.fix(self.oFile) lActual = self.oFile.get_lines() self.assertEqual(lExpected, lActual) oRule.analyze(self.oFile) self.assertEqual(oRule.violations, []) ",1 "lified BSD"" import sys from recursely._compat import IS_PY3 from recursely.importer import RecursiveImporter from recursely.utils import SentinelList __all__ = ['install'] def install(retroactive=True): """"""Install the recursive import hook in ``sys.meta_path``, enabling the use of ``__recursive__`` directive. :param retroactive: Whether the hook should be retroactively applied to module's that have been imported before it was installed. """""" if RecursiveImporter.is_installed(): return importer = RecursiveImporter() # because the hook is a catch-all one, we ensure that it's always # at the very end of ``sys.meta_path``, so that it's tried only if # no other (more specific) hook has been chosen by Python if IS_PY3: for i in reversed(range(len(sys.meta_path))): ih_module = getattr(sys.meta_path[i], '__module__', '') is_builtin = ih_module == '_frozen_importlib' if not is_builtin: break sys.meta_path = SentinelList( sys.meta_path[:i], sentinels=[importer] + sys.meta_path[i:]) else: sys.meta_path = SentinelList(sys.meta_path, sentinel=importer) # look through already imported packages and recursively import # their submodules, if they contain the ``__recursive__`` directive if retroactive: for module in list(sys.modules.values()): importer.recurse(module) ",1 """"""" Filter query list from treatment database table """""" class Meta: model = Treatment fields = {'id': ['exact', 'in'], 'no_replicate': ['exact', 'in', 'gte', 'lte'], 'nitrogen_treatment': ['iexact', 'in', 'icontains'], 'phosphate_treatment': ['iexact', 'in', 'icontains'], 'tillage_practice': ['iexact', 'in', 'icontains'], 'cropping_system': ['iexact', 'in', 'icontains'], 'crops_grown': ['iexact', 'in', 'icontains'], 'farm_yard_manure': ['iexact', 'in', 'icontains'], 'farm_residue': ['iexact', 'in', 'icontains'], } order_by = ['tillage_practice', 'cropping_system', 'crops_grown'] ",1 "rved. # # 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 pyglet 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. # ---------------------------------------------------------------------------- # Based on pygxinput originally by Andrew D. Straw # http://code.astraw.com/projects/motmot/wiki/pygxinput import ctypes import pyglet from pyglet.window.xlib import xlib import lib_xinput as xi class XInputDevice: def __init__(self, display, device_info): self._x_display = display._display self._device_id = device_info.id self.name = device_info.name self._open_device = None # TODO: retrieve inputclassinfo from device_info and expose / save # for valuator axes etc. def open(self): if self._open_device: return self._open_device = xi.XOpenDevice(self._x_display, self._device_id) if not self._open_device: raise Exception('Cannot open device') def close(self): if not self._open_device: return xi.XCloseDevice(self._x_display, self._open_device) def attach(self, window): assert window._x_display == self._x_display return XInputDeviceInstance(self, window) class XInputDeviceInstance(pyglet.event.EventDispatcher): def __init__(self, device, window): """"""Create an opened instance of a device on the given window. :Parameters: `device` : XInputDevice Device to open `window` : Window Window to open device on """""" assert device._x_display == window._x_display assert device._open_device self.device = device self.window = window self._events = list() try: dispatcher = window.__xinput_window_event_dispatcher except AttributeError: dispatcher = window.__xinput_window_event_dispatcher = \ XInputWindowEventDispatcher() dispatcher.add_instance(self) device = device._open_device.contents if not device.num_classes: return # Bind matching extended window events to bound instance methods # on this object. # # This is inspired by test.c of xinput package by Frederic # Lepied available at x.org. # # In C, this stuff is normally handled by the macro DeviceKeyPress and # friends. Since we don't have access to those macros here, we do it # this way. for i in range(device.num_classes): class_info = device.classes[i] if class_info.input_class == xi.KeyClass: self._add(class_info, xi._deviceKeyPress, dispatcher._event_xinput_key_press) self._add(class_info, xi._deviceKeyRelease, dispatcher._event_xinput_key_release) elif class_info.input_class == xi.ButtonClass: self._add(class_info, xi._deviceButtonPress, dispatcher._event_xinput_button_press) self._add(class_info, xi._deviceButtonRelease, dispatcher._event_xinput_button_release) elif class_info.input_class == xi.ValuatorClass: self._add(class_info, xi._deviceMotionNotify, dispatcher._event_xinput_motion) elif class_info.input_class == xi.ProximityClass: self._add(class_info, xi._proximityIn, dispatcher._event_xinput_proximity_in) self._add(class_info, xi._proximityOut, dispatcher._event_xinput_proximity_out) elif class_info.input_class == xi.FeedbackClass: pass elif class_info.input_class == xi.FocusClass: pass elif class_info.input_class == xi.OtherClass: pass array = (xi.XEventClass * len(self._events))(*self._events) xi.XSelectExtensionEvent(window._x_display, window._window, array, len(array)) def _add(self, class_info, event, handler): _type = class_info.event_type_base + event _class = self.device._device_id << 8 | _type self._events.append(_class) self.window._event_handlers[_type] = handler XInputDeviceInstance.register_event_type('on_button_press') XInputDeviceInstance.register_event_type('on_button_release') XInputDeviceInstance.register_event_type('on_motion') XInputDeviceInstance.register_event_type('on_proximity_in') XInputDeviceInstance.register_event_type('on_proximity_out') class XInputWindowEventDispatcher: def __init__(self): self._instances = dict() def add_instance(self, instance): self._instances[instance.device._device_id] = instance def remove_instance(self, instance): del self._instances[instance.device._device_id] def dispatch_instance_event(self, e, *args): try: instance = self._instances[e.deviceid] except KeyError: return instance.dispatch_event(*args) @pyglet.window.xlib.XlibEventHandler(0) def _event_xinput_key_press(self, ev): raise NotImplementedError('TODO') @pyglet.window.xlib.XlibEventHandler(0) def _event_xinput_key_release(self, ev): raise NotImplementedError('TODO') @pyglet.window.xlib.XlibEventHandler(0) def _event_xinput_button_press(self, ev): e = ctypes.cast(ctypes.byref(ev), ctypes.POINTER(xi.XDeviceButtonEvent)).contents self.dispatch_instance_event(e, 'on_button_press', e.button) @pyglet.window.xlib.XlibEventHandler(0) def _event_xinput_button_release(self, ev): e = ctypes.cast(ctypes.byref(ev), ctypes.POINTER(xi.XDeviceButtonEvent)).contents self.dispatch_instance_event(e, 'on_button_release', e.button) @pyglet.window.xlib.XlibEventHandler(0) def _event_xinput_motion(self, ev): e = ctypes.cast(ctypes.byref(ev), ctypes.POINTER(xi.XDeviceMotionEvent)).contents axis_data = list() for i in range(e.axes_count): axis_data.append(e.axis_data[i]) self.dispatch_instance_event(e, 'on_motion', axis_data, e.x, e.y) @pyglet.window.xlib.XlibEventHandler(0) def _event_xinput_proximity_in(self, ev): e = ctypes.cast(ctypes.byref(ev), ctypes.POINTER(xi.XProximityNotifyEvent)).contents self.dispatch_instance_event(e, 'on_proximity_in') @pyglet.window.xlib.XlibEventHandler(-1) def _event_xinput_proximity_out(self, ev): e = ctypes.cast(ctypes.byref(ev), ctypes.POINTER(xi.XProximityNotifyEvent)).contents self.dispatch_instance_event(e, 'on_proximity_out') def _check_extension(display): major_opcode = ctypes.c_int() first_event = ctypes.c_int() first_error = ctypes.c_int() xlib.XQueryExtension(display._display, 'XInputExtension', ctypes.byref(major_opcode), ctypes.byref(first_event), ctypes.byref(first_error)) if not major_opcode.value: raise Exception('XInput extension not available') def get_devices(display): _check_extension(display) devices = list() count = ctypes.c_int(0) device_list = xi.XListInputDevices(display._display, count) for i in range(count.value): device_info = device_list[i] devices.append(XInputDevice(display, device_info)) return devices ",1 "la.utils import timezone class PositionOptions(admin.ModelAdmin): def show_title(self, obj): if not obj.target: return '-- %s --' % ugettext('empty position') else: return u'%s [%s]' % (obj.target.title, ugettext(obj.target_ct.name),) show_title.short_description = _('Title') def is_filled(self, obj): if obj.target: return True else: return False is_filled.short_description = _('Filled') is_filled.boolean = True def is_active(self, obj): if obj.disabled: return False now = timezone.now() active_from = not obj.active_from or obj.active_from <= now active_till = not obj.active_till or obj.active_till > now return active_from and active_till is_active.short_description = _('Active') is_active.boolean = True list_display = ('name', 'category', 'box_type', 'is_active', 'is_filled', 'show_title', 'disabled',) list_filter = ('category', 'name', 'disabled', 'active_from', 'active_till',) search_fields = ('box_type', 'text',) # suggest_fields = {'category': ('tree_path', 'title', 'slug',),} admin.site.register(Position, PositionOptions) ",1 "PyQt4 UI code generator 4.9.3 # # WARNING! All changes made in this file will be lost! from PyQt4 import QtCore, QtGui try: _fromUtf8 = QtCore.QString.fromUtf8 except AttributeError: _fromUtf8 = lambda s: s class Ui_MainWindow(object): def setupUi(self, MainWindow): MainWindow.setObjectName(_fromUtf8(""MainWindow"")) MainWindow.resize(1024, 768) self.centralwidget = QtGui.QWidget(MainWindow) self.centralwidget.setEnabled(True) sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.centralwidget.sizePolicy().hasHeightForWidth()) self.centralwidget.setSizePolicy(sizePolicy) self.centralwidget.setObjectName(_fromUtf8(""centralwidget"")) self.verticalLayout = QtGui.QVBoxLayout(self.centralwidget) self.verticalLayout.setObjectName(_fromUtf8(""verticalLayout"")) self.horizontalLayout_2 = QtGui.QHBoxLayout() self.horizontalLayout_2.setObjectName(_fromUtf8(""horizontalLayout_2"")) self.label_3 = QtGui.QLabel(self.centralwidget) self.label_3.setMaximumSize(QtCore.QSize(200, 200)) self.label_3.setText(_fromUtf8("""")) self.label_3.setPixmap(QtGui.QPixmap(_fromUtf8("":/logo/pixmaps/logo.jpg""))) self.label_3.setScaledContents(True) self.label_3.setObjectName(_fromUtf8(""label_3"")) self.horizontalLayout_2.addWidget(self.label_3) self.verticalLayout_2 = QtGui.QVBoxLayout() self.verticalLayout_2.setObjectName(_fromUtf8(""verticalLayout_2"")) self.label_2 = QtGui.QLabel(self.centralwidget) font = QtGui.QFont() font.setPointSize(20) self.label_2.setFont(font) self.label_2.setAlignment(QtCore.Qt.AlignCenter) self.label_2.setObjectName(_fromUtf8(""label_2"")) self.verticalLayout_2.addWidget(self.label_2) self.labelServerId = QtGui.QLabel(self.centralwidget) palette = QtGui.QPalette() brush = QtGui.QBrush(QtGui.QColor(0, 0, 255)) brush.setStyle(QtCore.Qt.SolidPattern) palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText, brush) brush = QtGui.QBrush(QtGui.QColor(0, 0, 255)) brush.setStyle(QtCore.Qt.SolidPattern) palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.Text, brush) brush = QtGui.QBrush(QtGui.QColor(0, 0, 255)) brush.setStyle(QtCore.Qt.SolidPattern) palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText, brush) brush = QtGui.QBrush(QtGui.QColor(0, 0, 255)) brush.setStyle(QtCore.Qt.SolidPattern) palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.Text, brush) brush = QtGui.QBrush(QtGui.QColor(118, 116, 113)) brush.setStyle(QtCore.Qt.SolidPattern) palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText, brush) brush = QtGui.QBrush(QtGui.QColor(118, 116, 113)) brush.setStyle(QtCore.Qt.SolidPattern) palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.Text, brush) self.labelServerId.setPalette(palette) font = QtGui.QFont() font.setPointSize(16) font.setBold(True) font.setWeight(75) self.labelServerId.setFont(font) self.labelServerId.setAlignment(QtCore.Qt.AlignCenter) self.labelServerId.setObjectName(_fromUtf8(""labelServerId"")) self.verticalLayout_2.addWidget(self.labelServerId) self.labelYear = QtGui.QLabel(self.centralwidget) palette = QtGui.QPalette() brush = QtGui.QBrush(QtGui.QColor(0, 0, 255)) brush.setStyle(QtCore.Qt.SolidPattern) palette.setBrush(QtGui.QPalette.Active, QtGui.QPalette.WindowText, brush) brush = QtGui.QBrush(QtGui.QColor(0, 0, 255)) brush.setStyle(QtCore.Qt.SolidPattern) palette.setBrush(QtGui.QPalette.Inactive, QtGui.QPalette.WindowText, brush) brush = QtGui.QBrush(QtGui.QColor(118, 116, 113)) brush.setStyle(QtCore.Qt.SolidPattern) palette.setBrush(QtGui.QPalette.Disabled, QtGui.QPalette.WindowText, brush) self.labelYear.setPalette(palette) font = QtGui.QFont() font.setPointSize(37) font.setBold(True) font.setWeight(75) self.labelYear.setFont(font) self.labelYear.setTextFormat(QtCore.Qt.PlainText) self.labelYear.setAlignment(QtCore.Qt.AlignCenter) self.labelYear.setObjectName(_fromUtf8(""labelYear"")) self.verticalLayout_2.addWidget(self.labelYear) self.horizontalLayout_2.addLayout(self.verticalLayout_2) self.label = QtGui.QLabel(self.centralwidget) self.label.setMaximumSize(QtCore.QSize(200, 200)) self.label.setText(_fromUtf8("""")) self.label.setPixmap(QtGui.QPixmap(_fromUtf8("":/logo/pixmaps/Stampa-silicone-tondo-fi55.png""))) self.label.setScaledContents(True) self.label.setObjectName(_fromUtf8(""label"")) self.horizontalLayout_2.addWidget(self.label) self.verticalLayout.addLayout(self.horizontalLayout_2) self.line = QtGui.QFrame(self.centralwidget) self.line.setFrameShadow(QtGui.QFrame.Raised) self.line.setLineWidth(4) self.line.setFrameShape(QtGui.QFrame.HLine) self.line.setFrameShadow(QtGui.QFrame.Sunken) self.line.setObjectName(_fromUtf8(""line"")) self.verticalLayout.addWidget(self.line) spacerItem = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding) self.verticalLayout.addItem(spacerItem) self.horizontalLayout = QtGui.QHBoxLayout() self.horizontalLayout.setObjectName(_fromUtf8(""horizontalLayout"")) self.btnNewYear = QtGui.QToolButton(self.centralwidget) sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Maximum) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(11) sizePolicy.setHeightForWidth(self.btnNewYear.sizePolicy().hasHeightForWidth()) self.btnNewYear.setSizePolicy(sizePolicy) self.btnNewYear.setMinimumSize(QtCore.QSize(0, 200)) font = QtGui.QFont() font.setBold(True) font.setWeight(75) self.btnNewYear.setFont(font) icon = QtGui.QIcon() icon.addPixmap(QtGui.QPixmap(_fromUtf8("":/img/pixmaps/planner.png"")), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.btnNewYear.setIcon(icon) self.btnNewYear.setIconSize(QtCore.QSize(128, 128)) self.btnNewYear.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon) self.btnNewYear.setAutoRaise(False) self.btnNewYear.setArrowType(QtCore.Qt.NoArrow) self.btnNewYear.setObjectName(_fromUtf8(""btnNewYear"")) self.horizontalLayout.addWidget(self.btnNewYear) self.btnCloseYear = QtGui.QToolButton(self.centralwidget) sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(11) sizePolicy.setHeightForWidth(self.btnCloseYear.sizePolicy().hasHeightForWidth()) self.btnCloseYear.setSizePolicy(sizePolicy) self.btnCloseYear.setMinimumSize(QtCore.QSize(0, 200)) font = QtGui.QFont() font.setBold(True) font.setWeight(75) self.btnCloseYear.setFont(font) self.btnCloseYear.setAutoFillBackground(False) icon1 = QtGui.QIcon() icon1.addPixmap(QtGui.QPixmap(_fromUtf8("":/img/pixmaps/save.png"")), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.btnCloseYear.setIcon(icon1) self.btnCloseYear.setIconSize(QtCore.QSize(128, 128)) self.btnCloseYear.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon) self.btnCloseYear.setObjectName(_fromUtf8(""btnCloseYear"")) self.horizontalLayout.addWidget(self.btnCloseYear) self.btnTeachers = QtGui.QToolButton(self.centralwidget) sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Maximum) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(11) sizePolicy.setHeightForWidth(self.btnTeachers.sizePolicy().hasHeightForWidth()) self.btnTeachers.setSizePolicy(sizePolicy) self.btnTeachers.setMinimumSize(QtCore.QSize(0, 200)) font = QtGui.QFont() font.setBold(True) font.setWeight(75) self.btnTeachers.setFont(font) icon2 = QtGui.QIcon() icon2.addPixmap(QtGui.QPixmap(_fromUtf8("":/img/pixmaps/education.png"")), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.btnTeachers.setIcon(icon2) self.btnTeachers.setIconSize(QtCore.QSize(128, 128)) self.btnTeachers.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon) self.btnTeachers.setObjectName(_fromUtf8(""btnTeachers"")) self.horizontalLayout.addWidget(self.btnTeachers) self.btnStudents = QtGui.QToolButton(self.centralwidget) sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Maximum) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(11) sizePolicy.setHeightForWidth(self.btnStudents.sizePolicy().hasHeightForWidth()) self.btnStudents.setSizePolicy(sizePolicy) self.btnStudents.setMinimumSize(QtCore.QSize(0, 200)) font = QtGui.QFont() font.setBold(True) font.setWeight(75) self.btnStudents.setFont(font) self.btnStudents.setStyleSheet(_fromUtf8("""")) icon3 = QtGui.QIcon() icon3.addPixmap(QtGui.QPixmap(_fromUtf8("":/img/pixmaps/System-users.png"")), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.btnStudents.setIcon(icon3) self.btnStudents.setIconSize(QtCore.QSize(128, 128)) self.btnStudents.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon) self.btnStudents.setObjectName(_fromUtf8(""btnStudents"")) self.horizontalLayout.addWidget(self.btnStudents) self.btnAdvanced = QtGui.QToolButton(self.centralwidget) sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Maximum) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(11) sizePolicy.setHeightForWidth(self.btnAdvanced.sizePolicy().hasHeightForWidth()) self.btnAdvanced.setSizePolicy(sizePolicy) self.btnAdvanced.setMinimumSize(QtCore.QSize(0, 200)) font = QtGui.QFont() font.setBold(True) font.setWeight(75) self.btnAdvanced.setFont(font) icon4 = QtGui.QIcon() icon4.addPixmap(QtGui.QPixmap(_fromUtf8("":/img/pixmaps/advanced_options.png"")), QtGui.QIcon.Normal, QtGui.QIcon.Off) self.btnAdvanced.setIcon(icon4) self.btnAdvanced.setIconSize(QtCore.QSize(128, 128)) self.btnAdvanced.setToolButtonStyle(QtCore.Qt.ToolButtonTextUnderIcon) self.btnAdvanced.setObjectName(_fromUtf8(""btnAdvanced"")) self.horizontalLayout.addWidget(self.btnAdvanced) self.verticalLayout.addLayout(self.horizontalLayout) spacerItem1 = QtGui.QSpacerItem(20, 40, QtGui.QSizePolicy.Minimum, QtGui.QSizePolicy.Expanding) self.verticalLayout.addItem(spacerItem1) MainWindow.setCentralWidget(self.centralwidget) self.statusbar = QtGui.QStatusBar(MainWindow) self.statusbar.setObjectName(_fromUtf8(""statusbar"")) MainWindow.setStatusBar(self.statusbar) self.menubar = QtGui.QMenuBar(MainWindow) self.menubar.setGeometry(QtCore.QRect(0, 0, 1024, 29)) self.menubar.setObjectName(_fromUtf8(""menubar"")) self.menuImpostazioni = QtGui.QMenu(self.menubar) self.menuImpostazioni.setEnabled(False) self.menuImpostazioni.setObjectName(_fromUtf8(""menuImpostazioni"")) self.menuHelp = QtGui.QMenu(self.menubar) self.menuHelp.setEnabled(False) self.menuHelp.setObjectName(_fromUtf8(""menuHelp"")) self.menuArchivi = QtGui.QMenu(self.menubar) self.menuArchivi.setObjectName(_fromUtf8(""menuArchivi"")) MainWindow.setMenuBar(self.menubar) self.actionAbout = QtGui.QAction(MainWindow) self.actionAbout.setObjectName(_fromUtf8(""actionAbout"")) self.actionPreferenze = QtGui.QAction(MainWindow) self.actionPreferenze.setObjectName(_fromUtf8(""actionPreferenze"")) self.actionArchivioAnniPrec = QtGui.QAction(MainWindow) self.actionArchivioAnniPrec.setObjectName(_fromUtf8(""actionArchivioAnniPrec"")) self.menuImpostazioni.addAction(self.actionPreferenze) self.menuHelp.addAction(self.actionAbout) self.menuArchivi.addAction(self.actionArchivioAnniPrec) self.menubar.addAction(self.menuArchivi.menuAction()) self.menubar.addAction(self.menuImpostazioni.menuAction()) self.menubar.addAction(self.menuHelp.menuAction()) self.retranslateUi(MainWindow) QtCore.QObject.connect(self.btnAdvanced, QtCore.SIGNAL(_fromUtf8(""clicked()"")), MainWindow.execAdvancedUserManager) QtCore.QObject.connect(self.btnCloseYear, QtCore.SIGNAL(_fromUtf8(""clicked()"")), MainWindow.execYearEnd) QtCore.QObject.connect(self.btnNewYear, QtCore.SIGNAL(_fromUtf8(""clicked()"")), MainWindow.execYearNew) QtCore.QObject.connect(self.actionArchivioAnniPrec, QtCore.SIGNAL(_fromUtf8(""triggered()"")), MainWindow.showArchBackup) QtCore.QObject.connect(self.btnStudents, QtCore.SIGNAL(_fromUtf8(""clicked()"")), MainWindow.showStudentsManager) QtCore.QObject.connect(self.btnTeachers, QtCore.SIGNAL(_fromUtf8(""clicked()"")), MainWindow.showTeachersManager) QtCore.QMetaObject.connectSlotsByName(MainWindow) def retranslateUi(self, MainWindow): MainWindow.setWindowTitle(QtGui.QApplication.translate(""MainWindow"", ""MainWindow"", None, QtGui.QApplication.UnicodeUTF8)) self.label_2.setText(QtGui.QApplication.translate(""MainWindow"", ""Pannello di Amministrazione del Server"", None, QtGui.QApplication.UnicodeUTF8)) self.labelServerId.setText(QtGui.QApplication.translate(""MainWindow"", ""TextLabel"", None, QtGui.QApplication.UnicodeUTF8)) self.labelYear.setText(QtGui.QApplication.translate(""MainWindow"", ""Anno -"", None, QtGui.QApplication.UnicodeUTF8)) self.btnNewYear.setText(QtGui.QApplication.translate(""MainWindow"", ""Nuovo Anno"", None, QtGui.QApplication.UnicodeUTF8)) self.btnCloseYear.setText(QtGui.QApplication.translate(""MainWindow"", ""Chiusura Anno"", None, QtGui.QApplication.UnicodeUTF8)) self.btnTeachers.setText(QtGui.QApplication.translate(""MainWindow"", ""Gestione Insegnanti"", None, QtGui.QApplication.UnicodeUTF8)) self.btnStudents.setText(QtGui.QApplication.translate(""MainWindow"", ""Gestione Alunni"", None, QtGui.QApplication.UnicodeUTF8)) self.btnAdvanced.setText(QtGui.QApplication.translate(""MainWindow"", ""Gestione Avanzata"", None, QtGui.QApplication.UnicodeUTF8)) self.menuImpostazioni.setTitle(QtGui.QApplication.translate(""MainWindow"", ""Impostazioni"", None, QtGui.QApplication.UnicodeUTF8)) self.menuHelp.setTitle(QtGui.QApplication.translate(""MainWindow"", ""Help"", None, QtGui.QApplication.UnicodeUTF8)) self.menuArchivi.setTitle(QtGui.QApplication.translate(""MainWindow"", ""Archivi"", None, QtGui.QApplication.UnicodeUTF8)) self.actionAbout.setText(QtGui.QApplication.translate(""MainWindow"", ""About"", None, QtGui.QApplication.UnicodeUTF8)) self.actionPreferenze.setText(QtGui.QApplication.translate(""MainWindow"", ""Preferenze"", None, QtGui.QApplication.UnicodeUTF8)) self.actionArchivioAnniPrec.setText(QtGui.QApplication.translate(""MainWindow"", ""Archivio anni precedenti"", None, QtGui.QApplication.UnicodeUTF8)) import classerman_rc ",1 "= rig.get_default_rig() g = r.groups['all'] def all_red(): """""" Create an all-red frame. """""" g.setColor('#ff0000') g.setIntensity(255) return g.getFrame() def all_blue(): """""" Create an all-blue frame. """""" g.setColor('#0000ff') g.setIntensity(255) return g.getFrame() def main(config, controller=None): log.info(""Running script %s"" % __name__) # global g # g = get_default_fixture_group(config) q = controller or dmx.Controller(config.get('base', 'address'), bpm=60, nodaemon=True, runout=True) q.add(fades.create_multifade([ all_red(), all_blue(), ] * 3, secs=5.0)) if not controller: q.start() ",1 " """""" import os import sys import sqlalchemy sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))) import legendary_waffle # Database setup db_engine = sqlalchemy.create_engine(""sqlite://"") legendary_waffle.models.MODELBASE.metadata.create_all(db_engine) legendary_waffle.models.MODELBASE.metadata.bind = db_engine db_session = sqlalchemy.orm.sessionmaker(bind=db_engine) db = db_session() # Create the user legendary_waffle.model_create(db, legendary_waffle.models.User, name='sk4ly') print ""Users: {}"".format(legendary_waffle.model_read(db, legendary_waffle.models.User)) # Create the universe universe_config = { ""name"": 'poopiverse', ""map_size"": 1000, ""max_planets"": 1000, ""max_players"": 10 } legendary_waffle.model_create(db, legendary_waffle.models.Universe, **universe_config) print ""Universe: {}"".format(legendary_waffle.model_read(db, legendary_waffle.models.Universe)) # Create the planet planet_config = { ""universe"": 1, # The pkid of the universe 'poopiverse' ""coordinate_x"": 1, ""coordinate_y"": 1, ""name"": 'bloth', ""habitable"": True, ""player_control"": 1, # The pkid of user 'sk4ly' ""default_condition"": 1000, ""default_resources"": 1000, ""current_condition"": 1000, ""current_resources"": 1000 } legendary_waffle.model_create(db, legendary_waffle.models.Planet, **planet_config) print ""Planet: {}"".format(legendary_waffle.model_read(db, legendary_waffle.models.Planet)) # Create building type name legendary_waffle.model_create(db, legendary_waffle.models.BuildingTypeName, name=""Control Center"") print ""Building Type Name: {}"".format(legendary_waffle.model_read(db, legendary_waffle.models.BuildingTypeName)) # Create building type building_type_config = { ""typename"": 1, # The pkid of the building type name 'Control Center' ""description"": ""This is the control center"", ""default_condition"": 100, ""default_firepower"": 0, ""default_storage"": 100, ""rhr_passive"": 0, ""rhr_active"": 0, ""rhr_destructive"": 0, ""build_resource_reqs"": 500, } legendary_waffle.model_create(db, legendary_waffle.models.BuildingType, **building_type_config) print ""Building Type: {}"".format(legendary_waffle.model_read(db, legendary_waffle.models.BuildingType)) # Now create our new building building_config = { ""building_type"": 1, # The pkid of the building type with the name 'Control Center' ""universe"": 1, # The pkid of the universe 'poopiverse' ""planet"": 1, # The pkid of the planet 'bloth' ""player_control"": 1, # The pkid of the user 'sk4ly' } legendary_waffle.model_create(db, legendary_waffle.models.Building, **building_config) print ""Building: {}"".format(legendary_waffle.model_read(db, legendary_waffle.models.Building)) ",1 "?', hasattr(mod, '__all__') print 'Has __doc__?', hasattr(mod, '__doc__') print 'doc: ', getdoc(mod) if __name__=='__main__': attribs('cairo') attribs('zope') attribs('A.B.C') import hacked class Object(object): pass opt = Object() opt.ignore_errors = False a, d = hacked.get_all_attr_has_docstr('/home/ali/ws-pydev/apidocfilter/A/B', '/home/ali/ws-pydev/apidocfilter/A/B/C', opt) print(a) print(d)",1 "rk 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 tvm from tvm import te def test_stmt_simplify(): ib = tvm.tir.ir_builder.create() A = ib.pointer(""float32"", name=""A"") C = ib.pointer(""float32"", name=""C"") n = te.size_var(""n"") with ib.for_range(0, n, name=""i"") as i: with ib.if_scope(i < 12): A[i] = C[i] body = tvm.tir.LetStmt(n, 10, ib.get()) mod = tvm.IRModule.from_expr(tvm.tir.PrimFunc([A, C, n], body)) body = tvm.tir.transform.Simplify()(mod)[""main""].body assert isinstance(body.body, tvm.tir.Store) def test_thread_extent_simplify(): ib = tvm.tir.ir_builder.create() A = ib.pointer(""float32"", name=""A"") C = ib.pointer(""float32"", name=""C"") n = te.size_var(""n"") tx = te.thread_axis(""threadIdx.x"") ty = te.thread_axis(""threadIdx.y"") ib.scope_attr(tx, ""thread_extent"", n) ib.scope_attr(tx, ""thread_extent"", n) ib.scope_attr(ty, ""thread_extent"", 1) with ib.if_scope(tx + ty < 12): A[tx] = C[tx + ty] body = tvm.tir.LetStmt(n, 10, ib.get()) mod = tvm.IRModule.from_expr(tvm.tir.PrimFunc([A, C, n], body)) body = tvm.tir.transform.Simplify()(mod)[""main""].body assert isinstance(body.body.body.body, tvm.tir.Store) def test_if_likely(): ib = tvm.tir.ir_builder.create() A = ib.pointer(""float32"", name=""A"") C = ib.pointer(""float32"", name=""C"") n = te.size_var(""n"") tx = te.thread_axis(""threadIdx.x"") ty = te.thread_axis(""threadIdx.y"") ib.scope_attr(tx, ""thread_extent"", 32) ib.scope_attr(ty, ""thread_extent"", 32) with ib.if_scope(ib.likely(tx * 32 + ty < n)): with ib.if_scope(ib.likely(tx * 32 + ty < n)): A[tx] = C[tx * 32 + ty] body = ib.get() mod = tvm.IRModule.from_expr(tvm.tir.PrimFunc([A, C, n], body)) body = tvm.tir.transform.Simplify()(mod)[""main""].body assert isinstance(body.body.body, tvm.tir.IfThenElse) assert not isinstance(body.body.body.then_case, tvm.tir.IfThenElse) def test_basic_likely_elimination(): n = te.size_var(""n"") X = te.placeholder(shape=(n,), name=""x"") W = te.placeholder(shape=(n + 1,), dtype=""int32"", name=""w"") def f(i): start = W[i] extent = W[i + 1] - W[i] rv = te.reduce_axis((0, extent)) return te.sum(X[rv + start], axis=rv) Y = te.compute(X.shape, f, name=""y"") s = te.create_schedule([Y.op]) stmt = tvm.lower(s, [X, W, Y], simple_mode=True) assert ""if"" not in str(stmt) def test_complex_likely_elimination(): def cumsum(X): """""" Y[i] = sum(X[:i]) """""" (m,) = X.shape s_state = te.placeholder((m + 1,), dtype=""int32"", name=""state"") s_init = te.compute((1,), lambda _: tvm.tir.const(0, ""int32"")) s_update = te.compute((m + 1,), lambda l: s_state[l - 1] + X[l - 1]) return tvm.te.scan(s_init, s_update, s_state, inputs=[X], name=""cumsum"") def sparse_lengths_sum(data, indices, lengths): oshape = list(data.shape) oshape[0] = lengths.shape[0] length_offsets = cumsum(lengths) def sls(n, d): gg = te.reduce_axis((0, lengths[n])) indices_idx = length_offsets[n] + gg data_idx = indices[indices_idx] data_val = data[data_idx, d] return te.sum(data_val, axis=gg) return te.compute(oshape, sls) m, n, d, i, l = ( te.size_var(""m""), te.size_var(""n""), te.size_var(""d""), te.size_var(""i""), te.size_var(""l""), ) data_ph = te.placeholder((m, d * 32), name=""data"") indices_ph = te.placeholder((i,), name=""indices"", dtype=""int32"") lengths_ph = te.placeholder((n,), name=""lengths"", dtype=""int32"") Y = sparse_lengths_sum(data_ph, indices_ph, lengths_ph) s = te.create_schedule([Y.op]) (n, d) = s[Y].op.axis (do, di) = s[Y].split(d, factor=32) (gg,) = s[Y].op.reduce_axis s[Y].reorder(n, do, gg, di) s[Y].vectorize(di) stmt = tvm.lower(s, [data_ph, indices_ph, lengths_ph, Y], simple_mode=True) assert ""if"" not in str(stmt) if __name__ == ""__main__"": test_stmt_simplify() test_thread_extent_simplify() test_if_likely() test_basic_likely_elimination() test_complex_likely_elimination() ",1 "imiter.extension import C, Limiter from flask_limiter.util import get_remote_address def test_reset(extension_factory): app, limiter = extension_factory({C.DEFAULT_LIMITS: ""1 per day""}) @app.route(""/"") def null(): return ""Hello Reset"" with app.test_client() as cli: cli.get(""/"") assert ""1 per 1 day"" in cli.get(""/"").data.decode() limiter.reset() assert ""Hello Reset"" == cli.get(""/"").data.decode() assert ""1 per 1 day"" in cli.get(""/"").data.decode() def test_reset_unsupported(extension_factory, memcached_connection): app, limiter = extension_factory( {C.DEFAULT_LIMITS: ""1 per day"", C.STORAGE_URI: ""memcached://localhost:31211""} ) @app.route(""/"") def null(): return ""Hello Reset"" with app.test_client() as cli: cli.get(""/"") assert ""1 per 1 day"" in cli.get(""/"").data.decode() # no op with memcached but no error raised limiter.reset() assert ""1 per 1 day"" in cli.get(""/"").data.decode() def test_combined_rate_limits(extension_factory): app, limiter = extension_factory({C.DEFAULT_LIMITS: ""1 per hour; 10 per day""}) @app.route(""/t1"") @limiter.limit(""100 per hour;10/minute"") def t1(): return ""t1"" @app.route(""/t2"") def t2(): return ""t2"" with hiro.Timeline().freeze(): with app.test_client() as cli: assert 200 == cli.get(""/t1"").status_code assert 200 == cli.get(""/t2"").status_code assert 429 == cli.get(""/t2"").status_code def test_defaults_per_method(extension_factory): app, limiter = extension_factory( {C.DEFAULT_LIMITS: ""1 per hour"", C.DEFAULT_LIMITS_PER_METHOD: True} ) @app.route(""/t1"", methods=[""GET"", ""POST""]) def t1(): return ""t1"" with hiro.Timeline().freeze(): with app.test_client() as cli: assert 200 == cli.get(""/t1"").status_code assert 429 == cli.get(""/t1"").status_code assert 200 == cli.post(""/t1"").status_code assert 429 == cli.post(""/t1"").status_code def test_default_limit_with_exemption(extension_factory): def is_backdoor(): return request.headers.get(""backdoor"") == ""true"" app, limiter = extension_factory( {C.DEFAULT_LIMITS: ""1 per hour"", C.DEFAULT_LIMITS_EXEMPT_WHEN: is_backdoor} ) @app.route(""/t1"") def t1(): return ""test"" with hiro.Timeline() as timeline: with app.test_client() as cli: assert cli.get(""/t1"", headers={""backdoor"": ""true""}).status_code == 200 assert cli.get(""/t1"", headers={""backdoor"": ""true""}).status_code == 200 assert cli.get(""/t1"").status_code == 200 assert cli.get(""/t1"").status_code == 429 timeline.forward(3600) assert cli.get(""/t1"").status_code == 200 def test_default_limit_with_conditional_deduction(extension_factory): def failed_request(response): return response.status_code != 200 app, limiter = extension_factory( {C.DEFAULT_LIMITS: ""1 per hour"", C.DEFAULT_LIMITS_DEDUCT_WHEN: failed_request} ) @app.route(""/t1/' 'You will need to restart hass after fixing.' ''.format(err_msg), title=NOTIFICATION_TITLE, notification_id=NOTIFICATION_ID) add_entities(cams, True) return True class RingCam(Camera): """"""An implementation of a Ring Door Bell camera."""""" def __init__(self, hass, camera, device_info): """"""Initialize a Ring Door Bell camera."""""" super(RingCam, self).__init__() self._camera = camera self._hass = hass self._name = self._camera.name self._ffmpeg = hass.data[DATA_FFMPEG] self._ffmpeg_arguments = device_info.get(CONF_FFMPEG_ARGUMENTS) self._last_video_id = self._camera.last_recording_id self._video_url = self._camera.recording_url(self._last_video_id) self._utcnow = dt_util.utcnow() self._expires_at = FORCE_REFRESH_INTERVAL + self._utcnow @property def name(self): """"""Return the name of this camera."""""" return self._name @property def unique_id(self): """"""Return a unique ID."""""" return self._camera.id @property def device_state_attributes(self): """"""Return the state attributes."""""" return { ATTR_ATTRIBUTION: ATTRIBUTION, 'device_id': self._camera.id, 'firmware': self._camera.firmware, 'kind': self._camera.kind, 'timezone': self._camera.timezone, 'type': self._camera.family, 'video_url': self._video_url, } async def async_camera_image(self): """"""Return a still image response from the camera."""""" from haffmpeg.tools import ImageFrame, IMAGE_JPEG ffmpeg = ImageFrame(self._ffmpeg.binary, loop=self.hass.loop) if self._video_url is None: return image = await asyncio.shield(ffmpeg.get_image( self._video_url, output_format=IMAGE_JPEG, extra_cmd=self._ffmpeg_arguments)) return image async def handle_async_mjpeg_stream(self, request): """"""Generate an HTTP MJPEG stream from the camera."""""" from haffmpeg.camera import CameraMjpeg if self._video_url is None: return stream = CameraMjpeg(self._ffmpeg.binary, loop=self.hass.loop) await stream.open_camera( self._video_url, extra_cmd=self._ffmpeg_arguments) try: stream_reader = await stream.get_reader() return await async_aiohttp_proxy_stream( self.hass, request, stream_reader, self._ffmpeg.ffmpeg_stream_content_type) finally: await stream.close() @property def should_poll(self): """"""Update the image periodically."""""" return True def update(self): """"""Update camera entity and refresh attributes."""""" _LOGGER.debug(""Checking if Ring DoorBell needs to refresh video_url"") self._camera.update() self._utcnow = dt_util.utcnow() try: last_event = self._camera.history(limit=1)[0] except (IndexError, TypeError): return last_recording_id = last_event['id'] video_status = last_event['recording']['status'] if video_status == 'ready' and \ (self._last_video_id != last_recording_id or self._utcnow >= self._expires_at): video_url = self._camera.recording_url(last_recording_id) if video_url: _LOGGER.info(""Ring DoorBell properties refreshed"") # update attributes if new video or if URL has expired self._last_video_id = last_recording_id self._video_url = video_url self._expires_at = FORCE_REFRESH_INTERVAL + self._utcnow ",1 " self.events_count_by_type = dict() def increment_counting(self, event): """"""Counts an event Args: event (:obj:`baroque.entities.event.Event`): the event to be counted """""" assert isinstance(event, Event) self.events_count += 1 t = type(event.type) if t in self.events_count_by_type: self.events_count_by_type[t] += 1 else: self.events_count_by_type[t] = 1 def count_all(self): """"""Tells how many events have been counted globally Returns: int """""" return self.events_count def count(self, eventtype): """"""Tells how many events have been counted of the specified type Args: eventtype (:obj:`baroque.entities.eventtype.EventType`): the type of events to be counted Returns: int """""" return self.events_count_by_type.get(type(eventtype), 0) ",1 " @classmethod def setup_class(cls): cls.K = nx.krackhardt_kite_graph() cls.P3 = nx.path_graph(3) cls.P4 = nx.path_graph(4) cls.K5 = nx.complete_graph(5) cls.C4 = nx.cycle_graph(4) cls.T = nx.balanced_tree(r=2, h=2) cls.Gb = nx.Graph() cls.Gb.add_edges_from([(0, 1), (0, 2), (1, 3), (2, 3), (2, 4), (4, 5), (3, 5)]) F = nx.florentine_families_graph() cls.F = F cls.LM = nx.les_miserables_graph() # Create random undirected, unweighted graph for testing incremental version cls.undirected_G = nx.fast_gnp_random_graph(n=100, p=0.6, seed=123) cls.undirected_G_cc = nx.closeness_centrality(cls.undirected_G) def test_wf_improved(self): G = nx.union(self.P4, nx.path_graph([4, 5, 6])) c = nx.closeness_centrality(G) cwf = nx.closeness_centrality(G, wf_improved=False) res = {0: 0.25, 1: 0.375, 2: 0.375, 3: 0.25, 4: 0.222, 5: 0.333, 6: 0.222} wf_res = {0: 0.5, 1: 0.75, 2: 0.75, 3: 0.5, 4: 0.667, 5: 1.0, 6: 0.667} for n in G: assert almost_equal(c[n], res[n], places=3) assert almost_equal(cwf[n], wf_res[n], places=3) def test_digraph(self): G = nx.path_graph(3, create_using=nx.DiGraph()) c = nx.closeness_centrality(G) cr = nx.closeness_centrality(G.reverse()) d = {0: 0.0, 1: 0.500, 2: 0.667} dr = {0: 0.667, 1: 0.500, 2: 0.0} for n in sorted(self.P3): assert almost_equal(c[n], d[n], places=3) assert almost_equal(cr[n], dr[n], places=3) def test_k5_closeness(self): c = nx.closeness_centrality(self.K5) d = {0: 1.000, 1: 1.000, 2: 1.000, 3: 1.000, 4: 1.000} for n in sorted(self.K5): assert almost_equal(c[n], d[n], places=3) def test_p3_closeness(self): c = nx.closeness_centrality(self.P3) d = {0: 0.667, 1: 1.000, 2: 0.667} for n in sorted(self.P3): assert almost_equal(c[n], d[n], places=3) def test_krackhardt_closeness(self): c = nx.closeness_centrality(self.K) d = { 0: 0.529, 1: 0.529, 2: 0.500, 3: 0.600, 4: 0.500, 5: 0.643, 6: 0.643, 7: 0.600, 8: 0.429, 9: 0.310, } for n in sorted(self.K): assert almost_equal(c[n], d[n], places=3) def test_florentine_families_closeness(self): c = nx.closeness_centrality(self.F) d = { ""Acciaiuoli"": 0.368, ""Albizzi"": 0.483, ""Barbadori"": 0.4375, ""Bischeri"": 0.400, ""Castellani"": 0.389, ""Ginori"": 0.333, ""Guadagni"": 0.467, ""Lamberteschi"": 0.326, ""Medici"": 0.560, ""Pazzi"": 0.286, ""Peruzzi"": 0.368, ""Ridolfi"": 0.500, ""Salviati"": 0.389, ""Strozzi"": 0.4375, ""Tornabuoni"": 0.483, } for n in sorted(self.F): assert almost_equal(c[n], d[n], places=3) def test_les_miserables_closeness(self): c = nx.closeness_centrality(self.LM) d = { ""Napoleon"": 0.302, ""Myriel"": 0.429, ""MlleBaptistine"": 0.413, ""MmeMagloire"": 0.413, ""CountessDeLo"": 0.302, ""Geborand"": 0.302, ""Champtercier"": 0.302, ""Cravatte"": 0.302, ""Count"": 0.302, ""OldMan"": 0.302, ""Valjean"": 0.644, ""Labarre"": 0.394, ""Marguerite"": 0.413, ""MmeDeR"": 0.394, ""Isabeau"": 0.394, ""Gervais"": 0.394, ""Listolier"": 0.341, ""Tholomyes"": 0.392, ""Fameuil"": 0.341, ""Blacheville"": 0.341, ""Favourite"": 0.341, ""Dahlia"": 0.341, ""Zephine"": 0.341, ""Fantine"": 0.461, ""MmeThenardier"": 0.461, ""Thenardier"": 0.517, ""Cosette"": 0.478, ""Javert"": 0.517, ""Fauchelevent"": 0.402, ""Bamatabois"": 0.427, ""Perpetue"": 0.318, ""Simplice"": 0.418, ""Scaufflaire"": 0.394, ""Woman1"": 0.396, ""Judge"": 0.404, ""Champmathieu"": 0.404, ""Brevet"": 0.404, ""Chenildieu"": 0.404, ""Cochepaille"": 0.404, ""Pontmercy"": 0.373, ""Boulatruelle"": 0.342, ""Eponine"": 0.396, ""Anzelma"": 0.352, ""Woman2"": 0.402, ""MotherInnocent"": 0.398, ""Gribier"": 0.288, ""MmeBurgon"": 0.344, ""Jondrette"": 0.257, ""Gavroche"": 0.514, ""Gillenormand"": 0.442, ""Magnon"": 0.335, ""MlleGillenormand"": 0.442, ""MmePontmercy"": 0.315, ""MlleVaubois"": 0.308, ""LtGillenormand"": 0.365, ""Marius"": 0.531, ""BaronessT"": 0.352, ""Mabeuf"": 0.396, ""Enjolras"": 0.481, ""Combeferre"": 0.392, ""Prouvaire"": 0.357, ""Feuilly"": 0.392, ""Courfeyrac"": 0.400, ""Bahorel"": 0.394, ""Bossuet"": 0.475, ""Joly"": 0.394, ""Grantaire"": 0.358, ""MotherPlutarch"": 0.285, ""Gueulemer"": 0.463, ""Babet"": 0.463, ""Claquesous"": 0.452, ""Montparnasse"": 0.458, ""Toussaint"": 0.402, ""Child1"": 0.342, ""Child2"": 0.342, ""Brujon"": 0.380, ""MmeHucheloup"": 0.353, } for n in sorted(self.LM): assert almost_equal(c[n], d[n], places=3) def test_weighted_closeness(self): edges = [ (""s"", ""u"", 10), (""s"", ""x"", 5), (""u"", ""v"", 1), (""u"", ""x"", 2), (""v"", ""y"", 1), (""x"", ""u"", 3), (""x"", ""v"", 5), (""x"", ""y"", 2), (""y"", ""s"", 7), (""y"", ""v"", 6), ] XG = nx.Graph() XG.add_weighted_edges_from(edges) c = nx.closeness_centrality(XG, distance=""weight"") d = {""y"": 0.200, ""x"": 0.286, ""s"": 0.138, ""u"": 0.235, ""v"": 0.200} for n in sorted(XG): assert almost_equal(c[n], d[n], places=3) # # Tests for incremental closeness centrality. # @staticmethod def pick_add_edge(g): u = nx.utils.arbitrary_element(g) possible_nodes = set(g.nodes()) neighbors = list(g.neighbors(u)) + [u] possible_nodes.difference_update(neighbors) v = nx.utils.arbitrary_element(possible_nodes) return (u, v) @staticmethod def pick_remove_edge(g): u = nx.utils.arbitrary_element(g) possible_nodes = list(g.neighbors(u)) v = nx.utils.arbitrary_element(possible_nodes) return (u, v) def test_directed_raises(self): with pytest.raises(nx.NetworkXNotImplemented): dir_G = nx.gn_graph(n=5) prev_cc = None edge = self.pick_add_edge(dir_G) insert = True nx.incremental_closeness_centrality(dir_G, edge, prev_cc, insert) def test_wrong_size_prev_cc_raises(self): with pytest.raises(nx.NetworkXError): G = self.undirected_G.copy() edge = self.pick_add_edge(G) insert = True prev_cc = self.undirected_G_cc.copy() prev_cc.pop(0) nx.incremental_closeness_centrality(G, edge, prev_cc, insert) def test_wrong_nodes_prev_cc_raises(self): with pytest.raises(nx.NetworkXError): G = self.undirected_G.copy() edge = self.pick_add_edge(G) insert = True prev_cc = self.undirected_G_cc.copy() num_nodes = len(prev_cc) prev_cc.pop(0) prev_cc[num_nodes] = 0.5 nx.incremental_closeness_centrality(G, edge, prev_cc, insert) def test_zero_centrality(self): G = nx.path_graph(3) prev_cc = nx.closeness_centrality(G) edge = self.pick_remove_edge(G) test_cc = nx.incremental_closeness_centrality(G, edge, prev_cc, insertion=False) G.remove_edges_from([edge]) real_cc = nx.closeness_centrality(G) shared_items = set(test_cc.items()) & set(real_cc.items()) assert len(shared_items) == len(real_cc) assert 0 in test_cc.values() def test_incremental(self): # Check that incremental and regular give same output G = self.undirected_G.copy() prev_cc = None for i in range(5): if i % 2 == 0: # Remove an edge insert = False edge = self.pick_remove_edge(G) else: # Add an edge insert = True edge = self.pick_add_edge(G) # start = timeit.default_timer() test_cc = nx.incremental_closeness_centrality(G, edge, prev_cc, insert) # inc_elapsed = (timeit.default_timer() - start) # print(f""incremental time: {inc_elapsed}"") if insert: G.add_edges_from([edge]) else: G.remove_edges_from([edge]) # start = timeit.default_timer() real_cc = nx.closeness_centrality(G) # reg_elapsed = (timeit.default_timer() - start) # print(f""regular time: {reg_elapsed}"") # Example output: # incremental time: 0.208 # regular time: 0.276 # incremental time: 0.00683 # regular time: 0.260 # incremental time: 0.0224 # regular time: 0.278 # incremental time: 0.00804 # regular time: 0.208 # incremental time: 0.00947 # regular time: 0.188 assert set(test_cc.items()) == set(real_cc.items()) prev_cc = test_cc ",1 "oLismero 2.0 - The web knife - Copyright (C) 2011-2014 Golismero project site: https://github.com/golismero Golismero project mail: contact@golismero-project.com This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. 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, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. """""" __all__ = [""RPCManager""] from ..common import pickle from ..messaging.codes import MessageCode, MSG_RPC_CODES from ..messaging.manager import MessageManager from functools import partial from threading import Thread import sys import traceback #------------------------------------------------------------------------------ # Decorators to automatically register RPC implementors at import time. # Global map of RPC codes to implementors. # dict( int -> tuple(callable, bool) ) rpcMap = {} def implementor(rpc_code, blocking=False): """""" RPC implementation function. """""" return partial(_add_implementor, rpc_code, blocking) def _add_implementor(rpc_code, blocking, fn): # Validate the argument types. if type(rpc_code) is not int: raise TypeError(""Expected int, got %r instead"" % type(rpc_code)) if type(blocking) is not bool: raise TypeError(""Expected bool, got %r instead"" % type(blocking)) if not callable(fn): raise TypeError(""Expected callable, got %r instead"" % type(fn)) # Validate the RPC code. if rpc_code in rpcMap: try: msg = ""Duplicated RPC implementors for code %d: %s and %s"" msg %= (rpc_code, rpcMap[rpc_code][0].__name__, fn.__name__) except Exception: msg = ""Duplicated RPC implementors for code: %d"" % rpc_code raise SyntaxError(msg) # TODO: use introspection to validate the function signature # Register the implementor. rpcMap[rpc_code] = (fn, blocking) # Return the implementor. No wrapping is needed! :) return fn #------------------------------------------------------------------------------ # Implementor for the special MSG_RPC_BULK code for bulk RPC calls. @implementor(MessageCode.MSG_RPC_BULK) def rpc_bulk(orchestrator, audit_name, rpc_code, *arguments): # Get the implementor for the RPC code. # Raise NotImplementedError if it's not defined. try: method, blocking = rpcMap[rpc_code] except KeyError: raise NotImplementedError(""RPC code not implemented: %r"" % rpc_code) # This can't be done with blocking implementors! if blocking: raise NotImplementedError( ""Cannot run blocking RPC calls in bulk. Code: %r"" % rpc_code) # Prepare a partial function call to the implementor. caller = partial(method, orchestrator, audit_name) # Use the built-in map() function to issue all the calls. # This ensures we support the exact same interface and functionality. return map(caller, *arguments) #------------------------------------------------------------------------------ # Ensures the message is received by the Orchestrator. @implementor(MessageCode.MSG_RPC_SEND_MESSAGE) def rpc_send_message(orchestrator, audit_name, message): # Enqueue the ACK message. orchestrator.enqueue_msg(message) #------------------------------------------------------------------------------ class RPCManager (object): """""" Executes remote procedure calls from plugins. """""" #-------------------------------------------------------------------------- def __init__(self, orchestrator): """""" :param orchestrator: Orchestrator instance. :type orchestrator: Orchestrator """""" # Keep a reference to the Orchestrator. self.__orchestrator = orchestrator # Keep a reference to the global RPC map (it's faster this way). self.__rpcMap = rpcMap # Check all RPC messages have been mapped at this point. missing = MSG_RPC_CODES.difference(self.__rpcMap.keys()) if missing: msg = ""Missing RPC implementors for codes: %s"" msg %= "", "".join(str(x) for x in sorted(missing)) raise SyntaxError(msg) #-------------------------------------------------------------------------- @property def orchestrator(self): """""" :returns: Orchestrator instance. :rtype: Orchestrator """""" return self.__orchestrator #-------------------------------------------------------------------------- def execute_rpc(self, audit_name, rpc_code, response_queue, args, kwargs): """""" Honor a remote procedure call request from a plugin. :param audit_name: Name of the audit requesting the call. :type audit_name: str :param rpc_code: RPC code. :type rpc_code: int :param response_queue: Response queue identity. :type response_queue: str :param args: Positional arguments to the call. :type args: tuple :param kwargs: Keyword arguments to the call. :type kwargs: dict """""" try: # Get the implementor for the RPC code. # Raise NotImplementedError if it's not defined. try: target, blocking = self.__rpcMap[rpc_code] except KeyError: raise NotImplementedError( ""RPC code not implemented: %r"" % rpc_code) # If it's a blocking call... if blocking: # Run the implementor in a new thread. thread = Thread( target = self._execute_rpc_implementor_background, args = ( Config._context, audit_name, target, response_queue, args, kwargs), ) thread.daemon = True thread.start() # If it's a non-blocking call... else: # Call the implementor directly. self.execute_rpc_implementor( audit_name, target, response_queue, args, kwargs) # Catch exceptions and send them back. except Exception: if response_queue: error = self.prepare_exception(*sys.exc_info()) try: self.orchestrator.messageManager.send( response_queue, (False, error)) except IOError: import warnings warnings.warn(""RPC caller died!"") pass #-------------------------------------------------------------------------- def _execute_rpc_implementor_background(self, context, audit_name, target, response_queue, args, kwargs): """""" Honor a remote procedure call request from a plugin, from a background thread. Must only be used as the entry point for said background thread! :param context: Plugin execution context. :type context: PluginContext :param audit_name: Name of the audit requesting the call. :type audit_name: str :param target: RPC implementor function. :type target: callable :param response_queue: Response queue identity. :type response_queue: str :param args: Positional arguments to the call. :type args: tuple :param kwargs: Keyword arguments to the call. :type kwargs: dict """""" Config._context = context self.execute_rpc_implementor( audit_name, target, response_queue, args, kwargs) #-------------------------------------------------------------------------- def execute_rpc_implementor(self, audit_name, target, response_queue, args, kwargs): """""" Honor a remote procedure call request from a plugin. :param audit_name: Name of the audit requesting the call. :type audit_name: str :param target: RPC implementor function. :type target: callable :param response_queue: Response queue identity. :type response_queue: str :param args: Positional arguments to the call. :type args: tuple :param kwargs: Keyword arguments to the call. :type kwargs: dict """""" try: # Call the implementor and get the response. response = target(self.orchestrator, audit_name, *args, **kwargs) success = True # Catch exceptions and prepare them for sending. except Exception: if response_queue: response = self.prepare_exception(*sys.exc_info()) success = False # If the call was synchronous, # send the response/error back to the plugin. if response_queue: self.orchestrator.messageManager.send( response_queue, (success, response)) #-------------------------------------------------------------------------- @staticmethod def prepare_exception(exc_type, exc_value, exc_traceback): """""" Prepare an exception for sending back to the plugins. :param exc_type: Exception type. :type exc_type: class :param exc_value: Exception value. :type exc_value: :returns: Exception type, exception value and formatted traceback. The exception value may be formatted too and the exception type replaced by Exception if it's not possible to serialize it for sending. :rtype: tuple(class, object, str) """""" exc_type, exc_value, exc_traceback = sys.exc_info() try: pickle.dumps(exc_value, -1) except Exception: exc_value = traceback.format_exception_only(exc_type, exc_value) try: pickle.dumps(exc_type, -1) except Exception: exc_type = Exception exc_traceback = traceback.extract_tb(exc_traceback) return exc_type, exc_value, exc_traceback ",1 "RANCH = ""develop"" def run_git(*args, dry_run=False, quiet=False): """"""Run a git command, print it before executing and capture the output."""""" command = git[split("" "".join(args))] if not quiet: print(""{}{}"".format(""[DRY-RUN] "" if dry_run else """", command)) if dry_run: return """" rv = command() if not quiet and rv: print(rv) return rv def branch_exists(branch): """"""Return True if the branch exists."""""" try: run_git(""rev-parse --verify {}"".format(branch), quiet=True) return True except ProcessExecutionError: return False def get_current_branch(): """"""Get the current branch name."""""" return run_git(""rev-parse --abbrev-ref HEAD"", quiet=True).strip() ",1 "msg): print(msg) sys.exit(1) def isPathDisabled(path): for part in path.parts: if part.lower().startswith(""_disabled""): return True return False depsFolder = Path(""_deps_split"") prodFolder = Path(""_prods_split"") merged_deps = Path(""merged_deps.py"" ) merged_prods = Path(""merged_prods.py"") if not os.path.isfile(merged_deps): errorExit(""Merged depends file does not exist"") if not os.path.isfile(merged_prods): errorExit(""Merged products file does not exist"") if not os.path.isdir(depsFolder): os.makedirs(depsFolder) else: print(""Clearing old split folder:"" + str(depsFolder)) shutil.rmtree(depsFolder) os.makedirs(depsFolder) if not os.path.isdir(prodFolder): os.makedirs(prodFolder) else: print(""Clearing old split folder:"" + str(prodFolder)) shutil.rmtree(prodFolder) os.makedirs(prodFolder) things = { ""merged_deps.py"" : depsFolder, ""merged_prods.py"" : prodFolder, } for mergefile_name in things: mergedFile = None enableWrite = False curFile = None print(""Splitting "" +mergefile_name+ "" into seperate files in "" + str(things[mergefile_name])) with open(mergefile_name, ""r"", encoding=""utf-8"") as f: mergedFile = f.read().split(""\n"") fileBuffer = """" for line in mergedFile: startR = re.search(""^########START:\[(.+)\]$"",line) endR = re.search(""^########END:\[(.+)\]$"",line) if endR != None: enableWrite = False curFile.write(fileBuffer.rstrip(""\n"")) curFile.close() if enableWrite: fileBuffer+=line+""\n"" if startR != None: enableWrite = True fileBuffer = """" curFile = open(os.path.join(things[mergefile_name],startR.groups()[0]) ,""w"",encoding=""utf-8"") print(""Done"")",1 " import S_OK, S_ERROR, gLogger from DIRAC.Core.Base.Client import Client from DIRAC.Core.Utilities.List import breakListIntoChunks from DIRAC.Resources.Catalog.FileCatalogueBase import FileCatalogueBase from DIRAC.ConfigurationSystem.Client.Helpers.Operations import Operations rpc = None url = None class TransformationClient( Client, FileCatalogueBase ): """""" Exposes the functionality available in the DIRAC/TransformationHandler This inherits the DIRAC base Client for direct execution of server functionality. The following methods are available (although not visible here). Transformation (table) manipulation deleteTransformation(transName) getTransformationParameters(transName,paramNames) getTransformationWithStatus(status) setTransformationParameter(transName,paramName,paramValue) deleteTransformationParameter(transName,paramName) TransformationFiles table manipulation addFilesToTransformation(transName,lfns) addTaskForTransformation(transName,lfns=[],se='Unknown') getTransformationStats(transName) TransformationTasks table manipulation setTaskStatus(transName, taskID, status) setTaskStatusAndWmsID(transName, taskID, status, taskWmsID) getTransformationTaskStats(transName) deleteTasks(transName, taskMin, taskMax) extendTransformation( transName, nTasks) getTasksToSubmit(transName,numTasks,site='') TransformationLogging table manipulation getTransformationLogging(transName) File/directory manipulation methods (the remainder of the interface can be found below) getFileSummary(lfns) exists(lfns) Web monitoring tools getDistinctAttributeValues(attribute, selectDict) getTransformationStatusCounters() getTransformationSummary() getTransformationSummaryWeb(selectDict, sortList, startItem, maxItems) """""" def __init__( self, **kwargs ): Client.__init__( self, **kwargs ) opsH = Operations() self.maxResetCounter = opsH.getValue( 'Productions/ProductionFilesMaxResetCounter', 10 ) self.setServer( 'Transformation/TransformationManager' ) def setServer( self, url ): self.serverURL = url def getCounters( self, table, attrList, condDict, older = None, newer = None, timeStamp = None, rpc = '', url = '' ): rpcClient = self._getRPC( rpc = rpc, url = url ) return rpcClient. getCounters( table, attrList, condDict, older, newer, timeStamp ) def addTransformation( self, transName, description, longDescription, transType, plugin, agentType, fileMask, transformationGroup = 'General', groupSize = 1, inheritedFrom = 0, body = '', maxTasks = 0, eventsPerTask = 0, addFiles = True, rpc = '', url = '', timeout = 1800 ): """""" add a new transformation """""" rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout ) return rpcClient.addTransformation( transName, description, longDescription, transType, plugin, agentType, fileMask, transformationGroup, groupSize, inheritedFrom, body, maxTasks, eventsPerTask, addFiles ) def getTransformations( self, condDict = {}, older = None, newer = None, timeStamp = 'CreationDate', orderAttribute = None, limit = 100, extraParams = False, rpc = '', url = '', timeout = None ): """""" gets all the transformations in the system, incrementally. ""limit"" here is just used to determine the offset. """""" rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout ) transformations = [] # getting transformations - incrementally offsetToApply = 0 while True: res = rpcClient.getTransformations( condDict, older, newer, timeStamp, orderAttribute, limit, extraParams, offsetToApply ) if not res['OK']: return res else: gLogger.verbose( ""Result for limit %d, offset %d: %d"" % ( limit, offsetToApply, len( res['Value'] ) ) ) if res['Value']: transformations = transformations + res['Value'] offsetToApply += limit if len( res['Value'] ) < limit: break return S_OK( transformations ) def getTransformation( self, transName, extraParams = False, rpc = '', url = '', timeout = None ): rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout ) return rpcClient.getTransformation( transName, extraParams ) def getTransformationFiles( self, condDict = {}, older = None, newer = None, timeStamp = 'LastUpdate', orderAttribute = None, limit = 10000, rpc = '', url = '', timeout = 1800 ): """""" gets all the transformation files for a transformation, incrementally. ""limit"" here is just used to determine the offset. """""" rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout ) transformationFiles = [] # getting transformationFiles - incrementally offsetToApply = 0 while True: res = rpcClient.getTransformationFiles( condDict, older, newer, timeStamp, orderAttribute, limit, offsetToApply ) if not res['OK']: return res else: gLogger.verbose( ""Result for limit %d, offset %d: %d"" % ( limit, offsetToApply, len( res['Value'] ) ) ) if res['Value']: transformationFiles = transformationFiles + res['Value'] offsetToApply += limit if len( res['Value'] ) < limit: break return S_OK( transformationFiles ) def getTransformationTasks( self, condDict = {}, older = None, newer = None, timeStamp = 'CreationTime', orderAttribute = None, limit = 10000, inputVector = False, rpc = '', url = '', timeout = None ): """""" gets all the transformation tasks for a transformation, incrementally. ""limit"" here is just used to determine the offset. """""" rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout ) transformationTasks = [] # getting transformationFiles - incrementally offsetToApply = 0 while True: res = rpcClient.getTransformationTasks( condDict, older, newer, timeStamp, orderAttribute, limit, inputVector, offsetToApply ) if not res['OK']: return res else: gLogger.verbose( ""Result for limit %d, offset %d: %d"" % ( limit, offsetToApply, len( res['Value'] ) ) ) if res['Value']: transformationTasks = transformationTasks + res['Value'] offsetToApply += limit if len( res['Value'] ) < limit: break return S_OK( transformationTasks ) def cleanTransformation( self, transID, rpc = '', url = '', timeout = None ): """""" Clean the transformation, and set the status parameter (doing it here, for easier extensibility) """""" # Cleaning rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout ) res = rpcClient.cleanTransformation( transID ) if not res['OK']: return res # Setting the status return self.setTransformationParameter( transID, 'Status', 'TransformationCleaned' ) def moveFilesToDerivedTransformation( self, transDict, resetUnused = True ): """""" move files input to a transformation, to the derived one """""" prod = transDict['TransformationID'] parentProd = int( transDict.get( 'InheritedFrom', 0 ) ) movedFiles = {} if not parentProd: gLogger.warn( ""[None] [%d] .moveFilesToDerivedTransformation: Transformation was not derived..."" % prod ) return S_OK( ( parentProd, movedFiles ) ) # get the lfns in status Unused/MaxReset of the parent production res = self.getTransformationFiles( condDict = {'TransformationID': parentProd, 'Status': [ 'Unused', 'MaxReset' ]} ) if not res['OK']: gLogger.error( ""[None] [%d] .moveFilesToDerivedTransformation: Error getting Unused files from transformation %s:"" % ( prod, parentProd ), res['Message'] ) return res parentFiles = res['Value'] lfns = [lfnDict['LFN'] for lfnDict in parentFiles] if not lfns: gLogger.info( ""[None] [%d] .moveFilesToDerivedTransformation: No files found to be moved from transformation %d"" % ( prod, parentProd ) ) return S_OK( ( parentProd, movedFiles ) ) # get the lfns of the derived production that were Unused/MaxReset in the parent one res = self.getTransformationFiles( condDict = { 'TransformationID': prod, 'LFN': lfns} ) if not res['OK']: gLogger.error( ""[None] [%d] .moveFilesToDerivedTransformation: Error getting files from derived transformation"" % prod, res['Message'] ) return res derivedFiles = res['Value'] suffix = '-%d' % parentProd derivedStatusDict = dict( [( derivedDict['LFN'], derivedDict['Status'] ) for derivedDict in derivedFiles] ) newStatusFiles = {} parentStatusFiles = {} force = False for parentDict in parentFiles: lfn = parentDict['LFN'] derivedStatus = derivedStatusDict.get( lfn ) if derivedStatus: parentStatus = parentDict['Status'] if resetUnused and parentStatus == 'MaxReset': status = 'Unused' moveStatus = 'Unused from MaxReset' force = True else: status = parentStatus moveStatus = parentStatus if derivedStatus.endswith( suffix ): # This file is Unused or MaxReset while it was most likely Assigned at the time of derivation parentStatusFiles.setdefault( 'Moved-%s' % str( prod ), [] ).append( lfn ) newStatusFiles.setdefault( ( status, parentStatus ), [] ).append( lfn ) movedFiles[moveStatus] = movedFiles.setdefault( moveStatus, 0 ) + 1 elif parentDict['Status'] == 'Unused': # If the file was Unused already at derivation time, set it NotProcessed parentStatusFiles.setdefault( 'NotProcessed', [] ).append( lfn ) # Set the status in the parent transformation first for status, lfnList in parentStatusFiles.items(): for lfnChunk in breakListIntoChunks( lfnList, 5000 ): res = self.setFileStatusForTransformation( parentProd, status, lfnChunk ) if not res['OK']: gLogger.error( ""[None] [%d] .moveFilesToDerivedTransformation: Error setting status %s for %d files in transformation %d "" % ( prod, status, len( lfnList ), parentProd ), res['Message'] ) # Set the status in the new transformation for ( status, oldStatus ), lfnList in newStatusFiles.items(): for lfnChunk in breakListIntoChunks( lfnList, 5000 ): res = self.setFileStatusForTransformation( prod, status, lfnChunk, force = force ) if not res['OK']: gLogger.error( ""[None] [%d] .moveFilesToDerivedTransformation: Error setting status %s for %d files; resetting them %s in transformation %d"" % ( prod, status, len( lfnChunk ), oldStatus, parentProd ), res['Message'] ) res = self.setFileStatusForTransformation( parentProd, oldStatus, lfnChunk ) if not res['OK']: gLogger.error( ""[None] [%d] .moveFilesToDerivedTransformation: Error setting status %s for %d files in transformation %d"" % ( prod, oldStatus, len( lfnChunk ), parentProd ), res['Message'] ) return S_OK( ( parentProd, movedFiles ) ) def setFileStatusForTransformation( self, transName, newLFNsStatus = {}, lfns = [], force = False, rpc = '', url = '', timeout = 120 ): """""" sets the file status for LFNs of a transformation For backward compatibility purposes, the status and LFNs can be passed in 2 ways: - newLFNsStatus is a dictionary with the form: {'/this/is/an/lfn1.txt': 'StatusA', '/this/is/an/lfn2.txt': 'StatusB', ... } and at this point lfns is not considered - newLFNStatus is a string, that applies to all the LFNs in lfns """""" rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout ) # create dictionary in case newLFNsStatus is a string if type( newLFNsStatus ) == type( '' ): newLFNsStatus = dict( [( lfn, newLFNsStatus ) for lfn in lfns ] ) # gets status as of today tsFiles = self.getTransformationFiles( {'TransformationID':transName, 'LFN': newLFNsStatus.keys()} ) if not tsFiles['OK']: return tsFiles tsFiles = tsFiles['Value'] if tsFiles: # for convenience, makes a small dictionary out of the tsFiles, with the lfn as key tsFilesAsDict = {} for tsFile in tsFiles: tsFilesAsDict[tsFile['LFN']] = [tsFile['Status'], tsFile['ErrorCount'], tsFile['FileID']] # applying the state machine to the proposed status newStatuses = self._applyTransformationFilesStateMachine( tsFilesAsDict, newLFNsStatus, force ) if newStatuses: # if there's something to update # must do it for the file IDs... newStatusForFileIDs = dict( [( tsFilesAsDict[lfn][2], newStatuses[lfn] ) for lfn in newStatuses.keys()] ) res = rpcClient.setFileStatusForTransformation( transName, newStatusForFileIDs ) if not res['OK']: return res return S_OK( newStatuses ) def _applyTransformationFilesStateMachine( self, tsFilesAsDict, dictOfProposedLFNsStatus, force ): """""" For easier extension, here we apply the state machine of the production files. VOs might want to replace the standard here with something they prefer. tsFiles is a dictionary with the lfn as key and as value a list of [Status, ErrorCount, FileID] dictOfNewLFNsStatus is a dictionary with the proposed status force is a boolean It returns a dictionary with the status updates """""" newStatuses = {} for lfn in dictOfProposedLFNsStatus.keys(): if lfn not in tsFilesAsDict.keys(): continue else: newStatus = dictOfProposedLFNsStatus[lfn] # Apply optional corrections if tsFilesAsDict[lfn][0].lower() == 'processed' and dictOfProposedLFNsStatus[lfn].lower() != 'processed': if not force: newStatus = 'Processed' elif tsFilesAsDict[lfn][0].lower() == 'maxreset': if not force: newStatus = 'MaxReset' elif dictOfProposedLFNsStatus[lfn].lower() == 'unused': errorCount = tsFilesAsDict[lfn][1] # every 10 retries (by default) if errorCount and ( ( errorCount % self.maxResetCounter ) == 0 ): if not force: newStatus = 'MaxReset' if tsFilesAsDict[lfn][0].lower() != newStatus: newStatuses[lfn] = newStatus return newStatuses def setTransformationParameter( self, transID, paramName, paramValue, force = False, rpc = '', url = '', timeout = 120 ): """""" Sets a transformation parameter. There's a special case when coming to setting the status of a transformation. """""" rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout ) if paramName.lower() == 'status': # get transformation Type transformation = self.getTransformation( transID ) if not transformation['OK']: return transformation transformationType = transformation['Value']['Type'] # get status as of today originalStatus = self.getTransformationParameters( transID, 'Status' ) if not originalStatus['OK']: return originalStatus originalStatus = originalStatus['Value'] transIDAsDict = {transID: [originalStatus, transformationType]} dictOfProposedstatus = {transID: paramValue} # applying the state machine to the proposed status value = self._applyTransformationStatusStateMachine( transIDAsDict, dictOfProposedstatus, force ) else: value = paramValue return rpcClient.setTransformationParameter( transID, paramName, value ) def _applyTransformationStatusStateMachine( self, transIDAsDict, dictOfProposedstatus, force ): """""" For easier extension, here we apply the state machine of the transformation status. VOs might want to replace the standard here with something they prefer. transIDAsDict is a dictionary with the transID as key and as value a list with [Status, Type] dictOfProposedstatus is a dictionary with the proposed status force is a boolean It returns the new status (the standard is just doing nothing: everything is possible) """""" return dictOfProposedstatus.values()[0] ##################################################################### # # These are the file catalog interface methods # def isOK( self ): return self.valid def getName( self, DN = '' ): """""" Get the file catalog type name """""" return self.name def addDirectory( self, path, force = False, rpc = '', url = '', timeout = None ): rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout ) return rpcClient.addDirectory( path, force ) def getReplicas( self, lfn, rpc = '', url = '', timeout = None ): res = self.__checkArgumentFormat( lfn ) if not res['OK']: return res lfns = res['Value'].keys() rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout ) return rpcClient.getReplicas( lfns ) def addFile( self, lfn, force = False, rpc = '', url = '', timeout = None ): res = self.__checkArgumentFormat( lfn ) if not res['OK']: return res lfndicts = res['Value'] rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout ) return rpcClient.addFile( lfndicts, force ) def addReplica( self, lfn, force = False, rpc = '', url = '', timeout = None ): res = self.__checkArgumentFormat( lfn ) if not res['OK']: return res lfndicts = res['Value'] rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout ) return rpcClient.addReplica( lfndicts, force ) def removeFile( self, lfn, rpc = '', url = '', timeout = None ): res = self.__checkArgumentFormat( lfn ) if not res['OK']: return res lfns = res['Value'].keys() rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout ) successful = {} failed = {} listOfLists = breakListIntoChunks( lfns, 100 ) for fList in listOfLists: res = rpcClient.removeFile( fList ) if not res['OK']: return res successful.update( res['Value']['Successful'] ) failed.update( res['Value']['Failed'] ) resDict = {'Successful': successful, 'Failed':failed} return S_OK( resDict ) def removeReplica( self, lfn, rpc = '', url = '', timeout = None ): res = self.__checkArgumentFormat( lfn ) if not res['OK']: return res lfndicts = res['Value'] rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout ) successful = {} failed = {} # as lfndicts is a dict, the breakListIntoChunks will fail. Fake it! listOfDicts = [] localdicts = {} for lfn, info in lfndicts.items(): localdicts.update( { lfn : info } ) if len( localdicts.keys() ) % 100 == 0: listOfDicts.append( localdicts ) localdicts = {} for fDict in listOfDicts: res = rpcClient.removeReplica( fDict ) if not res['OK']: return res successful.update( res['Value']['Successful'] ) failed.update( res['Value']['Failed'] ) resDict = {'Successful': successful, 'Failed':failed} return S_OK( resDict ) def getReplicaStatus( self, lfn, rpc = '', url = '', timeout = None ): res = self.__checkArgumentFormat( lfn ) if not res['OK']: return res lfndict = res['Value'] rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout ) return rpcClient.getReplicaStatus( lfndict ) def setReplicaStatus( self, lfn, rpc = '', url = '', timeout = None ): res = self.__checkArgumentFormat( lfn ) if not res['OK']: return res lfndict = res['Value'] rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout ) return rpcClient.setReplicaStatus( lfndict ) def setReplicaHost( self, lfn, rpc = '', url = '', timeout = None ): res = self.__checkArgumentFormat( lfn ) if not res['OK']: return res lfndict = res['Value'] rpcClient = self._getRPC( rpc = rpc, url = url, timeout = timeout ) return rpcClient.setReplicaHost( lfndict ) def removeDirectory( self, lfn, rpc = '', url = '', timeout = None ): return self.__returnOK( lfn ) def createDirectory( self, lfn, rpc = '', url = '', timeout = None ): return self.__returnOK( lfn ) def createLink( self, lfn, rpc = '', url = '', timeout = None ): return self.__returnOK( lfn ) def removeLink( self, lfn, rpc = '', url = '', timeout = None ): return self.__returnOK( lfn ) def __returnOK( self, lfn ): res = self.__checkArgumentFormat( lfn ) if not res['OK']: return res successful = {} for lfn in res['Value'].keys(): successful[lfn] = True resDict = {'Successful':successful, 'Failed':{}} return S_OK( resDict ) def __checkArgumentFormat( self, path ): if type( path ) in types.StringTypes: urls = {path:False} elif type( path ) == types.ListType: urls = {} for url in path: urls[url] = False elif type( path ) == types.DictType: urls = path else: return S_ERROR( ""TransformationClient.__checkArgumentFormat: Supplied path is not of the correct format."" ) return S_OK( urls ) ",1 "et_gdb_executable = Architecture.resolve(GDB_X86) get_oocd_executable = Architecture.resolve(OPENOCD) qemu_name = 'i386' gdb_name = 'i386' registers = {'eax': 0, 'ecx': 1, 'edx': 2, 'ebx': 3, 'esp': 4, 'ebp': 5, 'esi': 6, 'edi': 7, 'eip': 8, 'pc': 8, 'eflags': 9, 'cs': 10, 'ss': 11, 'ds': 12, 'es': 13, 'fs': 14, 'gs': 15, } special_registers = { #SSE 'xmm0': {'format': '{{{:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$xmm0.v4_int32', }, 'xmm1': {'format': '{{{:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$xmm1.v4_int32', }, 'xmm2': {'format': '{{{:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$xmm2.v4_int32', }, 'xmm3': {'format': '{{{:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$xmm3.v4_int32', }, 'xmm4': {'format': '{{{:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$xmm4.v4_int32', }, 'xmm5': {'format': '{{{:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$xmm5.v4_int32', }, 'xmm6': {'format': '{{{:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$xmm6.v4_int32', }, 'xmm7': {'format': '{{{:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$xmm7.v4_int32', }, 'xmm8': {'format': '{{{:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$xmm8.v4_int32', }, 'xmm9': {'format': '{{{:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$xmm9.v4_int32', }, 'xmm10': {'format': '{{{:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$xmm10.v4_int32', }, 'xmm11': {'format': '{{{:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$xmm11.v4_int32', }, 'xmm12': {'format': '{{{:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$xmm12.v4_int32', }, 'xmm13': {'format': '{{{:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$xmm13.v4_int32', }, 'xmm14': {'format': '{{{:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$xmm14.v4_int32', }, 'xmm15': {'format': '{{{:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$xmm15.v4_int32', }, #AVX 'ymm0': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$ymm0.v8_int32', }, 'ymm1': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$ymm1.v8_int32', }, 'ymm2': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$ymm2.v8_int32', }, 'ymm3': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$ymm3.v8_int32', }, 'ymm4': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$ymm4.v8_int32', }, 'ymm5': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$ymm5.v8_int32', }, 'ymm6': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$ymm6.v8_int32', }, 'ymm7': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$ymm7.v8_int32', }, 'ymm8': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$ymm8.v8_int32', }, 'ymm9': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$ymm9.v8_int32', }, 'ymm10': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$ymm10.v8_int32', }, 'ymm11': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$ymm11.v8_int32', }, 'ymm12': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$ymm12.v8_int32', }, 'ymm13': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$ymm13.v8_int32', }, 'ymm14': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$ymm14.v8_int32', }, 'ymm15': {'format': '{{{:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}, {:d}}}', 'gdb_expression': '$ymm15.v8_int32', }, } sr_name = 'eflags' unemulated_instructions = [] capstone_arch = CS_ARCH_X86 capstone_mode = CS_MODE_32 word_size = 32 class X86_64(X86): qemu_name = 'x86_64' gdb_name = 'i386:x86-64' registers = {'rax': 0, 'rbx': 1, 'rcx': 2, 'rdx': 3, 'rsi': 4, 'rdi': 5, 'rbp': 6, 'rsp': 7, 'r8': 8, 'r9': 9, 'r10': 10, 'r11': 11, 'r12': 12, 'r13': 13, 'r14': 14, 'r15': 15, 'rip': 16, 'pc': 16, 'eflags': 17, 'cs': 18, 'ss': 19, 'ds': 20, 'es': 21, 'fs': 22, 'gs': 23, } capstone_mode = CS_MODE_64 unemulated_instructions = [] capstone_mode = CS_MODE_64 word_size = 64 ",1 "ef __init__(self): c_ptr = SummaryKeyMatcher.cNamespace().alloc() super(SummaryKeyMatcher, self).__init__(c_ptr) def addSummaryKey(self, key): assert isinstance(key, str) return SummaryKeyMatcher.cNamespace().add_key(self, key) def __len__(self): return SummaryKeyMatcher.cNamespace().size(self) def __contains__(self, key): return SummaryKeyMatcher.cNamespace().match_key(self, key) def isRequired(self, key): """""" @rtype: bool """""" return SummaryKeyMatcher.cNamespace().is_required(self, key) def keys(self): """""" @rtype: StringList """""" return SummaryKeyMatcher.cNamespace().keys(self) def free(self): SummaryKeyMatcher.cNamespace().free(self) cwrapper = CWrapper(ENKF_LIB) cwrapper.registerObjectType(""summary_key_matcher"", SummaryKeyMatcher) SummaryKeyMatcher.cNamespace().alloc = cwrapper.prototype(""c_void_p summary_key_matcher_alloc()"") SummaryKeyMatcher.cNamespace().free = cwrapper.prototype(""void summary_key_matcher_free(summary_key_matcher)"") SummaryKeyMatcher.cNamespace().size = cwrapper.prototype(""int summary_key_matcher_get_size(summary_key_matcher)"") SummaryKeyMatcher.cNamespace().add_key = cwrapper.prototype(""void summary_key_matcher_add_summary_key(summary_key_matcher, char*)"") SummaryKeyMatcher.cNamespace().match_key = cwrapper.prototype(""bool summary_key_matcher_match_summary_key(summary_key_matcher, char*)"") SummaryKeyMatcher.cNamespace().keys = cwrapper.prototype(""stringlist_obj summary_key_matcher_get_keys(summary_key_matcher)"") SummaryKeyMatcher.cNamespace().is_required = cwrapper.prototype(""bool summary_key_matcher_summary_key_is_required(summary_key_matcher, char*)"") ",1 "iven('a valid user with values {username}, {password}, {email}, {first_name}, {last_name}') def step_impl(context, username, password, email, first_name, last_name): context.base_user = User(username=username, email=email, password=password, first_name=first_name, last_name=last_name) @when('I add the user to the collection') def step_impl(context): context.user_service.save(context.base_user) @then('I check {user_name} exists') def step_impl(context, user_name): user_exists = context.user_service.exists(user_name) assert context.base_user.username == user_exists['username'] assert context.base_user.password == user_exists['password'] assert context.base_user.email == user_exists['email'] assert context.base_user.first_name == user_exists['first_name'] assert context.base_user.last_name == user_exists['last_name'] assert user_exists['_id'] is not None @given('I update {username} {field} with {value}') def step_impl(context, username, field, value): user = context.user_service.exists(username) if user is not None: user[field] = value context.user_service.update(user.to_json()) else: raise UserNotFound(username, ""User was not found"") @then('I check {username} {field} is {value}') def step_impl(context, username, field, value): user = context.user_service.exists(username) if user is not None: assert user[field] == value else: raise UserNotFound(username, ""User was not found"") ",1 "hemaMigration): def forwards(self, orm): # Adding field 'Question.order' db.add_column(u'survey_question', 'order', self.gf('django.db.models.fields.IntegerField')(default=0), keep_default=False) def backwards(self, orm): # Deleting field 'Question.order' db.delete_column(u'survey_question', 'order') models = { u'survey.option': { 'Meta': {'object_name': 'Option'}, u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'label': ('django.db.models.fields.SlugField', [], {'max_length': '64'}), 'text': ('django.db.models.fields.CharField', [], {'max_length': '254'}) }, u'survey.page': { 'Meta': {'ordering': ""['order']"", 'unique_together': ""(('survey', 'order'),)"", 'object_name': 'Page'}, u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'order': ('django.db.models.fields.IntegerField', [], {}), 'question': ('django.db.models.fields.related.ForeignKey', [], {'to': u""orm['survey.Question']""}), 'survey': ('django.db.models.fields.related.ForeignKey', [], {'to': u""orm['survey.Survey']""}) }, u'survey.question': { 'Meta': {'object_name': 'Question'}, 'allow_other': ('django.db.models.fields.BooleanField', [], {'default': 'False'}), u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'info': ('django.db.models.fields.CharField', [], {'max_length': '254', 'null': 'True', 'blank': 'True'}), 'label': ('django.db.models.fields.CharField', [], {'max_length': '254'}), 'modalQuestion': ('django.db.models.fields.related.ForeignKey', [], {'to': u""orm['survey.Question']"", 'null': 'True', 'blank': 'True'}), 'options': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': u""orm['survey.Option']"", 'null': 'True', 'blank': 'True'}), 'options_from_previous_answer': ('django.db.models.fields.CharField', [], {'max_length': '254', 'null': 'True', 'blank': 'True'}), 'options_json': ('django.db.models.fields.CharField', [], {'max_length': '254', 'null': 'True', 'blank': 'True'}), 'order': ('django.db.models.fields.IntegerField', [], {}), 'randomize_groups': ('django.db.models.fields.BooleanField', [], {'default': 'False'}), 'slug': ('django.db.models.fields.SlugField', [], {'max_length': '64'}), 'title': ('django.db.models.fields.TextField', [], {}), 'type': ('django.db.models.fields.CharField', [], {'default': ""'text'"", 'max_length': '20'}) }, u'survey.respondant': { 'Meta': {'object_name': 'Respondant'}, 'email': ('django.db.models.fields.EmailField', [], {'max_length': '254'}), 'responses': ('django.db.models.fields.related.ManyToManyField', [], {'related_name': ""'responses'"", 'symmetrical': 'False', 'to': u""orm['survey.Response']""}), 'survey': ('django.db.models.fields.related.ForeignKey', [], {'to': u""orm['survey.Survey']""}), 'ts': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2013, 4, 30, 0, 0)'}), 'uuid': ('django.db.models.fields.CharField', [], {'default': ""'bc967489-023c-46ce-b396-d209c8323fac'"", 'max_length': '36', 'primary_key': 'True'}) }, u'survey.response': { 'Meta': {'object_name': 'Response'}, 'answer': ('django.db.models.fields.TextField', [], {}), u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'question': ('django.db.models.fields.related.ForeignKey', [], {'to': u""orm['survey.Question']""}), 'respondant': ('django.db.models.fields.related.ForeignKey', [], {'to': u""orm['survey.Respondant']""}), 'ts': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime(2013, 4, 30, 0, 0)'}) }, u'survey.survey': { 'Meta': {'object_name': 'Survey'}, u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}), 'name': ('django.db.models.fields.CharField', [], {'max_length': '254'}), 'questions': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': u""orm['survey.Question']"", 'null': 'True', 'through': u""orm['survey.Page']"", 'blank': 'True'}), 'slug': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '254'}) } } complete_apps = ['survey']",1 " .product import ProductImage from .enum_values import EnumValues from .related_values import RelatedValues from .customer import Customer from .expense import Expense from .incoming import Incoming from .shipping import Shipping, ShippingLine from .receiving import Receiving, ReceivingLine from .inventory_transaction import InventoryTransaction, InventoryTransactionLine from .purchase_order import PurchaseOrder, PurchaseOrderLine from .sales_order import SalesOrder, SalesOrderLine from .user import User from .role import Role, roles_users from .organization import Organization from .inventory_in_out_link import InventoryInOutLink from .aspects import update_menemonic from .product_inventory import ProductInventory ",1 "ttp://www.opensource.org/licenses/mit-license.php. # CLI to solve an auxpow (or not) in regtest difficulty. import binascii import hashlib import sys def computeAuxpow (block, target, ok): """""" Build an auxpow object (serialised as hex string) that solves (ok = True) or doesn't solve (ok = False) the block. """""" # Start by building the merge-mining coinbase. The merkle tree # consists only of the block hash as root. coinbase = ""fabe"" + binascii.hexlify (""m"" * 2) coinbase += block coinbase += ""01000000"" + (""00"" * 4) # Construct ""vector"" of transaction inputs. vin = ""01"" vin += (""00"" * 32) + (""ff"" * 4) vin += (""%02x"" % (len (coinbase) / 2)) + coinbase vin += (""ff"" * 4) # Build up the full coinbase transaction. It consists only # of the input and has no outputs. tx = ""01000000"" + vin + ""00"" + (""00"" * 4) txHash = doubleHashHex (tx) # Construct the parent block header. It need not be valid, just good # enough for auxpow purposes. header = ""01000000"" header += ""00"" * 32 header += reverseHex (txHash) header += ""00"" * 4 header += ""00"" * 4 header += ""00"" * 4 # Mine the block. (header, blockhash) = mineBlock (header, target, ok) # Build the MerkleTx part of the auxpow. auxpow = tx auxpow += blockhash auxpow += ""00"" auxpow += ""00"" * 4 # Extend to full auxpow. auxpow += ""00"" auxpow += ""00"" * 4 auxpow += header return auxpow def mineBlock (header, target, ok): """""" Given a block header, update the nonce until it is ok (or not) for the given target. """""" data = bytearray (binascii.unhexlify (header)) while True: assert data[79] < 255 data[79] += 1 hexData = binascii.hexlify (data) blockhash = doubleHashHex (hexData) if (ok and blockhash < target) or ((not ok) and blockhash > target): break return (hexData, blockhash) def doubleHashHex (data): """""" Perform Crowncoin's Double-SHA256 hash on the given hex string. """""" hasher = hashlib.sha256 () hasher.update (binascii.unhexlify (data)) data = hasher.digest () hasher = hashlib.sha256 () hasher.update (data) return reverseHex (hasher.hexdigest ()) def reverseHex (data): """""" Flip byte order in the given data (hex string). """""" b = bytearray (binascii.unhexlify (data)) b.reverse () return binascii.hexlify (b) ################################################################################ if len (sys.argv) != 4: print ""Usage: solveauxpow.py HASH _TARGET OK"" sys.exit () blockHash = sys.argv[1] revTarget = sys.argv[2] ok = sys.argv[3] if ok not in [""true"", ""false""]: print ""expected 'true' or 'false' as OK value"" sys.exit () target = reverseHex (revTarget) ok = (ok == ""true"") res = computeAuxpow (blockHash, target, ok) print res ",1 " def test__POINTER_c_char(self): class X(Structure): _fields_ = [(""str"", POINTER(c_char))] x = X() # NULL pointer access self.assertRaises(ValueError, getattr, x.str, ""contents"") b = c_buffer(b""Hello, World"") from sys import getrefcount as grc self.assertEqual(grc(b), 2) x.str = b self.assertEqual(grc(b), 3) # POINTER(c_char) and Python string is NOT compatible # POINTER(c_char) and c_buffer() is compatible for i in range(len(b)): self.assertEqual(b[i], x.str[i]) self.assertRaises(TypeError, setattr, x, ""str"", ""Hello, World"") def test__c_char_p(self): class X(Structure): _fields_ = [(""str"", c_char_p)] x = X() # c_char_p and Python string is compatible # c_char_p and c_buffer is NOT compatible self.assertEqual(x.str, None) x.str = b""Hello, World"" self.assertEqual(x.str, b""Hello, World"") b = c_buffer(b""Hello, World"") self.assertRaises(TypeError, setattr, x, b""str"", b) def test_functions(self): strchr = lib.my_strchr strchr.restype = c_char_p # c_char_p and Python string is compatible # c_char_p and c_buffer are now compatible strchr.argtypes = c_char_p, c_char self.assertEqual(strchr(b""abcdef"", b""c""), b""cdef"") self.assertEqual(strchr(c_buffer(b""abcdef""), b""c""), b""cdef"") # POINTER(c_char) and Python string is NOT compatible # POINTER(c_char) and c_buffer() is compatible strchr.argtypes = POINTER(c_char), c_char buf = c_buffer(b""abcdef"") self.assertEqual(strchr(buf, b""c""), b""cdef"") self.assertEqual(strchr(b""abcdef"", b""c""), b""cdef"") # XXX These calls are dangerous, because the first argument # to strchr is no longer valid after the function returns! # So we must keep a reference to buf separately strchr.restype = POINTER(c_char) buf = c_buffer(b""abcdef"") r = strchr(buf, b""c"") x = r[0], r[1], r[2], r[3], r[4] self.assertEqual(x, (b""c"", b""d"", b""e"", b""f"", b""\000"")) del buf # x1 will NOT be the same as x, usually: x1 = r[0], r[1], r[2], r[3], r[4] if __name__ == '__main__': unittest.main() ",1 "erty() class Greeting(db.Model): author = db.UserProperty() content = db.StringProperty(multiline=True) avatar = db.BlobProperty() date = db.DateTimeProperty(auto_now_add=True) class Placebo(db.Model): developer = db.StringProperty() OID = db.StringProperty() concept = db.StringProperty() category = db.StringProperty() taxonomy = db.StringProperty() taxonomy_version = db.StringProperty() code = db.StringProperty() descriptor = db.StringProperty() ",1 "t 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. """"""All sorts of properties for every field. Generated by ./generate-onetime-js-widget-data.py AMD-style module definition. Note: No leading, internal path before the [], since we'd have to hardwire it to data/whatever-fns.js which is inflexible. """""" # TODO: Clean up the description fields that actually contain data # extracted from the comments of dbroot_v2.proto. # The META_INFO contains already vetted snippets. META_INFO = r"""""" { ""end_snippet.bbs_server_info.base_url:value"": { ""abstract_fieldpath"": ""end_snippet.bbs_server_info.base_url:value"", ""default_value"": null, ""description"": ""URL of the server including protocol, domain and port. Can be translated if we use different servers for different languages."", ""empty_concrete_fieldpath"": ""end_snippet.bbs_server_info.base_url:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""base_url:value"", ""presence"": ""optional"", ""short_label"": ""base_url"", ""typ"": ""string"" }, ""end_snippet.bbs_server_info.file_submit_path:value"": { ""abstract_fieldpath"": ""end_snippet.bbs_server_info.file_submit_path:value"", ""default_value"": null, ""description"": ""Path on server where files can be submitted."", ""empty_concrete_fieldpath"": ""end_snippet.bbs_server_info.file_submit_path:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""file_submit_path:value"", ""presence"": ""optional"", ""short_label"": ""file_submit_path"", ""typ"": ""string"" }, ""end_snippet.bbs_server_info.name:value"": { ""abstract_fieldpath"": ""end_snippet.bbs_server_info.name:value"", ""default_value"": null, ""description"": ""Name that will be displayed in context menu to user. Must be translated."", ""empty_concrete_fieldpath"": ""end_snippet.bbs_server_info.name:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""name:value"", ""presence"": ""optional"", ""short_label"": ""name"", ""typ"": ""string"" }, ""end_snippet.bbs_server_info.post_wizard_path:value"": { ""abstract_fieldpath"": ""end_snippet.bbs_server_info.post_wizard_path:value"", ""default_value"": null, ""description"": ""Path on server where wizard can be found."", ""empty_concrete_fieldpath"": ""end_snippet.bbs_server_info.post_wizard_path:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""post_wizard_path:value"", ""presence"": ""optional"", ""short_label"": ""post_wizard_path"", ""typ"": ""string"" }, ""end_snippet.client_options.disable_disk_cache"": { ""abstract_fieldpath"": ""end_snippet.client_options.disable_disk_cache"", ""default_value"": null, ""description"": ""If true, no data will be cached on disk for this database. It will not be accessible offline."", ""empty_concrete_fieldpath"": ""end_snippet.client_options.disable_disk_cache"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": false }, ""name"": ""disable_disk_cache"", ""presence"": ""optional"", ""short_label"": ""disable_disk_cache"", ""typ"": ""bool"" }, ""end_snippet.cobrand_info.logo_url"": { ""abstract_fieldpath"": ""end_snippet.cobrand_info.logo_url"", ""default_value"": null, ""description"": ""URL of image to use as logo. Can be remote or local. However, using local URLs depends on the installation of the client and should be used carefully."", ""empty_concrete_fieldpath"": ""end_snippet.cobrand_info.[].logo_url"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""logo_url"", ""presence"": ""required"", ""short_label"": ""logo_url"", ""typ"": ""string"" }, ""end_snippet.cobrand_info.screen_size"": { ""abstract_fieldpath"": ""end_snippet.cobrand_info.screen_size"", ""default_value"": ""0.0"", ""description"": ""If specified and strictly positive but <= 1.0, makes logo scalable with screen by forcing its width to occupy a fixed fraction of the screeen. For instance, a value of .25 makes the given logo occupy 25% of the screen."", ""empty_concrete_fieldpath"": ""end_snippet.cobrand_info.[].screen_size"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""screen_size"", ""presence"": ""optional"", ""short_label"": ""screen_size"", ""typ"": ""double"" }, ""end_snippet.cobrand_info.tie_point"": { ""abstract_fieldpath"": ""end_snippet.cobrand_info.tie_point"", ""default_value"": ""BOTTOM_LEFT"", ""description"": ""Controls reference point in overlay."", ""empty_concrete_fieldpath"": ""end_snippet.cobrand_info.[].tie_point"", ""enum_vals"": { ""BOTTOM_CENTER"": 7, ""BOTTOM_LEFT"": 6, ""BOTTOM_RIGHT"": 8, ""MID_CENTER"": 4, ""MID_LEFT"": 3, ""MID_RIGHT"": 5, ""TOP_CENTER"": 1, ""TOP_LEFT"": 0, ""TOP_RIGHT"": 2 }, ""js_validation_rule"": { ""required"": true }, ""name"": ""tie_point"", ""presence"": ""optional"", ""short_label"": ""tie_point"", ""typ"": ""TiePoint"" }, ""end_snippet.cobrand_info.x_coord.is_relative"": { ""abstract_fieldpath"": ""end_snippet.cobrand_info.x_coord.is_relative"", ""default_value"": ""false"", ""description"": ""If true, the coordinate is relative to the screen."", ""empty_concrete_fieldpath"": ""end_snippet.cobrand_info.[].x_coord.is_relative"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": false }, ""name"": ""is_relative"", ""presence"": ""optional"", ""short_label"": ""is_relative"", ""typ"": ""bool"" }, ""end_snippet.cobrand_info.x_coord.value"": { ""abstract_fieldpath"": ""end_snippet.cobrand_info.x_coord.value"", ""default_value"": ""0.0"", ""description"": ""Coordinate value. Interpretation depends on is_relative (absolute or"", ""empty_concrete_fieldpath"": ""end_snippet.cobrand_info.[].x_coord.value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""value"", ""presence"": ""required"", ""short_label"": ""value"", ""typ"": ""double"" }, ""end_snippet.cobrand_info.y_coord.is_relative"": { ""abstract_fieldpath"": ""end_snippet.cobrand_info.y_coord.is_relative"", ""default_value"": ""false"", ""description"": ""If true, the coordinate is relative to the screen."", ""empty_concrete_fieldpath"": ""end_snippet.cobrand_info.[].y_coord.is_relative"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": false }, ""name"": ""is_relative"", ""presence"": ""optional"", ""short_label"": ""is_relative"", ""typ"": ""bool"" }, ""end_snippet.cobrand_info.y_coord.value"": { ""abstract_fieldpath"": ""end_snippet.cobrand_info.y_coord.value"", ""default_value"": ""0.0"", ""description"": ""Coordinate value. Interpretation depends on is_relative (absolute or"", ""empty_concrete_fieldpath"": ""end_snippet.cobrand_info.[].y_coord.value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""value"", ""presence"": ""required"", ""short_label"": ""value"", ""typ"": ""double"" }, ""end_snippet.default_web_page_intl_url:value"": { ""abstract_fieldpath"": ""end_snippet.default_web_page_intl_url:value"", ""default_value"": null, ""description"": ""Default location of web page."", ""empty_concrete_fieldpath"": ""end_snippet.default_web_page_intl_url:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""default_web_page_intl_url:value"", ""presence"": ""optional"", ""short_label"": ""default_web_page_intl_url"", ""typ"": ""string"" }, ""end_snippet.earth_intl_url:value"": { ""abstract_fieldpath"": ""end_snippet.earth_intl_url:value"", ""default_value"": null, ""description"": ""Location of international page for earth."", ""empty_concrete_fieldpath"": ""end_snippet.earth_intl_url:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""earth_intl_url:value"", ""presence"": ""optional"", ""short_label"": ""earth_intl_url"", ""typ"": ""string"" }, ""end_snippet.elevation_service_base_url"": { ""abstract_fieldpath"": ""end_snippet.elevation_service_base_url"", ""default_value"": """", ""description"": ""Terrain elevation service URL. If empty, service will be unavailable."", ""empty_concrete_fieldpath"": ""end_snippet.elevation_service_base_url"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""elevation_service_base_url"", ""presence"": ""optional"", ""short_label"": ""elevation_service_base_url"", ""typ"": ""string"" }, ""end_snippet.hide_user_data"": { ""abstract_fieldpath"": ""end_snippet.hide_user_data"", ""default_value"": ""false"", ""description"": ""If true, hides user license key in about dialog. Useful for Pro only, allows information to not be visible for shared license keys."", ""empty_concrete_fieldpath"": ""end_snippet.hide_user_data"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": false }, ""name"": ""hide_user_data"", ""presence"": ""optional"", ""short_label"": ""hide_user_data"", ""typ"": ""bool"" }, ""end_snippet.keyboard_shortcuts_url:value"": { ""abstract_fieldpath"": ""end_snippet.keyboard_shortcuts_url:value"", ""default_value"": null, ""description"": ""URL for keyboard shortcuts page. If not specified, this URL is built from user_guide_intl_url as user_guide_intl_url + \""ug_keyboard.html\""."", ""empty_concrete_fieldpath"": ""end_snippet.keyboard_shortcuts_url:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""keyboard_shortcuts_url:value"", ""presence"": ""optional"", ""short_label"": ""keyboard_shortcuts_url"", ""typ"": ""string"" }, ""end_snippet.model.compressed_negative_altitude_threshold"": { ""abstract_fieldpath"": ""end_snippet.model.compressed_negative_altitude_threshold"", ""default_value"": null, ""description"": ""Threshold below which negative altitudes are compressed"", ""empty_concrete_fieldpath"": ""end_snippet.model.compressed_negative_altitude_threshold"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""compressed_negative_altitude_threshold"", ""presence"": ""optional"", ""short_label"": ""compressed_negative_altitude_threshold"", ""typ"": ""double"" }, ""end_snippet.model.elevation_bias"": { ""abstract_fieldpath"": ""end_snippet.model.elevation_bias"", ""default_value"": null, ""description"": ""Elevation bias"", ""empty_concrete_fieldpath"": ""end_snippet.model.elevation_bias"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""elevation_bias"", ""presence"": ""optional"", ""short_label"": ""elevation_bias"", ""typ"": ""double"" }, ""end_snippet.model.flattening"": { ""abstract_fieldpath"": ""end_snippet.model.flattening"", ""default_value"": ""0.00335281066474748"", ""description"": ""Planet flattening. Default value is 1.0/298.257223563 (from WGS84)."", ""empty_concrete_fieldpath"": ""end_snippet.model.flattening"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""flattening"", ""presence"": ""optional"", ""short_label"": ""flattening"", ""typ"": ""double"" }, ""end_snippet.model.negative_altitude_exponent_bias"": { ""abstract_fieldpath"": ""end_snippet.model.negative_altitude_exponent_bias"", ""default_value"": null, ""description"": ""Bias for negative altitude so that ocean tiles can be streamed to older clients"", ""empty_concrete_fieldpath"": ""end_snippet.model.negative_altitude_exponent_bias"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""negative_altitude_exponent_bias"", ""presence"": ""optional"", ""short_label"": ""negative_altitude_exponent_bias"", ""typ"": ""int32"" }, ""end_snippet.model.radius"": { ""abstract_fieldpath"": ""end_snippet.model.radius"", ""default_value"": ""6378.13700"", ""description"": ""Mean planet radius. Default value is the WGS84 model for earth."", ""empty_concrete_fieldpath"": ""end_snippet.model.radius"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""radius"", ""presence"": ""optional"", ""short_label"": ""radius"", ""typ"": ""double"" }, ""end_snippet.privacy_policy_url:value"": { ""abstract_fieldpath"": ""end_snippet.privacy_policy_url:value"", ""default_value"": null, ""description"": ""URL for the privacy policy."", ""empty_concrete_fieldpath"": ""end_snippet.privacy_policy_url:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""privacy_policy_url:value"", ""presence"": ""optional"", ""short_label"": ""privacy_policy_url"", ""typ"": ""string"" }, ""end_snippet.release_notes_url:value"": { ""abstract_fieldpath"": ""end_snippet.release_notes_url:value"", ""default_value"": null, ""description"": ""URL for release notes page."", ""empty_concrete_fieldpath"": ""end_snippet.release_notes_url:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""release_notes_url:value"", ""presence"": ""optional"", ""short_label"": ""release_notes_url"", ""typ"": ""string"" }, ""end_snippet.reverse_geocoder_protocol_version"": { ""abstract_fieldpath"": ""end_snippet.reverse_geocoder_protocol_version"", ""default_value"": ""3"", ""description"": ""Reverse geocoder protocol version. Default is 3 which is the protocol supported by newer clients."", ""empty_concrete_fieldpath"": ""end_snippet.reverse_geocoder_protocol_version"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""reverse_geocoder_protocol_version"", ""presence"": ""optional"", ""short_label"": ""reverse_geocoder_protocol_version"", ""typ"": ""int32"" }, ""end_snippet.reverse_geocoder_url:value"": { ""abstract_fieldpath"": ""end_snippet.reverse_geocoder_url:value"", ""default_value"": null, ""description"": ""Reverse geocoder server URL"", ""empty_concrete_fieldpath"": ""end_snippet.reverse_geocoder_url:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""reverse_geocoder_url:value"", ""presence"": ""optional"", ""short_label"": ""reverse_geocoder_url"", ""typ"": ""string"" }, ""end_snippet.show_signin_button"": { ""abstract_fieldpath"": ""end_snippet.show_signin_button"", ""default_value"": null, ""description"": ""If true, shows the signin button in the upper right corner."", ""empty_concrete_fieldpath"": ""end_snippet.show_signin_button"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": false }, ""name"": ""show_signin_button"", ""presence"": ""optional"", ""short_label"": ""show_signin_button"", ""typ"": ""bool"" }, ""end_snippet.startup_tips_intl_url:value"": { ""abstract_fieldpath"": ""end_snippet.startup_tips_intl_url:value"", ""default_value"": null, ""description"": ""URL from which to load startup tips in Earth 7.0 and higher."", ""empty_concrete_fieldpath"": ""end_snippet.startup_tips_intl_url:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""startup_tips_intl_url:value"", ""presence"": ""optional"", ""short_label"": ""startup_tips_intl_url"", ""typ"": ""string"" }, ""end_snippet.support_answer_intl_url:value"": { ""abstract_fieldpath"": ""end_snippet.support_answer_intl_url:value"", ""default_value"": null, ""description"": ""Url to support answer."", ""empty_concrete_fieldpath"": ""end_snippet.support_answer_intl_url:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""support_answer_intl_url:value"", ""presence"": ""optional"", ""short_label"": ""support_answer_intl_url"", ""typ"": ""string"" }, ""end_snippet.support_center_intl_url:value"": { ""abstract_fieldpath"": ""end_snippet.support_center_intl_url:value"", ""default_value"": null, ""description"": ""Url to support center."", ""empty_concrete_fieldpath"": ""end_snippet.support_center_intl_url:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""support_center_intl_url:value"", ""presence"": ""optional"", ""short_label"": ""support_center_intl_url"", ""typ"": ""string"" }, ""end_snippet.support_request_intl_url:value"": { ""abstract_fieldpath"": ""end_snippet.support_request_intl_url:value"", ""default_value"": null, ""description"": ""Url to support pages."", ""empty_concrete_fieldpath"": ""end_snippet.support_request_intl_url:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""support_request_intl_url:value"", ""presence"": ""optional"", ""short_label"": ""support_request_intl_url"", ""typ"": ""string"" }, ""end_snippet.support_topic_intl_url:value"": { ""abstract_fieldpath"": ""end_snippet.support_topic_intl_url:value"", ""default_value"": null, ""description"": ""Url to support topics used by certain diagnostic messages."", ""empty_concrete_fieldpath"": ""end_snippet.support_topic_intl_url:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""support_topic_intl_url:value"", ""presence"": ""optional"", ""short_label"": ""support_topic_intl_url"", ""typ"": ""string"" }, ""end_snippet.swoop_parameters.start_dist_in_meters"": { ""abstract_fieldpath"": ""end_snippet.swoop_parameters.start_dist_in_meters"", ""default_value"": null, ""description"": ""Controls how far from a target swooping should start."", ""empty_concrete_fieldpath"": ""end_snippet.swoop_parameters.start_dist_in_meters"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""start_dist_in_meters"", ""presence"": ""optional"", ""short_label"": ""start_dist_in_meters"", ""typ"": ""double"" }, ""end_snippet.tutorial_url:value"": { ""abstract_fieldpath"": ""end_snippet.tutorial_url:value"", ""default_value"": null, ""description"": ""URL for tutorial page. If not specified, this URL is built from user_guide_intl_url as user_guide_intl_url + \""tutorials/index.html\""."", ""empty_concrete_fieldpath"": ""end_snippet.tutorial_url:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""tutorial_url:value"", ""presence"": ""optional"", ""short_label"": ""tutorial_url"", ""typ"": ""string"" }, ""end_snippet.use_ge_logo"": { ""abstract_fieldpath"": ""end_snippet.use_ge_logo"", ""default_value"": ""true"", ""description"": ""If false, hides the Google logo."", ""empty_concrete_fieldpath"": ""end_snippet.use_ge_logo"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": false }, ""name"": ""use_ge_logo"", ""presence"": ""optional"", ""short_label"": ""use_ge_logo"", ""typ"": ""bool"" }, ""end_snippet.user_guide_intl_url:value"": { ""abstract_fieldpath"": ""end_snippet.user_guide_intl_url:value"", ""default_value"": null, ""description"": ""Url to user guide."", ""empty_concrete_fieldpath"": ""end_snippet.user_guide_intl_url:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""user_guide_intl_url:value"", ""presence"": ""optional"", ""short_label"": ""user_guide_intl_url"", ""typ"": ""string"" }, ""end_snippet.valid_database.database_name:value"": { ""abstract_fieldpath"": ""end_snippet.valid_database.database_name:value"", ""default_value"": null, ""description"": ""Human-readable name of database (such as \""Primary Database\"" or \""Digital Globe Database\"")"", ""empty_concrete_fieldpath"": ""end_snippet.valid_database.[].database_name:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""database_name:value"", ""presence"": ""optional"", ""short_label"": ""database_name"", ""typ"": ""string"" }, ""end_snippet.valid_database.database_url"": { ""abstract_fieldpath"": ""end_snippet.valid_database.database_url"", ""default_value"": null, ""description"": ""URL of server. This can include a path and query, and must be a well-formed, absolute URL."", ""empty_concrete_fieldpath"": ""end_snippet.valid_database.[].database_url"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""database_url"", ""presence"": ""required"", ""short_label"": ""database_url"", ""typ"": ""string"" }, ""end_snippet.search_config.error_page_url:value"": { ""abstract_fieldpath"": ""end_snippet.search_config.error_page_url:value"", ""default_value"": ""about:blank"", ""description"": ""URL of a page that will be displayed if a network error or other local error occurs while performing a search. This might be an error for a local geocode while in offline mode, a connection error while trying to connect to MFE, or some other error where we can't get an error message from the server. (Obviously this page should be cached locally, or it's not terribly useful.) The URL should be fully encoded, and can use $[hl] and friends if necessary."", ""empty_concrete_fieldpath"": ""end_snippet.search_config.error_page_url:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""error_page_url:value"", ""presence"": ""optional"", ""short_label"": ""error_page_url"", ""typ"": ""string"" }, ""end_snippet.search_config.kml_render_url:value"": { ""abstract_fieldpath"": ""end_snippet.search_config.kml_render_url:value"", ""default_value"": ""/earth/client/kmlrender/index_$[hl].html"", ""description"": ""URL of a page that will be shown when KML is rendered in the search panel. This page should have JavaScript that reads the KML from the environment and renders it as HTML, but should NOT perform onebox or searchlet searches. The URL should be fully encoded, and can use $[hl] and friends if necessary."", ""empty_concrete_fieldpath"": ""end_snippet.search_config.kml_render_url:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""kml_render_url:value"", ""presence"": ""optional"", ""short_label"": ""kml_render_url"", ""typ"": ""string"" }, ""end_snippet.search_config.kml_search_url:value"": { ""abstract_fieldpath"": ""end_snippet.search_config.kml_search_url:value"", ""default_value"": ""/earth/client/kmlrender/index_$[hl].html"", ""description"": ""URL of a page that will be shown when a KML search is performed. This page should have JavaScript that reads the KML from the environment and renders it as HTML, and also performs onebox and searchlet searches if applicable. The URL should be fully encoded, and can use $[hl] and friends if necessary."", ""empty_concrete_fieldpath"": ""end_snippet.search_config.kml_search_url:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""kml_search_url:value"", ""presence"": ""optional"", ""short_label"": ""kml_search_url"", ""typ"": ""string"" }, ""end_snippet.search_config.search_history_url:value"": { ""abstract_fieldpath"": ""end_snippet.search_config.search_history_url:value"", ""default_value"": ""http://www.google.com/earth/client/search/history_$[hl].html"", ""description"": ""URL of a page that will be shown when the search history is requested. This page should have JavaScript that reads the search history from the client and renders it as HTML."", ""empty_concrete_fieldpath"": ""end_snippet.search_config.search_history_url:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""search_history_url:value"", ""presence"": ""optional"", ""short_label"": ""search_history_url"", ""typ"": ""string"" }, ""end_snippet.google_maps_url:value"": { ""abstract_fieldpath"": ""end_snippet.google_maps_url:value"", ""default_value"": """", ""description"": ""URL for Google Maps, for features like 'View in Maps'."", ""empty_concrete_fieldpath"": ""end_snippet.google_maps_url:value"", ""enum_vals"": null, ""js_validation_rule"": { ""required"": true }, ""name"": ""google_maps_url:value"", ""presence"": ""optional"", ""short_label"": ""google_maps_url"", ""typ"": ""string"" } } """""" ",1 "mpliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an ""AS IS"" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # import pytest import numpy as np from test.zoo.pipeline.utils.test_utils import ZooTestCase from zoo.chronos.detector.anomaly.ae_detector import AEDetector class TestAEDetector(ZooTestCase): def setup_method(self, method): pass def teardown_method(self, method): pass def create_data(self): cycles = 10 time = np.arange(0, cycles * np.pi, 0.01) data = np.sin(time) data[600:800] = 10 return data def test_ae_fit_score_rolled_keras(self): y = self.create_data() ad = AEDetector(roll_len=314) ad.fit(y) anomaly_scores = ad.score() assert len(anomaly_scores) == len(y) anomaly_indexes = ad.anomaly_indexes() assert len(anomaly_indexes) == int(ad.ratio * len(y)) def test_ae_fit_score_rolled_pytorch(self): y = self.create_data() ad = AEDetector(roll_len=314, backend=""torch"") ad.fit(y) anomaly_scores = ad.score() assert len(anomaly_scores) == len(y) anomaly_indexes = ad.anomaly_indexes() assert len(anomaly_indexes) == int(ad.ratio * len(y)) def test_ae_fit_score_unrolled(self): y = self.create_data() ad = AEDetector(roll_len=0) ad.fit(y) anomaly_scores = ad.score() assert len(anomaly_scores) == len(y) anomaly_indexes = ad.anomaly_indexes() assert len(anomaly_indexes) == int(ad.ratio * len(y)) def test_corner_cases(self): y = self.create_data() ad = AEDetector(roll_len=314, backend=""dummy"") with pytest.raises(ValueError): ad.fit(y) ad = AEDetector(roll_len=314) with pytest.raises(RuntimeError): ad.score() y = np.array([1]) with pytest.raises(ValueError): ad.fit(y) y = self.create_data() y = y.reshape(2, -1) with pytest.raises(ValueError): ad.fit(y) ",1 "State from direct.fsm import State from direct.task import Task import random from toontown.toonbase import ToontownGlobals from toontown.toonbase import TTLocalizer import CharStateDatasAI class DistributedGoofySpeedwayAI(DistributedCCharBaseAI.DistributedCCharBaseAI): notify = DirectNotifyGlobal.directNotify.newCategory('DistributedGoofySpeedwayAI') def __init__(self, air): DistributedCCharBaseAI.DistributedCCharBaseAI.__init__(self, air, TTLocalizer.Goofy) self.fsm = ClassicFSM.ClassicFSM('DistributedGoofySpeedwayAI', [State.State('Off', self.enterOff, self.exitOff, ['Lonely', 'TransitionToCostume', 'Walk']), State.State('Lonely', self.enterLonely, self.exitLonely, ['Chatty', 'Walk', 'TransitionToCostume']), State.State('Chatty', self.enterChatty, self.exitChatty, ['Lonely', 'Walk', 'TransitionToCostume']), State.State('Walk', self.enterWalk, self.exitWalk, ['Lonely', 'Chatty', 'TransitionToCostume']), State.State('TransitionToCostume', self.enterTransitionToCostume, self.exitTransitionToCostume, ['Off'])], 'Off', 'Off') self.fsm.enterInitialState() self.handleHolidays() def delete(self): self.fsm.requestFinalState() DistributedCCharBaseAI.DistributedCCharBaseAI.delete(self) self.lonelyDoneEvent = None self.lonely = None self.chattyDoneEvent = None self.chatty = None self.walkDoneEvent = None self.walk = None return def generate(self): DistributedCCharBaseAI.DistributedCCharBaseAI.generate(self) name = self.getName() self.lonelyDoneEvent = self.taskName(name + '-lonely-done') self.lonely = CharStateDatasAI.CharLonelyStateAI(self.lonelyDoneEvent, self) self.chattyDoneEvent = self.taskName(name + '-chatty-done') self.chatty = CharStateDatasAI.CharChattyStateAI(self.chattyDoneEvent, self) self.walkDoneEvent = self.taskName(name + '-walk-done') if self.diffPath == None: self.walk = CharStateDatasAI.CharWalkStateAI(self.walkDoneEvent, self) else: self.walk = CharStateDatasAI.CharWalkStateAI(self.walkDoneEvent, self, self.diffPath) return def walkSpeed(self): return ToontownGlobals.GoofySpeed def start(self): self.fsm.request('Lonely') def __decideNextState(self, doneStatus): if self.transitionToCostume == 1: curWalkNode = self.walk.getDestNode() if simbase.air.holidayManager: if ToontownGlobals.HALLOWEEN_COSTUMES in simbase.air.holidayManager.currentHolidays and simbase.air.holidayManager.currentHolidays[ToontownGlobals.HALLOWEEN_COSTUMES]: simbase.air.holidayManager.currentHolidays[ToontownGlobals.HALLOWEEN_COSTUMES].triggerSwitch(curWalkNode, self) self.fsm.request('TransitionToCostume') elif ToontownGlobals.APRIL_FOOLS_COSTUMES in simbase.air.holidayManager.currentHolidays and simbase.air.holidayManager.currentHolidays[ToontownGlobals.APRIL_FOOLS_COSTUMES]: simbase.air.holidayManager.currentHolidays[ToontownGlobals.APRIL_FOOLS_COSTUMES].triggerSwitch(curWalkNode, self) self.fsm.request('TransitionToCostume') else: self.notify.warning('transitionToCostume == 1 but no costume holiday') else: self.notify.warning('transitionToCostume == 1 but no holiday Manager') if doneStatus['state'] == 'lonely' and doneStatus['status'] == 'done': self.fsm.request('Walk') elif doneStatus['state'] == 'chatty' and doneStatus['status'] == 'done': self.fsm.request('Walk') elif doneStatus['state'] == 'walk' and doneStatus['status'] == 'done': if len(self.nearbyAvatars) > 0: self.fsm.request('Chatty') else: self.fsm.request('Lonely') def enterOff(self): pass def exitOff(self): DistributedCCharBaseAI.DistributedCCharBaseAI.exitOff(self) def enterLonely(self): self.lonely.enter() self.acceptOnce(self.lonelyDoneEvent, self.__decideNextState) def exitLonely(self): self.ignore(self.lonelyDoneEvent) self.lonely.exit() def __goForAWalk(self, task): self.notify.debug('going for a walk') self.fsm.request('Walk') return Task.done def enterChatty(self): self.chatty.enter() self.acceptOnce(self.chattyDoneEvent, self.__decideNextState) def exitChatty(self): self.ignore(self.chattyDoneEvent) self.chatty.exit() def enterWalk(self): self.notify.debug('going for a walk') self.walk.enter() self.acceptOnce(self.walkDoneEvent, self.__decideNextState) def exitWalk(self): self.ignore(self.walkDoneEvent) self.walk.exit() def avatarEnterNextState(self): if len(self.nearbyAvatars) == 1: if self.fsm.getCurrentState().getName() != 'Walk': self.fsm.request('Chatty') else: self.notify.debug('avatarEnterNextState: in walk state') else: self.notify.debug('avatarEnterNextState: num avatars: ' + str(len(self.nearbyAvatars))) def avatarExitNextState(self): if len(self.nearbyAvatars) == 0: if self.fsm.getCurrentState().getName() != 'Walk': self.fsm.request('Lonely') def handleHolidays(self): DistributedCCharBaseAI.DistributedCCharBaseAI.handleHolidays(self) if hasattr(simbase.air, 'holidayManager'): if ToontownGlobals.APRIL_FOOLS_COSTUMES in simbase.air.holidayManager.currentHolidays: if simbase.air.holidayManager.currentHolidays[ToontownGlobals.APRIL_FOOLS_COSTUMES] != None and simbase.air.holidayManager.currentHolidays[ToontownGlobals.APRIL_FOOLS_COSTUMES].getRunningState(): self.diffPath = TTLocalizer.Donald return def getCCLocation(self): if self.diffPath == None: return 1 else: return 0 return def enterTransitionToCostume(self): pass def exitTransitionToCostume(self): pass ",1 "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. # """"""add tenant_id to lcm_subscriptions and lcm_op_occs Revision ID: d6ae359ab0d6 Revises: 3ff50553e9d3 Create Date: 2022-01-06 13:35:53.868106 """""" from alembic import op import sqlalchemy as sa # revision identifiers, used by Alembic. revision = 'd6ae359ab0d6' down_revision = '3ff50553e9d3' def upgrade(active_plugins=None, options=None): op.add_column('vnf_lcm_subscriptions', sa.Column('tenant_id', sa.String(length=64), nullable=False)) op.add_column('vnf_lcm_op_occs', sa.Column('tenant_id', sa.String(length=64), nullable=False)) ",1 "pacal.distr import sqrt as distr_sqrt class NoncentralTDistr(DivDistr): def __init__(self, df = 2, mu = 0): d1 = NormalDistr(mu, 1) d2 = distr_sqrt(ChiSquareDistr(df) / df) super(NoncentralTDistr, self).__init__(d1, d2) self.df = df self.mu = mu def __str__(self): return ""NoncentralTDistr(df={0},mu={1})#{2}"".format(self.df, self.mu, self.id()) def getName(self): return ""NoncT({0},{1})"".format(self.df, self.mu) class NoncentralChiSquareDistr(SumDistr): def __new__(cls, df, lmbda = 0): assert df >= 1 d1 = NormalDistr(sqrt(lmbda))**2 if df == 1: return d1 d2 = ChiSquareDistr(df - 1) ncc2 = super(NoncentralChiSquareDistr, cls).__new__(cls, d1, d2) super(NoncentralChiSquareDistr, ncc2).__init__(d1, d2) ncc2.df = df ncc2.lmbda = lmbda return ncc2 def __init__(self, df, lmbda = 0): pass def __str__(self): return ""NoncentralChiSquare(df={0},lambda={1})#{2}"".format(self.df, self.lmbda, self.id()) def getName(self): return ""NoncChi2({0},{1})"".format(self.df, self.lmbda) class NoncentralBetaDistr(InvDistr): def __init__(self, alpha = 1, beta = 1, lmbda = 0): d = 1 + ChiSquareDistr(2.0 * beta) / NoncentralChiSquareDistr(2 * alpha, lmbda) super(NoncentralBetaDistr, self).__init__(d) self.alpha = alpha self.beta = beta self.lmbda = lmbda def __str__(self): return ""NoncentralBetaDistr(alpha={0},beta={1},lambda={2})#{3}"".format(self.alpha, self.beta, self.lmbda, self.id()) def getName(self): return ""NoncBeta({0},{1},{2})"".format(self.alpha, self.beta, self.lmbda) class NoncentralFDistr(DivDistr): def __init__(self, df1 = 1, df2 = 1, lmbda = 0): d1 = NoncentralChiSquareDistr(df1, lmbda) / df1 d2 = ChiSquareDistr(df2) / df2 super(NoncentralFDistr, self).__init__(d1, d2) self.df1 = df1 self.df2 = df2 self.lmbda = lmbda def __str__(self): return ""NoncentralFDistr(df1={0},df2={1},lambda={2})#{3}"".format(self.df1, self.df2, self.lmbda, self.id()) def getName(self): return ""NoncF({0},{1},{2})"".format(self.df1, self.df2, self.lmbda) ",1 "license__ = 'BSD' import io, subprocess, wave, shutil import math, audioop, collections import json, urllib.request #wip: filter out clicks and other too short parts class AudioSource(object): def __init__(self): raise NotImplementedError(""this is an abstract class"") def __enter__(self): raise NotImplementedError(""this is an abstract class"") def __exit__(self, exc_type, exc_value, traceback): raise NotImplementedError(""this is an abstract class"") try: import pyaudio class Microphone(AudioSource): def __init__(self, device_index = None): self.device_index = device_index self.format = pyaudio.paInt16 # 16-bit int sampling self.SAMPLE_WIDTH = pyaudio.get_sample_size(self.format) self.RATE = 16000 # sampling rate in Hertz self.CHANNELS = 1 # mono audio self.CHUNK = 1024 # number of frames stored in each buffer self.audio = None self.stream = None def __enter__(self): self.audio = pyaudio.PyAudio() self.stream = self.audio.open( input_device_index = self.device_index, format = self.format, rate = self.RATE, channels = self.CHANNELS, frames_per_buffer = self.CHUNK, input = True, # stream is an input stream ) return self def __exit__(self, exc_type, exc_value, traceback): self.stream.stop_stream() self.stream.close() self.stream = None self.audio.terminate() except ImportError: pass class WavFile(AudioSource): def __init__(self, filename_or_fileobject): if isinstance(filename_or_fileobject, str): self.filename = filename_or_fileobject else: self.filename = None self.wav_file = filename_or_fileobject self.stream = None def __enter__(self): if self.filename: self.wav_file = open(self.filename, ""rb"") self.wav_reader = wave.open(self.wav_file, ""rb"") self.SAMPLE_WIDTH = self.wav_reader.getsampwidth() self.RATE = self.wav_reader.getframerate() self.CHANNELS = self.wav_reader.getnchannels() assert self.CHANNELS == 1 # audio must be mono self.CHUNK = 4096 self.stream = WavFile.WavStream(self.wav_reader) return self def __exit__(self, exc_type, exc_value, traceback): if self.filename: self.wav_file.close() self.stream = None class WavStream(object): def __init__(self, wav_reader): self.wav_reader = wav_reader def read(self, size = -1): if size == -1: return self.wav_reader.readframes(self.wav_reader.getnframes()) return self.wav_reader.readframes(size) class AudioData(object): def __init__(self, rate, data): self.rate = rate self.data = data class Recognizer(AudioSource): def __init__(self, language = ""fr-FR"", key = ""AIzaSyBOti4mM-6x9WDnZIjIeyEU21OpBXqWBgw""): self.key = key self.language = language self.energy_threshold = 1500 # minimum audio energy to consider for recording self.pause_threshold = 0.8 # seconds of quiet time before a phrase is considered complete self.quiet_duration = 0.5 # amount of quiet time to keep on both sides of the recording def samples_to_flac(self, source, frame_data): import platform, os with io.BytesIO() as wav_file: with wave.open(wav_file, ""wb"") as wav_writer: wav_writer.setsampwidth(source.SAMPLE_WIDTH) wav_writer.setnchannels(source.CHANNELS) wav_writer.setframerate(source.RATE) wav_writer.writeframes(frame_data) wav_data = wav_file.getvalue() # determine which converter executable to use system = platform.system() path = os.path.dirname(os.path.abspath(__file__)) # directory of the current module file, where all the FLAC bundled binaries are stored if shutil.which(""flac"") is not None: # check for installed version first flac_converter = shutil.which(""flac"") elif system == ""Windows"" and platform.machine() in {""i386"", ""x86"", ""x86_64"", ""AMD64""}: # Windows NT, use the bundled FLAC conversion utility flac_converter = os.path.join(path, ""flac-win32.exe"") elif system == ""Linux"" and platform.machine() in {""i386"", ""x86"", ""x86_64"", ""AMD64""}: flac_converter = os.path.join(path, ""flac-linux-i386"") else: raise ChildProcessError(""FLAC conversion utility not available - consider installing the FLAC utility"") process = subprocess.Popen(""\""%s\"" --stdout --totally-silent --best -"" % flac_converter, stdin=subprocess.PIPE, stdout=subprocess.PIPE, shell=True) flac_data, stderr = process.communicate(wav_data) return flac_data def record(self, source, duration = None): assert isinstance(source, AudioSource) and source.stream frames = io.BytesIO() seconds_per_buffer = source.CHUNK / source.RATE elapsed_time = 0 while True: # loop for the total number of chunks needed elapsed_time += seconds_per_buffer if duration and elapsed_time > duration: break buffer = source.stream.read(source.CHUNK) if len(buffer) == 0: break frames.write(buffer) frame_data = frames.getvalue() frames.close() return AudioData(source.RATE, self.samples_to_flac(source, frame_data)) def listen(self, source, timeout = None): assert isinstance(source, AudioSource) and source.stream # record audio data as raw samples frames = collections.deque() assert self.pause_threshold >= self.quiet_duration >= 0 seconds_per_buffer = source.CHUNK / source.RATE pause_buffer_count = math.ceil(self.pause_threshold / seconds_per_buffer) # number of buffers of quiet audio before the phrase is complete quiet_buffer_count = math.ceil(self.quiet_duration / seconds_per_buffer) # maximum number of buffers of quiet audio to retain before and after elapsed_time = 0 # store audio input until the phrase starts while True: # handle timeout if specified elapsed_time += seconds_per_buffer if timeout and elapsed_time > timeout: raise TimeoutError(""listening timed out"") buffer = source.stream.read(source.CHUNK) if len(buffer) == 0: break # reached end of the stream frames.append(buffer) # check if the audio input has stopped being quiet energy = audioop.rms(buffer, source.SAMPLE_WIDTH) # energy of the audio signal if energy > self.energy_threshold: break if len(frames) > quiet_buffer_count: # ensure we only keep the needed amount of quiet buffers frames.popleft() # read audio input until the phrase ends pause_count = 0 while True: buffer = source.stream.read(source.CHUNK) if len(buffer) == 0: break # reached end of the stream frames.append(buffer) # check if the audio input has gone quiet for longer than the pause threshold energy = audioop.rms(buffer, source.SAMPLE_WIDTH) # energy of the audio signal if energy > self.energy_threshold: pause_count = 0 else: pause_count += 1 if pause_count > pause_buffer_count: # end of the phrase break # obtain frame data for i in range(quiet_buffer_count, pause_buffer_count): frames.pop() # remove extra quiet frames at the end frame_data = b"""".join(list(frames)) return AudioData(source.RATE, self.samples_to_flac(source, frame_data)) def recognize(self, audio_data, show_all = False): assert isinstance(audio_data, AudioData) url = ""http://www.google.com/speech-api/v2/recognize?client=chromium&lang=%s&key=%s"" % (self.language, self.key) self.request = urllib.request.Request(url, data = audio_data.data, headers = {""Content-Type"": ""audio/x-flac; rate=%s"" % audio_data.rate}) # check for invalid key response from the server try: response = urllib.request.urlopen(self.request) except: raise KeyError(""Server wouldn't respond (invalid key or quota has been maxed out)"") response_text = response.read().decode(""utf-8"") # ignore any blank blocks actual_result = [] for line in response_text.split(""\n""): if not line: continue result = json.loads(line)[""result""] if len(result) != 0: actual_result = result[0] # make sure we have a list of transcriptions if ""alternative"" not in actual_result: raise LookupError(""Speech is unintelligible"") # return the best guess unless told to do otherwise if not show_all: for prediction in actual_result[""alternative""]: if ""confidence"" in prediction: return prediction[""transcript""] raise LookupError(""Speech is unintelligible"") spoken_text = [] # check to see if Google thinks it's 100% correct default_confidence = 0 if len(actual_result[""alternative""])==1: default_confidence = 1 # return all the possibilities for prediction in actual_result[""alternative""]: if ""confidence"" in prediction: spoken_text.append({""text"":prediction[""transcript""],""confidence"":prediction[""confidence""]}) else: spoken_text.append({""text"":prediction[""transcript""],""confidence"":default_confidence}) return spoken_text if __name__ == ""__main__"": r = Recognizer() m = Microphone() while True: print(""Say something!"") with m as source: audio = r.listen(source) print(""Got it! Now to recognize it..."") try: print(""You said "" + r.recognize(audio)) except LookupError: print(""Oops! Didn't catch that"") ",1 "__ import absolute_import, division, print_function __metaclass__ = type ANSIBLE_METADATA = {'metadata_version': '1.1', 'status': ['preview'], 'supported_by': 'community'} DOCUMENTATION = r''' --- module: aci_tenant_span_dst_group short_description: Manage SPAN destination groups (span:DestGrp) description: - Manage SPAN destination groups on Cisco ACI fabrics. notes: - The C(tenant) used must exist before using this module in your playbook. The M(aci_tenant) module can be used for this. - More information about the internal APIC class B(span:DestGrp) from L(the APIC Management Information Model reference,https://developer.cisco.com/docs/apic-mim-ref/). author: - Dag Wieers (@dagwieers) version_added: '2.4' options: dst_group: description: - The name of the SPAN destination group. required: yes aliases: [ name ] description: description: - The description of the SPAN destination group. aliases: [ descr ] tenant: description: - The name of the tenant. required: yes aliases: [ tenant_name ] state: description: - Use C(present) or C(absent) for adding or removing. - Use C(query) for listing an object or multiple objects. choices: [ absent, present, query ] default: present extends_documentation_fragment: aci ''' # FIXME: Add more, better examples EXAMPLES = r''' - aci_tenant_span_dst_group: host: apic username: admin password: SomeSecretPassword dst_group: '{{ dst_group }}' description: '{{ descr }}' tenant: '{{ tenant }}' ''' RETURN = r''' current: description: The existing configuration from the APIC after the module has finished returned: success type: list sample: [ { ""fvTenant"": { ""attributes"": { ""descr"": ""Production environment"", ""dn"": ""uni/tn-production"", ""name"": ""production"", ""nameAlias"": """", ""ownerKey"": """", ""ownerTag"": """" } } } ] error: description: The error information as returned from the APIC returned: failure type: dict sample: { ""code"": ""122"", ""text"": ""unknown managed object class foo"" } raw: description: The raw output returned by the APIC REST API (xml or json) returned: parse error type: string sample: '
"") text = text.replace(""\t"", "" "" * 8) text = re.sub(""(?i)"", """", text) if ""\"""" in text: text = ""\"""" + text.replace(""\"""", ""\""\"""") + ""\"""" return text def cardIds(self): if not self.did: cids = self.col.db.list(""select id from cards"") else: cids = self.col.decks.cids(self.did, children=True) self.count = len(cids) return cids # Cards as TSV ###################################################################### class TextCardExporter(Exporter): key = _(""Cards in Plain Text"") ext = "".txt"" hideTags = True def __init__(self, col): Exporter.__init__(self, col) def doExport(self, file): ids = sorted(self.cardIds()) # strids = ids2str(ids) def esc(s): # strip off the repeated question in answer if exists s = re.sub(""(?si)^.*
\n*"", """", s) return self.escapeText(s) out = """" for cid in ids: c = self.col.getCard(cid) out += esc(c.q()) out += ""\t"" + esc(c.a()) + ""\n"" file.write(out.encode(""utf-8"")) # Notes as TSV ###################################################################### class TextNoteExporter(Exporter): key = _(""Notes in Plain Text"") ext = "".txt"" def __init__(self, col): Exporter.__init__(self, col) self.includeID = False self.includeTags = True def doExport(self, file): cardIds = self.cardIds() data = [] for id, flds, tags in self.col.db.execute("""""" select guid, flds, tags from notes where id in (select nid from cards where cards.id in %s)"""""" % ids2str(cardIds)): row = [] # note id if self.includeID: row.append(str(id)) # fields row.extend([self.escapeText(f) for f in splitFields(flds)]) # tags if self.includeTags: row.append(tags.strip()) data.append(""\t"".join(row)) self.count = len(data) out = ""\n"".join(data) file.write(out.encode(""utf-8"")) # Anki decks ###################################################################### # media files are stored in self.mediaFiles, but not exported. class AnkiExporter(Exporter): key = _(""Anki 2.0 Deck"") ext = "".anki2"" def __init__(self, col): Exporter.__init__(self, col) self.includeSched = False self.includeMedia = True def exportInto(self, path): # create a new collection at the target try: os.unlink(path) except (IOError, OSError): pass self.dst = Collection(path) self.src = self.col # find cards if not self.did: cids = self.src.db.list(""select id from cards"") else: cids = self.src.decks.cids(self.did, children=True) # copy cards, noting used nids nids = {} data = [] for row in self.src.db.execute( ""select * from cards where id in "" + ids2str(cids)): nids[row[1]] = True data.append(row) self.dst.db.executemany( ""insert into cards values (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)"", data) # notes strnids = ids2str(list(nids.keys())) notedata = [] for row in self.src.db.all( ""select * from notes where id in ""+strnids): # remove system tags if not exporting scheduling info if not self.includeSched: row = list(row) row[5] = self.removeSystemTags(row[5]) notedata.append(row) self.dst.db.executemany( ""insert into notes values (?,?,?,?,?,?,?,?,?,?,?)"", notedata) # models used by the notes mids = self.dst.db.list( ""select distinct mid from notes where id in "" + strnids) # card history and revlog if self.includeSched: data = self.src.db.all( ""select * from revlog where cid in "" + ids2str(cids)) self.dst.db.executemany( ""insert into revlog values (?,?,?,?,?,?,?,?,?)"", data) else: # need to reset card state self.dst.sched.resetCards(cids) # models - start with zero self.dst.models.models = {} for m in self.src.models.all(): if int(m['id']) in mids: self.dst.models.update(m) # decks if not self.did: dids = [] else: dids = [self.did] + [ x[1] for x in self.src.decks.children(self.did)] dconfs = {} for d in self.src.decks.all(): if str(d['id']) == ""1"": continue if dids and d['id'] not in dids: continue if not d['dyn'] and d['conf'] != 1: if self.includeSched: dconfs[d['conf']] = True if not self.includeSched: # scheduling not included, so reset deck settings to default d = dict(d) d['conf'] = 1 self.dst.decks.update(d) # copy used deck confs for dc in self.src.decks.allConf(): if dc['id'] in dconfs: self.dst.decks.updateConf(dc) # find used media media = {} self.mediaDir = self.src.media.dir() if self.includeMedia: for row in notedata: flds = row[6] mid = row[2] for file in self.src.media.filesInStr(mid, flds): media[file] = True if self.mediaDir: for fname in os.listdir(self.mediaDir): if fname.startswith(""_""): media[fname] = True self.mediaFiles = list(media.keys()) self.dst.crt = self.src.crt # todo: tags? self.count = self.dst.cardCount() self.dst.setMod() self.postExport() self.dst.close() def postExport(self): # overwrite to apply customizations to the deck before it's closed, # such as update the deck description pass def removeSystemTags(self, tags): return self.src.tags.remFromStr(""marked leech"", tags) # Packaged Anki decks ###################################################################### class AnkiPackageExporter(AnkiExporter): key = _(""Anki Deck Package"") ext = "".apkg"" def __init__(self, col): AnkiExporter.__init__(self, col) def exportInto(self, path): # open a zip file z = zipfile.ZipFile(path, ""w"", zipfile.ZIP_DEFLATED) # if all decks and scheduling included, full export if self.includeSched and not self.did: media = self.exportVerbatim(z) else: # otherwise, filter media = self.exportFiltered(z, path) # media map z.writestr(""media"", json.dumps(media)) z.close() def exportFiltered(self, z, path): # export into the anki2 file colfile = path.replace("".apkg"", "".anki2"") AnkiExporter.exportInto(self, colfile) z.write(colfile, ""collection.anki2"") # and media self.prepareMedia() media = {} for c, file in enumerate(self.mediaFiles): c = str(c) mpath = os.path.join(self.mediaDir, file) if os.path.exists(mpath): z.write(mpath, c) media[c] = file # tidy up intermediate files os.unlink(colfile) p = path.replace("".apkg"", "".media.db2"") if os.path.exists(p): os.unlink(p) os.chdir(self.mediaDir) shutil.rmtree(path.replace("".apkg"", "".media"")) return media def exportVerbatim(self, z): # close our deck & write it into the zip file, and reopen self.count = self.col.cardCount() self.col.close() z.write(self.col.path, ""collection.anki2"") self.col.reopen() # copy all media if not self.includeMedia: return {} media = {} mdir = self.col.media.dir() for c, file in enumerate(os.listdir(mdir)): c = str(c) mpath = os.path.join(mdir, file) if os.path.exists(mpath): z.write(mpath, c) media[c] = file return media def prepareMedia(self): # chance to move each file in self.mediaFiles into place before media # is zipped up pass # Export modules ########################################################################## def exporters(): def id(obj): return (""%s (*%s)"" % (obj.key, obj.ext), obj) exps = [ id(AnkiPackageExporter), id(TextNoteExporter), id(TextCardExporter), ] runHook(""exportersList"", exps) return exps ",1 "_num from misc import is_number # info baseurl = 'http://phya.snu.ac.kr/xe/underbbs/' url ='http://phya.snu.ac.kr/xe/index.php?mid=underbbs&category=372' # notices + general f = open('srl_notices.txt','r') num_notices = f.read().split(',') f.close() g = open('srl_general.txt','r') num_general = g.read().split(',') g.close() g = open('srl_general.txt','a') response = urllib.request.urlopen(url) data = response.read() text = data.decode('utf-8') count_new = 0 srl_arr_general = [] text_splitted = text.split('document_srl=') for i in range(1,len(text_splitted)): srl = text_splitted[i].split('"">')[0].split('#comment')[0] if(is_number(srl)): if(srl not in num_notices and srl not in srl_arr_general): # second statement : to prevent duplication srl_arr_general.append(srl) if(srl not in num_general): count_new += 1 g.write(',' + srl) print('New post found : ' + srl) g.close() if(count_new != 0): print('Started generating feed...') # make FeedGenerator fg = FeedGenerator() fg.id('asdf') fg.title('SNU Physics Board RSS feed - general') fg.author({'name':'Seungwon Park','email':'yyyyy at snu dot ac dot kr'}) fg.link(href='asdf') fg.subtitle('SNU Physics Board RSS - general') fg.language('ko') for srl in srl_arr_general: print('Parsing post #' + srl + '...') fe = fg.add_entry() fe.id(baseurl + srl) fe.title(post_title(srl)) fe.author({'name':post_author(srl),'email':'unknown'}) fe.link(href = baseurl + srl) atomfeed = fg.atom_str(pretty=True) fg.atom_file('general.xml') print('Added ' + str(count_new) + ' posts to feed.') else: print('Posts are up-to-date.')",1 "u can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # 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, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA # import os import ConfigParser import HnTool.modules.util from HnTool.modules.rule import Rule as MasterRule class Rule(MasterRule): def __init__(self, options): MasterRule.__init__(self, options) self.short_name=""php"" self.long_name=""Checks security problems on php config file"" self.type=""config"" self.required_files = ['/etc/php5/apache2/php.ini', '/etc/php5/cli/php.ini', '/etc/php.ini'] def requires(self): return self.required_files def analyze(self, options): check_results = self.check_results conf_files = self.required_files for php_conf in conf_files: if os.path.isfile(php_conf): config = ConfigParser.ConfigParser() try: config.read(php_conf) except ConfigParser.ParsingError, (errno, strerror): check_results['info'].append('Could not parse %s: %s' % (php_conf, strerror)) continue if not config.has_section('PHP'): check_results['info'].append('%s is not a PHP config file' % (php_conf)) continue if config.has_option('PHP', 'register_globals'): rg = config.get('PHP', 'register_globals').lower() if rg == 'on': check_results['medium'].append('Register globals is on (%s)' % (php_conf)) elif rg == 'off': check_results['ok'].append('Register globals is off (%s)' % (php_conf)) else: check_results['info'].append('Unknown value for register globals (%s)' % (php_conf)) else: check_results['info'].append('Register globals not found (%s)' % (php_conf)) if config.has_option('PHP', 'safe_mode'): sm = config.get('PHP', 'safe_mode').lower() if sm == 'on': check_results['low'].append('Safe mode is on (fake security) (%s)' % (php_conf)) elif sm == 'off': check_results['info'].append('Safe mode is off (%s)' % (php_conf)) else: check_results['info'].append('Unknown value for safe mode (%s)' % (php_conf)) else: check_results['info'].append('Safe mode not found (%s)' % (php_conf)) if config.has_option('PHP', 'display_errors'): de = config.get('PHP', 'display_errors').lower() if de == 'on': check_results['medium'].append('Display errors is on (stdout) (%s)' % (php_conf)) elif de == 'off': check_results['ok'].append('Display errors is off (%s)' % (php_conf)) elif de == 'stderr': check_results['info'].append('Display errors set to stderr (%s)' % (php_conf)) else: check_results['info'].append('Unknown value for display errors (%s)' % (php_conf)) else: check_results['info'].append('Display errors not found (%s)' % (php_conf)) if config.has_option('PHP', 'expose_php'): ep = config.get('PHP', 'expose_php').lower() if ep == 'on': check_results['low'].append('Expose PHP is on (%s)' % (php_conf)) elif ep == 'off': check_results['ok'].append('Expose PHP is off (%s)' % (php_conf)) else: check_results['info'].append('Unknown value for expose PHP (%s)' % (php_conf)) else: check_results['info'].append('Expose PHP not found (%s)' % (php_conf)) return check_results ",1 "cept 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 .inventory import ( GetInventoryRequest, Inventory, ListInventoriesRequest, ListInventoriesResponse, InventoryView, ) from .os_policy import OSPolicy from .os_policy_assignment_reports import ( GetOSPolicyAssignmentReportRequest, ListOSPolicyAssignmentReportsRequest, ListOSPolicyAssignmentReportsResponse, OSPolicyAssignmentReport, ) from .os_policy_assignments import ( CreateOSPolicyAssignmentRequest, DeleteOSPolicyAssignmentRequest, GetOSPolicyAssignmentRequest, ListOSPolicyAssignmentRevisionsRequest, ListOSPolicyAssignmentRevisionsResponse, ListOSPolicyAssignmentsRequest, ListOSPolicyAssignmentsResponse, OSPolicyAssignment, OSPolicyAssignmentOperationMetadata, UpdateOSPolicyAssignmentRequest, ) from .osconfig_common import FixedOrPercent from .patch_deployments import ( CreatePatchDeploymentRequest, DeletePatchDeploymentRequest, GetPatchDeploymentRequest, ListPatchDeploymentsRequest, ListPatchDeploymentsResponse, MonthlySchedule, OneTimeSchedule, PatchDeployment, PausePatchDeploymentRequest, RecurringSchedule, ResumePatchDeploymentRequest, UpdatePatchDeploymentRequest, WeekDayOfMonth, WeeklySchedule, ) from .patch_jobs import ( AptSettings, CancelPatchJobRequest, ExecStep, ExecStepConfig, ExecutePatchJobRequest, GcsObject, GetPatchJobRequest, GooSettings, Instance, ListPatchJobInstanceDetailsRequest, ListPatchJobInstanceDetailsResponse, ListPatchJobsRequest, ListPatchJobsResponse, PatchConfig, PatchInstanceFilter, PatchJob, PatchJobInstanceDetails, PatchRollout, WindowsUpdateSettings, YumSettings, ZypperSettings, ) from .vulnerability import ( CVSSv3, GetVulnerabilityReportRequest, ListVulnerabilityReportsRequest, ListVulnerabilityReportsResponse, VulnerabilityReport, ) __all__ = ( ""GetInventoryRequest"", ""Inventory"", ""ListInventoriesRequest"", ""ListInventoriesResponse"", ""InventoryView"", ""OSPolicy"", ""GetOSPolicyAssignmentReportRequest"", ""ListOSPolicyAssignmentReportsRequest"", ""ListOSPolicyAssignmentReportsResponse"", ""OSPolicyAssignmentReport"", ""CreateOSPolicyAssignmentRequest"", ""DeleteOSPolicyAssignmentRequest"", ""GetOSPolicyAssignmentRequest"", ""ListOSPolicyAssignmentRevisionsRequest"", ""ListOSPolicyAssignmentRevisionsResponse"", ""ListOSPolicyAssignmentsRequest"", ""ListOSPolicyAssignmentsResponse"", ""OSPolicyAssignment"", ""OSPolicyAssignmentOperationMetadata"", ""UpdateOSPolicyAssignmentRequest"", ""FixedOrPercent"", ""CreatePatchDeploymentRequest"", ""DeletePatchDeploymentRequest"", ""GetPatchDeploymentRequest"", ""ListPatchDeploymentsRequest"", ""ListPatchDeploymentsResponse"", ""MonthlySchedule"", ""OneTimeSchedule"", ""PatchDeployment"", ""PausePatchDeploymentRequest"", ""RecurringSchedule"", ""ResumePatchDeploymentRequest"", ""UpdatePatchDeploymentRequest"", ""WeekDayOfMonth"", ""WeeklySchedule"", ""AptSettings"", ""CancelPatchJobRequest"", ""ExecStep"", ""ExecStepConfig"", ""ExecutePatchJobRequest"", ""GcsObject"", ""GetPatchJobRequest"", ""GooSettings"", ""Instance"", ""ListPatchJobInstanceDetailsRequest"", ""ListPatchJobInstanceDetailsResponse"", ""ListPatchJobsRequest"", ""ListPatchJobsResponse"", ""PatchConfig"", ""PatchInstanceFilter"", ""PatchJob"", ""PatchJobInstanceDetails"", ""PatchRollout"", ""WindowsUpdateSettings"", ""YumSettings"", ""ZypperSettings"", ""CVSSv3"", ""GetVulnerabilityReportRequest"", ""ListVulnerabilityReportsRequest"", ""ListVulnerabilityReportsResponse"", ""VulnerabilityReport"", ) ",1 "ternatives from django.template.loader import get_template from django.utils import timezone from invitations.models import Invitation logger = logging.getLogger('email') sentry = logging.getLogger('sentry') def send_invite(message): try: invite = Invitation.objects.get( id=message.get('id'), status__in=[Invitation.PENDING, Invitation.ERROR], ) except Invitation.DoesNotExist: sentry.error(""Invitation to send not found"", exc_info=True, extra={'message': message}) return invite.status = Invitation.PROCESSING invite.save() context = { 'invite': invite, 'domain': Site.objects.get_current().domain, } subject = ""[ContactOtter] Invitation to join ContactOtter from %s"" % (invite.sender) if invite.book: subject = ""[ContactOtter] Invitation to share %s's contact book"" % (invite.sender) txt = get_template('email/invitation.txt').render(context) html = get_template('email/invitation.html').render(context) try: message = EmailMultiAlternatives( subject=subject, body=txt, from_email=""ContactOtter