cvdlink 0.1.1__py3-none-any.whl

FeatureCloud/app/engine/library.py

@@ -0,0 +1,46 @@
+"""
+This is the module-level docstring for library.py
+"""
+from distutils import dir_util
+
+import yaml
+
+from app import AppState
+
+
+class BlankState(AppState):
+
+    def __init__(self, next_state: str = 'terminal'):
+        super().__init__()
+        self.next_state = next_state
+
+    def register(self):
+        if self.next_state:
+            self.register_transition(self.next_state)
+
+    def run(self):
+        return self.next_state
+
+
+class CopyState(BlankState):
+
+    def __init__(self, next_state=None):
+        super().__init__(next_state)
+
+    def run(self):
+        dir_util.copy_tree('/mnt/input/', '/mnt/output/')
+        return super().run()
+
+
+class ConfigState(BlankState):
+
+    def __init__(self, next_state, section, config='config'):
+        super().__init__(next_state)
+        self.section = section
+        self.config = config
+
+    def run(self):
+        if self.section:
+            with open('/mnt/input/config.yml') as f:
+                self.store(self.config, yaml.load(f, Loader=yaml.FullLoader)[self.section])
+        return super().run()

FeatureCloud/workflow/app.py

@@ -0,0 +1,197 @@
+import os.path
+from os import listdir
+from pathlib import Path
+import zipfile
+from time import sleep
+from FeatureCloud.workflow.controller import Controller
+from functools import partial
+import shutil
+from distutils.dir_util import copy_tree
+
+
+class TestApp(Controller):
+    """
+    Attributes:
+    -----------
+        app_image: str
+            image name of the app in FeatureCloud docker repository
+        test_id: int
+            ID of the test running on a specific controller.
+        n_clients: int
+            Number of clients that app will run for
+        results_ready: bool
+            It is true once the results are extracted to the app's directory
+        app_id: int
+            ID of app in the workflow
+        generic_dir: str
+            Relative path to directory containing generic files
+        clients_path: list
+            Full path to directory containing the clients' data
+        clients_relative_path: list
+            Relative path to directory containing the clients' data
+        results_path: str
+            Full path to directory containing the app's results for clients
+        results_relative_path: str
+            Relative path to directory containing the app's results for clients
+    Methods:
+    --------
+        set_id(test_id):
+        extract_results(def_res_file):
+        wait_until_finishes():
+        clean_dirs(def_re_dir):
+        create_paths(ctrl_data_path, ctrl_test_path):
+        copy_results(ctrl_data_path, dest_generic, dest_clients, default_res_name):
+
+    """
+    def __init__(self, app_id, ctrl_data_path, ctrl_test_path, n_clients, app_image, **kwargs):
+        super().__init__(**kwargs)
+        if app_image.strip().startswith("featurecloud.ai/"):
+            self.app_image = app_image.strip()
+        else:
+            self.app_image = f"featurecloud.ai/{app_image.strip()}"
+        self.test_id = None
+        self.n_clients = n_clients
+        self.results_ready = False
+        self.app_id = app_id
+        self.generic_dir = ""
+        self.clients_path = []
+        self.clients_relative_path = []
+        self.results_path = ""
+        self.results_relative_path = ""
+        self.create_paths(ctrl_data_path, ctrl_test_path)
+        self.start = partial(self.start,
+                             client_dirs=self.clients_relative_path,
+                             generic_dir=self.generic_dir,
+                             app_image=app_image,
+                             download_results=self.results_relative_path)
+        self.stop = partial(self.stop, self.test_id)
+
+    def set_id(self, test_id: int):
+        """ Set the app's test ID and partially define the
+            delete method based on it.
+
+
+        Parameters
+        ----------
+        test_id: int
+        """
+        self.test_id = test_id
+        self.delete = partial(self.delete, test_id=self.test_id, del_all=None)
+
+    def extract_results(self, def_res_file: str):
+        """ extract app's results zip files for all clients
+            into their corresponding directories
+
+        Parameters
+        ----------
+        def_res_file: str
+            Default name for the app's result directory
+            Same name for all clients.
+
+        """
+        zip_files = [f for f in listdir(self.results_path) if f.endswith(".zip")]
+        Path(self.results_path).mkdir(exist_ok=True, parents=True)
+        if len(zip_files) > 1:
+            print(f"Extracting the results of {self.app_image} ...")
+            for zip_file in zip_files:
+                client_n = int(zip_file.strip().split("client_")[-1].strip().split("_")[0])
+                res_dir = f"{self.clients_path[client_n]}/{def_res_file}"
+                zip_file_path = f"{self.results_path}/{zip_file}"
+                if not os.path.exists(res_dir):
+                    os.makedirs(res_dir, exist_ok=True)
+                    print(f"Create {res_dir} directory...")
+                with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:
+                    zip_ref.extractall(res_dir)
+                    print(f"Extract client {client_n} to {res_dir} directory...")
+            self.results_ready = True
+        else:
+            print(f"Looking into {self.results_path}\n"
+                  f"There is no file yet!\n"
+                  "We will check again later....")
+            sleep(5)
+            self.extract_results(def_res_file)
+
+    def wait_until_finishes(self):
+        """ Waits until the app status becomes finished.
+
+        """
+        while not self.is_finished():
+            sleep(5)
+
+    def is_finished(self):
+        """ Check either the app status is finished.
+
+        """
+        df = self.info(test_id=self.test_id, format='dataframe')
+        # if df is None:
+        #     print(msg)
+        return df.status.values == "finished"
+
+    def clean_dirs(self, def_re_dir: str):
+        """ creates results directories.
+            And removes existing results in the directories
+
+        Parameters
+        ----------
+        def_re_dir: str
+            Default name for the app's result directory
+            Same name for all clients.
+        """
+        for c_dir in self.clients_path:
+            print(c_dir, def_re_dir)
+            if os.path.exists(f"{c_dir}/{def_re_dir}"):
+                print(f"Delete {c_dir}/{def_re_dir}")
+                shutil.rmtree(f"{c_dir}/{def_re_dir}")
+        if os.path.exists(self.results_path):
+            for zip_file in os.listdir(self.results_path):
+                if zip_file.endswith(".zip"):
+                    print(f"Delete {self.results_path}/{zip_file}")
+                    os.remove(f"{self.results_path}/{zip_file}")
+        else:
+            Path(self.results_path).mkdir(exist_ok=True, parents=True)
+
+    def create_paths(self, ctrl_data_path: str, ctrl_test_path: str):
+        """ Generate paths to directories containing the app's data(for each client)
+            And also for app's results.
+
+        Parameters
+        ----------
+        ctrl_data_path: str
+            path to the target controller's data folder
+        ctrl_test_path: str
+            path to the target controller's tests folder
+
+        """
+        self.results_relative_path = f"./results/app{self.app_id}"
+        clients_relpath = [f"./app{self.app_id}/client_{c}" for c in range(self.n_clients)]
+        self.clients_relative_path = ",".join(clients_relpath)
+        self.clients_path = [f"{ctrl_data_path}{clients_relpath[c][1:]}" for c in
+                             range(self.n_clients)]
+        self.results_path = f"{ctrl_test_path}{self.results_relative_path[1:]}"
+        self.generic_dir = f"./app{self.app_id}/generic"
+
+    def copy_results(self, ctrl_data_path: str, dest_generic: str, dest_clients: list, default_res_name: str):
+        """ Copy results of the app to
+            as the data to the directory of the next app.
+
+        Parameters
+        ----------
+        ctrl_data_path: str
+            path to the target controller's data folder
+        dest_generic: str
+            Full path to directory containing
+            the generic data of the next app in the workflow
+        dest_clients: str
+            Full path to directory containing
+            the clients' data of the next app in the workflow
+        default_res_name: str
+            Default name for the app's result directory
+            Same name for all clients.
+
+        """
+        for client_n, client_res in enumerate(self.clients_path):
+            res_dir = f"{client_res}/{default_res_name}"
+            print(f"Copy {res_dir} to {dest_clients[client_n]} ...")
+            copy_tree(res_dir, dest_clients[client_n])
+        copy_tree(f"{ctrl_data_path}{dest_generic[1:]}",
+                  f"{ctrl_data_path}{dest_generic[1:]}")

