by-framework 0.2.2.dev13__py3-none-any.whl → 0.2.2.dev15__py3-none-any.whl

by_framework/client/client.py

@@ -971,6 +971,12 @@ class GatewayClient:
                         "parent_message_id": params["parent_message_id"] or "",
                         "source_agent_type": CLIENT_SOURCE_AGENT_TYPE,
                         "target_agent_type": params["target_agent_type"],
+                        # What this execution was dispatched with, so a worker
+                        # can restore it after the execution suspends and
+                        # resumes (see worker/_resume_metadata.py). Only the
+                        # non-RESUME branch reaches here, so this never
+                        # overwrites a suspended execution's original.
+                        "metadata": dict(metadata or {}),
                         "stream_name": route.stream_name,
                         "status": "QUEUED",
                         "route_policy": route_policy,

by_framework/metrics/catalog.py

@@ -367,6 +367,60 @@ _CATALOG: dict[str, MetricDefinition] = {
             "Instrumentation reliability signal pinpointing exporter failures."
         ),
     ),
+    # Self-monitoring for the background collector in metrics/collector.py.
+    # Exactly one process holds its Redis lock and writes history points, so
+    # these answer "is anyone still collecting?" — a gap here means the
+    # dashboards go stale silently rather than erroring.
+    "by_framework_metrics_collector_cycles_total": MetricDefinition(
+        name="by_framework_metrics_collector_cycles_total",
+        kind=MetricKind.COUNTER,
+        unit=MetricUnit.NONE,
+        labels=("result",),
+        description=(
+            "Metrics collector cycles by result "
+            "(success, snapshot_failed, lock_skipped, disabled)."
+        ),
+        interpretation=(
+            "Collector health signal: only the lock holder reports success, so "
+            "lock_skipped dominating across a fleet is expected."
+        ),
+    ),
+    "by_framework_metrics_collector_snapshot_duration_ms": MetricDefinition(
+        name="by_framework_metrics_collector_snapshot_duration_ms",
+        kind=MetricKind.HISTOGRAM,
+        unit=MetricUnit.MILLISECONDS,
+        description=(
+            "Duration of one collector snapshot build plus history write."
+        ),
+        interpretation=(
+            "Latency signal for collection itself; approaching the collection "
+            "interval means cycles are about to overlap."
+        ),
+    ),
+    "by_framework_metrics_collector_lock_held": MetricDefinition(
+        name="by_framework_metrics_collector_lock_held",
+        kind=MetricKind.GAUGE,
+        unit=MetricUnit.NONE,
+        description=(
+            "Whether this process currently holds the metrics collector lock."
+        ),
+        interpretation=(
+            "Saturation signal: should sum to 1 across the fleet — 0 means "
+            "nobody is collecting, above 1 means the lock split."
+        ),
+    ),
+    "by_framework_metrics_collector_last_success_timestamp_ms": MetricDefinition(
+        name="by_framework_metrics_collector_last_success_timestamp_ms",
+        kind=MetricKind.GAUGE,
+        unit=MetricUnit.MILLISECONDS,
+        description=(
+            "Unix timestamp in milliseconds of the last successful collection."
+        ),
+        interpretation=(
+            "Freshness signal: alert on now minus this value exceeding a few "
+            "collection intervals."
+        ),
+    ),
 }
 
 

by_framework/worker/_resume_metadata.py

