conan 2.16.1__tar.gz → 2.17.0__tar.gz

{conan-2.16.1/conan.egg-info → conan-2.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: conan
-Version: 2.16.1
+Version: 2.17.0
 Summary: Conan C/C++ package manager
 Home-page: https://conan.io
 Author: JFrog LTD

{conan-2.16.1 → conan-2.17.0}/conan/__init__.py

@@ -2,5 +2,5 @@ from conan.internal.model.conan_file import ConanFile
 from conan.internal.model.workspace import Workspace
 from conan.internal.model.version import Version
 
-__version__ = '2.16.1'
+__version__ = '2.17.0'
 conan_version = Version(__version__)

{conan-2.16.1 → conan-2.17.0}/conan/api/conan_api.py

@@ -22,7 +22,7 @@ from conan.api.subapi.search import SearchAPI
 from conan.api.subapi.upload import UploadAPI
 from conan.errors import ConanException
 from conan.internal.paths import get_conan_user_home
-from conans.client.migrations import ClientMigrator
+from conan.internal.api.migrations import ClientMigrator
 from conan.internal.model.version_range import validate_conan_version
 
 
@@ -45,8 +45,7 @@ class ConanAPI:
             raise ConanException("cache_folder has to be an absolute path")
 
         init_colorama(sys.stderr)
-        self.workspace = WorkspaceAPI(self)
-        self.cache_folder = self.workspace.home_folder() or cache_folder or get_conan_user_home()
+        self.cache_folder = cache_folder or get_conan_user_home()
         self.home_folder = self.cache_folder  # Lets call it home, deprecate "cache"
         self.migrate()
 
@@ -71,6 +70,8 @@ class ConanAPI:
         self.lockfile = LockfileAPI(self)
         self.local = LocalAPI(self)
         self.audit = AuditAPI(self)
+        # Now, lazy loading of editables
+        self.workspace = WorkspaceAPI(self)
 
         _check_conan_version(self)
 

{conan-2.16.1 → conan-2.17.0}/conan/api/model/list.py

@@ -4,13 +4,12 @@ import os
 from json import JSONDecodeError
 
 from conan.api.model import RecipeReference, PkgReference
-from conan.cli import make_abs_path
 from conan.errors import ConanException
 from conan.internal.errors import NotFoundException
 from conan.internal.model.version_range import VersionRange
-from conans.client.graph.graph import RECIPE_EDITABLE, RECIPE_CONSUMER, RECIPE_PLATFORM, \
+from conan.internal.graph.graph import RECIPE_EDITABLE, RECIPE_CONSUMER, RECIPE_PLATFORM, \
     RECIPE_VIRTUAL, BINARY_SKIP, BINARY_MISSING, BINARY_INVALID
-from conans.util.files import load
+from conan.internal.util.files import load
 
 
 class MultiPackagesList:
@@ -95,6 +94,10 @@ class MultiPackagesList:
             return mpkglist
         except JSONDecodeError as e:
             raise ConanException(f"Graph file invalid JSON: {graphfile}\n{e}")
+        except KeyError as e:
+            raise ConanException(f'Graph file {graphfile} is missing the required "{e}" key in its contents.\n'
+                                 "Note that the graph file should not be filtered "
+                                 "if you expect to use it with the list command.")
         except ConanException as e:
             raise e
         except Exception as e:

{conan-2.16.1 → conan-2.17.0}/conan/api/model/refs.py

@@ -5,7 +5,7 @@ from functools import total_ordering
 
 from conan.errors import ConanException
 from conan.internal.model.version import Version
-from conans.util.dates import timestamp_to_str
+from conan.internal.util.dates import timestamp_to_str
 
 
 @total_ordering

{conan-2.16.1 → conan-2.17.0}/conan/api/subapi/audit.py

@@ -7,7 +7,7 @@ from conan.internal.api.audit.providers import ConanCenterProvider, PrivateProvi
 from conan.errors import ConanException
 from conan.internal.api.remotes.encrypt import encode, decode
 from conan.internal.model.recipe_ref import RecipeReference
-from conans.util.files import save, load
+from conan.internal.util.files import save, load
 
 CONAN_CENTER_AUDIT_PROVIDER_NAME = "conancenter"
 CYPHER_KEY = "private"

{conan-2.16.1 → conan-2.17.0}/conan/api/subapi/cache.py

@@ -2,19 +2,22 @@ import json
 import os
 import shutil
 import tarfile
-from io import BytesIO
+import tempfile
 
 from conan.api.model import PackagesList
 from conan.api.output import ConanOutput
+from conan.internal.api.uploader import compress_files
 from conan.internal.cache.cache import PkgCache
+from conan.internal.cache.conan_reference_layout import EXPORT_SRC_FOLDER, EXPORT_FOLDER, SRC_FOLDER, \
+    METADATA, DOWNLOAD_EXPORT_FOLDER
 from conan.internal.cache.home_paths import HomePaths
 from conan.internal.cache.integrity_check import IntegrityChecker
-from conans.client.downloaders.download_cache import DownloadCache
+from conan.internal.rest.download_cache import DownloadCache
 from conan.errors import ConanException
 from conan.api.model import PkgReference
 from conan.api.model import RecipeReference
-from conans.util.dates import revision_timestamp_now
-from conans.util.files import rmdir, gzopen_without_timestamps, mkdir, remove
+from conan.internal.util.dates import revision_timestamp_now
+from conan.internal.util.files import rmdir, mkdir, remove, save
 
 
 class CacheAPI:
@@ -92,6 +95,7 @@ class CacheAPI:
             # Clean those build folders that didn't succeed to create a package and wont be in DB
             builds_folder = cache.builds_folder
             if os.path.isdir(builds_folder):
+                ConanOutput().verbose(f"Cleaning temporary folders")
                 for subdir in os.listdir(builds_folder):
                     folder = os.path.join(builds_folder, subdir)
                     manifest = os.path.join(folder, "p", "conanmanifest.txt")
@@ -100,16 +104,19 @@ class CacheAPI:
                         rmdir(folder)
         if backup_sources:
             backup_files = self.conan_api.cache.get_backup_sources(package_list, exclude=False, only_upload=False)
+            ConanOutput().verbose(f"Cleaning {len(backup_files)} backup sources")
             for f in backup_files:
                 remove(f)
 
         for ref, ref_bundle in package_list.refs().items():
+            ConanOutput(ref.repr_notime()).verbose("Cleaning recipe cache contents")
             ref_layout = cache.recipe_layout(ref)
             if source:
                 rmdir(ref_layout.source())
             if download:
                 rmdir(ref_layout.download_export())
             for pref, _ in package_list.prefs(ref, ref_bundle).items():
+                ConanOutput(pref).verbose("Cleaning package cache contents")
                 pref_layout = cache.pkg_layout(pref)
                 if build:
                     rmdir(pref_layout.build())
@@ -118,45 +125,55 @@ class CacheAPI:
                 if download:
                     rmdir(pref_layout.download_package())
 
-    def save(self, package_list, tgz_path):
+    def save(self, package_list, tgz_path, no_source=False):
         global_conf = self.conan_api.config.global_conf
         cache = PkgCache(self.conan_api.cache_folder, global_conf)
         cache_folder = cache.store  # Note, this is not the home, but the actual package cache
         out = ConanOutput()
         mkdir(os.path.dirname(tgz_path))
-        name = os.path.basename(tgz_path)
         compresslevel = global_conf.get("core.gzip:compresslevel", check_type=int)
-        with open(tgz_path, "wb") as tgz_handle:
-            tgz = gzopen_without_timestamps(name, mode="w", fileobj=tgz_handle,
-                                            compresslevel=compresslevel)
-            for ref, ref_bundle in package_list.refs().items():
-                ref_layout = cache.recipe_layout(ref)
-                recipe_folder = os.path.relpath(ref_layout.base_folder, cache_folder)
-                recipe_folder = recipe_folder.replace("\\", "/")  # make win paths portable
-                ref_bundle["recipe_folder"] = recipe_folder
-                out.info(f"Saving {ref}: {recipe_folder}")
-                tgz.add(os.path.join(cache_folder, recipe_folder), recipe_folder, recursive=True)
-                for pref, pref_bundle in package_list.prefs(ref, ref_bundle).items():
-                    pref_layout = cache.pkg_layout(pref)
-                    pkg_folder = pref_layout.package()
-                    folder = os.path.relpath(pkg_folder, cache_folder)
-                    folder = folder.replace("\\", "/")  # make win paths portable
-                    pref_bundle["package_folder"] = folder
-                    out.info(f"Saving {pref}: {folder}")
-                    tgz.add(os.path.join(cache_folder, folder), folder, recursive=True)
-                    if os.path.exists(pref_layout.metadata()):
-                        metadata_folder = os.path.relpath(pref_layout.metadata(), cache_folder)
-                        metadata_folder = metadata_folder.replace("\\", "/")  # make paths portable
-                        pref_bundle["metadata_folder"] = metadata_folder
-                        out.info(f"Saving {pref} metadata: {metadata_folder}")
-                        tgz.add(os.path.join(cache_folder, metadata_folder), metadata_folder,
-                                recursive=True)
-            serialized = json.dumps(package_list.serialize(), indent=2)
-            info = tarfile.TarInfo(name="pkglist.json")
-            data = serialized.encode('utf-8')
-            info.size = len(data)
-            tgz.addfile(tarinfo=info, fileobj=BytesIO(data))
-            tgz.close()
+        tar_files: dict[str,str] = {} # {path_in_tar: abs_path}
+
+        for ref, ref_bundle in package_list.refs().items():
+            ref_layout = cache.recipe_layout(ref)
+            recipe_folder = os.path.relpath(ref_layout.base_folder, cache_folder)
+            recipe_folder = recipe_folder.replace("\\", "/")  # make win paths portable
+            ref_bundle["recipe_folder"] = recipe_folder
+            out.info(f"Saving {ref}: {recipe_folder}")
+            # Package only selected folders, not DOWNLOAD one
+            for f in (EXPORT_FOLDER, EXPORT_SRC_FOLDER, SRC_FOLDER):
+                if f == SRC_FOLDER and no_source:
+                    continue
+                path = os.path.join(cache_folder, recipe_folder, f)
+                if os.path.exists(path):
+                    tar_files[f"{recipe_folder}/{f}"] = path
+            path = os.path.join(cache_folder, recipe_folder, DOWNLOAD_EXPORT_FOLDER, METADATA)
+            if os.path.exists(path):
+                tar_files[f"{recipe_folder}/{DOWNLOAD_EXPORT_FOLDER}/{METADATA}"] = path
+
+            for pref, pref_bundle in package_list.prefs(ref, ref_bundle).items():
+                pref_layout = cache.pkg_layout(pref)
+                pkg_folder = pref_layout.package()
+                folder = os.path.relpath(pkg_folder, cache_folder)
+                folder = folder.replace("\\", "/")  # make win paths portable
+                pref_bundle["package_folder"] = folder
+                out.info(f"Saving {pref}: {folder}")
+                tar_files[folder] = os.path.join(cache_folder, folder)
+
+                if os.path.exists(pref_layout.metadata()):
+                    metadata_folder = os.path.relpath(pref_layout.metadata(), cache_folder)
+                    metadata_folder = metadata_folder.replace("\\", "/")  # make paths portable
+                    pref_bundle["metadata_folder"] = metadata_folder
+                    out.info(f"Saving {pref} metadata: {metadata_folder}")
+                    tar_files[metadata_folder] = os.path.join(cache_folder, metadata_folder)
+
+        # Create a temporary file in order to reuse compress_files functionality
+        serialized = json.dumps(package_list.serialize(), indent=2)
+        pkglist_path = os.path.join(tempfile.gettempdir(), "pkglist.json")
+        save(pkglist_path, serialized)
+        tar_files["pkglist.json"] = pkglist_path
+        compress_files(tar_files, os.path.basename(tgz_path), os.path.dirname(tgz_path), compresslevel, recursive=True)
+        remove(pkglist_path)
 
     def restore(self, path):
         if not os.path.isfile(path):

{conan-2.16.1 → conan-2.17.0}/conan/api/subapi/config.py

@@ -12,16 +12,16 @@ from conan.internal.api.detect import detect_api
 from conan.internal.cache.home_paths import HomePaths
 from conan.internal.conan_app import ConanApp
 from conan.internal.default_settings import default_settings_yml
-from conans.client.graph.graph import CONTEXT_HOST, RECIPE_VIRTUAL, Node
-from conans.client.graph.graph_builder import DepsGraphBuilder
-from conans.client.graph.profile_node_definer import consumer_definer
+from conan.internal.graph.graph import CONTEXT_HOST, RECIPE_VIRTUAL, Node
+from conan.internal.graph.graph_builder import DepsGraphBuilder
+from conan.internal.graph.profile_node_definer import consumer_definer
 from conan.errors import ConanException
 from conan.internal.model.conf import ConfDefinition, BUILT_IN_CONFS, CORE_CONF_PATTERN
 from conan.internal.model.pkg_type import PackageType
 from conan.api.model import RecipeReference
 from conan.internal.model.settings import Settings
-from conans.client.hook_manager import HookManager
-from conans.util.files import load, save, rmdir, remove
+from conan.internal.hook_manager import HookManager
+from conan.internal.util.files import load, save, rmdir, remove
 
 
 class ConfigAPI:

{conan-2.16.1 → conan-2.17.0}/conan/api/subapi/export.py

@@ -3,9 +3,9 @@ from conan.internal.cache.cache import PkgCache
 from conan.internal.conan_app import ConanApp
 from conan.internal.api.export import cmd_export
 from conan.internal.methods import run_package_method
-from conans.client.graph.graph import BINARY_BUILD, RECIPE_INCACHE
+from conan.internal.graph.graph import BINARY_BUILD, RECIPE_INCACHE
 from conan.api.model import PkgReference
-from conans.util.files import mkdir
+from conan.internal.util.files import mkdir
 
 
 class ExportAPI:

{conan-2.16.1 → conan-2.17.0}/conan/api/subapi/graph.py

@@ -1,12 +1,12 @@
 from conan.api.output import ConanOutput
 from conan.internal.conan_app import ConanApp, ConanBasicApp
 from conan.internal.model.recipe_ref import ref_matches
-from conans.client.graph.graph import Node, RECIPE_CONSUMER, CONTEXT_HOST, RECIPE_VIRTUAL, \
-    CONTEXT_BUILD, BINARY_MISSING
-from conans.client.graph.graph_binaries import GraphBinariesAnalyzer
-from conans.client.graph.graph_builder import DepsGraphBuilder
-from conans.client.graph.install_graph import InstallGraph, ProfileArgs
-from conans.client.graph.profile_node_definer import initialize_conanfile_profile, consumer_definer
+from conan.internal.graph.graph import Node, RECIPE_CONSUMER, CONTEXT_HOST, RECIPE_VIRTUAL, \
+    CONTEXT_BUILD, BINARY_MISSING, DepsGraph
+from conan.internal.graph.graph_binaries import GraphBinariesAnalyzer
+from conan.internal.graph.graph_builder import DepsGraphBuilder
+from conan.internal.graph.install_graph import InstallGraph, ProfileArgs
+from conan.internal.graph.profile_node_definer import initialize_conanfile_profile, consumer_definer
 from conan.errors import ConanException
 from conan.api.model import RecipeReference
 
@@ -129,6 +129,12 @@ class GraphAPI:
                                                       update=update,
                                                       python_requires=python_requires)
 