FeatureCloud/workflow/controller.py

@@ -0,0 +1,17 @@
+from FeatureCloud.api.imp.test import commands
+from functools import partial
+
+
+class Controller:
+    def __init__(self, controller_host: str, channel: str, query_interval: str):
+        self.controller_host = controller_host
+        self.channel = channel
+        self.query_interval = query_interval
+        self.start = partial(commands.start, controller_host=controller_host, channel=channel,
+                             query_interval=query_interval)
+        self.stop = partial(commands.stop, controller_host=controller_host)
+        self.delete = partial(commands.delete, controller_host=controller_host)
+        self.list = partial(commands.list, controller_host=controller_host)
+        self.traffic = partial(commands.traffic, controller_host=controller_host)
+        self.logs = partial(commands.logs, controller_host=controller_host)
+        self.info = partial(commands.info, controller_host=controller_host)

FeatureCloud/workflow/example_wf.py

@@ -0,0 +1,83 @@
+from FeatureCloud.workflow.workflow import TestWorkFlow
+from FeatureCloud.workflow.app import TestApp
+from time import sleep
+from functools import partial
+
+
+class WorkFlow(TestWorkFlow):
+    """ Example workflow containing following apps:
+        1- featurecloud.ai/fc_cross_validation
+        2- featurecloud.ai/basic_rf
+        3- featurecloud.ai/fc_roc
+
+        Methods:
+        --------
+        register_apps(): registering the apps
+        run(): running apps with the same order as registration
+
+    """
+    def __init__(self, controller_host: str, channel: str, query_interval: str):
+        super().__init__(controller_host, channel, query_interval)
+
+        self.controller_path = "/home/mohammad/PycharmProjects/FeatureCloud/data"
+        self.ctrl_data_path = f"{self.controller_path}"
+        self.ctrl_test_path = f"{self.controller_path}/tests"
+
+        self.generic_dir = {}
+        self.n_clients = 2
+        self.TestApp = partial(TestApp,
+                               n_clients=self.n_clients,
+                               ctrl_data_path=self.ctrl_data_path,
+                               ctrl_test_path=self.ctrl_test_path,
+                               controller_host=controller_host,
+                               channel=channel,
+                               query_interval=query_interval)
+
+    def register_apps(self):
+        """ Registering the three apps.
+
+        """
+        app_id = 0
+        app1 = self.TestApp(app_id=app_id, app_image="featurecloud.ai/fc_cross_validation")
+        self.register(app1)
+
+        app_id += 1
+        app2 = self.TestApp(app_id=app_id, app_image="featurecloud.ai/basic_rf")
+        self.register(app2)
+
+        app_id += 1
+        app3 = self.TestApp(app_id=app_id, app_image="featurecloud.ai/fc_roc")
+        self.register(app3)
+
+    def run(self):
+        """ Running apps with the same registration order,
+            logging the app execution,
+            setting the ID
+            waiting until the app execution is finished
+            extracting the result to the app's directory
+            Waiting until the extraction is over
+            Delete the test run for the app
+            Copy the results as data for the next app
+
+        """
+        print("Workflow execution starts ...")
+        for i, app in enumerate(self.apps):
+            app.clean_dirs(self.default_res_dir_name)
+            id = app.start()
+            app.set_id(id)
+            print(f"{app.app_image}(ID: {app.test_id}) is running ...")
+            app.wait_until_finishes()
+            print("App execution is finished!")
+            app.extract_results(self.default_res_dir_name)
+            print("extracting the data...")
+            while not app.results_ready:
+                sleep(5)
+            print("Delete the app container...")
+            app.delete()
+            if i < len(self.apps) - 1:
+                print(f"Move {app.app_image} results to the directory of the next app({self.apps[i + 1].app_image})")
+                app.copy_results(ctrl_data_path=self.ctrl_data_path,
+                                 dest_clients=self.apps[i + 1].clients_path,
+                                 dest_generic=self.apps[i + 1].generic_dir,
+                                 default_res_name=self.default_res_dir_name)
+        print("Workflow execution is finished!")

