.github/workflows/build.yml

@@ -605,7 +605,7 @@ jobs:
           os: ${{ runner.os }}
 
       - name: Setup PDM
-        uses: pdm-project/setup-pdm@b2472ca4258a9ea3aee813980a0100a2261a42fc # v4.2
+        uses: pdm-project/setup-pdm@deb8d8a4e2a03aabcef6f2cc981923fc6b29ef99 # v4.3
         with:
           python-version-file: .python-version
           version: ${{ env.PDM_VERSION }}

lib/modules/datasource/conda/__snapshots__/index.spec.ts.snap

@@ -156,6 +156,7 @@ exports[`modules/datasource/conda/index > getReleases > processes real data 1`]
       "version": "3.9.3",
     },
     {
+      "releaseTimestamp": "2020-02-28T11:46:01.948Z",
       "version": "3.10.0",
     },
     {

lib/modules/datasource/conda/index.spec.ts

@@ -1,3 +1,4 @@
+import { DateTime } from 'luxon';
 import { getPkgReleases } from '..';
 import { EXTERNAL_HOST_ERROR } from '../../../constants/error-messages';
 import { datasource, defaultRegistryUrl } from './common';
@@ -88,6 +89,7 @@ describe('modules/datasource/conda/index', () => {
           html_url: 'http://anaconda.org/anaconda/pytest',
           dev_url: 'https://github.com/pytest-dev/pytest/',
           versions: ['2.7.0', '2.5.1', '2.6.0'],
+          files: [],
         });
       const config = {
         registryUrls: [
@@ -112,5 +114,154 @@ describe('modules/datasource/conda/index', () => {
         sourceUrl: 'https://github.com/pytest-dev/pytest',
       });
     });
+
+    it('supports channel from prefix.dev with null response', async () => {
+      httpMock
+        .scope('https://prefix.dev/api/graphql')
+        .post('')
+        .reply(200, { data: { package: { variants: null } } });
+
+      const config = {
+        packageName: 'pytest',
+        registryUrls: ['https://prefix.dev/conda-forge'],
+      };
+      const res = await getPkgReleases({
+        ...config,
+        datasource,
+      });
+      expect(res).toBe(null);
+    });
+
+    it('supports channel from prefix.dev with multiple page responses', async () => {
+      // mock files
+      httpMock
+        .scope('https://prefix.dev/api/graphql')
+        .post('')
+        .once()
+        .reply(200, {
+          data: {
+            package: {
+              variants: {
+                pages: 2,
+                page: [
+                  {
+                    version: '0.0.5',
+                    createdAt: DateTime.fromISO(
+                      '2020-02-29T01:40:21Z',
+                    ).toString(),
+                    yankedReason: null,
+                    urls: [{ url: 'https://dev/url', kind: 'DEV' }],
+                  },
+                  {
+                    version: '0.0.5',
+                    createdAt: DateTime.fromISO(
+                      '2020-02-29T01:40:20.840Z',
+                    ).toString(),
+                    yankedReason: null,
+                    urls: [{ url: 'https://home/url', kind: 'HOME' }],
+                  },
+                  {
+                    version: '0.0.5',
+                    createdAt: DateTime.fromISO(
+                      '2020-02-29T01:40:23Z',
+                    ).toString(),
+                    yankedReason: null,
+                  },
+                  {
+                    version: '0.0.56',
+                    createdAt: null,
+                    yankedReason: null,
+                  },
+                ],
+              },
+            },
+          },
+        });
+      httpMock
+        .scope('https://prefix.dev/api/graphql')
+        .post('')
+        .once()
+        .reply(200, {
+          data: {
+            package: {
+              variants: {
+                pages: 2,
+                page: [
+                  {
+                    version: '0.0.7',
+                    createdAt: DateTime.fromISO(
+                      '2020-02-29T01:40:21Z',
+                    ).toString(),
+                    yankedReason: null,
+                  },
+                  {
+                    version: '0.0.8',
+                    createdAt: DateTime.fromISO(
+                      '2020-02-29T01:40:20.840Z',
+                    ).toString(),
+                    yankedReason: null,
+                  },
+                  {
+                    version: '0.0.10',
+                    createdAt: DateTime.fromISO(
+                      '2020-02-29T01:40:23Z',
+                    ).toString(),
+                    yankedReason: null,
+                  },
+                  {
+                    version: '0.0.560',
+                    createdAt: null,
+                    yankedReason: null,
+                  },
+                ],
+              },
+            },
+          },
+        });
+
+      const config = {
+        packageName: 'pytest',
+        registryUrls: ['https://prefix.dev/conda-forge'],
+      };
+      const res = await getPkgReleases({
+        ...config,
+        datasource,
+      });
+      expect(res).toMatchObject({
+        registryUrl: 'https://prefix.dev/conda-forge',
+        homepage: 'https://home/url',
+        sourceUrl: 'https://dev/url',
+        releases: [
+          {
+            isDeprecated: false,
+            releaseTimestamp: '2020-02-29T01:40:21.000Z',
+            version: '0.0.5',
+          },
+          {
+            isDeprecated: false,
+            releaseTimestamp: '2020-02-29T01:40:21.000Z',
+            version: '0.0.7',
+          },
+          {
+            isDeprecated: false,
+            releaseTimestamp: '2020-02-29T01:40:20.840Z',
+            version: '0.0.8',
+          },
+          {
+            isDeprecated: false,
+            releaseTimestamp: '2020-02-29T01:40:23.000Z',
+            version: '0.0.10',
+          },
+          {
+            isDeprecated: false,
+            version: '0.0.56',
+          },
+          {
+            isDeprecated: false,
+            version: '0.0.560',
+          },
+        ],
+      });
+    });
   });
 });

