dialectical-framework 0.4.4__py3-none-any.whl

dialectical_framework/analyst/think_constructive_convergence.py

@@ -0,0 +1,87 @@
+from mirascope import Messages, prompt_template
+from mirascope.integrations.langfuse import with_langfuse
+
+from dialectical_framework.analyst.domain.rationale import Rationale
+from dialectical_framework.analyst.domain.transition_segment_to_segment import \
+    TransitionSegmentToSegment
+from dialectical_framework.analyst.strategic_consultant import \
+    StrategicConsultant
+from dialectical_framework.enums.predicate import Predicate
+from dialectical_framework.synthesist.reverse_engineer import ReverseEngineer
+from dialectical_framework.utils.use_brain import use_brain
+from dialectical_framework.wheel_segment import WheelSegment
+
+
+class ThinkConstructiveConvergence(StrategicConsultant):
+    @prompt_template(
+        """
+        MESSAGES:
+        {wheel_construction}
+        
+        USER:
+        <instructions>
+        Identify the most actionable intermediate transition step that transforms the negative/exaggerated side of {from_alias}, i.e. {from_minus_alias}, to the positive/constructive side of the {to_alias}, i.e. {to_plus_alias}:
+        
+        This step should be:
+        - Concrete and immediately implementable
+        - Bridge the gap between opposing or contrasting elements
+        - Create momentum toward synthesis and balance
+        - Address the root tension that causes the negative aspect
+        
+        1. Start with the negative (-) or neutral state of {from_alias}, i.e. {from_minus_alias} or {from_alias}
+        2. To reach {to_plus_alias} identify 
+            - **Action**: What specific step to take (1-2 sentences)
+            - **Mechanism**: How this step transforms the negative into positive (1 sentence)
+            - **Timing**: When this transition is most effective (1 phrase)
+        
+        <examples>
+            1) T1- (Tyranny) → T2+ (Balance):
+            **Action**: Implement transparent priority matrices with employee input
+            **Mechanism**: Converts rigid control into collaborative structure
+            **Timing**: During planning cycles
+        </examples>
+        </instructions>
+    
+        <formatting>
+        Output the transition step as a fluent practical, implementable action plan (summarized but not mentioning derived Action, Mechanism, and Timing) that someone could take immediately to facilitate the transformation. Don't mention any special denotations such as "T", "T+", "A-", "Ac", "Re", etc.
+        </formatting>
+        """
+    )
+    def prompt(
+        self, text: str, focus: WheelSegment, next_ws: WheelSegment
+    ) -> Messages.Type:
+        # TODO: do we want to include transitions that are already present in the wheel?
+        return {
+            "computed_fields": {
+                "wheel_construction": ReverseEngineer.wheel(
+                    text=text, wheel=self._wheel
+                ),
+                "from_alias": focus.t.alias,
+                "from_minus_alias": focus.t_minus.alias,
+                "to_alias": next_ws.t.alias,
+                "to_plus_alias": next_ws.t_plus.alias,
+            }
+        }
+
+    @with_langfuse()
+    @use_brain(response_model=str)
+    async def constructive_convergence(
+        self, focus: WheelSegment, next_ws: WheelSegment
+    ):
+        return self.prompt(self._text, focus=focus, next_ws=next_ws)
+
+    async def think(self, focus: WheelSegment) -> TransitionSegmentToSegment:
+        current_index = self._wheel.index_of(focus)
+        next_index = (current_index + 1) % self._wheel.degree
+        next_ws = self._wheel.wheel_segment_at(next_index)
+
+        return TransitionSegmentToSegment(
+            predicate=Predicate.CONSTRUCTIVELY_CONVERGES_TO,
+            source_aliases=[focus.t_minus.alias, focus.t.alias],
+            target_aliases=[next_ws.t_plus.alias],
+            source=focus,
+            target=next_ws,
+            rationales=[Rationale(
+                text=await self.constructive_convergence(focus=focus, next_ws=next_ws)
+            )],
+        )

dialectical_framework/analyst/wheel_builder_transition_calculator.py