FeatureCloud/workflow/workflow.py

@@ -0,0 +1,86 @@
+import abc
+from FeatureCloud.workflow.controller import Controller
+
+
+class TestWorkFlow(abc.ABC):
+    """ The abstract TestWorkFlow class to cover basic functionalities
+        for FeatureCloud workflow.
+        Non-linear streams
+    Attributes:
+    -----------
+        apps: list of instances of TestApp in the workflow
+        controller: an instance of Controller class
+        default_res_dir_name: str
+            the dir-name of apps' results
+    Methods:
+    --------
+        register_apps():
+        run():
+        register(app):
+        stop(controller_ind):
+        delete(controller_ind):
+        list(controller_ind, format):
+        info(format, controller_ind):
+    """
+
+    def __init__(self, controller_host: str, channel: str, query_interval: str):
+        self.apps = []
+        self.controller = Controller(controller_host, channel, query_interval)
+        self.default_res_dir_name = "AppResSults"
+
+    @abc.abstractmethod
+    def register_apps(self):
+        """ Abstract method tha should be implemented
+         by developers to register apps into the workflow.
+
+        """
+
+    @abc.abstractmethod
+    def run(self):
+        """ Abstract method tha should be implemented
+            by developers to run the workflow.
+        """
+
+    def register(self, app):
+        """ Adding TestApp instance to the app list
+            and logging the apps attributes.
+
+        Parameters
+        ----------
+        app: TestApp
+            app instance to be registered.
+
+        """
+        self.apps.append(app)
+        clients_dirs = "\n\t\t".join(app.clients_path)
+        msg = f"{app.app_image} app is registered:\n" \
+              f"\tController: {app.controller_host}\n" \
+              f"\tClient data:\n" \
+              f"\t\t{clients_dirs}\n" \
+              f"\tGeneric data: {app.generic_dir}\n" \
+              f"\tResult dir: {app.results_path}"
+        print(msg)
+
+    def stop(self):
+        """ Stop all tests in the controller.
+
+        """
+        for test_id in self.controller.list():
+            self.controller.stop(test_id)
+
+    def delete(self):
+        """ Delete all tests in the controller.
+
+        """
+        for test_id in self.controller.list():
+            self.controller.delete(test_id)
+
+    def info(self, format: str):
+        """ info of all tests in the specified controller or all of them.
+
+        """
+
+        info_list = []
+        for test_id in self.controller.list():
+            info_list.append(self.controller.info(test_id, format))
+        return info_list

