vega-framework 0.1.28__py3-none-any.whl → 0.1.30__py3-none-any.whl

vega/events/event.py

@@ -0,0 +1,156 @@
+"""Base Event class for domain events"""
+from datetime import datetime, timezone
+from typing import Any, Dict
+from uuid import uuid4
+
+
+class PublishableEventMeta(type):
+    """
+    Metaclass for auto-publishing events.
+
+    Automatically publishes the event after instantiation,
+    allowing ultra-clean syntax:
+
+        await UserCreated(user_id="123", email="test@test.com")
+
+    Instead of:
+        event = UserCreated(user_id="123", email="test@test.com")
+        await event.publish()
+    """
+
+    def __call__(cls, *args, **kwargs):
+        """
+        Create instance and return publish() coroutine (auto-publish is always enabled).
+
+        To disable auto-publish on an event class (rare):
+            class UserCreated(Event, auto_publish=False):
+                ...
+        """
+        instance = super().__call__(*args, **kwargs)
+
+        # Auto-publish is enabled by default, can be disabled with auto_publish=False
+        if getattr(cls, '_auto_publish', True):  # Default is True now!
+            return instance.publish()
+
+        return instance
+
+
+class Event(metaclass=PublishableEventMeta):
+    """
+    Base class for domain events.
+
+    An event represents something that has happened in the domain.
+    Events are immutable and should be named in past tense.
+
+    Key Characteristics:
+    - Immutable (use frozen dataclass or read-only properties)
+    - Named in past tense (UserCreated, OrderPlaced, PaymentProcessed)
+    - Contains all data needed by handlers
+    - Auto-generates event_id and timestamp
+    - Auto-publishes by default (like Interactors!)
+
+    Example - Auto-publish (default, ultra-clean syntax):
+        from vega.events import Event
+        from dataclasses import dataclass
+
+        @dataclass(frozen=True)
+        class UserCreated(Event):
+            user_id: str
+            email: str
+            name: str
+
+            def __post_init__(self):
+                super().__init__()
+
+        # Event is auto-published when instantiated! Just await it!
+        await UserCreated(user_id="123", email="test@test.com", name="Test")
+
+    Example - Disable auto-publish (rare, when you need to inspect first):
+        @dataclass(frozen=True)
+        class UserCreated(Event, auto_publish=False):
+            user_id: str
+            email: str
+            name: str
+
+            def __post_init__(self):
+                super().__init__()
+
+        # Manual publish
+        event = UserCreated(user_id="123", email="test@test.com", name="Test")
+        # ... inspect or modify event ...
+        await event.publish()
+    """
+
+    def __init_subclass__(cls, auto_publish: bool = True, **kwargs):
+        """
+        Hook to configure auto-publish behavior.
+
+        Args:
+            auto_publish: If False, event will NOT auto-publish when instantiated (default: True)
+        """
+        super().__init_subclass__(**kwargs)
+        cls._auto_publish = auto_publish
+
+    def __init__(self):
+        """Initialize event with auto-generated metadata"""
+        # Use object.__setattr__ to bypass frozen dataclass
+        object.__setattr__(self, '_event_id', str(uuid4()))
+        object.__setattr__(self, '_timestamp', datetime.now(timezone.utc))
+        object.__setattr__(self, '_metadata', {})
+
+    @property
+    def event_id(self) -> str:
+        """Unique identifier for this event instance"""
+        return self._event_id
+
+    @property
+    def timestamp(self) -> datetime:
+        """When this event was created"""
+        return self._timestamp
+
+    @property
+    def event_name(self) -> str:
+        """Name of the event (class name)"""
+        return self.__class__.__name__
+
+    @property
+    def metadata(self) -> Dict[str, Any]:
+        """Additional metadata attached to the event"""
+        return self._metadata
+
+    def add_metadata(self, key: str, value: Any) -> None:
+        """
+        Add metadata to the event.
+
+        Useful for adding correlation IDs, user context, etc.
+
+        Args:
+            key: Metadata key
+            value: Metadata value
+        """
+        # Access metadata dict directly to modify it
+        if not hasattr(self, '_metadata'):
+            object.__setattr__(self, '_metadata', {})
+        self._metadata[key] = value
+
+    async def publish(self) -> None:
+        """
+        Publish this event to the global event bus.
+
+        This is a convenience method to avoid importing get_event_bus().
+
+        Example:
+            event = UserCreated(user_id="123", email="test@test.com", name="Test")
+            await event.publish()  # Simple!
+
+        Note:
+            This uses the global event bus. If you need a custom bus,
+            call bus.publish(event) directly.
+        """
+        # Import here to avoid circular dependency
+        from vega.events.bus import get_event_bus
+        bus = get_event_bus()
+        await bus.publish(self)
+
+    def __repr__(self) -> str:
+        return f"{self.event_name}(event_id={self.event_id}, timestamp={self.timestamp})"

