def test_picking_a_property_is_deferred(): Person = namedtuple('Person', ['age']) pipe = Pype((Person(n) for n in _123)) pipe.pick(Person.age) assert tuple(pipe) == (Person(1), Person(2), Person(3))
def pype(self: DefDyct[K, V]) -> Pype[Tuple[K, V]]: """ Return this ``DefDyct``-'s items as a ``Pype`` :return: ``Pype`` containing pairs of key, values """ return Pype(self.items())
def pype(self: CountDyct[K]) -> Pype[Tuple[K, int]]: """ Return this ``CountDyct``-'s items as a ``Pype`` :return: ``Pype`` containing pairs of key, count """ return Pype(item for item in self.items())
def json(src: Union[AnyStr, PathLike, int], *, mode: str = 'r', cls: Optional[Type] = None, object_hook: Optional[Fn] = None, parse_float: Optional[Fn] = None, parse_int: Optional[Fn] = None, parse_constant: Optional[Fn] = None, object_pairs_hook: Optional[Fn] = None) -> Pype[Union[Tuple[str, Any], None, bool, float, int, str]]: """ Reads content in given json into a pipe. >>> from pypey import pype >>> from os.path import join, dirname >>> dict(pype.json(join(dirname(__file__), 'unittests', 'object.json'))) {'a': 1.0, 'fun': 2.0, 'day': 3.0} :param src: path to the file or file descriptor, as per built-in ``open`` ``file`` argument :param mode: mode as per built-in ``open``, except no write modes are allowed :param cls: custom JSONDecoder class, as per ``json.load`` :param object_hook: object_hook ``Callable``, as per ``json.load`` :param parse_float: parse_float ``Callable``, as per ``json.load`` :param parse_int: parse_int ``Callable``, as per ``json.load`` :param parse_constant: parse_constance ``Callable``, as per ``json.load`` :param object_pairs_hook: object_pairs_hook ``Callable``, as per ``json.load`` :return: pype with single item if json contains a single value, several items if json contains a list and pairs of items if json contains object """ require_val('w' not in mode and '+' not in mode and 'a' not in mode, f'mode cannot be write or append but was [{mode}]') with open(src, mode=mode) as json_file: value = built_in_json.load(json_file, cls=cls, object_hook=object_hook, parse_float=parse_float, parse_int=parse_int, parse_constant=parse_constant, object_pairs_hook=object_pairs_hook) if isinstance(value, List): return Pype(value) if isinstance(value, Dict): return Pype(value.items()) return Pype((value,))
def dict(dictionary: Mapping[K, V]) -> Pype[Tuple[K, V]]: """ Returns a pipe where each item is a key-value pair in the given ``Mapping``. >>> from pypey import pype list(pype.dict({'fun':1, 'day':2})) [('fun', 1), ('day', 2)] :param dictionary: the dictionary to pipe :return: a pipe containing the dictionary's items :raises: ``TypeError`` if dictionary is not a ``Mapping`` """ require(isinstance(dictionary, abc.Mapping), f'argument should be dict-like but was [{dictionary}]') return Pype(dictionary.items())
def __call__(self, iterable: Iterable[T]) -> Pype[T]: """ Creates a ``Pype`` with the given backing ``Iterable``. :param iterable: backing ``Iterable`` for this `Pype`` :return: a new `Pype`` backed by the given ``Iterable`` :raises ``TypeError`` if ``iterable`` is not an ``Iterable`` """ try: iter(iterable) return Pype(iterable) except TypeError: raise
def file(src: Union[AnyStr, PathLike, int], *, mode: str = 'r', buffering: int = -1, encoding: Optional[str] = 'utf8', errors: Optional[str] = None, newline: Optional[str] = None, closefd: bool = True, opener: Optional[Fn[..., int]] = None, strip: bool = True) -> Pype[str]: """ Reads lines from given file into a pipe. >>> from pypey import pype >>> from os.path import join, dirname >>> list(pype.file(join(dirname(__file__), 'unittests', 'test_file.txt'))) ['line 1', 'line 2', 'line 3'] :param src: path to the file or file descriptor, as per built-in ``open`` ``file`` argument :param mode: mode as per built-in ``open``, except no write modes are allowed :param buffering: buffering as per built-in ``open`` :param encoding: encoding as per built-in ``open`` except the default value is ``utf8`` instead of ``None`` :param errors: errors as per built-in ``open`` :param newline: newline as per built-in ``open`` :param closefd: closefd as per built-in ``open`` :param opener: opener as per built-in ``open`` :param strip: ``True`` if end of line should be removed from each line, ``False`` otherwise :return: a pipe where each item is a line in the given file :raises: ``ValueError`` if ``mode`` has ``w`` (write) or ``+`` (append) in it """ require_val('w' not in mode and '+' not in mode and 'a' not in mode, f'mode cannot be write or append but was [{mode}]') return Pype( _lines_from(src, strip, mode=mode, buffering=buffering, encoding=encoding, errors=errors, newline=newline, closefd=closefd, opener=opener))
def test_writing_to_json_file_consumes_pipe(tmpdir): pipe = Pype((k, v) for k, v in [('a', 1), ('fun', 2), ('day', 3)]) pipe = pipe.to_json(join(tmpdir, 'object.json')) assert tuple(pipe) == ()
def test_picking_a_key_is_deferred(): pipe = Pype(str(n) for n in _123) pipe.pick(0) assert tuple(pipe) == ('1', '2', '3')