cvdlink-0.1.1.dist-info/METADATA

@@ -0,0 +1,176 @@
+Metadata-Version: 2.4
+Name: cvdlink
+Version: 0.1.1
+Summary: Secure Federated Learning Platform
+Home-page: https://github.com/FeatureCloud/app-template
+Author: CoSyBio Group, University of Hamburg
+Author-email: mohammad.bakhtiari@uni-hamburg.de
+Project-URL: Bug Tracker, https://github.com/FeatureCloud/app-template/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: bottle
+Requires-Dist: jsonpickle
+Requires-Dist: joblib
+Requires-Dist: numpy
+Requires-Dist: pydot
+Requires-Dist: pyyaml
+Requires-Dist: flake8~=3.9.2
+Requires-Dist: pycodestyle~=2.7.0
+Requires-Dist: Click~=8.0.1
+Requires-Dist: requests
+Requires-Dist: urllib3~=1.26.6
+Requires-Dist: pandas>=2.0
+Requires-Dist: pyinstaller
+Requires-Dist: docker==7.1.0
+Requires-Dist: gitpython
+Requires-Dist: tqdm
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+
+# CVDLink (FeatureCloud Extension)
+
+## Overview
+
+**CVDLink** is a domain-specific extension of the **FeatureCloud** Python package, customized and deployed for the **CVDLink project** available on https://fc.cdvlink-project.eu   
+It builds on the core FeatureCloud platform to support **privacy-preserving federated learning and data analysis**, while providing **CVDLink-specific defaults, endpoints, and infrastructure integrations**.
+
+CVDLink targets federated collaborations in cardiovascular research and related biomedical domains, enabling partners to participate in secure, distributed workflows without sharing raw data.
+
+> **Important:**  
+> CVDLink is **not a replacement or independent fork** of FeatureCloud.  
+> It is an **extension and specialization** built on top of the FeatureCloud engine.
+
+---
+
+## Relationship to FeatureCloud
+
+CVDLink is based on the FeatureCloud platform and reuses:
+
+- FeatureCloud controller and execution engine
+- FeatureCloud app and state model
+- FeatureCloud CLI command structure
+- FeatureCloud testing and workflow system
+
+CVDLink extends FeatureCloud by providing:
+
+- A **CVDLink-specific CLI entry point**
+- **Profile-based configuration** for CVDLink deployments
+- **CVDLink-specific defaults** for:
+  - Controller images
+  - Global API endpoints
+  - Docker registries
+  - Relay servers
+- Seamless switching between FeatureCloud and CVDLink environments using the same codebase
+
+For general FeatureCloud concepts, architecture, and app development, please refer to:
+- https://featurecloud.ai
+- [FeatureCloud GitHub repositor](https://github.com/FeatureCloud/FeatureCloud/tree/cvdlink) 
+- Matschinske, J., Späth, J., Bakhtiari, M., Probul, N., Kazemi Majdabadi, M. M., Nasirigerdeh, R., ... & Baumbach, J. (2023). The FeatureCloud platform for federated learning in biomedicine: unified approach. Journal of Medical Internet Research, 25, e42621.
+
+---
+
+## Installation
+
+Install the CVDLink Python package via pip:
+
+```bash
+pip install cvdlink
+```
+
+
+## CLI Overview
+
+CVDLink provides a **FeatureCloud-compatible command-line interface** with a dedicated entry point:
+
+```bash
+cvdlink --help
+```
+
+The CLI mirrors the FeatureCloud command structure, ensuring that existing FeatureCloud users can work with CVDLink without a learning curve.
+
+Internally, the CLI uses a profile-based configuration, allowing the same codebase to support both FeatureCloud and CVDLink deployments.
+
+### Controller Commands
+
+The controller command group is used to start, manage, and inspect CVDLink controller instances.
+
+##### Start a Controller
+```bash
+cvdlink controller start [NAME] [OPTIONS]
+```
+
+By default, this command:
+
+* Uses CVDLink-specific controller Docker images
+* Connects to CVDLink global API endpoints
+* Uses the CVDLink relay infrastructure
+* Applies CVDLink defaults defined in the configuration profile
+
+#### Common Options
+
+* --port: Port number for the controller (default: 8000)
+* --data-dir: Directory used to store controller data
+* --controller-image: Override the controller Docker image
+* --global-endpoint: Override the global API endpoint
+* --registry: Override the Docker registry
+* --relay-address: Override the relay server address
+* --poll-interval: Override workflow poll interval
+* --query-interval: Override workflow query interval
+* --config-file: Path to a custom configuration file inside the container
+
+Example:
+```bash
+cvdlink controller start --data-dir ./data
+```
+
+
+Other Controller Commands
+
+* cvdlink controller status – Display controller status
+* cvdlink controller logs – Show controller logs
+* cvdlink controller tail – Follow controller logs
+* cvdlink controller ls – List running controllers
+* cvdlink controller stop – Stop a controller instance
+
+#### App Commands
+
+The app command group is used to create, build, manage, and publish federated apps.
+
+##### Create a New App
+```bash
+cvdlink app new --template-name <TEMPLATE_URL>
+```
+
+Creates a new federated app based on a FeatureCloud-compatible template.
+
+Build an App Image
+```bash
+cvdlink app build --path <APP_PATH> --image-name <NAME> --tag <TAG>
+```
+
+Publish an App
+```bash
+cvdlink app publish --name <NAME> --tag <TAG>
+```
+
+Pushes the app image to the configured Docker registry. The image name should include fc.cvdlink-project.eu/ as the registry prefix which by default, this uses the CVDLink registry, unless overridden.
+
+Additional App Commands:
+
+* download – Download an app image
+* remove – Remove a local app image
+* plot-states – Visualize app states and transitions
+* All app commands follow the same semantics as FeatureCloud but operate within the CVDLink ecosystem by default.

cvdlink-0.1.1.dist-info/RECORD

@@ -0,0 +1,45 @@
+FeatureCloud/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+FeatureCloud/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+FeatureCloud/api/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+FeatureCloud/api/cli/__main__.py,sha256=MCVGVzgBzOZXq_6P0llQYV2UUX5ciLvwsIlAL2XpEpU,3641
+FeatureCloud/api/cli/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+FeatureCloud/api/cli/app/commands.py,sha256=wXInRwylUVmoa4zw7Vge96zP3EAL8FZhsMW_akd6pAE,6804
+FeatureCloud/api/cli/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+FeatureCloud/api/cli/controller/commands.py,sha256=GEgQwXdhx7TBbl_CLcU59AGHWDbJz68vCNgnvVPEnKg,6288
+FeatureCloud/api/cli/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+FeatureCloud/api/cli/test/commands.py,sha256=M7oPMG8CuTRu-UJBwpyRIeglhXy7Vj-xGcFwQ-jkZo4,13126
+FeatureCloud/api/cli/test/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+FeatureCloud/api/cli/test/workflow/commands.py,sha256=MKi8m6W_EYODWk4mSdPxIpVxu8OUUMBvcxGCLhHk3NA,1249
+FeatureCloud/api/imp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+FeatureCloud/api/imp/exceptions.py,sha256=vauYTlbJEVkjfHnsFZXNx2EmITiEsnfiDj0cVvOq1ks,762
+FeatureCloud/api/imp/util.py,sha256=fF6OoCHPot0gS_fUmBjPMvvxnUJFPurdUbkDBcr-8QA,1128
+FeatureCloud/api/imp/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+FeatureCloud/api/imp/app/commands.py,sha256=7NlKqIVdPAzivt9j8MoZeP-zOWpHPxhhnL5zoO21X28,8648
+FeatureCloud/api/imp/controller/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+FeatureCloud/api/imp/controller/commands.py,sha256=bmaguJrrr26SYI7iHnnm9NY1P8vPprP3yomt1MZq4J0,7550
+FeatureCloud/api/imp/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+FeatureCloud/api/imp/test/commands.py,sha256=YuTWmHFV0ys2Goq-8lmloSDFXouj33TPjEqBZafNRmk,4444
+FeatureCloud/api/imp/test/helper.py,sha256=_7ZsFOxLuxotWZ3dUFifsUURbbMXrVrOH-3El-5Lz4E,1227
+FeatureCloud/api/imp/test/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+FeatureCloud/api/imp/test/api/controller.py,sha256=LzJzZgaEOhQdkY4aNewModjMuuaWLQvfU73-_u91n7M,2999
+FeatureCloud/api/imp/test/api/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+FeatureCloud/api/imp/test/api/backend/auth.py,sha256=7Ds4tXQWo-GIkSqoK0qfLv-rtbdwYn8-KO4TUdd3O6g,1521
+FeatureCloud/api/imp/test/api/backend/project.py,sha256=QPURzxXmCMfMVZNpBbsagXAErc-MHeA3snvjh7aclQw,2128
+FeatureCloud/app/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+FeatureCloud/app/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+FeatureCloud/app/api/http_ctrl.py,sha256=g0P0Vv3ltLj9ngzty7ZMIgmABTPtFmEWKxJgGaeKnJM,1380
+FeatureCloud/app/api/http_web.py,sha256=TOgcB8UiW1sJ2feudckzaaHcdFSQvHVWKF7K8ND-FJE,499
+FeatureCloud/app/engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+FeatureCloud/app/engine/app.py,sha256=kk0XY5WdsSD9KCTXS8kEcCF1HPH92HW77JGIvbL3eQM,48989
+FeatureCloud/app/engine/library.py,sha256=WGrgHakcsfUIwQnd5_F7BgzpHM8EDXdsSeXytNLGUmE,1064
+FeatureCloud/workflow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+FeatureCloud/workflow/app.py,sha256=SSD82zX_qqQE0wr9gGsPR4Bn6kEwq6O7AI4ocT4yVLM,7707
+FeatureCloud/workflow/controller.py,sha256=MUNotYuiTuAfQUHfgE5jnVeQ2YuSD0Od4yfFhiHdWA0,922
+FeatureCloud/workflow/example_wf.py,sha256=saJ5R8K-APbityQk1ykFyTZgC8ijuT-jJdjumFBFMlc,3327
+FeatureCloud/workflow/workflow.py,sha256=xYSQeG-76f08WCZGAKN1Cl_SgtaBOS2XoE6tpjGrR8w,2526
+cvdlink-0.1.1.dist-info/licenses/LICENSE,sha256=BgX6XyNxc1g4sAz8y9To3QBry89ZYTObngyahwMcpxw,11352
+cvdlink-0.1.1.dist-info/METADATA,sha256=Ae_o3bjHdhIOrHm_L0lKEnTVssgQRTcK8k43cLa-OfY,5798
+cvdlink-0.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+cvdlink-0.1.1.dist-info/entry_points.txt,sha256=uew2Fofb9y5uNNWFMsNIwmuLVTHROTigmH0bC_V80o8,226
+cvdlink-0.1.1.dist-info/top_level.txt,sha256=80W3BaTCpbvGi9n3eeAJIE8iGOPAdSns2ZGA7-OhaJs,13
+cvdlink-0.1.1.dist-info/RECORD,,

cvdlink-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cvdlink-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+CVDLink = FeatureCloud.api.cli.__main__:cvdlink_cli
+FeatureCloud = FeatureCloud.api.cli.__main__:fc_cli
+cvdlink = FeatureCloud.api.cli.__main__:cvdlink_cli
+featurecloud = FeatureCloud.api.cli.__main__:fc_cli