lib/modules/datasource/conda/index.ts

@@ -1,11 +1,14 @@
 import { logger } from '../../../logger';
 import { ExternalHostError } from '../../../types/errors/external-host-error';
+import { coerceArray } from '../../../util/array';
 import { cache } from '../../../util/cache/package/decorator';
 import { HttpError } from '../../../util/http';
-import { joinUrlParts } from '../../../util/url';
+import { Timestamp } from '../../../util/timestamp';
+import { ensureTrailingSlash, joinUrlParts } from '../../../util/url';
 import { Datasource } from '../datasource';
 import type { GetReleasesConfig, Release, ReleaseResult } from '../types';
 import { datasource, defaultRegistryUrl } from './common';
+import * as prefixDev from './prefix-dev';
 import type { CondaPackage } from './types';
 
 export class CondaDatasource extends Datasource {
@@ -43,6 +46,19 @@ export class CondaDatasource extends Datasource {
       return null;
     }
 
+    // fast.prefix.dev is a alias, deprecated, but still running.
+    // We expect registryUrl to be `https://prefix.dev/${channel}` here.
+    if (
+      registryUrl.startsWith('https://prefix.dev/') ||
+      registryUrl.startsWith('https://fast.prefix.dev/')
+    ) {
+      // Since the registryUrl contains at least 3 `/` ,
+      // the channel varitable won't be undefined in any case.
+      const channel = ensureTrailingSlash(registryUrl).split('/').at(-2)!;
+
+      return prefixDev.getReleases(this.http, channel, packageName);
+    }
+
     const url = joinUrlParts(registryUrl, packageName);
 
     const result: ReleaseResult = {
@@ -57,9 +73,16 @@ export class CondaDatasource extends Datasource {
       result.homepage = response.body.html_url;
       result.sourceUrl = response.body.dev_url;
 
+      const releaseDate: Record<string, Timestamp> = {};
+      // we assume all packages are roughly released on the same time
+      for (const file of coerceArray(response.body.files)) {
+        releaseDate[file.version] ??= Timestamp.parse(file.upload_time);
+      }
+
       response.body.versions.forEach((version: string) => {
         const thisRelease: Release = {
           version,
+          releaseTimestamp: releaseDate[version],
         };
         result.releases.push(thisRelease);
       });

lib/modules/datasource/conda/prefix-dev.ts

@@ -0,0 +1,114 @@
+import { logger } from '../../../logger';
+import { isNotNullOrUndefined } from '../../../util/array';
+import type { Http } from '../../../util/http';
+import { MaybeTimestamp } from '../../../util/timestamp';
+import type { Release, ReleaseResult } from '../types';
+import { type File, PagedResponseSchema } from './schema/prefix-dev';
+
+const MAX_PREFIX_DEV_GRAPHQL_PAGE = 100;
+
+const query = `
+query search($channel: String!, $package: String!, $page: Int = 0) {
+  package(channelName: $channel, name: $package) {
+    variants(limit: 500, page: $page) {
+      pages
+      page {
+        createdAt
+        version
+        yankedReason
+        urls {
+          url
+          kind
+        }
+      }
+    }
+  }
+}
+`;
+
+export async function getReleases(
+  http: Http,
+  channel: string,
+  packageName: string,
+): Promise<ReleaseResult | null> {
+  logger.debug(
+    { channel, packageName },
+    'lookup package from prefix.dev graphql API',
+  );
+
+  const files = await getPagedResponse(http, query, {
+    channel,
+    package: packageName,
+  });
+
+  if (!files.length) {
+    return null;
+  }
+
+  let homepage: string | undefined = undefined;
+  let sourceUrl: string | undefined = undefined;
+
+  const releases: Record<string, Release> = {};
+  for (const file of files) {
+    const version = file.version;
+
+    homepage ??= file.urls.HOME;
+    sourceUrl ??= file.urls.DEV;
+
+    releases[version] ??= { version };
+
+    // we assume all packages are roughly released on the same time
+    releases[version].releaseTimestamp =
+      releases[version].releaseTimestamp ??
+      MaybeTimestamp.parse(file.createdAt);
+
+    // if the version has not been marked as deprecated, check other releases packages of the same version
+    if (!releases[version].isDeprecated) {
+      releases[version].isDeprecated = isNotNullOrUndefined(file.yankedReason);
+    }
+  }
+
+  return {
+    homepage,
+    sourceUrl,
+    releases: Object.values(releases),
+  };
+}
+
+async function getPagedResponse(
+  http: Http,
+  query: string,
+  data: any,
+): Promise<File[]> {
+  const result: File[] = [];
+
+  for (let page = 0; page <= MAX_PREFIX_DEV_GRAPHQL_PAGE; page++) {
+    const res = await http.postJson(
+      'https://prefix.dev/api/graphql',
+      {
+        body: {
+          operationName: 'search',
+          query,
+          variables: {
+            ...data,
+            page,
+          },
+        },
+      },
+      PagedResponseSchema,
+    );
+
+    const currentPage = res.body.data.package?.variants;
+    if (!currentPage) {
+      break;
+    }
+
+    result.push(...currentPage.page);
+
+    if (page >= currentPage.pages - 1) {
+      break;
+    }
+  }
+
+  return result;
+}

lib/modules/datasource/conda/readme.md

@@ -1,5 +1,34 @@
-This datasource returns releases from the specified [conda](https://docs.conda.io/en/latest/) registry.
+This datasource returns releases for package from anaconda registry and prefix.dev. Other repositories are not supported currently.
 
-The default registry is `https://api.anaconda.org/package/`, which queries a specific conda channel for a specific package.
+This datasource support following cases:
 
-Use `channel/packageName` as your `depName` when using this datasource.
+Look up `numpy` in `conda-forge` channel on anaconda.
+
+```
+{
+  packageName: 'conda-forge/numpy',
+}
+```
+
+Look up `numpy` in `conda-forge` channel from prefix.dev using API `https://prefix.dev/api/graphql`.
+
+```
+{
+  packageName: 'numpy',
+  registryUrls: ["https://prefix.dev/conda-forge/"]
+}
+```
+
+### Multiple channels support
+
+```
+{
+  packageName: 'some-package',
+  registryUrls: [
+    "https://api.anaconda.org/package/conda-forge/",
+    "https://prefix.dev/conda-forge/",
+  ]
+}
+```
+
+The above example will lookup try to find the package on anaconda first, if the package can not be found on prefix.dev.