vega/events/middleware.py

@@ -0,0 +1,259 @@
+"""Event middleware for cross-cutting concerns"""
+import logging
+import time
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+from vega.events.event import Event
+
+logger = logging.getLogger(__name__)
+
+
+class EventMiddleware(ABC):
+    """
+    Base class for event middleware.
+
+    Middleware allows you to add cross-cutting concerns to event processing,
+    such as logging, metrics, validation, or security checks.
+
+    Middleware is executed in the order it was added to the event bus.
+
+    Example:
+        class LoggingMiddleware(EventMiddleware):
+            async def before_publish(self, event: Event):
+                print(f"Publishing: {event.event_name}")
+
+            async def after_publish(self, event: Event):
+                print(f"Published: {event.event_name}")
+
+        bus = EventBus()
+        bus.add_middleware(LoggingMiddleware())
+    """
+
+    @abstractmethod
+    async def before_publish(self, event: Event) -> None:
+        """
+        Called before event is published to handlers.
+
+        Use this to modify the event, add metadata, or perform validation.
+
+        Args:
+            event: Event about to be published
+        """
+        pass
+
+    @abstractmethod
+    async def after_publish(self, event: Event) -> None:
+        """
+        Called after all handlers have processed the event.
+
+        Use this for cleanup, logging, or metrics collection.
+
+        Args:
+            event: Event that was published
+        """
+        pass
+
+
+class LoggingEventMiddleware(EventMiddleware):
+    """
+    Middleware that logs all events.
+
+    Logs event name, ID, and processing time.
+
+    Example:
+        from vega.events import EventBus, LoggingEventMiddleware
+
+        bus = EventBus()
+        bus.add_middleware(LoggingEventMiddleware())
+    """
+
+    def __init__(self, log_level: int = logging.DEBUG):
+        """
+        Initialize logging middleware.
+
+        Args:
+            log_level: Log level to use (default: DEBUG)
+        """
+        self.log_level = log_level
+        self._start_times: Dict[str, float] = {}
+
+    async def before_publish(self, event: Event) -> None:
+        """Log event publication start"""
+        self._start_times[event.event_id] = time.time()
+        logger.log(
+            self.log_level,
+            f"Publishing event: {event.event_name} (id={event.event_id})"
+        )
+
+    async def after_publish(self, event: Event) -> None:
+        """Log event publication completion with duration"""
+        start_time = self._start_times.pop(event.event_id, None)
+        if start_time:
+            duration = (time.time() - start_time) * 1000  # ms
+            logger.log(
+                self.log_level,
+                f"Event processed: {event.event_name} (id={event.event_id}, duration={duration:.2f}ms)"
+            )
+
+
+class MetricsEventMiddleware(EventMiddleware):
+    """
+    Middleware that collects metrics for events.
+
+    Tracks:
+    - Event count by type
+    - Processing duration
+    - Success/failure rates
+
+    Example:
+        middleware = MetricsEventMiddleware()
+        bus.add_middleware(middleware)
+
+        # Later, get metrics
+        print(middleware.get_metrics())
+    """
+
+    def __init__(self):
+        """Initialize metrics middleware"""
+        self._metrics: Dict[str, Dict[str, Any]] = {}
+        self._start_times: Dict[str, float] = {}
+
+    async def before_publish(self, event: Event) -> None:
+        """Record event start time"""
+        self._start_times[event.event_id] = time.time()
+
+        # Initialize metrics for this event type
+        event_name = event.event_name
+        if event_name not in self._metrics:
+            self._metrics[event_name] = {
+                'count': 0,
+                'total_duration_ms': 0,
+                'min_duration_ms': float('inf'),
+                'max_duration_ms': 0,
+            }
+
+    async def after_publish(self, event: Event) -> None:
+        """Record event completion and update metrics"""
+        start_time = self._start_times.pop(event.event_id, None)
+        if start_time is None:
+            return
+
+        duration_ms = (time.time() - start_time) * 1000
+
+        # Update metrics
+        event_name = event.event_name
+        metrics = self._metrics[event_name]
+        metrics['count'] += 1
+        metrics['total_duration_ms'] += duration_ms
+        metrics['min_duration_ms'] = min(metrics['min_duration_ms'], duration_ms)
+        metrics['max_duration_ms'] = max(metrics['max_duration_ms'], duration_ms)
+        metrics['avg_duration_ms'] = metrics['total_duration_ms'] / metrics['count']
+
+    def get_metrics(self) -> Dict[str, Dict[str, Any]]:
+        """
+        Get collected metrics.
+
+        Returns:
+            Dictionary of metrics by event type
+        """
+        return self._metrics.copy()
+
+    def reset_metrics(self) -> None:
+        """Reset all metrics"""
+        self._metrics.clear()
+        self._start_times.clear()
+
+
+class ValidationEventMiddleware(EventMiddleware):
+    """
+    Middleware that validates events before publishing.
+
+    Ensures events meet certain criteria before being processed.
+
+    Example:
+        def validate_user_event(event):
+            if hasattr(event, 'user_id') and not event.user_id:
+                raise ValueError("user_id cannot be empty")
+
+        middleware = ValidationEventMiddleware()
+        middleware.add_validator(UserCreated, validate_user_event)
+
+        bus.add_middleware(middleware)
+    """
+
+    def __init__(self):
+        """Initialize validation middleware"""
+        from typing import Type, Callable
+        self._validators: Dict[Type[Event], list[Callable]] = {}
+
+    def add_validator(self, event_type: type, validator: callable) -> None:
+        """
+        Add a validator for an event type.
+
+        Args:
+            event_type: Event type to validate
+            validator: Validation function that raises on invalid event
+        """
+        if event_type not in self._validators:
+            self._validators[event_type] = []
+        self._validators[event_type].append(validator)
+
+    async def before_publish(self, event: Event) -> None:
+        """Validate event before publishing"""
+        event_type = type(event)
+
+        # Run validators for this event type
+        if event_type in self._validators:
+            for validator in self._validators[event_type]:
+                # Run validator
+                result = validator(event)
+                # Await if async
+                if hasattr(result, '__await__'):
+                    await result
+
+    async def after_publish(self, event: Event) -> None:
+        """No action after publish"""
+        pass
+
+
+class EnrichmentEventMiddleware(EventMiddleware):
+    """
+    Middleware that enriches events with additional data.
+
+    Automatically adds metadata like user context, correlation IDs, etc.
+
+    Example:
+        middleware = EnrichmentEventMiddleware()
+        middleware.add_enricher(lambda event: event.add_metadata('tenant_id', 'abc123'))
+
+        bus.add_middleware(middleware)
+    """
+
+    def __init__(self):
+        """Initialize enrichment middleware"""
+        self._enrichers: list[callable] = []
+
+    def add_enricher(self, enricher: callable) -> None:
+        """
+        Add an enricher function.
+
+        Enricher should modify the event in-place (e.g., add metadata).
+
+        Args:
+            enricher: Function that enriches the event
+        """
+        self._enrichers.append(enricher)
+
+    async def before_publish(self, event: Event) -> None:
+        """Enrich event before publishing"""
+        for enricher in self._enrichers:
+            # Run enricher
+            result = enricher(event)
+            # Await if async
+            if hasattr(result, '__await__'):
+                await result
+
+    async def after_publish(self, event: Event) -> None:
+        """No action after publish"""
+        pass

