infrahub-server 1.1.6__py3-none-any.whl → 1.2.0rc0__py3-none-any.whl

infrahub_testcontainers/container.py

@@ -3,7 +3,6 @@ import uuid
 from dataclasses import dataclass
 from functools import cached_property
 from pathlib import Path
-from typing import Optional
 
 from testcontainers.compose import DockerCompose
 from typing_extensions import Self
@@ -18,7 +17,7 @@ class ContainerService:
 
 
 INFRAHUB_SERVICES: dict[str, ContainerService] = {
-    "server": ContainerService(container="infrahub-server", port=8000),
+    "server": ContainerService(container="infrahub-server-lb", port=8000),
     "task-manager": ContainerService(container="task-manager", port=4200),
 }
 
@@ -33,8 +32,8 @@ PROJECT_ENV_VARIABLES: dict[str, str] = {
     "INFRAHUB_TESTING_INITIAL_ADMIN_TOKEN": "06438eb2-8019-4776-878c-0941b1f1d1ec",
     "INFRAHUB_TESTING_INITIAL_AGENT_TOKEN": "44af444d-3b26-410d-9546-b758657e026c",
     "INFRAHUB_TESTING_SECURITY_SECRET_KEY": "327f747f-efac-42be-9e73-999f08f86b92",
-    "INFRAHUB_TESTING_ADDRESS": "http://infrahub-server:8000",
-    "INFRAHUB_TESTING_INTERNAL_ADDRESS": "http://infrahub-server:8000",
+    "INFRAHUB_TESTING_ADDRESS": "http://infrahub-server-lb:8000",
+    "INFRAHUB_TESTING_INTERNAL_ADDRESS": "http://infrahub-server-lb:8000",
     "INFRAHUB_TESTING_BROKER_ADDRESS": "message-queue",
     "INFRAHUB_TESTING_CACHE_ADDRESS": "cache",
     "INFRAHUB_TESTING_WORKFLOW_ADDRESS": "task-manager",
@@ -43,15 +42,19 @@ PROJECT_ENV_VARIABLES: dict[str, str] = {
     "INFRAHUB_TESTING_LOCAL_REMOTE_GIT_DIRECTORY": "repos",
     "INFRAHUB_TESTING_INTERNAL_REMOTE_GIT_DIRECTORY": "/remote",
     "INFRAHUB_TESTING_WEB_CONCURRENCY": "4",
+    "INFRAHUB_TESTING_LOCAL_DB_BACKUP_DIRECTORY": "backups",
+    "INFRAHUB_TESTING_INTERNAL_DB_BACKUP_DIRECTORY": "/backups",
+    "INFRAHUB_TESTING_API_SERVER_COUNT": "2",
+    "INFRAHUB_TESTING_TASK_WORKER_COUNT": "2",
 }
 
 
 @dataclass
 class InfrahubDockerCompose(DockerCompose):
-    project_name: Optional[str] = None
+    project_name: str | None = None
 
     @classmethod
-    def init(cls, directory: Optional[Path] = None, version: Optional[str] = None) -> Self:
+    def init(cls, directory: Path | None = None, version: str | None = None) -> Self:
         if not directory:
             directory = Path.cwd()
 
@@ -80,6 +83,11 @@ class InfrahubDockerCompose(DockerCompose):
         test_compose_file = directory / "docker-compose.yml"
         test_compose_file.write_bytes(compose_file.read_bytes())
 
+        haproxy_config_file = current_directory / "haproxy.cfg"
+
+        test_haproxy_config_file = directory / "haproxy.cfg"
+        test_haproxy_config_file.write_bytes(haproxy_config_file.read_bytes())
+
         return test_compose_file
 
     @classmethod

infrahub_testcontainers/docker-compose.test.yml

@@ -28,6 +28,22 @@ services:
       timeout: 5s
       retries: 3
 
+  infrahub-server-lb:
+    image: haproxy:3.1-alpine
+    volumes:
+      - ./haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg
+    depends_on:
+      infrahub-server:
+        condition: service_started
+    healthcheck:
+      test: wget -O /dev/null http://127.0.0.1:8000/api/config || exit 1
+      interval: 5s
+      timeout: 5s
+      retries: 20
+      start_period: 10s
+    ports:
+      - ${INFRAHUB_TESTING_SERVER_PORT:-0}:8000
+
   database:
     image: ${NEO4J_DOCKER_IMAGE:-neo4j:5.20.0-community}
     restart: unless-stopped
@@ -35,9 +51,11 @@ services:
       NEO4J_AUTH: neo4j/admin
       NEO4J_dbms_security_procedures_unrestricted: "apoc.*"
       NEO4J_dbms_security_auth__minimum__password__length: 4
+      NEO4J_ACCEPT_LICENSE_AGREEMENT: "yes"
     volumes:
       - "database_data:/data"
       - "database_logs:/logs"
+      - "./${INFRAHUB_TESTING_LOCAL_DB_BACKUP_DIRECTORY}:${INFRAHUB_TESTING_INTERNAL_DB_BACKUP_DIRECTORY}"
     healthcheck:
       test: wget http://localhost:7474 || exit 1
       interval: 2s
@@ -49,8 +67,8 @@ services:
       - ${INFRAHUB_TESTING_DATABASE_UI_PORT:-0}:7474
 
   task-manager:
-    image: "${TASK_MANAGER_DOCKER_IMAGE:-prefecthq/prefect:3.0.11-python3.12}"
-    command: prefect server start --host 0.0.0.0 --ui
+    image: "${INFRAHUB_TESTING_DOCKER_IMAGE}:${INFRAHUB_TESTING_IMAGE_VERSION}"
+    command: uvicorn --host 0.0.0.0 --port 4200 --factory infrahub.prefect_server.app:create_infrahub_prefect
     depends_on:
       task-manager-db:
         condition: service_healthy
@@ -80,6 +98,9 @@ services:
       retries: 5
 
   infrahub-server:
+    deploy:
+      mode: replicated
+      replicas: ${INFRAHUB_TESTING_API_SERVER_COUNT}
     image: "${INFRAHUB_TESTING_DOCKER_IMAGE}:${INFRAHUB_TESTING_IMAGE_VERSION}"
     command: >
       gunicorn --config backend/infrahub/serve/gunicorn_config.py
@@ -106,8 +127,6 @@ services:
         condition: service_healthy
       task-manager:
         condition: service_healthy
-    ports:
-      - ${INFRAHUB_TESTING_SERVER_PORT:-0}:8000
     volumes:
       - "storage_data:/opt/infrahub/storage"
     tty: true
@@ -121,7 +140,7 @@ services:
   task-worker:
     deploy:
       mode: replicated
-      replicas: 2
+      replicas: ${INFRAHUB_TESTING_TASK_WORKER_COUNT}
     image: "${INFRAHUB_TESTING_DOCKER_IMAGE}:${INFRAHUB_TESTING_IMAGE_VERSION}"
     command: prefect worker start --type infrahubasync --pool infrahub-worker --with-healthcheck
     environment:

infrahub_testcontainers/haproxy.cfg

@@ -0,0 +1,43 @@
+global
+    log stdout local0
+    log stdout local1 notice
+    #chroot /var/lib/haproxy
+    #stats socket /run/haproxy/admin.sock mode 660 level admin
+    stats timeout 30s
+    user haproxy
+    group haproxy
+    daemon
+
+    # Default SSL material locations
+    ca-base /etc/ssl/certs
+    crt-base /etc/ssl/private
+
+    # See: https://ssl-config.mozilla.org/#server=haproxy&server-version=2.0.3&config=intermediate
+    ssl-default-bind-ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384
+    ssl-default-bind-ciphersuites TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256
+    ssl-default-bind-options ssl-min-ver TLSv1.2 no-tls-tickets
+
+defaults
+    log        global
+    mode       http
+    option     httplog
+    option     dontlognull
+    timeout connect 5000
+    timeout client  50000
+    timeout server  50000
+
+resolvers docker
+    parse-resolv-conf
+    accepted_payload_size 8192
+
+frontend fe
+    mode http
+    bind *:8000
+    option forwardfor
+
+    default_backend be
+
+backend be
+    mode http
+    balance roundrobin
+    server-template api 100 infrahub-server:8000 check resolvers docker init-addr none

infrahub_testcontainers/helpers.py

@@ -1,4 +1,5 @@
 import os
+import shutil
 import subprocess  # noqa: S404
 from pathlib import Path
 
@@ -36,12 +37,25 @@ class TestInfrahubDocker:
 
         return directory
 
+    @pytest.fixture(scope="class")
+    def remote_backups_dir(self, tmp_directory: Path) -> Path:
+        directory = tmp_directory / PROJECT_ENV_VARIABLES["INFRAHUB_TESTING_LOCAL_DB_BACKUP_DIRECTORY"]
+        directory.mkdir(exist_ok=True)
+
+        return directory
+
     @pytest.fixture(scope="class")
     def default_branch(self) -> str:
         return "main"
 
     @pytest.fixture(scope="class")
-    def infrahub_compose(self, tmp_directory: Path, infrahub_version: str) -> InfrahubDockerCompose:
+    def infrahub_compose(
+        self,
+        tmp_directory: Path,
+        remote_repos_dir: Path,  # initialize repository before running docker compose to fix permissions issues # noqa: ARG002
+        remote_backups_dir: Path,  # noqa: ARG002
+        infrahub_version: str,
+    ) -> InfrahubDockerCompose:
         return InfrahubDockerCompose.init(directory=tmp_directory, version=infrahub_version)
 
     @pytest.fixture(scope="class")
@@ -62,3 +76,73 @@ class TestInfrahubDocker:
     @pytest.fixture(scope="class")
     def task_manager_port(self, infrahub_app: dict[str, int]) -> int:
         return infrahub_app["task-manager"]
+
+    def backup_database(self, request: pytest.FixtureRequest, dest_dir: Path | None = None) -> None:
+        assert "enterprise" in os.environ.get("NEO4J_DOCKER_IMAGE", "")
+
+        backup_dir: Path = request.getfixturevalue("remote_backups_dir")
+        infrahub_compose: InfrahubDockerCompose = request.getfixturevalue("infrahub_compose")
+
+        infrahub_compose.exec_in_container(
+            command=[
+                "neo4j-admin",
+                "database",
+                "backup",
+                "--to-path",
+                os.environ.get(
+                    "INFRAHUB_TESTING_INTERNAL_DB_BACKUP_DIRECTORY",
+                    PROJECT_ENV_VARIABLES["INFRAHUB_TESTING_INTERNAL_DB_BACKUP_DIRECTORY"],
+                ),
+            ],
+            service_name="database",
+        )
+
+        if dest_dir:
+            shutil.copytree(
+                str(backup_dir),
+                str(dest_dir),
+            )
+
+    def restore_database(self, request: pytest.FixtureRequest, backup_file: Path) -> None:
+        assert "enterprise" in os.environ.get("NEO4J_DOCKER_IMAGE", "")
+
+        backup_dir: Path = request.getfixturevalue("remote_backups_dir")
+        infrahub_compose: InfrahubDockerCompose = request.getfixturevalue("infrahub_compose")
+
+        shutil.copy(
+            str(backup_file),
+            str(backup_dir / backup_file.name),
+        )
+
+        infrahub_compose.exec_in_container(
+            command=["cypher-shell", "-u", "neo4j", "-p", "admin", "STOP DATABASE neo4j;"],
+            service_name="database",
+        )
+
+        infrahub_compose.exec_in_container(
+            command=[
+                "neo4j-admin",
+                "database",
+                "restore",
+                "--overwrite-destination",
+                "--from-path",
+                str(
+                    Path(
+                        os.environ.get(
+                            "INFRAHUB_TESTING_INTERNAL_DB_BACKUP_DIRECTORY",
+                            PROJECT_ENV_VARIABLES["INFRAHUB_TESTING_INTERNAL_DB_BACKUP_DIRECTORY"],
+                        )
+                    )
+                    / backup_file.name
+                ),
+            ],
+            service_name="database",
+        )
+
+        infrahub_compose.exec_in_container(
+            command=["cypher-shell", "-d", "system", "-u", "neo4j", "-p", "admin", "START DATABASE neo4j;"],
+            service_name="database",
+        )
+
+        infrahub_compose.stop(down=False)
+        infrahub_compose.start()

infrahub/core/branch/constants.py

@@ -1,2 +0,0 @@
-AUTOMATION_NAME_CREATE = "Trigger-branch-create-events"
-AUTOMATION_NAME_REMOVE = "Trigger-branch-remove-events"

infrahub/graphql/query.py

@@ -1,52 +0,0 @@
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Optional
-
-from graphql import graphql
-
-from infrahub.core.branch import Branch
-from infrahub.core.constants import InfrahubKind
-from infrahub.core.manager import NodeManager
-from infrahub.core.protocols import CoreGraphQLQuery
-from infrahub.core.registry import registry
-from infrahub.core.timestamp import Timestamp
-from infrahub.graphql.initialization import prepare_graphql_params
-
-if TYPE_CHECKING:
-    from graphql.execution import ExecutionResult
-
-    from infrahub.database import InfrahubDatabase
-
-
-async def execute_query(
-    name: str,
-    db: InfrahubDatabase,
-    params: Optional[dict] = None,
-    branch: Branch | str | None = None,
-    at: Timestamp | str | None = None,
-) -> ExecutionResult:
-    """Helper function to Execute a GraphQL Query."""
-
-    if not isinstance(branch, Branch):
-        branch = await registry.get_branch(db=db, branch=branch)
-    at = Timestamp(at)
-
-    graphql_query = await NodeManager.get_one_by_default_filter(
-        db=db, id=name, kind=CoreGraphQLQuery, branch=branch, at=at
-    )
-    if not graphql_query:
-        raise ValueError(f"Unable to find the {InfrahubKind.GRAPHQLQUERY} {name}")
-
-    gql_params = await prepare_graphql_params(
-        branch=branch, db=db, at=at, include_mutation=False, include_subscription=False
-    )
-
-    result = await graphql(
-        schema=gql_params.schema,
-        source=graphql_query.query.value,
-        context_value=gql_params.context,
-        root_value=None,
-        variable_values=params or {},
-    )
-
-    return result

infrahub/message_bus/messages/request_artifactdefinition_check.py

@@ -1,17 +0,0 @@
-from pydantic import ConfigDict, Field
-
-from infrahub.message_bus import InfrahubMessage
-from infrahub.message_bus.types import ProposedChangeArtifactDefinition, ProposedChangeBranchDiff
-
-
-class RequestArtifactDefinitionCheck(InfrahubMessage):
-    """Sent to validate the generation of artifacts in relation to a proposed change."""
-
-    model_config = ConfigDict(arbitrary_types_allowed=True)
-
-    artifact_definition: ProposedChangeArtifactDefinition = Field(..., description="The Artifact Definition")
-    branch_diff: ProposedChangeBranchDiff = Field(..., description="The calculated diff between the two branches")
-    proposed_change: str = Field(..., description="The unique ID of the Proposed Change")
-    source_branch: str = Field(..., description="The source branch")
-    source_branch_sync_with_git: bool = Field(..., description="Indicates if the source branch should sync with git")
-    destination_branch: str = Field(..., description="The target branch")

infrahub/message_bus/operations/requests/artifact_definition.py

@@ -1,148 +0,0 @@
-from typing import Optional
-
-from infrahub_sdk.uuidt import UUIDT
-from prefect import flow
-from prefect.logging import get_run_logger
-
-from infrahub.core.constants import InfrahubKind, ValidatorConclusion, ValidatorState
-from infrahub.core.timestamp import Timestamp
-from infrahub.message_bus import InfrahubMessage, Meta, messages
-from infrahub.message_bus.types import KVTTL
-from infrahub.services import InfrahubServices
-from infrahub.workflows.utils import add_tags
-
-
-@flow(
-    name="artifact-definition-check",
-    flow_run_name="Validating generation of artifacts for {message.artifact_definition.definition_name}",
-)
-async def check(message: messages.RequestArtifactDefinitionCheck, service: InfrahubServices) -> None:
-    events: list[InfrahubMessage] = []
-    await add_tags(branches=[message.source_branch], nodes=[message.proposed_change], db_change=True)
-
-    log = get_run_logger()
-    artifact_definition = await service.client.get(
-        kind=InfrahubKind.ARTIFACTDEFINITION,
-        id=message.artifact_definition.definition_id,
-        branch=message.source_branch,
-    )
-    proposed_change = await service.client.get(kind=InfrahubKind.PROPOSEDCHANGE, id=message.proposed_change)
-
-    validator_name = f"Artifact Validator: {message.artifact_definition.definition_name}"
-    validator_execution_id = str(UUIDT())
-    check_execution_ids: list[str] = []
-
-    await proposed_change.validations.fetch()
-
-    validator = None
-    for relationship in proposed_change.validations.peers:
-        existing_validator = relationship.peer
-        if (
-            existing_validator.typename == InfrahubKind.ARTIFACTVALIDATOR
-            and existing_validator.definition.id == message.artifact_definition.definition_id
-        ):
-            validator = existing_validator
-
-    if validator:
-        validator.conclusion.value = ValidatorConclusion.UNKNOWN.value
-        validator.state.value = ValidatorState.QUEUED.value
-        validator.started_at.value = ""
-        validator.completed_at.value = ""
-        await validator.save()
-    else:
-        validator = await service.client.create(
-            kind=InfrahubKind.ARTIFACTVALIDATOR,
-            data={
-                "label": validator_name,
-                "proposed_change": message.proposed_change,
-                "definition": message.artifact_definition.definition_id,
-            },
-        )
-        await validator.save()
-
-    await artifact_definition.targets.fetch()
-    group = artifact_definition.targets.peer
-    await group.members.fetch()
-
-    existing_artifacts = await service.client.filters(
-        kind=InfrahubKind.ARTIFACT,
-        definition__ids=[message.artifact_definition.definition_id],
-        include=["object"],
-        branch=message.source_branch,
-    )
-    artifacts_by_member = {}
-    for artifact in existing_artifacts:
-        artifacts_by_member[artifact.object.peer.id] = artifact.id
-
-    repository = message.branch_diff.get_repository(repository_id=message.artifact_definition.repository_id)
-    requested_artifacts = 0
-    impacted_artifacts = message.branch_diff.get_subscribers_ids(kind=InfrahubKind.ARTIFACT)
-    for relationship in group.members.peers:
-        member = relationship.peer
-        artifact_id = artifacts_by_member.get(member.id)
-        if _render_artifact(
-            artifact_id=artifact_id,
-            managed_branch=message.source_branch_sync_with_git,
-            impacted_artifacts=impacted_artifacts,
-        ):
-            check_execution_id = str(UUIDT())
-            check_execution_ids.append(check_execution_id)
-            requested_artifacts += 1
-            log.info(f"Trigger Artifact processing for {member.display_label}")
-            events.append(
-                messages.CheckArtifactCreate(
-                    artifact_name=message.artifact_definition.artifact_name,
-                    artifact_id=artifact_id,
-                    artifact_definition=message.artifact_definition.definition_id,
-                    commit=repository.source_commit,
-                    content_type=message.artifact_definition.content_type,
-                    transform_type=message.artifact_definition.transform_kind,
-                    transform_location=message.artifact_definition.transform_location,
-                    repository_id=repository.repository_id,
-                    repository_name=repository.repository_name,
-                    repository_kind=repository.kind,
-                    branch_name=message.source_branch,
-                    query=message.artifact_definition.query_name,
-                    variables=member.extract(params=artifact_definition.parameters.value),
-                    target_id=member.id,
-                    target_name=member.display_label,
-                    timeout=message.artifact_definition.timeout,
-                    validator_id=validator.id,
-                    meta=Meta(validator_execution_id=validator_execution_id, check_execution_id=check_execution_id),
-                )
-            )
-
-    checks_in_execution = ",".join(check_execution_ids)
-    await service.cache.set(
-        key=f"validator_execution_id:{validator_execution_id}:checks",
-        value=checks_in_execution,
-        expires=KVTTL.TWO_HOURS,
-    )
-    events.append(
-        messages.FinalizeValidatorExecution(
-            start_time=Timestamp().to_string(),
-            validator_id=validator.id,
-            validator_execution_id=validator_execution_id,
-            validator_type=InfrahubKind.ARTIFACTVALIDATOR,
-        )
-    )
-    for event in events:
-        event.assign_meta(parent=message)
-        await service.send(message=event)
-
-
-def _render_artifact(artifact_id: Optional[str], managed_branch: bool, impacted_artifacts: list[str]) -> bool:  # pylint: disable=unused-argument
-    """Returns a boolean to indicate if an artifact should be generated or not.
-    Will return true if:
-        * The artifact_id wasn't set which could be that it's a new object that doesn't have a previous artifact
-        * The source brance is not data only which would indicate that it could contain updates in git to the transform
-        * The artifact_id exists in the impacted_artifacts list
-    Will return false if:
-        * The source branch is a data only branch and the artifact_id exists and is not in the impacted list
-    """
-
-    # if not artifact_id or managed_branch:
-    #    return True
-    # return artifact_id in impacted_artifacts
-    # Temporary workaround tracked in https://github.com/opsmill/infrahub/issues/4991
-    return True

infrahub/schema/constants.py

@@ -1 +0,0 @@
-AUTOMATION_NAME = "Trigger-schema-update-event"

infrahub/schema/tasks.py

@@ -1,76 +0,0 @@
-from __future__ import annotations
-
-from datetime import timedelta
-
-from prefect import flow
-from prefect.automations import AutomationCore
-from prefect.client.orchestration import get_client
-from prefect.client.schemas.filters import DeploymentFilter, DeploymentFilterName
-from prefect.events.actions import RunDeployment
-from prefect.events.schemas.automations import EventTrigger, Posture
-from prefect.logging import get_run_logger
-
-from infrahub.workflows.catalogue import COMPUTED_ATTRIBUTE_SETUP, COMPUTED_ATTRIBUTE_SETUP_PYTHON
-
-from .constants import AUTOMATION_NAME
-
-
-@flow(name="schema-updated-setup", flow_run_name="Setup schema updated event in task-manager")
-async def schema_updated_setup() -> None:
-    log = get_run_logger()
-
-    async with get_client(sync_client=False) as client:
-        deployments = {
-            item.name: item
-            for item in await client.read_deployments(
-                deployment_filter=DeploymentFilter(
-                    name=DeploymentFilterName(
-                        any_=[COMPUTED_ATTRIBUTE_SETUP.name, COMPUTED_ATTRIBUTE_SETUP_PYTHON.name]
-                    )
-                )
-            )
-        }
-        if COMPUTED_ATTRIBUTE_SETUP.name not in deployments:
-            raise ValueError("Unable to find the deployment for PROCESS_COMPUTED_MACRO")
-
-        deployment_id_computed_attribute_setup = deployments[COMPUTED_ATTRIBUTE_SETUP.name].id
-        deployment_id_computed_attribute_setup_python = deployments[COMPUTED_ATTRIBUTE_SETUP_PYTHON.name].id
-
-        schema_update_automation = await client.find_automation(id_or_name=AUTOMATION_NAME)
-
-        automation = AutomationCore(
-            name=AUTOMATION_NAME,
-            description="Trigger actions on schema update event",
-            enabled=True,
-            trigger=EventTrigger(
-                posture=Posture.Reactive,
-                expect={"infrahub.schema.update"},
-                within=timedelta(0),
-                threshold=1,
-            ),
-            actions=[
-                RunDeployment(
-                    source="selected",
-                    deployment_id=deployment_id_computed_attribute_setup,
-                    parameters={
-                        "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
-                    },
-                    job_variables={},
-                ),
-                RunDeployment(
-                    source="selected",
-                    deployment_id=deployment_id_computed_attribute_setup_python,
-                    parameters={
-                        "branch_name": "{{ event.resource['infrahub.branch.name'] }}",
-                    },
-                    job_variables={},
-                ),
-            ],
-        )
-
-        if schema_update_automation:
-            await client.update_automation(automation_id=schema_update_automation.id, automation=automation)
-            log.info(f"{AUTOMATION_NAME} Updated")
-        else:
-            await client.create_automation(automation=automation)
-            log.info(f"{AUTOMATION_NAME} Created")

infrahub/services/adapters/database/__init__.py

@@ -1,9 +0,0 @@
-from neo4j import AsyncSession
-
-
-class InfrahubDatabase:
-    """Base class for database access"""
-
-    @property
-    def session(self) -> AsyncSession:
-        raise NotImplementedError()

infrahub_sdk/ctl/_file.py

@@ -1,13 +0,0 @@
-from pathlib import Path
-
-from .exceptions import FileNotValidError
-
-
-def read_file(file_name: Path) -> str:
-    if not file_name.is_file():
-        raise FileNotValidError(name=str(file_name), message=f"{file_name} is not a valid file")
-    try:
-        with Path.open(file_name, encoding="utf-8") as fobj:
-            return fobj.read()
-    except UnicodeDecodeError as exc:
-        raise FileNotValidError(name=str(file_name), message=f"Unable to read {file_name} with utf-8 encoding") from exc