@@ -0,0 +1,157 @@
+from abc import ABC, abstractmethod
+from typing import Dict, Union
+
+from dialectical_framework.analyst.domain.cycle import Cycle
+from dialectical_framework.analyst.domain.transition import Transition
+from dialectical_framework.enums.predicate import Predicate
+from dialectical_framework.settings import Settings
+from dialectical_framework.synthesist.polarity.polarity_reasoner import \
+    PolarityReasoner
+from dialectical_framework.synthesist.wheel_builder import WheelBuilder
+from dialectical_framework.wheel import Wheel, WheelSegmentReference
+from dialectical_framework.wheel_segment import WheelSegment
+
+
+class WheelBuilderTransitionCalculator(WheelBuilder, ABC):
+    def __init__(self, builder: WheelBuilder):
+        super().__init__(text=builder.text)
+        self.__decorated_builder = builder
+
+    @property
+    def decorated_builder(self) -> WheelBuilder:
+        return self.__decorated_builder
+
+    @property
+    def reasoner(self) -> PolarityReasoner:
+        return self.__decorated_builder.reasoner
+
+    @property
+    def wheel_permutations(self) -> list[Wheel]:
+        return self.__decorated_builder.wheel_permutations
+
+    @property
+    def text(self) -> str | None:
+        return self.__decorated_builder.text
+
+    @property
+    def settings(self) -> Settings:
+        return self.__decorated_builder.settings
+
+    async def build_wheel_permutations(
+        self, *, theses: list[Union[str, None]] = None, t_cycle: Cycle = None
+    ) -> list[Wheel]:
+        await self.__decorated_builder.build_wheel_permutations(
+            theses=theses, t_cycle=t_cycle
+        )
+        return self.wheel_permutations
+
+    async def redefine(
+        self, modified_statement_per_alias: Dict[str, str]
+    ) -> list[Wheel]:
+        await self.__decorated_builder.redefine(
+            modified_statement_per_alias=modified_statement_per_alias
+        )
+        return self.wheel_permutations
+
+    async def calculate_syntheses(
+        self,
+        wheel: Wheel,
+        at: WheelSegmentReference | list[WheelSegmentReference] = None,
+    ):
+        await self.__decorated_builder.calculate_syntheses(wheel=wheel, at=at)
+
+    async def calculate_transitions(
+            self,
+            wheel: Wheel,
+            at: WheelSegmentReference | list[WheelSegmentReference] = None,
+    ):
+        if wheel not in self.wheel_permutations:
+            raise ValueError(f"Wheel permutation {wheel} not found in available wheels")
+
+        if at is None:
+            # Calculate for each
+            if hasattr(self.decorated_builder, "calculate_transitions"):
+                await self.decorated_builder.calculate_transitions(wheel=wheel, at=None)
+            # This is for subclasses to implement
+            trs = await self._do_calculate_transitions_all(wheel=wheel)
+            for tr in trs:
+                self._take_transition(wheel=wheel, transition=tr)
+        elif isinstance(at, list):
+            # Calculate for some
+            for ref in at:
+                if hasattr(self.decorated_builder, "calculate_transitions"):
+                    await self.decorated_builder.calculate_transitions(
+                        wheel=wheel, at=ref
+                    )
+                # This is for subclasses to implement
+                trs_i = await self._do_calculate_transitions(wheel=wheel, at=ref)
+                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)
+            # This is for subclasses to implement
+            trs = await self._do_calculate_transitions(wheel=wheel, at=at)
+            for tr in trs:
+                self._take_transition(wheel=wheel, transition=tr)
+
+        wheel.calculate_score()
+
+    @abstractmethod
+    async def _do_calculate_transitions(
+        self, wheel: Wheel, at: WheelSegment
+    ) -> list[Transition]:
+        """Subclasses implement the actual transition calculation logic here."""
+
+    @abstractmethod
+    async def _do_calculate_transitions_all(self, wheel: Wheel) -> list[Transition]:
+        """Subclasses implement the actual transition calculation logic here."""
+
+    @staticmethod
+    def _take_transition(wheel: Wheel, transition: Transition) -> None:
+        """
+        The decorator might be enriching the existing transition, so we need to merge, not just add
+        """
+        new_transition = transition
+
+        if transition.predicate == Predicate.TRANSFORMS_TO:
+            # this is only valid for wisdom units!
+            wu = wheel.wisdom_unit_at(transition.source)
+            old_transition = wu.transformation.graph.get_transition(
+                transition.source_aliases, transition.target_aliases
+            )
+            if old_transition is not None:
+                new_transition = old_transition.new_with(transition)
+            wu.transformation.graph.add_transition(new_transition)
+        elif transition.predicate == Predicate.CONSTRUCTIVELY_CONVERGES_TO:
+            old_transition = wheel.spiral.graph.get_transition(
+                transition.source_aliases, transition.target_aliases
+            )
+            if old_transition is not None:
+                new_transition = old_transition.new_with(transition)
+            wheel.spiral.graph.add_transition(new_transition)
+        elif transition.predicate == Predicate.CAUSES:
+            # Cycle graphs must be present in the wheel upfront, so we only enrich the transitions
+            # TODO: I'm not 100% confident, that given a transition we should update it in both cycles. They might have different rationales... in each cycle.
+            graph = None
+            old_transition = wheel.t_cycle.graph.get_transition(
+                transition.source_aliases, transition.target_aliases
+            )
+            if old_transition is not None:
+                graph = wheel.t_cycle.graph
+            if graph:
+                if old_transition is not None:
+                    new_transition = old_transition.new_with(transition)
+                graph.add_transition(new_transition)
+                graph = None
+
+            old_transition = wheel.cycle.graph.get_transition(
+                transition.source_aliases, transition.target_aliases
+            )
+            if old_transition is not None:
+                graph = wheel.cycle.graph
+            if graph:
+                if old_transition is not None:
+                    new_transition = old_transition.new_with(transition)
+                graph.add_transition(new_transition)

