crewmaster 0.1.0__tar.gz

crewmaster-0.1.0/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.3
+Name: crewmaster
+Version: 0.1.0
+Summary: Manejador de agentes
+Author: Imolko
+Author-email: info@imolko.com
+Requires-Python: >=3.12.3,<3.14
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: deepeval (>=2.3.8,<3.0.0)
+Requires-Dist: fastapi (>=0.115.8,<0.116.0)
+Requires-Dist: google (>=3.0.0,<4.0.0)
+Requires-Dist: google-api-python-client (>=2.161.0,<3.0.0)
+Requires-Dist: google-auth-httplib2 (>=0.2.0,<0.3.0)
+Requires-Dist: google-auth-oauthlib (>=1.2.1,<2.0.0)
+Requires-Dist: langchain (>=0.3.18,<0.4.0)
+Requires-Dist: langchain-cli (>=0.0.35,<0.0.36)
+Requires-Dist: langchain-community (>=0.3.17,<0.4.0)
+Requires-Dist: langchain-core (>=0.3.35,<0.4.0)
+Requires-Dist: langchain-openai (>=0.3.5,<0.4.0)
+Requires-Dist: langchain-postgres (>=0.0.13,<0.0.14)
+Requires-Dist: langgraph (>=0.2.71,<0.3.0)
+Requires-Dist: langserve (>=0.3.1,<0.4.0)
+Requires-Dist: pydantic (>=2.10.6,<3.0.0)
+Requires-Dist: pydantic-settings (>=2.7.1,<3.0.0)
+Requires-Dist: pytest (>=8.3.4,<9.0.0)
+Requires-Dist: pytest-asyncio (>=0.25.3,<0.26.0)
+Requires-Dist: pytest-mock (>=3.14.0,<4.0.0)
+Requires-Dist: pytest-watcher (>=0.4.3,<0.5.0)
+Requires-Dist: python-dotenv (>=1.0.1,<2.0.0)
+Requires-Dist: pyyaml (>=6.0.2,<7.0.0)
+Requires-Dist: setuptools (>=75.8.0,<76.0.0)
+Requires-Dist: structlog (>=25.1.0,<26.0.0)
+Description-Content-Type: text/markdown
+
+# Crewmaster
+
+## Instalar dependencias
+
+1. Activar entorno virtual
+```
+poetry env use python
+```
+2. Instalar
+```
+poetry install
+```
+
+## Ejecutar los test 
+
+1. Ejecutar todos los test
+```
+poetry run pytest
+```
+
+2. Se puede utilizar pytest para hacer los tests:
+```
+poetry run pytest ./ruta/a/probar --capture=no
+```
+
+3. Pytest no ofrece un modo "watch".  Si quiere utilizar un modo watch debes  ejecutar:
+```
+poetry run ptw ./ruta/a/monitorear ./ruta/a/probar --capture=no
+```
+
+4. Si se quiere probar sólo algún test, se puede agregar la marca `@pytest.mark.mi_marca` y luego ejecutar con el parámetro -k=mi_marca.
+
+```
+# test.py
+@pytest.mark.mi_marca
+def test_check...
+
+# console
+poetry run ptw ./ruta/a/monitorear ./ruta/a/probar --capture=no -k=mi_marca
+```
+
+## Publicar libreria
+
+1. Crear cuenta en pypi
+2. Crear credenciales
+3. Ir a "Configurar cuenta"
+3. Dar scroll hasta "Anadir una ficha api" y crear token(si es necesario)
+4. Agregar token a poetry
+```
+poetry config pypi-token.pypi your-api-token
+```
+5. Construir el paquete
+```
+poetry build
+```
+6. Publicar el paquete
+```
+poetry publish
+```
+
+* Tambien puedes crear y publicar el paquete en un solo paso
+```
+poetry publish --build
+```

crewmaster-0.1.0/README.md

