mainsequence 8.1.21.dev20__tar.gz → 8.1.22.dev21__tar.gz

{mainsequence-8.1.21.dev20/mainsequence.egg-info → mainsequence-8.1.22.dev21}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mainsequence
-Version: 8.1.21.dev20
+Version: 8.1.22.dev21
 Summary: Main Sequence SDK 
 Author-email: Main Sequence GmbH <dev@main-sequence.io>
 License-Expression: LicenseRef-MainSequence-Proprietary

{mainsequence-8.1.21.dev20 → mainsequence-8.1.22.dev21}/agent_scaffold/skills/application_surfaces/api_surfaces/SKILL.md

@@ -187,27 +187,27 @@ Before release, verify local CodeRepository resolution:
 mainsequence code-repository current --debug --json
 ```
 
-Then move the tested code through the canonical lifecycle:
+Declare the FastAPI resource in `.mainsequence/workflows/`, validate the
+workflow against the backend template, then move the tested commit through the
+canonical lifecycle:
 
 ```bash
 mainsequence code-repository sync -m "Release Command Center API"
-mainsequence code-repository images create
 mainsequence code-repository resources list --filter resource_type=fastapi
-mainsequence code-repository resources create_fastapi
 ```
 
 Verify that:
 
 - code-repository sync used the intended Git branch
-- the selected image contains the exact tested commit
-- resource discovery found the expected FastAPI path at that commit
-- the selected resource UID and image UID refer to the same commit
-- the created release kind is `fastapi`
+- the workflow declaration identifies the tested FastAPI source path
+- resource discovery found that path at the exact deployed commit
+- Django resolved and built the exact image for the workflow event
+- the resulting release kind is `fastapi`
 - compute and spot settings are intentional
 
-Use `--automatic-deployment` only after the route paths, resource path, and
-frontend contracts are stable and the release should follow future repository
-syncs. Otherwise keep the release pinned and create deliberate replacements.
+Enable automatic deployment in the repository workflow when the route paths,
+resource path, and frontend contracts are stable enough for future repository
+events to promote exact images.
 
 ### 6. Verify the deployed API
 

{mainsequence-8.1.21.dev20 → mainsequence-8.1.22.dev21}/agent_scaffold/skills/platform_operations/orchestration_and_releases/SKILL.md

@@ -21,17 +21,11 @@ This skill is for:
 
 ## This Skill Can Do
 
-- create or review manual jobs
-- create or review scheduled jobs
-- author backend-managed declarations under `.mainsequence/workflows/`
-- validate workflow files through the CodeRepositoryBranch workflow endpoints
-- create or select code repository images
-- bind every job to one exact code repository image
-- configure standalone Job automatic deployment as future exact-image promotion
-- inspect job runs and logs
-- reason about code repository resources and resource releases
-- decide whether a `ResourceRelease` should opt into `automatic_deployment`
-- inspect automatic deployment run state for release rotations
+- author and validate Job, FastAPI, and Static Site workflow declarations
+- inspect exact CodeRepository images, Jobs, ResourceReleases, and deployment runs
+- run an existing Job manually and inspect logs
+- update supported properties on an existing Job or release
+- reason about automatic deployment and repository-event image promotion
 - review Artifact-based workflows in operational pipelines
 
 ## This Skill Must Not Claim
@@ -68,41 +62,19 @@ changing the operational workflow.
 
 ## Inputs This Skill Needs
 
-Before changing orchestration or release behavior, collect or infer:
-
-- the execution target:
-  - `execution_path`
-  - app entrypoint
-- whether the job is:
-  - manual
-  - interval
-  - crontab
-  - one-off
-- the image strategy:
-  - existing image
-  - new image
-- whether the workflow is:
-  - direct CLI/client job creation
-  - backend-managed code-repository workflow declarations
-- whether a `ResourceRelease` should be manually pinned or opted into repository-sync automatic deployment
-- whether Artifact inputs or outputs are part of the run
-- who owns the exact initial image: the caller for manual pinning or the
-  backend for automatic deployment
-- whether future qualifying immutable repository events may promote a standalone Job
-
-If the execution target or image strategy is unclear, stop before scheduling anything.
+Identify the repository source path or Job execution path, the product kind,
+schedule and compute intent, and whether future qualifying repository events
+should promote the target. For an existing target, obtain its public UID before
+running or updating it. The repository workflow is the creation input; callers
+do not select image, resource, Job, or release UIDs for creation.
 
 ## Required Decisions
 
-For every non-trivial orchestration task, decide:
-
-1. Is this a one-off/manual workflow or a repository-managed recurring workflow?
-2. Should the jobs live in a `.mainsequence/workflows/*.yaml` declaration?
-3. Is the Job manually pinned to a caller-selected exact ready image, or does
-   automatic deployment make the backend derive it from the synchronized commit?
-4. Does the workflow depend on Artifacts?
-5. Is the task actually a release/resource problem instead of only a job problem?
-6. For a `ResourceRelease`, should repository sync be allowed to rotate the release automatically through `automatic_deployment`?
+1. Which repository workflow declaration owns the target?
+2. Is the Job manual, interval, crontab, or one-off?
+3. Should future exact repository events promote its image automatically?
+4. Are Artifacts inputs or outputs of the run?
+5. Which existing Job or release needs observation or an explicit operation?
 
 ## Build Rules
 
@@ -129,38 +101,11 @@ Do not hide important recurring schedules in ad hoc shell history or one-off man
 
 ### 2. Every Job requires one exact image
 
-Every persisted direct Job has one exact code repository image, but the creation mode
-determines who supplies it.
-
-Remember:
-
-- images are built from pushed commits
-- if a commit is not on the remote, it cannot be used for an image
-- there is no dynamic, blank-image, branch-tip, or `latest` Job mode
-- a manual Job requires the caller to select `related_image_uid`
-- an automatic Job forbids caller image selection; the backend derives the
-  exact initial image from the CodeRepositoryBranch's persisted synchronized commit
-
-When standalone Job automatic deployment is enabled during creation, the
-backend prepares the exact initial image and later qualifying immutable
-repository events may atomically promote another exact image. On an existing
-Job, enabling or disabling it retains the current exact image. The backend owns
-repository-event truth, policy evaluation, image preparation, and promotion;
-CodeRepository code and the SDK must not choose a Job's deployment branch or image.
-This deployment-policy rule does not replace ADR-0037 runtime source discovery:
-code executing inside the resulting code repository image still resolves and validates
-its attached Git branch and exact commit.
-
-For direct creation use:
-
-- `--automatic-deployment` to permit future exact-image promotion
-- `--no-automatic-deployment` to keep future repository events from changing
-  the Job image
-- `--automatic-redeployment-tag-regex` to require a full matching immutable
-  tag; omit the regex for every otherwise-eligible exact event
-
-Use `--related-image-uid` only for manual pinning. Omit it with
-`--automatic-deployment`; passing both is invalid.
+Django derives the initial image from the exact repository event when it
+applies a `kind: job` workflow declaration. A later qualifying event may
+promote another exact image under the Job's automatic deployment policy.
+There is no dynamic, blank-image, branch-tip, or `latest` execution mode.
+A caller does not create an image or Job by selecting a stored image UID.
 
 ### 3. Jobs must be verifiable after creation
 
@@ -201,7 +146,7 @@ Current support matrix:
 | `Job.run_job(command_args=[...])` | Supported for that manual run |
 | `mainsequence code-repository jobs run ... --arg/-- ...` | Supported for that manual run |
 | `Job.scheduled_command_args` | Persisted list copied into future scheduler-created runs |
-| `mainsequence code-repository jobs create/update --scheduled-arg ...` | Creates or replaces the persisted scheduled list |
+| `mainsequence code-repository jobs update --scheduled-arg ...` | Replaces the persisted list on an existing Job |
 | `.mainsequence/workflows/*.yaml` Job declaration | Supports `scheduled_command_args` as an ordered `list[str]` |
 
 Keep `scheduled_command_args` separate from manual `command_args`. Retrieve the
@@ -298,36 +243,27 @@ Enable `automatic_deployment` only when:
 
 Keep `automatic_deployment` disabled when:
 
-- the release must stay pinned to a manually selected image or resource version
+- the release should not promote on future repository events
 - each release rotation needs human approval
 - the resource path or entrypoint is still moving
 - API or widget contracts are not stable enough for automatic rotation
 - the current branch/CodeRepository sync target is not the intended deployment source
 
-Create opted-in releases with the CLI flags that exist:
-
-- `mainsequence code-repository resources create_fastapi --automatic-deployment`
-- use `--no-automatic-deployment` when the decision is explicitly to keep the release pinned/manual
-
-The SDK surface also accepts:
-
-- `CodeRepositoryResource.create_fastapi(..., automatic_deployment=True)`
-- `ResourceRelease.create(..., automatic_deployment=True)`
-- `ResourceRelease.deploy_current_version()` for an SDK-triggered manual deployment run; it returns `DeploymentRun`
-- `DeploymentRun.filter(target_type="resource_release", target_uid=release.uid)` to inspect runs for one release
+Declare opted-in releases in the repository workflow and validate the file
+against the backend template. Repository events create deployment runs.
+`DeploymentRun.filter(target_type="resource_release", target_uid=release.uid)`
+inspects runs for an existing release.
 
 Every release also exposes its immutable revision lifecycle:
 
 - `desired_revision` is the public UID of the accepted revision being materialized
 - `active_revision` is the public UID of the ready revision currently serving behind the stable release URL
 - the two UIDs may differ while a deployment is running or after a deployment fails
-- `revision_retention_count` is the positive release-owned retention setting; omission on create uses the backend default
-- configure retention with `ResourceRelease.create(..., revision_retention_count=3)` or `release.patch(revision_retention_count=5)`
+- `revision_retention_count` is the positive release-owned retention setting; omission in the workflow uses the backend default
+- configure retention in the workflow or update an existing release with `release.patch(revision_retention_count=5)`
 
 Treat `active_revision` and `desired_revision` as read-only public identities. Do not substitute provider revision names, deployment names, or internal database IDs.
 
-Do not claim there is a CLI command for `deploy_current_version` unless the local CLI actually exposes one. In this SDK, the manual detail action is available through the client model.
-
 Inspect the unified run's `state`, `phase`, `outcome`, `steps`, `logs`, and `error` fields. Do not use legacy resource-release deployment status fields or filters.
 Detail responses also expose `builder_image` and `builder_runtime`; these are empty strings when the run has no static-site builder metadata.
 
@@ -336,11 +272,9 @@ Detail responses also expose `builder_image` and `builder_runtime`; these are em
 When reviewing an orchestration task, look for:
 
 - schedules that should have been version-controlled
-- direct job creation where a batch file should exist
-- missing or wrong `related_image_uid`
-- jobs tied to moving repository state instead of a pinned image
-- manual Job creation that omits an exact ready image
-- automatic Job creation that supplies a caller-selected image
+- a missing repository workflow declaration for a new Job
+- a workflow with a caller-selected image or generated platform UID
+- jobs tied to moving repository state instead of an exact image
 - client code that interprets automatic deployment as a branch-tip or `latest` selector
 - no run/log verification after creation
 - unsafe use of `--strict`
@@ -360,9 +294,9 @@ Do not claim success until you have checked:
   - interval
   - crontab
   - one-off
-- manual image selection or backend-owned automatic image preparation is intentional
+- the exact repository event and backend-owned image preparation are intentional
 - standalone Job automatic deployment and tag policy are intentionally enabled or disabled
-- the job exists after direct creation or repository workflow application
+- the Job exists after repository workflow application
 - runs and logs were inspected when execution success matters
 - resources and releases were verified when deployment success matters
 - `automatic_deployment` is intentionally enabled or disabled on each release
@@ -386,7 +320,7 @@ If the workflow uses Artifacts, also check:
 - the execution target is unclear
 - the image strategy is unclear but reproducibility matters
 - the backend rejects the workflow version, resource kind, or requested field
-- a manually pinned Job has no exact ready initial image
+- a Job workflow cannot resolve an exact source image
 - an automatically deployed Job has no persisted synchronized CodeRepositoryBranch commit
 - the workflow depends on local file paths that should be platform Artifacts
 - automatic deployment is requested but the deployment source branch/current synced CodeRepository version is unclear

{mainsequence-8.1.21.dev20 → mainsequence-8.1.22.dev21}/mainsequence/cli/api.py

@@ -2171,117 +2171,6 @@ def get_code_repository_time_index_table_updates(
                 os.environ[k] = v
 
 
-def create_code_repository_image(
-    *,
-    code_repository_commit_hash: str,
-    related_code_repository_branch_uid: str,
-    base_image_uid: str | None = None,
-    timeout: int | None = None,
-) -> dict[str, Any]:
-    """
-    Create a code repository image via SDK client model.
-
-    Single source of truth:
-      - delegates payload construction and request behavior to `CodeRepositoryImage.create()`
-      - avoids duplicating the endpoint contract in the CLI API wrapper
-    """
-    tokens = get_tokens()
-    access = (tokens.get("access") or "").strip()
-    refresh = (tokens.get("refresh") or "").strip()
-    if not access:
-        raise NotLoggedIn("Not logged in.")
-
-    endpoint = backend_url().rstrip("/")
-    root_url = f"{endpoint}/api/v1"
-
-    old_env = {
-        "MAINSEQUENCE_AUTH_MODE": os.environ.get("MAINSEQUENCE_AUTH_MODE"),
-        "MAINSEQUENCE_ACCESS_TOKEN": os.environ.get("MAINSEQUENCE_ACCESS_TOKEN"),
-        "MAINSEQUENCE_REFRESH_TOKEN": os.environ.get("MAINSEQUENCE_REFRESH_TOKEN"),
-        "MAINSEQUENCE_ENDPOINT": os.environ.get("MAINSEQUENCE_ENDPOINT"),
-    }
-
-    client_utils = None
-    old_provider = None
-    old_base_root_url = None
-    old_image_root_url = None
-
-    try:
-        os.environ["MAINSEQUENCE_AUTH_MODE"] = "jwt"
-        os.environ["MAINSEQUENCE_ACCESS_TOKEN"] = access
-        if refresh:
-            os.environ["MAINSEQUENCE_REFRESH_TOKEN"] = refresh
-        else:
-            os.environ.pop("MAINSEQUENCE_REFRESH_TOKEN", None)
-        os.environ["MAINSEQUENCE_ENDPOINT"] = endpoint
-        resolved_branch_uid = resolve_code_repository_branch_uid(related_code_repository_branch_uid)
-
-        from mainsequence.client import utils as _client_utils
-        from mainsequence.client.base import BaseObjectOrm
-        from mainsequence.client.models_foundry import (
-            CodeRepositoryImage as ClientCodeRepositoryImage,
-        )
-
-        client_utils = _client_utils
-        old_provider = getattr(client_utils.loaders, "provider", None)
-        old_base_root_url = BaseObjectOrm.ROOT_URL
-        old_image_root_url = getattr(ClientCodeRepositoryImage, "ROOT_URL", None)
-
-        _set_client_utils_endpoint(client_utils, endpoint)
-        client_utils.loaders.use_jwt(access=access, refresh=refresh or None)
-
-        BaseObjectOrm.ROOT_URL = root_url
-        ClientCodeRepositoryImage.ROOT_URL = root_url
-
-        created = ClientCodeRepositoryImage.create(
-            code_repository_commit_hash=code_repository_commit_hash,
-            related_code_repository_branch_uid=resolved_branch_uid,
-            base_image_uid=base_image_uid,
-            timeout=timeout,
-        )
-        if isinstance(created, dict):
-            return created
-        if hasattr(created, "model_dump"):
-            return created.model_dump()
-        return {"uid": getattr(created, "uid", None)}
-
-    except Exception as e:
-        err_name = type(e).__name__
-        if err_name in {"AuthenticationError", "PermissionDeniedError"}:
-            raise NotLoggedIn(str(e) or "Not logged in.") from e
-        if err_name == "NotFoundError":
-            raise ApiError(
-                f"CodeRepositoryBranch not found: {related_code_repository_branch_uid}"
-            ) from e
-        raise ApiError(f"CodeRepository image create failed: {e}") from e
-    finally:
-        if client_utils is not None:
-            try:
-                client_utils.loaders.provider = old_provider
-            except Exception:
-                pass
-        if old_base_root_url is not None:
-            try:
-                from mainsequence.client.base import BaseObjectOrm
-
-                BaseObjectOrm.ROOT_URL = old_base_root_url
-            except Exception:
-                pass
-        if old_image_root_url is not None:
-            try:
-                from mainsequence.client.models_foundry import (
-                    CodeRepositoryImage as ClientCodeRepositoryImage,
-                )
-
-                ClientCodeRepositoryImage.ROOT_URL = old_image_root_url
-            except Exception:
-                pass
-
-        for k, v in old_env.items():
-            if v is None:
-                os.environ.pop(k, None)
-            else:
-                os.environ[k] = v
 
 
 def list_code_repository_images(
@@ -2797,135 +2686,6 @@ def list_code_repository_resources(
                 os.environ[k] = v
 
 
-def create_code_repository_resource_release(
-    *,
-    release_kind: str,
-    resource_uid: str,
-    related_image_uid: str | None = None,
-    cpu_request: str | int | float | None = None,
-    memory_request: str | int | float | None = None,
-    gpu_request: str | int | None = None,
-    gpu_type: str | None = None,
-    spot: bool | None = None,
-    automatic_deployment: bool | None = None,
-    timeout: int | None = None,
-) -> dict[str, Any]:
-    """
-    Create a resource release via SDK client model.
-
-    Single source of truth:
-      - delegates to `CodeRepositoryResource.create_fastapi()`
-      - which in turn use `ResourceRelease.create()`
-    """
-    normalized_release_kind = str(release_kind).strip()
-    if normalized_release_kind != "fastapi":
-        raise ApiError("release_kind must be 'fastapi'.")
-
-    tokens = get_tokens()
-    access = (tokens.get("access") or "").strip()
-    refresh = (tokens.get("refresh") or "").strip()
-    if not access:
-        raise NotLoggedIn("Not logged in.")
-
-    endpoint = backend_url().rstrip("/")
-    root_url = f"{endpoint}/api/v1"
-
-    old_env = {
-        "MAINSEQUENCE_AUTH_MODE": os.environ.get("MAINSEQUENCE_AUTH_MODE"),
-        "MAINSEQUENCE_ACCESS_TOKEN": os.environ.get("MAINSEQUENCE_ACCESS_TOKEN"),
-        "MAINSEQUENCE_REFRESH_TOKEN": os.environ.get("MAINSEQUENCE_REFRESH_TOKEN"),
-        "MAINSEQUENCE_ENDPOINT": os.environ.get("MAINSEQUENCE_ENDPOINT"),
-    }
-
-    client_utils = None
-    old_provider = None
-    old_base_root_url = None
-    old_resource_root_url = None
-
-    try:
-        os.environ["MAINSEQUENCE_AUTH_MODE"] = "jwt"
-        os.environ["MAINSEQUENCE_ACCESS_TOKEN"] = access
-        if refresh:
-            os.environ["MAINSEQUENCE_REFRESH_TOKEN"] = refresh
-        else:
-            os.environ.pop("MAINSEQUENCE_REFRESH_TOKEN", None)
-        os.environ["MAINSEQUENCE_ENDPOINT"] = endpoint
-
-        from mainsequence.client import utils as _client_utils
-        from mainsequence.client.base import BaseObjectOrm
-        from mainsequence.client.models_helpers import (
-            CodeRepositoryResource as ClientCodeRepositoryResource,
-        )
-
-        client_utils = _client_utils
-        old_provider = getattr(client_utils.loaders, "provider", None)
-        old_base_root_url = BaseObjectOrm.ROOT_URL
-        old_resource_root_url = getattr(ClientCodeRepositoryResource, "ROOT_URL", None)
-
-        _set_client_utils_endpoint(client_utils, endpoint)
-        client_utils.loaders.use_jwt(access=access, refresh=refresh or None)
-
-        BaseObjectOrm.ROOT_URL = root_url
-        ClientCodeRepositoryResource.ROOT_URL = root_url
-
-        resource = ClientCodeRepositoryResource.get(pk=resource_uid, timeout=timeout)
-        create_kwargs: dict[str, Any] = {
-            "related_image_uid": related_image_uid,
-            "cpu_request": cpu_request,
-            "memory_request": memory_request,
-            "gpu_request": gpu_request,
-            "gpu_type": gpu_type,
-            "spot": spot,
-            "automatic_deployment": automatic_deployment,
-            "timeout": timeout,
-        }
-
-        create_method = getattr(resource, "create_fastapi", None)
-        if not callable(create_method):
-            raise ApiError("CodeRepositoryResource does not implement create_fastapi().")
-        created = create_method(**create_kwargs)
-
-        if isinstance(created, dict):
-            return created
-        if hasattr(created, "model_dump"):
-            return created.model_dump()
-        return {"uid": getattr(created, "uid", None)}
-
-    except Exception as e:
-        err_name = type(e).__name__
-        if err_name in {"AuthenticationError", "PermissionDeniedError"}:
-            raise NotLoggedIn(str(e) or "Not logged in.") from e
-        if err_name == "NotFoundError":
-            raise ApiError(f"CodeRepository resource not found: {resource_uid}") from e
-        raise ApiError(f"CodeRepository resource release create failed: {e}") from e
-    finally:
-        if client_utils is not None:
-            try:
-                client_utils.loaders.provider = old_provider
-            except Exception:
-                pass
-        if old_base_root_url is not None:
-            try:
-                from mainsequence.client.base import BaseObjectOrm
-
-                BaseObjectOrm.ROOT_URL = old_base_root_url
-            except Exception:
-                pass
-        if old_resource_root_url is not None:
-            try:
-                from mainsequence.client.models_helpers import (
-                    CodeRepositoryResource as ClientCodeRepositoryResource,
-                )
-
-                ClientCodeRepositoryResource.ROOT_URL = old_resource_root_url
-            except Exception:
-                pass
-
-        for k, v in old_env.items():
-            if v is None:
-                os.environ.pop(k, None)
-            else:
-                os.environ[k] = v
 
 
 def list_time_index_tables(
@@ -4476,134 +4236,6 @@ def remove_meta_table_labels(
     )
 
 
-def create_code_repository_job(
-    *,
-    name: str,
-    code_repository_branch_uid: str,
-    execution_path: str | None = None,
-    task_schedule: dict[str, Any] | str | None = None,
-    scheduled_command_args: list[str] | None = None,
-    cpu_request: str | int | float | None = None,
-    memory_request: str | int | float | None = None,
-    gpu_request: str | int | float | None = None,
-    gpu_type: str | None = None,
-    spot: bool | None = None,
-    max_runtime_seconds: int | None = None,
-    related_image_uid: str | None = None,
-    automatic_deployment: bool = False,
-    automatic_redeployment_tag_regex: str | None = None,
-    timeout: int | None = None,
-) -> dict[str, Any]:
-    """
-    Create a CodeRepository job via the SDK client model.
-
-    Single source of truth:
-      - delegates payload construction and request behavior to `Job.create()`
-    """
-    tokens = get_tokens()
-    access = (tokens.get("access") or "").strip()
-    refresh = (tokens.get("refresh") or "").strip()
-    if not access:
-        raise NotLoggedIn("Not logged in.")
-
-    endpoint = backend_url().rstrip("/")
-    root_url = f"{endpoint}/api/v1"
-
-    old_env = {
-        "MAINSEQUENCE_AUTH_MODE": os.environ.get("MAINSEQUENCE_AUTH_MODE"),
-        "MAINSEQUENCE_ACCESS_TOKEN": os.environ.get("MAINSEQUENCE_ACCESS_TOKEN"),
-        "MAINSEQUENCE_REFRESH_TOKEN": os.environ.get("MAINSEQUENCE_REFRESH_TOKEN"),
-        "MAINSEQUENCE_ENDPOINT": os.environ.get("MAINSEQUENCE_ENDPOINT"),
-    }
-
-    client_utils = None
-    old_provider = None
-    old_base_root_url = None
-    old_job_root_url = None
-
-    try:
-        os.environ["MAINSEQUENCE_AUTH_MODE"] = "jwt"
-        os.environ["MAINSEQUENCE_ACCESS_TOKEN"] = access
-        if refresh:
-            os.environ["MAINSEQUENCE_REFRESH_TOKEN"] = refresh
-        else:
-            os.environ.pop("MAINSEQUENCE_REFRESH_TOKEN", None)
-        os.environ["MAINSEQUENCE_ENDPOINT"] = endpoint
-        resolved_branch_uid = resolve_code_repository_branch_uid(code_repository_branch_uid)
-
-        from mainsequence.client import utils as _client_utils
-        from mainsequence.client.base import BaseObjectOrm
-        from mainsequence.client.models_helpers import Job as ClientJob
-
-        client_utils = _client_utils
-        old_provider = getattr(client_utils.loaders, "provider", None)
-        old_base_root_url = BaseObjectOrm.ROOT_URL
-        old_job_root_url = getattr(ClientJob, "ROOT_URL", None)
-
-        _set_client_utils_endpoint(client_utils, endpoint)
-        client_utils.loaders.use_jwt(access=access, refresh=refresh or None)
-
-        BaseObjectOrm.ROOT_URL = root_url
-        ClientJob.ROOT_URL = root_url
-
-        created = ClientJob.create(
-            name=name,
-            code_repository_branch_uid=resolved_branch_uid,
-            execution_path=execution_path,
-            task_schedule=task_schedule,
-            scheduled_command_args=scheduled_command_args,
-            cpu_request=cpu_request,
-            memory_request=memory_request,
-            gpu_request=gpu_request,
-            gpu_type=gpu_type,
-            spot=spot,
-            max_runtime_seconds=max_runtime_seconds,
-            related_image_uid=related_image_uid,
-            automatic_deployment=automatic_deployment,
-            automatic_redeployment_policy={
-                "tag_regex": automatic_redeployment_tag_regex,
-            },
-            timeout=timeout,
-        )
-        if isinstance(created, dict):
-            return created
-        if hasattr(created, "model_dump"):
-            return created.model_dump()
-        return {"uid": getattr(created, "uid", None)}
-
-    except Exception as e:
-        err_name = type(e).__name__
-        if err_name in {"AuthenticationError", "PermissionDeniedError"}:
-            raise NotLoggedIn(str(e) or "Not logged in.") from e
-        if err_name == "NotFoundError":
-            raise ApiError(f"CodeRepositoryBranch not found: {code_repository_branch_uid}") from e
-        raise ApiError(f"CodeRepository job create failed: {e}") from e
-    finally:
-        if client_utils is not None:
-            try:
-                client_utils.loaders.provider = old_provider
-            except Exception:
-                pass
-        if old_base_root_url is not None:
-            try:
-                from mainsequence.client.base import BaseObjectOrm
-
-                BaseObjectOrm.ROOT_URL = old_base_root_url
-            except Exception:
-                pass
-        if old_job_root_url is not None:
-            try:
-                from mainsequence.client.models_helpers import Job as ClientJob
-
-                ClientJob.ROOT_URL = old_job_root_url
-            except Exception:
-                pass
-
-        for k, v in old_env.items():
-            if v is None:
-                os.environ.pop(k, None)
-            else:
-                os.environ[k] = v
 
 
 def update_code_repository_job_scheduled_command_args(