vega/patterns/interactor.py

@@ -15,16 +15,62 @@ class InteractorMeta(ABCMeta):
     Instead of:
         interactor = CreateUser(name="John", email="john@example.com")
         result = await interactor.call()
+
+    Also supports @trigger decorator to automatically publish events after call() completes.
     """
 
     def __call__(cls, *args, **kwargs):
         """
         Create instance and call the call() method.
 
+        If @trigger decorator is used, wraps call() to publish event after completion.
+
         Returns the result of call() method (usually a coroutine).
         """
         instance = super(InteractorMeta, cls).__call__(*args, **kwargs)
-        return instance.call()
+        call_result = instance.call()
+
+        # Check if @trigger decorator was used
+        if hasattr(cls, '_trigger_event'):
+            # Wrap the coroutine to trigger event after completion
+            return cls._wrap_with_event_trigger(call_result, cls._trigger_event)
+
+        return call_result
+
+    @staticmethod
+    async def _wrap_with_event_trigger(call_coroutine, event_class):
+        """
+        Wrap call() coroutine to trigger event after it completes.
+
+        Args:
+            call_coroutine: The coroutine returned by call()
+            event_class: The event class to instantiate and publish
+
+        Returns:
+            The result of call()
+        """
+        # Execute the call() method
+        result = await call_coroutine
+
+        # Trigger the event with the result
+        try:
+            # If result is a dict, unpack as kwargs
+            if isinstance(result, dict):
+                await event_class(**result)
+            # If result is None, create event with no args
+            elif result is None:
+                await event_class()
+            # Otherwise, pass result as first argument
+            else:
+                await event_class(result)
+        except Exception as e:
+            # Log but don't fail the interactor if event publishing fails
+            import logging
+            logger = logging.getLogger(__name__)
+            logger.error(f"Failed to trigger event {event_class.__name__}: {e}")
+
+        # Return the original result
+        return result
 
 
 class Interactor(Generic[T], metaclass=InteractorMeta):

{vega_framework-0.1.28.dist-info → vega_framework-0.1.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vega-framework
-Version: 0.1.28
+Version: 0.1.30
 Summary: Enterprise-ready Python framework that enforces Clean Architecture for building maintainable and scalable applications.
 License: MIT
 License-File: LICENSE

{vega_framework-0.1.28.dist-info → vega_framework-0.1.30.dist-info}/RECORD

@@ -2,24 +2,26 @@ vega/__init__.py,sha256=A05RwOYXooAZUz3GnbJ--ofLXgtRZK9gaSmsLVRdGPY,1811
 vega/cli/__init__.py,sha256=NCzOOyhKHqLeN1r80ekhMfkQwBdAQXKcKiKoNwYPNiY,304
 vega/cli/commands/__init__.py,sha256=UH7MdYduBG_YoulgdiWkUCtcgGLzuYRGFzxaqoa0pyg,19
 vega/cli/commands/add.py,sha256=5Li588W1KWQqCKV0VZSURx4J3I8dQE297c4V_3anf5U,6465
-vega/cli/commands/generate.py,sha256=Rb4hXPHm_pFEKFViWJ2sMzyUNJWCCoTjLq2H2GvruGc,33720
-vega/cli/commands/init.py,sha256=kBRtntHT7e-y9uOwZm9o9IUED64e_pO5fBEsIx5m-X8,5592
+vega/cli/commands/generate.py,sha256=S3qNE40exn1dSub8kM8Vp-Tpn9ByK2UBjaVA6LadAos,38172
+vega/cli/commands/init.py,sha256=Ro35QfCKeo-Nm_rJkRT-DaX0nH7_bGc_ewX5Q1eqpP8,5860
 vega/cli/commands/migrate.py,sha256=00swKeVhmKr1_1VJhg3GpIMcJ6Jfgz5FUpmJoLf5qSQ,3805
 vega/cli/commands/update.py,sha256=0zRWkHvQwKGlJL9XF3bi--dThkFapyNOugL6AgGr6Ic,5897
-vega/cli/commands/web.py,sha256=7Lte7X7Gx0XJFCxnUIaadlmzXdosPR5P4Uu71V2cxWc,3130
-vega/cli/main.py,sha256=GNqNB6kX_c2a7d68B3g4_oFyWjxTf8ZaoPH7TaYiSmk,5136
+vega/cli/commands/web.py,sha256=tkaMzrENiV044JdPtCSRmzX_vVpnumlDeTG6YH3DWo4,3450
+vega/cli/main.py,sha256=0hSar-MFpu3tp2QDOite4LGVpAhCTojuRZhPDiilEFQ,5476
 vega/cli/scaffolds/__init__.py,sha256=WFJf2H_4UWL89gDxX8PXKkTVSVOfw7hFfyaPWKokp1g,217
 vega/cli/scaffolds/fastapi.py,sha256=a_vZVSfMgyteRURFZAShbtjSRMOSM4YeEIKKvBtAOfo,3788
 vega/cli/scaffolds/sqlalchemy.py,sha256=il5JqiA8LSQKnNoOYfAFD82rdYx5l_ZsqsjHnplYohw,6164
-vega/cli/templates/__init__.py,sha256=axjR2Nk8Cy36owrXiHxDOFn9CCd6-Z7Ri5UvOcK1CoM,1876
+vega/cli/templates/__init__.py,sha256=1Udc3hlhj3pJYQGk4NVpg0u9us040YarL_adlomJTf4,2018
 vega/cli/templates/cli/command.py.j2,sha256=Z8K9DRfppsco9uID_uG8EKVyWYD_1x-KYqLZY4BJKzM,1097
 vega/cli/templates/cli/command_simple.py.j2,sha256=PshUZyKtkazSEtaf6E1__hQbX07pz6ojxTXK4TgtUEw,531
 vega/cli/templates/cli/commands_init.py.j2,sha256=iZGnWmJoFUGM1pUMQGYLNplgwgwo8D48vT1hzBcHUEQ,300
-vega/cli/templates/components.py,sha256=nb8B9ha7-vYqnv6dpkI6ruL_Uo6cvJVdcDUseUACpdE,7631
+vega/cli/templates/components.py,sha256=93fzDB6DJUq4_wPaM1ao8RgHxlm6giMSu4JIP8ULOS4,8541
 vega/cli/templates/domain/entity.py.j2,sha256=dl5rzuJMnTRqOdU5SYV2o_OPGy9l6DNf_symCcjdjK0,344
+vega/cli/templates/domain/event.py.j2,sha256=hfNTrlhtwgyiid5oCIBOeVkb6t4K5IOCx7cd0cQi7mQ,667
+vega/cli/templates/domain/event_handler.py.j2,sha256=F8uYJp4WbbAjUk74raD01WcgjU0NVPqtD_9wx2aC4lM,664
 vega/cli/templates/domain/interactor.py.j2,sha256=Hv6whUyW67smjMRw_HuvC3_-q7g32dEUOFZdmi5xkrc,684
 vega/cli/templates/domain/mediator.py.j2,sha256=gdEDNscYaB3wOemaVrFr3qKVE5sTS5wRVvbxrrfBemY,694
-vega/cli/templates/domain/repository_interface.py.j2,sha256=FDlK10yYim6wHMk44IVncoo6RPO0TWDeHWpPjgLlaLo,577
+vega/cli/templates/domain/repository_interface.py.j2,sha256=90jPcokr7GPbfzma_k5GFYFAKk8RZ52SMTmnrC6bnQg,584
 vega/cli/templates/domain/service_interface.py.j2,sha256=Pq-wwGvGbns9Z_2lqL8Xi2_G-MMU-0JjAuGW94H6mrE,330
 vega/cli/templates/infrastructure/model.py.j2,sha256=zNY4m7BZJeQhdu_bTFY6WIhizsYW4eJY6PS1DCs0vbE,796
 vega/cli/templates/infrastructure/repository_impl.py.j2,sha256=Rmip4Swh3wdJRioVOWKgJVQgl45Y9STu3M-oviaOrPM,488
@@ -30,6 +32,7 @@ vega/cli/templates/project/.gitignore,sha256=7JSDihCtBznd-QxQ4wUtHM9fnbYnbw6PK4A
 vega/cli/templates/project/ARCHITECTURE.md.j2,sha256=HunrJ_9LlPxd5-GONaJxjoLlw-XfjYaLpsVHFa72Yf4,25868
 vega/cli/templates/project/README.md.j2,sha256=tZtMKhyKjfCq5JTECHihISu0VjYd254t-7y2kJ0nbKY,4589
 vega/cli/templates/project/config.py.j2,sha256=1Iva9JEz5ej_WmTbRVBvOfSBhYUKIzN88p6GYKR0m4s,866
+vega/cli/templates/project/events_init.py.j2,sha256=dp9yc8_Du6lv62vum_Br0p030I4TKZAkZG29mj4AZaM,1057
 vega/cli/templates/project/main.py.j2,sha256=wpIWNcj0N42KI1crdn0aDISZ6aRt9LjX7FDzJxEE8OM,572
 vega/cli/templates/project/main_fastapi.py.j2,sha256=5xXB7_OR1-3vkTAkvRvSh3GpL5NWnUEId3bSOOd9qxA,613
 vega/cli/templates/project/main_standard.py.j2,sha256=j2z6u93_ObiOquzYQM1sZex50Z1cAwHOEG1-0REImRI,617
@@ -62,18 +65,26 @@ vega/di/container.py,sha256=o4cpxCx53wWSNLcrr8Qt9tc7_YiDtHpYvUrdruNVwEc,5467
 vega/di/decorators.py,sha256=WypsUa9sqojwCCnZ6jXdOob6G6vL4wIx3df_WbUV8Ks,9733
 vega/di/errors.py,sha256=TITDvwkL05b_O7sygJvTx8aSegUXBgF2EqEhVxRuuGE,148
 vega/di/scope.py,sha256=1yorvknVwmYGcDpNGsQDgob1jZQ5QoHdibbBH1SLcwQ,4652
-vega/discovery/__init__.py,sha256=s1MCuJQnCX1C0_YuAhKLHqhkpCRgeSrtAPfNbuboD20,180
+vega/discovery/__init__.py,sha256=nTq5wapJxg2ZZ2rylp1xY3Phq7OQYjXskIy2Ld8wQSw,251
 vega/discovery/commands.py,sha256=U1adQJXqBi88c2lkx8gMWzNE1hj8od72QLEKxjNq7gM,3375
+vega/discovery/events.py,sha256=TF8pjYE6gyJJRpOW8Pqvc0Gpu1n1iIHh3UBqzD8kGRI,3051
 vega/discovery/routes.py,sha256=WiNhNynbKewOrXv7D5fY03I3Oh_yfwEZbkeS8WGyQpU,4347
+vega/events/README.md,sha256=3dp-ZwVxKURIl3FfokzMzVj12wlMImvWaWKx9Y46U7w,13934
+vega/events/SYNTAX_GUIDE.md,sha256=LFnxGOi-IzpOkpW5RERxL-jjMlVmJEIfdXN7_w0DJKY,8577
+vega/events/__init__.py,sha256=yt-0idaDMDfAFiQcRjI-VrDTunKGkYrMV9QFJ244p0Y,800
+vega/events/bus.py,sha256=uALNVeGOyis2ZLCUQn7d87U3UzBO1-0HYO0GErxCmmM,12116
+vega/events/decorators.py,sha256=UF2dQ2GOoXeGuScWBNsePP66ZCIZznJalZVX3i4ome0,5720
+vega/events/event.py,sha256=PfsIl8-6dZR2J1aS7VV9ZQn1CzxvNZOcbP-dil49z9U,4964
+vega/events/middleware.py,sha256=jNltBxeF42-XnC_uVB9OD0BLNRBirudOPeOUYa-fGv8,7862
 vega/patterns/__init__.py,sha256=UlrgFy8OQkAjgqRLFCOcnTHFKODfZH4FA4_33hq0GgQ,1150
-vega/patterns/interactor.py,sha256=QWy20KpWlgL6dav5IgHsfKFNHsTU0igyt4hWQxh_qXc,2366
+vega/patterns/interactor.py,sha256=kRJaFp2eUwHZ-cTQ5y7FoF59yEUo2J9yzL9mo_JbLfI,4030
 vega/patterns/mediator.py,sha256=n5rqu1ZD0iljbAHct4mRPFPHaKVPWQJF-Ps9egYQ41g,2306
 vega/patterns/repository.py,sha256=uYUyLs-O8OqW1Wb9ZqIo8UUcCjZ5UFuHors_F2iDg9A,1480
 vega/patterns/service.py,sha256=buFRgJoeQtZQK22Upb4vh84c1elWKFXWBaB0X4RaruE,1374
 vega/settings/__init__.py,sha256=Eb8PMUyXAlCAQIcL2W8QhTTUHUbVlkAfXdpTUlADo1I,786
 vega/settings/base.py,sha256=bL45hyoa3t-hQOvur860eSo7O833sQMsXJJPwbTVbwE,1321
-vega_framework-0.1.28.dist-info/METADATA,sha256=phV5zRJGewa-FkO3KNY2BW8ILdZRaQy8qu-u4eaxISQ,12349
-vega_framework-0.1.28.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-vega_framework-0.1.28.dist-info/entry_points.txt,sha256=p3gyTmPYjNRLbuiKS-hG3ytWd-ssBweFy6VZ-F9FTNk,42
-vega_framework-0.1.28.dist-info/licenses/LICENSE,sha256=wlHh1MBTcs2kSQr99P30mZ61s7uh7Cp9Rk0YiJxots0,1084
-vega_framework-0.1.28.dist-info/RECORD,,
+vega_framework-0.1.30.dist-info/METADATA,sha256=zPGu-SvaUbI2HUAlWGgpN457HPycRqeGpEuKO5pq2v8,12349
+vega_framework-0.1.30.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+vega_framework-0.1.30.dist-info/entry_points.txt,sha256=p3gyTmPYjNRLbuiKS-hG3ytWd-ssBweFy6VZ-F9FTNk,42
+vega_framework-0.1.30.dist-info/licenses/LICENSE,sha256=wlHh1MBTcs2kSQr99P30mZ61s7uh7Cp9Rk0YiJxots0,1084
+vega_framework-0.1.30.dist-info/RECORD,,