dialectical_framework/brain.py

@@ -0,0 +1,81 @@
+class Brain:
+    def __init__(self, *, ai_model: str, ai_provider: str | None):
+        if not ai_provider:
+            if not "/" in ai_model:
+                raise ValueError(
+                    "ai_model must be in the form of 'provider/model' if ai_provider is not specified."
+                )
+            else:
+                derived_ai_provider, derived_ai_model = ai_model.split("/", 1)
+                self._ai_provider, self._ai_model = (
+                    derived_ai_provider,
+                    derived_ai_model,
+                )
+        else:
+            if not "/" in ai_model:
+                self._ai_provider, self._ai_model = ai_provider, ai_model
+            else:
+                derived_ai_provider, derived_ai_model = ai_model.split("/", 1)
+                # Special case for litellm which can handle models with provider/ prefix
+                if ai_provider == "litellm":
+                    self._ai_provider, self._ai_model = ai_provider, ai_model
+                elif derived_ai_provider != ai_provider:
+                    raise ValueError(
+                        f"ai_provider '{ai_provider}' does not match ai_model '{ai_model}'"
+                    )
+                else:
+                    self._ai_provider, self._ai_model = (
+                        derived_ai_provider,
+                        derived_ai_model,
+                    )
+
+    def __str__(self):
+        provider, model = self.specification()
+        return f"Brain(provider='{provider}', model='{model}')"
+
+    def specification(self) -> tuple[str, str]:
+        return self._ai_provider, self._ai_model
+
+    def modified_specification(
+        self, *, ai_provider: str | None = None, ai_model: str | None = None
+    ) -> tuple[str, str]:
+        """
+        This doesn't mutate the current instance.
+        """
+        current_provider, current_model = self.specification()
+
+        if ai_provider == "litellm":
+            if not ai_model:
+                if not current_provider and not current_model:
+                    raise ValueError("ai_model not provided.")
+                else:
+                    return ai_provider, f"{current_provider}/{current_model}"
+            else:
+                if not "/" in ai_model:
+                    if not current_provider:
+                        raise ValueError(
+                            "ai_model must be in the form of 'provider/model' for litellm."
+                        )
+                    else:
+                        return ai_provider, f"{current_provider}/{ai_model}"
+                else:
+                    return ai_provider, ai_model
+
+        if not ai_provider:
+            if not "/" in ai_model:
+                raise ValueError(
+                    "ai_model must be in the form of 'provider/model' if ai_provider is not specified."
+                )
+            else:
+                derived_ai_provider, derived_ai_model = ai_model.split("/", 1)
+                return derived_ai_provider, derived_ai_model
+        else:
+            if not "/" in ai_model:
+                return ai_provider, ai_model
+            else:
+                derived_ai_provider, derived_ai_model = ai_model.split("/", 1)
+                if derived_ai_provider != ai_provider:
+                    raise ValueError(
+                        f"ai_provider '{ai_provider}' does not match ai_model '{ai_model}'"
+                    )
+                return derived_ai_provider, derived_ai_model

dialectical_framework/dialectical_analysis.py

