dialectical-framework 0.4.4__tar.gz

dialectical_framework-0.4.4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dialexity
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dialectical_framework-0.4.4/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.3
+Name: dialectical-framework
+Version: 0.4.4
+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,reasoning,ai,philosophy,logic
+Author: Evaldas Taroza
+Author-email: evaldas@dialexity.com
+Requires-Python: >=3.11,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Dist: dependency-injector (>=4.48.1,<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: 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
+Description-Content-Type: text/markdown
+
+# Dialectical 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.
+
+## What It Does:
+ - Converts natural language into Dialectical Wheels (DWs)
+ - Highlights thesis–antithesis tensions and feedback loops
+ - Reveals overlooked leverage points and systemic blind-spots
+ - Maps decisions, ethics, or mindsets across dialectical structures
+
+## Built for:
+ - Systems optimization
+ - Wisdom mining & decision diagnostics
+ - Augmented intelligence / narrative AI
+ - Ethical modeling & polarity navigation
+
+## Useful for:
+ - Consultants, coaches, facilitators, and system designers
+ - Storytellers, educators, and regenerative thinkers
+ - Strategists, SDD/BIMA practitioners, values-driven innovators
+
+## Learn more:
+ - [Dialectical Wheels Overview](https://dialexity.com/blog/dialectical-wheels-for-systems-optimization/)
+ - [Wisdom Mining & Tokenomics](https://dialexity.com/blog/dialectical-token-dlt/)
+ - [Dialectical Ethics](https://dialexity.com/blog/dialectical-ethics/)
+ - [Earlier Work](https://dialexity.com/blog/wp-content/uploads/2023/11/Moral-Wisdom-from-Ontology-1.pdf)
+
+# Development
+
+## Contributors Welcome!
+
+We invite developers, philosophers, cognitive scientists, and regenerative ecosystem builders to co-create with us.
+
+## Setup
+
+Behind the scenes we heavily rely on [Mirascope](https://mirascope.com/)
+
+## Environment Variables
+
+| Variable Name                    | Description                          | Example Value |
+|----------------------------------|--------------------------------------|---------------|
+| DIALEXITY_DEFAULT_MODEL          | Default model name for the framework | gpt-4         |
+| DIALEXITY_DEFAULT_MODEL_PROVIDER | Model provider (required)            | openai        |
+
+You can store these in a `.env` file or export them in your environment.
+
+These will specify the default "brain" for your reasoning.
+
+## Architecture
+
+At the core of the dialectical framework is a dialectical wheel. It is a fancy semantic graph where nodes are statements or concepts and edges are relationships such as "opposite of," "complementary to," etc. To make the graph more readable, it's depicted as a 2D wheel.
+
+| Simple                                              | More Complicated                                     |
+|-----------------------------------------------------|------------------------------------------------------|
+| ![Dialectical Wheel Diagram](docs/wheel-scheme.png) | ![Dialectical Wheel Diagram](docs/wheel-scheme2.png) |
+
+The main architectural parts are:
+- Wheel
+- Wheel Segment
+- Wisdom Unit
+- Dialectical Component
+- Transition
+
+
+**Wheel** is composed of segments. Think of a dialectical wheel as a pizza, a segment is a slice of pizza. In the simplest case it represents some thesis (a statement, a concept, an action, a thought, an idea, etc.). A thesis can have positive and negative things related to it. Hence, a segment of a wheel is composed of these dialectical components: a thesis (T), positive side of that thesis (T+) and a negative side of that thesis (T-). In more detailed wheels, a segment could have more than 3 layers.
+
+If we take two opposite segments, we get the basic (and the most important) structure: **Wisdom Unit** (half-wheel, verified by diagonal constraints: control statements). It's composed of:
+
+| Dialectical Component | Description                      |
+|-----------------------|----------------------------------|
+| T-                    | Negative side of the main thesis |
+| T                     | The thesis                       |
+| T+                    | Positive side of the main thesis |
+| A+                    | Positive side of the antithesis  |
+| A                     | The antithesis                   |
+| A-                    | Negative side of the antithesis  |
+
+In a Wheel, segments next to each other are related. We wrap that relationship into a **Transition**. Practically, a Transition is a recipe for how to go from one segment to another in a way that we approach synthesis. Essentially, it shows how the negative side of a given thesis (Tn-) converts into the positive side of the following thesis (T(n+1)+). If we were to look at a wheel as a sliced pizza, the lines that separate the slices would be Transitions.
+
+If we derive Transitions in a Wheel with only 2 segments (aka half-wheel), they are symmetrical and represent a special kind of Wisdom Unit, we call it Action (Ac) and Reflection (Re). As any Wisdom Unit, Action and Reflection must be verified by diagonal constraints as well.
+
+## Prototyping & App Ideas
+
+### Simple Win-Win Finder
+![Win-Win Finder](./docs/b2c-mvp.png)
+
+### Eye-Opener
+Working beta product [Eye Opener](https://app.dialexity.com/aiapps/eye-opener). It's a tool that analyzes text and generates a visual map of its underlying structure and hidden assumptions. The core feature is a graph-like interface we call the Dialectical Wheel, that shows the delayed dialectical responses ("blind spots").
+
+### Argument Inspector
+Working beta product [Argument Inspector](https://dialexity.com/start). Useful for analysts and mediators/facilitators to deeper understand the case.
+
+### Atlas of Feelings
+[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. 

dialectical_framework-0.4.4/README.md

@@ -0,0 +1,97 @@
+# Dialectical 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.
+
+## What It Does:
+ - Converts natural language into Dialectical Wheels (DWs)
+ - Highlights thesis–antithesis tensions and feedback loops
+ - Reveals overlooked leverage points and systemic blind-spots
+ - Maps decisions, ethics, or mindsets across dialectical structures
+
+## Built for:
+ - Systems optimization
+ - Wisdom mining & decision diagnostics
+ - Augmented intelligence / narrative AI
+ - Ethical modeling & polarity navigation
+
+## Useful for:
+ - Consultants, coaches, facilitators, and system designers
+ - Storytellers, educators, and regenerative thinkers
+ - Strategists, SDD/BIMA practitioners, values-driven innovators
+
+## Learn more:
+ - [Dialectical Wheels Overview](https://dialexity.com/blog/dialectical-wheels-for-systems-optimization/)
+ - [Wisdom Mining & Tokenomics](https://dialexity.com/blog/dialectical-token-dlt/)
+ - [Dialectical Ethics](https://dialexity.com/blog/dialectical-ethics/)
+ - [Earlier Work](https://dialexity.com/blog/wp-content/uploads/2023/11/Moral-Wisdom-from-Ontology-1.pdf)
+
+# Development
+
+## Contributors Welcome!
+
+We invite developers, philosophers, cognitive scientists, and regenerative ecosystem builders to co-create with us.
+
+## Setup
+
+Behind the scenes we heavily rely on [Mirascope](https://mirascope.com/)
+
+## Environment Variables
+
+| Variable Name                    | Description                          | Example Value |
+|----------------------------------|--------------------------------------|---------------|
+| DIALEXITY_DEFAULT_MODEL          | Default model name for the framework | gpt-4         |
+| DIALEXITY_DEFAULT_MODEL_PROVIDER | Model provider (required)            | openai        |
+
+You can store these in a `.env` file or export them in your environment.
+
+These will specify the default "brain" for your reasoning.
+
+## Architecture
+
+At the core of the dialectical framework is a dialectical wheel. It is a fancy semantic graph where nodes are statements or concepts and edges are relationships such as "opposite of," "complementary to," etc. To make the graph more readable, it's depicted as a 2D wheel.
+
+| Simple                                              | More Complicated                                     |
+|-----------------------------------------------------|------------------------------------------------------|
+| ![Dialectical Wheel Diagram](docs/wheel-scheme.png) | ![Dialectical Wheel Diagram](docs/wheel-scheme2.png) |
+
+The main architectural parts are:
+- Wheel
+- Wheel Segment
+- Wisdom Unit
+- Dialectical Component
+- Transition
+
+
+**Wheel** is composed of segments. Think of a dialectical wheel as a pizza, a segment is a slice of pizza. In the simplest case it represents some thesis (a statement, a concept, an action, a thought, an idea, etc.). A thesis can have positive and negative things related to it. Hence, a segment of a wheel is composed of these dialectical components: a thesis (T), positive side of that thesis (T+) and a negative side of that thesis (T-). In more detailed wheels, a segment could have more than 3 layers.
+
+If we take two opposite segments, we get the basic (and the most important) structure: **Wisdom Unit** (half-wheel, verified by diagonal constraints: control statements). It's composed of:
+
+| Dialectical Component | Description                      |
+|-----------------------|----------------------------------|
+| T-                    | Negative side of the main thesis |
+| T                     | The thesis                       |
+| T+                    | Positive side of the main thesis |
+| A+                    | Positive side of the antithesis  |
+| A                     | The antithesis                   |
+| A-                    | Negative side of the antithesis  |
+
+In a Wheel, segments next to each other are related. We wrap that relationship into a **Transition**. Practically, a Transition is a recipe for how to go from one segment to another in a way that we approach synthesis. Essentially, it shows how the negative side of a given thesis (Tn-) converts into the positive side of the following thesis (T(n+1)+). If we were to look at a wheel as a sliced pizza, the lines that separate the slices would be Transitions.
+
+If we derive Transitions in a Wheel with only 2 segments (aka half-wheel), they are symmetrical and represent a special kind of Wisdom Unit, we call it Action (Ac) and Reflection (Re). As any Wisdom Unit, Action and Reflection must be verified by diagonal constraints as well.
+
+## Prototyping & App Ideas
+
+### Simple Win-Win Finder
+![Win-Win Finder](./docs/b2c-mvp.png)
+
+### Eye-Opener
+Working beta product [Eye Opener](https://app.dialexity.com/aiapps/eye-opener). It's a tool that analyzes text and generates a visual map of its underlying structure and hidden assumptions. The core feature is a graph-like interface we call the Dialectical Wheel, that shows the delayed dialectical responses ("blind spots").
+
+### Argument Inspector
+Working beta product [Argument Inspector](https://dialexity.com/start). Useful for analysts and mediators/facilitators to deeper understand the case.
+
+### Atlas of Feelings
+[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. 

dialectical_framework-0.4.4/pyproject.toml

@@ -0,0 +1,64 @@
+[tool.poetry]
+name = "dialectical-framework"
+version = "0.4.4"
+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"
+license = "MIT"
+homepage = "https://github.com/dialexity/dialectical-framework"
+repository = "https://github.com/dialexity/dialectical-framework"
+keywords = ["dialectics", "reasoning", "ai", "philosophy", "logic"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[[tool.poetry.packages]]
+include = "dialectical_framework"
+from = "src"
+
+
+
+[tool.poetry.dependencies]
+python = "^3.11"
+mirascope = {extras = [
+    "azure",
+    "openai",
+    "anthropic",
+    "litellm",
+    "bedrock",
+    "langfuse",
+    "tenacity"
+], version = "^1.25.6"}
+python-dotenv = "^1.1.1"
+tabulate = "^0.9.0"
+dependency-injector = "^4.48.1"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.4.1"
+black = "^25.1.0"
+isort = "^6.0.1"
+#flake8 = "^7.1.2"
+pytest-asyncio = "^1.1.0"
+autoflake = "^2.3.1"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+filterwarnings = [
+    "ignore::DeprecationWarning:mirascope.*",
+    "ignore::UserWarning:mirascope.*",
+    "ignore::DeprecationWarning:pydantic._internal._config",
+    "ignore::DeprecationWarning:httpx._models",
+    "ignore::UserWarning:pydantic.main"
+]

dialectical_framework-0.4.4/src/dialectical_framework/__init__.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+
+# Import all core Pydantic models that participate in potential circular dependencies.
+# The order of imports here ensures classes are defined before their `.model_rebuild()`
+# methods are called below.
+from .analyst.domain.assessable_cycle import AssessableCycle
+from .analyst.domain.cycle import Cycle
+from .analyst.domain.rationale import Rationale
+from .analyst.domain.spiral import Spiral
+from .analyst.domain.transformation import Transformation
+from .analyst.domain.transition import Transition
+from .analyst.domain.transition_cell_to_cell import TransitionCellToCell
+from .analyst.domain.transition_segment_to_segment import \
+    TransitionSegmentToSegment
+from .dialectical_component import DialecticalComponent
+from .protocols.assessable import Assessable
+from .protocols.ratable import Ratable
+from .synthesis import Synthesis
+from .wheel import Wheel
+from .wheel_segment import WheelSegment
+from .wisdom_unit import WisdomUnit
+
+# Explicitly call `model_rebuild()` on all models that might have forward references
+# or be part of circular dependencies. This forces Pydantic to resolve their schemas
+# after all classes are defined in the module.
+# The order of these rebuild calls is generally from base classes to derived classes,
+# or simply ensuring all interdependent models are covered.
+
+Assessable.model_rebuild()
+Ratable.model_rebuild()
+DialecticalComponent.model_rebuild()
+Rationale.model_rebuild()
+Synthesis.model_rebuild()
+Wheel.model_rebuild()
+WheelSegment.model_rebuild()
+Transition.model_rebuild()
+TransitionCellToCell.model_rebuild()
+TransitionSegmentToSegment.model_rebuild()
+AssessableCycle.model_rebuild()
+Cycle.model_rebuild()
+Spiral.model_rebuild()
+Transformation.model_rebuild()
+WisdomUnit.model_rebuild()

dialectical_framework-0.4.4/src/dialectical_framework/ai_dto/causal_cycle_assessment_dto.py

@@ -0,0 +1,16 @@
+
+from pydantic import BaseModel, Field
+
+
+class CausalCycleAssessmentDto(BaseModel):
+    probability: float = Field(
+        default=0,
+        description="The probability 0 to 1 of the arranged cycle to exist in reality.",
+    )
+    reasoning_explanation: str = Field(
+        default="", description="Explanation why/how this cycle might occur."
+    )
+    argumentation: str = Field(
+        default="",
+        description="Circumstances or contexts where this cycle would be most applicable or useful.",
+    )

dialectical_framework-0.4.4/src/dialectical_framework/ai_dto/causal_cycle_dto.py

@@ -0,0 +1,16 @@
+
+from pydantic import Field
+
+from dialectical_framework.ai_dto.causal_cycle_assessment_dto import \
+    CausalCycleAssessmentDto
+
+
+class CausalCycleDto(CausalCycleAssessmentDto):
+    """
+    Causal circular sequence of statements, where aliases reference each statement
+    """
+
+    aliases: list[str] = Field(
+        ...,
+        description="Aliases (not the explicit statements) arranged in the circular causality sequence (cycle) where the last element points to the first",
+    )

dialectical_framework-0.4.4/src/dialectical_framework/ai_dto/causal_cycles_deck_dto.py

@@ -0,0 +1,11 @@
+
+from pydantic import BaseModel, Field
+
+from dialectical_framework.ai_dto.causal_cycle_dto import CausalCycleDto
+
+
+class CausalCyclesDeckDto(BaseModel):
+    causal_cycles: list[CausalCycleDto] = Field(
+        ...,
+        description="A list of causal circular sequences (cycles). It might also be filled with only one if only one is to be found.",
+    )

dialectical_framework-0.4.4/src/dialectical_framework/ai_dto/dialectical_component_dto.py

@@ -0,0 +1,16 @@
+from pydantic import BaseModel, Field
+
+
+class DialecticalComponentDto(BaseModel):
+    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.",
+    )
+    explanation: str = Field(
+        default="",
+        description="The explanation how the dialectical component (statement) is derived.",
+    )

dialectical_framework-0.4.4/src/dialectical_framework/ai_dto/dialectical_components_deck_dto.py

@@ -0,0 +1,12 @@
+
+from pydantic import BaseModel, Field
+
+from dialectical_framework.ai_dto.dialectical_component_dto import \
+    DialecticalComponentDto
+
+
+class DialecticalComponentsDeckDto(BaseModel):
+    dialectical_components: list[DialecticalComponentDto] = 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.",
+    )

dialectical_framework-0.4.4/src/dialectical_framework/ai_dto/dto_mapper.py

@@ -0,0 +1,103 @@
+from typing import Dict, Generic, Type, TypeVar
+
+from pydantic import BaseModel
+
+from dialectical_framework import DialecticalComponent, Rationale
+from dialectical_framework.ai_dto.dialectical_component_dto import DialecticalComponentDto
+
+# Type variables for generic mapping
+DtoType = TypeVar('DtoType', bound=BaseModel)
+ModelType = TypeVar('ModelType', bound=BaseModel)
+
+
+class DtoMapper(Generic[DtoType, ModelType]):
+    """
+    Generic auto-mapper that uses field introspection to map between DTOs and models.
+    Works when models have compatible field names.
+    """
+
+    def __init__(self, dto_class: Type[DtoType], model_class: Type[ModelType]):
+        self.dto_class = dto_class
+        self.model_class = model_class
+
+    def map_from_dto(self, dto: DtoType, **kwargs) -> ModelType:
+        """
+        Auto-maps from DTO to model using common fields plus any additional kwargs.
+        """
+        # Get DTO field values
+        dto_data = dto.model_dump()
+
+        # Merge with additional kwargs (kwargs take precedence)
+        merged_data = {**dto_data, **kwargs}
+
+        # Filter to only include fields that exist in the target model
+        model_fields = self.model_class.model_fields.keys()
+        filtered_data = {k: v for k, v in merged_data.items() if k in model_fields}
+
+        return self.model_class(**filtered_data)
+
+    def map_list_from_dto(self, dtos: list[DtoType], **kwargs) -> list[ModelType]:
+        """
+        Maps a list of DTOs to domain models.
+
+        Args:
+            dtos: List of DTO instances to convert
+            **kwargs: Additional parameters for mapping
+
+        Returns:
+            List of domain model instances
+        """
+        return [self.map_from_dto(dto, **kwargs) for dto in dtos]
+
+class DialecticalComponentMapper(DtoMapper[DialecticalComponentDto, DialecticalComponent]):
+    def map_from_dto(self, dto: DialecticalComponentDto, **kwargs) -> ModelType:
+        mapped: DialecticalComponent = super().map_from_dto(dto, **kwargs)
+        if dto.explanation:
+            mapped.rationales.append(Rationale(
+                text=dto.explanation,
+            ))
+        return mapped
+
+# Registry for mappers
+_mapper_registry: Dict[tuple[Type, Type], DtoMapper] = {
+    # Use default DtoMapper if no specific mapper is registered
+
+    (DialecticalComponentDto, DialecticalComponent): DialecticalComponentMapper(DialecticalComponentDto, DialecticalComponent),
+}
+
+
+def register_mapper(dto_class: Type[DtoType], model_class: Type[ModelType], mapper: DtoMapper[DtoType, ModelType]):
+    """
+    Register a mapper for a specific DTO-Model pair.
+    """
+    _mapper_registry[(dto_class, model_class)] = mapper
+
+
+def get_mapper(dto_class: Type[DtoType], model_class: Type[ModelType]) -> DtoMapper[DtoType, ModelType]:
+    """
+    Get a mapper for a specific DTO-Model pair.
+    If no specific mapper is registered, returns an AutoMapper.
+    """
+    key = (dto_class, model_class)
+    if key in _mapper_registry:
+        return _mapper_registry[key]
+
+    # Return auto-mapper as fallback
+    return DtoMapper(dto_class, model_class)
+
+
+def map_from_dto(dto: DtoType, model_class: Type[ModelType], **kwargs) -> ModelType:
+    """
+    Convenience function to map from DTO to model.
+    """
+    mapper = get_mapper(type(dto), model_class)
+    return mapper.map_from_dto(dto, **kwargs)
+
+def map_list_from_dto(dtos: list[DtoType], model_class: Type[ModelType], **kwargs) -> list[ModelType]:
+    """
+    Convenience function to map a list of DTOs to domain models.
+    """
+    if not dtos:
+        return []
+    mapper = get_mapper(type(dtos[0]), model_class)
+    return mapper.map_list_from_dto(dtos, **kwargs)

dialectical_framework-0.4.4/src/dialectical_framework/ai_dto/reciprocal_solution_dto.py

@@ -0,0 +1,24 @@
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ReciprocalSolutionDto(BaseModel):
+    model_config = ConfigDict(
+        extra="forbid",
+    )
+    problem: str | None = Field(default=None, description="Problem statement")
+    linear_action: str | None = Field(
+        default=None, description="Solution(s) that transforms T- into A+"
+    )
+    dialectical_reflection: str | None = Field(
+        default=None, description="Complementary solution(s) that transforms A- into T+"
+    )
+
+    def __str__(self):
+        str_pieces = []
+        if self.problem:
+            str_pieces.append(f"Problem: {self.problem}")
+        if self.linear_action:
+            str_pieces.append(f"Linear action: {self.linear_action}")
+        if self.dialectical_reflection:
+            str_pieces.append(f"Dialectical reflection: {self.dialectical_reflection}")
+        return "\n".join(str_pieces)

dialectical_framework-0.4.4/src/dialectical_framework/analyst/__init__.py

@@ -0,0 +1 @@
+

dialectical_framework-0.4.4/src/dialectical_framework/analyst/consultant.py

@@ -0,0 +1,30 @@
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from dialectical_framework.analyst.domain.transition import Transition
+from dialectical_framework.brain import Brain
+from dialectical_framework.protocols.has_brain import HasBrain
+from dialectical_framework.wheel import Wheel
+
+
+class Consultant(ABC, HasBrain):
+    def __init__(
+        self,
+        *,
+        text: str,
+        wheel: Wheel,
+        brain: Optional[Brain] = None,
+    ):
+        self._text = text
+        self._wheel = wheel
+        self._brain = brain
+
+    @property
+    def brain(self) -> Brain:
+        return super().brain if self._brain is None else self._brain
+
+    @abstractmethod
+    async def rationalize(self, transition: Transition) -> Transition: ...
+    """
+    The main method of the class. It should return an enriched Transition with the new rationale.
+    """

dialectical_framework-0.4.4/src/dialectical_framework/analyst/decorator_action_reflection.py

@@ -0,0 +1,28 @@
+from dialectical_framework.analyst.domain.transition_segment_to_segment import \
+    TransitionSegmentToSegment
+from dialectical_framework.analyst.think_action_reflection import \
+    ThinkActionReflection
+from dialectical_framework.analyst.wheel_builder_transition_calculator import \
+    WheelBuilderTransitionCalculator
+from dialectical_framework.wheel import Wheel
+from dialectical_framework.wheel_segment import WheelSegment
+
+
+class DecoratorActionReflection(WheelBuilderTransitionCalculator):
+    async def _do_calculate_transitions(
+        self, wheel: Wheel, at: WheelSegment
+    ) -> list[TransitionSegmentToSegment]:
+        consultant = ThinkActionReflection(
+            text=self.text, wheel=wheel, brain=self.reasoner.brain
+        )
+
+        return await consultant.think(focus=at)
+
+    async def _do_calculate_transitions_all(
+        self, wheel: Wheel
+    ) -> list[TransitionSegmentToSegment]:
+        result: list[TransitionSegmentToSegment] = []
+        for wu in wheel.wisdom_units:
+            tr = await self._do_calculate_transitions(wheel, wu)
+            result.extend(tr)
+        return result

dialectical_framework-0.4.4/src/dialectical_framework/analyst/decorator_discrete_spiral.py

@@ -0,0 +1,30 @@
+
+from dialectical_framework.analyst.domain.transition_segment_to_segment import \
+    TransitionSegmentToSegment
+from dialectical_framework.analyst.think_constructive_convergence import \
+    ThinkConstructiveConvergence
+from dialectical_framework.analyst.wheel_builder_transition_calculator import \
+    WheelBuilderTransitionCalculator
+from dialectical_framework.wheel import Wheel
+from dialectical_framework.wheel_segment import WheelSegment
+
+
+class DecoratorDiscreteSpiral(WheelBuilderTransitionCalculator):
+    async def _do_calculate_transitions(
+        self, wheel: Wheel, at: WheelSegment
+    ) -> list[TransitionSegmentToSegment]:
+        consultant = ThinkConstructiveConvergence(
+            text=self.text, wheel=wheel, brain=self.reasoner.brain
+        )
+
+        return [await consultant.think(at)]
+
+    async def _do_calculate_transitions_all(
+        self, wheel: Wheel
+    ) -> list[TransitionSegmentToSegment]:
+        # TODO: use a single prompt to derive all transitions faster?
+        result: list[TransitionSegmentToSegment] = []
+        for i in range(wheel.degree):
+            tr = await self._do_calculate_transitions(wheel, wheel.wheel_segment_at(i))
+            result.extend(tr)
+        return result