+        if not requires and not tool_requires and python_requires is not None:
+            # This only happens at `conan create` for python-requires, the graph is not needed
+            # in fact, it can cause errors, if tool-requires injected
+            dep_graph = DepsGraph()
+            dep_graph.add_node(root_node)
+            return dep_graph
         # check_updates = args.check_updates if "check_updates" in args else False
         deps_graph = self.load_graph(root_node, profile_host=profile_host,
                                      profile_build=profile_build,

{conan-2.16.1 → conan-2.17.0}/conan/api/subapi/install.py

@@ -4,8 +4,8 @@ from conan.internal.api.install.generators import write_generators
 from conan.internal.conan_app import ConanBasicApp
 from conan.internal.deploy import do_deploys
 
-from conans.client.graph.install_graph import InstallGraph
-from conans.client.installer import BinaryInstaller
+from conan.internal.graph.install_graph import InstallGraph
+from conan.internal.graph.installer import BinaryInstaller
 from conan.errors import ConanInvalidConfiguration
 
 

{conan-2.16.1 → conan-2.17.0}/conan/api/subapi/list.py

@@ -14,8 +14,34 @@ from conan.errors import ConanException
 from conan.internal.model.info import load_binary_info
 from conan.api.model import PkgReference
 from conan.api.model import RecipeReference
-from conans.util.dates import timelimit
-from conans.util.files import load
+from conan.internal.util.dates import timestamp_now
+from conan.internal.util.files import load
+
+
+def _timelimit(expression):
+    """ convert an expression like "2d" (2 days) or "3h" (3 hours) to a timestamp in the past
+    with respect to current time
+    """
+    time_value = expression[:-1]
+    try:
+        time_value = int(time_value)
+    except TypeError:
+        raise ConanException(f"Time value '{time_value}' must be an integer")
+    time_units = expression[-1]
+    units = {"y": 365 * 24 * 60 * 60,
+             "M": 30 * 24 * 60 * 60,
+             "w": 7 * 24 * 60 * 60,
+             "d": 24 * 60 * 60,
+             "h": 60 * 60,
+             "m": 60,
+             "s": 1}
+    try:
+        lru_value = time_value * units[time_units]
+    except KeyError:
+        raise ConanException(f"Unrecognized time unit: '{time_units}'. Use: {list(units)}")
+
+    limit = timestamp_now() - lru_value
+    return limit
 
 
 class ListAPI:
@@ -145,7 +171,7 @@ class ListAPI:
         # Avoid doing a ``search`` of recipes if it is an exact ref and it will be used later
         search_ref = pattern.search_ref
         app = ConanBasicApp(self.conan_api)
-        limit_time = timelimit(lru) if lru else None
+        limit_time = _timelimit(lru) if lru else None
         out = ConanOutput()
         remote_name = "local cache" if not remote else remote.name
         if search_ref:

{conan-2.16.1 → conan-2.17.0}/conan/api/subapi/local.py

@@ -4,12 +4,12 @@ from conan.cli import make_abs_path
 from conan.internal.conan_app import ConanApp
 from conan.internal.api.local.editable import EditablePackages
 from conan.internal.methods import run_build_method, run_source_method
-from conans.client.graph.graph import CONTEXT_HOST
-from conans.client.graph.profile_node_definer import initialize_conanfile_profile
+from conan.internal.graph.graph import CONTEXT_HOST
+from conan.internal.graph.profile_node_definer import initialize_conanfile_profile
 from conan.internal.errors import conanfile_exception_formatter
 from conan.errors import ConanException
 from conan.api.model import RecipeReference
-from conans.util.files import chdir
+from conan.internal.util.files import chdir
 
 
 class LocalAPI:

{conan-2.16.1 → conan-2.17.0}/conan/api/subapi/lockfile.py

@@ -2,7 +2,7 @@ import os
 
 from conan.api.output import ConanOutput
 from conan.cli import make_abs_path
-from conans.client.graph.graph import Overrides
+from conan.internal.graph.graph import Overrides
 from conan.errors import ConanException
 from conan.internal.model.lockfile import Lockfile, LOCKFILE
 

{conan-2.16.1 → conan-2.17.0}/conan/api/subapi/new.py

@@ -6,7 +6,7 @@ from jinja2 import Template, StrictUndefined, UndefinedError, Environment, meta
 
 from conan.api.output import ConanOutput
 from conan.errors import ConanException
-from conans.util.files import load, save
+from conan.internal.util.files import load, save
 from conan import __version__
 
 
@@ -85,6 +85,7 @@ class NewAPI:
         from conan.internal.api.new.alias_new import alias_file
         from conan.internal.api.new.cmake_exe import cmake_exe_files
         from conan.internal.api.new.cmake_lib import cmake_lib_files
+        from conan.internal.api.new.header_lib import header_only_lib_files
         from conan.internal.api.new.meson_lib import meson_lib_files
         from conan.internal.api.new.meson_exe import meson_exe_files
         from conan.internal.api.new.msbuild_lib import msbuild_lib_files
@@ -101,6 +102,7 @@ class NewAPI:
         new_templates = {"basic": basic_file,
                          "cmake_lib": cmake_lib_files,
                          "cmake_exe": cmake_exe_files,
+                         "header_lib": header_only_lib_files,
                          "meson_lib": meson_lib_files,
                          "meson_exe": meson_exe_files,
                          "msbuild_lib": msbuild_lib_files,

{conan-2.16.1 → conan-2.17.0}/conan/api/subapi/profiles.py

@@ -3,7 +3,7 @@ import os
 from conan.api.output import ConanOutput
 from conan.internal.cache.home_paths import HomePaths
 
-from conans.client.loader import load_python_file
+from conan.internal.loader import load_python_file
 from conan.internal.api.profile.profile_loader import ProfileLoader
 from conan.internal.errors import scoped_traceback
 from conan.errors import ConanException

{conan-2.16.1 → conan-2.17.0}/conan/api/subapi/remotes.py

@@ -8,13 +8,13 @@ from conan.api.model import Remote, LOCAL_RECIPES_INDEX
 from conan.api.output import ConanOutput
 from conan.internal.cache.home_paths import HomePaths
 from conan.internal.conan_app import ConanBasicApp
-from conans.client.rest.conan_requester import ConanRequester
-from conans.client.rest.remote_credentials import RemoteCredentials
-from conans.client.rest_client_local_recipe_index import add_local_recipes_index_remote, \
+from conan.internal.rest.conan_requester import ConanRequester
+from conan.internal.rest.remote_credentials import RemoteCredentials
+from conan.internal.rest.rest_client_local_recipe_index import add_local_recipes_index_remote, \
     remove_local_recipes_index_remote
 from conan.internal.api.remotes.localdb import LocalDB
 from conan.errors import ConanException
-from conans.util.files import save, load
+from conan.internal.util.files import save, load
 
 CONAN_CENTER_REMOTE_NAME = "conancenter"
 

{conan-2.16.1 → conan-2.17.0}/conan/api/subapi/upload.py

@@ -3,11 +3,12 @@ import time
 from multiprocessing.pool import ThreadPool
 
 from conan.api.output import ConanOutput
+from conan.internal.api.upload import add_urls
 from conan.internal.conan_app import ConanApp
 from conan.internal.api.uploader import PackagePreparator, UploadExecutor, UploadUpstreamChecker, \
     gather_metadata
-from conans.client.pkg_sign import PkgSignaturesPlugin
-from conans.client.rest.file_uploader import FileUploader
+from conan.internal.rest.pkg_sign import PkgSignaturesPlugin
+from conan.internal.rest.file_uploader import FileUploader
 from conan.internal.errors import AuthenticationException, ForbiddenException
 from conan.errors import ConanException
 
@@ -99,6 +100,7 @@ class UploadAPI:
             thread_pool.join()
         elapsed = time.time() - t
         ConanOutput().success(f"Upload completed in {int(elapsed)}s\n")
+        add_urls(package_list, remote)
 
     def upload_backup_sources(self, files):
         config = self.conan_api.config.global_conf

{conan-2.16.1 → conan-2.17.0}/conan/api/subapi/workspace.py

@@ -1,6 +1,7 @@
 import inspect
 import os
 import shutil
+import textwrap
 from pathlib import Path
 
 from conan import ConanFile
@@ -9,21 +10,24 @@ from conan.api.output import ConanOutput
 from conan.cli import make_abs_path
 from conan.errors import ConanException
 from conan.internal.conan_app import ConanApp
-from conan.internal.model.workspace import Workspace
+from conan.internal.model.workspace import Workspace, WORKSPACE_YML, WORKSPACE_PY, WORKSPACE_FOLDER
 from conan.tools.scm import Git
-from conans.client.graph.graph import RECIPE_EDITABLE, DepsGraph, CONTEXT_HOST, RECIPE_VIRTUAL, Node, \
+from conan.internal.graph.graph import RECIPE_EDITABLE, DepsGraph, CONTEXT_HOST, RECIPE_VIRTUAL, Node, \
     RECIPE_CONSUMER
-from conans.client.graph.graph import TransitiveRequirement
-from conans.client.graph.profile_node_definer import consumer_definer
-from conans.client.loader import load_python_file
-from conans.client.source import retrieve_exports_sources
-from conans.util.files import merge_directories
+from conan.internal.graph.graph import TransitiveRequirement
+from conan.internal.graph.profile_node_definer import consumer_definer
+from conan.internal.loader import load_python_file
+from conan.internal.source import retrieve_exports_sources
+from conan.internal.util.files import merge_directories, save
 
 
 def _find_ws_folder():
     path = Path(os.getcwd())
-    while path.is_dir() and len(path.parts) > 1:  # finish at '/'
-        if (path / "conanws.yml").is_file() or (path / "conanws.py").is_file():
+    while path.is_dir() and len(path.parts) > 1:  # finish at '/' or 'conanws/'
+        if path.name == WORKSPACE_FOLDER:
+            if (path / WORKSPACE_YML).is_file() or (path / WORKSPACE_PY).is_file():
+                return str(path)
+        if (path / WORKSPACE_YML).is_file() or (path / WORKSPACE_PY).is_file():
             return str(path)
         else:
             path = path.parent
@@ -32,10 +36,10 @@ def _find_ws_folder():
 def _load_workspace(ws_folder, conan_api):
     """ loads a conanfile basic object without evaluating anything, returns the module too
     """
-    wspy = os.path.join(ws_folder, "conanws.py")
+    wspy = os.path.join(ws_folder, WORKSPACE_PY)
     if not os.path.isfile(wspy):
-        ConanOutput().info(f"conanws.py doesn't exist in {ws_folder}, using default behavior")
-        assert os.path.exists(os.path.join(ws_folder, "conanws.yml"))
+        ConanOutput().info(f"{WORKSPACE_PY} doesn't exist in {ws_folder}, using default behavior")
+        assert os.path.exists(os.path.join(ws_folder, WORKSPACE_YML))
         ws = Workspace(ws_folder, conan_api)
     else:
         try:
@@ -43,7 +47,7 @@ def _load_workspace(ws_folder, conan_api):
             ws = _parse_module(module, module_id)
             ws = ws(ws_folder, conan_api)
         except ConanException as e:
-            raise ConanException(f"Error loading conanws.py at '{wspy}': {e}")
+            raise ConanException(f"Error loading {WORKSPACE_PY} at '{wspy}': {e}")
     return ws
 
 
@@ -86,17 +90,6 @@ class WorkspaceAPI:
         self._check_ws()
         return self._ws.name()
 
-    def home_folder(self):
-        """
-        @return: The custom defined Conan home/cache folder if defined, else None
-        """
-        if not self._folder:
-            return
-        folder = self._ws.home_folder()
-        if folder is None or os.path.isabs(folder):
-            return folder
-        return os.path.normpath(os.path.join(self._folder, folder))
-
     def folder(self):
         """
         @return: the current workspace folder where the conanws.yml or conanws.py is located
@@ -110,7 +103,7 @@ class WorkspaceAPI:
         """
         if not self._folder:
             return
-        editables = self._ws.editables()
+        editables = self._ws.packages()
         editables = {RecipeReference.loads(r): v.copy() for r, v in editables.items()}
         for v in editables.values():
             path = os.path.normpath(os.path.join(self._folder, v["path"], "conanfile.py"))
@@ -170,8 +163,8 @@ class WorkspaceAPI:
 
     def _check_ws(self):
         if not self._folder:
-            raise ConanException("Workspace not defined, please create a "
-                                 "'conanws.py' or 'conanws.yml' file")
+            raise ConanException(f"Workspace not defined, please create a "
+                                 f"'{WORKSPACE_PY}' or '{WORKSPACE_YML}' file")
 
     def add(self, path, name=None, version=None, user=None, channel=None, cwd=None,
             output_folder=None, remotes=None, product=False):
@@ -201,29 +194,57 @@ class WorkspaceAPI:
         self._ws.add(ref, full_path, output_folder, product)
         return ref
 
+    @staticmethod
+    def init(path):
+        abs_path = make_abs_path(path)
+        os.makedirs(abs_path, exist_ok=True)
+        ws_yml_file = Path(abs_path, WORKSPACE_YML)
+        ws_py_file = Path(abs_path, WORKSPACE_PY)
+        if not ws_yml_file.exists():
+            ConanOutput().success(f"Created empty {WORKSPACE_YML} in {path}")
+            save(ws_yml_file, "")
+        if not ws_py_file.exists():
+            ConanOutput().success(f"Created minimal {WORKSPACE_PY} in {path}")
+            ws_name = os.path.basename(abs_path)
+            save(ws_py_file, textwrap.dedent(f'''\
+            from conan import Workspace
+
+            class MyWorkspace(Workspace):
+               """
+               Minimal Workspace class definition.
+               More info: https://docs.conan.io/2/incubating.html#workspaces
+               """
+               def name(self):
+                  return "{ws_name}"
+            '''))
+
     def remove(self, path):
         self._check_ws()
         return self._ws.remove(path)
 
+    def clean(self):
+        self._check_ws()
+        return self._ws.clean()
+
     def info(self):
         self._check_ws()
         return {"name": self.name,
                 "folder": self._folder,
                 "products": self.products,
-                "editables": self._ws.editables()}
+                "packages": self._ws.packages()}
 
     def editable_from_path(self, path):
-        editables = self._ws.editables()
+        editables = self._ws.packages()
         for ref, info in editables.items():
             if info["path"].replace("\\", "/") == path:
                 return RecipeReference.loads(ref)
 
     def collapse_editables(self, deps_graph, profile_host, profile_build):
-        ConanOutput().title(f"Collapsing workspace editables")
+        ConanOutput().title("Collapsing workspace editables")
 
         root_class = self._ws.root_conanfile()
         if root_class is not None:
-            conanfile = root_class("conanws.py base project Conanfile")
+            conanfile = root_class(f"{WORKSPACE_PY} base project Conanfile")
             consumer_definer(conanfile, profile_host, profile_build)
             root = Node(None, conanfile, context=CONTEXT_HOST, recipe=RECIPE_CONSUMER,
                         path=self._folder)  # path lets use the conanws.py folder
@@ -233,7 +254,7 @@ class WorkspaceAPI:
                 if getattr(conanfile, field, None):
                     raise ConanException(f"Conanfile in conanws.py shouldn't have '{field}'")
         else:
-            ConanOutput().info("Workspace conanfilews.py not found in the workspace folder, "
+            ConanOutput().info(f"Workspace {WORKSPACE_PY} not found in the workspace folder, "
                                "using default behavior")
             conanfile = ConanFile(display_name="cli")
             consumer_definer(conanfile, profile_host, profile_build)