dialectical-framework 0.4.4__py3-none-any.whl

dialectical_framework/protocols/causality_sequencer.py

@@ -0,0 +1,111 @@
+from abc import abstractmethod
+from itertools import permutations
+from typing import Union
+
+from dialectical_framework.analyst.domain.cycle import Cycle
+from dialectical_framework.dialectical_component import DialecticalComponent
+from dialectical_framework.protocols.reloadable import Reloadable
+from dialectical_framework.wisdom_unit import WisdomUnit
+
+
+class CausalitySequencer(Reloadable):
+    @abstractmethod
+    async def arrange(
+        self, thoughts: Union[list[str], list[WisdomUnit], list[DialecticalComponent]]
+    ) -> list[Cycle]:
+        """
+        Arranges items in multiple sequences and arranges them as cycles.
+        IMPORTANT: we don't do single sequence estimation isolated, because they all depend on each other.
+        Isolated estimation would lead to some sort of unnormalized probabilities, which is not good.
+        """
+        ...
+
+
+def generate_permutation_sequences(
+    dialectical_components: list[DialecticalComponent],
+) -> list[list[DialecticalComponent]]:
+    if len(dialectical_components) < 2:
+        return []
+
+    first, rest = dialectical_components[0], dialectical_components[1:]
+    sequences = list([first, *p] for p in permutations(rest))
+    return sequences
+
+
+def generate_compatible_sequences(
+    ordered_wisdom_units: list[WisdomUnit],
+) -> list[list[DialecticalComponent]]:
+    """
+    Generate all circular, diagonally symmetric arrangements for T/A pairs.
+
+    Each wisdom unit consists of a thesis (`T`) and its antithesis (`A`). This function arranges them
+    around a circle (of length 2n, where n is the number of units) such that:
+
+    1. **Circular Symmetry**: For each pair, if `T_i` is at position `p`, then `A_i` is at position `(p + n) % (2n)`.
+    2. **Order Preservation**: The order of all `T`s matches their input order and is strictly increasing
+       in placement (i.e., `T1` before `T2`, etc.).
+    3. **Start Condition**: The sequence always starts with the first thesis (`T1`) at position 0.
+
+    Parameters:
+        ordered_wisdom_units (list): List of wisdom units, each having `.t.alias` (thesis) and `.a.alias` (antithesis).
+
+    Returns:
+        list of list: Each inner list is a possible arrangement; positions 0..n-1 represent the 'top row'
+        (or first semi-circle), and positions n..2n-1 represent the 'bottom row' (or mirrored second semi-circle),
+        such that the diagonal relationship and thesis order constraints are always met.
+
+    Example:
+        For input units T1/A1, T2/A2, T3/A3, T4/A4, a valid output can be:
+            [T1, T2, A4, T3, A1, A2, T4, A3]
+        Which means:
+            Top:    T1 -> T2 -> A4 -> T3
+            Bottom: A1 -> A2 -> T4 -> A3 (mirrored on the circle)
+    """
+
+    n = len(ordered_wisdom_units)
+    ts = [u.t for u in ordered_wisdom_units]
+    as_ = [u.a for u in ordered_wisdom_units]
+    size = 2 * n
+
+    results = []
+
+    # Step 1: set T1 at 0, its diagonal A1 at n
+    def backtrack(t_positions, next_t_idx):
+        if next_t_idx == n:
+            # Fill arrangement based on t_positions
+            arrangement = [None] * size
+            occupied = set()
+            for t_idx, pos in enumerate(t_positions):
+                arrangement[pos] = ts[t_idx]
+                diag = (pos + n) % size
+                arrangement[diag] = as_[t_idx]
+                occupied.add(pos)
+                occupied.add(diag)
+            results.append(arrangement)
+            return
+
+        # Next ti to place: always in order, always > previous ti's position
+        # Skip positions already assigned (to ensure symmetry and distinctness)
+        prev_pos = t_positions[-1]
+        for pos in range(prev_pos + 1, size):
+            diag = (pos + n) % size
+
+            # Check if pos or diag are used by previous Ts/A's
+            collision = False
+            for prev_t_pos in t_positions:
+                if pos == prev_t_pos or diag == prev_t_pos:
+                    collision = True
+                    break
+                prev_diag = (prev_t_pos + n) % size
+                if pos == prev_diag or diag == prev_diag:
+                    collision = True
+                    break
+            if collision:
+                continue
+
+            # Place next T at pos, corresponding A at diag
+            backtrack(t_positions + [pos], next_t_idx + 1)
+
+    # T1 fixed at position 0
+    backtrack([0], 1)
+    return results

