alayaflow 0.1.0__py3-none-any.whl

alayaflow/workflow/workflow_loader.py

@@ -0,0 +1,168 @@
+import sys
+import json
+import importlib.util
+import re
+from pathlib import Path
+from typing import Any, List, Callable
+from functools import cache
+
+from pydantic import BaseModel
+
+from alayaflow.workflow.runnable import StateGraphRunnableWorkflow
+from alayaflow.workflow.workflow_info import WorkflowInfo
+from alayaflow.workflow.runnable import BaseRunnableWorkflow
+
+
+class WorkflowLoader:
+    def __init__(self, workflows_dir: Path | str, workflow_id: str, version: str) -> None:
+        workflows_dir = Path(workflows_dir) if isinstance(workflows_dir, str) else workflows_dir
+        self.workflow_dir = workflows_dir / workflow_id / version
+    
+    @cache
+    def load_info(self) -> WorkflowInfo:
+        metadata_file = self.workflow_dir / "metadata.json"
+        if not metadata_file.exists():
+            raise FileNotFoundError(f"工作流目录 {self.workflow_dir} 中没有 metadata.json 文件")
+        
+        try:
+            with open(metadata_file, 'r', encoding='utf-8') as f:
+                metadata = json.load(f)
+        except json.JSONDecodeError as e:
+            raise ValueError(f"解析 metadata.json 失败: {e}")
+        except Exception as e:
+            raise IOError(f"读取 metadata.json 失败: {e}")
+        
+        required_fields = ["id", "version", "entry_file", "entry_point"]
+        missing_fields = [field for field in required_fields if field not in metadata]
+        
+        if missing_fields:
+            raise ValueError(
+                f"工作流目录 {self.workflow_dir} 的 metadata.json 中缺少必需字段: {', '.join(missing_fields)}"
+            )
+        
+        return WorkflowInfo(
+            id=metadata["id"],
+            name=metadata.get("name", metadata["id"]),
+            description=metadata.get("description", ""),
+            version=metadata.get("version"),
+            tags=metadata.get("tags", []),
+            entry_file=metadata["entry_file"],
+            entry_point=metadata["entry_point"],
+            wf_dir=self.workflow_dir,
+        )
+    
+    @cache
+    def load_requirements(self) -> List[str]:
+        requirements_file = self.workflow_dir / "requirements.txt"
+        if not requirements_file.exists():
+            return []
+        
+        requirements: List[str] = []
+        try:
+            with open(requirements_file, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    if line and not line.startswith("#"):
+                        requirements.append(line)
+        except Exception as e:
+            raise IOError(f"读取 requirements.txt 失败: {e}")
+        
+        return requirements
+
+    def _clear_module_cache(self, module_name: str) -> None:
+        """清理模块及其子模块缓存（用于 force_reload）"""
+        prefix = module_name + "."
+        for key in list(sys.modules.keys()):
+            if key == module_name or key.startswith(prefix):
+                del sys.modules[key]
+
+    def _load_runnable_data(self, force_reload: bool = False) -> tuple[Callable[..., BaseModel], Callable[..., Any]]:
+        info = self.load_info()
+
+        entry_filepath = info.wf_dir / info.entry_file
+        if not entry_filepath.exists():
+            raise FileNotFoundError(
+                f"工作流 {info.id} 的入口文件不存在: {entry_filepath}"
+            )
+
+        module_name = self._sanitize_module_name(info.id, info.version)
+
+        if force_reload:
+            self._clear_module_cache(module_name)
+        module = sys.modules.get(module_name)
+        if module is None:
+            module = self._load_module(module_name, entry_filepath)
+
+        create_graph_func = self._resolve_entry_point(module, info.entry_point, info.id)
+        if not callable(create_graph_func):
+            raise TypeError(
+                f"工作流 {info.id} 的入口点 '{info.entry_point}' 不是可调用对象，"
+                f"而是 {type(create_graph_func)}"
+            )
+
+        # TODO: Support loading input schema
+        get_input_schema_func = None
+
+        return get_input_schema_func, create_graph_func
+
+    def load_workflow(self, init_args: dict = {}, force_reload: bool = False) -> BaseRunnableWorkflow:
+        """加载工作流，返回包含 info 和 creator 的加载结果"""
+        info = self.load_info()
+
+        # now we only support StateGraph
+        get_input_schema_func, create_graph_func = self._load_runnable_data(force_reload)
+        graph = create_graph_func(init_args)
+        runnable = StateGraphRunnableWorkflow(info=info, graph=graph)
+
+        return runnable
+    
+    def _sanitize_module_name(self, wf_id: str, version: str) -> str:
+        safe_version = version.replace(".", "_")
+        safe_wf_id = re.sub(r'[^0-9a-zA-Z_]', '_', wf_id)
+        return f"workflow.{safe_wf_id}.{safe_version}"
+    
+    def _load_module(self, module_name: str, filepath: Path) -> Any:
+        """加载 Python 模块，支持相对导入"""
+        try:
+            # 工作流目录（包含 workflow.py 的目录）
+            workflow_dir = filepath.parent
+            
+            # 使用 spec_from_file_location 加载模块
+            # submodule_search_locations 参数使相对导入能够工作
+            spec = importlib.util.spec_from_file_location(
+                module_name,
+                filepath,
+                submodule_search_locations=[str(workflow_dir)]
+            )
+            if spec is None:
+                raise ImportError(f"无法为文件 {filepath} 创建模块规范")
+            
+            if spec.loader is None:
+                raise ImportError(f"文件 {filepath} 没有加载器")
+            
+            module = importlib.util.module_from_spec(spec)
+            sys.modules[module_name] = module
+            spec.loader.exec_module(module)
+            
+            return module
+        except Exception as e:
+            # 如果加载失败，清理 sys.modules
+            if module_name in sys.modules:
+                del sys.modules[module_name]
+            raise ImportError(f"加载工作流模块失败: {e}") from e
+    
+    def _resolve_entry_point(self, module: Any, entry_point: str, workflow_id: str) -> Any:
+        parts = entry_point.split('.')
+        obj = module
+        
+        for i, part in enumerate(parts):
+            if not hasattr(obj, part):
+                path_so_far = '.'.join(parts[:i+1])
+                raise AttributeError(
+                    f"工作流 {workflow_id} 的模块中没有找到入口点 '{path_so_far}'"
+                )
+            obj = getattr(obj, part)
+        
+        return obj
+
+    

alayaflow/workflow/workflow_manager.py

@@ -0,0 +1,257 @@
+import json
+import zipfile
+import shutil
+import tempfile
+
+from pathlib import Path
+from typing import Optional, Dict, List, Tuple, Callable, Any
+import requests
+
+from alayaflow.workflow.workflow_info import WorkflowKey, WorkflowInfo
+from alayaflow.workflow.workflow_loader import WorkflowLoader
+from alayaflow.workflow.runnable import BaseRunnableWorkflow
+from alayaflow.common.config import settings
+
+
+class WorkflowManager:
+    def __init__(self):
+        self._info_cache: Dict[WorkflowKey, WorkflowInfo] = {}
+        self._workflow_cache: Dict[WorkflowKey, BaseRunnableWorkflow] = {}
+        self._requirements_cache: Dict[WorkflowKey, List[str]] = {}
+        
+    def clear_cache(self):
+        self._info_cache.clear()
+        self._workflow_cache.clear()
+        self._requirements_cache.clear()
+    
+    def load_workflow(self, workflow_id: str, version: str, init_args: dict = {}) -> None:
+        loader = WorkflowLoader(settings.workflow_storage_path, workflow_id, version)
+        self._info_cache[WorkflowKey(workflow_id, version)] = loader.load_info()
+        self._workflow_cache[WorkflowKey(workflow_id, version)] = loader.load_workflow(init_args)
+        self._requirements_cache[WorkflowKey(workflow_id, version)] = loader.load_requirements()
+
+    # Keep for future reference
+    # def load_workflows(self) -> None:
+    #     if not settings.workflow_storage_path.exists():
+    #         raise FileNotFoundError(f"Workflow storage path {settings.workflow_storage_path} does not exist")
+    #     for workflow_id_dir in settings.workflow_storage_path.iterdir():
+    #         if not workflow_id_dir.is_dir() or workflow_id_dir.name.startswith("_"):
+    #             continue
+    #         workflow_id = workflow_id_dir.name
+    #         for version_dir in workflow_id_dir.iterdir():
+    #             if not version_dir.is_dir() or version_dir.name.startswith("_"):
+    #                 continue
+                
+    #             version = version_dir.name
+    #             try:
+    #                 self.load_workflow(workflow_id, version)
+    #             except (FileNotFoundError, ValueError, IOError, ImportError, AttributeError, TypeError) as e:
+    #                 print(f"Loading workflow {workflow_id} version {version} failed: {e}")
+    #                 continue
+
+    def get_workflow_info(self, workflow_id: str, version: str) -> WorkflowInfo:
+        key = WorkflowKey(workflow_id, version)
+        info = self._info_cache.get(key)
+        if info is None:
+            loader = WorkflowLoader(settings.workflow_storage_path, workflow_id, version)
+            info = loader.load_info()
+            self._info_cache[key] = info
+        return info
+
+    def get_workflow_requirements(self, workflow_id: str, version: str) -> List[str]:
+        key = WorkflowKey(workflow_id, version)
+        reqs = self._requirements_cache.get(key)
+        if reqs is None:
+            loader = WorkflowLoader(settings.workflow_storage_path, workflow_id, version)
+            reqs = loader.load_requirements()
+            self._requirements_cache[key] = reqs
+        return reqs
+
+    def get_workflow_runnable(self, workflow_id: str, version: str) -> BaseRunnableWorkflow:
+        key = WorkflowKey(workflow_id, version)
+        runnable = self._workflow_cache.get(key)
+        if runnable is None:
+            raise ValueError(f"Workflow {workflow_id} version {version} does not loaded. Call load_workflow first.")
+        return runnable
+
+    def list_loaded_workflows(self) -> List[str]:
+        return [f'{wf.id}_{wf.version}' for wf in self._workflow_cache.keys()]
+
+    def list_loaded_workflow_ids(self) -> List[str]:
+        return list(set(wf.id for wf in self._workflow_cache.keys()))
+
+    def list_local_workflow_info_list(self) -> List[WorkflowInfo]:
+        if not settings.workflow_storage_path.exists():
+            raise FileNotFoundError(f"Workflow storage path {settings.workflow_storage_path} does not exist")
+        info_list = []
+        for workflow_id_dir in settings.workflow_storage_path.iterdir():
+            if not workflow_id_dir.is_dir() or workflow_id_dir.name.startswith("_"):
+                continue
+            workflow_id = workflow_id_dir.name
+            for version_dir in workflow_id_dir.iterdir():
+                if not version_dir.is_dir() or version_dir.name.startswith("_"):
+                    continue
+                
+                version = version_dir.name
+                try:
+                    info = self.get_workflow_info(workflow_id, version)
+                    info_list.append(info)
+                except (FileNotFoundError, ValueError, IOError, ImportError, AttributeError, TypeError) as e:
+                    print(f"Loading workflow {workflow_id} version {version} failed: {e}")
+                    continue
+        return info_list
+        
+    def list_local_workflows(self) -> List[str]:
+        return list(set(wf.id for wf in self.list_local_workflow_info_list()))
+
+    def list_local_workflow_versions(self, workflow_id: str) -> List[str]:
+        return [wf.version for wf in self.list_local_workflow_info_list() if wf.id == workflow_id]
+
+    def list_remote_workflow_ids(self) -> List[str]:
+        remote_workflow_ids = []
+        try:
+            list_url = f"{settings.alayahub_url}/api/workflows/list"
+            params = {"page": 1, "page_size": 100}
+            
+            response = requests.get(list_url, params=params, timeout=10)
+            response.raise_for_status()
+            
+            data = response.json()
+
+            if isinstance(data, dict):
+                workflows_data = data.get("workflows", data.get("items", []))
+            elif isinstance(data, list):
+                workflows_data = data
+            else:
+                workflows_data = []
+            
+            for workflow in workflows_data:
+                if isinstance(workflow, dict):
+                    workflow_id = workflow.get("id") or workflow.get("workflow_id")
+                    if workflow_id:
+                        remote_workflow_ids.append(workflow_id)
+                elif isinstance(workflow, str):
+                    remote_workflow_ids.append(workflow)
+                        
+        except requests.RequestException:
+            pass
+        
+        # 去重后返回
+        return list(set(remote_workflow_ids))
+
+    def list_available_workflows(self) -> Dict[str, List[str]]:
+        """列举工作流，分别返回本地已安装和远程未安装的工作流"""
+        # 获取本地已安装的工作流，格式为 ID_version
+        local_workflows = self.list_local_workflows()
+        local_set = set(local_workflows)
+        
+        # 获取远程平台上的工作流列表
+        remote_workflows = []
+        try:
+            list_url = f"{self.platform_api_url}/api/workflows/list"
+            params = {"page": 1, "page_size": 100}  # 获取前100个工作流
+            
+            response = requests.get(list_url, params=params, timeout=10)
+            response.raise_for_status()
+            
+            data = response.json()
+
+            if isinstance(data, dict):
+                workflows_data = data.get("workflows", data.get("items", []))
+            elif isinstance(data, list):
+                workflows_data = data
+            else:
+                workflows_data = []
+            
+            # 提取工作流，格式为 id_version，只保留未安装的
+            for workflow in workflows_data:
+                if isinstance(workflow, dict):
+                    workflow_id = workflow.get("id")
+                    workflow_version = workflow.get("version")
+                    workflow_key = f"{workflow_id}_{workflow_version}"
+                    # 检查该 id_version 是否已在本地安装
+                    if workflow_key not in local_set:
+                        remote_workflows.append(workflow_key)
+                        
+        except requests.RequestException:
+            pass
+        
+        return {
+            "local": local_workflows,
+            "remote": remote_workflows,
+        }
+
+
+    def install_workflow(self, workflow_id: str) -> bool:
+        try:
+            # 1. 从平台下载工作流 zip 文件
+            download_url = f"{settings.alayahub_url}/api/workflows/{workflow_id}/download"
+            response = requests.get(download_url, stream=True, timeout=30)
+            response.raise_for_status()
+            
+            # 2. 创建临时目录存放 zip 文件
+            with tempfile.TemporaryDirectory() as temp_dir:
+                zip_path = Path(temp_dir) / f"{workflow_id}.zip"
+                
+                # 保存 zip 文件
+                with open(zip_path, "wb") as f:
+                    for chunk in response.iter_content(chunk_size=8192):
+                        f.write(chunk)
+                
+                # 3. 读取 metadata.json 获取工作流信息
+                with zipfile.ZipFile(zip_path, "r") as zip_ref:
+                    # 检查是否有 metadata.json
+                    metadata_content = None
+                    for file_info in zip_ref.namelist():
+                        if file_info.endswith("metadata.json"):
+                            metadata_content = zip_ref.read(file_info).decode("utf-8")
+                            break
+                    
+                    if not metadata_content:
+                        raise ValueError(f"工作流 {workflow_id} 的 zip 文件中未找到 metadata.json")
+                    
+                    # 解析 metadata.json 获取版本
+                    metadata = json.loads(metadata_content)
+                    version = metadata.get("version", "1.0.0")
+                    
+                    # 确定本地工作流目录（格式：workflow_id/version）
+                    workflow_id_dir = settings.workflow_storage_path / workflow_id
+                    workflow_dir = workflow_id_dir / version
+                    
+                    # 4. 如果该版本目录已存在，先删除
+                    if workflow_dir.exists():
+                        shutil.rmtree(workflow_dir)
+                    
+                    # 5. 创建目录并解压文件
+                    workflow_dir.mkdir(parents=True, exist_ok=True)
+                    
+                    # 解压所有文件到目标目录
+                    zip_ref.extractall(workflow_dir)
+                    
+                    # 6. 清理缓存以便重新加载
+                    self.clear_cache()
+                    
+                    return True
+                    
+        except requests.RequestException as e:
+            raise ValueError(f"下载工作流 {workflow_id} 失败: {e}") from e
+        except Exception as e:
+            raise ValueError(f"安装工作流 {workflow_id} 失败: {e}") from e
+    
+    def uninstall_workflow(self, workflow_id: str) -> bool:
+        try:
+            # 确定工作流目录（格式：workflow_id/）
+            workflow_id_dir = settings.workflow_storage_path / workflow_id
+            
+            if not workflow_id_dir.exists() or not workflow_id_dir.is_dir():
+                raise ValueError(f"工作流 {workflow_id} 未安装")
+            
+            # 删除整个 workflow_id 目录（包含所有版本）
+            shutil.rmtree(workflow_id_dir)
+            
+            # 清理缓存
+            self.clear_cache()
+            return True
+            
+        except Exception as e:
+            raise ValueError(f"卸载工作流 {workflow_id} 失败: {e}") from e

alayaflow-0.1.0.dist-info/METADATA

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: alayaflow
+Version: 0.1.0
+Summary: A desktop platform for executing LangGraph workflows with uv-managed sandboxes.
+Author-email: alayaflow group <dev@example.com>
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: fastapi<0.116.0,>=0.100.0
+Requires-Dist: langchain
+Requires-Dist: langchain-community
+Requires-Dist: langchain-openai
+Requires-Dist: langgraph
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: requests>=2.31.0
+Requires-Dist: rich
+Requires-Dist: typer>=0.9.0
+Description-Content-Type: text/markdown
+
+# AlayaFlow
+
+A desktop platform for executing LangGraph workflows with multiple executors.
+
+## 简介
+
+AlayaFlow 是一个桌面平台，用于执行 LangGraph 工作流。
+
+
+## 安装
+
+### 从 PyPI 安装（推荐）
+
+```bash
+pip install alayaflow
+```
+
+### 从源码安装
+
+```bash
+git clone git@github.com:AlayaDB-AI/AlayaFlow.git
+cd alayaflow
+pip install -e .
+```
+
+## 系统要求
+
+- Python >= 3.10
+- uv (Rust-based Python package installer)
+
+## 使用示例
+
+```python
+from alayaflow.workflow import WorkflowManager, WorkflowLoader
+
+# 创建工作流管理器
+manager = WorkflowManager()
+
+# 加载工作流
+manager.load_workflow(workflow_id="my-workflow", version="1.0.0")
+
+# 执行工作流...
+```
+
+## 配置
+
+项目支持通过 `.env` 文件进行配置。主要配置项包括：
+
+- `dev_mode`: 开发模式（dev/dev-uneditable/prod）
+- `alayahub_url`: AlayaHub API 地址
+- `langfuse_enabled`: 是否启用 Langfuse 追踪
+- 各种存储路径配置
+
+## 开发
+
+### 安装开发依赖
+
+```bash
+pip install -e ".[dev]"
+```
+
+### 运行测试
+
+```bash
+pytest
+```
+
+## 许可证
+
+本项目采用 MIT License。详情请参阅 [LICENSE](LICENSE) 文件。
+
+## 贡献
+
+欢迎提交 Issue 和 Pull Request！
+
+## 相关链接
+
+- [LangGraph](https://github.com/langchain-ai/langgraph)
+- [uv](https://github.com/astral-sh/uv)

alayaflow-0.1.0.dist-info/RECORD

@@ -0,0 +1,37 @@
+alayaflow/__init__.py,sha256=Twp-G7fdsTkTspyDl9VKx9yieHHF9b8BalhEtnqNKWs,121
+alayaflow/api/__init__.py,sha256=Y33eVzsA9v20VLpRK-v3DZOF-DsjfExag6C1taK2WRc,74
+alayaflow/api/api_singleton.py,sha256=5ffWXL4umEOD3VNBOL0X2c38-PjOEEeQkK5yWbTI1BU,10721
+alayaflow/clients/alayamem/base_client.py,sha256=pyU2WF2jqNEgBEe8JOZSg13gHQ2pJcBgJ_6YP-5mWkw,540
+alayaflow/clients/alayamem/http_client.py,sha256=n0hAh_ddzEwFfNMsdw5s2dqvuMsyZNGOT-RcHsIXuEw,2171
+alayaflow/common/config.py,sha256=pi4zH_Pi0u6Fb8ZIs4u3qFOUOUeqxxUqqksoUp-hynM,3806
+alayaflow/component/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+alayaflow/component/chat_model.py,sha256=aXBRDdtp0HOHlonwfXTzOIcjepjd5zBh8znlJpK9oVU,461
+alayaflow/component/intent_classifier.py,sha256=5KH52LIqIDpw2hlX4gi3Ff7SFVhenCFdFV-fXag0sDM,3765
+alayaflow/component/llm_node.py,sha256=URRqSj-snRjbPk-7S7uEd8DJk3L2srYe8Qslu8T6u28,3773
+alayaflow/component/memory.py,sha256=Xl5ABW89dswC9oMwkeS6NFAZniKFw8BuGuLAAHddRRA,1448
+alayaflow/component/retrieve_node.py,sha256=vJqK-5KC-w9ZE_cxA1hHDTWuA-vbPrvxJkionKfniYE,652
+alayaflow/component/web_search.py,sha256=PoUZV_H4vTDSwTqQarbmukQzpyUcBTatJxLZso-0Kok,3282
+alayaflow/component/langflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+alayaflow/component/langflow/intent_classifier.py,sha256=0xqq2wpVVnEErgjOenKYHMsXMkCrHOlCpEZRJqw3PoM,2822
+alayaflow/execution/__init__.py,sha256=9gj_xgIJxlq3EuwsDMb5X05yP70HoD0_T25Khd495Xc,117
+alayaflow/execution/env_manager.py,sha256=fQm8RO4HwEIfbqdwA4Qc76TgrJiBj39NCaJuy7XhaAk,16672
+alayaflow/execution/executor_manager.py,sha256=EwSlU6WnsRkhO0z2cxESwtsQnaIOjfmDazVyUob6DVA,2158
+alayaflow/execution/langfuse_tracing.py,sha256=BuRMHDH7Gub7CMkJM5ECLzs4vjy3VqAgzh2INE9zbOI,3882
+alayaflow/execution/workflow_runner.py,sha256=XEX4Em0Hv1sI8Im0lREjXq3fN1jYVwFnMMW3pphIAZk,3243
+alayaflow/execution/executors/__init__.py,sha256=RYwYg880smrZ8EX5iwVsJe0Rtgo8-tF82pY5jA3926g,412
+alayaflow/execution/executors/base_executor.py,sha256=yMP2Fw2uf6TCOj9axQtFApIZCSw94QOXuxvEpzy9UW0,257
+alayaflow/execution/executors/naive_executor.py,sha256=lLqjsHZBbXGUO2HMvr_0hYD9tgUKMWep7v0QBQUF8Lk,4892
+alayaflow/execution/executors/uv_executor.py,sha256=XCqECDdieBlZ36CcMSGVyml11Oi9p4HnJLhyapBDlfQ,4630
+alayaflow/execution/executors/worker_executor.py,sha256=o_O8RjguTifGye4avuBkhKGZcrB_xAAbVuMNve8isfY,521
+alayaflow/utils/singleton.py,sha256=5crFVfOkr9pU_j83ywqAMaL07BvVN5Ke_VGjT9qyUN0,432
+alayaflow/workflow/__init__.py,sha256=9IqNPAtWt7DzASmxg48iTRu-STymvUBd8_7-JsR2pgk,250
+alayaflow/workflow/workflow_info.py,sha256=rnpAwYE4trhiv7o8LPmQpyQ3CDFfNN2yk1CLKRnWz0w,1259
+alayaflow/workflow/workflow_loader.py,sha256=fJi7i714JRY5bESahLxcTNei_f-YEL5fnZtgHG7ChG4,6623
+alayaflow/workflow/workflow_manager.py,sha256=bfPGP1UWom4B2ZfuWyyKI0tfFxyn4j2_wBMECc8-Fu8,11536
+alayaflow/workflow/runnable/__init__.py,sha256=sNybFeRxLwbDLHiZxlVFXsn3w2n1Jn0Mtun2W6fvjFU,257
+alayaflow/workflow/runnable/base_runnable_workflow.py,sha256=gN8d2pUijugu1JZr3RrHS95ziu8Of401IQQtmTM6_lc,655
+alayaflow/workflow/runnable/state_graph_runnable_workflow.py,sha256=K2ahaGN9ubr9G2wDeBTQR_0sYo03SWhQbGVUjIb7w0U,843
+alayaflow-0.1.0.dist-info/METADATA,sha256=ribiSb6KxPEN_sDGa9Yd4v8w21jFzKegHvkD0448zsw,1925
+alayaflow-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+alayaflow-0.1.0.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+alayaflow-0.1.0.dist-info/RECORD,,

alayaflow-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py3-none-any