@@ -0,0 +1,14 @@
+
+from pydantic import BaseModel, ConfigDict
+
+from dialectical_framework.wisdom_unit import WisdomUnit
+
+
+class DialecticalAnalysis(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+
+    # TODO: This should rather be documents, references, images, texts...
+    corpus: str = None
+    perspectives: list[WisdomUnit] = []

dialectical_framework/dialectical_component.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import re
+
+from pydantic import Field
+
+from dialectical_framework.protocols.ratable import Ratable
+
+
+class DialecticalComponent(Ratable):
+    alias: str = Field(
+        ...,
+        description="The user friendly name of the dialectical component such as T, A, T+, A+, etc.",
+    )
+    statement: str = Field(
+        ...,
+        description="The dialectical component value that is provided after analysis.",
+    )
+
+    def is_same(self, other: DialecticalComponent) -> bool:
+        """
+        Determines if the current object is equal to another object based on their attributes.
+
+        This method compares the `alias` and `statement` attributes of the current object
+        with those of another object to check if they are identical.
+
+        Args:
+            other: The object to compare against the current object.
+
+        Returns:
+            bool: True if both `alias` and `statement` attributes of the objects are
+            the same, otherwise False.
+        """
+        return (
+            self == other
+            or self.alias == other.alias
+            and self.statement == other.statement
+        )
+
+    def get_human_friendly_index(self) -> int:
+        """
+        Converts the alias of an object into a human-friendly integer index.
+
+        This method processes an alias string provided by the object and identifies
+        the last sequence of digits as the human-readable integer index. If no index
+        can be identified, the method defaults to returning zero.
+
+        Returns:
+            int: The extracted integer index if present; otherwise, returns 0.
+        """
+        # Find the last sequence of digits in the alias
+        match = re.search(r"(\d+)(?!.*\d)", self.alias)
+        return int(match.group(1)) if match else 0
+
+    def set_human_friendly_index(self, human_friendly_index: int):
+        """
+        Updates the alias of the object by replacing the last sequence of digits with the
+        provided human-friendly index. If the index is 0, removes any existing digits entirely.
+        If no digits exist and index > 0, inserts the index before any trailing signs.
+
+        Args:
+            human_friendly_index: The integer index to replace the last sequence of digits
+            in the alias with. If 0, removes existing digits.
+        """
+        if human_friendly_index == 0:
+            # Remove the last sequence of digits entirely
+            self.alias = re.sub(r"(\d+)(?!.*\d)", "", self.alias)
+        else:
+            # Try to replace existing digits first
+            if re.search(r"\d", self.alias):
+                # Replace the last sequence of digits with the new index
+                self.alias = re.sub(
+                    r"(\d+)(?!.*\d)", str(human_friendly_index), self.alias
+                )
+            else:
+                # No digits exist, insert before any trailing signs
+                match = re.search(r"([+-]+)$", self.alias)
+                if match:
+                    # Has trailing signs, insert index before them
+                    base = self.alias[: match.start()]
+                    signs = match.group(1)
+                    self.alias = f"{base}{human_friendly_index}{signs}"
+                else:
+                    # No trailing signs, just append the index
+                    self.alias = f"{self.alias}{human_friendly_index}"
+
+    def calculate_probability(self, *, mutate: bool = True) -> float | None:
+        """
+        Fallback to 1.0 for leaves.
+        """
+
+        # A statement is a fact, so probability is always 1.0
+        probability = self.probability if self.probability is not None else 1.0
+
+        if mutate:
+            self.probability = probability
+
+        return probability
+
+    def pretty(
+        self, dialectical_component_label: str | None = None, *, skip_explanation=False
+    ) -> str:
+        if not dialectical_component_label:
+            dialectical_component_label = self.alias
+        result = f"{dialectical_component_label} = {self.statement}"
+        if self.best_rationale and not skip_explanation:
+            result = f"{result}\nExplanation: {self.best_rationale.text if self.best_rationale else ''}"
+        return result
+
+    def __str__(self):
+        return self.pretty()

dialectical_framework/dialectical_components_deck.py

@@ -0,0 +1,48 @@
+
+from pydantic import BaseModel, Field
+
+from dialectical_framework.dialectical_component import DialecticalComponent
+
+
+class DialecticalComponentsDeck(BaseModel):
+    dialectical_components: list[DialecticalComponent] = Field(
+        ...,
+        description="A list of dialectical components. It can be empty when no dialectical components are found. It might also be filled with only one dialectical component if only one is to be found.",
+    )
+
+    def get_aliases_as_cycle_str(self) -> str:
+        aliases = self.get_aliases()
+
+        if len(aliases) < 2:
+            return ""
+        else:
+            # Create a simple cycle: first → second → third → ... → first
+            cycle_parts = aliases + [aliases[0]]  # Add first element at the end
+            return " → ".join(cycle_parts) + "..."
+
+    def get_aliases(self) -> list[str]:
+        return [dc.alias for dc in self.dialectical_components]
+
+    def get_by_alias(self, alias: str) -> DialecticalComponent:
+        return next(filter(lambda d: d.alias == alias, self.dialectical_components))
+
+    def rearrange_by_aliases(
+        self, ordered_aliases: list[str], mutate: bool = False
+    ) -> list[DialecticalComponent]:
+        # Use dict to maintain first occurrence order while removing duplicates
+        unique_aliases = dict.fromkeys(ordered_aliases)
+
+        sorted_components = []
+        for alias in unique_aliases:
+            component = next(
+                (c for c in self.dialectical_components if c.alias == alias), None
+            )
+            if component:
+                sorted_components.append(component)
+
+        if mutate:
+            # mutate the existing list in place instead of rebinding the attribute
+            self.dialectical_components[:] = sorted_components
+            return self.dialectical_components
+        else:
+            return sorted_components

dialectical_framework/dialectical_reasoning.py

@@ -0,0 +1,105 @@
+import importlib
+import pkgutil
+
+from dependency_injector import containers, providers
+
+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.thesis_extractor import ThesisExtractor
+from dialectical_framework.settings import Settings
+from dialectical_framework.synthesist.causality.causality_sequencer_balanced import \
+    CausalitySequencerBalanced
+from dialectical_framework.synthesist.causality.causality_sequencer_desirable import \
+    CausalitySequencerDesirable
+from dialectical_framework.synthesist.causality.causality_sequencer_feasible import \
+    CausalitySequencerFeasible
+from dialectical_framework.synthesist.causality.causality_sequencer_realistic import \
+    CausalitySequencerRealistic
+from dialectical_framework.synthesist.concepts.thesis_extractor_basic import \
+    ThesisExtractorBasic
+from dialectical_framework.synthesist.polarity.polarity_reasoner import \
+    PolarityReasoner
+from dialectical_framework.synthesist.polarity.reason_fast_and_simple import \
+    ReasonFastAndSimple
+from dialectical_framework.synthesist.wheel_builder import WheelBuilder
+
+
+class DialecticalReasoning(containers.DeclarativeContainer):
+    """
+    Main DI container for the Dialectical Reasoning Framework.
+
+    Provides injectable services for building wheels and calculating transitions.
+
+
+    IMPORTANT:
+    When renaming the fields, make sure to also change it in di.py, as IDE refactoring will not do it automatically.
+    """
+
+    @classmethod
+    def setup(cls, settings: Settings) -> 'DialecticalReasoning':
+        """Create a new container instance with user-specific settings."""
+        container = cls()
+        container.settings.override(settings)
+        return container
+
+    # It will be the same settings for all services in the container
+    settings = providers.Dependency(instance_of=Settings)
+
+    brain: providers.Factory[Brain] = providers.Factory(
+        lambda settings: Brain(ai_model=settings.ai_model, ai_provider=settings.ai_provider),
+        settings=settings
+    )
+
+    polarity_reasoner: providers.Factory[PolarityReasoner] = providers.Factory(
+        ReasonFastAndSimple,
+    )
+
+
+    @staticmethod
+    def _create_causality_sequencer(settings: Settings) -> CausalitySequencer:
+        """Factory method to create the appropriate causality sequencer based on config"""
+        causality_type = settings.causality_type
+
+        if causality_type == CausalityType.DESIRABLE:
+            return CausalitySequencerDesirable()
+        elif causality_type == CausalityType.FEASIBLE:
+            return CausalitySequencerFeasible()
+        elif causality_type == CausalityType.REALISTIC:
+            return CausalitySequencerRealistic()
+        else:
+            return CausalitySequencerBalanced()
+
+    causality_sequencer: providers.Factory[CausalitySequencer] = providers.Factory(
+        _create_causality_sequencer,
+        settings=settings,
+    )
+
+    thesis_extractor: providers.Factory[ThesisExtractor] = providers.Factory(
+        ThesisExtractorBasic,
+    )
+
+    wheel_builder: providers.Factory[WheelBuilder] = providers.Factory(WheelBuilder)
+
+    # -- Wiring --
+
+    @staticmethod
+    def _discover_modules() -> list[str]:
+        try:
+            package = importlib.import_module("dialectical_framework")
+            modules = []
+
+            for _, module_name, _ in pkgutil.walk_packages(
+                package.__path__, package.__name__ + "."
+            ):
+                modules.append(module_name)
+
+            return modules
+        except (ImportError, AttributeError):
+            # Fallback to empty list if package can't be imported
+            return []
+
+    wiring_config = containers.WiringConfiguration(
+        modules=_discover_modules(),
+    )