dialectical_framework/protocols/content_fidelity_evaluator.py

@@ -0,0 +1,16 @@
+from abc import abstractmethod
+from typing import Union
+
+
+from dialectical_framework.dialectical_component import DialecticalComponent
+from dialectical_framework.protocols.reloadable import Reloadable
+from dialectical_framework.wheel import Wheel
+from dialectical_framework.wheel_segment import WheelSegment
+
+
+class ContentFidelityEvaluator(Reloadable):
+    @abstractmethod
+    async def evaluate(self, *, target: Union[
+        list[str | DialecticalComponent | WheelSegment | Wheel],
+        str, DialecticalComponent, WheelSegment, Wheel
+    ]) -> DialecticalComponent: ...

dialectical_framework/protocols/has_brain.py

@@ -0,0 +1,18 @@
+from typing import Protocol, runtime_checkable
+
+from dependency_injector.wiring import Provide, inject
+
+from dialectical_framework.brain import Brain
+from dialectical_framework.enums.di import DI
+
+
+@inject
+def di_brain(brain: Brain = Provide[DI.brain]) -> Brain:
+    return brain
+
+
+@runtime_checkable
+class HasBrain(Protocol):
+    @property
+    def brain(self) -> Brain:
+        return di_brain()

dialectical_framework/protocols/has_config.py

@@ -0,0 +1,18 @@
+from typing import Protocol, runtime_checkable
+
+from dependency_injector.wiring import Provide, inject
+
+from dialectical_framework.enums.di import DI
+from dialectical_framework.settings import Settings
+
+
+@inject
+def di_settings(settings: Settings = Provide[DI.settings]) -> Settings:
+    return settings
+
+
+@runtime_checkable
+class SettingsAware(Protocol):
+    @property
+    def settings(self) -> Settings:
+        return di_settings()

dialectical_framework/protocols/ratable.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from abc import ABC
+from typing import TYPE_CHECKING, final, List
+
+from pydantic import ConfigDict, Field
+
+from dialectical_framework.protocols.assessable import Assessable
+from dialectical_framework.utils.gm import gm_with_zeros_and_nones_handled
+
+if TYPE_CHECKING: # Conditionally import Rationale for type checking only
+    pass
+
+class Ratable(Assessable, ABC):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+    )
+
+    rating: float | None = Field(
+        default=None, ge=0.0, le=1.0,
+        description="Importance/quality rating."
+    )
+
+    confidence: float | None = Field(
+        default=None, ge=0.0, le=1.0,
+        description="Credibility/reputation/confidence of the expert making probability assessments. Used for weighing probabilities (applied during aggregation)")
+
+    def rating_or_default(self) -> float:
+        """
+        The default rating is 1.0 when None.
+        It's a convenient thing, this way we can estimate higher level CFs and propagate them up and down.
+        """
+        return self.rating if self.rating is not None else 1.0
+
+    def confidence_or_default(self) -> float:
+        """
+        The default confidence is 0.5 when None. This is a rather technical thing, we are never 100% sure, so 0.5 is ok.
+        """
+        return self.confidence if self.confidence is not None else 0.5
+
+    def _hard_veto_on_own_zero(self) -> bool:
+        return True  # default for DC and Transition
+
+    def calculate_contextual_fidelity(self, *, mutate: bool = True) -> float:
+        """
+        Leaves combine:
+          - own intrinsic CF × own rating (if present; 0 may be a hard veto by policy),
+          - rated rationale CFs (weighted in the base helper),
+          - any subclass sub-elements (e.g., Rationale's wheels), unrated here.
+        Neutral fallback = 1.0. Parent rating never reweights children.
+        """
+        own_cf = self.contextual_fidelity
+        own_rating = self.rating_or_default()
+
+        # 1) Hard veto on intrinsic CF == 0, independent of rating (policy-controlled)
+        if own_cf is not None and own_cf == 0.0 and self._hard_veto_on_own_zero():
+            # Do NOT overwrite the manual CF field; return veto as the effective value
+            return 0.0
+
+        # 2) Collect child contributions (already filtered/weighted by helpers)
+        parts: List[float] = []
+        parts.extend(v for v in (self._calculate_contextual_fidelity_for_rationales(mutate=mutate) or [])
+                     if v is not None and v > 0.0)
+        parts.extend(
+            v for v in (self._calculate_contextual_fidelity_for_sub_elements_excl_rationales(mutate=mutate) or [])
+            if v is not None and v > 0.0)
+
+        # 3) Include own positive contribution if present
+        if own_cf is not None and own_cf > 0.0 and own_rating > 0.0:
+            parts.append(own_cf * own_rating)
+
+        # 4) Aggregate or neutral fallback
+        fidelity = gm_with_zeros_and_nones_handled(parts) if parts else 1.0
+
+        # 5) Cache only if there was no manual CF provided (don't clobber human input)
+        if mutate and own_cf is None:
+            self.contextual_fidelity = fidelity
+
+        return fidelity

