dialectical-framework 0.7.4__tar.gz → 0.7.6__tar.gz

{dialectical_framework-0.7.4 → dialectical_framework-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dialectical-framework
-Version: 0.7.4
+Version: 0.7.6
 Summary: A dialectical framework for augmented intelligence. AI reasoning powered with dialectics supports humans in: system optimization (psychology, engineering, business, politics, etc.); dispute resolution (mediation, conflicts, negotiations, etc.); decision-making (dilemmas, challenging situations, win-win, etc.).
 License: MIT
 Keywords: dialectics,dialectical-reasoning,synthesis,thesis-antithesis,ai,artificial-intelligence,llm,reasoning-framework,philosophy,logic,argumentation,conflict-resolution,decision-making,critical-thinking,semantic-graph,mirascope,pydantic,wisdom-units,polarity-reasoning
@@ -28,8 +28,9 @@ Classifier: Topic :: Sociology
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Text Processing :: Linguistic
 Requires-Dist: dependency-injector (>=4.48.2,<5.0.0)
-Requires-Dist: mirascope[anthropic,azure,bedrock,langfuse,litellm,openai,tenacity] (>=1.25.6,<2.0.0)
-Requires-Dist: python-dotenv (>=1.1.1,<2.0.0)
+Requires-Dist: litellm (>=1.79.3,<2.0.0)
+Requires-Dist: mirascope[anthropic,azure,bedrock,langfuse,openai,tenacity] (>=1.25.7,<2.0.0)
+Requires-Dist: python-dotenv (>=1.2.1,<2.0.0)
 Requires-Dist: tabulate (>=0.9.0,<0.10.0)
 Project-URL: Homepage, https://github.com/dialexity/dialectical-framework
 Project-URL: Repository, https://github.com/dialexity/dialectical-framework

{dialectical_framework-0.7.4 → dialectical_framework-0.7.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dialectical-framework"
-version = "0.7.4"
+version = "0.7.6"
 description = "A dialectical framework for augmented intelligence. AI reasoning powered with dialectics supports humans in: system optimization (psychology, engineering, business, politics, etc.); dispute resolution (mediation, conflicts, negotiations, etc.); decision-making (dilemmas, challenging situations, win-win, etc.)."
 authors = ["Evaldas Taroza <evaldas@dialexity.com>"]
 readme = "README.md"
@@ -48,14 +48,14 @@ mirascope = {extras = [
     "azure",
     "openai",
     "anthropic",
-    "litellm",
     "bedrock",
     "langfuse",
     "tenacity"
-], version = "^1.25.6"}
-python-dotenv = "^1.1.1"
+], version = "^1.25.7"}
+python-dotenv = "^1.2.1"
 tabulate = "^0.9.0"
 dependency-injector = "^4.48.2"
+litellm = "^1.79.3"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.4.1"

{dialectical_framework-0.7.4 → dialectical_framework-0.7.6}/src/dialectical_framework/analyst/domain/cycle.py

@@ -25,15 +25,11 @@ class Cycle(AssessableCycle[TransitionCellToCell]):
     causality_type: CausalityType = Field(
         ..., description="The type of causality in the cycle."
     )
+
     causality_direction: Literal["clockwise", "counterclockwise"] = Field(
         default="clockwise", description="The direction of causality in the ring."
     )
 