@@ -0,0 +1,64 @@
+# Crewmaster
+
+## Instalar dependencias
+
+1. Activar entorno virtual
+```
+poetry env use python
+```
+2. Instalar
+```
+poetry install
+```
+
+## Ejecutar los test 
+
+1. Ejecutar todos los test
+```
+poetry run pytest
+```
+
+2. Se puede utilizar pytest para hacer los tests:
+```
+poetry run pytest ./ruta/a/probar --capture=no
+```
+
+3. Pytest no ofrece un modo "watch".  Si quiere utilizar un modo watch debes  ejecutar:
+```
+poetry run ptw ./ruta/a/monitorear ./ruta/a/probar --capture=no
+```
+
+4. Si se quiere probar sólo algún test, se puede agregar la marca `@pytest.mark.mi_marca` y luego ejecutar con el parámetro -k=mi_marca.
+
+```
+# test.py
+@pytest.mark.mi_marca
+def test_check...
+
+# console
+poetry run ptw ./ruta/a/monitorear ./ruta/a/probar --capture=no -k=mi_marca
+```
+
+## Publicar libreria
+
+1. Crear cuenta en pypi
+2. Crear credenciales
+3. Ir a "Configurar cuenta"
+3. Dar scroll hasta "Anadir una ficha api" y crear token(si es necesario)
+4. Agregar token a poetry
+```
+poetry config pypi-token.pypi your-api-token
+```
+5. Construir el paquete
+```
+poetry build
+```
+6. Publicar el paquete
+```
+poetry publish
+```
+
+* Tambien puedes crear y publicar el paquete en un solo paso
+```
+poetry publish --build
+```

crewmaster-0.1.0/crewmaster/__init__.py

@@ -0,0 +1,7 @@
+from . import core
+from . import features
+
+__all__ = [
+    "core",
+    "features"
+]

crewmaster-0.1.0/crewmaster/core/__init__.py

@@ -0,0 +1,10 @@
+from . import ultra_result
+from . import pydantic
+from . import ultra_ddd
+
+
+__all__ = [
+    "ultra_result",
+    "pydantic",
+    "ultra_ddd"
+]

crewmaster-0.1.0/crewmaster/core/pydantic/__init__.py

@@ -0,0 +1,47 @@
+from pydantic import (
+    AnyHttpUrl,
+    BaseModel,
+    ConfigDict,
+    conlist,
+    computed_field,
+    create_model,
+    field_validator,
+    Field,
+    model_validator,
+    PrivateAttr,
+    RootModel,
+    SecretStr,
+    SerializeAsAny,
+    StringConstraints,
+    TypeAdapter,
+    ValidationError,
+)
+from pydantic_settings import (
+    BaseSettings,
+)
+
+from pydantic_settings import (
+    BaseSettings as BaseSettingsV2
+)
+
+__all__ = [
+    "AnyHttpUrl",
+    "BaseModel",
+    "BaseSettings",
+    "BaseSettingsV2",
+    "computed_field",
+    "ConfigDict",
+    "conlist",
+    "create_model",
+    "DiscriminatedBaseModel",
+    "field_validator",
+    "Field",
+    "model_validator",
+    "PrivateAttr",
+    "RootModel",
+    "SecretStr",
+    "SerializeAsAny",
+    "StringConstraints",
+    "TypeAdapter",
+    "ValidationError",
+]

crewmaster-0.1.0/crewmaster/core/setup.py

@@ -0,0 +1,15 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="core",
+    version="0.1.0",
+    packages=find_packages(),
+    description="Manejador de agentes",
+    author=[
+        {'name': "Imolko", "email": "info@imolko.com"},
+        {'name': "Carlos N", "email": "machinery.e@gmail.com"}
+    ],
+    contributors=[
+        {'name': "Carlos N", "email": "machinery.e@gmail.com"}
+    ]
+)

crewmaster-0.1.0/crewmaster/core/ultra_ddd/__init__.py

@@ -0,0 +1,7 @@
+from . import use_case
+from . import emitter
+
+__all__ = [
+    "use_case",
+    "emitter",
+]

crewmaster-0.1.0/crewmaster/core/ultra_ddd/emitter/__init__.py

@@ -0,0 +1,7 @@
+from .emitter import Emitter
+from .emitter_explained import EmitterExplained
+
+__all__ = [
+    "Emitter",
+    "EmitterExplained",
+]

crewmaster-0.1.0/crewmaster/core/ultra_ddd/emitter/emitter.py

