def _generic_command(sin, sout, serr, argv, efx):
"""
The associated path is a directory of files in some obvious order.
Under the hood; we create a temporary directory, init it as a git
repository, add the first file snapshot, commit it, copy the second
file snapshot over to the file, add it, commit it and so on until
all the snapshots have been written in to the repository.
There will be tons of other metadata stored in a recfile probably.
The end result is we write to STDOUT the results of going `git log`
(with particular options stored in the parameters recfile probably)
on the respository.
"""
bash_argv = list(reversed(argv))
prog_name = bash_argv.pop()
foz = _foz_via(_formals_for_generic_command(), lambda: prog_name)
vals, rc = foz.terminal_parse(serr, bash_argv)
if vals is None:
return None, rc
if vals.get('help'):
return foz.write_help_into(sout, _generic_command.__doc__)
source_path = efx['fixture_source_path']
from script_lib.magnetics.error_monitor_via_stderr import func
mon = func(serr)
from . import real_system_response_via_story_source_path_ as func
lines = func(source_path, mon.listener)
sout.writelines(lines)
return mon.returncode
def _common_execute(serr, argv, efx, doc, formals, functioner):
bash_argv = list(reversed(argv))
long_prog_name = bash_argv.pop()
prog_name = _prog_name_function_via(long_prog_name)
foz = _foz_via(formals, prog_name)
vals, es = foz.terminal_parse(serr, bash_argv)
if vals is None:
return es
if vals.get('help'):
serr.writelines(foz.help_lines(doc=doc))
return 0
mon = efx.produce_monitor()
listener = mon.listener
coll_path, rc = efx.require_collection_path(listener, vals)
if not coll_path:
return rc
func = functioner()
res = func(coll_path, listener=listener, **vals)
assert res is None
return mon.returncode
def query_parser():
from .tagging_subtree_via_string import grammar_path_ as func
_grammar_path = func('the-query-grammar.ebnf')
with open(_grammar_path) as fh:
ebnf_grammar_big_string = fh.read()
import tatsu
return tatsu.compile(ebnf_grammar_big_string, asmodel=True)
def EXPERIMENTAL_NEW_WAY(tokens, listener):
""" 33 months later we think we can do better than tatsu
for our use case anyway. #history-B.4
"""
sx = _recursive_sexp_via(tokens, listener)
if sx is None:
return
from tag_lyfe.the_query_model import simplified_matcher_via_sexp_ as func
return func(sx)
def _execute_command_now__no_daemonize(sout, serr, cmd, config, mon):
if config is None:
serr.write("-c option needs a <config-path> argument\n")
return 123
def recv_output_line(line):
sout.write(line)
sout.write('\n')
from pho.config_component_ import capture_output_lines_ as func
listener = func(recv_output_line, mon.listener)
rc = config.EXECUTE_COMMAND(cmd, listener)
if not isinstance(rc, int): # #todo
raise RuntimeError(f"oops: {type(rc)}")
return rc
def RUMSKALLA(serr, query_s):
def my_pprint(x):
from pprint import pprint
pprint(x, stream=serr, width=20, indent=4)
itr = MAKE_CRAZY_ITERATOR_THING(query_s)
print('the model:')
my_pprint(next(itr))
print('the unsani:')
unsani = next(itr)
from script_lib.magnetics.error_monitor_via_stderr import func
monitor = func(serr)
wat = unsani.sanitize(monitor.listener)
print('the sani:')
my_pprint(wat)
return monitor.exitstatus
def _build_simplified_tag_parser_and_stop(cstacker, listener):
# EXPERIMENTAL does check only for now
def parse_tag(token):
try:
return main(token)
except stop:
pass
def main(token):
scn = build_string_scanner(token)
scn.skip_required(leading_octothorpe)
scn.skip_required(tag_body)
scn.skip_required(the_end)
from text_lib.magnetics.string_scanner_via_string import \
build_throwing_string_scanner_and_friends as func
o, build_string_scanner, stop = func(listener, cstacker)
leading_octothorpe = o("'#'", '#')
tag_body = o('tag body ([-a-z]..)', '[a-z]+(?:-[a-z]+)*')
the_end = o('end of tag', r'\Z')
return parse_tag, stop
def _load_commonly(mod_tail):
from importlib import import_module as func
return func(f'pho.cli.commands.{mod_tail}').CLI
def _foz_via(defs, pner, x=None):
from script_lib.cheap_arg_parse import formals_via_definitions as func
return func(defs, pner, x)
def _cheap_arg_parse_branch(sin, sout, serr, argv, cx, doc, efx):
from script_lib.cheap_arg_parse import cheap_arg_parse_branch as func
return func(sin, sout, serr, argv, cx, doc, efx)
def produce_monitor(_):
from script_lib.magnetics.error_monitor_via_stderr import func
return func(stderr, default_error_exitstatus=5678)
def _load_the_connect_COMMAND():
from pho.cli.commands.connect import build_CLI_command_ as func
return func(_port, _foz_via)
def _CLI(sin, sout, serr, argv, efx): # efx = external functions
def line_contents():
yield 'experiments in generating documents from "notecards"'
func = _cheap_arg_parse_branch
return func(sin, sout, serr, argv, _commands(), line_contents, efx)
config_path = vals.pop('config_path', None)
cmd = vals.pop('command', None)
port = vals.pop('port')
assert not vals
kw = {}
mon = efx.produce_monitor()
# Process the config option if it was passed (processing it can fail)
config = None
if config_path:
use_environ = efx.produce_environ()
from pho.generation_service_.generation_config_via_definition import \
via_path as func
config = func(config_path, use_environ, mon.listener)
if config is None:
return mon.returncode
kw['config'] = config
# The --command option requires a config
if cmd:
return _execute_command_now__no_daemonize(sout, serr, cmd, config, mon)
from pho.generation_service_.run_message_broker_via_config import func
func(mon.listener, port, **kw) # run forever or until interrupt
return mon.returncode
