airbyte.sources.registry

 78class ConnectorMetadata(BaseModel):
 79    """Metadata for a connector."""
 80
 81    name: str
 82    """Connector name. For example, "source-google-sheets"."""
 83
 84    display_name: str | None = None
 85    """Human-readable connector name."""
 86
 87    connector_type: str | None = None
 88    """Connector type: `source` or `destination`."""
 89
 90    definition_id: str | None = None
 91    """Source or destination definition ID."""
 92
 93    docker_repository: str | None = None
 94    """Docker repository for the connector image."""
 95
 96    latest_available_version: str | None
 97    """The latest available version of the connector."""
 98
 99    pypi_package_name: str | None
100    """The name of the PyPI package for the connector, if it exists."""
101
102    language: Language | None
103    """The language of the connector."""
104
105    install_types: set[InstallType]
106    """The supported install types for the connector."""
107
108    suggested_streams: list[str] | None = None
109    """A list of suggested streams for the connector, if available."""
110
111    support_level: str | None = None
112    """Connector support level."""
113
114    release_stage: str | None = None
115    """Connector release stage."""
116
117    source_type: str | None = None
118    """Connector subtype."""
119
120    documentation_url: str | None = None
121    """Connector documentation URL."""
122
123    release_date: str | None = None
124    """Connector release date."""
125
126    github_issue_label: str | None = None
127    """GitHub issue label for the connector."""
128
129    @property
130    def default_install_type(self) -> InstallType:
131        """Return the default install type for the connector."""
132        if self.language == Language.MANIFEST_ONLY and InstallType.YAML in self.install_types:
133            return InstallType.YAML
134
135        if InstallType.PYTHON in self.install_types:
136            return InstallType.PYTHON
137
138        # Else: Java or Docker
139        return InstallType.DOCKER

49class InstallType(str, Enum):
50    """The type of installation for a connector."""
51
52    YAML = "yaml"
53    """Manifest-only connectors that can be run without Docker."""
54    PYTHON = "python"
55    """Python-based connectors available via PyPI."""
56    DOCKER = "docker"
57    """Docker-based connectors (returns all connectors for backward compatibility)."""
58    JAVA = "java"
59    """Java-based connectors."""
60
61    INSTALLABLE = "installable"
62    """Connectors installable in the current environment (environment-sensitive).
63
64    Returns all connectors if Docker is installed, otherwise only Python and YAML.
65    """
66    ANY = "any"
67    """All connectors in the registry (environment-independent)."""

70class Language(str, Enum):
71    """The language of a connector."""
72
73    PYTHON = InstallType.PYTHON.value
74    JAVA = InstallType.JAVA.value
75    MANIFEST_ONLY = _MANIFEST_ONLY_LANGUAGE

293def get_available_connectors(
294    install_type: InstallType | str | None = InstallType.INSTALLABLE,
295) -> list[str]:
296    """Return a list of all available connectors.
297
298    Connectors will be returned in alphabetical order, with the standard prefix "source-".
299
300    Args:
301        install_type: The type of installation for the connector.
302            Defaults to `InstallType.INSTALLABLE`.
303    """
304    if install_type is None or install_type == InstallType.INSTALLABLE:
305        # Filter for installable connectors (default behavior).
306        if is_docker_installed():
307            logger.info("Docker is detected. Returning all connectors.")
308            return sorted(_get_registry_cache().keys())
309
310        logger.info("Docker was not detected. Returning only Python and Manifest-only connectors.")
311        return sorted(
312            [
313                connector_name
314                for connector_name, conn_info in _get_registry_cache().items()
315                if conn_info.language in {Language.PYTHON, Language.MANIFEST_ONLY}
316            ]
317        )
318
319    if not isinstance(install_type, InstallType):
320        install_type = InstallType(install_type)
321
322    if install_type == InstallType.PYTHON:
323        return sorted(
324            connector_name
325            for connector_name, conn_info in _get_registry_cache().items()
326            if conn_info.pypi_package_name is not None
327        )
328
329    if install_type == InstallType.JAVA:
330        warnings.warn(
331            message="Java connectors are not yet supported.",
332            stacklevel=2,
333        )
334        return sorted(
335            connector_name
336            for connector_name, conn_info in _get_registry_cache().items()
337            if conn_info.language == Language.JAVA
338        )
339
340    if install_type in {InstallType.DOCKER, InstallType.ANY}:
341        return sorted(_get_registry_cache().keys())
342
343    if install_type == InstallType.YAML:
344        return sorted(
345            conn.name
346            for conn in _get_registry_cache().values()
347            if InstallType.YAML in conn.install_types
348        )
349
350    # pragma: no cover  # Should never be reached.
351    raise exc.PyAirbyteInputError(
352        message="Invalid install type.",
353        context={
354            "install_type": install_type,
355        },
356    )

263def get_connector_metadata(name: str) -> ConnectorMetadata | None:
264    """Check the cache for the connector.
265
266    If the cache is empty, populate by calling update_cache.
267    """
268    registry_url = _get_registry_url()
269
270    if _is_registry_disabled(registry_url):
271        return None
272
273    cache = copy(_get_registry_cache())
274
275    if not cache:
276        raise exc.PyAirbyteInternalError(
277            message="Connector registry could not be loaded.",
278            context={
279                "registry_url": _get_registry_url(),
280            },
281        )
282    if name not in cache:
283        raise exc.AirbyteConnectorNotRegisteredError(
284            connector_name=name,
285            context={
286                "registry_url": _get_registry_url(),
287                "available_connectors": get_available_connectors(),
288            },
289        )
290    return cache[name]