@@ -0,0 +1,86 @@
+from asyncio import (
+    Queue,
+)
+from typing import (
+    AsyncIterator,
+    Callable,
+    Optional,
+    TypeVar,
+    Generic,
+)
+
+
+# Define generic type variables
+OutputType = TypeVar('OutputType')
+
+
+class NoEmittedValue(Exception):
+    pass
+
+
+EmitterOperator = Callable[
+    [OutputType, OutputType],
+    OutputType
+]
+
+
+class Emitter(Generic[OutputType]):
+    """
+    Abstract base class for emitter.
+
+    """
+    _queue = Queue()
+    _is_finished = False
+    operator: Optional[EmitterOperator] = None
+    """
+    Operador utilizado para el acumular los valores en get_value,
+    por defecto se envía siempre el último valor del stream
+    """
+
+    def __init__(
+        self,
+        operator: Optional[EmitterOperator] = None
+    ):
+        self.operator = operator
+
+    def emit_value(
+        self,
+        value: OutputType,
+        finished: bool = True
+    ) -> None:
+        self._queue.put_nowait(value)
+        if finished:
+            self._queue.put_nowait(None)
+            self._is_finished = True
+
+    async def get_stream(
+        self,
+    ) -> AsyncIterator[OutputType]:
+        while not self._is_finished or not self._queue.empty():
+            result = await self._queue.get()
+            if result is None:
+                break
+            yield result
+
+    def _acum(
+        self,
+        current: Optional[OutputType],
+        next: OutputType
+    ) -> OutputType:
+        # Por defecto siempre enviamos el último valor
+        if self.operator is None:
+            return next
+        return self.operator(current, next)
+
+    async def get_value(
+        self,
+    ) -> OutputType:
+        response = None
+        async for result in self.get_stream():
+            if response is None:
+                response = result
+            else:
+                response = self._acum(response, result)
+        if response is None:
+            raise NoEmittedValue('No value emitted')
+        return response

crewmaster-0.1.0/crewmaster/core/ultra_ddd/emitter/emitter_explained.py

@@ -0,0 +1,95 @@
+from typing import (
+    Callable,
+    Dict,
+    Generic,
+    List,
+    Type,
+    TypeVar,
+    TypedDict,
+    Union,
+)
+from ...ultra_result.either import (
+    Either
+)
+from .emitter import (
+    Emitter,
+)
+
+LeftType = TypeVar('LeftType')
+RightType = TypeVar('RightType')
+
+
+class NaturalResponse(TypedDict, Generic[LeftType, RightType]):
+    explanation: str
+    result: Either[LeftType, RightType]
+
+
+class EmitterExplained(
+    Generic[LeftType, RightType],
+    Emitter[NaturalResponse[LeftType, RightType]]
+):
+    right_explanation_fn: Union[
+        Callable[[RightType], str],
+        str
+    ]
+    left_exclusive: Dict[Type[Exception], str] = {}
+    left_multiple_intro: str = 'Can not process because {count} problems: '
+
+    def __init__(
+        self,
+        right_explanation_fn:  Union[
+            Callable[[RightType], str],
+            str
+        ],
+        left_exclusive: Dict[Type[Exception], str] = {},
+        left_multiple_intro: str = 'Can not process because {count} problems: '
+    ):
+        self.right_explanation_fn = right_explanation_fn
+        self.left_exclusive = left_exclusive
+        self.left_multiple_intro = left_multiple_intro
+
+    def _build_left_explanation(
+        self,
+        errors: List[LeftType]
+    ) -> str:
+        if len(errors) == 1:
+            specials = [value for key, value in self.left_exclusive.items()
+                        if isinstance(errors[0], key)]
+            if len(specials) > 0:
+                return specials[0]
+        errors_str = [f'"{str(item)}"' for item in errors]
+        joined = ", ".join(errors_str)
+        intro = self.left_multiple_intro.format(count=len(errors))
+        explanation = f'{intro}{joined}'
+        return explanation
+
+    def _build_right_explanation(
+        self,
+        result: RightType
+    ) -> str:
+        if isinstance(self.right_explanation_fn, str):
+            # If it's a string, return it directly
+            return self.right_explanation_fn
+        elif callable(self.right_explanation_fn):
+            # If it's a callable, call it with the result and return the result
+            return self.right_explanation_fn(result)
+        else:
+            raise ValueError("Invalid type for right_explanation_fn")
+
+    def emit_value(
+        self,
+        result: Either[LeftType, RightType]
+    ) -> None:
+        if result.is_right():
+            explanation = self._build_right_explanation(
+                result.get_value()
+            )
+        else:
+            explanation = self._build_left_explanation(
+                result.get_errors()
+            )
+        full_response: NaturalResponse = {
+            "explanation": explanation,
+            "result": result
+        }
+        super().emit_value(full_response)

