devservices 0.0.2__tar.gz → 0.0.4__tar.gz

devservices-0.0.4/LICENSE.md

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

{devservices-0.0.2 → devservices-0.0.4}/PKG-INFO

@@ -1,7 +1,8 @@
 Metadata-Version: 2.1
 Name: devservices
-Version: 0.0.2
+Version: 0.0.4
 Requires-Python: >=3.10
+License-File: LICENSE.md
 Requires-Dist: pyyaml
 Requires-Dist: sentry-devenv
 Provides-Extra: dev

devservices-0.0.4/README.md

@@ -0,0 +1,38 @@
+# devservices
+
+A standalone cli tool used to manage dependencies for services. It simplifies the process of starting, stopping, and managing services for development purposes.
+
+## Overview
+
+`devservices` reads configuration files located in the `devservices` directory of your repository. These configurations define services, their dependencies, and various modes of operation.
+
+## Installation
+
+A system-wide installation can be done by downloading the binary of the latest release
+
+```
+PLATFORM=darwin # Options: darwin/linux
+INSTALL_DIR="$HOME/.local/bin"
+curl -L "https://github.com/getsentry/devservices/releases/download/0.0.4/devservices-$PLATFORM" -o "$INSTALL_DIR/devservices"
+chmod +x "$INSTALL_DIR/devservices"
+```
+
+Alternatively, if the repository you're working in has a python virtualenv, you can simply add this to the requirements-dev.txt:
+
+```
+devservices==0.0.4
+```
+## Usage
+
+devservices provides several commands to manage your services:
+
+### Commands
+
+NOTE: service-name is an optional parameter. If not provided, devservices will attempt to automatically find a devservices configuration in the current directory in order to proceed.
+
+- `devservices start <service-name>`: Start a service and its dependencies.
+- `devservices stop <service-name>`: Stop a service including its dependencies.
+- `devservices status <service-name>`: Display the current status of all services, including their dependencies and ports.
+- `devservices logs <service-name>`: View logs for a specific service.
+- `devservices list-services`: List all available Sentry services.
+- `devservices list-dependencies <service-name>`: List all dependencies for a service and whether they are enabled/disabled.

devservices-0.0.4/devservices/commands/check_for_update.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+import json
+from urllib.request import urlopen
+
+
+def check_for_update(current_version: str) -> str | None:
+    url = "https://api.github.com/repos/getsentry/devservices/releases/latest"
+    with urlopen(url) as response:
+        if response.status == 200:
+            data = json.loads(response.read().decode("utf-8"))
+            latest_version = str(data["tag_name"])
+            return latest_version
+    return None

devservices-0.0.4/devservices/commands/list_services.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+from argparse import _SubParsersAction
+from argparse import ArgumentParser
+from argparse import Namespace
+
+from devservices.utils.devenv import get_coderoot
+from devservices.utils.docker_compose import get_active_docker_compose_projects
+from devservices.utils.services import get_local_services
+
+
+def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
+    parser = subparsers.add_parser(
+        "list-services", help="List the services installed locally", aliases=["ls"]
+    )
+    parser.add_argument(
+        "-a",
+        "--all",
+        action="store_true",
+        help="Show all services, including stopped ones",
+    )
+    parser.set_defaults(func=list_services)
+
+
+def list_services(args: Namespace) -> None:
+    """List the services installed locally."""
+
+    # Get all of the services installed locally
+    coderoot = get_coderoot()
+    services = get_local_services(coderoot)
+    running_projects = get_active_docker_compose_projects()
+
+    if not services:
+        print("No services found")
+        return
+
+    services_to_show = (
+        services if args.all else [s for s in services if s.name in running_projects]
+    )
+
+    if args.all:
+        print("Services installed locally:")
+    else:
+        print("Running services:")
+
+    for service in services_to_show:
+        status = "running" if service.name in running_projects else "stopped"
+        print(f"- {service.name}")
+        print(f"  status: {status}")
+        print(f"  location: {service.repo_path}")
+
+    if not args.all:
+        stopped_count = len(services) - len(services_to_show)
+        if stopped_count > 0:
+            print(
+                f"\n{stopped_count} stopped service(s) not shown. Use --all/-a to see them."
+            )

{devservices-0.0.2 → devservices-0.0.4}/devservices/commands/logs.py

@@ -1,13 +1,10 @@
 from __future__ import annotations
 
