Source code for towhee.functional.option

# Copyright 2021 Zilliz. All rights reserved.
# 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
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import Callable, Generic
from typing import Any, TypeVar

A = TypeVar('A', covariant=True)
B = TypeVar('B')
T = TypeVar('T')

class _Reason:
    """The reason for the current value.

            x (Any): The value.
            e (Exception): The Exception that caused it.
    def __init__(self, x: Any, e: Exception) -> None:
        self._value = x
        self._exception = e

    def value(self):
        return self._value

    def exception(self):
        return self._exception

[docs]class Option(Generic[A]): """Functional-style error handling. Option[A] = Some(A) or Empty[A] 1. Some(A): just a container for result; 2. Empty[A]: result is empty, because of input error or computation error; Examples: >>> a = Some(10) >>> x: x/2.0) Some(5.0) >>> x: x/0) Empty() >>> b = Empty() >>> x: x/2.0) Empty() """
[docs] @staticmethod def of(x: T): """Return a boxed value. Args: x (T): The input value. Returns: Some(T): The boxed value. """ return Some(x)
[docs] @staticmethod def empty(): """Return an empty value. Returns: Empty: The empty value. """ return Empty()
[docs] def flat_map(self, f: Callable[[A], 'Option[B]']) -> 'Option[B]': """Apply boxed version of callable. Args: f (Callable[[A], Option[B]]): Boxed version of callable Returns: Option[B]: The boxed value. Examples: >>> Option.of(1).flat_map(lambda x: x+1) 2 >>> Option.empty().flat_map(lambda x: x+1) Empty() """ if isinstance(self, Some): return f(self._value) else: return self
[docs] def map(self, f: Callable[[A], 'B']) -> 'Option[B]': """Apply a function to a value. Args: f (Callable[[A], B]): A unboxed callable. Returns: Option[B]: The boxed return value. """ def wrapper(x): try: return Some(f(x)) except Exception as e: # pylint: disable=broad-except return Empty(x, e) return self.flat_map(wrapper)
[docs] def is_empty(self): """Return True if the value is empty. Returns: bool: True if empty. """ return isinstance(self, Empty)
[docs] def is_some(self): """Return True if the value is boxed value. Returns: bool: True if boxed. """ return isinstance(self, Some)
[docs] def get_or_else(self, default): """Return unboxed value, or default if the value is empty. Args: default (any): The default value to return. Returns: any: The unboxed value, or default if empty. Examples: >>> Option.of(0).get_or_else(1) 0 >>> Option.empty().get_or_else(1) 1 """ if self.is_some(): return self.get() return default
[docs]class Some(Option[A]): """`Some` value for `Option` """
[docs] def __init__(self, x: A) -> None: self._value = x
[docs] def __repr__(self) -> str: return 'Some({})'.format(self._value)
[docs] def flat_map(self, f: Callable[[A], 'Option[B]']) -> 'Option[B]': return f(self._value)
[docs] def get(self): """Return unboxed value """ return self._value
[docs]class Empty(Option[A]): """`Empty` value for `Option` Args: x (Any, optional): The value. Defaults to None. e (Exception, optional): The reasone for value. Defaults to None. """
[docs] def __init__(self, x: Any = None, e: Exception = None) -> None: self._reason = _Reason(x, e)
[docs] def __repr__(self) -> str: """The repr function that returns default 'Empty()'. Returns: str: Returns 'Empty()'. """ return 'Empty()'
[docs] def flat_map(self, f: Callable[[A], 'Option[B]']) -> 'Option[B]': return self
[docs] def get(self): """Return the reason of the empty value. Returns: _Reason: Reason for empty. """ return self._reason
empty = Empty()