arkitekt-next 0.8.32__tar.gz → 0.8.35__tar.gz

{arkitekt_next-0.8.32 → arkitekt_next-0.8.35}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arkitekt-next
-Version: 0.8.32
+Version: 0.8.35
 Summary: client for the arkitekt_next platform
 License: MIT
 Author: jhnnsrs
@@ -21,21 +21,21 @@ Requires-Dist: blok (>=0.0.19) ; (python_version >= "3.9" and python_version < "
 Requires-Dist: cryptography (>=40.0.8) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "blok")
 Requires-Dist: dokker (>=1.0.0)
 Requires-Dist: fakts-next (>=1.0.2)
-Requires-Dist: fluss-next (>=0.1.90) ; extra == "all"
+Requires-Dist: fluss-next (>=0.1.91) ; extra == "all"
 Requires-Dist: herre-next (>=1.0.2)
-Requires-Dist: kabinet (>=0.1.38) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "all")
+Requires-Dist: kabinet (>=0.1.40) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "all")
 Requires-Dist: koil (>=1.0.0)
-Requires-Dist: kraph (>=0.1.91) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "extended")
-Requires-Dist: lovekit (>=0.1.15) ; (python_version >= "3.10" and python_version < "4.0") and (extra == "all")
-Requires-Dist: mikro-next (>=0.1.47) ; (python_version >= "3.10" and python_version < "4.0") and (extra == "all")
+Requires-Dist: kraph (>=0.1.92) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "extended")
+Requires-Dist: lovekit (>=0.1.16) ; (python_version >= "3.10" and python_version < "4.0") and (extra == "all")
+Requires-Dist: mikro-next (>=0.1.48) ; (python_version >= "3.10" and python_version < "4.0") and (extra == "all")
 Requires-Dist: namegenerator (>=1.0.6) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "blok")
 Requires-Dist: netifaces (>=0.11.0) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "blok")
-Requires-Dist: reaktion-next (>=0.1.80) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "all")
-Requires-Dist: rekuest-next (>=0.2.43) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "cli" or extra == "all")
+Requires-Dist: reaktion-next (>=0.1.81) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "all")
+Requires-Dist: rekuest-next (>=0.2.44) ; (python_version >= "3.8" and python_version < "4.0") and (extra == "cli" or extra == "all")
 Requires-Dist: rich-click (>=1.6.1) ; extra == "cli" or extra == "all"
 Requires-Dist: semver (>=3.0.1) ; extra == "cli" or extra == "all"
-Requires-Dist: turms (>=0.6.0) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "cli" or extra == "all")
-Requires-Dist: unlok-next (>=0.1.83) ; python_version >= "3.8" and python_version < "4.0"
+Requires-Dist: turms (>=0.7.0) ; (python_version >= "3.9" and python_version < "4.0") and (extra == "cli" or extra == "all")
+Requires-Dist: unlok-next (>=0.1.84) ; python_version >= "3.8" and python_version < "4.0"
 Requires-Dist: watchfiles (>=0.18.1) ; extra == "cli" or extra == "all"
 Description-Content-Type: text/markdown
 

{arkitekt_next-0.8.32 → arkitekt_next-0.8.35}/arkitekt_next/base_models.py

@@ -17,48 +17,6 @@ class Requirement(BaseModel):
     """ The description is a human readable description of the requirement. Will be show to the user when asking for the requirement."""
 
 
-def build_default_requirements() -> List[Requirement]:
-    return [
-        Requirement(
-            key="lok",
-            service="live.arkitekt_next.lok",
-            description="An instance of ArkitektNext Lok to authenticate the user",
-        ),
-        Requirement(
-            key="rekuest",
-            service="live.arkitekt_next.rekuest",
-            description="An instance of ArkitektNext Rekuest to assign to nodes",
-        ),
-        Requirement(
-            key="kabinet",
-            service="live.arkitekt_next.kabinet",
-            description="An instance of ArkitektNext Kabinet to retrieve nodes from",
-        ),
-        Requirement(
-            key="mikro",
-            service="live.arkitekt_next.mikro",
-            description="An instance of ArkitektNext Mikro to make requests to the user's data",
-            optional=True,
-        ),
-        Requirement(
-            key="fluss",
-            service="live.arkitekt_next.fluss",
-            description="An instance of ArkitektNext Fluss to make requests to the user's data",
-            optional=False,
-        ),
-        Requirement(
-            key="port",
-            service="live.arkitekt_next.port",
-            description="An instance of ArkitektNext Fluss to make requests to the user's data",
-            optional=True,
-        ),
-        Requirement(
-            key="datalayer",
-            service="live.arkitekt_next.datalayer",
-            description="An instance of ArkitektNext Datalayer to make requests to the user's data",
-            optional=False,
-        ),
-    ]
 
 
 class Manifest(BaseModel):
