pythonic-fp-booleans 1.1.2__tar.gz → 2.0.0__tar.gz

pythonic_fp_booleans-2.0.0/CHANGELOG.rst

@@ -0,0 +1,76 @@
+CHANGELOG
+=========
+
+PyPI pythonic-fp-booleans project.
+
+Semantic Versioning
+-------------------
+
+Strict 3 digit semantic versioning adopted 2025-05-19.
+
+- **MAJOR** version incremented for incompatible API changes
+- **MINOR** version incremented for backward compatible added functionality
+- **PATCH** version incremented for backward compatible bug fixes
+
+See `Semantic Versioning 2.0.0 <https://semver.org>`_.
+
+Releases and Important Milestones
+---------------------------------
+
+PyPI 2.0.0 - 2025-09-27
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Released to get the next consistent set of Pythonic FP out (v3.2.0) out.
+
+- PyPI documentation link now goes to root, not releases
+- decided to flatten directory structure
+
+  - makes more sense from an end user perspective
+  - will help Sphinx docs be more homogeneous across repos
+
+Warning: API not fully locked down, major version number change may be needed.
+
+TODO:
+
+- bitwise operators not symmetric when used with ``SBool`` types and ``int`` or ``bool``
+
+  - may need to define reversed bit-wise operators
+
+- ``TS_Boolean`` has a code smell to it
+
+  - may be just a hack to get get around sub-optimal type usage
+  - Using ``TS_Bool`` as a variable type may be enough 
+
+PyPI 1.1.2 - 2025-09-09
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Fixed pyproject.toml dependency issues.
+
+PyPI 1.1.1 - 2025-09-03
+~~~~~~~~~~~~~~~~~~~~~~~
+
+Only change was to give README.rst a final edit. Missed this on
+the v1.1.0 release.
+
+
+PyPI 1.1.0 - 2025-09-02
+~~~~~~~~~~~~~~~~~~~~~~~
+
+First PyPI release as pythonic-fp-booleans.
+
+- module booleans.subtypable
+- package booleans.subtypes
+
+  - module booleans.subtypes.flavored
+  - module booleans.subtypes.truthy_falsy
+
+Needs
+
+-  "pythonic-fp>=3.0.0" for gadgets
+-  "pythonic-fp-sentinels>=2.1.0",
+
+Created pythonic-fp-boolean repo - 2025-08-06
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+- created grscheller/pythonic-fp-boolean GitHub repo
+- moved pythonic_fp.singletons.sbool to pythonic_fp.booleans.sbool

