def substitute(files: Files, path: Path, lnum: int, col: Either[str, int], error: str, coco_path: Path) -> Generator:
lines = yield files.lift(path).to_either('corrupt state')
line = yield lines.lift(lnum - 1).to_either(f'invalid line number {lnum} for {path}')
lnum_match = yield lnum_rex.search(line)
coco_lnum = yield lnum_match.group('lnum')
coco_lnum_i = yield parse_int(coco_lnum)
col_map = col / (lambda a: Map(col=a)) | Map()
yield Right(Map(lnum=coco_lnum_i, text=error, valid=1, maker_name='mypy') ** col_map)
def add_multi(self):
key = 'key'
val = 'value'
k2 = 'key2'
v2 = 'value2'
m = Map({key: val})
m2 = m**Map({k2: v2})
m2.lift(k2).should.equal(Just(v2))
m.lift(k2).should.equal(Empty())
def traverse(self) -> None:
def f(a: int) -> Either[str, int]:
return Right(a * 2)
Map({
1: 2,
3: 4
}).traverse(f, Either).should.equal(Right(Map({
1: 4,
3: 8
})))
def synth_method(name: str, params: List[Tuple[str, Type]], statements: List[str], _globals: dict) -> FunctionType:
id = f'synth_{name}__'
params_s = params.map2(lambda n, t: f'{n}: {typename(t)}').join_comma
param_globals = Map(params.map2(lambda n, t: (typename(t), t)))
globs = Map(_globals) ** param_globals
code = f'''\
def {name}(self, {params_s}) -> None:
{statements.indent(4).join_lines}
globals()['{id}'] = {name}
'''
exec(code, globs)
return globs.pop(id)
def decode_json_object(data: dict) -> Do:
m = Map(data)
tpe_s = yield m.lift(tpe_key).to_either(
f'no `{tpe_key}` attr in json object {m}')
tpe = yield Either.import_path(tpe_s)
dec = yield Decoder.e(tpe)
yield dec.decode(tpe, m)
def _instances(self):
from amino import Map
return Map({
Functor: MapFunctor(),
Traverse: MapTraverse(),
Monoid: MapMonoid(),
})
def purge(self, cmd):
days = cmd.args.head | 30
self.log.info('Deleting releases older than {} days'.format(days))
data = Map(self.client.put('release/purge', dict(days=days)))
return IO.pure(
purge_msg.format(data['monitors'], data['links'], data['releases'])
)
def is_handler(name: str, f: Callable) -> Do:
effective = getattr(f, '__do_original', f)
spec = yield Try(inspect.getfullargspec, effective).to_maybe
param_name = yield Lists.wrap(spec.args).lift(1)
param_type = yield Map(spec.annotations).lift(param_name)
yield (Just((normalize_type(param_type),
f)) if issubclass(param_type, alg) else Nothing)
def parse_magnet(magnet) -> Either[str, Magnet]:
pr = urlparse(magnet)
if pr.scheme == 'magnet':
q = Map(parse_qs(pr.query)).valmap(List.wrap)
name = q.get('dn') // _.head
return Right(Magnet(name, q))
else:
return Left('not a magnet')
def __new__(cls: type, name: str, bases: tuple, namespace: SimpleNamespace,
**kw) -> type:
fs = Map(namespace).lift(
'__init__') / inspect.getfullargspec / init_fields | Nil
inst = super().__new__(cls, name, bases, namespace, **kw)
if not (fs.empty and hasattr(inst, '_dat__fields_value')):
inst._dat__fields_value = fs
return inst
def copy(self, **kw: Any) -> Sub:
updates = Map(kw)
def update(f: Field) -> Any:
return updates.lift(f.name) | (lambda: getattr(self, f.name))
updated = self._dat__fields / update
return cast(Dat, type(self)(*updated))
def __new__(cls: type, name: str, bases: tuple, namespace: dict,
**kw) -> type:
fs = Map(namespace).lift(
'__init__') / inspect.getfullargspec / init_fields | Nil
inst = super().__new__(cls, name, bases, namespace, **kw)
if fs:
inst._dat__fields_value = fs
return inst
def substitute_lnums(self) -> None:
lines = List('sooo...In module imported from: asdf',
'amino/maybe.py:116:5: error: broken',
'foo/bar/__coconut__.py:22: error: nutt')
return
process_output(lines).should.equal(
List(Map(lnum=82, text='broken', valid=1, maker_name='mypy',
col=5)))
def _instances(self):
from amino import Map
return Map({
Monad: MaybeMonad(),
Optional: MaybeOptional(),
Traverse: MaybeTraverse(),
Foldable: MaybeFoldable(),
Zip: MaybeZip(),
})
def keymap(self):
k1 = 'key'
v1 = 'value'
k2 = 'key2'
v2 = 'value2'
m = Map({k1: v1, k2: v2})
res = m.keymap(lambda a: len(a))
res.should.have.key(len(k1)).being.equal(v1)
res.should.have.key(len(k2)).being.equal(v2)
def add(self):
key = 'key'
val = 'value'
k2 = 'key2'
v2 = 'value2'
m = Map({key: val})
m2 = m + (k2, v2)
m2.lift(k2).should.equal(Just(v2))
m.lift(k2).should.equal(Empty())
def init_fields(spec: inspect.FullArgSpec) -> List[Field]:
args = Lists.wrap(spec.args).tail | Nil
types = Map(spec.annotations)
def field(name: str) -> Field:
tpe = types.lift(name) | Val(Any)
return Field(name, tpe)
return args / field
def parse(torr):
td = Map(torr)
name = '{} {}'.format(title_long, td.get('quality') | '')
size = td.get('size_bytes') | 0
size_str = sizeof_fmt(str(size))
seeds = td.get('seeds') | 0
hsh = td.get('hash') | 'no_hash'
magnet_link = yify_magnet(title, hsh)
return SearchResult(name, size, size_str, seeds, magnet_link)
def _search_yify(self):
query = ' '.join(self.args)
response = requests.get(yify_url,
params=dict(query_term=query,
limit=self._limit))
data = Map(response.json())
results = ((data.get('data') / Map // __.get('movies') / List.wrap /
__.flat_map(SearchResultFactory.from_yify)) | List())
return self._handle_results(query, results)
def _instances(self):
from amino import Map
return Map({
Monad: ListMonad(),
Traverse: ListTraverse(),
Foldable: ListFoldable(),
Zip: ListZip(),
Monoid: ListMonoid(),
})
def single_venv_config(name: str, spec: str,
**extra_vars: Any) -> Tuple[Rplugin, Venv, TestConfig]:
rplugin = simple_rplugin(name, spec)
dir = temp_dir('rplugin', 'venv')
vars = Map(chromatin_venv_dir=str(dir))**Map(extra_vars)
conf = lens.basic.state_ctor.set(LogBufferEnv.cons)(chromatin_config)
venv = Venv(
rplugin.name,
VenvMeta(name, dir / name, Right(Path('/dev/null')),
Right(Path('/dev/null'))))
return rplugin, venv, TestConfig.cons(
conf,
vars=vars,
io_interpreter=single_venv_io_interpreter(venv),
logger=buffering_logger,
function_handler=test_function_handler(exists=1),
command_handler=test_command_handler(),
)
def traverse(self, fa: Map[Any, A], f: Callable[[A], B],
tpe: Type[G]) -> G:
monad = Monad.fatal(tpe)
def folder(z, kv: Tuple[A, B]):
k, v = kv
return monad.map2(z.product(f(v)), lambda l, b: l.cat((k, b)))
return fa.to_list.fold_left(monad.pure(Map()))(folder)
def flat_map(self):
k1 = 'key'
v1 = 'value'
k2 = 'key2'
v2 = 'value2'
m = Map({k1: v1, k2: v2})
res = m.flat_map(lambda a, b: Just((a, b)) if a == k1 else Empty())
res.should.have.key(k1).being.equal(v1)
res.should_not.have.key(k2)
def to_json(a: Any) -> Json:
return (
JsonArray(Lists.wrap(a) / to_json)
if isinstance(a, (list, tuple)) else
JsonObject(Map(a).valmap(to_json))
if isinstance(a, dict) else
JsonNull(None)
if a is None else
JsonScalar(a)
)
def init_fields(init: FunctionType, globalns: dict) -> List[Field]:
spec = inspect.getfullargspec(init)
args = Lists.wrap(spec.args).tail | Nil
types = Map(get_type_hints(init))
def field(name: str) -> Field:
tpe = types.lift(name) | Val(Any)
return Field(name, tpe)
return args / field
def find(self):
k1 = 'key'
v1 = 'value'
k2 = 'key2'
v2 = 'value2'
m = Map({k1: v1, k2: v2})
m.find(_ == v1).should.equal(Just((k1, v1)))
m.find_key(_ == k2).should.equal(Just((k2, v2)))
m.find(_ == 'invalid').should.equal(Empty())
m.find_key(_ == 'invalid').should.equal(Empty())
def cons() -> 'LogBufferEnv':
return LogBufferEnv(Nil,
Nothing,
Nothing,
Nil,
Nil,
Nil,
Nil,
Map(),
Nil,
log_buffer=Nil)
def __new__(cls: type, name: str, bases: tuple, namespace: SimpleNamespace,
**kw) -> type:
mod = inspect.currentframe()
caller = mod.f_back
globalns = caller.f_globals
fs = Map(namespace).lift('__init__') / (
lambda a: init_fields(a, globalns)) | Nil
inst = super().__new__(cls, name, bases, namespace, **kw)
if not (fs.empty and hasattr(inst, '_dat__fields_value')):
inst._dat__fields_value = fs
return inst
def info(self):
return Map(
url=self.url,
status=self.status,
dead=self.dead,
multipart=self.multipart,
time_checked=self.time_checked,
checking=self.checking,
size=self.size,
reason=self.reason,
)
def is_handler(name: str, f: Callable) -> Do:
effective = getattr(f, '__do_original', f)
hints = yield Try(get_type_hints, effective).to_maybe
spec = yield Try(inspect.getfullargspec, effective).to_maybe
param_name = yield Lists.wrap(spec.args).lift(1)
param_type = yield Map(hints).lift(param_name)
yield (Just(
(normalize_type(param_type), f)) if isinstance(param_type, type)
and issubclass(param_type, alg) else Just(
(normalize_type(param_type),
f)) if isinstance(param_type, _GenericAlias)
and issubclass(param_type.__origin__, alg) else Nothing)