crewmaster-0.1.0/crewmaster/core/ultra_ddd/emitter/emitter_explained_test.py

@@ -0,0 +1,90 @@
+import structlog
+import pytest
+
+from .emitter_explained import (
+    EmitterExplained,
+)
+from ...ultra_result.either import (
+    right,
+    left,
+)
+
+log = structlog.get_logger()
+"Logger para el módulo"
+
+
+@pytest.mark.only
+@pytest.mark.asyncio
+async def test_single_value_as_stream():
+    emitter = EmitterExplained[str, None](
+        right_explanation_fn='Estoy bien'
+    )
+    emitter.emit_value(right(None))
+    async for value in emitter.get_stream():
+        result = value
+    assert result.get('explanation', '') == 'Estoy bien'
+
+
+@pytest.mark.only
+@pytest.mark.asyncio
+async def test_fn_transform_right():
+    emitter = EmitterExplained[Exception, str](
+        right_explanation_fn=lambda result: f'Hola {result}'
+    )
+    emitter.emit_value(right('Pedro'))
+    result = await emitter.get_value()
+    assert result.get('explanation', '') == 'Hola Pedro'
+
+
+@pytest.mark.only
+@pytest.mark.asyncio
+async def test_exclusive_left():
+    emitter = EmitterExplained[Exception, str](
+        right_explanation_fn=lambda result: f'Hola {result}',
+        left_exclusive={ValueError: 'Sucedio un problemon'}
+    )
+    emitter.emit_value(left(ValueError('invalid value')))
+    result = await emitter.get_value()
+    assert result.get('explanation', '') == 'Sucedio un problemon'
+
+
+@pytest.mark.only
+@pytest.mark.asyncio
+async def test_multiples_errors():
+    emitter = EmitterExplained[Exception, str](
+        right_explanation_fn=lambda result: f'Hola {result}',
+        left_exclusive={ValueError: 'Sucedio un problemon'}
+    )
+    emitter.emit_value(left([
+        ValueError('invalid value'),
+        Exception('otro error más')
+    ]))
+    result = await emitter.get_value()
+    explanation = result.get('explanation', '')
+    assert (
+        'Can not process because 2 problems'
+        in explanation
+    )
+    assert 'invalid value' in explanation
+    assert 'otro error más' in explanation
+
+
+@pytest.mark.only
+@pytest.mark.asyncio
+async def test_multiples_errors_with_custom_intro():
+    emitter = EmitterExplained[Exception, str](
+        right_explanation_fn=lambda result: f'Hola {result}',
+        left_multiple_intro='Increible, hay {count} errores:'
+    )
+    emitter.emit_value(left([
+        ValueError('invalid value'),
+        Exception('otro error más')
+    ]))
+    result = await emitter.get_value()
+    explanation = result.get('explanation', '')
+    assert (
+        'Increible, hay 2 errores:'
+        in explanation
+    )
+    assert 'invalid value' in explanation
+    assert 'otro error más' in explanation

crewmaster-0.1.0/crewmaster/core/ultra_ddd/emitter/emitter_test.py