{pythonic_fp_booleans-1.1.2 → pythonic_fp_booleans-2.0.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: pythonic-fp-booleans
-Version: 1.1.2
-Summary: Subtypable Boolean like classes
+Version: 2.0.0
+Summary: Subtypable Boolean Class Hierarchy
 Keywords: booleans,subtypable
 Author-email: "Geoffrey R. Scheller" <geoffrey@scheller.com>
 Requires-Python: >=3.13
 Description-Content-Type: text/x-rst
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Framework :: Pytest
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
@@ -14,12 +14,11 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Typing :: Typed
 License-File: LICENSE
-Requires-Dist: pythonic-fp-gadgets>=3.0.0
-Requires-Dist: pythonic-fp-sentinels>=2.1.0
+Requires-Dist: pythonic-fp-gadgets>=3.1.0
 Requires-Dist: pytest>=8.4.1 ; extra == "test"
 Project-URL: Changelog, https://github.com/grscheller/pythonic-fp-booleans/blob/main/CHANGELOG.rst
-Project-URL: Documentation, https://grscheller.github.io/pythonic-fp/booleans/development/build/html/releases.html
-Project-URL: Homepage, https://github.com/grscheller/pythonic-fp/blob/main/README.md
+Project-URL: Documentation, https://grscheller.github.io/pythonic-fp/booleans/development/build/html/
+Project-URL: Homepage, https://grscheller.github.io/pythonic-fp/homepage/build/html/
 Project-URL: Source, https://github.com/grscheller/pythonic-fp-booleans
 Provides-Extra: test
 
@@ -35,9 +34,10 @@ Subtypable Boolean like classes.
 While still compatible with Python shortcut logic, these classes can be non-shortcut logically
 composed with Python’s bitwise operators.
 
-This PyPI project is part of of the grscheller
-`pythonic-fp namespace projects
-<https://github.com/grscheller/pythonic-fp/blob/main/README.md>`_
+Part of the
+`pythonic-fp
+<https://grscheller.github.io/pythonic-fp/homepage/build/html/index.html>`_
+PyPI projects.
 
 Documentation
 -------------

{pythonic_fp_booleans-1.1.2 → pythonic_fp_booleans-2.0.0}/README.rst

@@ -10,9 +10,10 @@ Subtypable Boolean like classes.
 While still compatible with Python shortcut logic, these classes can be non-shortcut logically
 composed with Python’s bitwise operators.
 
-This PyPI project is part of of the grscheller
-`pythonic-fp namespace projects
-<https://github.com/grscheller/pythonic-fp/blob/main/README.md>`_
+Part of the
+`pythonic-fp
+<https://grscheller.github.io/pythonic-fp/homepage/build/html/index.html>`_
+PyPI projects.
 
 Documentation
 -------------

{pythonic_fp_booleans-1.1.2 → pythonic_fp_booleans-2.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pythonic-fp-booleans"
-version = "1.1.2"
+version = "2.0.0"
 readme = "README.rst"
 requires-python = ">=3.13"
 license = { file = "LICENSE" }
@@ -10,7 +10,7 @@ keywords = [
   "subtypable",
 ]
 classifiers = [
-  "Development Status :: 3 - Alpha",
+  "Development Status :: 4 - Beta",
   "Framework :: Pytest",
   "Intended Audience :: Developers",
   "License :: OSI Approved :: Apache Software License",
@@ -19,15 +19,14 @@ classifiers = [
   "Typing :: Typed",
 ]
 dependencies = [
-  "pythonic-fp-gadgets>=3.0.0",
-  "pythonic-fp-sentinels>=2.1.0",
+  "pythonic-fp-gadgets>=3.1.0",
 ]
 dynamic = ["description"]
 
 [project.urls]
 Changelog = "https://github.com/grscheller/pythonic-fp-booleans/blob/main/CHANGELOG.rst"
-Documentation = "https://grscheller.github.io/pythonic-fp/booleans/development/build/html/releases.html"
-Homepage = "https://github.com/grscheller/pythonic-fp/blob/main/README.md"
+Documentation = "https://grscheller.github.io/pythonic-fp/booleans/development/build/html/"
+Homepage = "https://grscheller.github.io/pythonic-fp/homepage/build/html/"
 Source = "https://github.com/grscheller/pythonic-fp-booleans"
 
 [project.optional-dependencies]

{pythonic_fp_booleans-1.1.2/src/pythonic_fp/booleans/subtypes → pythonic_fp_booleans-2.0.0/src/pythonic_fp/booleans}/__init__.py

@@ -13,23 +13,28 @@
 # limitations under the License.
 
 """
-Module subtypes
-===============
+Subtypable Boolean Class Hierarchy
+==================================
 
-Module flavored
----------------
+.. graphviz::
 
-- when different "flavors" of the truth matter
-- the constructor ``FBool(witness: object, flavor: Hashable)`` produces invariant types
+    digraph Booleans {
+        bgcolor="#957fb8";
+        node [style=filled, fillcolor="#181616", fontcolor="#dcd7ba"];
+        edge [color="#181616", fontcolor="#dcd7ba"];
+        int -> bool;
+        int -> SBool;
+        SBool -> "FBool(h1)";
+        SBool -> "FBool(h2)";
+        SBool -> "FBool(h3)";
+        SBool -> TF_Bool;
+        TF_Bool -> T_Bool;
+        TF_Bool -> F_Bool;
+    }
 
-Module truthy_falsy
--------------------
-
-- where truthy and falsy are typeable
-- class ``TF_Bool`` consists of two disjoint subclasses
-
-  - ``T_Bool`` instances are always truthy
-  - ``F_Bool`` instances are always falsy
+While still compatible with Python shortcut logic, ``SBool`` and its
+subclasses can be non-shortcut logically composed with Python's bitwise
+operators.
 """
 
 __author__ = 'Geoffrey R. Scheller'

{pythonic_fp_booleans-1.1.2/src/pythonic_fp/booleans/subtypes → pythonic_fp_booleans-2.0.0/src/pythonic_fp/booleans}/flavored.py

@@ -12,42 +12,46 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
 """
-Flavored Booleans
-=================
+**Class F_Bool.**
+
+When different flavors of the truth matter. Each ``FBool`` is
+an ``SBool`` subtype corresponds to a hashable value
+called its flavor.
+
+.. warning::
+    
+    Combining ``FBool`` instances of different flavors
+    with bitwise operators will just result in an ``SBool``.
+
+----
+
+**Function truthy(flavor: Hashable)**
 
-When different flavors of the truth are needed. Each "flavor" is
-"indexed" by a hashable value, not "subtyped" by it.
+Returns the truthy ``FBool`` of a particular ``flavor``.
+
+----
+
+**Function falsy(flavor: Hashable)**
+
+Returns the falsy ``FBool`` of a particular ``flavor``.
 """
 
 import threading
 from collections.abc import Hashable
 from typing import ClassVar, final
-from ..subtypable import SBool
+from .subtypable import SBool
 
 __all__ = ['FBool', 'truthy', 'falsy']
 
 
 @final
 class FBool(SBool):
-    """
-    Flavored Boolean
-    ----------------
+    _falsy_dict: 'ClassVar[dict[Hashable, FBool]]' = {}
+    _falsy_dict_lock: ClassVar[threading.Lock] = threading.Lock()
 
-    When different flavors of the truth are needed. Each "flavor" is
-    "indexed" by a hashable value, not "subtyped" by it.
-
-    This type can also do (non-shortcut) Boolean logic using Python
-    bitwise operators. Combining ``FBool`` instances of different
-    flavors in this way will just result in an ``SBool``.
-    """
-
-    _truthy: 'ClassVar[dict[Hashable, FBool]]' = {}
-    _truthy_lock: ClassVar[threading.Lock] = threading.Lock()
-
-    _falsy: 'ClassVar[dict[Hashable, FBool]]' = {}
-    _falsy_lock: ClassVar[threading.Lock] = threading.Lock()
+    _truthy_dict: 'ClassVar[dict[Hashable, FBool]]' = {}
+    _truthy_dict_lock: ClassVar[threading.Lock] = threading.Lock()
 
     def __new__(cls, witness: object, flavor: Hashable) -> 'FBool':
         """
@@ -56,22 +60,21 @@ class FBool(SBool):
         :returns: The truthy or falsy ``FBool`` instance of a particular ``flavor``.
         """
         if witness:
-            if flavor not in cls._truthy:
+            if flavor not in cls._truthy_dict:
                 with cls._truthy_lock:
-                    if flavor not in cls._truthy:
-                        cls._truthy[flavor] = super(SBool, cls).__new__(cls, True)
-            return cls._truthy[flavor]
+                    if flavor not in cls._truthy_dict:
+                        cls._truthy_dict[flavor] = super(SBool, cls).__new__(cls, True)
+            return cls._truthy_dict[flavor]
         else:
-            if flavor not in cls._falsy:
-                with cls._falsy_lock:
-                    if flavor not in cls._falsy:
-                        cls._falsy[flavor] = super(SBool, cls).__new__(cls, False)
-            return cls._falsy[flavor]
+            if flavor not in cls._falsy_dict:
+                with cls._falsy_dict_lock:
+                    if flavor not in cls._falsy_dict:
+                        cls._falsy_dict[flavor] = super(SBool, cls).__new__(cls, False)
+            return cls._falsy_dict[flavor]
 
     def __init__(self, witness: object, flavor: Hashable) -> None:
         self._flavor = flavor
 
-    # override in derived classes
     def __repr__(self) -> str:
         if self:
             return f'FBool(True, {repr(self._flavor)})'
@@ -110,34 +113,23 @@ class FBool(SBool):
         return self ^ other
 
     def flavor(self) -> Hashable:
-        """t
+        """
         :returns: The flavor of the FBool.
-
         """
         return self._flavor
 
 
 def truthy(flavor: Hashable) -> FBool:
     """
-    Get truthy FBool
-    ----------------
-
-    Get the truthy ``FBool`` of a particular ``flavor``.
-
     :param flavor: Hashable value to determine which singleton ``flavor`` to return.
-    :returns: The truthy singleton of a particular  ``flavor``.
+    :returns: The truthy singleton of a particular ``flavor``.
     """
     return FBool(True, flavor)
 
 
 def falsy(flavor: Hashable) -> FBool:
     """
-    Get falsy FBool
-    ---------------
-
-    Get the falsy ``FBool`` of a particular ``flavor``.
-
     :param flavor: Hashable value to determine which singleton ``flavor`` to return.
-    :returns: The falsy singleton of a particular  ``flavor``.
+    :returns: The falsy singleton of a particular ``flavor``.
     """
     return FBool(False, flavor)

{pythonic_fp_booleans-1.1.2 → pythonic_fp_booleans-2.0.0}/src/pythonic_fp/booleans/subtypable.py

@@ -12,14 +12,52 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+"""
+**Subtypable Boolean.**
 
-"""Subtypable Booleans."""
+Like Python's built in bool, class ``SBool`` is a subclass of int.
+Unlike bool, this version can be further subclassed.
+
+This type and its subtypes can also do (non-shortcut) Boolean logic
+using Python bitwise operators.
+
++-------------------+--------+------------+
+| Boolean operation | symbol | dunder     |
++===================+========+============+
+|       not         | ``~``  | __invert__ |
++-------------------+--------+------------+
+|       and         | ``&``  | __and__    |
++-------------------+--------+------------+
+|       or          | ``|``  | __or__     |
++-------------------+--------+------------+
+|       xor         | ``^``  | __xor__    |
++-------------------+--------+------------+
+
+.. note::
+
+    These operators are contravariant, that is they will return the
+    instance of the latest common ancestor of their arguments. More
+    specifically, the instance returned will have the type of the
+    least upper bound in the inheritance graph of the classes of
+    the two arguments.
+
+While compatible with Python  short-cut logic. Unfortunately, the
+``not`` operator always returns a ``bool``. Use the bitwise ``~``
+operator to return an opposite ``SBool`` class or subclass.
+
+.. warning::
+
+   The "bitwise" operators can raise ``TypeError`` exceptions
+   when applied against an ``SBool`` and objects not descended
+   from ``int``.
+
+"""
 
 import threading
 from collections.abc import Hashable
 from typing import cast, ClassVar, Final, overload
 from pythonic_fp.gadgets.latest_common_ancestor import lca
-from pythonic_fp.sentinels.novalue import NoValue
+from pythonic_fp.gadgets.sentinels.novalue import NoValue
 
 __all__ = ['SBool', 'TRUTH', 'LIE']
 
@@ -27,17 +65,6 @@ _novalue = NoValue()
 
 
 class SBool(int):
-    """Subtypable Booleans.
-
-    Like Python's built in bool, class SBool is a subclass of int.
-    Unlike bool, this version can be further subclassed. It can be
-    used with Python ``and`` and ``or`` short-cut logic. The ``not``
-    operator will just return a ``bool``. Use the ``snot`` function
-    to return an ``SBool`` or ``SBool`` subclass.
-
-    This type and its subtypes can also do (non-shortcut) Boolean logic
-    using Python bitwise operators.
-    """
     _falsy: 'ClassVar[SBool | NoValue]' = _novalue
     _falsy_lock: ClassVar[threading.Lock] = threading.Lock()
 
@@ -88,9 +115,7 @@ class SBool(int):
             if type(other) is bool:
                 base_class = int
             else:
-                msg = (
-                    f"unsupported operand type(s) for &: '{type(self)}' and '{type(other)}'"
-                )
+                msg = f"unsupported operand type(s) for &: '{type(self)}' and '{type(other)}'"
                 raise TypeError(msg)
 
         if issubclass(base_class, SBool):
@@ -107,9 +132,7 @@ class SBool(int):
             if type(other) is bool:
                 base_class = int
             else:
-                msg = (
-                    f"unsupported operand type(s) for |: '{type(self)}' and '{type(other)}'"
-                )
+                msg = f"unsupported operand type(s) for |: '{type(self)}' and '{type(other)}'"
                 raise TypeError(msg)
 
         if issubclass(base_class, SBool):
@@ -126,9 +149,7 @@ class SBool(int):
             if type(other) is bool:
                 base_class = int
             else:
-                msg = (
-                    f"unsupported operand type(s) for ^: '{type(self)}' and '{type(other)}'"
-                )
+                msg = f"unsupported operand type(s) for ^: '{type(self)}' and '{type(other)}'"
                 raise TypeError(msg)
 
         if issubclass(base_class, SBool):

{pythonic_fp_booleans-1.1.2/src/pythonic_fp/booleans/subtypes → pythonic_fp_booleans-2.0.0/src/pythonic_fp/booleans}/truthy_falsy.py

@@ -12,19 +12,33 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
 """
-Truthy-Falsy Booleans
----------------------
+**Class TF_Bool**
+
+Subclass of ``SBool`` whose truthy values and falsy values are
+different distinct singleton subtypes.
+
+This type can also do (non-shortcut) Boolean logic using Python
+bitwise operators.
+
+----
 
+**Class T_Bool**
 
-Booleans whose "truthy" and "falsy" instances are distinct subtypes."""
+The subtype of ``TF_Bool`` which is always truthy.
+
+----
+
+**Class F_Bool**
+
+The subtype of ``TF_Bool`` which is always falsy.
+"""
 
 import threading
 from collections.abc import Hashable
 from typing import cast, ClassVar, Final, final
-from pythonic_fp.sentinels.novalue import NoValue
-from ..subtypable import SBool
+from pythonic_fp.gadgets.sentinels.novalue import NoValue
+from .subtypable import SBool
 
 __all__ = [
     'TF_Bool',
@@ -39,22 +53,11 @@ _novalue = NoValue()
 
 
 class TF_Bool(SBool):
-    """
-    Truthy-Falsy Boolean
-    --------------------
-
-    Subclass of ``SBool`` whose truthy values and falsy values are
-    different singleton subtypes.
-
-    This type can also do (non-shortcut) Boolean logic using Python
-    bitwise operators.
-    """
-
     def __new__(cls, witness: object, flavor: Hashable = NoValue()) -> 'TF_Bool':
         """
         :param witness: Determines which subtype, ``T_Bool`` or ``F_Bool`` is returned.
         :param flavor: Ignored parameter, only two flavors, one truthy and one falsy.
-        :returns: either The singleton truthy or singleton falsy subtypes.
+        :returns: Either The singleton truthy or singleton falsy subtypes.
         """
         if witness:
             return T_Bool()
@@ -94,13 +97,6 @@ class TF_Bool(SBool):
 
 @final
 class T_Bool(TF_Bool):
-    """
-    Truthy TF_Bool
-    --------------
-
-    The subtype of ``TF_Bool`` which is always truthy.
-    """
-
     _truthy: 'ClassVar[T_Bool | NoValue]' = _novalue
     _lock: ClassVar[threading.Lock] = threading.Lock()
 
@@ -126,13 +122,6 @@ class T_Bool(TF_Bool):
 
 @final
 class F_Bool(TF_Bool):
-    """
-    Falsy TF_Bool
-    -------------
-
-    The subtype of ``TF_Bool`` which is always falsy.
-    """
-
     _falsy: 'ClassVar[F_Bool | NoValue]' = _novalue
     _lock: ClassVar[threading.Lock] = threading.Lock()
 

{pythonic_fp_booleans-1.1.2 → pythonic_fp_booleans-2.0.0}/tests/test_bool_vs_fbool.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 from pythonic_fp.booleans.subtypable import SBool, TRUTH, LIE
-from pythonic_fp.booleans.subtypes.flavored import FBool, truthy, falsy
+from pythonic_fp.booleans.flavored import FBool, truthy, falsy
 
 class TestBooleanBehaviors():
     def test_bool(self) -> None:

{pythonic_fp_booleans-1.1.2 → pythonic_fp_booleans-2.0.0}/tests/test_flavored.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from pythonic_fp.booleans.subtypes.flavored import FBool, truthy, falsy
+from pythonic_fp.booleans.flavored import FBool, truthy, falsy
 from pythonic_fp.booleans.subtypable import TRUTH, LIE
 
 t0_1 = FBool(1 == 1, 0)

{pythonic_fp_booleans-1.1.2 → pythonic_fp_booleans-2.0.0}/tests/test_flavored_non_shortcut_logic.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 from pythonic_fp.booleans.subtypable import TRUTH, LIE
-from pythonic_fp.booleans.subtypes.flavored import FBool, truthy, falsy
+from pythonic_fp.booleans.flavored import FBool, truthy, falsy
 
 
 class TestBitwiseOperations():

{pythonic_fp_booleans-1.1.2 → pythonic_fp_booleans-2.0.0}/tests/test_flavored_sbool.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from pythonic_fp.booleans.subtypes.flavored import FBool, truthy, falsy
+from pythonic_fp.booleans.flavored import FBool, truthy, falsy
 from pythonic_fp.booleans.subtypable import SBool, TRUTH, LIE
 
 fbt0_1 = FBool(1 == 1, 0)

{pythonic_fp_booleans-1.1.2 → pythonic_fp_booleans-2.0.0}/tests/test_true_false.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 from pythonic_fp.booleans.subtypable import SBool, TRUTH, LIE
-from pythonic_fp.booleans.subtypes.truthy_falsy import (
+from pythonic_fp.booleans.truthy_falsy import (
     TF_Boolean,
     T_Bool,
     F_Bool,

{pythonic_fp_booleans-1.1.2 → pythonic_fp_booleans-2.0.0}/tests/test_true_false_non_shortcut_logic.py

@@ -13,8 +13,8 @@
 # limitations under the License.
 
 from pythonic_fp.booleans.subtypable import TRUTH, LIE
-from pythonic_fp.booleans.subtypes.truthy_falsy import TF_Boolean, TF_Bool, T_Bool, F_Bool
-from pythonic_fp.booleans.subtypes.truthy_falsy import ALWAYS, NEVER
+from pythonic_fp.booleans.truthy_falsy import TF_Boolean, TF_Bool, T_Bool, F_Bool
+from pythonic_fp.booleans.truthy_falsy import ALWAYS, NEVER
 
 false0: TF_Boolean = F_Bool('ignored', 'also ignored')
 false1: TF_Boolean = TF_Bool(1 > 42)

{pythonic_fp_booleans-1.1.2 → pythonic_fp_booleans-2.0.0}/tests/test_typing.py

@@ -13,8 +13,8 @@
 # limitations under the License.
 
 from pythonic_fp.booleans.subtypable import SBool
-from pythonic_fp.booleans.subtypes.flavored import FBool, truthy, falsy
-from pythonic_fp.booleans.subtypes.truthy_falsy import TF_Bool, T_Bool, F_Bool
+from pythonic_fp.booleans.flavored import FBool, truthy, falsy
+from pythonic_fp.booleans.truthy_falsy import TF_Bool, T_Bool, F_Bool
 
 
 class TestInvert:

{pythonic_fp_booleans-1.1.2 → pythonic_fp_booleans-2.0.0}/tests/test_variance.py

@@ -12,8 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from pythonic_fp.booleans.subtypes.truthy_falsy import TF_Bool, TF_Boolean, T_Bool, F_Bool, ALWAYS, NEVER
-from pythonic_fp.booleans.subtypes.flavored import FBool, truthy, falsy
+from pythonic_fp.booleans.truthy_falsy import TF_Bool, TF_Boolean, T_Bool, F_Bool, ALWAYS, NEVER
+from pythonic_fp.booleans.flavored import FBool, truthy, falsy
 from pythonic_fp.booleans.subtypable import SBool, TRUTH, LIE
 
 class TestBoolWithInt():

pythonic_fp_booleans-1.1.2/CHANGELOG.rst

@@ -1,46 +0,0 @@
-CHANGELOG
-=========
-
-PyPI pythonic-fp-booleans project.
-
-Semantic Versioning
--------------------
-
-Strict 3 digit semantic versioning adopted 2025-05-19.
-
-- **MAJOR** version incremented for incompatible API changes
-- **MINOR** version incremented for backward compatible added functionality
-- **PATCH** version incremented for backward compatible bug fixes
-
-See `Semantic Versioning 2.0.0 <https://semver.org>`_.
-
-Releases and Important Milestones
----------------------------------
-
-PyPI v1.1.1 - 2025-09-03
-~~~~~~~~~~~~~~~~~~~~~~~~
-
-Only change was to give README.rst a final edit. Missed this on
-the v1.1.0 release.
-
-
-PyPI v1.1.0 - 2025-09-02
-~~~~~~~~~~~~~~~~~~~~~~~~
-
-First PyPI release as pythonic-fp-booleans.
-
-- module booleans.subtypable
-- package booleans.subtypes
-
-  - module booleans.subtypes.flavored
-  - module booleans.subtypes.truthy_falsy
-
-Needs
-
--  "pythonic-fp>=3.0.0" for gadgets
--  "pythonic-fp-sentinels>=2.1.0",
-
-Created pythonic-fp-boolean GitHub repo - 2025-08-06
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Moved pythonic_fp.singletons.sbool -> pythonic_fp.booleans.sbool

pythonic_fp_booleans-1.1.2/src/pythonic_fp/booleans/__init__.py

@@ -1,99 +0,0 @@
-# Copyright 2023-2025 Geoffrey R. Scheller
-#
-# 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
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-Subtypable Boolean like classes
-===============================
-
-While still compatible with Python shortcut logic, these classes can
-be non-shortcut logically composed with Python's bitwise operators.
-These classes are implemented with the Singleton Pattern.
-
-Covariant class hierarchy
--------------------------
-
-.. graphviz::
-
-    digraph Booleans {
-        bgcolor="deepskyblue";
-        int -> bool;
-        int -> SBool;
-        SBool -> "FBool(h1)";
-        SBool -> "FBool(h2)";
-        SBool -> "FBool(h3)";
-        SBool -> TF_Bool;
-        TF_Bool -> T_Bool;
-        TF_Bool -> F_Bool;
-    }
-
-Contravariant non-shortcut "bitwise" operators
-----------------------------------------------
-
-+-------------------+--------+------------+
-| Boolean operation | symbol | dunder     |
-+===================+========+============+
-|       not         | ``~``  | __invert__ |
-+-------------------+--------+------------+
-|       and         | ``&``  | __and__    |
-+-------------------+--------+------------+
-|       or          | ``|``  | __or__     |
-+-------------------+--------+------------+
-|       xor         | ``^``  | __xor__    |
-+-------------------+--------+------------+
-
-These operators are contravariant, that is they will return
-the instance of the latest common ancestor of their arguments.
-More specifically, the instance returned will have the type
-of the least upper bound in the inheritance graph of the classes
-of the two arguments.
-
-.. warning::
-
-   These "bitwise" operators could raise ``TypeError`` exceptions
-   when applied against an ``SBool`` and objects not descended
-   from ``int``.
-
-Classes
--------
-
-Class SBool
-~~~~~~~~~~~
-
-Base of the hierarchy.
-
-Like Python's built-in ``bool``, ``SBool`` is a subclass of ``int``,
-unlike ``bool``, class ``SBool`` can be further subclassed.
-
-Class FBool
-~~~~~~~~~~~
-
-For when you need to deal with different "flavors" of the truth.
-
-Each "flavor" corresponds to a hashable value. Instances of ``FBool``
-are invariant in their flavor. Best to think of the "flavor" as an
-index.
-
-Class TF_Bool
-~~~~~~~~~~~~~
-
-Class ``TF_Bool`` consists of just two disjoint subclasses, each one
-a singleton.
-
-- class ``T_Bool`` is the  always truthy ``TF_Bool`` subtype
-- class ``F_Bool`` is the  always falsy ``TF_Bool`` subtype
-"""
-
-__author__ = 'Geoffrey R. Scheller'
-__copyright__ = 'Copyright (c) 2025 Geoffrey R. Scheller'
-__license__ = 'Apache License 2.0'

pythonic_fp_booleans-1.1.2/src/pythonic_fp/booleans/subtypable.pyi

@@ -1,18 +0,0 @@
-from collections.abc import Hashable
-from typing import Final, overload
-
-__all__ = ['SBool', 'TRUTH', 'LIE']
-
-class SBool(int):
-    @overload
-    def __new__(cls) -> SBool: ...
-    @overload
-    def __new__(cls, witness: object) -> SBool: ...
-    def __init__(self, witness: object = False, flavor: Hashable = ...) -> None: ...
-    def __invert__(self) -> SBool: ...
-    def __and__(self, other: int) -> int: ...
-    def __or__(self, other: int) -> int: ...
-    def __xor__(self, other: int) -> int: ...
-
-TRUTH: Final[SBool]
-LIE: Final[SBool]

pythonic_fp_booleans-1.1.2/src/pythonic_fp/booleans/subtypes/flavored.pyi

@@ -1,19 +0,0 @@
-from ..subtypable import SBool
-from collections.abc import Hashable
-
-__all__ = ['FBool', 'truthy', 'falsy']
-
-class FBool(SBool):
-    def __new__(cls, witness: object, flavor: Hashable) -> FBool: ...
-    def __init__(self, witness: object, flavor: Hashable) -> None: ...
-    def __invert__(self) -> FBool: ...
-    def __and__(self, other: int) -> SBool: ...
-    def __rand__(self, other: int) -> SBool: ...
-    def __or__(self, other: int) -> SBool: ...
-    def __ror__(self, other: int) -> SBool: ...
-    def __xor__(self, other: int) -> SBool: ...
-    def __rxor__(self, other: int) -> SBool: ...
-    def flavor(self) -> Hashable: ...
-
-def truthy(flavor: Hashable) -> FBool: ...
-def falsy(flavor: Hashable) -> FBool: ...

pythonic_fp_booleans-1.1.2/src/pythonic_fp/booleans/subtypes/truthy_falsy.pyi

@@ -1,21 +0,0 @@
-from ..subtypable import SBool
-from collections.abc import Hashable
-from typing import Final
-
-__all__ = ['TF_Bool', 'T_Bool', 'F_Bool', 'ALWAYS', 'NEVER', 'TF_Boolean']
-
-class TF_Bool(SBool):
-    def __new__(cls, witness: object, flavor: Hashable = ...) -> TF_Bool: ...
-    def __invert__(self) -> TF_Bool: ...
-    def __and__(self, other: int) -> SBool: ...
-    def __or__(self, other: int) -> SBool: ...
-    def __xor__(self, other: int) -> SBool: ...
-
-class T_Bool(TF_Bool):
-    def __new__(cls, witness: object = ..., flavor: Hashable = ...) -> T_Bool: ...
-
-class F_Bool(TF_Bool):
-    def __new__(cls, witness: object = ..., flavor: Hashable = ...) -> F_Bool: ...
-TF_Boolean = T_Bool | F_Bool | TF_Bool
-ALWAYS: Final[TF_Boolean]
-NEVER: Final[TF_Boolean]