-import os
 import sys
 from argparse import _SubParsersAction
 from argparse import ArgumentParser
 from argparse import Namespace
 
-from devservices.constants import DEVSERVICES_DIR_NAME
-from devservices.constants import DOCKER_COMPOSE_FILE_NAME
 from devservices.exceptions import DockerComposeError
 from devservices.utils.docker_compose import run_docker_compose_command
 from devservices.utils.services import find_matching_service
@@ -32,19 +29,17 @@ def logs(args: Namespace) -> None:
     except Exception as e:
         print(e)
         exit(1)
+
     modes = service.config.modes
     # TODO: allow custom modes to be used
     mode_to_use = "default"
-    mode_dependencies = " ".join(modes[mode_to_use])
-    service_config_file_path = os.path.join(
-        service.repo_path, DEVSERVICES_DIR_NAME, DOCKER_COMPOSE_FILE_NAME
-    )
+    mode_dependencies = modes[mode_to_use]
+
     try:
-        logs = run_docker_compose_command(
-            f"-f {service_config_file_path} logs {mode_dependencies}"
-        )
+        logs = run_docker_compose_command(service, "logs", mode_dependencies)
     except DockerComposeError as dce:
         print(f"Failed to get logs for {service.name}: {dce.stderr}")
         exit(1)
-    sys.stdout.write(logs.stdout)
-    sys.stdout.flush()
+    for log in logs:
+        sys.stdout.write(log.stdout)
+        sys.stdout.flush()

{devservices-0.0.2 → devservices-0.0.4}/devservices/commands/start.py

@@ -1,12 +1,9 @@
 from __future__ import annotations
 
-import os
 from argparse import _SubParsersAction
 from argparse import ArgumentParser
 from argparse import Namespace
 
-from devservices.constants import DEVSERVICES_DIR_NAME
-from devservices.constants import DOCKER_COMPOSE_FILE_NAME
 from devservices.exceptions import DockerComposeError
 from devservices.utils.console import Status
 from devservices.utils.docker_compose import run_docker_compose_command
@@ -29,17 +26,16 @@ def start(args: Namespace) -> None:
     except Exception as e:
         print(e)
         exit(1)
+
     modes = service.config.modes
     # TODO: allow custom modes to be used
     mode_to_start = "default"
-    mode_dependencies = " ".join(modes[mode_to_start])
-    service_config_file_path = os.path.join(
-        service.repo_path, DEVSERVICES_DIR_NAME, DOCKER_COMPOSE_FILE_NAME
-    )
+    mode_dependencies = modes[mode_to_start]
+
     with Status(f"Starting {service.name}", f"{service.name} started") as status:
         try:
             run_docker_compose_command(
-                f"-f {service_config_file_path} up -d {mode_dependencies}"
+                service, "up", mode_dependencies, ["-d"], force_update_dependencies=True
             )
         except DockerComposeError as dce:
             status.print(f"Failed to start {service.name}: {dce.stderr}")

{devservices-0.0.2 → devservices-0.0.4}/devservices/commands/status.py

@@ -1,14 +1,11 @@
 from __future__ import annotations
 
 import json
-import os
 import sys
 from argparse import _SubParsersAction
 from argparse import ArgumentParser
 from argparse import Namespace
 
-from devservices.constants import DEVSERVICES_DIR_NAME
-from devservices.constants import DOCKER_COMPOSE_FILE_NAME
 from devservices.exceptions import DockerComposeError
 from devservices.utils.docker_compose import run_docker_compose_command
 from devservices.utils.services import find_matching_service
@@ -49,7 +46,7 @@ def format_status_output(status_json: str) -> str:
             output.append("Ports:")
             for port in ports:
                 output.append(
-                    f"  {port['PublishedPort']} -> {port['TargetPort']}/{port['Protocol']}"
+                    f"  {port['URL']}:{port['PublishedPort']} -> {port['TargetPort']}/{port['Protocol']}"
                 )
         else:
             output.append("No ports exposed")
@@ -67,26 +64,26 @@ def status(args: Namespace) -> None:
     except Exception as e:
         print(e)
         exit(1)
+
     modes = service.config.modes
     # TODO: allow custom modes to be used
     mode_to_view = "default"
-    mode_dependencies = " ".join(modes[mode_to_view])
-    service_config_file_path = os.path.join(
-        service.repo_path, DEVSERVICES_DIR_NAME, DOCKER_COMPOSE_FILE_NAME
-    )
+    mode_dependencies = modes[mode_to_view]
+
     try:
