import pathlib import os import types import pyflexconfig config = types.SimpleNamespace( HOME=os.getenv("HOME", "unset") ) def custom_parser(path): # Stupid custom parser that just adds an option result: dict = pyflexconfig.pure_python_parser(path) result["ADDED_BY_PARSER"] = "anything" return result def filters_nothing_more(conf): # We do like the standdard filter ;o) pyflexconfig.keep_upper_names(conf) return def bootstrap(): global config defaultsettings_path = pathlib.Path(__file__).resolve().parent / "defaultsettings.py" pyflexconfig.bootstrap(config, parser=custom_parser, defaults_path=defaultsettings_path, custom_path_envvar="CUSTOM_OPTIONS_FILE", filter_=filters_nothing_more)
import logging logging.basicConfig(level=logging.INFO) from ..experiments_security_game_one import Train # import matplotlib.pyplot as plt import numpy as np import os import types args = types.SimpleNamespace() args.split_settings = 'const_val' args.val_size = 2000 args.loss = 'vlogloss' args.datasize = 200 args.lr = 0.005 args.nEpochs = 2000 args.monitorFreq = 5 args.fracval = 0.3 args.batchsize = 128 args.tie_initial_raiseval = True args.uniform_dist = False args.single_feature = 1 save_path_template = './results/secgame/secgameone_size200_SLOWrmsprop_bsize_vonly/%d_%d/' args.max_val = 2. args.success_rates = '0.5,0.5' args.static_rewards = 1 args.momentum = 0.1 args.optimizer = 'rmsprop' args.fixbets = 10
def setUp(self): self.config = types.SimpleNamespace()
def lex(self, filename: str) -> T.Generator[Token, None, None]: line_start = 0 lineno = 1 loc = 0 par_count = 0 bracket_count = 0 curl_count = 0 col = 0 while loc < len(self.code): matched = False value = None # type: T.Union[str, bool, int] for (tid, reg) in self.token_specification: mo = reg.match(self.code, loc) if mo: curline = lineno curline_start = line_start col = mo.start() - line_start matched = True span_start = loc loc = mo.end() span_end = loc bytespan = (span_start, span_end) match_text = mo.group() if tid == 'ignore' or tid == 'comment': break elif tid == 'lparen': par_count += 1 elif tid == 'rparen': par_count -= 1 elif tid == 'lbracket': bracket_count += 1 elif tid == 'rbracket': bracket_count -= 1 elif tid == 'lcurl': curl_count += 1 elif tid == 'rcurl': curl_count -= 1 elif tid == 'dblquote': raise ParseException('Double quotes are not supported. Use single quotes.', self.getline(line_start), lineno, col) elif tid in {'string', 'fstring'}: # Handle here and not on the regexp to give a better error message. if match_text.find("\n") != -1: msg = ParseException("Newline character in a string detected, use ''' (three single quotes) " "for multiline strings instead.\n" "This will become a hard error in a future Meson release.", self.getline(line_start), lineno, col) mlog.warning(msg, location=BaseNode(lineno, col, filename)) value = match_text[2 if tid == 'fstring' else 1:-1] try: value = ESCAPE_SEQUENCE_SINGLE_RE.sub(decode_match, value) except MesonUnicodeDecodeError as err: raise MesonException(f"Failed to parse escape sequence: '{err.match}' in string:\n {match_text}") elif tid == 'multiline_string': tid = 'string' value = match_text[3:-3] lines = match_text.split('\n') if len(lines) > 1: lineno += len(lines) - 1 line_start = mo.end() - len(lines[-1]) elif tid == 'number': value = int(match_text, base=0) elif tid == 'eol_cont': lineno += 1 line_start = loc break elif tid == 'eol': lineno += 1 line_start = loc if par_count > 0 or bracket_count > 0 or curl_count > 0: break elif tid == 'id': if match_text in self.keywords: tid = match_text else: if match_text in self.future_keywords: mlog.warning(f"Identifier '{match_text}' will become a reserved keyword in a future release. Please rename it.", location=types.SimpleNamespace(filename=filename, lineno=lineno)) value = match_text yield Token(tid, filename, curline_start, curline, col, bytespan, value) break if not matched: raise ParseException('lexer', self.getline(line_start), lineno, col)
def test_empty_simple_namespace(self): ns = types.SimpleNamespace() formatted = FancyPrinter().pformat(ns) assert formatted == "namespace()"
def main(argv): login = json.load(open(os.path.join(clientDir, 'config', 'login.json'), )) # initialize thread channels thcmds = {} thcmds['tgApi'] = Queue() thcmds['bot'] = Queue() ths = {} ths['tgApi'] = tgApi( cmdQueue=thcmds, token=login['telegram']['token'], botname=login['telegram']['botname'], authgroup=login['telegram']['authgroup'], itag="tgApi", otag="bot", ) print( 'telegram:', login['telegram']['token'], login['telegram']['botname'], login['telegram']['authgroup'], ) # prepare threadings # initialize threadings for key, th in ths.items(): th.daemon = True th.start() # initialize process channels manager = Manager() smpCmds = {} rmpCmds = {} impReqs = {} mps = {} is_on = {} is_auto = {} thcmds['tgApi'].put('client starts') pkey = 'bot' # socket HOST = login['server']['host'] PORT = login['server']['port'] print( 'MT Communication @', HOST, PORT, ) sel = selectors.DefaultSelector() lsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) lsock.bind((HOST, PORT)) lsock.listen() print('listening on', (HOST, PORT)) lsock.setblocking(False) sel.register(lsock, selectors.EVENT_READ, data=None) while True: events = sel.select(timeout=None) for key, mask in events: if key.data is None: # accept_wrapper(key.fileobj) sock = key.fileobj conn, addr = sock.accept() # Should be ready to read print('accepted connection from', addr) conn.setblocking(False) data = types.SimpleNamespace(addr=addr, inb=b'', outb=b'') events = selectors.EVENT_READ | selectors.EVENT_WRITE sel.register(conn, events, data=data) else: # service_connection(key, mask) sock = key.fileobj data = key.data if mask & selectors.EVENT_READ: recv_data = sock.recv(1024) # Should be ready to read if recv_data: data.outb += recv_data else: print('closing connection to', data.addr) sel.unregister(sock) sock.close() if mask & selectors.EVENT_WRITE: if data.outb: try: thcmds['tgApi'].put(data.outb.decode()) except Exception as e: print(e) print('echoing', repr(data.outb), 'to', data.addr) sent = sock.send(data.outb) # Should be ready to write data.outb = data.outb[sent:]
def _update_phantoms(self): if not self.view.is_primary(): return # not sure why this happens, but ignore these cases if self.view.window() is None: return if not ghostscript_installed(): return view = self.view window = view.window() # see #980; in any case window is None only for newly created views # where there isn't much point in running the phantom update. if (window is None or not any( window.active_view_in_group(g) == view for g in range(window.num_groups()))): return # TODO we may only want to apply if the view is visible # if view != view.window().active_view(): # return # update the regions of the phantoms self._update_phantom_regions() new_phantoms = [] job_args = [] if not _IS_ENABLED or self.visible_mode == "none": if not self.phantoms: return scopes = [] elif self.visible_mode == "all": scopes = view.find_by_selector( "text.tex.latex meta.environment.math") elif self.visible_mode == "selected": math_scopes = view.find_by_selector( "text.tex.latex meta.environment.math") scopes = [ scope for scope in math_scopes if any( scope.contains(sel) for sel in view.sel()) ] else: self.visible_mode = "none" scopes = [] # avoid creating a preview if someone just inserts $|$ and # most likely want to create an inline and not a block block def is_dollar_snippet(scope): is_selector = view.score_selector( scope.begin(), "meta.environment.math.block.dollar") sel_at_start = any(sel.empty() and sel.b == scope.begin() + 1 for sel in view.sel()) return is_selector and sel_at_start scopes = [scope for scope in scopes if not is_dollar_snippet(scope)] color = self.color # if no foreground color is defined use the default test color if not color: color = get_color(view) style_kwargs = { "color": color, "background_color": self.background_color } for scope in scopes: content = view.substr(scope) multline = "\n" in content layout = (sublime.LAYOUT_BLOCK if multline or self.visible_mode == "selected" else sublime.LAYOUT_INLINE) BE_BLOCK = view.score_selector(scope.begin(), "meta.environment.math.block.be") # avoid jumping around in begin end block if multline and BE_BLOCK: region = sublime.Region(scope.end() + 4) else: region = sublime.Region(scope.end()) try: p = next(e for e in self.phantoms if e.region == region) if p.content == content: new_phantoms.append(p) continue # update the content and the layout p.content = content p.layout = layout except: p = types.SimpleNamespace(id=None, region=region, content=content, layout=layout, update_time=0) # generate the latex template latex_document = self._create_document(scope, color) # create a string, which uniquely identifies the compiled document id_str = "\n".join([ str(_version), self.latex_program, str(_density), str(_hires), color, latex_document ]) base_name = cache.hash_digest(id_str) image_path = os.path.join(temp_path, base_name + _IMAGE_EXTENSION) # if the file exists as an image update the phantom if os.path.exists(image_path): if p.id is not None: view.erase_phantom_by_id(p.id) _cancel_image_jobs(view.id(), p) html_content = _generate_html(view, image_path, style_kwargs) p.id = view.add_phantom(self.key, region, html_content, layout, on_navigate=self.on_navigate) new_phantoms.append(p) continue # if neither the file nor the phantom exists, create a # placeholder phantom elif p.id is None: p.id = view.add_phantom(self.key, region, _wrap_html("\u231B", **style_kwargs), layout, on_navigate=self.on_navigate) job_args.append({ "latex_document": latex_document, "base_name": base_name, "color": color, "p": p, "cont": self._make_cont(p, image_path, time.time(), style_kwargs) }) new_phantoms.append(p) # delete deprecated phantoms delete_phantoms = [x for x in self.phantoms if x not in new_phantoms] for p in delete_phantoms: if p.region != sublime.Region(-1): view.erase_phantom_by_id(p.id) _cancel_image_jobs(view.id(), delete_phantoms) # set the new phantoms self.phantoms = new_phantoms # run the jobs to create the remaining images if job_args: _extend_image_jobs(view.id(), self.latex_program, job_args) _run_image_jobs()
'sub': '*****@*****.**', } @pytest.fixture def tokendata_zero_scopes(): now = int(time.time()) return { 'iat': now, 'exp': now + 30, 'scopes': [], 'sub': '*****@*****.**', } ok_response = types.SimpleNamespace(status_code=200) @pytest.fixture def middleware(): reload_settings(TESTSETTINGS) return authorization_middleware(lambda r: ok_response) def test_missing_conf(): with pytest.raises(config.AuthzConfigurationError): authorization_middleware(None) def test_bad_jwks(): with pytest.raises(config.AuthzConfigurationError):
def create_request_no_auth_header(path='/', method='GET'): return types.SimpleNamespace(META={}, path=path, method=method)
def fake_args(request): ns = types.SimpleNamespace() ns.backend = 'webengine' if request.config.webengine else 'webkit' objreg.register('args', ns) yield ns objreg.delete('args')
def generate_code(request, response): # MainFilePath = os.path.join(".", "src/main.cpp") # Find all proto files file_map = OrderedDict() for proto_file in request.proto_file: file_map[proto_file.name] = proto_file # Create an ordered dictionary for all Protobuf packages packages_dict = OrderedDict() # Find the *Notification messages to add them to a list notification_messages_list = [] # Find Messages and RPC's that have the same name within the proto files because ROS doesn't handle namespaces messages_unordered_set = set() rpcs_unordered_set = set() duplicated_messages_unordered_set = set() duplicated_rpcs_unordered_set = set() for filename, proto_file in file_map.items(): for item, package in traverse(proto_file): # Skip the packages we don't want to generate if package.split(".")[-1] in NON_GENERATED_PACKAGES: continue packages_dict[package] = DetailedPackage(package) # If the item is a message or an enum if not isinstance(item, ServiceDescriptorProto): if item.name not in messages_unordered_set: messages_unordered_set.add(item.name) # Add the notifications to a list to match them to their respective RPCs later (because there package may differ from the RPC's) if re.match(r"\w+Notification", item.name): notification_messages_list.append( DetailedMessage(item, package, False)) else: duplicated_messages_unordered_set.add(item.name) # If the item is a Protobuf service (a collection of methods) else: for method in item.method: if method.name not in rpcs_unordered_set: rpcs_unordered_set.add(method.name) else: duplicated_rpcs_unordered_set.add(method.name) # Remove old generated files and create new directories for package in packages_dict.values(): for s in ['srv', 'msg']: try: shutil.rmtree("../{}/generated/{}".format( s, package.short_name_lowercase_with_underscores)) except: pass os.mkdir("../{}/generated/{}".format( s, package.short_name_lowercase_with_underscores)) shutil.rmtree("../src/generated") shutil.rmtree("../include/kortex_driver/generated") os.mkdir("../src/generated") os.mkdir("../include/kortex_driver/generated") ########################################### # Parse the proto files to add the messages and RPC's to the DetailedPackage's for filename, proto_file in file_map.items(): # For every item in the current proto file for item, package in traverse(proto_file): # Skip the packages we don't want to generate if package.split(".")[-1] in NON_GENERATED_PACKAGES: continue current_package = packages_dict[package] # If this is an enum if isinstance(item, EnumDescriptorProto): is_enum_duplicated = item.name in duplicated_messages_unordered_set current_package.addEnum( DetailedMessage(item, package, is_enum_duplicated)) # If this is a message if isinstance(item, DescriptorProto): is_message_duplicated = item.name in duplicated_messages_unordered_set duplicated_fields = filter( lambda x: x.type_name.split(".")[-1] in duplicated_messages_unordered_set, item.field) temp_message = DetailedMessage(item, package, is_message_duplicated, duplicated_fields) # Find if the message contains oneof message_contains_one_of = False for member in item.field: # If a member is part of a one_of, it will have this additional field. if member.HasField("oneof_index"): message_contains_one_of = True break # Register every one_of in the message if message_contains_one_of: # Find the one_of names for one_of in item.ListFields( )[-1][1]: # This is the very obscure way to get the one_of's name temp_message.one_of_list.append( DetailedOneOf(one_of.name)) # Find the fields and what one_of they belong to for member in item.field: # If a member is part of a one_of, add it to the DetailedOneOf it belongs to if member.HasField("oneof_index"): is_field_duplicated = member.type_name.split( ".")[-1] in duplicated_messages_unordered_set temp_message.one_of_list[ member.oneof_index].addField( member, is_field_duplicated) current_package.addMessage(temp_message) # If this is a Protobuf service (a group of RPC's) if isinstance(item, ServiceDescriptorProto): # Register every RPC in the Protobuf service for rpc in item.method: # Do not generate the services that cause generation bugs if rpc.name in FORBIDDEN_RPC_METHODS: continue is_rpc_duplicated = rpc.name in duplicated_rpcs_unordered_set is_input_type_duplicated = rpc.input_type.split( ".")[-1] in duplicated_messages_unordered_set is_output_type_duplicated = rpc.output_type.split( ".")[-1] in duplicated_messages_unordered_set notification_message = list( filter( lambda x: x.name == rpc.name.replace( "Topic", "Notification"), notification_messages_list)) temp_rpc = DetailedRPC(rpc, package, is_rpc_duplicated, is_input_type_duplicated, is_output_type_duplicated, notification_message) current_package.addRPC(temp_rpc) ########################################### # Generate the include names with the packages that contain messages packages_with_messages = filter(lambda x: len(x.messages) > 0, packages_dict.values()) include_file_names = [] for p in packages_with_messages: for s in ["proto", "ros"]: include_file_names.append( "kortex_driver/generated/{}_{}_converter.h".format( p.short_name.lower(), s)) # Generate the ROS files for each package for package in packages_dict.values(): # Generate the enums for enum in package.enums: this_enum_context = types.SimpleNamespace() this_enum_context.item = enum ros_enum_path = os.path.join( "..", "msg/generated/{}{}{}.msg".format(enum.containing_folder, enum.prepend_message_name, enum.name)) with open(ros_enum_path, 'wt') as serviceFile: serviceFile.write( render("../templates/ros_enum.msg.jinja2", this_enum_context.__dict__)) # Generate the messages for message in package.messages: this_message_context = types.SimpleNamespace() this_message_context.item = message this_message_context.field_descriptor_class = FieldDescriptor # Generate the one_of's for the message for detailed_one_of in message.one_of_list: # not empty this_message_context.detailed_one_of = detailed_one_of ros_oneofPath = os.path.join( "..", "msg/generated/{}{}{}_{}.msg".format( message.containing_folder, message.prepend_message_name, message.name, detailed_one_of.name)) with open(ros_oneofPath, 'wt') as serviceFile: serviceFile.write( render("../templates/ros_oneof.msg.jinja2", this_message_context.__dict__)) # Generate the message ros_messagePath = os.path.join( "..", "msg/generated/{}{}{}.msg".format(message.containing_folder, message.prepend_message_name, message.name)) with open(ros_messagePath, 'wt') as serviceFile: serviceFile.write( render("../templates/ros_message.msg.jinja2", this_message_context.__dict__)) # Generate the RPC's for rpc in package.methods: this_rpc_context = types.SimpleNamespace() this_rpc_context.item = rpc ros_servicePath = os.path.join( "..", "srv/generated/{}/{}{}{}.srv".format( package.short_name_lowercase_with_underscores, rpc.prepend_rpc_package_name, rpc.prepend_on_notification, rpc.name)) with open(ros_servicePath, 'wt') as serviceFile: serviceFile.write( render("../templates/ros_service.srv.jinja2", this_rpc_context.__dict__)) # Generate the Proto-ROS converters (C++ files) this_package_context = types.SimpleNamespace() this_package_context.package = package if package.messages: # package contains at least one message # Proto converter header file current_header_filename = "kortex_driver/generated/{}_proto_converter.h".format( package.short_name.lower()) this_package_context.include_file_names = filter( lambda x: "proto_converter" in x and x != current_header_filename, include_file_names) with open(os.path.join("..", "include/" + current_header_filename), 'wt') as converterFile: converterFile.write( render("../templates/proto_converter.h.jinja2", this_package_context.__dict__)) # Proto converter cpp file this_package_context.current_header_filename = current_header_filename with open( os.path.join( "..", "src/generated/{}_proto_converter.cpp".format( package.short_name.lower())), 'wt') as converterFile: converterFile.write( render("../templates/proto_converter.cpp.jinja2", this_package_context.__dict__)) # ROS converter header file current_header_filename = "kortex_driver/generated/{}_ros_converter.h".format( package.short_name.lower()) this_package_context.include_file_names = filter( lambda x: "ros_converter" in x and x != current_header_filename, include_file_names) with open(os.path.join("..", "include/" + current_header_filename), 'wt') as converterFile: converterFile.write( render("../templates/ros_converter.h.jinja2", this_package_context.__dict__)) # ROS converter cpp file this_package_context.current_header_filename = current_header_filename with open( os.path.join( "..", "src/generated/{}_ros_converter.cpp".format( package.short_name.lower())), 'wt') as converterFile: converterFile.write( render("../templates/ros_converter.cpp.jinja2", this_package_context.__dict__)) # Generate the ServiceProxy's for every Kortex API method if package.methods: # package contains at least one RPC current_header_filename = "kortex_driver/generated/{}_services.h".format( package.short_name.lower()) this_package_context.current_header_filename = current_header_filename this_package_context.include_file_names = include_file_names with open(os.path.join("..", "include/" + current_header_filename), 'wt') as services_file: services_file.write( render("../templates/services.h.jinja2", this_package_context.__dict__)) with open( os.path.join( "..", "src/generated/{}_services.cpp".format( package.short_name.lower())), 'wt') as services_file: services_file.write( render("../templates/services.cpp.jinja2", this_package_context.__dict__)) # Delete unused folders we created for None for package in packages_dict.values(): for s in ['srv', 'msg']: if len( os.listdir('../{}/generated/{}'.format( s, package.short_name_lowercase_with_underscores))) == 0: shutil.rmtree("../{}/generated/{}".format( s, package.short_name_lowercase_with_underscores))
def loadTestArgs(): templatePath = os.path.abspath(os.path.join("test", "si.in")) nameSpace = types.SimpleNamespace(elementList=["Mg"], templatePath=templatePath) return nameSpace
def test_return_for_single_tag(monkeypatch, capsys): cssdata = () assert cssedit.return_for_single_tag(cssdata) == '' cssdata = (types.SimpleNamespace(style=MockStyle()), ) assert cssedit.return_for_single_tag(cssdata) == 'style text'
def __init__(self, server_id, address, n): """ Sets up this server to (1) connect to other servers and (2) connect to client """ self.sel = selectors.DefaultSelector() self.logger = logging.getLogger('Server') logging.basicConfig(filename='test.log', level=logging.DEBUG) self.client_port: int = address[1] self.server_id: int = server_id self.server_port: int = 20000 + self.server_id # establish a listening TCP endpoint to client self.client_lsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.client_lsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # establish a listening TCP endpoint for other servers self.server_lsock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.server_lsock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.n = n # bind to client-facing port; assumed guaranteed to be available while True: try: self.client_lsock.bind(address) break except: pass # bind to server-facing port; available by port assigning convention while True: try: self.server_lsock.bind(('localhost', self.server_port)) break except: pass self.client_csock = None # map server IDs to sockets self.id_to_sock = {} # establish connections to all preceding servers for i in range(n): if i == self.server_id: continue # create a connecting socket for servers that have been started addr = 20000 + i print(self.server_id, 'connecting to', addr) csock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) csock.setblocking(False) csock.connect_ex(('localhost', addr)) events = selectors.EVENT_READ | selectors.EVENT_WRITE data = types.SimpleNamespace(connid=i, outb=b'') self.sel.register(csock, events, data=data) # finish setting up our client listening socket self.client_lsock.listen(int(n)) self.client_lsock.setblocking(False) self.sel.register(self.client_lsock, selectors.EVENT_READ, data=None) # finish setting up our server listening socket self.server_lsock.listen(int(n)) self.server_lsock.setblocking(False) self.sel.register(self.server_lsock, selectors.EVENT_READ, data=None) self.lock = threading.RLock() # raft-specific persistent state on ALL servers self.current_term = 0 self.voted_for = None # reset always when current term changes self.log = {} # log[index] = (cmd, term) # volatile state on ALL servers self.commit_index = 0 self.last_applied = 0 self.state = 'follower' # valid states: 'follower', 'leader', 'candidate' self.store = {} self.application_thr = threading.Thread(name='application_thr', target=self.apply_committed) self.application_thr.daemon = True self.application_thr_cv = threading.Condition() self.application_thr.start() # https://www.cl.cam.ac.uk/~ms705/pub/papers/2015-osr-raft.pdf section 4 self.election_timeout_lower = 5000 self.election_timeout = random.randint( self.election_timeout_lower, self.election_timeout_lower * 2) # slowed to allow sufficient time to see changes self.election_timer = threading.Timer(self.election_timeout / 1000, self.convert_to_candidate) self.election_timer.daemon = True self.leader_timeout = self.election_timeout_lower / 2 self.heartbeat_timer = threading.Timer(self.leader_timeout / 1000, self.send_heartbeats) self.heartbeat_timer.daemon = True self.leader = None # volatile state ONLY for leaders, None otherwise self.match_index = None self.next_index = None # TODO. array of queues for retrying indefinitely for servers that have failed self.pending_rpcs = None # state for candidates self.vote_count = 0
def get_token_stream(file_obj): """ returns generator for stream of tokens read from IO object :param file_obj: io-like object with read method :returns: generator that returns Token objects """ token_reader = RadixReader.from_list(TOKEN_LIST) rollover = False read_buffer = [] closure = types.SimpleNamespace() closure.line_num = 1 closure.char_num = 0 def read_char(): if len(read_buffer) == 0: closure.char_num += 1 c = file_obj.read(1) if c == "\n": closure.line_num += 1 token_str = TokenString(c, line_num=closure.line_num, char_num=closure.char_num) return token_str else: return read_buffer.pop(0) def read_while(read_buffer, char_buffer, pred): while True: c = read_char() if c == "" or not pred(c): break char_buffer.append(c) return [c] + read_buffer def maybe_implicit_token(string, token_class): token_reader.reset() if (not token_reader.add(string) or token_reader.last_string != string): return token_class(string) return string while True: c = read_char() if c == "": break if is_stop_char(c): continue # read variable names if is_letter(c): char_buffer = [c] read_buffer = read_while(read_buffer, char_buffer, valid_string_char) yield (maybe_implicit_token(TokenString.join(char_buffer), Tokens._Variable)) continue # read numbers if is_digit(c): char_buffer = [c] read_buffer = read_while(read_buffer, char_buffer, is_digit) yield (maybe_implicit_token(TokenString.join(char_buffer), Tokens._Number)) continue accepted_any = False token_reader.reset() while token_reader._add(c): accepted_any = True c = read_char() if c == "": break if not accepted_any: yield c else: unmatched_buffer = [x for x in token_reader.unmatched] read_buffer = (unmatched_buffer + [c] + read_buffer) result = token_reader.last_string if result == "": continue yield result if result == Tokens.BEGIN_COMMENT: # read in rest of comment char_buffer = [] read_buffer = read_while(read_buffer, char_buffer, lambda x: x != "\n") yield Tokens._Comment(TokenString.join(char_buffer))
def get_with_metadata(self, *, count=None, as_string=False, as_numpy=True, timeout=None, with_ctrlvars=False, use_monitor=True, form=None, as_namespace=False): """Returns a dictionary of the current value and associated metadata Parameters ---------- count : int, optional explicitly limit count for array data as_string : bool, optional flag(True/False) to get a string representation of the value. as_numpy : bool, optional use numpy array as the return type for array data. timeout : float, optional maximum time to wait for value to be received. (default = 0.5 + log10(count) seconds) use_monitor : bool, optional use value from latest monitor callback (True, default) or to make an explicit CA call for the value. form : {'time', 'ctrl', None} Optionally change the type of the get request as_namespace : bool, optional Change the return type to that of a namespace with support for tab-completion Returns ------- val : dict or namespace The dictionary of data, guaranteed to at least have the 'value' key. Depending on the request form, other keys may also be present:: {'precision', 'units', 'status', 'severity', 'enum_strs', 'status', 'severity', 'timestamp', 'posixseconds', 'nanoseconds', 'upper_disp_limit', 'lower_disp_limit', 'upper_alarm_limit', 'upper_warning_limit', 'lower_warning_limit','lower_alarm_limit', 'upper_ctrl_limit', 'lower_ctrl_limit'} Returns ``None`` if the channel is not connected, `wait=False` was used, or the data transfer timed out. """ if form is None: form = self.form if count is None: count = self.default_count if timeout is None: if count is None: timeout = 1.0 else: timeout = 1.0 + log10(max(1, count)) type_key = 'control' if form == 'ctrl' else form if (with_ctrlvars and type_key not in ('control', 'native')): md = self.get_with_metadata(count=count, as_string=as_string, as_numpy=as_numpy, timeout=timeout, with_ctrlvars=False, use_monitor=use_monitor, form='control', as_namespace=False) elif use_monitor: md = self._args.copy() else: md = {} dt = field_types[type_key][self.type] if not as_string and dt in ca.char_types: re_map = { ChannelType.CHAR: ChannelType.INT, ChannelType.CTRL_CHAR: ChannelType.CTRL_INT, ChannelType.TIME_CHAR: ChannelType.TIME_INT, ChannelType.STS_CHAR: ChannelType.STS_INT } dt = re_map[dt] # TODO if you want char arrays not as_string # force no-monitor rather than use_monitor = False cached_value = self._args['value'] # trigger going out to got data from network if ((not use_monitor) or (self._auto_monitor_sub is None) or (cached_value is None) or (count is not None and count > len(cached_value))): command = self._caproto_pv.read(data_type=dt, data_count=count, timeout=timeout) response = _read_response_to_pyepics(self.typefull, command) self._args.update(**response) md.update(**response) if as_string and self.typefull in ca.enum_types: enum_strs = self.enum_strs else: enum_strs = None md['value'] = _pyepics_get_value(value=md['raw_value'], string_value=md['char_value'], full_type=self.typefull, native_count=self._args['count'], requested_count=count, enum_strings=enum_strs, as_string=as_string, as_numpy=as_numpy) if as_namespace: return types.SimpleNamespace(**md) return md
__default_host__ = _os.environ.get('JINA_DEFAULT_HOST', '0.0.0.0') __ready_msg__ = 'ready and listening' __stop_msg__ = 'terminated' __binary_delimiter__ = _os.environ.get( 'JINA_BINARY_DELIMITER', '460841a0a8a430ae25d9ad7c1f048c57').encode() __root_dir__ = _os.path.dirname(_os.path.abspath(__file__)) _names_with_underscore = [ '__version__', '__copyright__', '__license__', '__proto_version__', '__default_host__', '__ready_msg__', '__stop_msg__', '__binary_delimiter__', '__jina_env__', '__uptime__', '__root_dir__' ] # ADD GLOBAL NAMESPACE VARIABLES JINA_GLOBAL = _types.SimpleNamespace() JINA_GLOBAL.logserver = _types.SimpleNamespace() import jina.importer as _ji # driver first, as executor may contain driver _ji.import_classes('jina.drivers', show_import_table=False, import_once=True) _ji.import_classes('jina.executors', show_import_table=False, import_once=True) _ji.import_classes('jina.hub', show_import_table=False, import_once=True) _signal.signal(_signal.SIGINT, _signal.default_int_handler) def _set_nofile(nofile_atleast=4096): """ sets nofile soft limit to at least 4096, useful for running matlplotlib/seaborn on
print(key + ' : ' + str(value)) print() def main(): """ Main function """ # Print all Flags to confirm parameter settings print_flags() # Run the training operation eval() FLAGS = types.SimpleNamespace() if __name__ == '__main__': # Command line arguments parser = argparse.ArgumentParser() parser.add_argument('--model_name', type = str, default = MODEL_NAME_DEFAULT, help='Name of the model type to train (baseline, )') parser.add_argument('--checkpoint_path', type = str, default = CHECKPOINT_PATH_DEFAULT, help='Path to a model checkpoint') parser.add_argument('--output_dir', type = str, default = OUTPUT_DIR_DEFAULT, help='Directory to write output to') parser.add_argument('--data_path', type=str, default=DATA_PATH_DEFAULT, help='Path to the SNLI test dataset') parser.add_argument('--embedding_path', type=str, default=EMBEDDING_PATH_DEFAULT, help='Path to word embedding file') FLAGS, unparsed = parser.parse_known_args()
def test__perform_realtime_02(server): event = supriya.patterns.NoteEvent(duration=1.0, delta=10.0, frequency=[443, 445, 447]) server = types.SimpleNamespace( node_id_allocator=supriya.realtime.NodeIdAllocator()) event_products = event._perform_realtime(server=server, timestamp=100.0, uuids={}) assert pytest.helpers.get_objects_as_string( event_products, replace_uuids=True) == uqbar.strings.normalize(""" EventProduct( event=NoteEvent( delta=10.0, duration=1.0, frequency=[443, 445, 447], ), requests=[ SynthNewRequest( add_action=AddAction.ADD_TO_HEAD, frequency=443, node_id=1000, synthdef=<SynthDef: default>, target_node_id=1, ), SynthNewRequest( add_action=AddAction.ADD_TO_HEAD, frequency=445, node_id=1001, synthdef=<SynthDef: default>, target_node_id=1, ), SynthNewRequest( add_action=AddAction.ADD_TO_HEAD, frequency=447, node_id=1002, synthdef=<SynthDef: default>, target_node_id=1, ), ], timestamp=100.0, uuid=UUID('A'), ) EventProduct( event=NoteEvent( delta=10.0, duration=1.0, frequency=[443, 445, 447], ), is_stop=True, requests=[ NodeSetRequest( gate=0, node_id=1000, ), NodeSetRequest( gate=0, node_id=1001, ), NodeSetRequest( gate=0, node_id=1002, ), ], timestamp=101.0, uuid=UUID('A'), ) """)
from importlib import machinery, util, invalidate_caches from importlib.abc import ResourceReader import io import os import os.path from pathlib import Path, PurePath from test import support import unittest import sys import tempfile import types from . import data01 from . import zipdata01 BUILTINS = types.SimpleNamespace() BUILTINS.good_name = None BUILTINS.bad_name = None if 'errno' in sys.builtin_module_names: BUILTINS.good_name = 'errno' if 'importlib' not in sys.builtin_module_names: BUILTINS.bad_name = 'importlib' EXTENSIONS = types.SimpleNamespace() EXTENSIONS.path = None EXTENSIONS.ext = None EXTENSIONS.filename = None EXTENSIONS.file_path = None EXTENSIONS.name = '_testcapi'
'__uptime__', '__root_dir__', ] # Primitive data type, # note, they must be loaded BEFORE all executors/drivers/... to avoid cyclic imports from jina.types.ndarray.generic import NdArray from jina.types.request import Request, Response from jina.types.message import Message from jina.types.querylang import QueryLang from jina.types.document import Document from jina.types.document.multimodal import MultimodalDocument from jina.types.arrays import DocumentArray, QueryLangArray # ADD GLOBAL NAMESPACE VARIABLES JINA_GLOBAL = _types.SimpleNamespace() JINA_GLOBAL.scipy_installed = None JINA_GLOBAL.tensorflow_installed = None JINA_GLOBAL.torch_installed = None import jina.importer as _ji # driver first, as executor may contain driver _ji.import_classes('jina.drivers', show_import_table=False, import_once=True) _ji.import_classes('jina.executors', show_import_table=False, import_once=True) _ji.import_classes('jina.hub', show_import_table=False, import_once=True) _signal.signal(_signal.SIGINT, _signal.default_int_handler) def _set_nofile(nofile_atleast=4096):
async def _test_content_db(self, emirrordist_cmd, env, layouts, content_db, distfiles, settings, portdb): # Simulate distfile digest change for ContentDB. emdisopts = types.SimpleNamespace(content_db=content_db, distfiles=settings["DISTDIR"]) with EmirrordistConfig(emdisopts, portdb, asyncio.get_event_loop()) as emdisconf: # Copy revisions from bar to foo. for revision_key in emdisconf.content_db["filename:{}".format( "bar")]: emdisconf.content_db.add( DistfileName("foo", digests=dict(revision_key))) # Copy revisions from foo to bar. for revision_key in emdisconf.content_db["filename:{}".format( "foo")]: emdisconf.content_db.add( DistfileName("bar", digests=dict(revision_key))) content_db_state = dict(emdisconf.content_db.items()) self.assertEqual(content_db_state, dict(emdisconf.content_db.items())) self.assertEqual( [ k[len("filename:"):] for k in content_db_state if k.startswith("filename:") ], ["bar", "foo"], ) self.assertEqual(content_db_state["filename:foo"], content_db_state["filename:bar"]) self.assertEqual(len(content_db_state["filename:foo"]), 2) for k in distfiles: try: os.unlink(os.path.join(settings["DISTDIR"], k)) except OSError: pass proc = await asyncio.create_subprocess_exec(*emirrordist_cmd, env=env) self.assertEqual(await proc.wait(), 0) for k in distfiles: with open( os.path.join(settings["DISTDIR"], layouts[0].get_path(k)), "rb") as f: self.assertEqual(f.read(), distfiles[k]) with EmirrordistConfig(emdisopts, portdb, asyncio.get_event_loop()) as emdisconf: self.assertEqual(content_db_state, dict(emdisconf.content_db.items())) # Verify that remove works as expected filename = [ filename for filename in distfiles if filename == "foo" ][0] self.assertTrue(bool(filename.digests)) emdisconf.content_db.remove(filename) # foo should still have a content revision corresponding to bar's content. self.assertEqual( [ k[len("filename:"):] for k in emdisconf.content_db if k.startswith("filename:") ], ["bar", "foo"], ) self.assertEqual(len(emdisconf.content_db["filename:foo"]), 1) self.assertEqual( len([ revision_key for revision_key in emdisconf.content_db["filename:foo"] if not filename.digests_equal( DistfileName( "foo", digests=dict(revision_key), )) ]), 1, ) # bar should still have a content revision corresponding to foo's content. self.assertEqual(len(emdisconf.content_db["filename:bar"]), 2) self.assertEqual( len([ revision_key for revision_key in emdisconf.content_db["filename:bar"] if filename.digests_equal( DistfileName( "bar", digests=dict(revision_key), )) ]), 1, ) # remove the foo which refers to bar's content bar = [filename for filename in distfiles if filename == "bar"][0] foo_remaining = DistfileName("foo", digests=bar.digests) emdisconf.content_db.remove(foo_remaining) self.assertEqual( [ k[len("filename:"):] for k in emdisconf.content_db if k.startswith("filename:") ], ["bar"], ) self.assertRaises(KeyError, emdisconf.content_db.__getitem__, "filename:foo") # bar should still have a content revision corresponding to foo's content. self.assertEqual(len(emdisconf.content_db["filename:bar"]), 2)
def _process(v): if isinstance(v, dict): sub_args = UvnConfig._to_sns_args(v) return types.SimpleNamespace(**sub_args) else: return v
def main(): # Check args for if we're going to compile a single file instead m_matchingPattern = None if (len(sys.argv) > 1): m_matchingPattern = sys.argv[1] # Grab directory l_directoryPath = os.path.dirname(os.path.realpath(__file__)) m_projectRootPath = os.path.split(l_directoryPath)[0] + "/" # Set up display m_buildSucceeded = 0 m_buildFailed = 0 m_buildUpToDate = 0 m_buildSkipped = 0 # Grab include foldrs m_includeFolders = CollectIncludeFolders(m_projectRootPath) # Loop through each .res folder to compile shaders. for i_filename in os.listdir(m_projectRootPath): # Only work on res folders: if not (".res" in i_filename): continue if ("backup" in i_filename): continue # Check if the folder exists l_resourceFolder = m_projectRootPath + i_filename + "/shaders" print(m_outp + " Scanning in " + bcolors.UNDERLINE + i_filename + bcolors.ENDC + "...") if not os.path.isdir(l_resourceFolder): continue # Loop through each file for subdir, dirs, files in os.walk(l_resourceFolder): for file in files: if (file.endswith(".glsl") and ((m_matchingPattern is None) or (m_matchingPattern in file))): # Get the file path & display it l_shaderFilePath = os.path.join(subdir, file) l_displayName = l_shaderFilePath[len(m_projectRootPath):] print(m_outp + l_displayName) # Need extensionless filename l_nakedFile = os.path.splitext(l_shaderFilePath)[0] # Create default ouput l_outputFilePath = l_nakedFile + ".spv" # Check for variants l_variantsFile = l_nakedFile + ".variants.h" l_variants = [] if (os.path.exists(l_variantsFile)): l_variants = ReadVariants(l_variantsFile) # Compile the shader if (not l_variants): l_status = CompileShader(l_shaderFilePath, l_outputFilePath, m_includeFolders, []) if (l_status == 1): m_buildSkipped += 1 elif (l_status == 0): m_buildSucceeded += 1 elif (l_status == 2): m_buildFailed += 1 else: # Cache all permuations of macros l_macroVariants = [] for variant in l_variants: l_newMacroVariants = [] # For each variant value... for variant_value in variant.values: # Create macro that needs to be added to every macro list macro = types.SimpleNamespace( name=variant.name, value=str(variant_value)) if (l_macroVariants): # Add macro to every existing macro list for old_macro_list in l_macroVariants: new_macro_list = old_macro_list.copy() new_macro_list.append(macro) l_newMacroVariants.append( new_macro_list) else: #If macro list is empty, then we just start with size-1 lists l_newMacroVariants.append([macro]) # Save the current list l_macroVariants = l_newMacroVariants l_macroVariantIndex = 0 for l_macroVariant in l_macroVariants: l_outputFilePath = l_nakedFile + "_" + str( l_macroVariantIndex) + ".spv" print(m_outp + "\tOutput: " + l_outputFilePath) l_status = CompileShader(l_shaderFilePath, l_outputFilePath, m_includeFolders, l_macroVariant) if (l_status == 1): m_buildSkipped += 1 elif (l_status == 0): m_buildSucceeded += 1 elif (l_status == 2): m_buildFailed += 1 l_macroVariantIndex += 1 print( (bcolors.WARNING if m_buildFailed > 0 else bcolors.OKGREEN) + "Shader Build: {:d} succeeded, {:d} failed, {:d} up-to-date, {:d} skipped." .format(m_buildSucceeded, m_buildFailed, m_buildUpToDate, m_buildSkipped) + bcolors.ENDC) return (0 if m_buildSucceeded else 1) # Done.
def test_small_simple_namespace(self): ns = types.SimpleNamespace(a=1, b=2) formatted = FancyPrinter().pformat(ns) assert formatted == "namespace(a=1, b=2)"
def prepare_textacy_widgets(self): item_layout = dict( display='flex', flex_flow='row', justify_content='space-between', ) pos_options = get_pos_options(self.tagset) normalize_options = {'None': False, 'Lemma': 'lemma', 'Lower': 'lower'} ngrams_options = {'1': [1], '1, 2': [1, 2], '1,2,3': [1, 2, 3]} default_include_pos = ['NOUN', 'PROPN'] frequent_words = ['_mask_'] # widgets.Label( gui = types.SimpleNamespace( #min_freq=widgets.IntSlider(description='Min word freq',min=0, max=10, value=2, step=1, layout=widgets.Layout(width='240px', **item_layout)), #max_doc_freq=widgets.IntSlider(description='Min doc %', min=75, max=100, value=100, step=1, layout=widgets.Layout(width='240px', **item_layout)), min_freq=widgets.Dropdown(description='Min word freq', options=list(range(0, 11)), value=2, layout=widgets.Layout(width='200px', **item_layout)), max_doc_freq=widgets.Dropdown(description='Min doc %', options=list(range(75, 101)), value=100, layout=widgets.Layout( width='200px', **item_layout)), ngrams=widgets.Dropdown(description='n-grams', options=ngrams_options, value=[1], layout=widgets.Layout(width='200px')), normalize=widgets.Dropdown(description='Normalize', options=normalize_options, value='lemma', layout=widgets.Layout(width='200px')), filter_stops=widgets.ToggleButton(value=True, description='Remove stopword', tooltip='Filter out stopwords', icon='check'), named_entities=widgets.ToggleButton(value=False, description='Merge entities', tooltip='Merge entities', icon='check', disabled=False), substitute_terms=widgets.ToggleButton(value=False, description='Map words', tooltip='Substitute words', icon='check'), include_pos=widgets.SelectMultiple( options=pos_options, value=default_include_pos, rows=7, layout=widgets.Layout(width='60px', **item_layout)), stop_words=widgets.SelectMultiple( options=frequent_words, value=list([]), rows=7, layout=widgets.Layout(width='120px', **item_layout)), ) boxes = [ widgets.VBox([ gui.min_freq, gui.max_doc_freq, gui.normalize, gui.ngrams, ]), widgets.VBox( [gui.filter_stops, gui.named_entities, gui.substitute_terms], layout=widgets.Layout(margin='0px 0px 0px 10px')), widgets.HBox([ widgets.Label(value='POS', layout=widgets.Layout( width='40px')), gui.include_pos ], layout=widgets.Layout(margin='0px 0px 0px 10px')), widgets.HBox([widgets.Label(value='STOP'), gui.stop_words], layout=widgets.Layout(margin='0px 0px 0px 10px')) ] return gui, boxes
def ParseResponseJSON(self): self.ResponseData = json.loads( self.ResponseText, object_hook=lambda d: types.SimpleNamespace(**d))
def ensure_directories(self, env_dir): """ Create the directories for the environment. Returns a context object which holds paths in the environment, for use by subsequent logic. """ def create_if_needed(d): if not os.path.exists(d): os.makedirs(d) elif os.path.islink(d) or os.path.isfile(d): raise ValueError('Unable to create directory %r' % d) if os.path.exists(env_dir) and self.clear: self.clear_directory(env_dir) context = types.SimpleNamespace() context.env_dir = env_dir context.env_name = os.path.split(env_dir)[1] prompt = self.prompt if self.prompt is not None else context.env_name context.prompt = '(%s) ' % prompt create_if_needed(env_dir) env = os.environ executable = getattr(sys, '_base_executable', sys.executable) dirname, exename = os.path.split(os.path.abspath(executable)) context.executable = executable context.python_dir = dirname context.python_exe = exename if sys.platform == 'win32': binname = 'Scripts' incpath = 'Include' libpath = os.path.join(env_dir, 'Lib', 'site-packages') else: binname = 'bin' incpath = 'include' libpath = os.path.join(env_dir, 'lib', 'python%d.%d' % sys.version_info[:2], 'site-packages') # Truffle change: our executable may not just be a file (e.g. we're # running through java), we always provide a script for launching in # venv exename = context.python_exe = "graalpython" import atexit, tempfile tempdir = tempfile.mkdtemp() script = os.path.join(tempdir, "graalpython") if sys.platform == 'win32': script += ".bat" with open(script, "w") as f: if sys.platform != "win32": f.write("#!/bin/sh\n") f.write(sys.executable) f.write( " --python.CoreHome='%s' --python.StdLibHome='%s' --python.SysPrefix='%s' --python.SysBasePrefix='%s' --python.Executable='%s'" % ( sys.graal_python_core_home, sys.graal_python_stdlib_home, context.env_dir, sys.base_prefix, os.path.join(context.env_dir, binname, exename), )) if sys.platform == "win32": f.write(" %*") else: f.write(" \"$@\"") if sys.platform != "win32": os.chmod(script, 0o777) atexit.register(lambda: shutil.rmtree(tempdir, ignore_errors=True)) dirname = context.python_dir = sys.graal_python_home context.executable = script if self.symlinks: logger.warning("We're not using symlinks in a Graal Python venv") self.symlinks = False # End of Truffle change context.inc_path = path = os.path.join(env_dir, incpath) create_if_needed(path) create_if_needed(libpath) # Issue 21197: create lib64 as a symlink to lib on 64-bit non-OS X POSIX if ((sys.maxsize > 2**32) and (os.name == 'posix') and (sys.platform != 'darwin')): link_path = os.path.join(env_dir, 'lib64') if not os.path.exists(link_path): # Issue #21643 os.symlink('lib', link_path) context.bin_path = binpath = os.path.join(env_dir, binname) context.bin_name = binname context.env_exe = os.path.join(binpath, exename) create_if_needed(binpath) return context
# Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. import os import types script = types.SimpleNamespace() script.random = script_cpp.random script.wait = script_cpp.wait script.time = script_cpp.time script.timer = script_cpp.timer script.system = script_cpp.system script.writeToFile = script_cpp.writeToFile script.writeData = script_cpp.writeData script.readAll = script_cpp.readAll script.removeFile = script_cpp.removeFile script.run = script_cpp.run script.quit = script_cpp.quit script.reset = script_cpp.reset script.getPhoto = script_cpp.getPhoto
"Parameter functions with array arguments: all the arguments must be arrays of the same shape." ) for k in args[1:]: if len(k) != len(args[0]): raise ValueError( "Parameter functions with array arguments: all the arguments must be arrays of the same shape." ) # apply func elementwise, recursively, on the args return np.array([wrapper(*k) for k in zip(*args)]) return func(*args) return wrapper par_funcs = types.SimpleNamespace( **{name: wrap_mathfunc(getattr(sf, name)) for name in dir(sf) if name[0] != "_"} ) """SimpleNamespace: Namespace of mathematical functions for manipulating Parameters. Consists of all :mod:`sympy.functions` public members, which we wrap with :func:`wrap_mathfunc`. """ class ParameterError(RuntimeError): """Exception raised when the Parameter classes encounter an illegal operation. E.g., trying to use a measurement result before it is available. """ def is_object_array(p): """Returns True iff p is an object array.