diff --git a/README.md b/README.md
index cc87916b..e3df8118 100644
--- a/README.md
+++ b/README.md
@@ -29,6 +29,7 @@ PulpUI is a community driven single-page application that talks to a running [pu
 ### Plugins
 - Ansible (repositories, remotes, collections, namespaces, approvals, imports)
 - File (repositories, remotes)
+- Python (repositories, remotes, packages)
 - RPM (repositories, remotes, content)
 - Container (execution environments, tags, manifests)
 
diff --git a/e2e/smoke/pages.spec.ts b/e2e/smoke/pages.spec.ts
index c51b7975..3e55d511 100644
--- a/e2e/smoke/pages.spec.ts
+++ b/e2e/smoke/pages.spec.ts
@@ -55,6 +55,39 @@ test.describe('pages of a signed-in session', () => {
     await expect(page.locator('#architectures')).toBeVisible();
   });
 
+  test('Python repositories', async ({ page }) => {
+    await page.goto('python/repositories');
+    await expect(title(page, 'Repositories')).toBeVisible();
+    await expect(page.getByText('No repositories yet')).toBeVisible();
+
+    // pulp_python repositories can refuse package substitution, so the form
+    // carries settings the other plugins have no use for
+    await page.getByRole('button', { name: 'Add repository' }).click();
+    await expect(page.locator('#allow_package_substitution')).toBeVisible();
+    await expect(page.locator('#error_on_reject')).toBeVisible();
+  });
+
+  test('Python remotes', async ({ page }) => {
+    await page.goto('python/remotes');
+    await expect(title(page, 'Remotes')).toBeVisible();
+    await expect(page.getByText('No remotes yet')).toBeVisible();
+
+    // a Python remote filters what it syncs by project, package type and
+    // platform, and offers the download policy
+    await page.getByRole('button', { name: 'Add remote' }).click();
+    await expect(page.locator('#includes')).toBeVisible();
+    await expect(page.locator('#excludes')).toBeVisible();
+    await expect(page.locator('#keep_latest_packages')).toBeVisible();
+    await expect(page.locator('#package_types_sdist')).toBeVisible();
+    await expect(page.locator('#policy')).toHaveValue('on_demand');
+  });
+
+  test('Python packages', async ({ page }) => {
+    await page.goto('python/packages');
+    await expect(title(page, 'Packages')).toBeVisible();
+    await expect(page.getByText('No packages yet')).toBeVisible();
+  });
+
   test('RPM repositories', async ({ page }) => {
     await page.goto('rpm/repositories');
     await expect(title(page, 'Repositories')).toBeVisible();
diff --git a/src/actions/index.ts b/src/actions/index.ts
index 3c949376..d20bd577 100644
--- a/src/actions/index.ts
+++ b/src/actions/index.ts
@@ -27,6 +27,13 @@ export { fileRepositoryCreateAction } from './file-repository-create';
 export { fileRepositoryDeleteAction } from './file-repository-delete';
 export { fileRepositoryEditAction } from './file-repository-edit';
 export { fileRepositorySyncAction } from './file-repository-sync';
+export { pythonRemoteCreateAction } from './python-remote-create';
+export { pythonRemoteDeleteAction } from './python-remote-delete';
+export { pythonRemoteEditAction } from './python-remote-edit';
+export { pythonRepositoryCreateAction } from './python-repository-create';
+export { pythonRepositoryDeleteAction } from './python-repository-delete';
+export { pythonRepositoryEditAction } from './python-repository-edit';
+export { pythonRepositorySyncAction } from './python-repository-sync';
 export { rpmRemoteCreateAction } from './rpm-remote-create';
 export { rpmRemoteDeleteAction } from './rpm-remote-delete';
 export { rpmRemoteEditAction } from './rpm-remote-edit';
diff --git a/src/actions/python-remote-create.tsx b/src/actions/python-remote-create.tsx
new file mode 100644
index 00000000..37dc42cc
--- /dev/null
+++ b/src/actions/python-remote-create.tsx
@@ -0,0 +1,9 @@
+import { msg } from '@lingui/core/macro';
+import { Paths, formatPath } from 'src/paths';
+import { Action } from './action';
+
+export const pythonRemoteCreateAction = Action({
+  title: msg`Add remote`,
+  onClick: (item, { navigate }) =>
+    navigate(formatPath(Paths.python.remote.edit, { name: '_' })),
+});
diff --git a/src/actions/python-remote-delete.tsx b/src/actions/python-remote-delete.tsx
new file mode 100644
index 00000000..ce78c167
--- /dev/null
+++ b/src/actions/python-remote-delete.tsx
@@ -0,0 +1,44 @@
+import { msg, t } from '@lingui/core/macro';
+import { PythonRemoteAPI } from 'src/api';
+import { DeleteRemoteModal } from 'src/components';
+import {
+  handleHttpError,
+  parsePulpIDFromURL,
+  taskAlert,
+  waitForTaskUrl,
+} from 'src/utilities';
+import { Action } from './action';
+
+export const pythonRemoteDeleteAction = Action({
+  title: msg`Delete`,
+  modal: ({ addAlert, listQuery, setState, state }) =>
+    state.deleteModalOpen ? (
+      <DeleteRemoteModal
+        closeAction={() => setState({ deleteModalOpen: null })}
+        deleteAction={() =>
+          deleteRemote(state.deleteModalOpen, { addAlert, setState, listQuery })
+        }
+        name={state.deleteModalOpen.name}
+      />
+    ) : null,
+  onClick: (
+    { name, id, pulp_href }: { name: string; id?: string; pulp_href?: string },
+    { setState },
+  ) =>
+    setState({
+      deleteModalOpen: { pulpId: id || parsePulpIDFromURL(pulp_href), name },
+    }),
+});
+
+function deleteRemote({ name, pulpId }, { addAlert, setState, listQuery }) {
+  return PythonRemoteAPI.delete(pulpId)
+    .then(({ data }) => {
+      addAlert(taskAlert(data.task, t`Removal started for remote ${name}`));
+      setState({ deleteModalOpen: null });
+      return waitForTaskUrl(data.task);
+    })
+    .then(() => listQuery())
+    .catch(
+      handleHttpError(t`Failed to remove remote ${name}`, () => null, addAlert),
+    );
+}
diff --git a/src/actions/python-remote-edit.tsx b/src/actions/python-remote-edit.tsx
new file mode 100644
index 00000000..00a16de0
--- /dev/null
+++ b/src/actions/python-remote-edit.tsx
@@ -0,0 +1,9 @@
+import { msg } from '@lingui/core/macro';
+import { Paths, formatPath } from 'src/paths';
+import { Action } from './action';
+
+export const pythonRemoteEditAction = Action({
+  title: msg`Edit`,
+  onClick: ({ name }, { navigate }) =>
+    navigate(formatPath(Paths.python.remote.edit, { name })),
+});
diff --git a/src/actions/python-repository-create.tsx b/src/actions/python-repository-create.tsx
new file mode 100644
index 00000000..8c18cc61
--- /dev/null
+++ b/src/actions/python-repository-create.tsx
@@ -0,0 +1,9 @@
+import { msg } from '@lingui/core/macro';
+import { Paths, formatPath } from 'src/paths';
+import { Action } from './action';
+
+export const pythonRepositoryCreateAction = Action({
+  title: msg`Add repository`,
+  onClick: (item, { navigate }) =>
+    navigate(formatPath(Paths.python.repository.edit, { name: '_' })),
+});
diff --git a/src/actions/python-repository-delete.tsx b/src/actions/python-repository-delete.tsx
new file mode 100644
index 00000000..d7fe52d9
--- /dev/null
+++ b/src/actions/python-repository-delete.tsx
@@ -0,0 +1,123 @@
+import { msg, t } from '@lingui/core/macro';
+import { PythonDistributionAPI, PythonRepositoryAPI } from 'src/api';
+import { DeleteRepositoryModal } from 'src/components';
+import {
+  handleHttpError,
+  parsePulpIDFromURL,
+  taskAlert,
+  waitForTaskUrl,
+} from 'src/utilities';
+import { Action } from './action';
+
+export const pythonRepositoryDeleteAction = Action({
+  title: msg`Delete`,
+  modal: ({ addAlert, listQuery, setState, state }) =>
+    state.deleteModalOpen ? (
+      <DeleteRepositoryModal
+        closeAction={() => setState({ deleteModalOpen: null })}
+        deleteAction={() =>
+          deleteRepository(state.deleteModalOpen, {
+            addAlert,
+            listQuery,
+            setState,
+          })
+        }
+        name={state.deleteModalOpen.name}
+      />
+    ) : null,
+  onClick: (
+    { name, id, pulp_href }: { name: string; id?: string; pulp_href?: string },
+    { setState },
+  ) =>
+    setState({
+      deleteModalOpen: {
+        pulpId: id || parsePulpIDFromURL(pulp_href),
+        name,
+        pulp_href,
+      },
+    }),
+});
+
+const DISTRIBUTION_PAGE_SIZE = 100;
+
+// A repository can be serving more distributions than a single page holds, and
+// any the lookup misses are left pointing at a repository that no longer exists.
+async function listDistributions(repository) {
+  const distributions = [];
+  let page = 1;
+  let count = Infinity;
+
+  while (distributions.length < count) {
+    const { data } = await PythonDistributionAPI.list({
+      repository,
+      page,
+      page_size: DISTRIBUTION_PAGE_SIZE,
+    });
+
+    // Also stops the loop should count ever disagree with what the pages return.
+    if (!data.results?.length) {
+      break;
+    }
+
+    distributions.push(...data.results);
+    count = data.count;
+    page++;
+  }
+
+  return distributions;
+}
+
+async function deleteRepository(
+  { name, pulp_href, pulpId },
+  { addAlert, setState, listQuery },
+) {
+  const distributionsToDelete = await listDistributions(pulp_href).catch(
+    (e) => {
+      handleHttpError(
+        t`Failed to list distributions, removing only the repository.`,
+        () => null,
+        addAlert,
+      )(e);
+      return [];
+    },
+  );
+
+  const deleteRepo = PythonRepositoryAPI.delete(pulpId)
+    .then(({ data }) => {
+      addAlert(taskAlert(data.task, t`Removal started for repository ${name}`));
+      return waitForTaskUrl(data.task);
+    })
+    .catch(
+      handleHttpError(
+        t`Failed to remove repository ${name}`,
+        () => setState({ deleteModalOpen: null }),
+        addAlert,
+      ),
+    );
+
+  const deleteDistribution = ({ name, pulp_href }) => {
+    const distribution_id = parsePulpIDFromURL(pulp_href);
+    return PythonDistributionAPI.delete(distribution_id)
+      .then(({ data }) => {
+        addAlert(
+          taskAlert(data.task, t`Removal started for distribution ${name}`),
+        );
+        return waitForTaskUrl(data.task);
+      })
+      .catch(
+        handleHttpError(
+          t`Failed to remove distribution ${name}`,
+          () => null,
+          addAlert,
+        ),
+      );
+  };
+
+  return Promise.all([
+    deleteRepo,
+    ...distributionsToDelete.map(deleteDistribution),
+  ]).then(() => {
+    setState({ deleteModalOpen: null });
+    listQuery();
+  });
+}
diff --git a/src/actions/python-repository-edit.tsx b/src/actions/python-repository-edit.tsx
new file mode 100644
index 00000000..ee8c7adc
--- /dev/null
+++ b/src/actions/python-repository-edit.tsx
@@ -0,0 +1,9 @@
+import { msg } from '@lingui/core/macro';
+import { Paths, formatPath } from 'src/paths';
+import { Action } from './action';
+
+export const pythonRepositoryEditAction = Action({
+  title: msg`Edit`,
+  onClick: ({ name }, { navigate }) =>
+    navigate(formatPath(Paths.python.repository.edit, { name })),
+});
diff --git a/src/actions/python-repository-sync.tsx b/src/actions/python-repository-sync.tsx
new file mode 100644
index 00000000..0ae25fc7
--- /dev/null
+++ b/src/actions/python-repository-sync.tsx
@@ -0,0 +1,63 @@
+import { msg, t } from '@lingui/core/macro';
+import { PythonRepositoryAPI } from 'src/api';
+import { SyncModal } from 'src/components';
+import { handleHttpError, parsePulpIDFromURL, taskAlert } from 'src/utilities';
+import { Action } from './action';
+
+// pulp_python syncs additively unless mirror is requested. Mirroring deletes
+// local content the remote no longer has, so it is the direction to opt into
+// rather than out of, as for deb.
+const MIRROR_BY_DEFAULT = false;
+
+export const pythonRepositorySyncAction = Action({
+  title: msg`Sync`,
+  modal: ({ addAlert, query, setState, state }) =>
+    state.syncModalOpen ? (
+      <SyncModal
+        closeAction={() => setState({ syncModalOpen: null })}
+        defaultMirror={MIRROR_BY_DEFAULT}
+        showOptimize={false}
+        syncAction={(syncParams) =>
+          syncRepository(state.syncModalOpen, { addAlert, query }, syncParams)
+        }
+        name={state.syncModalOpen.name}
+      />
+    ) : null,
+  onClick: ({ name, pulp_href }, { setState }) =>
+    setState({
+      syncModalOpen: { name, pulp_href },
+    }),
+  visible: (_item, { hasPermission }) =>
+    hasPermission('python.change_pythonrepository'),
+  disabled: ({ remote, last_sync_task }) => {
+    if (!remote) {
+      return t`There are no remotes associated with this repository.`;
+    }
+
+    if (
+      last_sync_task &&
+      ['running', 'waiting'].includes(last_sync_task.state)
+    ) {
+      return t`Sync task is already queued.`;
+    }
+  },
+});
+
+function syncRepository({ name, pulp_href }, { addAlert, query }, syncParams) {
+  const pulpId = parsePulpIDFromURL(pulp_href);
+  return PythonRepositoryAPI.sync(pulpId, {
+    mirror: syncParams?.mirror ?? MIRROR_BY_DEFAULT,
+  })
+    .then(({ data }) => {
+      addAlert(taskAlert(data.task, t`Sync started for repository "${name}".`));
+
+      query();
+    })
+    .catch(
+      handleHttpError(
+        t`Failed to sync repository "${name}"`,
+        () => null,
+        addAlert,
+      ),
+    );
+}
diff --git a/src/api/index.ts b/src/api/index.ts
index 9e7b2efd..2e69b565 100644
--- a/src/api/index.ts
+++ b/src/api/index.ts
@@ -77,6 +77,18 @@ export {
   type UserType,
 } from './response-types/user';
 export { RoleAPI } from './role';
+export { PythonDistributionAPI } from './python-distribution';
+export {
+  PythonRemoteAPI,
+  type PythonPackageType,
+  type PythonPlatform,
+  type PythonRemoteType,
+} from './python-remote';
+export {
+  PythonRepositoryAPI,
+  type PythonRepositoryType,
+} from './python-repository';
+export { PythonPackageAPI } from './python-package';
 export { RPMPackageAPI } from './rpm-package';
 export { RPMDistributionAPI } from './rpm-distribution';
 export { RPMRemoteAPI, type RPMRemoteType } from './rpm-remote';
diff --git a/src/api/python-distribution.ts b/src/api/python-distribution.ts
new file mode 100644
index 00000000..f200e930
--- /dev/null
+++ b/src/api/python-distribution.ts
@@ -0,0 +1,11 @@
+import { PulpAPI } from './pulp';
+
+const base = new PulpAPI();
+
+export const PythonDistributionAPI = {
+  create: (data) => base.http.post(`distributions/python/pypi/`, data),
+
+  delete: (id) => base.http.delete(`distributions/python/pypi/${id}/`),
+
+  list: (params?) => base.list(`distributions/python/pypi/`, params),
+};
diff --git a/src/api/python-package.ts b/src/api/python-package.ts
new file mode 100644
index 00000000..1e66e542
--- /dev/null
+++ b/src/api/python-package.ts
@@ -0,0 +1,7 @@
+import { PulpAPI } from './pulp';
+
+const base = new PulpAPI();
+
+export const PythonPackageAPI = {
+  list: (params?) => base.list(`content/python/packages/`, params),
+};
diff --git a/src/api/python-remote.ts b/src/api/python-remote.ts
new file mode 100644
index 00000000..312b6152
--- /dev/null
+++ b/src/api/python-remote.ts
@@ -0,0 +1,67 @@
+import type { GenericRemote } from './common';
+import { PulpAPI } from './pulp';
+
+type PythonPackageType =
+  | 'bdist_dmg'
+  | 'bdist_dumb'
+  | 'bdist_egg'
+  | 'bdist_msi'
+  | 'bdist_rpm'
+  | 'bdist_wheel'
+  | 'bdist_wininst'
+  | 'sdist';
+type PythonPlatform = 'windows' | 'macos' | 'freebsd' | 'linux';
+
+/**
+ * Python Remote Type.
+ *
+ * @see https://github.com/pulp/pulp_python/blob/main/pulp_python/app/serializers.py
+ */
+interface PythonRemoteType extends GenericRemote {
+  includes?: string[];
+  excludes?: string[];
+  prereleases?: boolean;
+  package_types?: PythonPackageType[];
+  keep_latest_packages?: number;
+  exclude_platforms?: PythonPlatform[];
+  provenance?: boolean;
+}
+
+// as in deb-remote / file-remote
+function smartUpdate(
+  remote: PythonRemoteType,
+  unmodifiedRemote: PythonRemoteType,
+) {
+  for (const field of Object.keys(remote)) {
+    if (remote[field] === '') {
+      remote[field] = null;
+    }
+
+    // API returns headers:null but doesn't accept it .. and we don't edit headers
+    if (remote[field] === null && unmodifiedRemote[field] === null) {
+      delete remote[field];
+    }
+  }
+
+  return remote;
+}
+
+const base = new PulpAPI();
+
+export const PythonRemoteAPI = {
+  create: (data) => base.http.post(`remotes/python/python/`, data),
+
+  delete: (id) => base.http.delete(`remotes/python/python/${id}/`),
+
+  get: (id) => base.http.get(`remotes/python/python/${id}/`),
+
+  list: (params?) => base.list(`remotes/python/python/`, params),
+
+  smartUpdate: (id, newValue: PythonRemoteType, oldValue: PythonRemoteType) =>
+    base.http.put(
+      `remotes/python/python/${id}/`,
+      smartUpdate(newValue, oldValue),
+    ),
+};
+
+export type { PythonPackageType, PythonPlatform, PythonRemoteType };
diff --git a/src/api/python-repository.ts b/src/api/python-repository.ts
new file mode 100644
index 00000000..d434bc2b
--- /dev/null
+++ b/src/api/python-repository.ts
@@ -0,0 +1,40 @@
+import type { GenericRepository } from './common';
+import { PulpAPI } from './pulp';
+
+/**
+ * Python Repository Type.
+ *
+ * @see https://github.com/pulp/pulp_python/blob/main/pulp_python/app/serializers.py
+ */
+interface PythonRepositoryType extends GenericRepository {
+  /** @deprecated by pulp_python; not offered in the UI */
+  autopublish?: boolean;
+  allow_package_substitution?: boolean;
+  error_on_reject?: boolean;
+}
+
+const base = new PulpAPI();
+
+export const PythonRepositoryAPI = {
+  create: (data) => base.http.post(`repositories/python/python/`, data),
+
+  delete: (id) => base.http.delete(`repositories/python/python/${id}/`),
+
+  list: (params?) => base.list(`repositories/python/python/`, params),
+
+  listVersions: (id: string, params?) =>
+    base.list(`repositories/python/python/${id}/versions/`, params),
+
+  revert: (id: string, version_href) =>
+    base.http.post(`repositories/python/python/${id}/modify/`, {
+      base_version: version_href,
+    }),
+
+  sync: (id: string, body = {}) =>
+    base.http.post(`repositories/python/python/${id}/sync/`, body),
+
+  update: (id: string, data) =>
+    base.http.put(`repositories/python/python/${id}/`, data),
+};
+
+export type { PythonRepositoryType };
diff --git a/src/app-routes.tsx b/src/app-routes.tsx
index 986a5cf7..fa8a25ba 100644
--- a/src/app-routes.tsx
+++ b/src/app-routes.tsx
@@ -55,6 +55,13 @@ import {
   NamespaceDetail,
   Partners,
   PulpStatus,
+  PythonPackageList,
+  PythonRemoteDetail,
+  PythonRemoteEdit,
+  PythonRemoteList,
+  PythonRepositoryDetail,
+  PythonRepositoryEdit,
+  PythonRepositoryList,
   RPMPackageList,
   RPMRemoteDetail,
   RPMRemoteEdit,
@@ -350,6 +357,34 @@ const routes: IRouteConfig[] = [
     path: Paths.meta.about,
     noAuth: true,
   },
+  {
+    component: PythonPackageList,
+    path: Paths.python.package.list,
+  },
+  {
+    component: PythonRemoteDetail,
+    path: Paths.python.remote.detail,
+  },
+  {
+    component: PythonRemoteEdit,
+    path: Paths.python.remote.edit,
+  },
+  {
+    component: PythonRemoteList,
+    path: Paths.python.remote.list,
+  },
+  {
+    component: PythonRepositoryDetail,
+    path: Paths.python.repository.detail,
+  },
+  {
+    component: PythonRepositoryEdit,
+    path: Paths.python.repository.edit,
+  },
+  {
+    component: PythonRepositoryList,
+    path: Paths.python.repository.list,
+  },
   {
     component: RPMPackageList,
     path: Paths.rpm.package.list,
diff --git a/src/components/lazy-repositories.tsx b/src/components/lazy-repositories.tsx
index b3aaf150..c444b08b 100644
--- a/src/components/lazy-repositories.tsx
+++ b/src/components/lazy-repositories.tsx
@@ -14,7 +14,7 @@ export const LazyRepositories = ({
 }: {
   content_href?: string;
   emptyText?: string;
-  plugin: 'ansible' | 'deb' | 'file' | 'rpm';
+  plugin: 'ansible' | 'deb' | 'file' | 'python' | 'rpm';
   remote_href?: string;
 }) => {
   const [repositories, setRepositories] = useState([]);
diff --git a/src/components/remote-form.tsx b/src/components/remote-form.tsx
index 9cde8cac..97e06b22 100644
--- a/src/components/remote-form.tsx
+++ b/src/components/remote-form.tsx
@@ -15,6 +15,7 @@ import {
   InputGroupItem,
   Modal,
   Switch,
+  TextArea,
   TextInput,
 } from '@patternfly/react-core';
 import DownloadIcon from '@patternfly/react-icons/dist/esm/icons/download-icon';
@@ -37,13 +38,13 @@ import {
 
 // Plugins whose remotes offer a download policy in this form. pulp_file and
 // pulp_deb accept the same three policies; add them here once tested.
-const PLUGINS_WITH_POLICY = ['rpm'];
+const PLUGINS_WITH_POLICY = ['python', 'rpm'];
 
 interface IProps {
   allowEditName?: boolean;
   closeModal: () => void;
   errorMessages: ErrorMessagesType;
-  plugin: 'ansible' | 'container' | 'deb' | 'file' | 'rpm';
+  plugin: 'ansible' | 'container' | 'deb' | 'file' | 'python' | 'rpm';
   remote: RemoteType;
   saveRemote: () => void;
   showMain?: boolean;
@@ -197,6 +198,7 @@ export class RemoteForm extends Component<IProps, IState> {
       case 'container':
       case 'deb':
       case 'file':
+      case 'python':
       case 'rpm':
         disabledFields = disabledFields.concat([
           'auth_url',
@@ -371,6 +373,183 @@ export class RemoteForm extends Component<IProps, IState> {
             </FormFieldHelper>
           </FormGroup>
         )}
+
+        {plugin === 'python' ? (
+          <>
+            {(['includes', 'excludes'] as const).map((field) => (
+              <FormGroup
+                key={field}
+                fieldId={field}
+                label={field === 'includes' ? t`Includes` : t`Excludes`}
+                labelIcon={
+                  <HelpButton
+                    content={
+                      field === 'includes'
+                        ? t`Projects to sync, one specifier per line, for example "django>=4.2". Leave empty to sync every project the remote offers.`
+                        : t`Projects to skip, one specifier per line, for example "django<4". Applied after includes.`
+                    }
+                  />
+                }
+              >
+                <TextArea
+                  validated={field in errorMessages ? 'error' : 'default'}
+                  id={field}
+                  placeholder={'django>=4.2\nrequests'}
+                  value={(remote[field] || []).join('\n')}
+                  onChange={(_event, value) =>
+                    this.updateRemote(value.split('\n'), field)
+                  }
+                  autoResize
+                />
+                <FormFieldHelper
+                  variant={field in errorMessages ? 'error' : 'default'}
+                >
+                  {errorMessages[field]}
+                </FormFieldHelper>
+              </FormGroup>
+            ))}
+
+            <FormGroup
+              fieldId={'prereleases'}
+              label={t`Pre-releases`}
+              labelIcon={
+                <HelpButton
+                  content={t`Whether to include pre-release versions in the sync.`}
+                />
+              }
+            >
+              <Checkbox
+                id='prereleases'
+                isChecked={!!remote['prereleases']}
+                onChange={(_event, value) =>
+                  this.updateRemote(value, 'prereleases')
+                }
+                label={t`Include pre-release versions`}
+              />
+            </FormGroup>
+
+            <FormGroup
+              fieldId={'package_types'}
+              label={t`Package types`}
+              labelIcon={
+                <HelpButton
+                  content={t`Package types to sync. Leave all unticked to sync every type.`}
+                />
+              }
+            >
+              {[
+                'sdist',
+                'bdist_wheel',
+                'bdist_egg',
+                'bdist_dumb',
+                'bdist_rpm',
+                'bdist_msi',
+                'bdist_wininst',
+                'bdist_dmg',
+              ].map((type) => (
+                <Checkbox
+                  key={type}
+                  id={`package_types_${type}`}
+                  label={type}
+                  isChecked={(remote['package_types'] || []).includes(type)}
+                  onChange={(_event, checked) =>
+                    this.updateRemote(
+                      checked
+                        ? [...(remote['package_types'] || []), type]
+                        : (remote['package_types'] || []).filter(
+                            (t) => t !== type,
+                          ),
+                      'package_types',
+                    )
+                  }
+                />
+              ))}
+            </FormGroup>
+
+            <FormGroup
+              fieldId={'keep_latest_packages'}
+              label={t`Latest versions kept per package`}
+              labelIcon={
+                <HelpButton
+                  content={t`How many of the newest versions of each package to sync, including pre-releases if those are synced. Leave blank to keep all versions.`}
+                />
+              }
+            >
+              <TextInput
+                validated={
+                  'keep_latest_packages' in errorMessages ? 'error' : 'default'
+                }
+                id='keep_latest_packages'
+                type='number'
+                value={remote['keep_latest_packages'] || ''}
+                onChange={(_event, value) =>
+                  this.updateRemote(
+                    value === '' ? 0 : Number(value),
+                    'keep_latest_packages',
+                  )
+                }
+              />
+              <FormFieldHelper
+                variant={
+                  'keep_latest_packages' in errorMessages ? 'error' : 'default'
+                }
+              >
+                {errorMessages['keep_latest_packages']}
+              </FormFieldHelper>
+            </FormGroup>
+
+            <FormGroup
+              fieldId={'exclude_platforms'}
+              label={t`Excluded platforms`}
+              labelIcon={
+                <HelpButton
+                  content={t`Platforms whose packages should not be synced.`}
+                />
+              }
+            >
+              {['windows', 'macos', 'freebsd', 'linux'].map((platform) => (
+                <Checkbox
+                  key={platform}
+                  id={`exclude_platforms_${platform}`}
+                  label={platform}
+                  isChecked={(remote['exclude_platforms'] || []).includes(
+                    platform,
+                  )}
+                  onChange={(_event, checked) =>
+                    this.updateRemote(
+                      checked
+                        ? [...(remote['exclude_platforms'] || []), platform]
+                        : (remote['exclude_platforms'] || []).filter(
+                            (p) => p !== platform,
+                          ),
+                      'exclude_platforms',
+                    )
+                  }
+                />
+              ))}
+            </FormGroup>
+
+            <FormGroup
+              fieldId={'provenance'}
+              label={t`Provenance`}
+              labelIcon={
+                <HelpButton
+                  content={t`Whether to also sync the provenance attestations published for packages.`}
+                />
+              }
+            >
+              <Checkbox
+                id='provenance'
+                isChecked={!!remote['provenance']}
+                onChange={(_event, value) =>
+                  this.updateRemote(value, 'provenance')
+                }
+                label={t`Sync package provenance`}
+              />
+            </FormGroup>
+          </>
+        ) : null}
+
         {plugin === 'deb' ? (
           <>
             <FormGroup
diff --git a/src/components/repository-form.tsx b/src/components/repository-form.tsx
index 18ca9bbc..fe5c5323 100644
--- a/src/components/repository-form.tsx
+++ b/src/components/repository-form.tsx
@@ -41,7 +41,7 @@ interface IProps {
   onSave: (options: {
     distribution: { basePath: string } | null;
   }) => void | Promise<void>;
-  plugin: 'ansible' | 'deb' | 'file' | 'rpm';
+  plugin: 'ansible' | 'deb' | 'file' | 'python' | 'rpm';
   repository: AnsibleRepositoryType;
   updateRepository: (r) => void;
 }
@@ -227,6 +227,40 @@ export const RepositoryForm = ({
         </>
       )}
 
+      {plugin === 'python' && (
+        <>
+          {formGroup(
+            'allow_package_substitution',
+            t`Allow package substitution`,
+            t`Allow replacing an existing package with one that has the same filename but a different checksum. When off, any new repository version that would cause such a substitution is rejected, whether from sync, upload or modify.`,
+            <Checkbox
+              id='allow_package_substitution'
+              isChecked={repository['allow_package_substitution'] !== false}
+              onChange={(_event, value) =>
+                updateRepository({
+                  ...repository,
+                  allow_package_substitution: value,
+                })
+              }
+              label={t`Allow same-filename packages with different contents`}
+            />,
+          )}
+          {formGroup(
+            'error_on_reject',
+            t`Fail on rejected packages`,
+            t`When on, a rejected package fails the whole repository version and nothing is added. When off, rejected packages are skipped, the rest are added, and the skipped ones are listed in the task's progress report.`,
+            <Checkbox
+              id='error_on_reject'
+              isChecked={repository['error_on_reject'] !== false}
+              onChange={(_event, value) =>
+                updateRepository({ ...repository, error_on_reject: value })
+              }
+              label={t`Fail the whole version if any package is rejected`}
+            />,
+          )}
+        </>
+      )}
+
       {formGroup(
         'distributions',
         t`Distributions`,
diff --git a/src/components/sync-modal.tsx b/src/components/sync-modal.tsx
index 180f9578..cd6bf00b 100644
--- a/src/components/sync-modal.tsx
+++ b/src/components/sync-modal.tsx
@@ -15,6 +15,8 @@ interface IProps {
   // Which way the mirror switch starts. Plugins disagree: pulp_deb's API defaults
   // a sync to not mirroring, where ansible and file have always offered to.
   defaultMirror?: boolean;
+  // pulp_python's sync has no optimize option
+  showOptimize?: boolean;
   syncAction: (syncParams) => Promise<void>;
   name: string;
   // When given, a sync policy dropdown replaces the mirror switch (pulp_rpm).
@@ -27,6 +29,7 @@ export const SyncModal = ({
   defaultMirror = true,
   defaultSyncPolicy,
   syncPolicies,
+  showOptimize = true,
   syncAction,
   name,
 }: IProps) => {
@@ -120,24 +123,28 @@ export const SyncModal = ({
         </FormGroup>
       )}
       <br />
-      <FormGroup
-        label={t`Optimize`}
-        labelIcon={
-          <HelpButton
-            content={t`Only perform the sync if changes are reported by the remote server. To force a sync to happen, deselect this option.`}
-          />
-        }
-      >
-        <Switch
-          isChecked={syncParams.optimize}
-          onChange={(_event, optimize) =>
-            setSyncParams({ ...syncParams, optimize })
-          }
-          label={t`Only perform the sync if changes are reported by the remote server.`}
-          labelOff={t`Force a sync to happen.`}
-        />
-      </FormGroup>
-      <br />
+      {showOptimize && (
+        <>
+          <FormGroup
+            label={t`Optimize`}
+            labelIcon={
+              <HelpButton
+                content={t`Only perform the sync if changes are reported by the remote server. To force a sync to happen, deselect this option.`}
+              />
+            }
+          >
+            <Switch
+              isChecked={syncParams.optimize}
+              onChange={(_event, optimize) =>
+                setSyncParams({ ...syncParams, optimize })
+              }
+              label={t`Only perform the sync if changes are reported by the remote server.`}
+              labelOff={t`Force a sync to happen.`}
+            />
+          </FormGroup>
+          <br />
+        </>
+      )}
     </Modal>
   );
 };
diff --git a/src/containers/index.ts b/src/containers/index.ts
index e29d45b6..1116e64f 100644
--- a/src/containers/index.ts
+++ b/src/containers/index.ts
@@ -43,6 +43,13 @@ export { default as PulpStatus } from './pulp-status';
 export { default as RoleCreate } from './role-management/role-create';
 export { default as EditRole } from './role-management/role-edit';
 export { default as RoleList } from './role-management/role-list';
+export { default as PythonRemoteDetail } from './python-remote/detail';
+export { default as PythonRemoteEdit } from './python-remote/edit';
+export { default as PythonRemoteList } from './python-remote/list';
+export { default as PythonRepositoryDetail } from './python-repository/detail';
+export { default as PythonRepositoryEdit } from './python-repository/edit';
+export { default as PythonRepositoryList } from './python-repository/list';
+export { default as PythonPackageList } from './python/package-list';
 export { default as RPMPackageList } from './rpm/package-list';
 export { default as RPMRemoteDetail } from './rpm-remote/detail';
 export { default as RPMRemoteEdit } from './rpm-remote/edit';
diff --git a/src/containers/python-remote/detail.tsx b/src/containers/python-remote/detail.tsx
new file mode 100644
index 00000000..38d29164
--- /dev/null
+++ b/src/containers/python-remote/detail.tsx
@@ -0,0 +1,48 @@
+import { msg, t } from '@lingui/core/macro';
+import { pythonRemoteDeleteAction, pythonRemoteEditAction } from 'src/actions';
+import { PythonRemoteAPI, type PythonRemoteType } from 'src/api';
+import { PageWithTabs } from 'src/components';
+import { Paths, formatPath } from 'src/paths';
+import { DetailsTab } from './tab-details';
+
+const PythonRemoteDetail = PageWithTabs<PythonRemoteType>({
+  breadcrumbs: ({ name }) =>
+    [
+      { url: formatPath(Paths.python.remote.list), name: t`Remotes` },
+      { url: formatPath(Paths.python.remote.detail, { name }), name },
+    ].filter(Boolean),
+  displayName: 'PythonRemoteDetail',
+  errorTitle: msg`Remote could not be displayed.`,
+  headerActions: [pythonRemoteEditAction, pythonRemoteDeleteAction],
+  listUrl: formatPath(Paths.python.remote.list),
+  query: ({ name }) =>
+    PythonRemoteAPI.list({ name, page_size: 1 }).then(({ data }) => {
+      const remote = data?.results?.[0];
+
+      // There is no detail endpoint keyed by name, so a name matching nothing
+      // answers 200 with an empty list. Turn that into the 404 the page already
+      // knows how to render, instead of resolving with undefined.
+      if (!remote) {
+        return Promise.reject({ response: { status: 404 } });
+      }
+
+      return remote;
+    }),
+  renderTab: (tab, item, actionContext) =>
+    ({
+      details: <DetailsTab item={item} actionContext={actionContext} />,
+    })[tab],
+  tabs: (tab, name) => [
+    {
+      active: tab === 'details',
+      title: t`Details`,
+      link: formatPath(
+        Paths.python.remote.detail,
+        { name },
+        { tab: 'details' },
+      ),
+    },
+  ],
+});
+
+export default PythonRemoteDetail;
diff --git a/src/containers/python-remote/edit.test.tsx b/src/containers/python-remote/edit.test.tsx
new file mode 100644
index 00000000..e4fd09d5
--- /dev/null
+++ b/src/containers/python-remote/edit.test.tsx
@@ -0,0 +1,223 @@
+import { screen, waitFor } from '@testing-library/react';
+import { HttpResponse, http } from 'msw';
+import { Route, Routes, useLocation } from 'react-router';
+import { beforeEach, describe, expect, it } from 'vitest';
+import { AppContextProvider } from 'src/app-context';
+import { Paths } from 'src/paths';
+import { listOf, remote } from 'src/test-utils/pulp';
+import { renderWithProviders } from 'src/test-utils/render';
+import { server } from 'src/test-utils/server';
+import PythonRemoteEdit from './edit';
+
+const API = '/pulp/api/v3';
+const TASK_HREF = `${API}/tasks/00000000-0000-4000-8000-0000000000cc/`;
+
+let bodies: Record<string, unknown>[];
+
+beforeEach(() => {
+  bodies = [];
+});
+
+// Shows where the application ended up after a save.
+function Where() {
+  const { pathname } = useLocation();
+  return <p data-testid='where'>{pathname}</p>;
+}
+
+function renderEdit(route: string) {
+  return renderWithProviders(
+    <AppContextProvider>
+      <Routes>
+        <Route path={Paths.python.remote.edit} element={<PythonRemoteEdit />} />
+        <Route path={Paths.python.remote.detail} element={<Where />} />
+      </Routes>
+    </AppContextProvider>,
+    { route },
+  );
+}
+
+function serveCreate() {
+  server.use(
+    http.post(`*${API}/remotes/python/python/`, async ({ request }) => {
+      bodies.push((await request.json()) as Record<string, unknown>);
+      return HttpResponse.json(
+        { pulp_href: `${API}/remotes/python/python/1/` },
+        { status: 201 },
+      );
+    }),
+  );
+}
+
+function serveExisting(existing: ReturnType<typeof remote>) {
+  server.use(
+    listOf(`${API}/remotes/python/python/`, [existing], {
+      matching: (row, query) => row.name === query.get('name'),
+    }).handler,
+    http.put(`*${API}/remotes/python/python/:id/`, async ({ request }) => {
+      bodies.push((await request.json()) as Record<string, unknown>);
+      return HttpResponse.json({ task: TASK_HREF }, { status: 202 });
+    }),
+  );
+}
+
+const policy = () =>
+  screen.getByRole('combobox', {
+    name: /Download policy/,
+  }) as HTMLSelectElement;
+const includes = () => screen.getByRole('textbox', { name: /^Includes/ });
+const excludes = () => screen.getByRole('textbox', { name: /^Excludes/ });
+const save = () => screen.getByRole('button', { name: 'Save' });
+
+async function fillNewRemote(user: ReturnType<typeof renderEdit>['user']) {
+  await user.type(
+    await screen.findByRole('textbox', { name: /^Name/ }),
+    'zz-test-python',
+  );
+  await user.type(
+    screen.getByRole('textbox', { name: /^URL/ }),
+    'https://pypi.example/',
+  );
+}
+
+describe('creating a Python remote', () => {
+  it('offers the immediate, on demand and streamed download policies', async () => {
+    renderEdit('/python/remotes/edit/_');
+
+    await screen.findByRole('textbox', { name: /^Name/ });
+    expect(
+      Array.from(policy().options).map((option) => option.value),
+    ).toStrictEqual(['immediate', 'on_demand', 'streamed']);
+  });
+
+  it('sends the on demand policy when the user never touches the select', async () => {
+    serveCreate();
+    const { user } = renderEdit('/python/remotes/edit/_');
+
+    await fillNewRemote(user);
+    expect(policy().value).toBe('on_demand');
+    await user.click(save());
+
+    await waitFor(() =>
+      expect(screen.getByTestId('where')).toHaveTextContent(
+        '/python/remotes/detail/zz-test-python',
+      ),
+    );
+    expect(bodies).toHaveLength(1);
+    expect(bodies[0]).toMatchObject({
+      name: 'zz-test-python',
+      policy: 'on_demand',
+    });
+  });
+
+  it('sends the policy the user picked', async () => {
+    serveCreate();
+    const { user } = renderEdit('/python/remotes/edit/_');
+
+    await fillNewRemote(user);
+    await user.selectOptions(policy(), 'streamed');
+    await user.click(save());
+
+    await waitFor(() =>
+      expect(screen.getByTestId('where')).toBeInTheDocument(),
+    );
+    expect(bodies[0]).toMatchObject({ policy: 'streamed' });
+  });
+
+  it('sends includes and excludes trimmed, without blank lines and in the order typed', async () => {
+    serveCreate();
+    const { user } = renderEdit('/python/remotes/edit/_');
+
+    await fillNewRemote(user);
+    await user.type(includes(), '  django  {Enter}{Enter}requests');
+    await user.type(excludes(), 'zz-last{Enter}  aa-first  {Enter}');
+    await user.click(save());
+
+    await waitFor(() =>
+      expect(screen.getByTestId('where')).toBeInTheDocument(),
+    );
+    expect(bodies[0]['includes']).toStrictEqual(['django', 'requests']);
+    expect(bodies[0]['excludes']).toStrictEqual(['zz-last', 'aa-first']);
+  });
+
+  it('leaves repeated entries to the server instead of merging them', async () => {
+    serveCreate();
+    const { user } = renderEdit('/python/remotes/edit/_');
+
+    await fillNewRemote(user);
+    await user.type(includes(), 'django{Enter} django {Enter}django>=4');
+    await user.click(save());
+
+    await waitFor(() =>
+      expect(screen.getByTestId('where')).toBeInTheDocument(),
+    );
+    expect(bodies[0]['includes']).toStrictEqual([
+      'django',
+      'django',
+      'django>=4',
+    ]);
+  });
+
+  it('sends a cleared includes field as an empty list, never a list holding an empty string', async () => {
+    serveCreate();
+    const { user } = renderEdit('/python/remotes/edit/_');
+
+    await fillNewRemote(user);
+    await user.type(includes(), 'django');
+    await user.clear(includes());
+    await user.click(save());
+
+    await waitFor(() =>
+      expect(screen.getByTestId('where')).toBeInTheDocument(),
+    );
+    expect(bodies[0]['includes']).toStrictEqual([]);
+  });
+});
+
+describe('editing a Python remote', () => {
+  it('shows the stored policy and sends it back unchanged', async () => {
+    serveExisting(
+      remote({
+        name: 'existing',
+        policy: 'immediate',
+        includes: ['django'],
+        excludes: [],
+      }),
+    );
+    const { user } = renderEdit('/python/remotes/edit/existing');
+
+    await screen.findByDisplayValue('existing');
+    expect(policy().value).toBe('immediate');
+    await user.click(save());
+
+    await waitFor(() =>
+      expect(screen.getByTestId('where')).toHaveTextContent(
+        '/python/remotes/detail/existing',
+      ),
+    );
+    expect(bodies).toHaveLength(1);
+    expect(bodies[0]).toMatchObject({ policy: 'immediate' });
+  });
+
+  it('sends a cleared excludes field as an empty list', async () => {
+    serveExisting(
+      remote({
+        name: 'existing',
+        policy: 'streamed',
+        includes: [],
+        excludes: ['django<4'],
+      }),
+    );
+    const { user } = renderEdit('/python/remotes/edit/existing');
+
+    await screen.findByDisplayValue('existing');
+    expect(excludes()).toHaveValue('django<4');
+    await user.clear(excludes());
+    await user.click(save());
+
+    await waitFor(() =>
+      expect(screen.getByTestId('where')).toBeInTheDocument(),
+    );
+    expect(bodies[0]['excludes']).toStrictEqual([]);
+    expect(bodies[0]).toMatchObject({ policy: 'streamed' });
+  });
+});
diff --git a/src/containers/python-remote/edit.tsx b/src/containers/python-remote/edit.tsx
new file mode 100644
index 00000000..677d0ca8
--- /dev/null
+++ b/src/containers/python-remote/edit.tsx
@@ -0,0 +1,159 @@
+import { msg, t } from '@lingui/core/macro';
+import { PythonRemoteAPI, type PythonRemoteType } from 'src/api';
+import { Page, RemoteForm } from 'src/components';
+import { Paths, formatPath } from 'src/paths';
+import { parsePulpIDFromURL, taskAlert } from 'src/utilities';
+
+const initialRemote: PythonRemoteType = {
+  name: '',
+  url: '',
+  ca_cert: null,
+  client_cert: null,
+  tls_validation: true,
+  proxy_url: null,
+  download_concurrency: null,
+  rate_limit: null,
+  // pulp_python's own default; set here so the form's display fallback never
+  // decides what is sent
+  policy: 'on_demand',
+  hidden_fields: [
+    'client_key',
+    'proxy_username',
+    'proxy_password',
+    'username',
+    'password',
+  ].map((name) => ({ name, is_set: false })),
+};
+
+const PythonRemoteEdit = Page<PythonRemoteType>({
+  breadcrumbs: ({ name }) =>
+    [
+      { url: formatPath(Paths.python.remote.list), name: t`Remotes` },
+      name && { url: formatPath(Paths.python.remote.detail, { name }), name },
+      name ? { name: t`Edit` } : { name: t`Add` },
+    ].filter(Boolean),
+
+  displayName: 'PythonRemoteEdit',
+  errorTitle: msg`Remote could not be displayed.`,
+  listUrl: formatPath(Paths.python.remote.list),
+  query: ({ name }) =>
+    PythonRemoteAPI.list({ name }).then(({ data: { results } }) => results[0]),
+  title: ({ name }) => name || t`Add new remote`,
+  transformParams: ({ name, ...rest }) => ({
+    ...rest,
+    name: name !== '_' ? name : null,
+  }),
+
+  render: (item, { navigate, queueAlert, state, setState }) => {
+    if (!state.remoteToEdit) {
+      const remoteToEdit = {
+        ...initialRemote,
+        ...item,
+      };
+      setState({ remoteToEdit, errorMessages: {} });
+    }
+
+    const { remoteToEdit, errorMessages } = state;
+    if (!remoteToEdit) {
+      return null;
+    }
+
+    const saveRemote = () => {
+      const { remoteToEdit } = state;
+
+      const data = { ...remoteToEdit };
+
+      // Includes and excludes are edited one specifier per line; drop blank
+      // lines and surrounding whitespace before sending them to Pulp.
+      for (const field of ['includes', 'excludes'] as const) {
+        if (Array.isArray(data[field])) {
+          data[field] = data[field].map((s) => s.trim()).filter(Boolean);
+        }
+      }
+
+      if (!item) {
+        // prevent "This field may not be blank." when writing in and then deleting username/password/etc
+        // only when creating, edit diffs with item
+        Object.keys(data).forEach((k) => {
+          if (data[k] === '' || data[k] == null) {
+            delete data[k];
+          }
+        });
+
+        delete data.hidden_fields;
+      }
+
+      delete data.my_permissions;
+
+      // api requires traling slash, fix the trivial case
+      if (data.url && !data.url.includes('?') && !data.url.endsWith('/')) {
+        data.url += '/';
+      }
+
+      const promise = !item
+        ? PythonRemoteAPI.create(data)
+        : PythonRemoteAPI.smartUpdate(
+            parsePulpIDFromURL(item.pulp_href),
+            data,
+            item,
+          );
+
+      promise
+        .then(({ data: task }) => {
+          setState({
+            errorMessages: {},
+            remoteToEdit: undefined,
+          });
+
+          queueAlert(
+            item
+              ? taskAlert(task, t`Update started for remote ${data.name}`)
+              : {
+                  variant: 'success',
+                  title: t`Successfully created remote ${data.name}`,
+                },
+          );
+
+          navigate(
+            formatPath(Paths.python.remote.detail, {
+              name: data.name,
+            }),
+          );
+        })
+        .catch(({ response: { data } }) =>
+          setState({
+            errorMessages: {
+              __nofield: data.non_field_errors || data.detail,
+              ...data,
+            },
+          }),
+        );
+    };
+
+    const closeModal = () => {
+      setState({ errorMessages: {}, remoteToEdit: undefined });
+      navigate(
+        item
+          ? formatPath(Paths.python.remote.detail, {
+              name: item.name,
+            })
+          : formatPath(Paths.python.remote.list),
+      );
+    };
+
+    return (
+      <RemoteForm
+        allowEditName={!item}
+        closeModal={closeModal}
+        errorMessages={errorMessages}
+        plugin='python'
+        remote={remoteToEdit}
+        saveRemote={saveRemote}
+        showMain
+        updateRemote={(r) => setState({ remoteToEdit: r })}
+      />
+    );
+  },
+});
+
+export default PythonRemoteEdit;
diff --git a/src/containers/python-remote/list.tsx b/src/containers/python-remote/list.tsx
new file mode 100644
index 00000000..160066d9
--- /dev/null
+++ b/src/containers/python-remote/list.tsx
@@ -0,0 +1,81 @@
+import { msg, t } from '@lingui/core/macro';
+import { Td, Tr } from '@patternfly/react-table';
+import { Link } from 'react-router';
+import {
+  pythonRemoteCreateAction,
+  pythonRemoteDeleteAction,
+  pythonRemoteEditAction,
+} from 'src/actions';
+import { PythonRemoteAPI, type PythonRemoteType } from 'src/api';
+import { CopyURL, ListItemActions, ListPage } from 'src/components';
+import { Paths, formatPath } from 'src/paths';
+import { parsePulpIDFromURL } from 'src/utilities';
+
+const listItemActions = [
+  // Edit
+  pythonRemoteEditAction,
+  // Delete
+  pythonRemoteDeleteAction,
+];
+
+const PythonRemoteList = ListPage<PythonRemoteType>({
+  defaultPageSize: 10,
+  defaultSort: '-pulp_created',
+  displayName: 'PythonRemoteList',
+  errorTitle: msg`Remotes could not be displayed.`,
+  filterConfig: () => [
+    {
+      id: 'name__icontains',
+      title: t`Remote name`,
+    },
+  ],
+  headerActions: [pythonRemoteCreateAction], // Add remote
+  listItemActions,
+  noDataButton: pythonRemoteCreateAction.button,
+  noDataDescription: msg`Remotes will appear once created.`,
+  noDataTitle: msg`No remotes yet`,
+  query: ({ params }) => PythonRemoteAPI.list(params),
+  renderTableRow(item: PythonRemoteType, index: number, actionContext) {
+    const { name, policy, pulp_href, url } = item;
+    const id = parsePulpIDFromURL(pulp_href);
+
+    const kebabItems = listItemActions.map((action) =>
+      action.dropdownItem({ ...item, id }, actionContext),
+    );
+
+    return (
+      <Tr key={index}>
+        <Td>
+          <Link to={formatPath(Paths.python.remote.detail, { name })}>
+            {name}
+          </Link>
+        </Td>
+        <Td>
+          <CopyURL url={url} />
+        </Td>
+        <Td>{policy || '---'}</Td>
+        <ListItemActions kebabItems={kebabItems} />
+      </Tr>
+    );
+  },
+  sortHeaders: [
+    {
+      title: msg`Remote name`,
+      type: 'alpha',
+      id: 'name',
+    },
+    {
+      title: msg`URL`,
+      type: 'alpha',
+      id: 'url',
+    },
+    {
+      title: msg`Download policy`,
+      type: 'none',
+      id: 'policy',
+    },
+  ],
+  title: msg`Remotes`,
+});
+
+export default PythonRemoteList;
diff --git a/src/containers/python-remote/tab-details.tsx b/src/containers/python-remote/tab-details.tsx
new file mode 100644
index 00000000..30070133
--- /dev/null
+++ b/src/containers/python-remote/tab-details.tsx
@@ -0,0 +1,97 @@
+import { t } from '@lingui/core/macro';
+import { type PythonRemoteType } from 'src/api';
+import {
+  CopyURL,
+  Details,
+  LazyRepositories,
+  PulpCodeBlock,
+} from 'src/components';
+
+interface TabProps {
+  item: PythonRemoteType;
+  actionContext: object;
+}
+
+const MaybeCode = ({ code, filename }: { code: string; filename: string }) =>
+  code ? <PulpCodeBlock code={code} filename={filename} /> : <>{t`None`}</>;
+
+export const DetailsTab = ({ item }: TabProps) => (
+  <Details
+    fields={[
+      { label: t`Remote name`, value: item?.name },
+      {
+        label: t`URL`,
+        value: <CopyURL url={item?.url} fallback />,
+      },
+      { label: t`Download policy`, value: item?.policy },
+      {
+        label: t`Includes`,
+        value: item?.includes?.length
+          ? item.includes.join(', ')
+          : t`All projects`,
+      },
+      {
+        label: t`Excludes`,
+        value: item?.excludes?.length ? item.excludes.join(', ') : t`None`,
+      },
+      {
+        label: t`Pre-releases`,
+        value: item?.prereleases ? t`Included` : t`Excluded`,
+      },
+      {
+        label: t`Package types`,
+        value: item?.package_types?.length
+          ? item.package_types.join(', ')
+          : t`All`,
+      },
+      {
+        label: t`Latest versions kept per package`,
+        value: item?.keep_latest_packages || t`All`,
+      },
+      {
+        label: t`Excluded platforms`,
+        value: item?.exclude_platforms?.length
+          ? item.exclude_platforms.join(', ')
+          : t`None`,
+      },
+      {
+        label: t`Provenance`,
+        value: item?.provenance ? t`Synced` : t`Not synced`,
+      },
+      {
+        label: t`Proxy URL`,
+        value: <CopyURL url={item?.proxy_url} fallback />,
+      },
+      {
+        label: t`TLS validation`,
+        value: item?.tls_validation ? t`Enabled` : t`Disabled`,
+      },
+      {
+        label: t`Client certificate`,
+        value: (
+          <MaybeCode
+            code={item?.client_cert}
+            filename={item.name + '-client_cert'}
+          />
+        ),
+      },
+      {
+        label: t`CA certificate`,
+        value: (
+          <MaybeCode code={item?.ca_cert} filename={item.name + '-ca_cert'} />
+        ),
+      },
+      {
+        label: t`Download concurrency`,
+        value: item?.download_concurrency ?? t`None`,
+      },
+      { label: t`Rate limit`, value: item?.rate_limit ?? t`None` },
+      {
+        label: t`Repositories`,
+        value: (
+          <LazyRepositories plugin='python' remote_href={item?.pulp_href} />
+        ),
+      },
+    ]}
+  />
+);
diff --git a/src/containers/python-repository/detail.test.tsx b/src/containers/python-repository/detail.test.tsx
new file mode 100644
index 00000000..9be046c1
--- /dev/null
+++ b/src/containers/python-repository/detail.test.tsx
@@ -0,0 +1,158 @@
+import { screen, within } from '@testing-library/react';
+import { HttpResponse, http } from 'msw';
+import { Route, Routes } from 'react-router';
+import { describe, expect, it } from 'vitest';
+import { AppContextProvider } from 'src/app-context';
+import { Paths } from 'src/paths';
+import { distribution, listOf, repository } from 'src/test-utils/pulp';
+import { renderWithProviders } from 'src/test-utils/render';
+import { server } from 'src/test-utils/server';
+import PythonRepositoryDetail from './detail';
+
+const API = '/pulp/api/v3';
+const REPOSITORY_HREF = `${API}/repositories/python/python/00000000-0000-4000-8000-0000000000aa/`;
+const OTHER_REPOSITORY_HREF = `${API}/repositories/python/python/00000000-0000-4000-8000-0000000000bb/`;
+
+const index = repository({
+  name: 'zz-test-python',
+  pulp_href: REPOSITORY_HREF,
+  retain_repo_versions: null,
+  remote: null,
+});
+
+// Every distribution the page reads comes from the Python distribution
+// endpoint, filtered by repository the way the server does.
+function serveDistributions(rows: ReturnType<typeof distribution>[]) {
+  server.use(
+    listOf(`${API}/distributions/python/pypi/`, rows, {
+      matching: (row, query) =>
+        query.has('repository')
+          ? row.repository === query.get('repository')
+          : true,
+    }).handler,
+  );
+}
+
+function serveRepository(row = index) {
+  server.use(
+    listOf(`${API}/repositories/python/python/`, [row], {
+      matching: (r, query) => r.name === query.get('name'),
+    }).handler,
+  );
+}
+
+function renderDetail(tab: 'details' | 'distributions' = 'details') {
+  return renderWithProviders(
+    <AppContextProvider>
+      <Routes>
+        <Route
+          path={Paths.python.repository.detail}
+          element={<PythonRepositoryDetail />}
+        />
+      </Routes>
+    </AppContextProvider>,
+    { route: `/python/repositories/detail/zz-test-python?tab=${tab}` },
+  );
+}
+
+describe('Python repository details', () => {
+  it('shows the base_url the server reports for each distribution, never a URL built from the base path', async () => {
+    serveRepository();
+    serveDistributions([
+      distribution({
+        name: 'zz-first',
+        base_path: 'zz-first',
+        base_url: 'https://pulp.example/mirror-one/zz-first/',
+        repository: REPOSITORY_HREF,
+      }),
+      distribution({
+        name: 'zz-second',
+        base_path: 'zz-second',
+        base_url: 'https://pulp.example/mirror-two/other/',
+        repository: REPOSITORY_HREF,
+      }),
+      distribution({
+        name: 'zz-foreign',
+        base_path: 'zz-foreign',
+        base_url: 'https://pulp.example/foreign/',
+        repository: OTHER_REPOSITORY_HREF,
+      }),
+    ]);
+    renderDetail();
+
+    expect(
+      await screen.findByText('https://pulp.example/mirror-one/zz-first/'),
+    ).toBeInTheDocument();
+    expect(
+      screen.getByText('https://pulp.example/mirror-two/other/'),
+    ).toBeInTheDocument();
+    expect(screen.queryByText('https://pulp.example/foreign/')).toBeNull();
+    expect(screen.queryByText(/\/pulp\/content\/zz-/)).toBeNull();
+    // Python distributions serve the repository directly
+    expect(screen.queryByText(/Not served/)).toBeNull();
+  });
+
+  it('shows why the distributions are missing when they could not be loaded, instead of "None"', async () => {
+    serveRepository();
+    server.use(
+      http.get(`*${API}/distributions/python/pypi/`, () =>
+        HttpResponse.json({ detail: 'broken' }, { status: 500 }),
+      ),
+    );
+    renderDetail();
+
+    expect(
+      await screen.findByText(/Distributions could not be loaded/),
+    ).toBeInTheDocument();
+  });
+});
+
+describe('Python repository Distributions tab', () => {
+  it('lists every distribution bound to the repository with the server URL and a pip line using it', async () => {
+    serveRepository();
+    serveDistributions([
+      distribution({
+        name: 'zz-one',
+        base_path: 'bp-one',
+        base_url: 'https://pulp.example/served/zz-one/',
+        repository: REPOSITORY_HREF,
+      }),
+      distribution({
+        name: 'zz-two',
+        base_path: 'bp-two',
+        base_url: 'https://pulp.example/served/zz-two/',
+        repository: REPOSITORY_HREF,
+      }),
+      distribution({
+        name: 'zz-foreign',
+        base_path: 'zz-foreign',
+        repository: OTHER_REPOSITORY_HREF,
+      }),
+    ]);
+    renderDetail('distributions');
+
+    for (const name of ['zz-one', 'zz-two']) {
+      const row = (await screen.findByText(name)).closest('tr');
+      expect(row).not.toBeNull();
+      const line = within(row as HTMLElement).getByText(/pip install/);
+      expect(line.textContent).toBe(
+        `pip install --index-url https://pulp.example/served/${name}/simple/ <package>`,
+      );
+    }
+    expect(screen.queryByText('zz-foreign')).toBeNull();
+  });
+
+  it('shows the list error when the distributions could not be loaded', async () => {
+    serveRepository();
+    server.use(
+      http.get(`*${API}/distributions/python/pypi/`, () =>
+        HttpResponse.json({ detail: 'broken' }, { status: 500 }),
+      ),
+    );
+    renderDetail('distributions');
+
+    expect(
+      await screen.findByText(/Distributions could not be displayed/),
+    ).toBeInTheDocument();
+  });
+});
diff --git a/src/containers/python-repository/detail.tsx b/src/containers/python-repository/detail.tsx
new file mode 100644
index 00000000..28de76df
--- /dev/null
+++ b/src/containers/python-repository/detail.tsx
@@ -0,0 +1,159 @@
+import { msg, t } from '@lingui/core/macro';
+import { Trans } from '@lingui/react/macro';
+import { pythonRepositoryDeleteAction } from 'src/actions/python-repository-delete';
+import { pythonRepositoryEditAction } from 'src/actions/python-repository-edit';
+import { pythonRepositorySyncAction } from 'src/actions/python-repository-sync';
+import { PythonRemoteAPI, type PythonRemoteType } from 'src/api/python-remote';
+import {
+  PythonRepositoryAPI,
+  type PythonRepositoryType,
+} from 'src/api/python-repository';
+import { PageWithTabs } from 'src/components';
+import { Paths, formatPath } from 'src/paths';
+import { lastSyncStatus, lastSynced } from 'src/utilities/last-sync-task';
+import { parsePulpIDFromURL } from 'src/utilities/parse-pulp-id';
+import {
+  type RepositoryDistribution,
+  distributionsLoadError,
+  repositoryDistributions,
+} from 'src/utilities/repository-distributions';
+import { DetailsTab } from './tab-details';
+import { DistributionsTab } from './tab-distributions';
+import { PackagesTab } from './tab-packages';
+import { RepositoryVersionsTab } from './tab-repository-versions';
+
+const PythonRepositoryDetail = PageWithTabs<
+  PythonRepositoryType & {
+    distributions?: RepositoryDistribution[];
+    distributionsError?: string | null;
+    remote?: PythonRemoteType;
+  }
+>({
+  breadcrumbs: ({ name, tab, params: { repositoryVersion } }) => {
+    const crumbs = [
+      { url: formatPath(Paths.python.repository.list), name: t`Repositories` },
+      { url: formatPath(Paths.python.repository.detail, { name }), name },
+    ];
+
+    if (tab !== 'repository-versions') {
+      return crumbs;
+    }
+
+    // Looking at a single version keeps a link back to the list of them.
+    return repositoryVersion
+      ? [
+          ...crumbs,
+          {
+            url: formatPath(Paths.python.repository.detail, { name }, { tab }),
+            name: t`Versions`,
+          },
+          { name: t`Version ${repositoryVersion}` },
+        ]
+      : [...crumbs, { name: t`Versions` }];
+  },
+  displayName: 'PythonRepositoryDetail',
+  errorTitle: msg`Repository could not be displayed.`,
+  headerActions: [
+    pythonRepositoryEditAction,
+    pythonRepositorySyncAction,
+    pythonRepositoryDeleteAction,
+  ],
+  headerDetails: (item) => (
+    <>
+      {item?.last_sync_task && (
+        <p className='pulp-m-truncated'>
+          <Trans>Last updated from registry {lastSynced(item)}</Trans>{' '}
+          {lastSyncStatus(item)}
+        </p>
+      )}
+    </>
+  ),
+  listUrl: formatPath(Paths.python.repository.list),
+  query: ({ name }) =>
+    PythonRepositoryAPI.list({ name, page_size: 1 })
+      .then(({ data }) => data?.results?.[0])
+      .then((repository) => {
+        // There is no detail endpoint keyed by name, so a name matching nothing
+        // answers 200 with an empty list. Turn that into the 404 the page already
+        // knows how to render, instead of resolving with undefined.
+        if (!repository) {
+          return Promise.reject({ response: { status: 404 } });
+        }
+
+        return Promise.all([
+          // a failed load reaches the page as a visible message, never as an
+          // empty list
+          repositoryDistributions('python', repository.pulp_href).then(
+            (distributions) => ({ distributions, distributionsError: null }),
+            (e) => {
+              console.error(e);
+              return {
+                distributions: [] as RepositoryDistribution[],
+                distributionsError: distributionsLoadError(e),
+              };
+            },
+          ),
+          repository.remote
+            ? PythonRemoteAPI.get(parsePulpIDFromURL(repository.remote))
+                .then(({ data }) => data)
+                .catch(() => null)
+            : null,
+        ]).then(([{ distributions, distributionsError }, remote]) => ({
+          ...repository,
+          distributions,
+          distributionsError,
+          remote,
+        }));
+      }),
+  renderTab: (tab, item, actionContext) =>
+    ({
+      details: <DetailsTab item={item} actionContext={actionContext} />,
+      'repository-versions': (
+        <RepositoryVersionsTab item={item} actionContext={actionContext} />
+      ),
+      distributions: (
+        <DistributionsTab item={item} actionContext={actionContext} />
+      ),
+      packages: <PackagesTab item={item} actionContext={actionContext} />,
+    })[tab],
+  tabs: (tab, name) => [
+    {
+      active: tab === 'details',
+      title: t`Details`,
+      link: formatPath(
+        Paths.python.repository.detail,
+        { name },
+        { tab: 'details' },
+      ),
+    },
+    {
+      active: tab === 'repository-versions',
+      title: t`Versions`,
+      link: formatPath(
+        Paths.python.repository.detail,
+        { name },
+        { tab: 'repository-versions' },
+      ),
+    },
+    {
+      active: tab === 'distributions',
+      title: t`Distributions`,
+      link: formatPath(
+        Paths.python.repository.detail,
+        { name },
+        { tab: 'distributions' },
+      ),
+    },
+    {
+      active: tab === 'packages',
+      title: t`Packages`,
+      link: formatPath(
+        Paths.python.repository.detail,
+        { name },
+        { tab: 'packages' },
+      ),
+    },
+  ],
+});
+
+export default PythonRepositoryDetail;
diff --git a/src/containers/python-repository/edit.test.tsx b/src/containers/python-repository/edit.test.tsx
new file mode 100644
index 00000000..61688721
--- /dev/null
+++ b/src/containers/python-repository/edit.test.tsx
@@ -0,0 +1,332 @@
+import { screen, waitFor } from '@testing-library/react';
+import { HttpResponse, http } from 'msw';
+import { Route, Routes, useLocation } from 'react-router';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { AppContextProvider, useAppContext } from 'src/app-context';
+import { Paths } from 'src/paths';
+import { distribution, listOf, repository } from 'src/test-utils/pulp';
+import { renderWithProviders } from 'src/test-utils/render';
+import { server } from 'src/test-utils/server';
+import PythonRepositoryEdit from './edit';
+
+const API = '/pulp/api/v3';
+const REPOSITORY_HREF = `${API}/repositories/python/python/00000000-0000-4000-8000-0000000000aa/`;
+const TASK_HREF = `${API}/tasks/00000000-0000-4000-8000-0000000000cc/`;
+
+interface Seen {
+  method: string;
+  path: string;
+}
+
+let seen: Seen[];
+let repositoryBodies: Record<string, unknown>[];
+let distributionBodies: Record<string, unknown>[];
+
+const requests = () => seen.map((r) => `${r.method} ${r.path}`);
+const writes = () =>
+  seen.filter((r) => r.method !== 'GET').map((r) => `${r.method} ${r.path}`);
+
+// Records every request the page makes, in order.
+beforeEach(() => {
+  seen = [];
+  repositoryBodies = [];
+  distributionBodies = [];
+  server.events.on('request:start', ({ request }) => {
+    seen.push({ method: request.method, path: new URL(request.url).pathname });
+  });
+});
+
+afterEach(() => {
+  server.events.removeAllListeners();
+});
+
+// Shows where the application ended up after a save and the alerts it raised.
+function Where() {
+  const { pathname } = useLocation();
+  const { alerts } = useAppContext();
+  return (
+    <>
+      <p data-testid='where'>{pathname}</p>
+      <ul>
+        {alerts.map(({ title }, index) => (
+          <li key={index}>{String(title)}</li>
+        ))}
+      </ul>
+    </>
+  );
+}
+
+function renderEdit(route: string) {
+  return renderWithProviders(
+    <AppContextProvider>
+      <Routes>
+        <Route
+          path={Paths.python.repository.edit}
+          element={<PythonRepositoryEdit />}
+        />
+        <Route path={Paths.python.repository.detail} element={<Where />} />
+      </Routes>
+    </AppContextProvider>,
+    { route },
+  );
+}
+
+const nameInput = () => screen.findByRole('textbox', { name: /^Name/ });
+const repositoryVersionsInput = () =>
+  screen.getByRole('spinbutton', { name: /Retained number of versions/ });
+const createDistributionBox = () =>
+  screen.getByRole('checkbox', { name: /Create a distribution/ });
+const save = () => screen.getByRole('button', { name: 'Save' });
+
+function serveRepositoryCreate() {
+  server.use(
+    http.post(`*${API}/repositories/python/python/`, async ({ request }) => {
+      repositoryBodies.push((await request.json()) as Record<string, unknown>);
+      return HttpResponse.json({ pulp_href: REPOSITORY_HREF }, { status: 201 });
+    }),
+  );
+}
+
+function serveDistributionCreate(answer: () => Response) {
+  server.use(
+    http.post(`*${API}/distributions/python/pypi/`, async ({ request }) => {
+      distributionBodies.push(
+        (await request.json()) as Record<string, unknown>,
+      );
+      return answer();
+    }),
+    http.get(`*${API}/tasks/:id/`, () =>
+      HttpResponse.json({ pulp_href: TASK_HREF, state: 'completed' }),
+    ),
+  );
+}
+
+function serveSupportingLists() {
+  server.use(
+    listOf(`${API}/remotes/python/python/`, []).handler,
+    listOf(`${API}/distributions/python/pypi/`, []).handler,
+    // the conflict checks read the generic list of all plugins
+    listOf(`${API}/distributions/`, []).handler,
+    http.get(`*${API}/status/`, () =>
+      HttpResponse.json({
+        content_settings: {
+          content_origin: 'https://pulp.example',
+          content_path_prefix: '/pulp/content/',
+        },
+      }),
+    ),
+  );
+}
+
+describe('creating a Python repository', () => {
+  beforeEach(serveSupportingLists);
+
+  it('keeps all versions and offers the distribution unticked, with no RPM or Ansible only options', async () => {
+    renderEdit('/python/repositories/edit/_');
+
+    await nameInput();
+    expect(repositoryVersionsInput()).toHaveValue(null);
+    expect(createDistributionBox()).not.toBeChecked();
+    expect(screen.queryByRole('checkbox', { name: /Publish new/ })).toBeNull();
+    expect(screen.queryByRole('checkbox', { name: /Make private/ })).toBeNull();
+  });
+
+  it('sends one repository POST with every version kept and no distribution request when the distribution box stays unticked', async () => {
+    serveRepositoryCreate();
+    const { user } = renderEdit('/python/repositories/edit/_');
+
+    await user.type(await nameInput(), 'zz-test-python');
+    await user.click(save());
+
+    await waitFor(() =>
+      expect(screen.getByTestId('where')).toHaveTextContent(
+        '/python/repositories/detail/zz-test-python',
+      ),
+    );
+    expect(repositoryBodies).toHaveLength(1);
+    expect(repositoryBodies[0]).toMatchObject({
+      name: 'zz-test-python',
+      retain_repo_versions: null,
+    });
+    expect(repositoryBodies[0]).not.toHaveProperty('autopublish');
+    expect(repositoryBodies[0]).not.toHaveProperty('private');
+    expect(writes()).toStrictEqual([`POST ${API}/repositories/python/python/`]);
+    // the name and base path are only checked when a distribution is wanted
+    expect(requests()).not.toContain(`GET ${API}/distributions/`);
+  });
+
+  it('sends the package substitution choices the user made', async () => {
+    serveRepositoryCreate();
+    const { user } = renderEdit('/python/repositories/edit/_');
+
+    await user.type(await nameInput(), 'zz-test-python');
+    await user.click(
+      screen.getByRole('checkbox', {
+        name: /Allow same-filename packages with different contents/,
+      }),
+    );
+    await user.click(
+      screen.getByRole('checkbox', {
+        name: /Fail the whole version if any package is rejected/,
+      }),
+    );
+    await user.click(save());
+
+    await waitFor(() =>
+      expect(screen.getByTestId('where')).toBeInTheDocument(),
+    );
+    expect(repositoryBodies[0]).toMatchObject({
+      allow_package_substitution: false,
+      error_on_reject: false,
+    });
+  });
+
+  it('checks the name and base path, then creates the repository, then one distribution with the typed base path', async () => {
+    serveRepositoryCreate();
+    serveDistributionCreate(() =>
+      HttpResponse.json({ task: TASK_HREF }, { status: 202 }),
+    );
+    const { user } = renderEdit('/python/repositories/edit/_');
+
+    await user.type(await nameInput(), 'zz-test-python');
+    await user.click(createDistributionBox());
+    await waitFor(() =>
+      expect(screen.getByRole('textbox', { name: /Base path/ })).toHaveValue(
+        'zz-test-python',
+      ),
+    );
+    await user.click(save());
+
+    await waitFor(() =>
+      expect(screen.getByTestId('where')).toHaveTextContent(
+        '/python/repositories/detail/zz-test-python',
+      ),
+    );
+    expect(distributionBodies).toStrictEqual([
+      {
+        name: 'zz-test-python',
+        base_path: 'zz-test-python',
+        repository: REPOSITORY_HREF,
+      },
+    ]);
+    expect(writes()).toStrictEqual([
+      `POST ${API}/repositories/python/python/`,
+      `POST ${API}/distributions/python/pypi/`,
+    ]);
+    const firstCheck = requests().indexOf(`GET ${API}/distributions/`);
+    expect(firstCheck).toBeGreaterThanOrEqual(0);
+    expect(firstCheck).toBeLessThan(
+      requests().indexOf(`POST ${API}/repositories/python/python/`),
+    );
+  });
+
+  it('reports a refused distribution once, never retries it under another name, and keeps the repository', async () => {
+    serveRepositoryCreate();
+    serveDistributionCreate(() =>
+      HttpResponse.json(
+        { base_path: ['Overlaps with an existing distribution.'] },
+        { status: 400 },
+      ),
+    );
+    const { user } = renderEdit('/python/repositories/edit/_');
+
+    await user.type(await nameInput(), 'zz-test-python');
+    await user.click(createDistributionBox());
+    await user.click(save());
+
+    const where = await screen.findByTestId('where');
+    expect(where).toHaveTextContent(
+      '/python/repositories/detail/zz-test-python',
+    );
+    expect(
+      await screen.findByText(/was not created.*Overlaps with an existing/),
+    ).toBeInTheDocument();
+    expect(distributionBodies).toHaveLength(1);
+    expect(distributionBodies[0]).toMatchObject({ name: 'zz-test-python' });
+    const names = [...repositoryBodies, ...distributionBodies].map(
+      (b) => b['name'],
+    );
+    expect(new Set(names)).toStrictEqual(new Set(['zz-test-python']));
+    expect(writes()).toStrictEqual([
+      `POST ${API}/repositories/python/python/`,
+      `POST ${API}/distributions/python/pypi/`,
+    ]);
+  });
+
+  it('is blocked before any write when a distribution already uses the name', async () => {
+    serveRepositoryCreate();
+    server.use(
+      listOf(
+        `${API}/distributions/`,
+        [distribution({ name: 'zz-test-python', base_path: 'elsewhere' })],
+        {
+          matching: (row, query) =>
+            query.has('name') ? row.name === query.get('name') : false,
+        },
+      ).handler,
+    );
+    const { user } = renderEdit('/python/repositories/edit/_');
+
+    await user.type(await nameInput(), 'zz-test-python');
+    await user.click(createDistributionBox());
+    await user.click(save());
+
+    expect(
+      await screen.findByText(/A distribution named "zz-test-python" already/),
+    ).toBeInTheDocument();
+    expect(writes()).toStrictEqual([]);
+    expect(screen.queryByTestId('where')).toBeNull();
+  });
+});
+
+describe('editing a Python repository', () => {
+  beforeEach(serveSupportingLists);
+
+  it('sends one PUT to the repository and offers no distribution', async () => {
+    const existing = repository({
+      name: 'existing',
+      pulp_href: REPOSITORY_HREF,
+      retain_repo_versions: null,
+      allow_package_substitution: false,
+    });
+    server.use(
+      listOf(`${API}/repositories/python/python/`, [existing], {
+        matching: (row, query) => row.name === query.get('name'),
+      }).handler,
+      http.put(
+        `*${API}/repositories/python/python/:id/`,
+        async ({ request }) => {
+          repositoryBodies.push(
+            (await request.json()) as Record<string, unknown>,
+          );
+          return HttpResponse.json({ task: TASK_HREF }, { status: 202 });
+        },
+      ),
+    );
+    const { user } = renderEdit('/python/repositories/edit/existing');
+
+    await screen.findByDisplayValue('existing');
+    expect(
+      screen.queryByRole('checkbox', { name: /Create a distribution/ }),
+    ).toBeNull();
+    expect(
+      screen.getByRole('checkbox', {
+        name: /Allow same-filename packages with different contents/,
+      }),
+    ).not.toBeChecked();
+    await user.click(save());
+
+    await waitFor(() =>
+      expect(screen.getByTestId('where')).toHaveTextContent(
+        '/python/repositories/detail/existing',
+      ),
+    );
+    expect(writes()).toStrictEqual([
+      `PUT ${API}/repositories/python/python/00000000-0000-4000-8000-0000000000aa/`,
+    ]);
+    expect(repositoryBodies[0]).toMatchObject({
+      allow_package_substitution: false,
+    });
+    expect(screen.queryByText(/Created distribution/)).toBeNull();
+  });
+});
diff --git a/src/containers/python-repository/edit.tsx b/src/containers/python-repository/edit.tsx
new file mode 100644
index 00000000..cd11841c
--- /dev/null
+++ b/src/containers/python-repository/edit.tsx
@@ -0,0 +1,163 @@
+import { msg, t } from '@lingui/core/macro';
+import { PythonDistributionAPI } from 'src/api/python-distribution';
+import {
+  PythonRepositoryAPI,
+  type PythonRepositoryType,
+} from 'src/api/python-repository';
+import { Page, RepositoryForm } from 'src/components';
+import { Paths, formatPath } from 'src/paths';
+import {
+  createRepository,
+  saveErrorMessages,
+} from 'src/utilities/create-repository';
+import { parsePulpIDFromURL } from 'src/utilities/parse-pulp-id';
+import { taskAlert } from 'src/utilities/task-alert';
+
+// retain_repo_versions null keeps every version of a new repository
+const initialRepository: PythonRepositoryType = {
+  name: '',
+  description: '',
+  retain_repo_versions: null,
+  pulp_labels: {},
+  remote: null,
+};
+
+const PythonRepositoryEdit = Page<PythonRepositoryType>({
+  breadcrumbs: ({ name }) =>
+    [
+      { url: formatPath(Paths.python.repository.list), name: t`Repositories` },
+      name && {
+        url: formatPath(Paths.python.repository.detail, { name }),
+        name,
+      },
+      name ? { name: t`Edit` } : { name: t`Add` },
+    ].filter(Boolean),
+
+  displayName: 'PythonRepositoryEdit',
+  errorTitle: msg`Repository could not be displayed.`,
+  listUrl: formatPath(Paths.python.repository.list),
+  query: ({ name }) =>
+    PythonRepositoryAPI.list({ name }).then(
+      ({ data: { results } }) => results[0],
+    ),
+  title: ({ name }) => name || t`Add new repository`,
+  transformParams: ({ name, ...rest }) => ({
+    ...rest,
+    name: name !== '_' ? name : null,
+  }),
+
+  render: (item, { navigate, queueAlert, state, setState }) => {
+    // derived while rendering; the edited copy is stored on the first change
+    const repositoryToEdit = state.repositoryToEdit ?? {
+      ...initialRepository,
+      ...item,
+    };
+    const errorMessages = state.errorMessages ?? {};
+
+    const saveRepository = async ({ distribution }) => {
+      setState({ errorMessages: {} });
+
+      const data = { ...repositoryToEdit };
+
+      // prevent "This field may not be blank." for nullable fields
+      Object.keys(data).forEach((k) => {
+        if (data[k] === '') {
+          data[k] = null;
+        }
+      });
+
+      data.pulp_labels ||= {};
+
+      const goToRepository = () => {
+        setState({ errorMessages: {}, repositoryToEdit: undefined });
+        navigate(
+          formatPath(Paths.python.repository.detail, { name: data.name }),
+        );
+      };
+
+      try {
+        if (item) {
+          // editing never creates a distribution
+          delete data.last_sync_task;
+          delete data.last_synced_metadata_time;
+          delete data.latest_version_href;
+          delete data.pulp_created;
+          delete data.pulp_href;
+          delete data.versions_href;
+
+          const { data: task } = await PythonRepositoryAPI.update(
+            parsePulpIDFromURL(item.pulp_href),
+            data,
+          );
+          // the server answers with the repository itself, not a task, when
+          // the update changes nothing
+          queueAlert(
+            task?.task
+              ? taskAlert(task, t`Update started for repository ${data.name}`)
+              : {
+                  variant: 'success',
+                  title: t`Updated repository ${data.name}`,
+                },
+          );
+          goToRepository();
+          return;
+        }
+
+        const { distributionError } = await createRepository({
+          RepositoryAPI: PythonRepositoryAPI,
+          DistributionAPI: PythonDistributionAPI,
+          data,
+          distribution,
+        });
+
+        if (distributionError) {
+          queueAlert({
+            variant: 'danger',
+            title: t`Repository "${data.name}" was created. The distribution "${data.name}" was not created: ${distributionError}`,
+          });
+        } else {
+          queueAlert({
+            variant: 'success',
+            title: t`Successfully created repository ${data.name}`,
+          });
+          if (distribution) {
+            const { basePath } = distribution;
+            queueAlert({
+              variant: 'success',
+              title: t`Created distribution "${data.name}" at base path ${basePath}.`,
+            });
+          }
+        }
+        goToRepository();
+      } catch (e) {
+        setState({ errorMessages: saveErrorMessages(e) });
+      }
+    };
+
+    const closeModal = () => {
+      setState({ errorMessages: {}, repositoryToEdit: undefined });
+      navigate(
+        item
+          ? formatPath(Paths.python.repository.detail, {
+              name: item.name,
+            })
+          : formatPath(Paths.python.repository.list),
+      );
+    };
+
+    return (
+      <RepositoryForm
+        allowEditName={!item}
+        errorMessages={errorMessages}
+        isNew={!item}
+        onCancel={closeModal}
+        onSave={saveRepository}
+        plugin='python'
+        repository={repositoryToEdit}
+        updateRepository={(r) => setState({ repositoryToEdit: r })}
+      />
+    );
+  },
+});
+
+export default PythonRepositoryEdit;
diff --git a/src/containers/python-repository/list.tsx b/src/containers/python-repository/list.tsx
new file mode 100644
index 00000000..7dc81215
--- /dev/null
+++ b/src/containers/python-repository/list.tsx
@@ -0,0 +1,124 @@
+import { msg, t } from '@lingui/core/macro';
+import { Td, Tr } from '@patternfly/react-table';
+import { Link } from 'react-router';
+import {
+  pythonRepositoryCreateAction,
+  pythonRepositoryDeleteAction,
+  pythonRepositoryEditAction,
+  pythonRepositorySyncAction,
+} from 'src/actions';
+import {
+  PythonRemoteAPI,
+  PythonRepositoryAPI,
+  type PythonRepositoryType,
+} from 'src/api';
+import {
+  DateComponent,
+  ListItemActions,
+  ListPage,
+  PulpLabels,
+} from 'src/components';
+import { Paths, formatPath } from 'src/paths';
+import { parsePulpIDFromURL } from 'src/utilities';
+
+const listItemActions = [
+  // Edit
+  pythonRepositoryEditAction,
+  // Sync
+  pythonRepositorySyncAction,
+  // Delete
+  pythonRepositoryDeleteAction,
+];
+
+const typeaheadQuery = ({ inputText, selectedFilter, setState }) => {
+  if (selectedFilter !== 'remote') {
+    return;
+  }
+
+  return PythonRemoteAPI.list({ name__icontains: inputText })
+    .then(({ data: { results } }) =>
+      results.map(({ name, pulp_href }) => ({ id: pulp_href, title: name })),
+    )
+    .then((remotes) => setState({ remotes }));
+};
+
+const PythonRepositoryList = ListPage<PythonRepositoryType>({
+  defaultPageSize: 10,
+  defaultSort: '-pulp_created',
+  displayName: 'PythonRepositoryList',
+  errorTitle: msg`Repositories could not be displayed.`,
+  filterConfig: ({ state: { remotes } }) => [
+    {
+      id: 'name__icontains',
+      title: t`Repository name`,
+    },
+    {
+      id: 'pulp_label_select',
+      title: t`Pulp Label`,
+    },
+    {
+      id: 'remote',
+      title: t`Remote`,
+      inputType: 'typeahead',
+      options: [
+        {
+          id: 'null',
+          title: t`None`,
+        },
+        ...(remotes || []),
+      ],
+    },
+  ],
+  headerActions: [pythonRepositoryCreateAction], // Add repository
+  listItemActions,
+  noDataButton: pythonRepositoryCreateAction.button,
+  noDataDescription: msg`Repositories will appear once created.`,
+  noDataTitle: msg`No repositories yet`,
+  query: ({ params }) => PythonRepositoryAPI.list(params),
+  typeaheadQuery,
+  renderTableRow(item: PythonRepositoryType, index: number, actionContext) {
+    const { name, pulp_created, pulp_href, pulp_labels } = item;
+    const id = parsePulpIDFromURL(pulp_href);
+
+    const kebabItems = listItemActions.map((action) =>
+      action.dropdownItem({ ...item, id }, actionContext),
+    );
+
+    return (
+      <Tr key={index}>
+        <Td>
+          <Link to={formatPath(Paths.python.repository.detail, { name })}>
+            {name}
+          </Link>
+        </Td>
+        <Td>
+          <PulpLabels labels={pulp_labels} />
+        </Td>
+        <Td>
+          <DateComponent date={pulp_created} />
+        </Td>
+        <ListItemActions kebabItems={kebabItems} />
+      </Tr>
+    );
+  },
+  sortHeaders: [
+    {
+      title: msg`Repository name`,
+      type: 'alpha',
+      id: 'name',
+    },
+    {
+      title: msg`Labels`,
+      type: 'none',
+      id: 'pulp_labels',
+    },
+    {
+      title: msg`Created date`,
+      type: 'numeric',
+      id: 'pulp_created',
+    },
+  ],
+  title: msg`Repositories`,
+});
+
+export default PythonRepositoryList;
diff --git a/src/containers/python-repository/tab-details.tsx b/src/containers/python-repository/tab-details.tsx
new file mode 100644
index 00000000..cef9ed8a
--- /dev/null
+++ b/src/containers/python-repository/tab-details.tsx
@@ -0,0 +1,73 @@
+import { t } from '@lingui/core/macro';
+import { Link } from 'react-router';
+import { type PythonRemoteType } from 'src/api/python-remote';
+import { type PythonRepositoryType } from 'src/api/python-repository';
+import { Details, PulpLabels } from 'src/components';
+import { DistributionURLs } from 'src/components/distribution-url';
+import { Paths, formatPath } from 'src/paths';
+import { type RepositoryDistribution } from 'src/utilities/repository-distributions';
+
+interface TabProps {
+  item: PythonRepositoryType & {
+    distributions?: RepositoryDistribution[];
+    distributionsError?: string | null;
+    remote?: PythonRemoteType;
+  };
+  actionContext: { addAlert: (alert) => void; state: { params } };
+}
+
+export const DetailsTab = ({ item }: TabProps) => {
+  return (
+    <Details
+      fields={[
+        { label: t`Repository name`, value: item?.name },
+        { label: t`Description`, value: item?.description || t`None` },
+        {
+          label: t`Retained version count`,
+          value: item?.retain_repo_versions ?? t`All`,
+        },
+        {
+          label: t`Repository URL`,
+          value: (
+            <DistributionURLs
+              distributions={item?.distributions}
+              error={item?.distributionsError}
+            />
+          ),
+        },
+        {
+          label: t`Labels`,
+          value: <PulpLabels labels={item?.pulp_labels} />,
+        },
+        {
+          label: t`Remote`,
+          value: item?.remote ? (
+            <Link
+              to={formatPath(Paths.python.remote.detail, {
+                name: item.remote.name,
+              })}
+            >
+              {item.remote.name}
+            </Link>
+          ) : (
+            t`None`
+          ),
+        },
+        {
+          label: t`Package substitution`,
+          value:
+            item?.allow_package_substitution === false
+              ? t`Not allowed`
+              : t`Allowed`,
+        },
+        {
+          label: t`When packages are rejected`,
+          value:
+            item?.error_on_reject === false
+              ? t`Skip them`
+              : t`Fail the whole version`,
+        },
+      ]}
+    />
+  );
+};
diff --git a/src/containers/python-repository/tab-distributions.tsx b/src/containers/python-repository/tab-distributions.tsx
new file mode 100644
index 00000000..3c8003d5
--- /dev/null
+++ b/src/containers/python-repository/tab-distributions.tsx
@@ -0,0 +1,128 @@
+import { t } from '@lingui/core/macro';
+import { Td, Tr } from '@patternfly/react-table';
+import { type PythonRepositoryType } from 'src/api/python-repository';
+import { ClipboardCopy, DateComponent, DetailList } from 'src/components';
+import { DistributionURL } from 'src/components/distribution-url';
+import {
+  type RepositoryDistribution,
+  listLoadedDistributions,
+} from 'src/utilities/repository-distributions';
+
+interface TabProps {
+  item: PythonRepositoryType & {
+    distributions?: RepositoryDistribution[];
+    distributionsError?: string | null;
+  };
+  actionContext: {
+    addAlert: (alert) => void;
+    state: { params };
+    hasPermission;
+  };
+}
+
+export const DistributionsTab = ({
+  item,
+  actionContext: { addAlert, hasPermission },
+}: TabProps) => {
+  // The page loaded every distribution serving the repository (bound to it,
+  // to one of its publications or to one of its versions), so the list is cut
+  // from those; a failed load is shown as the list's error.
+  const query = ({ params } = { params: null }) =>
+    item.distributionsError
+      ? Promise.reject(item.distributionsError)
+      : Promise.resolve(listLoadedDistributions(item.distributions, params));
+
+  // pip looks for packages in the simple index under the URL the server
+  // reports for the distribution.
+  const cliConfig = (url: string | null) =>
+    url
+      ? `pip install --index-url ${url.endsWith('/') ? url : `${url}/`}simple/ <package>`
+      : t`None`;
+
+  const renderTableRow = (
+    item: RepositoryDistribution,
+    index: number,
+    _actionContext,
+  ) => {
+    const { name, base_path, pulp_created, url } = item;
+
+    return (
+      <Tr key={index}>
+        <Td>{name}</Td>
+        <Td>{base_path}</Td>
+        <Td>
+          <DistributionURL distribution={item} />
+        </Td>
+        <Td>
+          <DateComponent date={pulp_created} />
+        </Td>
+        <Td>
+          <ClipboardCopy
+            isCode
+            isReadOnly
+            variant={'inline-compact'}
+            key={index}
+          >
+            {cliConfig(url)}
+          </ClipboardCopy>
+        </Td>
+      </Tr>
+    );
+  };
+
+  return (
+    <DetailList<RepositoryDistribution>
+      actionContext={{
+        addAlert,
+        query,
+        hasPermission,
+        hasObjectPermission: (_p: string): boolean => true,
+      }}
+      defaultPageSize={10}
+      defaultSort={'name'}
+      errorTitle={t`Distributions could not be displayed.`}
+      filterConfig={[
+        {
+          id: 'name__icontains',
+          title: t`Name`,
+        },
+        {
+          id: 'base_path__icontains',
+          title: t`Base path`,
+        },
+      ]}
+      noDataDescription={t`Clients cannot download its content until a distribution serves it.`}
+      noDataTitle={t`No distribution serves this repository`}
+      query={query}
+      renderTableRow={renderTableRow}
+      sortHeaders={[
+        {
+          title: t`Name`,
+          type: 'alpha',
+          id: 'name',
+        },
+        {
+          title: t`Base path`,
+          type: 'alpha',
+          id: 'base_path',
+        },
+        {
+          title: t`URL`,
+          type: 'none',
+          id: 'url',
+        },
+        {
+          title: t`Created`,
+          type: 'alpha',
+          id: 'pulp_created',
+        },
+        {
+          title: t`Install with pip`,
+          type: 'none',
+          id: '',
+        },
+      ]}
+      title={t`Distributions`}
+    />
+  );
+};
diff --git a/src/containers/python-repository/tab-packages.tsx b/src/containers/python-repository/tab-packages.tsx
new file mode 100644
index 00000000..030c1d27
--- /dev/null
+++ b/src/containers/python-repository/tab-packages.tsx
@@ -0,0 +1,86 @@
+import { t } from '@lingui/core/macro';
+import { Td, Tr } from '@patternfly/react-table';
+import { PythonPackageAPI, type PythonRepositoryType } from 'src/api';
+import { DetailList } from 'src/components';
+
+interface TabProps {
+  item: PythonRepositoryType;
+  actionContext: {
+    addAlert: (alert) => void;
+    state: { params };
+    hasPermission;
+  };
+}
+
+interface PythonPackage {
+  name: string;
+  version: string;
+  packagetype: string;
+  filename: string;
+  requires_python: string;
+  pulp_href: string;
+}
+
+export const PackagesTab = ({
+  item,
+  actionContext: { addAlert, hasPermission },
+}: TabProps) => {
+  const query = ({ params } = { params: null }) => {
+    // without repository_version, Pulp would list every package on the server
+    if (!item.latest_version_href) {
+      return Promise.resolve({ data: { count: 0, results: [] } });
+    }
+
+    const newParams = { ...params };
+    newParams.ordering = newParams.sort;
+    delete newParams.sort;
+
+    return PythonPackageAPI.list({
+      repository_version: item.latest_version_href,
+      fields: 'name,version,packagetype,filename,requires_python,pulp_href',
+      ...newParams,
+    });
+  };
+
+  // one release usually has several files (an sdist and per-platform wheels);
+  // the filename is what tells them apart
+  const renderTableRow = (
+    pkg: PythonPackage,
+    index: number,
+    _actionContext,
+  ) => (
+    <Tr key={index}>
+      <Td>{pkg.name}</Td>
+      <Td>{pkg.version}</Td>
+      <Td>{pkg.packagetype}</Td>
+      <Td>{pkg.filename}</Td>
+      <Td>{pkg.requires_python || '---'}</Td>
+    </Tr>
+  );
+
+  return (
+    <DetailList<PythonPackage>
+      actionContext={{ addAlert, query, hasPermission }}
+      defaultPageSize={20}
+      defaultSort={'name'}
+      errorTitle={t`Packages could not be displayed.`}
+      filterConfig={[
+        { id: 'name__contains', title: t`Package name` },
+        { id: 'packagetype', title: t`Package type` },
+        { id: 'requires_python__contains', title: t`Requires Python` },
+      ]}
+      noDataDescription={t`Sync this repository or upload packages to it.`}
+      noDataTitle={t`No packages in the latest version`}
+      query={query}
+      renderTableRow={renderTableRow}
+      sortHeaders={[
+        { title: t`Name`, type: 'alpha', id: 'name' },
+        { title: t`Version`, type: 'none', id: 'version' },
+        { title: t`Type`, type: 'none', id: 'packagetype' },
+        { title: t`File`, type: 'none', id: 'filename' },
+        { title: t`Requires Python`, type: 'none', id: 'requires_python' },
+      ]}
+      title={t`Packages`}
+    />
+  );
+};
diff --git a/src/containers/python-repository/tab-repository-versions.tsx b/src/containers/python-repository/tab-repository-versions.tsx
new file mode 100644
index 00000000..a49452cd
--- /dev/null
+++ b/src/containers/python-repository/tab-repository-versions.tsx
@@ -0,0 +1,241 @@
+import { t } from '@lingui/core/macro';
+import { Table, Td, Th, Tr } from '@patternfly/react-table';
+import { useEffect, useState } from 'react';
+import { Link } from 'react-router';
+import { PythonRepositoryAPI } from 'src/api';
+import {
+  DateComponent,
+  DetailList,
+  Details,
+  ListItemActions,
+  Spinner,
+} from 'src/components';
+import { Paths, formatPath } from 'src/paths';
+import { parsePulpIDFromURL } from 'src/utilities';
+
+interface TabProps {
+  item;
+  actionContext: {
+    addAlert: (alert) => void;
+    state: { params };
+    hasPermission: (string) => boolean;
+    hasObjectPermission: (string) => boolean;
+  };
+}
+
+type ContentSummary = Record<
+  string,
+  {
+    count: number;
+    href: string;
+  }
+>;
+
+interface PythonRepositoryVersionType {
+  pulp_href: string;
+  pulp_created: string;
+  number: number;
+  repository: string;
+  base_version: null;
+  content_summary: {
+    added: ContentSummary;
+    removed: ContentSummary;
+    present: ContentSummary;
+  };
+}
+
+const ContentSummary = ({ data }: { data: object }) => {
+  if (!Object.keys(data).length) {
+    return <>{t`None`}</>;
+  }
+
+  return (
+    <Table>
+      <Tr>
+        <Th>{t`Count`}</Th>
+        <Th>{t`Pulp type`}</Th>
+      </Tr>
+      {Object.entries(data).map(([k, v]) => (
+        <Tr key={k}>
+          <Td>{v['count']}</Td>
+          <Th>{k}</Th>
+        </Tr>
+      ))}
+    </Table>
+  );
+};
+
+const BaseVersion = ({
+  repositoryName,
+  data,
+}: {
+  repositoryName: string;
+  data?: string;
+}) => {
+  if (!data) {
+    return <>{t`None`}</>;
+  }
+
+  const number = data.split('/').at(-2);
+  return (
+    <Link
+      to={formatPath(
+        Paths.python.repository.detail,
+        {
+          name: repositoryName,
+        },
+        {
+          repositoryVersion: number,
+          tab: 'repository-versions',
+        },
+      )}
+    >
+      {number}
+    </Link>
+  );
+};
+
+export const RepositoryVersionsTab = ({
+  item,
+  actionContext: { addAlert, state, hasPermission, hasObjectPermission },
+}: TabProps) => {
+  const pulpId = parsePulpIDFromURL(item.pulp_href);
+  const latest_href = item.latest_version_href;
+  const repositoryName = item.name;
+  const queryList = ({ params }) =>
+    PythonRepositoryAPI.listVersions(pulpId, params);
+  const queryDetail = ({ number }) =>
+    PythonRepositoryAPI.listVersions(pulpId, { number });
+  const [modalState, setModalState] = useState({});
+  const [version, setVersion] = useState(null);
+
+  useEffect(() => {
+    if (state.params.repositoryVersion) {
+      queryDetail({ number: state.params.repositoryVersion }).then(
+        ({ data }) => {
+          if (!data?.results?.[0]) {
+            addAlert({
+              variant: 'danger',
+              title: t`Failed to find repository version`,
+            });
+          }
+          setVersion(data.results[0]);
+        },
+      );
+    } else {
+      setVersion(null);
+    }
+  }, [state.params.repositoryVersion]);
+
+  const renderTableRow = (
+    item: PythonRepositoryVersionType,
+    index: number,
+    actionContext,
+    listItemActions,
+  ) => {
+    const { number, pulp_created, pulp_href } = item;
+
+    const isLatest = latest_href === pulp_href;
+
+    const kebabItems = listItemActions.map((action) =>
+      action.dropdownItem({ ...item, isLatest, repositoryName }, actionContext),
+    );
+
+    return (
+      <Tr key={index}>
+        <Td>
+          <Link
+            to={formatPath(
+              Paths.python.repository.detail,
+              {
+                name: repositoryName,
+              },
+              {
+                repositoryVersion: number,
+                tab: 'repository-versions',
+              },
+            )}
+          >
+            {number}
+          </Link>
+          {isLatest ? ' ' + t`(latest)` : null}
+        </Td>
+        <Td>
+          <DateComponent date={pulp_created} />
+        </Td>
+        <ListItemActions kebabItems={kebabItems} />
+      </Tr>
+    );
+  };
+
+  return state.params.repositoryVersion ? (
+    version ? (
+      <Details
+        fields={[
+          { label: t`Version number`, value: version.number },
+          {
+            label: t`Created date`,
+            value: <DateComponent date={version.pulp_created} />,
+          },
+          {
+            label: t`Content added`,
+            value: <ContentSummary data={version.content_summary?.added} />,
+          },
+          {
+            label: t`Content removed`,
+            value: <ContentSummary data={version.content_summary?.removed} />,
+          },
+          {
+            label: t`Current content`,
+            value: <ContentSummary data={version.content_summary?.present} />,
+          },
+          {
+            label: t`Base version`,
+            value: (
+              <BaseVersion
+                repositoryName={repositoryName}
+                data={version.base_version}
+              />
+            ),
+          },
+        ]}
+      />
+    ) : (
+      <Spinner size='md' />
+    )
+  ) : (
+    <DetailList<PythonRepositoryVersionType>
+      actionContext={{
+        addAlert,
+        state: modalState,
+        setState: setModalState,
+        query: queryList,
+        hasPermission,
+        hasObjectPermission, // needs item=repository, not repository version
+      }}
+      defaultPageSize={10}
+      defaultSort={'-pulp_created'}
+      errorTitle={t`Repository versions could not be displayed.`}
+      filterConfig={null}
+      listItemActions={[]}
+      noDataButton={null}
+      noDataDescription={t`Repository versions will appear once the repository is modified.`}
+      noDataTitle={t`No repository versions yet`}
+      query={queryList}
+      renderTableRow={renderTableRow}
+      sortHeaders={[
+        {
+          title: t`Version number`,
+          type: 'numeric',
+          id: 'number',
+        },
+        {
+          title: t`Created date`,
+          type: 'numeric',
+          id: 'pulp_created',
+        },
+      ]}
+      title={t`Repository versions`}
+    />
+  );
+};
diff --git a/src/containers/python/package-list.test.tsx b/src/containers/python/package-list.test.tsx
new file mode 100644
index 00000000..79caaa78
--- /dev/null
+++ b/src/containers/python/package-list.test.tsx
@@ -0,0 +1,85 @@
+import { screen } from '@testing-library/react';
+import { HttpResponse, http } from 'msw';
+import { Route, Routes } from 'react-router';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { AppContextProvider } from 'src/app-context';
+import { Paths } from 'src/paths';
+import { listOf } from 'src/test-utils/pulp';
+import { renderWithProviders } from 'src/test-utils/render';
+import { server } from 'src/test-utils/server';
+import PythonPackageList from './package-list';
+
+const API = '/pulp/api/v3';
+
+let paths: string[];
+
+// Records the path of every request the page makes.
+beforeEach(() => {
+  paths = [];
+  server.events.on('request:start', ({ request }) => {
+    paths.push(new URL(request.url).pathname);
+  });
+});
+
+afterEach(() => {
+  server.events.removeAllListeners();
+});
+
+const packages = (count: number) =>
+  Array.from({ length: count }, (_, i) => ({
+    name: `zz-pkg-${i}`,
+    version: `1.0.${i}`,
+    packagetype: 'sdist',
+    filename: `zz-pkg-${i}-1.0.${i}.tar.gz`,
+    pulp_href: `${API}/content/python/packages/00000000-0000-4000-8000-${String(i).padStart(12, '0')}/`,
+  }));
+
+function renderList() {
+  return renderWithProviders(
+    <AppContextProvider>
+      <Routes>
+        <Route
+          path={Paths.python.package.list}
+          element={<PythonPackageList />}
+        />
+      </Routes>
+    </AppContextProvider>,
+    { route: '/python/packages' },
+  );
+}
+
+describe('Python package list', () => {
+  it.each([0, 1, 10])(
+    'sends no repository request when it shows %i packages',
+    async (count) => {
+      server.use(
+        listOf(`${API}/content/python/packages/`, packages(count)).handler,
+        // any repository lookup would be answered, so a request is visible in
+        // the recorded paths rather than as an unhandled-request error
+        http.get(`*${API}/repositories/python/python/`, () =>
+          HttpResponse.json({
+            count: 0,
+            next: null,
+            previous: null,
+            results: [],
+          }),
+        ),
+      );
+      renderList();
+
+      if (count === 0) {
+        expect(await screen.findByText('No packages yet')).toBeInTheDocument();
+      } else {
+        expect(await screen.findByText('zz-pkg-0')).toBeInTheDocument();
+        expect(
+          screen.getByText(`zz-pkg-${count - 1}-1.0.${count - 1}.tar.gz`),
+        ).toBeInTheDocument();
+      }
+
+      expect(
+        paths.filter((p) => p.includes('/repositories/python/python/')),
+      ).toStrictEqual([]);
+      expect(screen.queryByText('Repository')).toBeNull();
+    },
+  );
+});
diff --git a/src/containers/python/package-list.tsx b/src/containers/python/package-list.tsx
new file mode 100644
index 00000000..edd25130
--- /dev/null
+++ b/src/containers/python/package-list.tsx
@@ -0,0 +1,51 @@
+import { msg, t } from '@lingui/core/macro';
+import { Td, Tr } from '@patternfly/react-table';
+import { PythonPackageAPI } from 'src/api/python-package';
+import { ListPage } from 'src/components';
+
+interface PythonPackage {
+  name: string;
+  version: string;
+  packagetype: string;
+  filename: string;
+  pulp_href: string;
+}
+
+const PythonPackageList = ListPage<PythonPackage>({
+  defaultPageSize: 10,
+  defaultSort: 'name',
+  displayName: 'PythonPackageList',
+  errorTitle: msg`Packages could not be displayed.`,
+  filterConfig: (_) => [
+    { id: 'name__contains', title: t`Package name` },
+    { id: 'packagetype', title: t`Package type` },
+  ],
+  noDataDescription: msg`Packages will appear once a repository is synced or a package is uploaded.`,
+  noDataTitle: msg`No packages yet`,
+  query: ({ params }) =>
+    PythonPackageAPI.list({
+      fields: 'name,version,packagetype,filename,pulp_href',
+      ...params,
+    }),
+  renderTableRow(item: PythonPackage, index: number) {
+    const { name, version, packagetype, filename } = item;
+
+    return (
+      <Tr key={index}>
+        <Td>{name}</Td>
+        <Td>{version}</Td>
+        <Td>{packagetype}</Td>
+        <Td>{filename}</Td>
+      </Tr>
+    );
+  },
+  sortHeaders: [
+    { title: msg`Package name`, type: 'alpha', id: 'name' },
+    { title: msg`Version`, type: 'none', id: 'version' },
+    { title: msg`Type`, type: 'none', id: 'packagetype' },
+    { title: msg`File`, type: 'none', id: 'filename' },
+  ],
+  title: msg`Packages`,
+});
+
+export default PythonPackageList;
diff --git a/src/menu.tsx b/src/menu.tsx
index 36422478..d1b06c9f 100644
--- a/src/menu.tsx
+++ b/src/menu.tsx
@@ -115,6 +115,21 @@ function standaloneMenu() {
         url: formatPath(Paths.file.remote.list),
       }),
     ]),
+    menuSection(
+      'Pulp Python',
+      { condition: and(loggedIn, hasPlugin('python')) },
+      [
+        menuItem(t`Repositories`, {
+          url: formatPath(Paths.python.repository.list),
+        }),
+        menuItem(t`Remotes`, {
+          url: formatPath(Paths.python.remote.list),
+        }),
+        menuItem(t`Packages`, {
+          url: formatPath(Paths.python.package.list),
+        }),
+      ],
+    ),
     menuSection('Pulp RPM', { condition: and(loggedIn, hasPlugin('rpm')) }, [
       menuItem(t`Repositories`, {
         url: formatPath(Paths.rpm.repository.list),
diff --git a/src/paths.ts b/src/paths.ts
index 23437e74..93304da1 100644
--- a/src/paths.ts
+++ b/src/paths.ts
@@ -151,6 +151,19 @@ export const Paths = {
     login: '/login',
     search: '/search',
   },
+  python: {
+    remote: {
+      detail: '/python/remotes/detail/:name',
+      edit: '/python/remotes/edit/:name',
+      list: '/python/remotes',
+    },
+    repository: {
+      detail: '/python/repositories/detail/:name',
+      edit: '/python/repositories/edit/:name',
+      list: '/python/repositories',
+    },
+    package: { list: '/python/packages' },
+  },
   rpm: {
     remote: {
       detail: '/rpm/remotes/detail/:name',
diff --git a/src/test-utils/pulp.test.ts b/src/test-utils/pulp.test.ts
index 3022cd11..47b1a087 100644
--- a/src/test-utils/pulp.test.ts
+++ b/src/test-utils/pulp.test.ts
@@ -1,5 +1,12 @@
 import { describe, expect, it } from 'vitest';
-import { distribution, listOf, page, publication, repository } from './pulp';
+import {
+  distribution,
+  listOf,
+  page,
+  publication,
+  remote,
+  repository,
+} from './pulp';
 import { server } from './server';
 
 const REPOSITORIES = '/pulp/api/v3/repositories/file/file/';
@@ -111,4 +118,13 @@ describe('builders', () => {
     expect(first.repository_version).toBe('/v/1/');
     expect(first.pulp_href).not.toBe(second.pulp_href);
   });
+
+  it('remote carries its url and policy and takes overrides', () => {
+    const built = remote({ name: 'index', policy: 'streamed' });
+
+    expect(built.name).toBe('index');
+    expect(built.policy).toBe('streamed');
+    expect(built.url).toBe('https://pulp.example/index/');
+    expect(built.pulp_href).toMatch(/^\/pulp\/api\/v3\/remotes\//);
+  });
 });
diff --git a/src/test-utils/pulp.ts b/src/test-utils/pulp.ts
index 5b3f718c..a0e3f630 100644
--- a/src/test-utils/pulp.ts
+++ b/src/test-utils/pulp.ts
@@ -159,3 +159,38 @@ export function publication(
     ...overrides,
   };
 }
+
+export interface IRemote {
+  pulp_href: string;
+  name: string;
+  url: string;
+  policy: string;
+  pulp_created: string;
+  [field: string]: unknown;
+}
+
+// A remote as the server returns it: the secret fields are not carried, only
+// listed under hidden_fields with whether a value is set.
+export function remote(overrides: Partial<IRemote> = {}): IRemote {
+  return {
+    pulp_href: href('remotes/file/file'),
+    name: `remote-${sequence}`,
+    url: 'https://pulp.example/index/',
+    policy: 'immediate',
+    pulp_created: '2000-01-01T00:00:00.000000Z',
+    tls_validation: true,
+    ca_cert: null,
+    client_cert: null,
+    proxy_url: null,
+    download_concurrency: null,
+    rate_limit: null,
+    hidden_fields: [
+      'client_key',
+      'proxy_username',
+      'proxy_password',
+      'username',
+      'password',
+    ].map((field) => ({ name: field, is_set: false })),
+    ...overrides,
+  };
+}
diff --git a/src/utilities/distribution-serving.test.ts b/src/utilities/distribution-serving.test.ts
index 733c48a0..5f20c729 100644
--- a/src/utilities/distribution-serving.test.ts
+++ b/src/utilities/distribution-serving.test.ts
@@ -12,6 +12,7 @@ describe('SERVES_FROM_PUBLICATION', () => {
       ansible: false,
       deb: true,
       file: true,
+      python: false,
       rpm: true,
     });
   });
diff --git a/src/utilities/distribution-serving.ts b/src/utilities/distribution-serving.ts
index d260137c..c84ada10 100644
--- a/src/utilities/distribution-serving.ts
+++ b/src/utilities/distribution-serving.ts
@@ -6,14 +6,15 @@
 export type ServedState = 'served' | 'not-served';
 
 // Whether a plugin's distributions need a publication to serve content.
-// Ansible serves from the repository version directly.
+// Ansible and Python serve from the repository version directly.
 export const SERVES_FROM_PUBLICATION: Record<
-  'ansible' | 'deb' | 'file' | 'rpm',
+  'ansible' | 'deb' | 'file' | 'python' | 'rpm',
   boolean
 > = {
   ansible: false,
   deb: true,
   file: true,
+  python: false,
   rpm: true,
 };
 
diff --git a/src/utilities/plugin-repository-base-path.ts b/src/utilities/plugin-repository-base-path.ts
index 798d62c6..45e91cd9 100644
--- a/src/utilities/plugin-repository-base-path.ts
+++ b/src/utilities/plugin-repository-base-path.ts
@@ -8,6 +8,9 @@ import { DebRepositoryAPI } from '../api/deb-repository';
 import { FileDistributionAPI } from '../api/file-distribution';
 import { FileRemoteAPI } from '../api/file-remote';
 import { FileRepositoryAPI } from '../api/file-repository';
+import { PythonDistributionAPI } from '../api/python-distribution';
+import { PythonRemoteAPI } from '../api/python-remote';
+import { PythonRepositoryAPI } from '../api/python-repository';
 import { RPMDistributionAPI } from '../api/rpm-distribution';
 import { RPMRemoteAPI } from '../api/rpm-remote';
 import { RPMRepositoryAPI } from '../api/rpm-repository';
@@ -38,6 +41,12 @@ export function plugin2api(plugin) {
         RemoteAPI: FileRemoteAPI,
         RepositoryAPI: FileRepositoryAPI,
       };
+    case 'python':
+      return {
+        DistributionAPI: PythonDistributionAPI,
+        RemoteAPI: PythonRemoteAPI,
+        RepositoryAPI: PythonRepositoryAPI,
+      };
     case 'rpm':
       return {
         DistributionAPI: RPMDistributionAPI,
diff --git a/src/utilities/repository-distributions.test.ts b/src/utilities/repository-distributions.test.ts
index bc980b0e..1e4b1b6c 100644
--- a/src/utilities/repository-distributions.test.ts
+++ b/src/utilities/repository-distributions.test.ts
@@ -283,4 +283,38 @@ describe('repositoryDistributions', () => {
       expect(found[0].served).toBe(false);
     });
   });
+
+  describe('python', () => {
+    it('lists the distributions of the python endpoint and treats a repository-bound one as served without any publication', async () => {
+      const repo = repository();
+      const python = listOf(
+        '/pulp/api/v3/distributions/python/pypi/',
+        [
+          distribution({
+            base_path: 'index',
+            base_url: 'https://pulp.example/pypi/index/',
+            repository: repo.pulp_href,
+          }),
+        ],
+        {
+          pageSize: 1000,
+          matching: (row, query) =>
+            query.has('repository') ? ofRepository(row, query) : true,
+        },
+      );
+      server.use(python.handler);
+
+      const found = await repositoryDistributions('python', repo.pulp_href);
+
+      expect(
+        found.map(({ name, url, served }) => ({ name, url, served })),
+      ).toStrictEqual([
+        {
+          name: 'index',
+          url: 'https://pulp.example/pypi/index/',
+          served: true,
+        },
+      ]);
+    });
+  });
 });
diff --git a/src/utilities/repository-distributions.ts b/src/utilities/repository-distributions.ts
index f86e4539..ea865678 100644
--- a/src/utilities/repository-distributions.ts
+++ b/src/utilities/repository-distributions.ts
@@ -16,7 +16,8 @@ import { plugin2api } from './plugin-repository-base-path';
 // Every distribution that serves a repository, with the URL the server
 // reports for it and whether the content app answers with content.
 
-export type RepositoryDistributionPlugin = 'ansible' | 'deb' | 'file' | 'rpm';
+export type RepositoryDistributionPlugin =
+  'ansible' | 'deb' | 'file' | 'python' | 'rpm';
 
 export interface RepositoryDistribution {
   pulp_href: string;
@@ -53,7 +54,8 @@ interface PublicationRecord {
 const PAGE_SIZE = 500;
 
 // Publication endpoints per plugin. A deb distribution may serve either kind
-// of publication. Ansible serves without publications.
+// of publication. Ansible and Python serve the repository directly, so they
+// have no publication endpoint to scan.
 const PUBLICATION_APIS: Record<
   RepositoryDistributionPlugin,
   {
@@ -65,6 +67,7 @@ const PUBLICATION_APIS: Record<
   ansible: [],
   deb: [DebPublicationAPI, DebVerbatimPublicationAPI],
   file: [FilePublicationAPI],
+  python: [],
   rpm: [RPMPublicationAPI],
 };