-    argumentation: str = Field(
-        default="",
-        description="Circumstances or contexts where this cycle would be most applicable or useful.",
-    )
-
     def __init__(
         self,
         dialectical_components: list[DialecticalComponent],

{dialectical_framework-0.7.4 → dialectical_framework-0.7.6}/src/dialectical_framework/analyst/wheel_builder_transition_calculator.py

@@ -77,21 +77,24 @@ class WheelBuilderTransitionCalculator(WheelBuilder, ABC):
                 self._take_transition(wheel=wheel, transition=tr)
         elif isinstance(at, list):
             # Calculate for some
+            if hasattr(self.decorated_builder, "calculate_transitions"):
+                await self.decorated_builder.calculate_transitions(
+                    wheel=wheel, at=at
+                )
             for ref in at:
-                if hasattr(self.decorated_builder, "calculate_transitions"):
-                    await self.decorated_builder.calculate_transitions(
-                        wheel=wheel, at=ref
-                    )
+                segment = wheel.wheel_segment_at(ref)
                 # This is for subclasses to implement
-                trs_i = await self._do_calculate_transitions(wheel=wheel, at=ref)
+                trs_i = await self._do_calculate_transitions(wheel=wheel, at=segment)
                 for tr in trs_i:
                     self._take_transition(wheel=wheel, transition=tr)
         else:
             # Calculate for one
             if hasattr(self.decorated_builder, "calculate_transitions"):
                 await self.decorated_builder.calculate_transitions(wheel=wheel, at=at)
+
+            segment = wheel.wheel_segment_at(at)
             # This is for subclasses to implement
-            trs = await self._do_calculate_transitions(wheel=wheel, at=at)
+            trs = await self._do_calculate_transitions(wheel=wheel, at=segment)
             for tr in trs:
                 self._take_transition(wheel=wheel, transition=tr)
 

dialectical_framework-0.7.6/src/dialectical_framework/protocols/polarity_extractor.py

@@ -0,0 +1,101 @@
+from abc import abstractmethod
+from typing import Union
+
+from dialectical_framework.protocols.thesis_extractor import ThesisExtractor
+from dialectical_framework.synthesist.domain.dialectical_component import DialecticalComponent
+from dialectical_framework.synthesist.domain.dialectical_components_deck import DialecticalComponentsDeck
+
+
+class PolarityExtractor(ThesisExtractor):
+    @abstractmethod
+    async def extract_polarities(
+        self,
+        *,
+        given: Union[str, list[str | None], list[tuple[str | None, str | None]]] = None,
+        at: None | int | list[int] = None,
+        not_like_these: list[str] | None = None
+    ) -> list[tuple[DialecticalComponent, DialecticalComponent]]:
+        """
+        Extract polarities (thesis-antithesis pairs) with optional selective generation.
+
+        This method provides flexible polarity extraction with support for partial inputs and
+        selective generation control. It intelligently generates missing components while avoiding
+        duplicates across the entire matrix.
+
+        Parameters
+        ----------
+        given : Union[str, list[str | None], list[tuple[str | None, str | None]]], optional
+            Input specification for polarities. Supports multiple formats:
+
+            **Simple formats:**
+            - `None` or `[]`: Generate a single complete polarity pair from scratch
+            - `"text"`: Use "text" as thesis, generate its antithesis
+
+            **List formats:**
+            - `["thesis1", "thesis2"]`: Each string becomes a thesis, generate antitheses
+            - `[None, "text"]`: Generate thesis for first, use "text" for second
+            - `[(None, None)]`: Generate one complete polarity pair
+            - `[("thesis", None)]`: Use provided thesis, generate antithesis
+            - `[(None, "antithesis")]`: Generate thesis (opposite) for provided antithesis
+            - `[("thesis", "antithesis")]`: Both provided, no generation needed
+
+            **Mixed formats:**
+            - `[("Love", None), (None, "Hate"), ("Peace", "War"), (None, None)]`
+              Handles any combination of complete, partial, or empty tuples
+
+            Maximum 4 polarities supported.
+
+        at : None | int | list[int], optional
+            Selective generation control (0-based indices):
+
+            - `None` (default): Generate ALL missing components across the matrix.
+              Returns complete polarities with no empty statements.
+
+            - `int` (e.g., `at=0`): Generate ONLY at that specific index.
+              Other indices preserve provided values but leave missing parts empty.
+
+            - `list[int]` (e.g., `at=[0, 2]`): Generate at multiple specific indices.
+              Only specified indices are completed; others remain incomplete.
+
+            **Deduplication:** When `at` is specified, all known statements from the
+            entire `given` matrix are passed as `not_like_these` to avoid duplicate
+            concepts during generation.
+
+            **Complete tuples:** If an index in `at` has both thesis and antithesis
+            already provided, no generation occurs—the tuple is simply preserved.
+
+        not_like_these: list[str] | None, optional
+            Some statements to hint that we don't need to generate them.
+
+        Returns
+        -------
+        list[tuple[DialecticalComponent, DialecticalComponent]]
+            List of (thesis, antithesis) tuples with proper aliases and indices.
+
+            **When `at=None` (default):**
+            All tuples are complete (no empty statements).
+
+            **When `at` is specified:**
+            - Indices in `at`: Complete tuples (both components have statements)
+            - Indices NOT in `at`: May contain empty components:
+                - `(DialecticalComponent(statement="thesis"), DialecticalComponent(statement=""))`
+                  if only thesis was provided
+                - `(DialecticalComponent(statement=""), DialecticalComponent(statement="antithesis"))`
+                  if only antithesis was provided
+                - `(DialecticalComponent(statement=""), DialecticalComponent(statement=""))`
+                  if neither was provided
+
+        Raises
+        ------
+        IndexError
+            If any index in `at` is out of bounds (negative or >= length of `given`)
+        ValueError
+            If more than 4 polarities are requested
+        """
+        ...
+
+    @abstractmethod
+    async def extract_multiple_antitheses( self, *, theses: list[str], not_like_these: list[str] | None = None) -> DialecticalComponentsDeck: ...
+
+    @abstractmethod
+    async def extract_single_antithesis(self, *, thesis: str, not_like_these: list[str] | None = None) -> DialecticalComponent: ...

{dialectical_framework-0.7.4 → dialectical_framework-0.7.6}/src/dialectical_framework/protocols/ratable.py

@@ -12,15 +12,26 @@ if TYPE_CHECKING:
     pass
 
 class Ratable(Assessable, ABC):
-    model_config = ConfigDict(arbitrary_types_allowed=True)
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        populate_by_name=True
+    )
 
     rating: float | None = Field(
         default=None, ge=0.0, le=1.0,
         description="Importance/quality rating."
     )
 