@@ -0,0 +1,65 @@
+"""The inbound half of a resumed execution's metadata.
+
+Two different directions restore metadata on a resume, and they are NOT the
+same rule. Keep them apart:
+
+- **Outbound** (``GatewayWorker._resolve_reply_command`` /
+  ``GatewayProcessor._resolve_reply_header``): the header a resumed execution
+  *sends* to its caller. The stored dispatch metadata **replaces**
+  ``header.metadata`` wholesale — the waking hop's data is plumbing the
+  original caller never asked for, and ``_enqueue_agent_return``'s
+  ``{**header.metadata, **task_result.metadata}`` is the one sanctioned
+  channel for a handler to forward part of it.
+- **Inbound** (this module): the header a resumed execution's own handler
+  *reads*. Here the waking message's metadata is legitimate payload — an
+  ``ask_user`` answer's metadata was sent BY a client TO this agent — so it is
+  merged on top of the original dispatch metadata rather than discarded.
+
+Without this, everything a handler was originally dispatched with disappears
+the first time it suspends: it comes back seeing only whatever woke it up.
+"""
+
+from typing import Any, Mapping, Optional
+
+# Injected per dispatch by AgentContext._dispatch_single_task, not supplied by
+# business code. A stored copy of them is stale by definition — it describes
+# the hop that dispatched the execution, not the hop resuming it now — so they
+# are dropped from the restored base and always come from the current message.
+# Letting them through would surface a dispatch-time span id where the waking
+# message has none, and AgentContext._resolve_call_langfuse_parent_id() reads
+# exactly that as its last-resort fallback: a call made after a resume would
+# parent to the original dispatch's observation.
+FRAMEWORK_HOP_METADATA_KEYS = frozenset(
+    {
+        "trace_parent_span_id",
+        "framework_parent_span_id",
+        "langfuse_parent_observation_id",
+    }
+)
+
+
+def merge_resume_metadata(
+    stored: Optional[Mapping[str, Any]],
+    incoming: Optional[Mapping[str, Any]],
+) -> dict[str, Any]:
+    """Merge an execution's original dispatch metadata under this hop's.
+
+    ``stored`` is the ``metadata`` field of the execution record (what the
+    execution was originally dispatched with); ``incoming`` is the waking
+    message's own metadata. The waking message wins on key collisions: it is
+    the newer, more specific hop, and this keeps the property that every key a
+    handler can read today stays readable — the restore only ever adds keys.
+
+    A ``stored`` that is missing (an execution recorded before this field
+    existed, or one dispatched by an SDK that doesn't write it) degrades to
+    ``incoming`` unchanged, i.e. exactly the pre-restore behaviour.
+
+    Neither argument is mutated.
+    """
+    merged = {
+        key: value
+        for key, value in (stored or {}).items()
+        if key not in FRAMEWORK_HOP_METADATA_KEYS
+    }
+    merged.update(incoming or {})
+    return merged

by_framework/worker/processor.py

