[Summary view] [Print] [Text view]

   1  <?php
   2  
   3  declare (strict_types=1);
   4  namespace WordPress\AiClient\Providers;
   5  
   6  use WordPress\AiClient\Providers\Contracts\ModelMetadataDirectoryInterface;
   7  use WordPress\AiClient\Providers\Contracts\ProviderAvailabilityInterface;
   8  use WordPress\AiClient\Providers\Contracts\ProviderInterface;
   9  use WordPress\AiClient\Providers\DTO\ProviderMetadata;
  10  use WordPress\AiClient\Providers\Models\Contracts\ModelInterface;
  11  use WordPress\AiClient\Providers\Models\DTO\ModelConfig;
  12  use WordPress\AiClient\Providers\Models\DTO\ModelMetadata;
  13  /**
  14   * Base class for a provider.
  15   *
  16   * @since 0.1.0
  17   */
  18  abstract class AbstractProvider implements ProviderInterface
  19  {
  20      /**
  21       * @var array<string, ProviderMetadata> Cache for provider metadata per class.
  22       */
  23      private static array $metadataCache = [];
  24      /**
  25       * @var array<string, ProviderAvailabilityInterface> Cache for provider availability per class.
  26       */
  27      private static array $availabilityCache = [];
  28      /**
  29       * @var array<string, ModelMetadataDirectoryInterface> Cache for model metadata directory per class.
  30       */
  31      private static array $modelMetadataDirectoryCache = [];
  32      /**
  33       * {@inheritDoc}
  34       *
  35       * @since 0.1.0
  36       */
  37      final public static function metadata(): ProviderMetadata
  38      {
  39          $className = static::class;
  40          if (!isset(self::$metadataCache[$className])) {
  41              self::$metadataCache[$className] = static::createProviderMetadata();
  42          }
  43          return self::$metadataCache[$className];
  44      }
  45      /**
  46       * {@inheritDoc}
  47       *
  48       * @since 0.1.0
  49       */
  50      final public static function model(string $modelId, ?ModelConfig $modelConfig = null): ModelInterface
  51      {
  52          $providerMetadata = static::metadata();
  53          $modelMetadata = static::modelMetadataDirectory()->getModelMetadata($modelId);
  54          $model = static::createModel($modelMetadata, $providerMetadata);
  55          if ($modelConfig) {
  56              $model->setConfig($modelConfig);
  57          }
  58          return $model;
  59      }
  60      /**
  61       * {@inheritDoc}
  62       *
  63       * @since 0.1.0
  64       */
  65      final public static function availability(): ProviderAvailabilityInterface
  66      {
  67          $className = static::class;
  68          if (!isset(self::$availabilityCache[$className])) {
  69              self::$availabilityCache[$className] = static::createProviderAvailability();
  70          }
  71          return self::$availabilityCache[$className];
  72      }
  73      /**
  74       * {@inheritDoc}
  75       *
  76       * @since 0.1.0
  77       */
  78      final public static function modelMetadataDirectory(): ModelMetadataDirectoryInterface
  79      {
  80          $className = static::class;
  81          if (!isset(self::$modelMetadataDirectoryCache[$className])) {
  82              self::$modelMetadataDirectoryCache[$className] = static::createModelMetadataDirectory();
  83          }
  84          return self::$modelMetadataDirectoryCache[$className];
  85      }
  86      /**
  87       * Creates a model instance based on the given model metadata and provider metadata.
  88       *
  89       * @since 0.1.0
  90       *
  91       * @param ModelMetadata $modelMetadata The model metadata.
  92       * @param ProviderMetadata $providerMetadata The provider metadata.
  93       * @return ModelInterface The new model instance.
  94       */
  95      abstract protected static function createModel(ModelMetadata $modelMetadata, ProviderMetadata $providerMetadata): ModelInterface;
  96      /**
  97       * Creates the provider metadata instance.
  98       *
  99       * @since 0.1.0
 100       *
 101       * @return ProviderMetadata The provider metadata.
 102       */
 103      abstract protected static function createProviderMetadata(): ProviderMetadata;
 104      /**
 105       * Creates the provider availability instance.
 106       *
 107       * @since 0.1.0
 108       *
 109       * @return ProviderAvailabilityInterface The provider availability.
 110       */
 111      abstract protected static function createProviderAvailability(): ProviderAvailabilityInterface;
 112      /**
 113       * Creates the model metadata directory instance.
 114       *
 115       * @since 0.1.0
 116       *
 117       * @return ModelMetadataDirectoryInterface The model metadata directory.
 118       */
 119      abstract protected static function createModelMetadataDirectory(): ModelMetadataDirectoryInterface;
 120  }