-    manual_relevance: float | None = Field(default=None, description="Manual override for relevance")
-    manual_probability: float | None = Field(default=None, description="Manual override for probability")
+    manual_relevance: float | None = Field(
+        default=None,
+        description="Manual override for relevance",
+        alias="relevance"
+    )
+    manual_probability: float | None = Field(
+        default=None,
+        description="Manual override for probability",
+        alias="probability"
+    )
 
     @computed_field
     @property

{dialectical_framework-0.7.4 → dialectical_framework-0.7.6}/src/dialectical_framework/synthesist/concepts/polarity_extractor_basic.py

@@ -109,9 +109,28 @@ class PolarityExtractorBasic(ThesisExtractorBasic, PolarityExtractor):
         self,
         *,
         given: Union[str, list[str | None], list[tuple[str | None, str | None]]] = None,
-        at: None | int | list[int] = None
+        at: None | int | list[int] = None,
+        not_like_these: list[str] | None = None
     ) -> list[tuple[DialecticalComponent, DialecticalComponent]]:
+        """
+        Implementation Notes
+        -------------------
+        1. **Two-phase generation:** First generates missing theses for `(None, None)`
+           entries, then generates missing antitheses/opposites in batch.
+
+        2. **Batch optimization:** Multiple missing components are generated in a single
+           AI call when possible for efficiency.
+
+        3. **Alias assignment:** Components receive proper aliases:
+           - Single polarity: `T`, `A`
+           - Multiple polarities: `T1`, `A1`, `T2`, `A2`, etc.
 
+        4. **Index tracking:** Each component tracks its human-friendly index (1-based)
+           for display purposes.
+
+        5. **Safe with complete tuples:** Specifying an index in `at` with an already
+           complete tuple is harmless—it's preserved with no generation.
+        """
         if not given or len(given) == 0:
             given = None
 
@@ -146,7 +165,8 @@ class PolarityExtractorBasic(ThesisExtractorBasic, PolarityExtractor):
                     )
 
         # Collect all provided statements to avoid duplicates
-        not_like_these = []
+        if not_like_these is None:
+            not_like_these = []
         for thesis, antithesis in given:
             if thesis:
                 not_like_these.append(thesis)

dialectical_framework-0.7.4/src/dialectical_framework/protocols/polarity_extractor.py

@@ -1,55 +0,0 @@
-from abc import abstractmethod
-from typing import Union
-
-from dialectical_framework.protocols.thesis_extractor import ThesisExtractor
-from dialectical_framework.synthesist.domain.dialectical_component import DialecticalComponent
-from dialectical_framework.synthesist.domain.dialectical_components_deck import DialecticalComponentsDeck
-
-
-class PolarityExtractor(ThesisExtractor):
-    @abstractmethod
-    async def extract_polarities(
-        self,
-        *,
-        given: Union[str, list[str | None], list[tuple[str | None, str | None]]] = None,
-        at: None | int | list[int] = None
-    ) -> list[tuple[DialecticalComponent, DialecticalComponent]]:
-        """
-        Extract polarities (thesis-antithesis pairs) with optional selective generation.
-
-        Args:
-            given: Input specification for polarities:
-                - None: Extract a single polarity
-                - str: Extract a single polarity for that thesis
-                - [str]: Extract a single polarity for that thesis
-                - [None, str]: Extract two polarities for theses
-                - [(None, None)]: Extract a single polarity
-                - [(None, some_thesis)]: A thesis will be extracted
-                - More tuples: All given theses/antitheses will be taken into account
-
-            at: Selective generation control:
-                - None (default): Generate all missing components in the given matrix
-                - int: Generate only at that specific index (0-based)
-                - list[int]: Generate only at those specific indices (0-based)
-
-                When at is specified, all other known theses/antitheses from the given matrix
-                are passed as not_like_these to avoid duplicates.
-
-        Returns:
-            List of (thesis, antithesis) tuples.
-
-            When at=None (default): All tuples are complete (no None values).
-            When at is specified: Only indices in 'at' are complete; other indices may contain:
-                - (DialecticalComponent, DialecticalComponent(with statement="")) if only thesis was provided
-                - (DialecticalComponent(with statement=""), DialecticalComponent) if only antithesis was provided
-
-        Raises:
-            IndexError: If any index in 'at' is out of bounds
-        """
-        ...
-
-    @abstractmethod
-    async def extract_multiple_antitheses( self, *, theses: list[str], not_like_these: list[str] | None = None) -> DialecticalComponentsDeck: ...
-
-    @abstractmethod
-    async def extract_single_antithesis(self, *, thesis: str, not_like_these: list[str] | None = None) -> DialecticalComponent: ...