@@ -85,7 +43,7 @@ class Manifest(BaseModel):
     logo: Optional[str]
     """ A URL to the logo of the app TODO: We should enforce this to be a http URL as local paths won't work """
     requirements: Optional[List[Requirement]] = Field(
-        default_factory=build_default_requirements
+        default_factory=list
     )
     """ Requirements that this app has TODO: What are the requirements? """
 

{arkitekt_next-0.8.32 → arkitekt_next-0.8.35}/arkitekt_next/builders.py

@@ -112,6 +112,7 @@ def easy(
         logo=logo,
         requirements=registry.get_requirements(),
     )
+
     if token:
         fakts_next = build_arkitekt_next_token_fakts_next(
             manifest=manifest,

{arkitekt_next-0.8.32 → arkitekt_next-0.8.35}/arkitekt_next/cli/commands/gen/compile.py

@@ -20,6 +20,14 @@ def compile(projects, config):
     """
     app_directory = os.getcwd()
 
+
+
+
+
+
+
+    
+
     from turms.run import scan_folder_for_single_config, load_projects_from_configpath
     from turms.cli.main import generate_projects
 

arkitekt_next-0.8.35/arkitekt_next/cli/commands/gen/init.py

@@ -0,0 +1,117 @@
+import os
+import shutil
+from click import ClickException
+import rich_click as click
+from arkitekt_next.cli.options import (
+    with_documents,
+    with_graphql_config,
+    with_api_path,
+    with_boring,
+    with_choose_services,
+    with_schemas,
+    with_seperate_document_dirs,
+)
+import yaml
+from arkitekt_next.cli.utils import build_relative_dir
+from arkitekt_next.cli.vars import get_console, get_manifest
+from arkitekt_next.service_registry import check_and_import_services
+
+
+@click.command()
+@with_seperate_document_dirs
+@with_boring
+@with_choose_services
+@with_graphql_config
+@with_api_path
+@with_schemas
+@with_graphql_config
+@with_documents
+@click.pass_context
+def init(ctx, boring, services, config, documents, schemas, path, seperate_doc_dirs):
+    """Initialize code generation for the arkitekt_next app
+
+    Code generation for API's is done with the help of GraphQL Code Generation
+    that is powered by turms. This command initializes the code generation for
+    the app. It creates the necessary folders and files for the code generation
+    to work. It also creates a graphql config file that is used by turms to
+    generate the code.
+
+    """
+    app_directory = os.getcwd()
+
+    app_api_path = os.path.join(app_directory, path)
+    app_documents = os.path.join(app_directory, "documents")
+
+    app_schemas = os.path.join(app_directory, "schemas")
+
+    os.makedirs(app_documents, exist_ok=True)
+    os.makedirs(app_schemas, exist_ok=True)
+    os.makedirs(app_api_path, exist_ok=True)
+
+    # Initializing the config
+    projects = {}
+
+
+    registry = check_and_import_services()
+
+    base_config = yaml.load(
+        open(build_relative_dir("configs", "base.yaml"), "r"), Loader=yaml.FullLoader
+    )
+
+    for key, service in registry.service_builders.items():
+        try:
+
+            schema, project = service.get_graphql_schema(), service.get_turms_project()
+
+            if not schema or not project:
+                get_console(ctx).print(f"[red]No schema or project found for {key} [/]")
+                continue
+
+            if documents:
+                os.makedirs(os.path.join(app_documents, key), exist_ok=True)
+                if seperate_doc_dirs:
+                    os.makedirs(
+                        os.path.join(app_documents, key, "queries"), exist_ok=True
+                    )
+                    os.makedirs(
+                        os.path.join(app_documents, key, "mutations"), exist_ok=True
+                    )
+                    os.makedirs(
+                        os.path.join(app_documents, key, "subscriptions"), exist_ok=True
+                    )
+
+            if schemas:
+                out_path = os.path.join(app_schemas, key + ".schema.graphql")
+                with open(out_path, "w") as f:
+                    f.write(schema)
+                    
+
+
+            if schemas:
+                project["schema"] = os.path.join(app_schemas, key + ".schema.graphql")
+            if documents:
+                project["documents"] = (
+                    os.path.join(app_documents, key) + "/**/*.graphql"
+                )
+
+            project["extensions"]["turms"]["out_dir"] = path
+            project["extensions"]["turms"]["generated_name"] = f"{key}.py"
+            del project["extensions"]["turms"]["documents"] 
+
+            projects[key] = project
+
+        except Exception as e:
+            raise ClickException(f"Failed to initialize project for {key}. Error: {e}") from e
+
+    if os.path.exists(config):
+        if not click.confirm(
+            f"GraphQL Config file already exists. Do you want to overwrite?"
+        ):
+            click.echo("Aborting...")
+            ctx.abort()
+
+    graph_config_path = os.path.join(app_directory, config)
+    yaml.safe_dump(
+        {"projects": projects}, open(graph_config_path, "w"), sort_keys=False
+    )
+    get_console(ctx).print(f"Config file written to {graph_config_path}")

arkitekt_next-0.8.35/arkitekt_next/service_registry.py

@@ -0,0 +1,203 @@
+from pydantic import BaseModel, Field
+from herre_next import Herre
+from fakts_next import Fakts
+from .base_models import Manifest, Requirement
+from typing import Callable, Dict, Protocol
+import importlib
+import sys
+import os
+import traceback
+import logging
+import pkgutil
+from typing import runtime_checkable
+
+Params = Dict[str, str]
+
+
+
+
+
+
+class Registration(BaseModel):
+    name: str
+    requirement: Requirement
+    builder: Callable[[Herre, Fakts, Params], object]
+    schema_loader: Callable[[str], object]
+
+
+@runtime_checkable
+class ArkitektService(Protocol):
+
+
+    def get_service_name(self):
+        pass
+
+
+    def build_service(self, fakts: Fakts, herre: Herre, params: Params, manifest: Manifest):
+        pass
+
+
+    def get_requirements(self):
+        pass
+
+
+    def get_graphql_schema(self):
+        pass
+
+    def get_turms_project(self):
+        pass
+
+
+
+class BaseArkitektService:
+
+
+    def get_service_name(self):
+        raise NotImplementedError("get_service_name not implemented")
+    
+    def build_service(self, fakts: Fakts, herre: Herre, params: Params, manifest: Manifest):
+        raise NotImplementedError("build_service not implemented")
+    
+    def get_requirements(self):
+        raise NotImplementedError("get_requirements not implemented")
+    
+    def get_graphql_schema(self):
+        return None
+    
+    def get_turms_project(self):
+        return None
+    
+
+
+basic_requirements =  [Requirement(
+        key="lok",
+        service="live.arkitekt.lok",
+        description="An instance of ArkitektNext Lok to authenticate the user",
+    )]
+
+
+class ServiceBuilderRegistry:
+    def __init__(self):
+        self.service_builders: Dict[str, ArkitektService] = {}
+
+    def register(
+        self,
+        service: ArkitektService,
+    ):
+        
+        name = service.get_service_name()
+
+        if name not in self.service_builders:
+            self.service_builders[name] = service
+        else:
+            raise ValueError(f"Service {name} already registered")
+        
+
+    def get(self, name):
+        return self.services.get(name)
+
+    def build_service_map(
+        self, fakts: Fakts, herre: Herre, params: Params, manifest: Manifest
+    ):
+        potentially_needed_services = {
+            name: service.build_service(fakts, herre, params, manifest)
+            for name, service in self.service_builders.items() 
+        }
+
+
+
+        return {key: value for key, value in potentially_needed_services.items() if value is not None}
+
+
+
+    def get_requirements(self):
+
+        requirements = [Requirement(
+        key="lok",
+        service="live.arkitekt.lok",
+        description="An instance of ArkitektNext Lok to authenticate the user",
+    )]   
+        taken_requirements = set()
+
+
+        for service in self.service_builders.values():
+            for requirement in service.get_requirements():
+                if requirement.key not in taken_requirements:
+                    taken_requirements.add(requirement.key)
+                    requirements.append(requirement)
+
+
+
+        
+
+        sorted_requirements = sorted(requirements, key=lambda x: x.key)
+
+        return sorted_requirements
+
+
+class SetupInfo:
+    services: Dict[str, object]
+
+
+import os
+import importlib.util
+import pkgutil
+import traceback
+import logging
+
+def check_and_import_services() -> ServiceBuilderRegistry:
+    service_builder_registry = ServiceBuilderRegistry()
+    processed_modules = set()  # Track modules that have already been processed
+
+    # Function to load and call init_extensions from __rekuest__.py
+    def load_and_call_init_extensions(module_name, rekuest_path):
+        if module_name in processed_modules:
+            return  # Skip if module has already been processed
+        try:
+            spec = importlib.util.spec_from_file_location(
+                f"{module_name}.__arkitekt__", rekuest_path
+            )
+            rekuest_module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(rekuest_module)
+            if hasattr(rekuest_module, "build_services"):
+                for service in rekuest_module.build_services():
+                    try:
+                        service_builder_registry.register(service)
+                    except ValueError as e:
+                        print(f"Failed to register service {service}: Another service with the same name is already registered {service_builder_registry.service_builders}")
+                logging.info(f"Called build_services function from {module_name}")
+            else:
+                print(f"Discovered Arkitekt-like module (containing __arkitekt__) that doesn't conform with the __arkitekt__ spec. No build_services function in {module_name}.__arkitekt__")
+            processed_modules.add(module_name)  # Mark this module as processed
+        except Exception as e:
+            print(f"Failed to call init_services for {module_name}: {e}")
+            traceback.print_exc()
+
+    # Check local modules in the current working directory
+    current_directory = os.getcwd()
+    for item in os.listdir(current_directory):
+        item_path = os.path.join(current_directory, item)
+        if os.path.isdir(item_path) and os.path.isfile(
+            os.path.join(item_path, "__init__.py")
+        ):
+            rekuest_path = os.path.join(item_path, "__arkitekt__.py")
+            if os.path.isfile(rekuest_path):
+                load_and_call_init_extensions(item, rekuest_path)
+
+    # Check installed packages
+    for _, module_name, _ in pkgutil.iter_modules():
+        try:
+            module_spec = importlib.util.find_spec(module_name)
+            if module_spec and module_spec.origin:
+                rekuest_path = os.path.join(
+                    os.path.dirname(module_spec.origin), "__arkitekt__.py"
+                )
+                if os.path.isfile(rekuest_path):
+                    load_and_call_init_extensions(module_name, rekuest_path)
+        except Exception as e:
+            print(
+                f"Failed to call init_extensions for installed package {module_name}: {e}"
+            )
+            traceback.print_exc()
+
+    return service_builder_registry

{arkitekt_next-0.8.32 → arkitekt_next-0.8.35}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "arkitekt-next"
-version = "0.8.32"
+version = "0.8.35"
 description = "client for the arkitekt_next platform"
 authors = ["jhnnsrs <jhnnsrs@gmail.com>"]
 license = "MIT"
@@ -11,17 +11,17 @@ readme = "README.md"
 python = "^3.8"
 herre-next = ">=1.0.2"
 fakts-next = ">=1.0.2"
-kraph = { version = ">=0.1.91", python = "^3.8", optional = true }
-mikro-next = { version = ">=0.1.47", python = "^3.10", optional = true }
-kabinet = { version = ">=0.1.38", optional = true,  python = "^3.9" }
-fluss-next = { version = ">=0.1.90", optional = true }
-reaktion-next= { version = ">=0.1.80", python = "^3.8", optional = true }
-rekuest-next= { version = ">=0.2.43", python = "^3.8", optional = true }
-unlok-next= { version = ">=0.1.83", python = "^3.8", optional = true }
-lovekit = { version = ">=0.1.15", python = "^3.10", optional = true }
+kraph = { version = ">=0.1.92", python = "^3.8", optional = true }
+mikro-next = { version = ">=0.1.48", python = "^3.10", optional = true }
+kabinet = { version = ">=0.1.40", optional = true,  python = "^3.9" }
+fluss-next = { version = ">=0.1.91", optional = true }
+reaktion-next= { version = ">=0.1.81", python = "^3.8", optional = true }
+rekuest-next= { version = ">=0.2.44", python = "^3.8", optional = true }
+unlok-next= { version = ">=0.1.84", python = "^3.8", optional = true }
+lovekit = { version = ">=0.1.16", python = "^3.10", optional = true }
 rich-click = { version = ">=1.6.1", optional = true }
 watchfiles = { version = ">=0.18.1", optional = true }
-turms = { version = ">=0.6.0", python = "^3.9", optional = true }
+turms = { version = ">=0.7.0", python = "^3.9", optional = true }
 semver = { version = ">=3.0.1", optional = true }
 dokker = ">=1.0.0"
 koil = ">=1.0.0"

arkitekt_next-0.8.32/arkitekt_next/cli/commands/gen/init.py

@@ -1,122 +0,0 @@
-import os
-import shutil
-import rich_click as click
-from arkitekt_next.cli.options import (
-    with_documents,
-    with_graphql_config,
-    with_api_path,
-    with_boring,
-    with_choose_services,
-    with_schemas,
-    with_seperate_document_dirs,
-)
-import yaml
-from arkitekt_next.cli.utils import build_relative_dir
-from arkitekt_next.cli.vars import get_console, get_manifest
-
-
-@click.command()
-@with_seperate_document_dirs
-@with_boring
-@with_choose_services
-@with_graphql_config
-@with_api_path
-@with_schemas
-@with_graphql_config
-@with_documents
-@click.pass_context
-def init(ctx, boring, services, config, documents, schemas, path, seperate_doc_dirs):
-    """Initialize code generation for the arkitekt_next app
-
-    Code generation for API's is done with the help of GraphQL Code Generation
-    that is powered by turms. This command initializes the code generation for
-    the app. It creates the necessary folders and files for the code generation
-    to work. It also creates a graphql config file that is used by turms to
-    generate the code.
-
-    """
-    app_directory = os.getcwd()
-
-    app_api_path = os.path.join(app_directory, path)
-    app_documents = os.path.join(app_directory, "graphql", "documents")
-
-    app_schemas = os.path.join(app_directory, "graphql", "schemas")
-
-    if documents:
-        os.makedirs(app_documents, exist_ok=True)
-    if schemas:
-        os.makedirs(app_schemas, exist_ok=True)
-    if path:
-        os.makedirs(app_api_path, exist_ok=True)
-
-    # Initializing the config
-    projects = {}
-
-    base_config = yaml.load(
-        open(build_relative_dir("configs", "base.yaml"), "r"), Loader=yaml.FullLoader
-    )
-
-    for service in services:
-        schema_path = build_relative_dir("schemas", f"{service}.schema.graphql")
-
-        if documents:
-            os.makedirs(os.path.join(app_documents, service), exist_ok=True)
-            if seperate_doc_dirs:
-                os.makedirs(
-                    os.path.join(app_documents, service, "queries"), exist_ok=True
-                )
-                os.makedirs(
-                    os.path.join(app_documents, service, "mutations"), exist_ok=True
-                )
-                os.makedirs(
-                    os.path.join(app_documents, service, "subscriptions"), exist_ok=True
-                )
-
-        if schemas:
-            if os.path.exists(schema_path):
-                try:
-                    shutil.copyfile(
-                        schema_path,
-                        os.path.join(app_schemas, service + ".graphql"),
-                    )
-                except FileExistsError:
-                    if click.confirm(
-                        f"Schema for {service} already exist. Do you want to overwrite them?"
-                    ):
-                        shutil.copyfile(
-                            schema_path,
-                            os.path.join(app_schemas, service + ".graphql"),
-                        )
-            else:
-                get_console(ctx).print(f"[red]No schema found for {service} [/]")
-
-        try:
-            project = base_config["projects"][service]
-        except KeyError:
-            get_console(ctx).print(f"[red]No config found for {service} [/]")
-            continue
-
-        if schemas:
-            project["schema"] = os.path.join(app_schemas, service + ".graphql")
-        if documents:
-            project["documents"] = (
-                os.path.join(app_documents, service) + "/**/*.graphql"
-            )
-
-        project["extensions"]["turms"]["out_dir"] = path
-        project["extensions"]["turms"]["generated_name"] = f"{service}.py"
-
-        projects[service] = project
-
-    if os.path.exists(config):
-        if not click.confirm(
-            f"GraphQL Config file already exists. Do you want to overwrite?"
-        ):
-            click.echo("Aborting...")
-            ctx.abort()
-
-    graph_config_path = os.path.join(app_directory, config)
-    yaml.safe_dump(
-        {"projects": projects}, open(graph_config_path, "w"), sort_keys=False
-    )
-    get_console(ctx).print(f"Config file written to {graph_config_path}")

arkitekt_next-0.8.32/arkitekt_next/service_registry.py

@@ -1,113 +0,0 @@
-from pydantic import BaseModel, Field
-from herre_next import Herre
-from fakts_next import Fakts
-from .base_models import Manifest, Requirement
-from typing import Callable, Dict
-import importlib
-import sys
-import os
-import traceback
-import logging
-import pkgutil
-
-Params = Dict[str, str]
-
-
-class Registration(BaseModel):
-    name: str
-    requirement: Requirement
-    builder: Callable[[Herre, Fakts, Params], object]
-
-
-basic_requirements =  {"lok": Requirement(
-        key="lok",
-        service="live.arkitekt.lok",
-        description="An instance of ArkitektNext Lok to authenticate the user",
-    )}
-
-
-class ServiceBuilderRegistry:
-    def __init__(self):
-        self.service_builders = {}
-        self.requirements_map = basic_requirements
-
-    def register(
-        self,
-        name: str,
-        service_builder: Callable[[Herre, Fakts], object],
-        requirement: Requirement,
-    ):
-        if name not in self.service_builders:
-            self.service_builders[name] = service_builder
-        
-        if name not in self.requirements_map:
-            self.requirements_map[name] = requirement
-
-    def get(self, name):
-        return self.services.get(name)
-
-    def build_service_map(
-        self, fakts: Fakts, herre: Herre, params: Params, manifest: Manifest
-    ):
-        return {
-            name: builder(fakts, herre, params, manifest)
-            for name, builder in self.service_builders.items()
-        }
-
-    def get_requirements(self):
-        return self.requirements_map.values()
-
-
-class SetupInfo:
-    services: Dict[str, object]
-
-
-def check_and_import_services() -> ServiceBuilderRegistry:
-
-    service_builder_registry = ServiceBuilderRegistry()
-
-    # Function to load and call init_extensions from __rekuest__.py
-    def load_and_call_init_extensions(module_name, rekuest_path):
-        try:
-            spec = importlib.util.spec_from_file_location(
-                f"{module_name}.__arkitekt__", rekuest_path
-            )
-            rekuest_module = importlib.util.module_from_spec(spec)
-            spec.loader.exec_module(rekuest_module)
-            if hasattr(rekuest_module, "init_services"):
-                rekuest_module.init_services(service_builder_registry)
-                logging.info(f"Called init_service function from {module_name}")
-            else:
-                print(f"No init_services function in {module_name}.__arkitekt__")
-        except Exception as e:
-            print(f"Failed to call init_services for {module_name}: {e}")
-            traceback.print_exc()
-
-    # Check local modules in the current working directory
-    current_directory = os.getcwd()
-    for item in os.listdir(current_directory):
-        item_path = os.path.join(current_directory, item)
-        if os.path.isdir(item_path) and os.path.isfile(
-            os.path.join(item_path, "__init__.py")
-        ):
-            rekuest_path = os.path.join(item_path, "__arkitekt__.py")
-            if os.path.isfile(rekuest_path):
-                load_and_call_init_extensions(item, rekuest_path)
-
-    # Check installed packages
-    for _, module_name, _ in pkgutil.iter_modules():
-        try:
-            module_spec = importlib.util.find_spec(module_name)
-            if module_spec and module_spec.origin:
-                rekuest_path = os.path.join(
-                    os.path.dirname(module_spec.origin), "__arkitekt__.py"
-                )
-                if os.path.isfile(rekuest_path):
-                    load_and_call_init_extensions(module_name, rekuest_path)
-        except Exception as e:
-            print(
-                f"Failed to call init_extensions for installed package {module_name}: {e}"
-            )
-            traceback.print_exc()
-
-    return service_builder_registry