-        status_json = run_docker_compose_command(
-            f"-f {service_config_file_path} ps {mode_dependencies} --format json"
-        ).stdout
+        status_jsons = run_docker_compose_command(
+            service, "ps", mode_dependencies, options=["--format", "json"]
+        )
     except DockerComposeError as dce:
         print(f"Failed to get status for {service.name}: {dce.stderr}")
         exit(1)
     # If the service is not running, the status_json will be empty
-    if not status_json:
+    if len(status_jsons) == 0:
         print(f"{service.name} is not running")
         return
     output = f"Service: {service.name}\n\n"
-    output += format_status_output(status_json)
+    for status_json in status_jsons:
+        output += format_status_output(status_json.stdout)
     output += "=" * LINE_LENGTH
     sys.stdout.write(output + "\n")
     sys.stdout.flush()

{devservices-0.0.2 → devservices-0.0.4}/devservices/commands/stop.py

@@ -1,12 +1,9 @@
 from __future__ import annotations
 
-import os
 from argparse import _SubParsersAction
 from argparse import ArgumentParser
 from argparse import Namespace
 
-from devservices.constants import DEVSERVICES_DIR_NAME
-from devservices.constants import DOCKER_COMPOSE_FILE_NAME
 from devservices.exceptions import DockerComposeError
 from devservices.utils.console import Status
 from devservices.utils.docker_compose import run_docker_compose_command
@@ -29,18 +26,15 @@ def stop(args: Namespace) -> None:
     except Exception as e:
         print(e)
         exit(1)
+
     modes = service.config.modes
     # TODO: allow custom modes to be used
     mode_to_stop = "default"
-    mode_dependencies = " ".join(modes[mode_to_stop])
-    service_config_file_path = os.path.join(
-        service.repo_path, DEVSERVICES_DIR_NAME, DOCKER_COMPOSE_FILE_NAME
-    )
+    mode_dependencies = modes[mode_to_stop]
+
     with Status(f"Stopping {service.name}", f"{service.name} stopped") as status:
         try:
-            run_docker_compose_command(
-                f"-f {service_config_file_path} down {mode_dependencies}"
-            )
+            run_docker_compose_command(service, "down", mode_dependencies)
         except DockerComposeError as dce:
             status.print(f"Failed to stop {service.name}: {dce.stderr}")
             exit(1)

devservices-0.0.4/devservices/commands/update.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import platform
+import sys
+from argparse import _SubParsersAction
+from argparse import ArgumentParser
+from argparse import Namespace
+from importlib import metadata
+
+from devservices.commands.check_for_update import check_for_update
+from devservices.constants import DEVSERVICES_DOWNLOAD_URL
+from devservices.exceptions import BinaryInstallError
+from devservices.exceptions import DevservicesUpdateError
+from devservices.utils.install_binary import install_binary
+
+
+def is_in_virtualenv() -> bool:
+    return hasattr(sys, "real_prefix") or (
+        hasattr(sys, "base_prefix") and sys.base_prefix != sys.prefix
+    )
+
+
+def update_version(exec_path: str, latest_version: str) -> None:
+    system = platform.system().lower()
+    url = f"{DEVSERVICES_DOWNLOAD_URL}/{latest_version}/devservices-{system}"
+    try:
+        install_binary("devservices", exec_path, latest_version, url)
+    except BinaryInstallError as e:
+        raise DevservicesUpdateError(f"Failed to update devservices: {e}")
+
+    print(f"Devservices {latest_version} updated successfully")
+
+
+def add_parser(subparsers: _SubParsersAction[ArgumentParser]) -> None:
+    parser = subparsers.add_parser(
+        "update", help="update devservices to the latest version"
+    )
+    parser.set_defaults(func=update)
+
+
+def update(args: Namespace) -> None:
+    current_version = metadata.version("devservices")
+    latest_version = check_for_update(current_version)
+
+    if latest_version is None:
+        raise DevservicesUpdateError("Failed to check for updates.")
+
+    if latest_version == current_version:
+        print("You're already on the latest version.")
+        return
+
+    print(f"A new version of devservices is available: {latest_version}")
+
+    if is_in_virtualenv():
+        print("You are running in a virtual environment.")
+        print(
+            "To update, please update your requirements.txt or requirements-dev.txt file with the new version."
+        )
+        print(
+            f"For example, update the line in requirements.txt to: devservices=={latest_version}"
+        )
+        print("Then, run: pip install --update -r requirements.txt")
+        return
+
+    print("Upgrading to the latest version...")
+    update_version(sys.executable, latest_version)