@@ -0,0 +1,52 @@
+import structlog
+import pytest
+import operator
+
+from .emitter import Emitter
+
+log = structlog.get_logger()
+"Logger para el módulo"
+
+
+@pytest.mark.only
+@pytest.mark.asyncio
+async def test_single_value_as_stream():
+    emitter = Emitter[str]()
+    emitter.emit_value('hola')
+    async for value in emitter.get_stream():
+        result = value
+    assert result == 'hola'
+
+
+@pytest.mark.only
+@pytest.mark.asyncio
+async def test_multiple_value_as_stream():
+    emitter = Emitter[str]()
+    emitter.emit_value('hola, ', finished=False)
+    emitter.emit_value('como estas?')
+    result = ''
+    async for value in emitter.get_stream():
+        result += value
+    assert result == 'hola, como estas?'
+
+
+@pytest.mark.only
+@pytest.mark.asyncio
+async def test_single_value_as_single():
+    emitter = Emitter[str]()
+    emitter.emit_value('hola')
+    result = await emitter.get_value()
+    assert result == 'hola'
+
+
+@pytest.mark.only
+@pytest.mark.asyncio
+async def test_multiple_value_acummulated():
+    emitter = Emitter[str](
+        operator=operator.add
+    )
+    emitter.emit_value('hola, ', finished=False)
+    emitter.emit_value('buen dia, ', finished=False)
+    emitter.emit_value('como estas?')
+    result = await emitter.get_value()
+    assert result == 'hola, buen dia, como estas?'

crewmaster-0.1.0/crewmaster/core/ultra_ddd/use_case/__init__.py

@@ -0,0 +1,5 @@
+from .use_case_base import UseCaseBase
+
+__all__ = [
+    "UseCaseBase"
+]

crewmaster-0.1.0/crewmaster/core/ultra_ddd/use_case/use_case_base.py

@@ -0,0 +1,19 @@
+from abc import ABC, abstractmethod
+from typing import TypeVar, Generic
+
+# Define generic type variables
+IRequest = TypeVar('IRequest')
+
+
+class UseCaseBase(ABC, Generic[IRequest]):
+    """
+    Abstract base class for use cases.
+
+    All use cases must implement this interface.
+
+    Only one method is offered to "execute" the use case.
+    """
+
+    @abstractmethod
+    async def execute(self, request: IRequest) -> None:
+        pass

crewmaster-0.1.0/crewmaster/core/ultra_result/__init__.py

@@ -0,0 +1,5 @@
+from . import either
+
+__all__ = [
+    "either"
+]

crewmaster-0.1.0/crewmaster/core/ultra_result/either/__init__.py

@@ -0,0 +1,11 @@
+from .right import Right, right
+from .left import Left, left
+from .either import Either
+
+__all__ = [
+    "Right",
+    "right",
+    "Left",
+    "left",
+    "Either",
+]

crewmaster-0.1.0/crewmaster/core/ultra_result/either/either.py

@@ -0,0 +1,9 @@
+from typing import TypeVar, Union
+
+from .right import Right
+from .left import Left
+
+T = TypeVar('T')
+E = TypeVar('E')
+
+Either = Union[Left[E], Right[T]]

crewmaster-0.1.0/crewmaster/core/ultra_result/either/left.py

@@ -0,0 +1,42 @@
+from typing import TypeVar, Generic, List, Callable, Union
+
+T = TypeVar('T')
+E = TypeVar('E')
+
+
+class Left(Generic[E]):
+    def __init__(self, errors: List[E]) -> None:
+        if not errors or errors is None:
+            raise ValueError(
+                'Errors list is null or undefined. Must pass errors list.'
+            )
+        if len(errors) == 0:
+            raise ValueError('Errors list is empty. Must pass errors list.')
+        self.errors: List[E] = errors
+
+    def get_value(self):
+        raise TypeError('Cant access value from a Left value')
+
+    def get_errors(self) -> List[E]:
+        return self.errors
+
+    def is_left(self) -> bool:
+        return True
+
+    def is_right(self) -> bool:
+        return False
+
+    def fold(
+            self, left_fn: Callable[[List[E]], T],
+            right_fn: Callable[[T], T]
+            ) -> T:
+        return left_fn(self.get_errors())
+
+
+def left(errorOrErrors: Union[E, list[E]]) -> Left[E]:
+    """
+    Creates a Left instance from a list of errors.
+    """
+    errors = errorOrErrors if isinstance(errorOrErrors, list) \
+        else [errorOrErrors]
+    return Left(errors)