dialectical_framework/protocols/reloadable.py

@@ -0,0 +1,7 @@
+from abc import ABC, abstractmethod
+from typing import Self
+
+
+class Reloadable(ABC):
+    @abstractmethod
+    def reload(self, **kwargs) -> Self: ...

dialectical_framework/protocols/thesis_extractor.py

@@ -0,0 +1,15 @@
+from abc import abstractmethod
+
+
+from dialectical_framework.dialectical_component import DialecticalComponent
+from dialectical_framework.dialectical_components_deck import \
+    DialecticalComponentsDeck
+from dialectical_framework.protocols.reloadable import Reloadable
+
+
+class ThesisExtractor(Reloadable):
+    @abstractmethod
+    async def extract_multiple_theses( self, *, count: int = 2) -> DialecticalComponentsDeck: ...
+
+    @abstractmethod
+    async def extract_single_thesis(self) -> DialecticalComponent: ...

dialectical_framework/settings.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import os
+from typing import Optional, Self
+
+from dotenv import load_dotenv
+from pydantic import BaseModel, ConfigDict, Field
+
+from dialectical_framework.enums.causality_type import CausalityType
+
+
+class Settings(BaseModel):
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+    )
+
+    ai_model: str = Field(..., description="AI model alias/deployment to use.")
+    ai_provider: Optional[str] = Field(default=None, description="AI model provider to use.")
+    component_length: int = Field(default=7, description="Approximate length in words of the dialectical component.")
+    causality_type: CausalityType = Field(default=CausalityType.BALANCED, description="Type of causality in the wheel.")
+
+    @classmethod
+    def from_partial(cls, partial_settings: Optional[Settings] = None) -> Self:
+        """
+        Create GenerationSettings by merging partial settings with environment defaults.
+        Missing fields in partial_settings are filled from Settings.from_env().
+        """
+        if partial_settings is None:
+            return cls.from_env()
+
+        # Get full defaults from environment
+        env_defaults = cls.from_env()
+
+        # Convert partial_settings to dict, excluding None values
+        partial_dict = partial_settings.model_dump(exclude_none=True) if partial_settings else {}
+
+        # Convert env_defaults to dict
+        env_dict = env_defaults.model_dump()
+
+        # Merge: partial_settings override env_defaults
+        merged_dict = {**env_dict, **partial_dict}
+
+        # Create new instance from merged data
+        return cls(**merged_dict)
+
+    @classmethod
+    def from_env(cls) -> Self:
+        """
+        Static method to set up and return a Config instance.
+        It uses environment variables or hardcoded defaults for configuration.
+        """
+        load_dotenv()
+
+        model = os.getenv("DIALEXITY_DEFAULT_MODEL", None)
+        provider = os.getenv("DIALEXITY_DEFAULT_MODEL_PROVIDER", None)
+        missing = []
+        if not model:
+            missing.append("DIALEXITY_DEFAULT_MODEL")
+        if not provider:
+            if "/" not in model:
+                missing.append("DIALEXITY_DEFAULT_MODEL_PROVIDER")
+            else:
+                # We will give litellm a chance to derive the provider from the model
+                pass
+        if missing:
+            raise ValueError(
+                f"Missing required environment variables: {', '.join(missing)}"
+            )
+
+        return cls(
+            ai_model=model,
+            ai_provider=provider,
+            component_length=int(os.getenv("DIALEXITY_DEFAULT_COMPONENT_LENGTH", 7)),
+            causality_type=CausalityType(
+                os.getenv("DIALEXITY_DEFAULT_CAUSALITY_TYPE", CausalityType.BALANCED.value)
+            ),
+        )

dialectical_framework/synthesis.py

@@ -0,0 +1,7 @@
+from dialectical_framework.wheel_segment import WheelSegment
+
+ALIAS_S_PLUS = "S+"
+ALIAS_S_MINUS = "S-"
+
+
+class Synthesis(WheelSegment): ...

dialectical_framework/synthesist/__init__.py

@@ -0,0 +1 @@
+