{devservices-0.0.2 → devservices-0.0.4}/devservices/configs/service_config.py

@@ -2,11 +2,12 @@ from __future__ import annotations
 
 import os
 from dataclasses import dataclass
+from dataclasses import fields
 
 import yaml
 
+from devservices.constants import CONFIG_FILE_NAME
 from devservices.constants import DEVSERVICES_DIR_NAME
-from devservices.constants import DOCKER_COMPOSE_FILE_NAME
 from devservices.exceptions import ConfigNotFoundError
 from devservices.exceptions import ConfigParseError
 from devservices.exceptions import ConfigValidationError
@@ -14,10 +15,18 @@ from devservices.exceptions import ConfigValidationError
 VALID_VERSIONS = [0.1]
 
 
+@dataclass
+class RemoteConfig:
+    repo_name: str
+    branch: str
+    repo_link: str
+    mode: str = "default"
+
+
 @dataclass
 class Dependency:
     description: str
-    link: str | None = None
+    remote: RemoteConfig | None = None
 
 
 @dataclass
@@ -56,9 +65,7 @@ class ServiceConfig:
 
 
 def load_service_config_from_file(repo_path: str) -> ServiceConfig:
-    config_path = os.path.join(
-        repo_path, DEVSERVICES_DIR_NAME, DOCKER_COMPOSE_FILE_NAME
-    )
+    config_path = os.path.join(repo_path, DEVSERVICES_DIR_NAME, CONFIG_FILE_NAME)
     if not os.path.exists(config_path):
         raise ConfigNotFoundError(f"Config file not found in directory: {config_path}")
     with open(config_path, "r") as stream:
@@ -75,11 +82,23 @@ def load_service_config_from_file(repo_path: str) -> ServiceConfig:
             )
         service_config_data = config.get("x-sentry-service-config")
 
+        valid_dependency_keys = {field.name for field in fields(Dependency)}
+
+        dependencies = {}
+
         try:
-            dependencies = {
-                key: Dependency(**value)
-                for key, value in service_config_data.get("dependencies", {}).items()
-            }
+            for key, value in service_config_data.get("dependencies", {}).items():
+                unexpected_keys = set(value.keys()) - valid_dependency_keys
+                if unexpected_keys:
+                    raise ConfigParseError(
+                        f"Unexpected key(s) in dependency '{key}': {unexpected_keys}"
+                    )
+                dependencies[key] = Dependency(
+                    description=value.get("description"),
+                    remote=RemoteConfig(**value.get("remote"))
+                    if "remote" in value
+                    else None,
+                )
         except TypeError as type_error:
             raise ConfigParseError(
                 f"Error parsing service dependencies: {type_error}"

devservices-0.0.4/devservices/constants.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import os
+
+MINIMUM_DOCKER_COMPOSE_VERSION = "2.29.7"
+DEVSERVICES_DIR_NAME = "devservices"
+CONFIG_FILE_NAME = "config.yml"
+DOCKER_USER_PLUGIN_DIR = os.path.expanduser("~/.docker/cli-plugins/")
+
+DEVSERVICES_CACHE_DIR = os.path.expanduser("~/.cache/sentry-devservices")
+DEVSERVICES_LOCAL_DIR = os.path.expanduser("~/.local/share/sentry-devservices")
+DEVSERVICES_DEPENDENCIES_CACHE_DIR = os.path.join(DEVSERVICES_CACHE_DIR, "dependencies")
+DEVSERVICES_DEPENDENCIES_CACHE_DIR_KEY = "DEVSERVICES_DEPENDENCIES_CACHE_DIR"
+
+DEPENDENCY_CONFIG_VERSION = "v1"
+DEPENDENCY_GIT_PARTIAL_CLONE_CONFIG_OPTIONS = {
+    "protocol.version": "2",
+    "extensions.partialClone": "true",
+    "core.sparseCheckout": "true",
+}
+
+DOCKER_COMPOSE_DOWNLOAD_URL = "https://github.com/docker/compose/releases/download"
+DEVSERVICES_DOWNLOAD_URL = "https://github.com/getsentry/devservices/releases/download"
+BINARY_PERMISSIONS = 0o755