dialectical-framework 0.6.5__tar.gz → 0.7.0__tar.gz

{dialectical_framework-0.6.5 → dialectical_framework-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: dialectical-framework
-Version: 0.6.5
+Version: 0.7.0
 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
@@ -35,7 +35,7 @@ Project-URL: Homepage, https://github.com/dialexity/dialectical-framework
 Project-URL: Repository, https://github.com/dialexity/dialectical-framework
 Description-Content-Type: text/markdown
 
-# Dialectical Framework
+# Dialectical Reasoning Framework
 Turn stories, strategies, or systems into insight. Auto-generate Dialectical Wheels (DWs) from any text to reveal blind spots, surface polarities, and trace dynamic paths toward synthesis.
  DWs are semantic maps that expose tension, transformation, and coherence within a system—whether narrative, ethical, organizational, or technological.
 
@@ -132,3 +132,4 @@ Working beta product [Argument Inspector](https://dialexity.com/start). Useful f
 
 ### "Spiral" Lila game
 In [this blog post](https://dialexity.com/blog/spiral-lila-with-character-traits/) we explain how the ancient Lila (Leela) game has been elevated to a new level. 
+

{dialectical_framework-0.6.5 → dialectical_framework-0.7.0}/README.md

@@ -1,4 +1,4 @@
-# Dialectical Framework
+# Dialectical Reasoning Framework
 Turn stories, strategies, or systems into insight. Auto-generate Dialectical Wheels (DWs) from any text to reveal blind spots, surface polarities, and trace dynamic paths toward synthesis.
  DWs are semantic maps that expose tension, transformation, and coherence within a system—whether narrative, ethical, organizational, or technological.
 
@@ -94,4 +94,4 @@ Working beta product [Argument Inspector](https://dialexity.com/start). Useful f
 [The Atlas of Feelings](https://dialexity.com/blog/atlas-of-feelings-character-qualities/) is the Plutchik's wheel converted into the „vortex“ model, whereby the most gentle emotions are inside of the wheel, whereas the rudest are outside. As everything is interconnected with dialectical rules, we can understand human nature better.
 
 ### "Spiral" Lila game
-In [this blog post](https://dialexity.com/blog/spiral-lila-with-character-traits/) we explain how the ancient Lila (Leela) game has been elevated to a new level. 
+In [this blog post](https://dialexity.com/blog/spiral-lila-with-character-traits/) we explain how the ancient Lila (Leela) game has been elevated to a new level. 

{dialectical_framework-0.6.5 → dialectical_framework-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "dialectical-framework"
-version = "0.6.5"
+version = "0.7.0"
 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"

{dialectical_framework-0.6.5 → dialectical_framework-0.7.0}/src/dialectical_framework/analyst/domain/cycle.py

@@ -37,7 +37,7 @@ class Cycle(AssessableCycle[TransitionCellToCell]):
     def __init__(
         self,
         dialectical_components: list[DialecticalComponent],
-        causality_type: CausalityType = CausalityType.REALISTIC,
+        causality_type: CausalityType = CausalityType.BALANCED,
         default_transition_probability: float | None = None,
         **data,
     ):

{dialectical_framework-0.6.5 → dialectical_framework-0.7.0}/src/dialectical_framework/dialectical_reasoning.py

@@ -7,6 +7,7 @@ from dialectical_framework.brain import Brain
 from dialectical_framework.enums.causality_type import CausalityType
 from dialectical_framework.protocols.causality_sequencer import \
     CausalitySequencer
+from dialectical_framework.protocols.polarity_extractor import PolarityExtractor
 from dialectical_framework.protocols.thesis_extractor import ThesisExtractor
 from dialectical_framework.settings import Settings
 from dialectical_framework.synthesist.causality.causality_sequencer_balanced import \
@@ -17,6 +18,7 @@ from dialectical_framework.synthesist.causality.causality_sequencer_feasible imp
     CausalitySequencerFeasible
 from dialectical_framework.synthesist.causality.causality_sequencer_realistic import \
     CausalitySequencerRealistic
+from dialectical_framework.synthesist.concepts.polarity_extractor_basic import PolarityExtractorBasic
 from dialectical_framework.synthesist.concepts.thesis_extractor_basic import \
     ThesisExtractorBasic
 from dialectical_framework.synthesist.polarity.polarity_reasoner import \
@@ -76,8 +78,8 @@ class DialecticalReasoning(containers.DeclarativeContainer):
         settings=settings,
     )
 
-    thesis_extractor: providers.Factory[ThesisExtractor] = providers.Factory(
-        ThesisExtractorBasic,
+    polarity_extractor: providers.Factory[PolarityExtractor] = providers.Factory(
+        PolarityExtractorBasic,
     )
 
     wheel_builder: providers.Factory[WheelBuilder] = providers.Factory(WheelBuilder)

{dialectical_framework-0.6.5 → dialectical_framework-0.7.0}/src/dialectical_framework/enums/di.py

@@ -8,4 +8,4 @@ class DI(str, Enum):
     brain = "brain"
     polarity_reasoner = "polarity_reasoner"
     causality_sequencer = "causality_sequencer"
-    thesis_extractor = "thesis_extractor"
+    polarity_extractor = "polarity_extractor"

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

@@ -0,0 +1,22 @@
+from abc import abstractmethod
+
+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: list[tuple[str | None, str | None]]) -> list[tuple[DialecticalComponent, DialecticalComponent]]:
+        """
+        Given tuple of (None, None) a single polarity will be extracted.
+        Given tuple of (None, some_thesis) a theses will be extracted.
+        Given more tuples, all the given theses/antitheses will be taken into account.
+        """
+        ...
+
+    @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.6.5 → dialectical_framework-0.7.0}/src/dialectical_framework/synthesist/causality/causality_sequencer_balanced.py

@@ -216,7 +216,7 @@ class CausalitySequencerBalanced(CausalitySequencer, HasBrain, SettingsAware):
                         CausalCycleDto(
                             aliases=[ordered_wisdom_units[0].t.alias, ordered_wisdom_units[0].a.alias],
                             probability=1.0,
-                            reasoning_explanation="Single unit self-loop cycle",
+                            reasoning_explanation="Single unit cycle",
                             argumentation="Default unit cycle"
                         )
                     ]

dialectical_framework-0.7.0/src/dialectical_framework/synthesist/concepts/polarity_extractor_basic.py

@@ -0,0 +1,264 @@
+from mirascope import Messages, prompt_template
+from mirascope.integrations.langfuse import with_langfuse
+
+from dialectical_framework.ai_dto.dialectical_component_dto import \
+    DialecticalComponentDto
+from dialectical_framework.ai_dto.dialectical_components_deck_dto import \
+    DialecticalComponentsDeckDto
+from dialectical_framework.ai_dto.dto_mapper import (map_from_dto,
+                                                     map_list_from_dto)
+from dialectical_framework.protocols.polarity_extractor import PolarityExtractor
+from dialectical_framework.synthesist.concepts.thesis_extractor_basic import ThesisExtractorBasic
+from dialectical_framework.synthesist.domain.dialectical_component import DialecticalComponent
+from dialectical_framework.synthesist.domain.dialectical_components_deck import \
+    DialecticalComponentsDeck
+from dialectical_framework.synthesist.domain.wheel_segment import ALIAS_T
+from dialectical_framework.synthesist.domain.wisdom_unit import ALIAS_A
+from dialectical_framework.utils.use_brain import use_brain
+
+
+class PolarityExtractorBasic(ThesisExtractorBasic, PolarityExtractor):
+
+    @prompt_template(
+        """
+        MESSAGES:
+        {thesis_extraction}
+        
+        ASSISTANT:
+        T = {thesis}
+        
+        USER:
+        A dialectical opposition presents the conceptual or functional antithesis of the original statement that creates direct opposition, while potentially still allowing their mutual coexistence. For instance, Love vs. Hate or Indifference; Science vs. Superstition, Faith/Belief; Human-caused Global Warming vs. Natural Cycles.
+
+        Generate a dialectical opposition (A) of the thesis "{thesis}" (T). Be detailed enough to show deep understanding, yet concise enough to maintain clarity.
+
+        Output the dialectical component A within {component_length} word(s), the shorter, the better. Compose the explanation how it was derived in the passive voice. Don't mention any special denotations such as "T" or "A" in the explanation.
+        
+        {rule_out}
+        """
+    )
+    def prompt_single_antithesis(self, *, thesis: str, not_like_these: list[str] | None = None) -> Messages.Type:
+        rule_out = ""
+
+        if not_like_these:
+            rule_out = "**Rules**\nIMPORTANT: The output must be different than these already known theses:\n" + "\n".join(not_like_these)
+
+        return {
+            "computed_fields": {
+                'thesis_extraction': self.prompt_single_thesis(),
+                "thesis": thesis,
+                "rule_out": rule_out,
+                "component_length": self.settings.component_length,
+            },
+        }
+
+    @prompt_template(
+        """
+        MESSAGES:
+        {theses_extraction}
+        
+        ASSISTANT:
+        {theses}
+        
+        USER:
+        A dialectical opposition presents the conceptual or functional antithesis of the original statement that creates direct opposition, while potentially still allowing their mutual coexistence. For instance, Love vs. Hate or Indifference; Science vs. Superstition, Faith/Belief; Human-caused Global Warming vs. Natural Cycles.
+        
+        For each thesis, generate a dialectical opposition (A). Be detailed enough to show deep understanding, yet concise enough to maintain clarity.
+
+        **Output Format:**
+        A1 = [antithesis of T1 in 1-{component_length} words]
+        Explanation: [The explanation how it was derived in the passive voice]
+        
+        A2 = [antithesis of T2 in 1-{component_length} words]
+        Explanation: [The explanation how it was derived in the passive voice]
+        
+        ...
+        
+        Ax = [antithesis of Tx in 1-{component_length} words]
+        Explanation: [The explanation how it was derived in the passive voice]
+        
+        **Rules**
+        Make sure to output {count} antitheses, i.e. one for each thesis, no more no less.
+        {rule_out}
+        """
+    )
+    def prompt_multiple_antitheses(self, *, theses: list[str], not_like_these: list[str] | None = None) -> Messages.Type:
+        rule_out = ""
+
+        if not_like_these:
+            rule_out = "IMPORTANT: The output antitheses must be different than these already known theses/antitheses:\n" + "\n".join(
+                not_like_these)
+
+        theses_str = "\n".join(f"T{i + 1} = {thesis}" for i, thesis in enumerate(theses))
+
+        return {
+            "computed_fields": {
+                "theses_extraction": self.prompt_multiple_theses(count=len(theses)),
+                "theses": theses_str,
+                "count": len(theses),
+                "rule_out": rule_out,
+                "component_length": self.settings.component_length,
+            },
+        }
+
+    async def extract_polarities(self, *, given: list[tuple[str | None, str | None]]) \
+            -> list[tuple[DialecticalComponent, DialecticalComponent]]:
+        count = len(given)
+        if count > 4 or count < 1:
+            raise ValueError(
+                f"Incorrect number of polarities requested. Max 4 are supported."
+            )
+
+        # Collect all provided statements to avoid duplicates
+        not_like_these = []
+        for thesis, antithesis in given:
+            if thesis:
+                not_like_these.append(thesis)
+            if antithesis:
+                not_like_these.append(antithesis)
+
+        theses_to_find = []
+        theses_indices = []
+
+        # For every tuple that has both None, we want to first find theses
+        empty_count = 0
+        for i, (thesis, antithesis) in enumerate(given):
+            if thesis is None and antithesis is None:
+                empty_count += 1
+                theses_indices.append(i)
+
+        # Extract missing theses for empty positions
+        if empty_count == 1:
+            t = await self.extract_single_thesis(not_like_these=not_like_these)
+            not_like_these.append(t.statement)
+            theses_to_find = [t]
+        elif empty_count > 1:
+            ts = await self.extract_multiple_theses(count=empty_count, not_like_these=not_like_these)
+            not_like_these.extend(t.statement for t in ts.dialectical_components)
+            theses_to_find = ts.dialectical_components
+
+        # Initialize result list with placeholders
+        result: list[tuple[DialecticalComponent | None, DialecticalComponent | None]] = [(None, None) for _ in range(len(given))]
+
+        # Determine the index to use: 0 if only one tuple, otherwise 1-based index
+        def get_friendly_index(i: int) -> int:
+            return 0 if count == 1 else i + 1
+
+        # Helper to get the correct alias
+        def get_alias(base_alias: str, i: int) -> str:
+            return base_alias if count == 1 else f"{base_alias}{i + 1}"
+
+        # Fill in known statements and place found theses in correct positions
+        thesis_counter = 0
+        for i, (thesis, antithesis) in enumerate(given):
+            friendly_idx = get_friendly_index(i)
+            if thesis is not None and antithesis is not None:
+                # Both provided - just create components with correct aliases
+                t = DialecticalComponent(alias=get_alias(ALIAS_T, i), statement=thesis)
+                t.set_human_friendly_index(friendly_idx)
+                a = DialecticalComponent(alias=get_alias(ALIAS_A, i), statement=antithesis)
+                a.set_human_friendly_index(friendly_idx)
+                result[i] = (t, a)
+            elif thesis is not None:
+                # Thesis provided, need to find antithesis
+                t = DialecticalComponent(alias=get_alias(ALIAS_T, i), statement=thesis)
+                t.set_human_friendly_index(friendly_idx)
+                result[i] = (t, None)
+            elif antithesis is not None:
+                # Antithesis provided, need to find its opposite (which goes in thesis position)
+                a = DialecticalComponent(alias=get_alias(ALIAS_A, i), statement=antithesis)
+                a.set_human_friendly_index(friendly_idx)
+                result[i] = (None, a)
+            elif i in theses_indices:
+                # Both empty - use found thesis
+                t = theses_to_find[thesis_counter]
+                t.alias = get_alias(ALIAS_T, i)
+                t.set_human_friendly_index(friendly_idx)
+                result[i] = (t, None)
+                thesis_counter += 1
+
+        # Collect all statements that need opposites
+        statements_needing_opposites = []
+        indices_needing_opposites = []
+        is_thesis_position = []  # Track which position the opposite should go to
+
+        for i, (t, a) in enumerate(result):
+            if t is None:
+                # Need to find opposite for the provided antithesis
+                statements_needing_opposites.append(a.statement)
+                indices_needing_opposites.append(i)
+                is_thesis_position.append(True)  # Opposite goes to thesis position
+            elif a is None:
+                # Need to find opposite for the provided thesis
+                statements_needing_opposites.append(t.statement)
+                indices_needing_opposites.append(i)
+                is_thesis_position.append(False)  # Opposite goes to antithesis position
+
+        # Extract all opposites in one batch
+        if len(statements_needing_opposites) == 1:
+            opposite = await self.extract_single_antithesis(
+                thesis=statements_needing_opposites[0],
+                not_like_these=not_like_these
+            )
+            opposites = [opposite]
+        elif len(statements_needing_opposites) > 1:
+            deck = await self.extract_multiple_antitheses(
+                theses=statements_needing_opposites,
+                not_like_these=not_like_these
+            )
+            opposites = deck.dialectical_components
+        else:
+            opposites = []
+
+        # Place the opposites in the correct positions with correct aliases
+        for idx, opposite, is_t_pos in zip(indices_needing_opposites, opposites, is_thesis_position):
+            friendly_idx = get_friendly_index(idx)
+            if is_t_pos:
+                # Opposite goes to thesis position
+                opposite.alias = get_alias(ALIAS_T, idx)
+                opposite.set_human_friendly_index(friendly_idx)
+                result[idx] = (opposite, result[idx][1])
+            else:
+                # Opposite goes to antithesis position
+                opposite.alias = get_alias(ALIAS_A, idx)
+                opposite.set_human_friendly_index(friendly_idx)
+                result[idx] = (result[idx][0], opposite)
+
+        return result
+
+    async def extract_multiple_antitheses(self, *, theses: list[str], not_like_these: list[str] | None = None) \
+            -> DialecticalComponentsDeck:
+        count = len(theses)
+
+        @with_langfuse()
+        @use_brain(brain=self.brain, response_model=DialecticalComponentsDeckDto)
+        async def _find_antitheses():
+            return self.prompt_multiple_antitheses(theses=theses, not_like_these=not_like_these)
+
+        deck_dto = await _find_antitheses()
+        components = map_list_from_dto(deck_dto.dialectical_components, DialecticalComponent)
+        # It may happen that AI will return theses as well, so let's be prepared to filter out only the antitheses
+        antitheses = []
+        for dc in components:
+            if dc.alias.startswith(ALIAS_A):
+                antitheses.append(dc)
+
+        if len(antitheses) < count:
+            raise ValueError(f"AI returned {len(antitheses)} antitheses but {count} were requested.")
+
+        # Take only the requested count if AI returned more
+        deck = DialecticalComponentsDeck(dialectical_components=antitheses[:count])
+        if count == 1 and len(deck.dialectical_components) == 1:
+            dc: DialecticalComponent = deck.dialectical_components[0]
+            dc.set_human_friendly_index(0)
+        return deck
+
+    async def extract_single_antithesis(self, *, thesis: str, not_like_these: list[str] | None = None) \
+            -> DialecticalComponent:
+        @with_langfuse()
+        @use_brain(brain=self.brain, response_model=DialecticalComponentDto)
+        async def _find_antithesis():
+            return self.prompt_single_antithesis(thesis=thesis, not_like_these=not_like_these)
+
+        dc_dto = await _find_antithesis()
+        return map_from_dto(dc_dto, DialecticalComponent)

{dialectical_framework-0.6.5 → dialectical_framework-0.7.0}/src/dialectical_framework/synthesist/concepts/thesis_extractor_basic.py

@@ -106,7 +106,7 @@ class ThesisExtractorBasic(ThesisExtractor, HasBrain, SettingsAware):
         rule_out = ""
 
         if not_like_these:
-            rule_out = "IMPORTANT: The output concepts must have different than these already known theses:\n" + "\n".join(
+            rule_out = "IMPORTANT: The output concepts must be different than these already known theses:\n" + "\n".join(
                 not_like_these)
 
         return {
@@ -129,14 +129,15 @@ class ThesisExtractorBasic(ThesisExtractor, HasBrain, SettingsAware):
         async def _find_theses():
             return self.prompt_multiple_theses(count=count, not_like_these=not_like_these)
 
-        if count <= 4:
-            deck_dto = await _find_theses()
-            deck = DialecticalComponentsDeck(dialectical_components=map_list_from_dto(deck_dto.dialectical_components, DialecticalComponent))
-            if count == 1 and len(deck.dialectical_components) == 1:
-                dc: DialecticalComponent = deck.dialectical_components[0]
-                dc.set_human_friendly_index(0)
-        else:
-            raise ValueError(f"More than 4 theses are not supported yet.")
+        deck_dto = await _find_theses()
+        components = map_list_from_dto(deck_dto.dialectical_components, DialecticalComponent)
+        if len(components) < count:
+            raise ValueError(f"AI returned {len(components)} components but {count} were requested.")
+        # Take only the requested count if AI returned more
+        deck = DialecticalComponentsDeck(dialectical_components=components[:count])
+        if count == 1 and len(deck.dialectical_components) == 1:
+            dc: DialecticalComponent = deck.dialectical_components[0]
+            dc.set_human_friendly_index(0)
         return deck
 
     async def extract_single_thesis(self, *, not_like_these: list[str] | None = None) -> DialecticalComponent:

{dialectical_framework-0.6.5 → dialectical_framework-0.7.0}/src/dialectical_framework/synthesist/polarity/polarity_reasoner.py

@@ -108,7 +108,7 @@ class PolarityReasoner(HasBrain, Reloadable):
         """
         A dialectical opposition presents the conceptual or functional antithesis of the original statement that creates direct opposition, while potentially still allowing their mutual coexistence. For instance, Love vs. Hate or Indifference; Science vs. Superstition, Faith/Belief; Human-caused Global Warming vs. Natural Cycles.
         
-        Generate a dialectical opposition (A) of the thesis "{thesis}" (T). Be detailed enough to show deep understanding, yet concise enough to maintain clarity. Generalize all of them using up to 6 words.
+        Generate a dialectical opposition (A) of the thesis "{thesis}" (T). Be detailed enough to show deep understanding, yet concise enough to maintain clarity.
     
         Output the dialectical component A within {component_length} word(s), the shorter, the better. Compose the explanation how it was derived in the passive voice. Don't mention any special denotations such as "T" or "A" in the explanation.
         """

{dialectical_framework-0.6.5 → dialectical_framework-0.7.0}/src/dialectical_framework/synthesist/wheel_builder.py

@@ -7,6 +7,7 @@ from dependency_injector.wiring import Provide
 from dialectical_framework.ai_dto.dto_mapper import (map_from_dto,
                                                      map_list_from_dto)
 from dialectical_framework.analyst.domain.cycle import Cycle
+from dialectical_framework.protocols.polarity_extractor import PolarityExtractor
 from dialectical_framework.synthesist.domain.dialectical_component import DialecticalComponent
 from dialectical_framework.synthesist.domain.dialectical_components_deck import \
     DialecticalComponentsDeck
@@ -26,7 +27,7 @@ from dialectical_framework.synthesist.domain.wisdom_unit import WisdomUnit
 class WheelBuilder(SettingsAware):
     def __init__(
         self,
-        thesis_extractor: ThesisExtractor = Provide[DI.thesis_extractor],
+        polarity_extractor: PolarityExtractor = Provide[DI.polarity_extractor],
         causality_sequencer: CausalitySequencer = Provide[DI.causality_sequencer],
         polarity_reasoner: PolarityReasoner = Provide[DI.polarity_reasoner],
         *,
@@ -38,7 +39,7 @@ class WheelBuilder(SettingsAware):
 
         # TODO: reloading singletons isn't very good design here, because we're guessing the parameters...
 
-        self.__extractor = thesis_extractor
+        self.__extractor = polarity_extractor
         self.__extractor.reload(text=text)
 
         self.__sequencer = causality_sequencer
@@ -56,7 +57,7 @@ class WheelBuilder(SettingsAware):
         return self.__text
 
     @property
-    def extractor(self) -> ThesisExtractor:
+    def extractor(self) -> PolarityExtractor:
         return self.__extractor
 
     @property