def build_this_crazy_context_manager_(): # NOTE We want to move this to the "curses adapter" sibling module soon # (this is like the `curses.wrapper` but ..) stack, self = _build_this_crazy_stack() from contextlib import contextmanager as cm @cm def cm(): undo_stack = [] try: while stack: item = stack.pop() item.do() # Don't add `undo` until after the `do` completes successfully undo_stack.append(item.undo) yield self finally: while undo_stack: undo_stack.pop()() return cm()
def populate(): print "Getting the list of all packages." client = xmlrpclib.ServerProxy('http://pypi.python.org/pypi') packages = client.list_packages() print "Ridiculous! Found %i packages." % len(packages) print "Ingesting %i packages." % len(packages) with cm(shelve.open(fname, writeback=True)) as d: d['packages'] = d.get('packages', {}) for package in packages: if package not in d['packages']: result = ingest_package(package) try: requires = dependencies.get_dependencies(result['name']) print result['name'], "depends on %r" % requires except Exception as e: print str(e) continue d['packages'][result['name']] = result d['packages'][result['name']]['dependencies'] = requires d.sync() else: print "Skipping ", package print "Complete!"
def open_traverse_identifiers_via_two_opener(twoer): from contextlib import contextmanager as cm @cm def cm(): with twoer() as (sch, ents): yield (ent.identifier for ent in ents) return cm()
def main(): print "Scraping pypi..." populate() print "Complete!" with cm(shelve.open(fname)) as d: ostensibly_in_py3 = filter(is_python3, d['packages'].values()) ostensibly_not_in_py3 = filter( lambda p: not is_python3(p), d['packages'].values() ) print "In py3:", len(ostensibly_in_py3) print "Not in py3:", len(ostensibly_not_in_py3)
def func(listener, port): from contextlib import contextmanager as cm from microservice_lib.tcp_ip_client import \ open_dictionary_based_tcp_ip_client_via as func opened = func(listener, port) @cm # idk def cm(): with opened as impl: yield _Client(impl) return cm()
def open_schema_and_entity_traversal(listener): # (There are never files to close. there are no resources to manage from contextlib import contextmanager as cm @cm def cm(): yield None, each_entity() # .. def each_entity(): return (e for fr in to_FRs(listener) for e in fr.to_entities()) return cm()
def _open_classified_row_ASTs_via_issues_collection(ic): from contextlib import contextmanager as cm @cm def cm(): with ic.open_schema_and_issue_traversal() as (schema, ents): # Maybe the readme file doesn't begin its parse OK if ents is None: yield None return ks = schema.field_name_keys[1:] del schema yield _classified_row_ASTs_via_issues_collection(ks, ents) return cm()
def do_open_etc(listener): from contextlib import contextmanager as cm @cm def cm(): with coll.open_schema_and_RAW_entity_traversal(listener) as (sch, enx): # noqa: E501 if enx is None: return body_ks = sch.field_name_keys[1:] if fixed_for_now != body_ks: reason = f"expected {fixed_for_now!r} had {body_ks!r}" raise RuntimeError(reason) yield sch, enx return cm()
def sync_agent_builder_(opener, ST_doc_scn_via_lines): def do_open_sync_session(): from contextlib import contextmanager as cm @cm def cm(): if (opened := opener()) is None: yield None return with opened as fh: def ST_doc_scn_via_listener(listener): return ST_doc_scn_via_lines(fh, listener) yield sync_agent_(ST_doc_scn_via_listener, fh.name) return cm()
class directory_via_path: """Imagine that it's itself stateless, just a wrapper around the filesystem whose state determines its state, and also it exposes functions to mutate the filesystem and (in effect) move us through our states. (In practice we are seeing if we can avoid redudant filesystem hits while avoiding the pitfalls of caching:..) """ def __init__(self, path, injected_functions=None, filesystem=None): self.path = path self.injected_functions = injected_functions self._injected_filesystem = filesystem self._d = None def create_directory(self, listener): return self.EXECUTE_COMMAND('create_directory', listener) # == Hook-in to component API def EXECUTE_COMMAND(self, cmd, listener, stylesheet=None): from pho.config_component_ import execute_command_ as func with self._open_cache_session(): return func(self, cmd, listener, stylesheet) def to_additional_commands_(self): for k in self._state.transition_names: yield k, lambda kw: self._execute_action(**kw) def _execute_action(self, command_name, rest, stylesheet, listener): tr = self._state[command_name] args = () if rest is None else (rest, ) # idk func = getattr(self, tr.action_function_name) return func(listener, *args) # == Mutates filesystem def _create_directory(self, listener): self._clear_cache_early() pretend = ''.join(('mkdir ', self.path)) listener('info', 'expression', 'executing_system_command', lambda: (pretend, )) # noqa: E501 self._filesystem.mkdir(self.path) # result is none return 0 # == Read-only and derivations def _list_directory(self, listener): tup = self._cached('listdir_tuple') if len(tup): listener('output', 'expression', lambda: tup) else: msg = f'(empty directory: {self.path})' listener('info', 'expression', 'dir_is_empty', lambda: (msg, )) return 0 @_result_is_output_lines def execute_show_(self, ss, listener): with self._open_cache_session(): for line in self._do_execute_show(ss, listener): yield line def _do_execute_show(self, ss, listener): yield '(intermediate directory):' yield f' path: {self.path!r}' yield f' status: {self._status}' @property def _state(self): return self._FFSA[self._status] @property def status(self): with self._open_cache_session(): return self._status @property def _status(self): return self._cached('status_symbol') # == BEGIN cache yikes def _cached(self, k): cache = self._d assert cache is not None if len(cache): return cache[k] # VERY experimental # Experimental: do this whole cached "performance" all in once place status_symbol = self._hit_filesystem_for_initial_status_symbol() if 'exists_and_is_directory' == status_symbol: func = self._filesystem.listdir entries = tuple(func(self.path)) cache['listdir_tuple'] = entries status_symbol = 'non_empty_directory' if len( entries) else 'empty_directory' # noqa: E501 cache['status_symbol'] = status_symbol return cache[k] def _clear_cache_early(self): self._d.clear() def _hit_filesystem_for_initial_status_symbol(self): os_stat_mode = self._filesystem.os_stat_mode try: mode = os_stat_mode(self.path) except FileNotFoundError: return 'noent' from stat import S_ISDIR as is_directory if is_directory(mode): return 'exists_and_is_directory' return 'exists_and_is_not_directory' def _open_cache_session(self): # produce the context manger within which you can use the cache from contextlib import nullcontext, contextmanager as cm # If you are already in the middle of using your cache, do nothing if self._d is not None: return nullcontext() # Since you haven't started your cache yet, create it then destroy @cm def cm(): try: yield finally: if (dct := self._d) is None: # idk return dct.clear() # OCD self._d = None self._d = {} return cm()