@@ -24,6 +24,7 @@ from by_framework.core.protocol.results import (
 from by_framework.core.runtime.file_permissions import FilePermissionPolicy
 from by_framework.core.wait_gate import consume_wait_entry, emit_orphaned_reply
 from by_framework.core.wait_reply import flush_pending_group_replies
+from by_framework.worker._resume_metadata import merge_resume_metadata
 from by_framework.worker.context import AgentContext
 
 ContextHandler = Callable[
@@ -99,8 +100,18 @@ class GatewayProcessor:
                 )
                 return None
 
-        reply_header = await self._resolve_reply_header(command)
+        # One lookup feeds both directions: the header this execution replies
+        # with, and the header its own handler reads. They are different
+        # rules over the same record — see _resolve_reply_header and
+        # _restore_inbound_metadata.
+        snapshot = (
+            await self._load_execution_snapshot(command) if is_agent_return else None
+        )
+        raw_command = command
+        reply_header = self._resolve_reply_header(command, snapshot)
         has_source_agent = reply_header is not None
+        command = self._restore_inbound_metadata(command, is_agent_return, snapshot)
+        header = command.header
 
         context = AgentContext(
             session_id=header.session_id,
@@ -163,8 +174,10 @@ class GatewayProcessor:
                 getattr(context, "_is_suspended", False)
             ) and not is_terminal_state(task_result.status)
             if has_source_agent and not is_suspended:
+                # raw_command, not the inbound-restored one: the reply is the
+                # outbound direction and must not inherit the inbound merge.
                 await self._enqueue_callback(
-                    command,
+                    raw_command,
                     task_result.status,
                     task_result.reply_data,
                     content=task_result.content,
@@ -210,7 +223,7 @@ class GatewayProcessor:
 
             if has_source_agent:
                 await self._enqueue_callback(
-                    command,
+                    raw_command,
                     AgentState.FAILED.value,
                     {"error": str(e)},
                     reply_header=reply_header,
@@ -221,47 +234,101 @@ class GatewayProcessor:
             )
             raise
 
-    async def _resolve_reply_header(
+    async def _load_execution_snapshot(
         self, command: GatewayCommand
-    ) -> Optional[MessageHeader]:
-        """Return the header describing the caller this execution owes a reply
-        to, or None when nobody is waiting.
+    ) -> Optional[dict[str, Any]]:
+        """Read the execution record the original dispatch wrote.
 
-        Mirrors ``GatewayWorker._resolve_reply_command``: a resume's header
-        describes the sub-agent that just finished, so the caller has to be
-        read back from the execution record the original dispatch wrote — and,
-        for the same reason as there, ``CLIENT_SOURCE_AGENT_TYPE`` is not a
-        caller. It is what a client writes on a root execution's record, and
-        nothing consumes its control stream.
+        Fetched once per resume and shared by both restore directions.
+        Fail-soft: a registry error degrades to "no record", which each caller
+        then handles as its own no-op.
         """
         header = command.header
-        if not isinstance(command, ResumeCommand):
-            return header if header.source_agent_type else None
-
-        execution: Optional[dict[str, Any]] = None
         try:
             from by_framework.core.registry import WorkerRegistry
 
-            execution = await WorkerRegistry(self.redis).get_execution_by_message_id(
+            return await WorkerRegistry(self.redis).get_execution_by_message_id(
                 header.message_id, session_id=header.session_id
             )
         except Exception as error:  # pylint: disable=broad-exception-caught
             self.logger.warning(
-                "[%s] Could not resolve the caller of resumed execution %s: %s",
+                "[%s] Could not load the execution record of resumed execution "
+                "%s: %s",
                 self.worker_id,
                 header.message_id,
                 error,
             )
             return None
 
-        caller_agent_type = str((execution or {}).get("source_agent_type", "") or "")
+    def _resolve_reply_header(
+        self,
+        command: GatewayCommand,
+        snapshot: Optional[dict[str, Any]],
+    ) -> Optional[MessageHeader]:
+        """Return the header describing the caller this execution owes a reply
+        to, or None when nobody is waiting.
+
+        Mirrors ``GatewayWorker._resolve_reply_command``: a resume's header
+        describes the sub-agent that just finished, so the caller has to be
+        read back from the execution record the original dispatch wrote — and,
+        for the same reason as there, ``CLIENT_SOURCE_AGENT_TYPE`` is not a
+        caller. It is what a client writes on a root execution's record, and
+        nothing consumes its control stream.
+
+        Four fields come from that snapshot, not from the waking message:
+        ``source_agent_type``, ``parent_message_id``, ``task_group_id`` and
+        ``metadata``. The last one is restored as a full replacement rather
+        than a merge, exactly as ``GatewayWorker._resolve_reply_command``
+        does it: the waking message (an ``ask_user`` answer, or a sub-call's
+        reply) is transient plumbing for that one hop, not something the
+        caller ever sent. A snapshot missing the field (an execution recorded
+        before it existed) degrades to an empty dict rather than leaking the
+        waking message's metadata to the caller.
+
+        This is the OUTBOUND direction only. What the handler itself reads is
+        ``_restore_inbound_metadata``, which merges rather than replaces —
+        and which must run even when this returns None, since a
+        client-dispatched root has no caller but still has its own metadata
+        to get back.
+        """
+        header = command.header
+        if not isinstance(command, ResumeCommand):
+            return header if header.source_agent_type else None
+
+        caller_agent_type = str((snapshot or {}).get("source_agent_type", "") or "")
         if not caller_agent_type or caller_agent_type == CLIENT_SOURCE_AGENT_TYPE:
             return None
         return replace(
             header,
             source_agent_type=caller_agent_type,
-            parent_message_id=str((execution or {}).get("parent_message_id", "") or ""),
-            task_group_id=str((execution or {}).get("task_group_id", "") or ""),
+            parent_message_id=str((snapshot or {}).get("parent_message_id", "") or ""),
+            task_group_id=str((snapshot or {}).get("task_group_id", "") or ""),
+            metadata=dict((snapshot or {}).get("metadata") or {}),
+        )
+
+    @staticmethod
+    def _restore_inbound_metadata(
+        command: GatewayCommand,
+        is_agent_return: bool,
+        snapshot: Optional[dict[str, Any]],
+    ) -> GatewayCommand:
+        """Give a resumed handler its own dispatch metadata back.
+
+        Mirrors ``GatewayWorker._restore_inbound_metadata``, including its
+        merge-don't-replace rule and its no-mutation rule; see that docstring
+        for why the inbound direction differs from the outbound one.
+        """
+        if not is_agent_return:
+            return command
+        return replace(
+            command,
+            header=replace(
+                command.header,
+                metadata=merge_resume_metadata(
+                    (snapshot or {}).get("metadata"),
+                    command.header.metadata,
+                ),
+            ),
         )
 
     async def _enqueue_callback(

by_framework/worker/runner.py

@@ -625,11 +625,33 @@ class WorkerRunner:
             if registry:
                 if existing_execution:
                     if hasattr(registry, "update_execution_status"):
+                        status_fields: dict[str, Any] = {
+                            "worker_id": self.worker.worker_id
+                        }
+                        if not isinstance(command, ResumeCommand):
+                            # The dispatch metadata, recorded by whoever is
+                            # executing the message rather than by whoever
+                            # sent it: header.metadata IS the dispatch
+                            # metadata by definition, so this is correct for
+                            # every dispatcher — including a client root
+                            # dispatch and a TS/Java caller, neither of which
+                            # writes the field (see context.py's
+                            # initialize_execution, which does, and is kept
+                            # because it is the only record that exists
+                            # before a callee is ever picked up).
+                            # _handle_message reads it back to restore what
+                            # this execution was originally asked for once it
+                            # resumes.
+                            #
+                            # A ResumeCommand must NOT write it: the waking
+                            # message's metadata would overwrite the very
+                            # original this exists to preserve.
+                            status_fields["metadata"] = dict(header.metadata)
                         await registry.update_execution_status(
                             execution_id,
                             header.session_id,
                             "RUNNING",
-                            worker_id=self.worker.worker_id,
+                            **status_fields,
                         )
                 elif hasattr(registry, "save_execution"):
                     await registry.save_execution(
@@ -641,6 +663,12 @@ class WorkerRunner:
                             "parent_message_id": header.parent_message_id or "",
                             "worker_id": self.worker.worker_id,
                             "target_agent_type": header.target_agent_type,
+                            # Same reason as the update branch above. This one
+                            # is the no-existing-record fallback, so there is
+                            # no stored original to protect and no ResumeCommand
+                            # guard to make: whatever woke this is all this
+                            # execution has ever been told.
+                            "metadata": dict(header.metadata),
                             "stream_name": stream_name,
                             "redis_message_id": msg_id,
                             "status": "RUNNING",

by_framework/worker/worker.py

@@ -59,6 +59,7 @@ from by_framework.trace.span_recorder import TraceSpan, str_to_uint64
 from by_framework.worker.context import AgentContext, current_agent_context_var
 from by_framework.worker.heartbeat import WorkerHeartbeat
 
+from ._resume_metadata import merge_resume_metadata
 from .sandbox.hook_sandbox import active_workspace
 
 
@@ -377,6 +378,47 @@ class GatewayWorker(ABC):
             ),
         )
 
+    @staticmethod
+    def _restore_inbound_metadata(
+        command: GatewayCommand,
+        is_agent_return: bool,
+        execution: Optional["RunningExecution"],
+    ) -> GatewayCommand:
+        """Give a resumed handler its own dispatch metadata back.
+
+        The mirror image of ``_resolve_reply_command``, and deliberately not
+        the same rule. That one rebuilds the header this execution *sends*;
+        this one rebuilds the header it *reads*. A resumed handler otherwise
+        sees only the metadata of whatever woke it up — an ``ask_user``
+        answer's, or a sub-call's reply — and everything the execution was
+        originally dispatched with is gone from the moment it first suspends.
+
+        Merged, not replaced (the opposite of the outbound direction): this
+        agent IS the addressee of the waking message, so its metadata is real
+        payload here rather than someone else's plumbing. Original dispatch
+        metadata is the base, the waking message wins on collisions. See
+        ``_resume_metadata.py`` for why the framework's per-hop trace keys are
+        excluded from the base.
+
+        Returns a NEW command — never mutates. ``prepare_command_for_processing``
+        returns the *same* object for the base worker (only ``ByaiWorker``
+        rebuilds it), so mutating the header here would also rewrite
+        ``raw_command``'s and leak this merge into the reply that goes out.
+        """
+        if not is_agent_return:
+            return command
+        snapshot = getattr(execution, "existing_data", None) or {}
+        return replace(
+            command,
+            header=replace(
+                command.header,
+                metadata=merge_resume_metadata(
+                    snapshot.get("metadata"),
+                    command.header.metadata,
+                ),
+            ),
+        )
+
     @staticmethod
     def _apply_suspended_status(
         task_result: AgentTaskResult,
@@ -682,6 +724,7 @@ class GatewayWorker(ABC):
         is_agent_return = isinstance(raw_command, ResumeCommand)
         reply_command = self._resolve_reply_command(raw_command, execution)
         has_source_agent = reply_command is not None
+        command = self._restore_inbound_metadata(command, is_agent_return, execution)
 
         # Get workspace dir from workspace_manager if available
         # Note: We don't use hasattr check because it doesn't work well with mocks

{by_framework-0.2.2.dev13.dist-info → by_framework-0.2.2.dev15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: by-framework
-Version: 0.2.2.dev13
+Version: 0.2.2.dev15
 Summary: 分布式 Agent 调度框架
 License-File: LICENSE
 Requires-Python: >=3.12

{by_framework-0.2.2.dev13.dist-info → by_framework-0.2.2.dev15.dist-info}/RECORD

@@ -5,7 +5,7 @@ by_framework/admin/cli.py,sha256=YW4tQxb0kBheRNQR53zOkoAlYHWP4bgycuZkaJIU3WA,119
 by_framework/admin/worker_manager.py,sha256=ihXRMlFJAR74T2JSh3xTNCDjzAElWd0-_yVDAZwSTJU,5924
 by_framework/client/__init__.py,sha256=kGP7uoXIlTJuiJ2Cgl1Q5wqYjnMA4SZqoa7Q7BhQ5JQ,272
 by_framework/client/byai_client.py,sha256=bB1NyKLvVW82bXefD_3zymqZ1vk2O925CIbxOho9Qww,2426
-by_framework/client/client.py,sha256=_zVSzEFOz6c4LYnsmPbRazGVo_ZdNfuOLk93Py7ufAI,45235
+by_framework/client/client.py,sha256=XcI29Jm9ktb74cq-VcUoMl0lyIfAvGrSRcS4CttATug,45666
 by_framework/common/__init__.py,sha256=EkfIiVdmb8SCpi7OOUm6Hu84B7Wzekb-TG2hbvD_R1w,1685
 by_framework/common/config.py,sha256=mTbCn3YspY8k00b4URSbi07MNC3Cfdj7RPtDLrXrJV8,5107
 by_framework/common/constants.py,sha256=sZOUw5rlwszzsYO57yUHXI4zyrEuwka2cOyji_jblRE,34857
@@ -69,7 +69,7 @@ by_framework/errors/http.py,sha256=xtm4EKwbE1Z0n4yqWTjPOVbDd9fIPfmT8W4ou5aOLCQ,7
 by_framework/errors/protocol.py,sha256=MWr15TFIHs8Ql67mgvU9mebGdE04yPxmg4AOEGbF9E4,1269
 by_framework/errors/registry.py,sha256=LmcqSXiW8FSOghpLPHTllkbrQCnVcMYTLzO2cNU3wIw,842
 by_framework/metrics/__init__.py,sha256=8AQpVnOwAmHoQsDhCfkNXSKUOX_ZCBF_QajBXmsNhgc,11353
-by_framework/metrics/catalog.py,sha256=CR9-1M_L0rR-5jgGUw3M1TplTzntpTjN2MXG34s9lnw,17355
+by_framework/metrics/catalog.py,sha256=1yWxVCvvrbkT0Rdmi0x-rtRwtXFzQg6Dmuj75izN2X0,19684
 by_framework/metrics/collector.py,sha256=uIO2TJfX4zQTBi5gWbMfgwtdMjrhmhzjzW36BcqxBKE,8533
 by_framework/metrics/read_client.py,sha256=kcgHJlJh47eFPhlbH8QOyD-K6SpKbZHEX624XD6Mvxo,18511
 by_framework/metrics/snapshot.py,sha256=eI4JVV3uma7fT6nvp2bliO2ZUBJhJT6bzTvQDIeC-wk,101784
@@ -86,19 +86,20 @@ by_framework/worker/__init__.py,sha256=GBkUWYnHc2j3_Wx2AC2P49DzFl0CSrl0SKhdRP5CT
 by_framework/worker/_control_handling.py,sha256=0bL1Alx8_qaeXQV32Xv4ARSd9q77ySh9LMd7KtZZXu8,8111
 by_framework/worker/_execution_tracking.py,sha256=AWahfDKTXGrx_JWSCNisjGKkGAQruu9vSlXisof0BYQ,2493
 by_framework/worker/_message_processing.py,sha256=rgKzJTgPVDFp_HUfMcqJBwNdTCEfspuRAo5IM9VKsxs,2622
+by_framework/worker/_resume_metadata.py,sha256=bo3OiO_E5e6PaGcKRzwDdEKjFjMTe2d26aRPCpFSSBg,2938
 by_framework/worker/app.py,sha256=UHaQZzalqfPmHvfq-XL7vlPOJ8mTm5ULIU4JpeXA85g,16319
 by_framework/worker/byai_context.py,sha256=DvKw-X8ePZr5c5osdapvzTvH4G23u0J80U-fgMLtge4,2388
 by_framework/worker/byai_worker.py,sha256=0NoRqzuTG_MPMxVbZ1ueeOrqI0H8-Adxh7dM3vckjJo,1757
 by_framework/worker/context.py,sha256=5As3GcnVrwIE1nCJDDYLt_Ke8-8nzh44CzQBvyncQsU,59833
 by_framework/worker/health_server.py,sha256=4Jw3ltAD7Ow4dPHhwTUU_4JjKz-iDCNG7RJzD2VzPlM,6090
 by_framework/worker/heartbeat.py,sha256=trHDS8FUALsA6jyzDPa087hpr8_2vY8ZUFn0ld1kI2o,15465
-by_framework/worker/processor.py,sha256=3UjK6bqAWhmLXwQTroO5vxZlV6_j4iGQNzg_nAkDd2w,13173
-by_framework/worker/runner.py,sha256=y7qr6n-DdJyqX6RMzEknuiKsTA6wa2zjhXnLn8VuCk4,50016
-by_framework/worker/worker.py,sha256=tJfnPkRH_c-C1NGyP3tS_kpl3tfDubu0KWGH-cbQk0s,47525
+by_framework/worker/processor.py,sha256=UgC4_p-bg2KOHVTEILeMXF44rT9VLrRP5vompX0EeiQ,16243
+by_framework/worker/runner.py,sha256=6_L_UUV1Kljys_4Eh_qnwMd7a-gGsikd4M_O5K879NA,51897
+by_framework/worker/worker.py,sha256=IaPFLWCFo5U5Xo7PIQHtTt4JmtxZA1O_3nAuGl_g4N0,49527
 by_framework/worker/sandbox/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 by_framework/worker/sandbox/hook_sandbox.py,sha256=XXSdH5YGX814LvV03vkq-zn5DVIBPYYt2NhRv1lT1Bk,2329
-by_framework-0.2.2.dev13.dist-info/METADATA,sha256=C1KKoZ2p5Kq4scXP0AoQ2UpLvnWFLcw6_s4Xr8PFCjY,28018
-by_framework-0.2.2.dev13.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-by_framework-0.2.2.dev13.dist-info/entry_points.txt,sha256=5t6kgMjkR0UgJTpOsbuQDo0fOf7zeXjQW9DhkxfAGFc,56
-by_framework-0.2.2.dev13.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-by_framework-0.2.2.dev13.dist-info/RECORD,,
+by_framework-0.2.2.dev15.dist-info/METADATA,sha256=l050msraVm4RdyM0rIA_GXOpYu5pWyuUTdw7e2IBdd4,28018
+by_framework-0.2.2.dev15.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+by_framework-0.2.2.dev15.dist-info/entry_points.txt,sha256=5t6kgMjkR0UgJTpOsbuQDo0fOf7zeXjQW9DhkxfAGFc,56
+by_framework-0.2.2.dev15.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+by_framework-0.2.2.dev15.dist-info/RECORD,,